graphql

type Array []Marshaler

type Cache interface {
	// Get looks up a key's value from the cache.
	Get(ctx context.Context, key string) (value interface{}, ok bool)

	// Add adds a value to the cache.
	Add(ctx context.Context, key string, value interface{})
}

type CollectedField struct {
	*ast.Field

	Selections ast.SelectionSet
	Deferrable *Deferrable
}

type ContextMarshaler interface {
	MarshalGQLContext(ctx context.Context, w io.Writer) error
}

type ContextUnmarshaler interface {
	UnmarshalGQLContext(ctx context.Context, v interface{}) error
}

type ContextWriterFunc func(ctx context.Context, writer io.Writer) error

type Deferrable struct {
	Label string
}

type DeferredGroup struct {
	Path     ast.Path
	Label    string
	FieldSet *FieldSet
	Context  context.Context
}

type DeferredResult struct {
	Path   ast.Path
	Label  string
	Result Marshaler
	Errors gqlerror.List
}

type ErrorPresenterFunc func(ctx context.Context, err error) *gqlerror.Error

type ExecutableSchema interface {
	Schema() *ast.Schema

	Complexity(typeName, fieldName string, childComplexity int, args map[string]interface{}) (int, bool)
	Exec(ctx context.Context) ResponseHandler
}

type ExecutableSchemaMock struct {
	// ComplexityFunc mocks the Complexity method.
	ComplexityFunc func(typeName string, fieldName string, childComplexity int, args map[string]interface{}) (int, bool)

	// ExecFunc mocks the Exec method.
	ExecFunc func(ctx context.Context) ResponseHandler

	// SchemaFunc mocks the Schema method.
	SchemaFunc func() *ast.Schema
	// contains filtered or unexported fields
}

type FieldContext struct {
	Parent *FieldContext
	// The name of the type this field belongs to
	Object string
	// These are the args after processing, they can be mutated in middleware to change what the resolver will get.
	Args map[string]interface{}
	// The raw field
	Field CollectedField
	// The index of array in path.
	Index *int
	// The result object of resolver
	Result interface{}
	// IsMethod indicates if the resolver is a method
	IsMethod bool
	// IsResolver indicates if the field has a user-specified resolver
	IsResolver bool
	// Child allows getting a child FieldContext by its field collection description.
	// Note that, the returned child FieldContext represents the context as it was
	// before the execution of the field resolver. For example:
	//
	//	srv.AroundFields(func(ctx context.Context, next graphql.Resolver) (interface{}, error) {
	//		fc := graphql.GetFieldContext(ctx)
	//		op := graphql.GetOperationContext(ctx)
	//		collected := graphql.CollectFields(opCtx, fc.Field.Selections, []string{"User"})
	//
	//		child, err := fc.Child(ctx, collected[0])
	//		if err != nil {
	//			return nil, err
	//		}
	//		fmt.Println("child context %q with args: %v", child.Field.Name, child.Args)
	//
	//		return next(ctx)
	//	})
	//
	Child func(context.Context, CollectedField) (*FieldContext, error)
}

type FieldInterceptor interface {
	InterceptField(ctx context.Context, next Resolver) (res interface{}, err error)
}

type FieldMiddleware func(ctx context.Context, next Resolver) (res interface{}, err error)

type FieldSet struct {
	Values   []Marshaler
	Invalids uint32
	// contains filtered or unexported fields
}

type FieldStats struct {
	// When field execution started
	Started time.Time

	// When argument marshaling finished
	ArgumentsCompleted time.Time

	// When the field completed running all middleware. Not available inside field middleware!
	Completed time.Time
}

type GraphExecutor interface {
	CreateOperationContext(ctx context.Context, params *RawParams) (*OperationContext, gqlerror.List)
	DispatchOperation(ctx context.Context, rc *OperationContext) (ResponseHandler, context.Context)
	DispatchError(ctx context.Context, list gqlerror.List) *Response
}

type HandlerExtension interface {
	// ExtensionName should be a CamelCase string version of the extension which may be shown in stats and logging.
	ExtensionName() string
	// Validate is called when adding an extension to the server, it allows validation against the servers schema.
	Validate(schema ExecutableSchema) error
}

type MapCache map[string]interface{}

type Marshaler interface {
	MarshalGQL(w io.Writer)
}

type Mutation struct{}

type NoCache struct{}

type Omittable[T any] struct {
	// contains filtered or unexported fields
}

type OperationContext struct {
	RawQuery      string
	Variables     map[string]interface{}
	OperationName string
	Doc           *ast.QueryDocument
	Headers       http.Header

	Operation              *ast.OperationDefinition
	DisableIntrospection   bool
	RecoverFunc            RecoverFunc
	ResolverMiddleware     FieldMiddleware
	RootResolverMiddleware RootFieldMiddleware

	Stats Stats
}

type OperationContextMutator interface {
	MutateOperationContext(ctx context.Context, rc *OperationContext) *gqlerror.Error
}

type OperationHandler func(ctx context.Context) ResponseHandler

type OperationInterceptor interface {
	InterceptOperation(ctx context.Context, next OperationHandler) ResponseHandler
}

type OperationMiddleware func(ctx context.Context, next OperationHandler) ResponseHandler

type OperationParameterMutator interface {
	MutateOperationParameters(ctx context.Context, request *RawParams) *gqlerror.Error
}

type PathContext struct {
	ParentField *FieldContext
	Parent      *PathContext
	Field       *string
	Index       *int
}

type Query struct{}

type RawParams struct {
	Query         string                 `json:"query"`
	OperationName string                 `json:"operationName"`
	Variables     map[string]interface{} `json:"variables"`
	Extensions    map[string]interface{} `json:"extensions"`
	Headers       http.Header            `json:"headers"`

	ReadTime TraceTiming `json:"-"`
}

type RecoverFunc func(ctx context.Context, err interface{}) (userMessage error)

type Resolver func(ctx context.Context) (res interface{}, err error)

type Response struct {
	Errors     gqlerror.List          `json:"errors,omitempty"`
	Data       json.RawMessage        `json:"data"`
	Label      string                 `json:"label,omitempty"`
	Path       ast.Path               `json:"path,omitempty"`
	HasNext    *bool                  `json:"hasNext,omitempty"`
	Extensions map[string]interface{} `json:"extensions,omitempty"`
}

type ResponseHandler func(ctx context.Context) *Response

type ResponseInterceptor interface {
	InterceptResponse(ctx context.Context, next ResponseHandler) *Response
}

type ResponseMiddleware func(ctx context.Context, next ResponseHandler) *Response

type RootFieldContext struct {
	// The name of the type this field belongs to
	Object string
	// The raw field
	Field CollectedField
}

type RootFieldInterceptor interface {
	InterceptRootField(ctx context.Context, next RootResolver) Marshaler
}

type RootFieldMiddleware func(ctx context.Context, next RootResolver) Marshaler

type RootResolver func(ctx context.Context) Marshaler

type Stats struct {
	OperationStart time.Time
	Read           TraceTiming
	Parsing        TraceTiming
	Validation     TraceTiming
	// contains filtered or unexported fields
}

type Status int

type Subscription struct{}

type TraceTiming struct {
	Start time.Time
	End   time.Time
}

type Transport interface {
	Supports(r *http.Request) bool
	Do(w http.ResponseWriter, r *http.Request, exec GraphExecutor)
}

type Unmarshaler interface {
	UnmarshalGQL(v interface{}) error
}

type Upload struct {
	File        io.ReadSeeker
	Filename    string
	Size        int64
	ContentType string
}

type WriterFunc func(writer io.Writer)