Back to godoc.org

Package graphql

v0.13.0
Latest Go to latest

The latest major version is .

Published: Sep 21, 2020 | License: MIT | Module: github.com/99designs/gqlgen

Index

Constants

const Version = "v0.13.0"

Variables

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

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}

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

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

func (mock *ExecutableSchemaMock) Exec(ctx context.Context) ResponseHandler

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)

Package Files

Documentation was rendered with GOOS=linux and GOARCH=amd64.

Jump to identifier

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to identifier