plan

type AbstractFieldPathCollector struct {
	*astvisitor.Walker
	// contains filtered or unexported fields
}

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

type ArgumentConfiguration struct {
	Name         string
	SourceType   SourceType
	SourcePath   []string
	RenderConfig ArgumentRenderConfig
	RenameTypeTo string
}

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

type ArgumentRenderConfig string

type ArgumentsConfigurations []ArgumentConfiguration

type Configuration struct {
	Logger                             abstractlogger.Logger
	DefaultFlushIntervalMillis         int64
	DataSources                        []DataSource
	MaxDataSourceCollectorsConcurrency uint
	Fields                             FieldConfigurations
	Types                              TypeConfigurations
	EntityInterfaceNames               []string
	// DisableResolveFieldPositions should be set to true for testing purposes
	// This setting removes position information from all fields
	// In production, this should be set to false so that error messages are easier to understand
	DisableResolveFieldPositions bool
	// EnableOperationNamePropagation appends the operation name from nested operations
	EnableOperationNamePropagation bool
	CustomResolveMap               map[string]resolve.CustomResolve

	// Debug - configure debug options
	Debug DebugConfiguration

	MinifySubgraphOperations bool

	// DisableIncludeInfo controls whether the planner generates resolve.FieldInfo (useful in tests).
	DisableIncludeInfo bool

	// DisableIncludeFieldDependencies controls whether the planner generates
	// field dependency structures.
	// It requires DisableIncludeInfo set to false.
	DisableIncludeFieldDependencies bool

	// BuildFetchReasons allows generating the FetchReasons structure for all the fields.
	// It may be enabled by some other components of the engine.
	// It requires DisableIncludeInfo and DisableIncludeFieldDependencies set to false.
	BuildFetchReasons bool

	// ValidateRequiredExternalFields validates nullable external "@requires" dependencies.
	// When a subgraph entity fetch returns a null value with an error for a field set specified in
	// the "@requires" directive, any following fetch that depends on it should not receive such an
	// entity.
	// This option requires BuildFetchReasons set to true.
	ValidateRequiredExternalFields bool

	// ComputeStaticCost enables static cost computation for operations.
	ComputeStaticCost bool

	// When the list size is unknown from directives, this value is used as a default for static cost.
	StaticCostDefaultListSize int
}

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

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

type DSHash uint64

type DSKeyInfo struct {
	DSHash   DSHash
	TypeName string
	Path     string
	Keys     []KeyInfo
}

type DSSkip struct {
	DSHash DSHash
	// contains filtered or unexported fields
}

type DataSource interface {
	FederationInfo
	NodesInfo
	DirectivesConfigurations

	UpstreamSchema() (*ast.Document, bool)
	PlanningBehavior() DataSourcePlanningBehavior

	Id() string
	Name() string
	Hash() DSHash
	FederationConfiguration() FederationMetaData
	CreatePlannerConfiguration(logger abstractlogger.Logger, fetchConfig *objectFetchConfiguration, pathConfig *plannerPathsConfiguration, configuration *Configuration) PlannerConfiguration

	// GetCostConfig returns the IBM static cost configuration for this data source
	GetCostConfig() *DataSourceCostConfig
}

type DataSourceBehavior interface {
	// DownstreamResponseFieldAlias allows the DataSourcePlanner to overwrite the response path with an alias.
	// It requires DataSourcePlanningBehavior.OverrideFieldPathFromAlias to be set to true.
	// This function is useful in the following scenarios:
	// 1. The downstream Query doesn't contain an alias,
	// 2. The path configuration rewrites the field to an existing field,
	// 3. The DataSourcePlanner using an alias to the upstream.
	//
	// Example:
	//
	// type Query {
	//		country: Country
	//		countryAlias: Country
	// }
	//
	// Both, country and countryAlias have a path in the FieldConfiguration of "country"
	// In theory, they would be treated as the same field
	// However, by using DownstreamResponseFieldAlias, it's possible for the DataSourcePlanner to use an alias for countryAlias.
	// In this case, the response would contain both, country and countryAlias fields in the response.
	// At the same time, the downstream Query would only expect the response on the path "country",
	// as both country and countryAlias have a mapping to the path "country".
	// The DataSourcePlanner could keep track that it rewrites the upstream query and use DownstreamResponseFieldAlias
	// to indicate to the Planner to expect the response for countryAlias on the path "countryAlias" instead of "country".
	DownstreamResponseFieldAlias(downstreamFieldRef int) (alias string, exists bool)
}

