datasource

type Argument interface {
	ArgName() []byte
}

type BasePlanner struct {
	Log                   abstractlogger.Logger
	Walker                *astvisitor.Walker   // nolint
	Definition, Operation *ast.Document        // nolint
	Args                  []Argument           // nolint
	RootField             rootField            // nolint
	Config                PlannerConfiguration // nolint
}

type ContextVariableArgument struct {
	Name         []byte
	VariableName []byte
}

type CorePlanner interface {
	// Plan plan returns the pre configured DataSource as well as the Arguments
	// During runtime the arguments get resolved and passed to the DataSource
	Plan(args []Argument) (DataSource, []Argument)
	// Configure is the function to initialize all important values for the Planner to function correctly
	// You probably need access to the Walker, Operation and ObjectDefinition to use the Planner to its full power
	// Walker gives you useful information from within all visitor Callbacks, e.g. the Path & Ancestors
	// Operation is the AST of the GraphQL Operation
	// ObjectDefinition is the AST of the GraphQL schema ObjectDefinition
	// Args are the pre-calculated Arguments from the planner
	// resolverParameters are the parameters from the @directive params field
	Configure(operation, definition *ast.Document, walker *astvisitor.Walker)
}

type DataSource interface {
	Resolve(ctx context.Context, args ResolverArgs, out io.Writer) (n int, err error)
}

type GraphQLDataSource struct {
	Log                log.Logger
	Client             *http.Client
	WhitelistedSchemes []string
	Hooks              Hooks
}

type GraphQLDataSourceConfig struct {
	// URL is the url of the upstream
	URL string `bson:"url" json:"url"`
	// Method is the http.Method of the upstream, defaults to POST (optional)
	Method *string `bson:"method" json:"method"`
}

type GraphQLDataSourcePlanner struct {
	BasePlanner
	// contains filtered or unexported fields
}

type GraphQLDataSourcePlannerFactory struct {
	// contains filtered or unexported fields
}

type GraphQLDataSourcePlannerFactoryFactory struct {
	Client             *http.Client
	WhitelistedSchemes []string
	Hooks              Hooks
}

type GraphqlRequest struct {
	OperationName string          `json:"operationName"`
	Variables     json.RawMessage `json:"variables"`
	Query         string          `json:"query"`
}

type HookContext struct {
	TypeName  string
	FieldName string
}

type Hooks struct {
	PreSendHttpHook     PreSendHttpHook
	PostReceiveHttpHook PostReceiveHttpHook
}

type HttpJsonDataSource struct {
	Log                log.Logger
	Client             *http.Client
	WhitelistedSchemes []string
	Hooks              Hooks
}

type HttpJsonDataSourceConfig struct {
	// URL is the url of the upstream
	URL string `bson:"url" json:"url"`
	// Method is the http.Method, e.g. GET, POST, UPDATE, DELETE
	// default is GET
	Method *string `bson:"method" json:"method"`
	// Body is the http body to send
	// default is null/nil (no body)
	Body *string `bson:"body" json:"body"`
	// Headers defines the header mappings
	Headers []HttpJsonDataSourceConfigHeader `bson:"headers" json:"headers"`
	// DefaultTypeName is the optional variable to define a default type name for the response object
	// This is useful in case the response might be a Union or Interface type which uses StatusCodeTypeNameMappings
	DefaultTypeName *string `bson:"default_type_name" json:"default_type_name"`
	// StatusCodeTypeNameMappings is a slice of mappings from http.StatusCode to GraphQL TypeName
	// This can be used when the TypeName depends on the http.StatusCode
	StatusCodeTypeNameMappings []StatusCodeTypeNameMapping `bson:"status_code_type_name_mappings" json:"status_code_type_name_mappings"`
}

type HttpJsonDataSourceConfigHeader struct {
	Key   string `bson:"key" json:"key"`
	Value string `bson:"value" json:"value"`
}

type HttpJsonDataSourcePlanner struct {
	BasePlanner
	// contains filtered or unexported fields
}

type HttpJsonDataSourcePlannerFactory struct {
	// contains filtered or unexported fields
}

type HttpJsonDataSourcePlannerFactoryFactory struct {
	Client             *http.Client
	WhitelistedSchemes []string
	Hooks              Hooks
}

type HttpPollingStreamDataSource struct {
	Log log.Logger

	Delay time.Duration
	// contains filtered or unexported fields
}

type HttpPollingStreamDataSourceConfiguration struct {
	Host         string
	URL          string
	DelaySeconds *int
}

type HttpPollingStreamDataSourcePlanner struct {
	BasePlanner
	// contains filtered or unexported fields
}

type HttpPollingStreamDataSourcePlannerFactory struct {
	// contains filtered or unexported fields
}

type HttpPollingStreamDataSourcePlannerFactoryFactory struct {
}

type ListArgument struct {
	Name      []byte
	Arguments []Argument
}

type MQTTDataSource struct {
	// contains filtered or unexported fields
}

type MQTTDataSourceConfig struct {
	BrokerAddr string
	ClientID   string
	Topic      string
}

type MQTTDataSourcePlanner struct {
	BasePlanner
	// contains filtered or unexported fields
}

type MQTTDataSourcePlannerFactory struct {
	// contains filtered or unexported fields
}

