const Version = "v0.17.45"
var (
Null = &lit{nullLit}
True = &lit{trueLit}
False = &lit{falseLit}
)
Now is time.Now, except in tests. Then it can be whatever you want it to be.
var Now = time.Now
func AddError(ctx context.Context, err error)
AddError sends an error to the client, first passing it through the error presenter.
func AddErrorf(ctx context.Context, format string, args ...interface{})
AddErrorf writes a formatted error to the client, first passing it through the error presenter.
func BuildUnmarshalerMap(unmarshaler ...interface{}) map[reflect.Type]reflect.Value
BuildUnmarshalerMap returns a map of unmarshal functions of the ExecutableContext to use with the WithUnmarshalerMap function.
func CoerceList(v interface{}) []interface{}
CoerceList applies coercion from a single value to a list.
func CollectAllFields(ctx context.Context) []string
CollectAllFields returns a slice of all GraphQL field names that were selected for the current resolver context. The slice will contain the unique set of all field names requested regardless of fragment type conditions.
func DefaultErrorPresenter(ctx context.Context, err error) *gqlerror.Error
func DefaultRecover(ctx context.Context, err interface{}) error
func ErrorOnPath(ctx context.Context, err error) error
func GetErrors(ctx context.Context) gqlerror.List
func GetExtension(ctx context.Context, name string) interface{}
func GetExtensions(ctx context.Context) map[string]interface{}
GetExtensions returns any extensions registered in the current result context
func GetFieldErrors(ctx context.Context, rctx *FieldContext) gqlerror.List
GetFieldErrors returns a list of errors that occurred in the given field
func GetPath(ctx context.Context) ast.Path
func GetStartTime(ctx context.Context) time.Time
GetStartTime should only be called by the handler package, it will be set into request context as Stats.Start
func HasFieldError(ctx context.Context, rctx *FieldContext) bool
HasFieldError returns true if the given field has already errored
func HasOperationContext(ctx context.Context) bool
HasOperationContext checks if the given context is part of an ongoing operation
Some errors can happen outside of an operation, eg json unmarshal errors.
func Recover(ctx context.Context, err interface{}) (userMessage error)
func RegisterExtension(ctx context.Context, key string, value interface{})
RegisterExtension allows you to add a new extension into the graphql response
func StartOperationTrace(ctx context.Context) context.Context
StartOperationTrace captures the current time and stores it in context. This will eventually be added to request context but we want to grab it as soon as possible. For transports that can only handle a single graphql query per http requests you don't need to call this at all, the server will do it for you. For transports that handle multiple (eg batching, subscriptions) this should be called before decoding each request.
func UnmarshalAny(v interface{}) (interface{}, error)
func UnmarshalBoolean(v interface{}) (bool, error)
func UnmarshalDuration(v interface{}) (time.Duration, error)
UnmarshalDuration returns the duration from a string in ISO8601 format
func UnmarshalFloat(v interface{}) (float64, error)
func UnmarshalFloatContext(ctx context.Context, v interface{}) (float64, error)
func UnmarshalID(v interface{}) (string, error)
func UnmarshalInputFromContext(ctx context.Context, raw, v interface{}) error
UnmarshalInputFromContext allows unmarshaling input object from a context.
func UnmarshalInt(v interface{}) (int, error)
func UnmarshalInt32(v interface{}) (int32, error)
func UnmarshalInt64(v interface{}) (int64, error)
func UnmarshalIntID(v interface{}) (int, error)
func UnmarshalMap(v interface{}) (map[string]interface{}, error)
func UnmarshalString(v interface{}) (string, error)
func UnmarshalTime(v interface{}) (time.Time, error)
func UnmarshalUUID(v any) (uuid.UUID, error)
func UnmarshalUint(v interface{}) (uint, error)
func UnmarshalUint32(v interface{}) (uint32, error)
func UnmarshalUint64(v interface{}) (uint64, error)
func WithFieldContext(ctx context.Context, rc *FieldContext) context.Context
func WithFreshResponseContext(ctx context.Context) context.Context
func WithOperationContext(ctx context.Context, rc *OperationContext) context.Context
func WithPathContext(ctx context.Context, fic *PathContext) context.Context
func WithResponseContext(ctx context.Context, presenterFunc ErrorPresenterFunc, recoverFunc RecoverFunc) context.Context
func WithRootFieldContext(ctx context.Context, rc *RootFieldContext) context.Context
func WithUnmarshalerMap(ctx context.Context, maps map[reflect.Type]reflect.Value) context.Context
WithUnmarshalerMap returns a new context with a map from input types to their unmarshaler functions.
type Array []Marshaler
func (a Array) MarshalGQL(writer io.Writer)
Cache is a shared store for APQ and query AST caching
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
}
func CollectFields(reqCtx *OperationContext, selSet ast.SelectionSet, satisfies []string) []CollectedField
CollectFields returns the set of fields from an ast.SelectionSet where all collected fields satisfy at least one of the GraphQL types passed through satisfies. Providing an empty or nil slice for satisfies will return collect all fields regardless of fragment type conditions.
func CollectFieldsCtx(ctx context.Context, satisfies []string) []CollectedField
This is just a convenient wrapper method for CollectFields
type ContextMarshaler interface {
MarshalGQLContext(ctx context.Context, w io.Writer) error
}
func MarshalFloatContext(f float64) ContextMarshaler
type ContextUnmarshaler interface {
UnmarshalGQLContext(ctx context.Context, v interface{}) error
}
type ContextWriterFunc func(ctx context.Context, writer io.Writer) error
func (f ContextWriterFunc) MarshalGQLContext(ctx context.Context, w 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
}
ExecutableSchemaMock is a mock implementation of ExecutableSchema.
func TestSomethingThatUsesExecutableSchema(t *testing.T) {
// make and configure a mocked ExecutableSchema
mockedExecutableSchema := &ExecutableSchemaMock{
ComplexityFunc: func(typeName string, fieldName string, childComplexity int, args map[string]interface{}) (int, bool) {
panic("mock out the Complexity method")
},
ExecFunc: func(ctx context.Context) ResponseHandler {
panic("mock out the Exec method")
},
SchemaFunc: func() *ast.Schema {
panic("mock out the Schema method")
},
}
// use mockedExecutableSchema in code that requires ExecutableSchema
// and then make assertions.
}
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
}
func (mock *ExecutableSchemaMock) Complexity(typeName string, fieldName string, childComplexity int, args map[string]interface{}) (int, bool)
Complexity calls ComplexityFunc.
func (mock *ExecutableSchemaMock) ComplexityCalls() []struct { TypeName string FieldName string ChildComplexity int Args map[string]interface{} }
ComplexityCalls gets all the calls that were made to Complexity. Check the length with:
len(mockedExecutableSchema.ComplexityCalls())
func (mock *ExecutableSchemaMock) Exec(ctx context.Context) ResponseHandler
Exec calls ExecFunc.
func (mock *ExecutableSchemaMock) ExecCalls() []struct { Ctx context.Context }
ExecCalls gets all the calls that were made to Exec. Check the length with:
len(mockedExecutableSchema.ExecCalls())
func (mock *ExecutableSchemaMock) Schema() *ast.Schema
Schema calls SchemaFunc.
func (mock *ExecutableSchemaMock) SchemaCalls() []struct { }
SchemaCalls gets all the calls that were made to Schema. Check the length with:
len(mockedExecutableSchema.SchemaCalls())
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)
}
func GetFieldContext(ctx context.Context) *FieldContext
func (r *FieldContext) Path() ast.Path
FieldInterceptor called around each field
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
}
func NewFieldSet(fields []CollectedField) *FieldSet
func (m *FieldSet) AddField(field CollectedField)
func (m *FieldSet) Concurrently(i int, f func(context.Context) Marshaler)
func (m *FieldSet) Dispatch(ctx context.Context)
func (m *FieldSet) MarshalGQL(writer io.Writer)
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
}
HandlerExtension adds functionality to the http handler. See the list of possible hook points below Its important to understand the lifecycle of a graphql request and the terminology we use in gqlgen before working with these
+--- REQUEST POST /graphql --------------------------------------------+
| +- OPERATION query OpName { viewer { name } } -----------------------+ |
| | RESPONSE { "data": { "viewer": { "name": "bob" } } } | |
| +- OPERATION subscription OpName2 { chat { message } } --------------+ |
| | RESPONSE { "data": { "chat": { "message": "hello" } } } | |
| | RESPONSE { "data": { "chat": { "message": "byee" } } } | |
| +--------------------------------------------------------------------+ |
+------------------------------------------------------------------------+
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
}
MapCache is the simplest implementation of a cache, because it can not evict it should only be used in tests
type MapCache map[string]interface{}
func (m MapCache) Add(_ context.Context, key string, value interface{})
Add adds a value to the cache.
func (m MapCache) Get(_ context.Context, key string) (value interface{}, ok bool)
Get looks up a key's value from the cache.
type Marshaler interface {
MarshalGQL(w io.Writer)
}
func MarshalAny(v interface{}) Marshaler
func MarshalBoolean(b bool) Marshaler
func MarshalDuration(d time.Duration) Marshaler
MarshalDuration returns the duration on ISO8601 format
func MarshalFloat(f float64) Marshaler
func MarshalID(s string) Marshaler
func MarshalInt(i int) Marshaler
func MarshalInt32(i int32) Marshaler
func MarshalInt64(i int64) Marshaler
func MarshalIntID(i int) Marshaler
func MarshalMap(val map[string]interface{}) Marshaler
func MarshalString(s string) Marshaler
func MarshalTime(t time.Time) Marshaler
func MarshalUUID(id uuid.UUID) Marshaler
func MarshalUint(i uint) Marshaler
func MarshalUint32(i uint32) Marshaler
func MarshalUint64(i uint64) Marshaler
func MarshalUpload(f Upload) Marshaler
func WrapContextMarshaler(ctx context.Context, m ContextMarshaler) Marshaler
type Mutation struct{}
type NoCache struct{}
func (n NoCache) Add(_ context.Context, _ string, _ interface{})
func (n NoCache) Get(_ context.Context, _ string) (value interface{}, ok bool)
Omittable is a wrapper around a value that also stores whether it is set or not.
type Omittable[T any] struct { // contains filtered or unexported fields }
func OmittableOf[T any](value T) Omittable[T]
func (o Omittable[T]) IsSet() bool
func (o Omittable[T]) MarshalJSON() ([]byte, error)
func (o *Omittable[T]) UnmarshalJSON(bytes []byte) error
func (o Omittable[T]) Value() T
func (o Omittable[T]) ValueOK() (T, bool)
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
}
func GetOperationContext(ctx context.Context) *OperationContext
func (c *OperationContext) Error(ctx context.Context, err error)
Error add error or multiple errors (if underlaying type is gqlerror.List) into the stack. Then it will be sends to the client, passing it through the formatter.
func (c *OperationContext) Errorf(ctx context.Context, format string, args ...interface{})
Errorf sends an error string to the client, passing it through the formatter. Deprecated: use graphql.AddErrorf(ctx, err) instead
func (c *OperationContext) Recover(ctx context.Context, err interface{}) error
func (c *OperationContext) Validate(ctx context.Context) error
OperationContextMutator is called after creating the request context, but before executing the root resolver.
type OperationContextMutator interface {
MutateOperationContext(ctx context.Context, rc *OperationContext) *gqlerror.Error
}
type OperationHandler func(ctx context.Context) ResponseHandler
OperationInterceptor is called for each incoming query, for basic requests the writer will be invoked once, for subscriptions it will be invoked multiple times.
type OperationInterceptor interface {
InterceptOperation(ctx context.Context, next OperationHandler) ResponseHandler
}
type OperationMiddleware func(ctx context.Context, next OperationHandler) ResponseHandler
OperationParameterMutator is called before creating a request context. allows manipulating the raw query on the way in.
type OperationParameterMutator interface {
MutateOperationParameters(ctx context.Context, request *RawParams) *gqlerror.Error
}
type PathContext struct {
ParentField *FieldContext
Parent *PathContext
Field *string
Index *int
}
func GetPathContext(ctx context.Context) *PathContext
func NewPathWithField(field string) *PathContext
func NewPathWithIndex(index int) *PathContext
func (fic *PathContext) Path() ast.Path
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:"-"`
}
func (p *RawParams) AddUpload(upload Upload, key, path string) *gqlerror.Error
type RecoverFunc func(ctx context.Context, err interface{}) (userMessage error)
Deprecated: Please update all references to OperationContext instead
type RequestContext = OperationContext
func GetRequestContext(ctx context.Context) *RequestContext
Deprecated: Please update all references to GetOperationContext instead
type Resolver func(ctx context.Context) (res interface{}, err error)
Deprecated: Use FieldContext instead
type ResolverContext = FieldContext
func GetResolverContext(ctx context.Context) *ResolverContext
Deprecated: Use GetFieldContext instead
Errors are intentionally serialized first based on the advice in https://github.com/facebook/graphql/commit/7b40390d48680b15cb93e02d46ac5eb249689876#diff-757cea6edf0288677a9eea4cfc801d87R107 and https://github.com/facebook/graphql/pull/384
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"`
}
func ErrorResponse(ctx context.Context, messagef string, args ...interface{}) *Response
type ResponseHandler func(ctx context.Context) *Response
func OneShot(resp *Response) ResponseHandler
ResponseInterceptor is called around each graphql operation response. This can be called many times for a single operation the case of subscriptions.
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
}
func GetRootFieldContext(ctx context.Context) *RootFieldContext
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
}
func (c *Stats) GetExtension(name string) interface{}
func (c *Stats) SetExtension(name string, data interface{})
type Status int
type Subscription struct{}
type TraceTiming struct {
Start time.Time
End time.Time
}
Transport provides support for different wire level encodings of graphql requests, eg Form, Get, Post, Websocket
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
}
func UnmarshalUpload(v interface{}) (Upload, error)
type WriterFunc func(writer io.Writer)
func (f WriterFunc) MarshalGQL(w io.Writer)
| Name | Synopsis |
|---|---|
| .. | |
| errcode | |
| executor | |
| testexecutor | |
| handler | |
| apollofederatedtracingv1 | |
| generated | |
| apollotracing | |
| debug | |
| extension | |
| lru | |
| testserver | |
| transport | |
| introspection | introspection implements the spec defined in https://github.com/facebook/graphql/blob/master/spec/Section%204%20--%20Introspection.md#schema-introspection |
| playground | |