type DataSourceConfiguration[T any] interface {
	DataSource
	CustomConfiguration() T
}

type DataSourceCostConfig struct {
	// Weights maps field coordinate to its weights. Cannot be on fields of interfaces.
	// Location: FIELD_DEFINITION, INPUT_FIELD_DEFINITION
	Weights map[FieldCoordinate]*FieldWeight

	// ListSizes maps field coordinates to their respective list size configurations.
	// Location: FIELD_DEFINITION
	ListSizes map[FieldCoordinate]*FieldListSize

	// Types maps TypeName to the weight of the object, scalar or enum definition.
	// If TypeName is not present, the default value for Enums and Scalars is 0, otherwise 1.
	// Weight assigned to the field or argument definitions overrides the weight of type definition.
	// Location: ENUM, OBJECT, SCALAR
	Types map[string]int
}

type DataSourceDebugger interface {
	astvisitor.VisitorIdentifier
	DebugPrint(args ...interface{})
	EnableDebug()
	EnableDebugQueryPlanLogging()
}

type DataSourceFetchPlanner interface {
	ConfigureFetch() resolve.FetchConfiguration
	ConfigureSubscription() SubscriptionConfiguration
}

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

type DataSourceJumpsGraph struct {
	Jumps map[DSHash][]KeyJump
	Cache map[JumpCacheKey][]SourceConnection
}

type DataSourceMetadata struct {
	// FederationMetaData has federation-specific configuration for entity interfaces and
	// the @key, @requires, @provides directives.
	FederationMetaData

	// RootNodes defines the nodes where the responsibility of the DataSource begins.
	// RootNode is a node from which we could start a query or a subquery.
	// For a federation, RootNodes contain root query type fields, entity type fields,
	// and entity object fields.
	RootNodes TypeFields

	// ChildNodes describes additional fields, which are requested along with fields that the datasource has.
	// They're always required for Graphql datasources because each field could have its own datasource.
	// For a flat datasource (HTTP/REST or GRPC) we cannot request fewer fields, as we always get a full response.
	// For a federation, ChildNodes contain non-entity type fields and interface type fields.
	// Unions shouldn't be present in the child or root nodes.
	ChildNodes TypeFields

	Directives *DirectiveConfigurations

	// CostConfig holds IBM static cost configuration for this data source
	CostConfig *DataSourceCostConfig
	// contains filtered or unexported fields
}

type DataSourcePlanner[T any] interface {
	DataSourceFetchPlanner
	DataSourceBehavior
	Identifyable
	Register(visitor *Visitor, configuration DataSourceConfiguration[T], dataSourcePlannerConfiguration DataSourcePlannerConfiguration) error
}

type DataSourcePlannerConfiguration struct {
	RequiredFields FederationFieldConfigurations
	ParentPath     string
	PathType       PlannerPathType
	IsNested       bool
	Options        plannerConfigurationOptions
	FetchID        int
}

type DataSourcePlanningBehavior struct {
	// MergeAliasedRootNodes set to true will reuse a data source for multiple root fields with aliases.
	// Example:
	//  {
	//    rootField
	//    alias: rootField
	//  }
	// On dynamic data sources (GraphQL, SQL) this should be set to true,
	// and for static data sources (REST, static, gRPC) it should be false.
	MergeAliasedRootNodes bool

	// OverrideFieldPathFromAlias set to true will let the planner know
	// if the response path should also be aliased.
	//
	// Example:
	//  {
	//    rootField
	//    alias: original
	//  }
	// When true expected response will be { "rootField": ..., "alias": ... }
	// When false expected response will be { "rootField": ..., "original": ... }
	OverrideFieldPathFromAlias bool

	// AllowPlanningTypeName set to true will allow the planner to plan __typename fields.
	AllowPlanningTypeName bool

	// If true then planner will rewrite the operation
	// to flatten inline fragments to only the concrete types.
	AlwaysFlattenFragments bool
}

