import "github.com/99designs/gqlgen/graphql"
any.go bool.go cache.go context_field.go context_field_input.go context_operation.go context_response.go error.go executable_schema.go executable_schema_mock.go fieldset.go float.go handler.go id.go int.go jsonw.go map.go oneshot.go recovery.go response.go root.go stats.go string.go time.go upload.go version.go
const Version = "v0.12.1-dev"var False = &lit{falseLit}Now is time.Now, except in tests. Then it can be whatever you want it to be.
var Null = &lit{nullLit}var True = &lit{trueLit}AddError sends an error to the client, first passing it through the error presenter.
AddErrorf writes a formatted error to the client, first passing it through the error presenter.
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.
GetExtensions returns any extensions registered in the current result context
GetFieldErrors returns a list of errors that occurred in the given field
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
HasOperationContext checks if the given context is part of an ongoing operation
Some errors can happen outside of an operation, eg json unmarshal errors.
RegisterExtension allows you to add a new extension into the graphql response
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 dont 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 WithResponseContext(ctx context.Context, presenterFunc ErrorPresenterFunc, recoverFunc RecoverFunc) context.Context
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{})
}Cache is a shared store for APQ and query AST caching
type CollectedField struct {
*ast.Field
Selections ast.SelectionSet
}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 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
}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.
}
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
}func GetFieldContext(ctx context.Context) *FieldContext
func (r *FieldContext) Path() ast.Path
type FieldInputContext struct {
ParentField *FieldContext
ParentInput *FieldInputContext
Field *string
Index *int
}func GetFieldInputContext(ctx context.Context) *FieldInputContext
func NewFieldInputWithField(field string) *FieldInputContext
func NewFieldInputWithIndex(index int) *FieldInputContext
func (fic *FieldInputContext) Path() ast.Path
type FieldInterceptor interface {
InterceptField(ctx context.Context, next Resolver) (res interface{}, err error)
}FieldInterceptor called around each field
func NewFieldSet(fields []CollectedField) *FieldSet
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
}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" } } } | | | +--------------------------------------------------------------------+ | +------------------------------------------------------------------------+
MapCache is the simplest implementation of a cache, because it can not evict it should only be used in tests
Add adds a value to the cache.
Get looks up a key's value from the cache.
type Mutation struct{}type NoCache struct{}type OperationContext struct {
RawQuery string
Variables map[string]interface{}
OperationName string
Doc *ast.QueryDocument
Operation *ast.OperationDefinition
DisableIntrospection bool
Recover RecoverFunc
ResolverMiddleware FieldMiddleware
Stats Stats
}func GetOperationContext(ctx context.Context) *OperationContext
func (c *OperationContext) Error(ctx context.Context, err error)
Error sends an error to the client, passing it through the formatter. Deprecated: use graphql.AddError(ctx, err) instead
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) Validate(ctx context.Context) error
type OperationContextMutator interface {
MutateOperationContext(ctx context.Context, rc *OperationContext) *gqlerror.Error
}OperationContextMutator is called after creating the request context, but before executing the root resolver.
type OperationHandler func(ctx context.Context) ResponseHandler
type OperationInterceptor interface {
InterceptOperation(ctx context.Context, next OperationHandler) 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 OperationMiddleware func(ctx context.Context, next OperationHandler) ResponseHandler
type OperationParameterMutator interface {
MutateOperationParameters(ctx context.Context, request *RawParams) *gqlerror.Error
}OperationParameterMutator is called before creating a request context. allows manipulating the raw query on the way in.
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"`
ReadTime TraceTiming `json:"-"`
}type RequestContext = OperationContext
Deprecated: Please update all references to OperationContext instead
func GetRequestContext(ctx context.Context) *RequestContext
Deprecated: Please update all references to GetOperationContext instead
type ResolverContext = FieldContext
Deprecated: Use FieldContext instead
func GetResolverContext(ctx context.Context) *ResolverContext
Deprecated: Use GetFieldContext instead
type Response struct {
Errors gqlerror.List `json:"errors,omitempty"`
Data json.RawMessage `json:"data"`
Extensions map[string]interface{} `json:"extensions,omitempty"`
}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
func OneShot(resp *Response) ResponseHandler
type ResponseInterceptor interface {
InterceptResponse(ctx context.Context, next ResponseHandler) *Response
}ResponseInterceptor is called around each graphql operation response. This can be called many times for a single operation the case of subscriptions.
type ResponseMiddleware func(ctx context.Context, next ResponseHandler) *Response
type Stats struct {
OperationStart time.Time
Read TraceTiming
Parsing TraceTiming
Validation TraceTiming
// contains filtered or unexported fields
}type Subscription struct{}type Transport interface {
Supports(r *http.Request) bool
Do(w http.ResponseWriter, r *http.Request, exec GraphExecutor)
}Transport provides support for different wire level encodings of graphql requests, eg Form, Get, Post, Websocket
func (f WriterFunc) MarshalGQL(w io.Writer)
| Path | Synopsis |
|---|---|
| errcode | |
| executor | |
| executor/testexecutor | |
| handler | |
| handler/apollotracing | |
| handler/debug | |
| handler/extension | |
| handler/lru | |
| handler/testserver | |
| handler/transport | |
| introspection | introspection implements the spec defined in https://github.com/facebook/graphql/blob/master/spec/Section%204%20--%20Introspection.md#schema-introspection |
| playground |
Package graphql imports 14 packages (graph) and is imported by 202 packages. Updated 2020-08-14. Refresh now. Tools for package owners.