type MQTTDataSourcePlannerFactoryFactory struct {
}

type MappingConfiguration struct {
	Disabled bool   `bson:"disabled" json:"disabled"`
	Path     string `bson:"path" json:"path"`
}

type NatsDataSource struct {
	// contains filtered or unexported fields
}

type NatsDataSourceConfig struct {
	Addr  string
	Topic string
}

type NatsDataSourcePlanner struct {
	BasePlanner
	// contains filtered or unexported fields
}

type NatsDataSourcePlannerFactory struct {
	// contains filtered or unexported fields
}

type NatsDataSourcePlannerFactoryFactory struct {
}

type ObjectVariableArgument struct {
	Name         []byte
	PathSelector PathSelector
}

type PathSelector struct {
	Path string
}

type PipelineDataSource struct {
	Log      log.Logger
	Pipeline pipe.Pipeline
}

type PipelineDataSourceConfig struct {
	/*
		ConfigFilePath is the path where the Pipeline configuration file can be found
		it needs to be in the json format according to the Pipeline json schema
		see this url for more info: https://github.com/jensneuse/pipeline
	*/
	ConfigFilePath *string
	/*
			ConfigString is a string to configure the Pipeline
			it needs to be in the json format according to the Pipeline json schema
		   	see this url for more info: https://github.com/jensneuse/pipeline
			The PipelinDataSourcePlanner will always choose the configString over the configFilePath in case both are defined.
	*/
	ConfigString *string
	// InputJSON is the template to define a JSON object based on the request, parameters etc. which gets passed to the first Pipeline step
	InputJSON string
}

type PipelineDataSourcePlanner struct {
	BasePlanner
	// contains filtered or unexported fields
}

type PipelineDataSourcePlannerFactory struct {
	// contains filtered or unexported fields
}

type PipelineDataSourcePlannerFactoryFactory struct {
}

type Planner interface {
	CorePlanner
	PlannerVisitors
}

type PlannerConfiguration struct {
	TypeFieldConfigurations []TypeFieldConfiguration
}

type PlannerFactory interface {
	DataSourcePlanner() Planner
}

type PlannerFactoryFactory interface {
	Initialize(base BasePlanner, configReader io.Reader) (PlannerFactory, error)
}

type PlannerVisitors interface {
	astvisitor.EnterDocumentVisitor
	astvisitor.EnterInlineFragmentVisitor
	astvisitor.LeaveInlineFragmentVisitor
	astvisitor.EnterSelectionSetVisitor
	astvisitor.LeaveSelectionSetVisitor
	astvisitor.EnterFieldVisitor
	astvisitor.EnterArgumentVisitor
	astvisitor.LeaveFieldVisitor
}

type PostReceiveHttpHook interface {
	Execute(ctx HookContext, resp *http.Response, body []byte)
}

type PreSendHttpHook interface {
	Execute(ctx HookContext, req *http.Request)
}

type ResolverArgs interface {
	ByKey(key []byte) []byte
	Dump() []string
	Keys() [][]byte
}

type SchemaDataSource struct {
	SchemaBytes []byte
}

type SchemaDataSourcePlanner struct {
	BasePlanner
	// contains filtered or unexported fields
}

type SchemaDataSourcePlannerConfig struct {
}

type SchemaDataSourcePlannerFactory struct {
	// contains filtered or unexported fields
}

type SchemaDataSourcePlannerFactoryFactory struct {
}

type SourceConfig struct {
	// Kind defines the unique identifier of the DataSource
	// Kind needs to match to the Planner "DataSourceName" name
	Name string `bson:"kind" json:"kind"`
	// Config is the DataSource specific configuration object
	// Each Planner needs to make sure to parse their Config Object correctly
	Config json.RawMessage `bson:"data_source_config" json:"data_source_config"`
}

type StaticDataSource struct {
	Data []byte
}

type StaticDataSourceConfig struct {
	Data string
}

type StaticDataSourcePlanner struct {
	BasePlanner
	// contains filtered or unexported fields
}

type StaticDataSourcePlannerFactory struct {
	// contains filtered or unexported fields
}

type StaticDataSourcePlannerFactoryFactory struct {
}

type StaticVariableArgument struct {
	Name  []byte
	Value []byte
}

type StatusCodeTypeNameMapping struct {
	StatusCode int    `bson:"status_code" json:"status_code"`
	TypeName   string `bson:"type_name" json:"type_name"`
}

type TypeDataSource struct {
}

type TypeDataSourcePlanner struct {
	BasePlanner
	// contains filtered or unexported fields
}

type TypeDataSourcePlannerConfig struct {
}

type TypeDataSourcePlannerFactory struct {
	// contains filtered or unexported fields
}

type TypeDataSourcePlannerFactoryFactory struct {
}

type TypeFieldConfiguration struct {
	TypeName                 string                `bson:"type_name" json:"type_name"`
	FieldName                string                `bson:"field_name" json:"field_name"`
	Mapping                  *MappingConfiguration `bson:"mapping" json:"mapping"`
	DataSource               SourceConfig          `bson:"data_source" json:"data_source"`
	DataSourcePlannerFactory PlannerFactory        `bson:"-" json:"-"`
}