type DebugConfiguration struct {
	PrintOperationTransformations bool
	PrintOperationEnableASTRefs   bool
	PrintPlanningPaths            bool
	PrintQueryPlans               bool

	PrintNodeSuggestions                  bool
	PrintNodeSuggestionsFilterNotSelected bool

	NodeSelectionVisitor bool
	ConfigurationVisitor bool
	PlanningVisitor      bool
	DatasourceVisitor    bool
}

type DirectiveConfiguration struct {
	DirectiveName string
	RenameTo      string
}

type DirectiveConfigurations []DirectiveConfiguration

type DirectivesConfigurations interface {
	DirectiveConfigurations() *DirectiveConfigurations
}

type EntityInterfaceConfiguration struct {
	InterfaceTypeName string
	ConcreteTypeNames []string
}

type FailedToCreatePlanningPathsError struct {
	MissingPaths                 []string
	HasFieldWaitingForDependency bool
}

type FederationFieldConfiguration struct {
	TypeName              string         `json:"type_name"`            // TypeName is the name of the Entity the Fragment is for
	FieldName             string         `json:"field_name,omitempty"` // FieldName is empty for key requirements, otherwise, it is the name of the field that has requires or provides directive
	SelectionSet          string         `json:"selection_set"`        // SelectionSet is the selection set that is required for the given field (keys, requires, provides)
	DisableEntityResolver bool           `json:"-"`                    // applicable only for the keys. If true it means that the given entity could not be resolved by this key.
	Conditions            []KeyCondition `json:"conditions,omitempty"` // conditions stores coordinates under which we could use implicit key, while on other paths this key is not available

	RemappedPaths map[string]string
	// contains filtered or unexported fields
}

type FederationFieldConfigurations []FederationFieldConfiguration

type FederationInfo interface {
	HasKeyRequirement(typeName, requiresFields string) bool
	RequiredFieldsByKey(typeName string) []FederationFieldConfiguration
	RequiredFieldsByRequires(typeName, fieldName string) (cfg FederationFieldConfiguration, exists bool)
	HasEntity(typeName string) bool
	HasInterfaceObject(typeName string) bool
	HasEntityInterface(typeName string) bool
	EntityInterfaceNames() []string
}

type FederationMetaData struct {
	Keys             FederationFieldConfigurations
	Requires         FederationFieldConfigurations
	Provides         FederationFieldConfigurations
	EntityInterfaces []EntityInterfaceConfiguration
	InterfaceObjects []EntityInterfaceConfiguration
	// contains filtered or unexported fields
}

type FieldConfiguration struct {
	TypeName  string
	FieldName string
	// DisableDefaultMapping - instructs planner whether to use path mapping coming from Path field
	DisableDefaultMapping bool // TODO: has no effect as of now, remove?
	// Path - represents a json path to lookup for a field value in response json
	Path      []string
	Arguments ArgumentsConfigurations
	// UnescapeResponseJson set to true will allow fields (String,List,Object)
	// to be resolved from an escaped JSON string
	// e.g. {"response":"{\"foo\":\"bar\"}"} will be returned as {"foo":"bar"} when path is "response"
	// This way, it is possible to resolve a JSON string as part of the response without extra String encoding of the JSON
	UnescapeResponseJson bool
	// HasAuthorizationRule needs to be set to true if the Authorizer should be called for this field
	HasAuthorizationRule bool

	SubscriptionFilterCondition *SubscriptionFilterCondition
}

type FieldConfigurations []FieldConfiguration

type FieldCoordinate struct {
	TypeName  string `json:"type_name"`
	FieldName string `json:"field_name"`
}

