Documentation

Index

Constants

View Source
const Version = "v0.13.0"

Variables

View Source
var False = &lit{falseLit}
View Source
var Now = time.Now

    Now is time.Now, except in tests. Then it can be whatever you want it to be.

    View Source
    var Null = &lit{nullLit}
    View Source
    var True = &lit{trueLit}

    Functions

    func AddError

    func AddError(ctx context.Context, err error)

      AddError sends an error to the client, first passing it through the error presenter.

      func AddErrorf

      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 CollectAllFields

        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

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

          func DefaultRecover

          func DefaultRecover(ctx context.Context, err interface{}) error

          func ErrorOnPath

          func ErrorOnPath(ctx context.Context, err error) error

          func GetErrors

          func GetErrors(ctx context.Context) gqlerror.List

          func GetExtension

          func GetExtension(ctx context.Context, name string) interface{}

          func GetExtensions

          func GetExtensions(ctx context.Context) map[string]interface{}

            GetExtensions returns any extensions registered in the current result context

            func GetFieldErrors

            func GetFieldErrors(ctx context.Context, rctx *FieldContext) gqlerror.List

              GetFieldErrors returns a list of errors that occurred in the given field

              func GetPath

              func GetPath(ctx context.Context) ast.Path

              func GetStartTime

              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

                func HasFieldError(ctx context.Context, rctx *FieldContext) bool

                  HasFieldError returns true if the given field has already errored

                  func HasOperationContext

                  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

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

                    func RegisterExtension

                    func RegisterExtension(ctx context.Context, key string, value interface{})

                      RegisterExtension allows you to add a new extension into the graphql response

                      func StartOperationTrace

                      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 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 UnmarshalAny

                        func UnmarshalAny(v interface{}) (interface{}, error)

                        func UnmarshalBoolean

                        func UnmarshalBoolean(v interface{}) (bool, error)

                        func UnmarshalFloat

                        func UnmarshalFloat(v interface{}) (float64, error)

                        func UnmarshalID

                        func UnmarshalID(v interface{}) (string, error)

                        func UnmarshalInt

                        func UnmarshalInt(v interface{}) (int, error)

                        func UnmarshalInt32

                        func UnmarshalInt32(v interface{}) (int32, error)

                        func UnmarshalInt64

                        func UnmarshalInt64(v interface{}) (int64, error)

                        func UnmarshalIntID

                        func UnmarshalIntID(v interface{}) (int, error)

                        func UnmarshalMap

                        func UnmarshalMap(v interface{}) (map[string]interface{}, error)

                        func UnmarshalString

                        func UnmarshalString(v interface{}) (string, error)

                        func UnmarshalTime

                        func UnmarshalTime(v interface{}) (time.Time, error)

                        func WithFieldContext

                        func WithFieldContext(ctx context.Context, rc *FieldContext) context.Context

                        func WithOperationContext

                        func WithOperationContext(ctx context.Context, rc *OperationContext) context.Context

                        func WithPathContext

                        func WithPathContext(ctx context.Context, fic *PathContext) context.Context

                        func WithResponseContext

                        func WithResponseContext(ctx context.Context, presenterFunc ErrorPresenterFunc, recoverFunc RecoverFunc) context.Context

                        Types

                        type Array

                        type Array []Marshaler

                        func (Array) MarshalGQL

                        func (a Array) MarshalGQL(writer io.Writer)

                        type Cache

                        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

                          type CollectedField struct {
                          	*ast.Field
                          
                          	Selections ast.SelectionSet
                          }

                          func CollectFields

                          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

                            func CollectFieldsCtx(ctx context.Context, satisfies []string) []CollectedField

                              This is just a convenient wrapper method for CollectFields

                              type ErrorPresenterFunc

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

                              type ExecutableSchema

                              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

                              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 (*ExecutableSchemaMock) Complexity

                                func (mock *ExecutableSchemaMock) Complexity(typeName string, fieldName string, childComplexity int, args map[string]interface{}) (int, bool)

                                  Complexity calls ComplexityFunc.

                                  func (*ExecutableSchemaMock) ComplexityCalls

                                  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 (*ExecutableSchemaMock) Exec

                                      Exec calls ExecFunc.

                                      func (*ExecutableSchemaMock) ExecCalls

                                      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 (*ExecutableSchemaMock) Schema

                                        func (mock *ExecutableSchemaMock) Schema() *ast.Schema

                                          Schema calls SchemaFunc.

                                          func (*ExecutableSchemaMock) SchemaCalls

                                          func (mock *ExecutableSchemaMock) SchemaCalls() []struct {
                                          }

                                            SchemaCalls gets all the calls that were made to Schema. Check the length with:

                                            len(mockedExecutableSchema.SchemaCalls())
                                            

                                            type FieldContext

                                            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
                                            }

                                            func GetFieldContext

                                            func GetFieldContext(ctx context.Context) *FieldContext

                                            func (*FieldContext) Path

                                            func (r *FieldContext) Path() ast.Path

                                            type FieldInterceptor

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

                                              FieldInterceptor called around each field

                                              type FieldMiddleware

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

                                              type FieldSet

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

                                              func NewFieldSet

                                              func NewFieldSet(fields []CollectedField) *FieldSet

                                              func (*FieldSet) Concurrently

                                              func (m *FieldSet) Concurrently(i int, f func() Marshaler)

                                              func (*FieldSet) Dispatch

                                              func (m *FieldSet) Dispatch()

                                              func (*FieldSet) MarshalGQL

                                              func (m *FieldSet) MarshalGQL(writer io.Writer)

                                              type FieldStats

                                              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

                                              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

                                              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" } } } | | | +--------------------------------------------------------------------+ | +------------------------------------------------------------------------+

                                                type MapCache

                                                type MapCache map[string]interface{}

                                                  MapCache is the simplest implementation of a cache, because it can not evict it should only be used in tests

                                                  func (MapCache) Add

                                                  func (m MapCache) Add(ctx context.Context, key string, value interface{})

                                                    Add adds a value to the cache.

                                                    func (MapCache) Get

                                                    func (m MapCache) Get(ctx context.Context, key string) (value interface{}, ok bool)

                                                      Get looks up a key's value from the cache.

                                                      type Marshaler

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

                                                      func MarshalAny

                                                      func MarshalAny(v interface{}) Marshaler

                                                      func MarshalBoolean

                                                      func MarshalBoolean(b bool) Marshaler

                                                      func MarshalFloat

                                                      func MarshalFloat(f float64) Marshaler

                                                      func MarshalID

                                                      func MarshalID(s string) Marshaler

                                                      func MarshalInt

                                                      func MarshalInt(i int) Marshaler

                                                      func MarshalInt32

                                                      func MarshalInt32(i int32) Marshaler

                                                      func MarshalInt64

                                                      func MarshalInt64(i int64) Marshaler

                                                      func MarshalIntID

                                                      func MarshalIntID(i int) Marshaler

                                                      func MarshalMap

                                                      func MarshalMap(val map[string]interface{}) Marshaler

                                                      func MarshalString

                                                      func MarshalString(s string) Marshaler

                                                      func MarshalTime

                                                      func MarshalTime(t time.Time) Marshaler

                                                      func MarshalUpload

                                                      func MarshalUpload(f Upload) Marshaler

                                                      type Mutation

                                                      type Mutation struct{}

                                                      type NoCache

                                                      type NoCache struct{}

                                                      func (NoCache) Add

                                                      func (n NoCache) Add(ctx context.Context, key string, value interface{})

                                                      func (NoCache) Get

                                                      func (n NoCache) Get(ctx context.Context, key string) (value interface{}, ok bool)

                                                      type OperationContext

                                                      type OperationContext struct {
                                                      	RawQuery      string
                                                      	Variables     map[string]interface{}
                                                      	OperationName string
                                                      	Doc           *ast.QueryDocument
                                                      
                                                      	Operation            *ast.OperationDefinition
                                                      	DisableIntrospection bool
                                                      	RecoverFunc          RecoverFunc
                                                      	ResolverMiddleware   FieldMiddleware
                                                      
                                                      	Stats Stats
                                                      }

                                                      func GetOperationContext

                                                      func GetOperationContext(ctx context.Context) *OperationContext

                                                      func (*OperationContext) Error

                                                      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 (*OperationContext) Errorf

                                                        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 (*OperationContext) Recover

                                                          func (c *OperationContext) Recover(ctx context.Context, err interface{}) error

                                                          func (*OperationContext) Validate

                                                          func (c *OperationContext) Validate(ctx context.Context) error

                                                          type OperationContextMutator

                                                          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

                                                            type OperationHandler func(ctx context.Context) ResponseHandler

                                                            type OperationInterceptor

                                                            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

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

                                                              type OperationParameterMutator

                                                              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 PathContext

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

                                                                func GetPathContext

                                                                func GetPathContext(ctx context.Context) *PathContext

                                                                func NewPathWithField

                                                                func NewPathWithField(field string) *PathContext

                                                                func NewPathWithIndex

                                                                func NewPathWithIndex(index int) *PathContext

                                                                func (*PathContext) Path

                                                                func (fic *PathContext) Path() ast.Path

                                                                type Query

                                                                type Query struct{}

                                                                type RawParams

                                                                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:"-"`
                                                                }

                                                                func (*RawParams) AddUpload

                                                                func (p *RawParams) AddUpload(upload Upload, key, path string) *gqlerror.Error

                                                                type RecoverFunc

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

                                                                type RequestContext

                                                                type RequestContext = OperationContext

                                                                  Deprecated: Please update all references to OperationContext instead

                                                                  func GetRequestContext

                                                                  func GetRequestContext(ctx context.Context) *RequestContext

                                                                    Deprecated: Please update all references to GetOperationContext instead

                                                                    type Resolver

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

                                                                    type ResolverContext

                                                                    type ResolverContext = FieldContext

                                                                      Deprecated: Use FieldContext instead

                                                                      func GetResolverContext

                                                                      func GetResolverContext(ctx context.Context) *ResolverContext

                                                                        Deprecated: Use GetFieldContext instead

                                                                        type Response

                                                                        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 ErrorResponse

                                                                          func ErrorResponse(ctx context.Context, messagef string, args ...interface{}) *Response

                                                                          type ResponseHandler

                                                                          type ResponseHandler func(ctx context.Context) *Response

                                                                          func OneShot

                                                                          func OneShot(resp *Response) ResponseHandler

                                                                          type ResponseInterceptor

                                                                          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

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

                                                                            type Stats

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

                                                                            func (*Stats) GetExtension

                                                                            func (c *Stats) GetExtension(name string) interface{}

                                                                            func (*Stats) SetExtension

                                                                            func (c *Stats) SetExtension(name string, data interface{})

                                                                            type Status

                                                                            type Status int

                                                                            type Subscription

                                                                            type Subscription struct{}

                                                                            type TraceTiming

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

                                                                            type Transport

                                                                            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

                                                                              type Unmarshaler

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

                                                                              type Upload

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

                                                                              func UnmarshalUpload

                                                                              func UnmarshalUpload(v interface{}) (Upload, error)

                                                                              type WriterFunc

                                                                              type WriterFunc func(writer io.Writer)

                                                                              func (WriterFunc) MarshalGQL

                                                                              func (f WriterFunc) MarshalGQL(w io.Writer)

                                                                              Directories

                                                                              Path Synopsis
                                                                              lru
                                                                              introspection implements the spec defined in https://github.com/facebook/graphql/blob/master/spec/Section%204%20--%20Introspection.md#schema-introspection
                                                                              introspection implements the spec defined in https://github.com/facebook/graphql/blob/master/spec/Section%204%20--%20Introspection.md#schema-introspection