type FieldLimitedVisitor struct {
	*astvisitor.Walker
	// contains filtered or unexported fields
}

type FieldListSize struct {
	// AssumedSize is the default assumed size when no slicing argument is provided.
	// If 0, the global default list cost is used.
	AssumedSize int

	// SlicingArguments are argument names that control list size (e.g., "first", "last", "limit")
	// The value of these arguments will be used as the multiplier.
	SlicingArguments []string

	// SizedFields are contains field names in the returned object that returns lists.
	// For these lists we estimate the size based on the value of the slicing arguments or AssumedSize.
	SizedFields []string

	// RequireOneSlicingArgument if true, at least one slicing argument must be provided.
	// If false and no slicing argument is provided, AssumedSize is used.
	// It is not used right now since it is required only for validation.
	RequireOneSlicingArgument bool
}

type FieldWeight struct {

	// Weight is the cost of this field definition. It could be negative or zero.
	// Should be used only if HasWeight is true.
	Weight int

	// Means that there was weight attached to the field definition.
	HasWeight bool

	// ArgumentWeights maps an argument name to its weight.
	// Location: ARGUMENT_DEFINITION
	ArgumentWeights map[string]int
}

type Identifyable interface {
	astvisitor.VisitorIdentifier
}

type JumpCacheKey struct {
	Source DSHash
	Target DSHash
}

type KeyCondition struct {
	Coordinates []FieldCoordinate `json:"coordinates"`
	FieldPath   []string          `json:"field_path"`
}

type KeyIndex struct {
	Path     string
	TypeName string
}

type KeyInfo struct {
	DSHash       DSHash
	Source       bool
	Target       bool
	TypeName     string
	SelectionSet string
	FieldPaths   []KeyInfoFieldPath
}

type KeyInfoFieldPath struct {
	Path       string
	IsExternal bool
}

type KeyJump struct {
	From         DSHash
	To           DSHash
	SelectionSet string
	FieldPaths   []KeyInfoFieldPath
	TypeName     string
}

type Kind int

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

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

type NodeSuggestion struct {
	DataSourceID              string `json:"dsID"`
	DataSourceName            string `json:"dsName"`
	DataSourceHash            DSHash `json:"-"`
	Path                      string `json:"path"`
	TypeName                  string `json:"typeName"`
	FieldName                 string `json:"fieldName"`
	FieldRef                  int    `json:"fieldRef"`
	ParentPath                string `json:"-"`
	IsRootNode                bool   `json:"isRootNode"`
	IsProvided                bool   `json:"isProvided"`
	DisabledEntityResolver    bool   `json:"disabledEntityResolver"` // is true in case the node is an entity root node and all keys have disabled entity resolver
	IsEntityInterfaceTypeName bool   `json:"-"`
	IsExternal                bool   `json:"isExternal"`
	IsRequiredKeyField        bool   `json:"isRequiredKeyField"`
	IsLeaf                    bool   `json:"isLeaf"`

	IsOrphan bool // if node is orphan it should not be taken into account for planning

	Selected         bool     `json:"isSelected"`
	SelectionReasons []string `json:"selectReason"`
	// contains filtered or unexported fields
}

type NodeSuggestionDebugConfiguration struct {
	SelectionReasons  bool
	FilterNotSelected bool
}

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

type NodesAccess interface {
	ListRootNodes() TypeFields
	ListChildNodes() TypeFields
}

type NodesInfo interface {
	HasRootNode(typeName, fieldName string) bool
	HasExternalRootNode(typeName, fieldName string) bool
	HasRootNodeWithTypename(typeName string) bool
	HasChildNode(typeName, fieldName string) bool
	HasExternalChildNode(typeName, fieldName string) bool
	HasChildNodeWithTypename(typeName string) bool
	RequireFetchReasons() map[FieldCoordinate]struct{}
}

type Opts func(*_opts)

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

type PathType int

type Plan interface {
	PlanKind() Kind
	SetFlushInterval(interval int64)
	GetStaticCostCalculator() *CostCalculator
	SetStaticCostCalculator(calc *CostCalculator)
}

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

type PlannerConfiguration interface {
	DataSourceBehavior
	PlannerPathConfiguration

	ObjectFetchConfiguration() *objectFetchConfiguration
	DataSourceConfiguration() DataSource

	RequiredFields() *FederationFieldConfigurations

	Debugger() (d DataSourceDebugger, ok bool)
	Planner() any
	Register(visitor *Visitor) error
}

type PlannerFactory[DataSourceSpecificConfiguration any] interface {

	// Planner creates a new DataSourcePlanner
	Planner(logger abstractlogger.Logger) DataSourcePlanner[DataSourceSpecificConfiguration]

	// Context returns the execution context of the factory
	// For stateful datasources, the factory should contain cancellable global execution context
	// This method serves as a flag that factory should have a context
	Context() context.Context

	UpstreamSchema(dataSourceConfig DataSourceConfiguration[DataSourceSpecificConfiguration]) (*ast.Document, bool)
	PlanningBehavior() DataSourcePlanningBehavior
}

type PlannerPathConfiguration interface {
	ForEachPath(each func(*pathConfiguration) (shouldBreak bool))
	RemoveLeafFragmentPaths() (hasRemovals bool)
	ParentPath() string
	AddPath(configuration pathConfiguration)
	IsNestedPlanner() bool
	HasPath(path string) bool
	HasPathWithFieldRef(fieldRef int) bool
	HasFragmentPath(fragmentRef int) bool
	ShouldWalkFieldsOnPath(path string, typeName string) bool
	HasParent(parent string) bool
}

type PlannerPathType int

type QueryPlanProvider interface {
	IncludeQueryPlanInFetchConfiguration()
}

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

type SeenKeyPath struct {
	Path     string
	TypeName string
	DSHash   DSHash
}

type SourceConnection struct {
	Source DSHash
	Target DSHash
	Jumps  []KeyJump
	Type   SourceConnectionType
}

type SourceConnectionType int

type SourceType string

type StaticCostVisitor struct {
	Walker *astvisitor.Walker

	// AST documents - set before walking
	Operation  *ast.Document
	Definition *ast.Document
	// contains filtered or unexported fields
}

type SubgraphRequestMinifier interface {
	EnableSubgraphRequestMinifier()
}

type SubscriptionConfiguration struct {
	Input          string
	Variables      resolve.Variables
	DataSource     resolve.SubscriptionDataSource
	PostProcessing resolve.PostProcessingConfiguration
	QueryPlan      *resolve.QueryPlan
}

type SubscriptionFieldCondition struct {
	FieldPath []string
	Values    []string
}

type SubscriptionFilterCondition struct {
	And []SubscriptionFilterCondition
	Or  []SubscriptionFilterCondition
	Not *SubscriptionFilterCondition
	In  *SubscriptionFieldCondition
}

type SubscriptionResponsePlan struct {
	Response             *resolve.GraphQLSubscription
	FlushInterval        int64
	StaticCostCalculator *CostCalculator
}

type SynchronousResponsePlan struct {
	Response             *resolve.GraphQLResponse
	FlushInterval        int64
	StaticCostCalculator *CostCalculator
}

type TypeConfiguration struct {
	TypeName string
	// RenameTo modifies the TypeName
	// so that a downstream Operation can contain a different TypeName than the upstream Schema
	// e.g. if the downstream Operation contains { ... on Human_api { height } }
	// the upstream Operation can be rewritten to { ... on Human { height }}
	// by setting RenameTo to Human
	// This way, Types can be suffixed / renamed in downstream Schemas while keeping the contract with the upstream ok
	RenameTo string
}

type TypeConfigurations []TypeConfiguration

type TypeField struct {
	TypeName           string
	FieldNames         []string
	ExternalFieldNames []string
	FetchReasonFields  []string
}

type TypeFields []TypeField

type Visitor struct {
	Operation, Definition *ast.Document
	Walker                *astvisitor.Walker
	Importer              astimport.Importer
	Config                Configuration

	OperationName string
	// contains filtered or unexported fields
}