graphql

package
v0.11.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 18, 2020 License: MIT Imports: 14 Imported by: 4,682

Documentation

Index

Constants

View Source 
const Version = "v0.11.1"

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 added in v0.8.0 

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 GetErrors added in v0.11.0 

func GetErrors(ctx context.Context) gqlerror.List

func GetExtension added in v0.11.0 

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

func GetExtensions added in v0.11.0 

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

GetExtensions returns any extensions registered in the current result context

func GetFieldErrors added in v0.11.0 

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

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

func GetStartTime added in v0.11.0 

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 added in v0.11.0 

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

HasFieldError returns true if the given field has already errored

func Recover added in v0.11.0 

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

func RegisterExtension added in v0.11.0 

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

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

func StartOperationTrace added in v0.11.0 

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 added in v0.9.0 

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 added in v0.8.0 

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

func UnmarshalInt64 added in v0.8.0 

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

func UnmarshalIntID added in v0.8.0 

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 added in v0.11.0 

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

func WithOperationContext added in v0.11.0 

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

func WithResponseContext added in v0.11.0 

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 added in v0.11.0 

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 added in v0.11.0 

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 added in v0.11.0 

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

Complexity calls ComplexityFunc.

func (*ExecutableSchemaMock) ComplexityCalls added in v0.11.0 

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 added in v0.11.0 

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

Exec calls ExecFunc.

func (*ExecutableSchemaMock) ExecCalls added in v0.11.0 

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 added in v0.11.0 

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

Schema calls SchemaFunc.

func (*ExecutableSchemaMock) SchemaCalls added in v0.11.0 

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

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

len(mockedExecutableSchema.SchemaCalls())

type ExtendedError 

type ExtendedError interface {
	Extensions() map[string]interface{}
}

type FieldContext added in v0.11.0 

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 added in v0.11.0 

func GetFieldContext(ctx context.Context) *FieldContext

func (*FieldContext) Path added in v0.11.0 

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

type FieldInterceptor added in v0.11.0 

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 added in v0.8.0 

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

func NewFieldSet added in v0.8.0 

func NewFieldSet(fields []CollectedField) *FieldSet

func (*FieldSet) Concurrently added in v0.8.0 

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

func (*FieldSet) Dispatch added in v0.8.0 

func (m *FieldSet) Dispatch()

func (*FieldSet) MarshalGQL added in v0.8.0 

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

type FieldStats added in v0.11.0 

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 added in v0.11.0 

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 added in v0.11.0 

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 added in v0.11.0 

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 added in v0.11.0 

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

Add adds a value to the cache.

func (MapCache) Get added in v0.11.0 

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 added in v0.9.0 

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 added in v0.8.0 

func MarshalInt32(i int32) Marshaler

func MarshalInt64 added in v0.8.0 

func MarshalInt64(i int64) Marshaler

func MarshalIntID added in v0.8.0 

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 added in v0.9.0 

func MarshalUpload(f Upload) Marshaler

type Mutation added in v0.8.0 

type Mutation struct{}

type NoCache added in v0.11.0 

type NoCache struct{}

func (NoCache) Add added in v0.11.0 

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

func (NoCache) Get added in v0.11.0 

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

type OperationContext added in v0.11.0 

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 added in v0.11.0 

func GetOperationContext(ctx context.Context) *OperationContext

func (*OperationContext) Error added in v0.11.0 

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 added in v0.11.0 

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) Validate added in v0.11.0 

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

type OperationContextMutator added in v0.11.0 

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 added in v0.11.0 

type OperationHandler func(ctx context.Context) ResponseHandler

type OperationInterceptor added in v0.11.0 

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 added in v0.11.0 

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

type OperationParameterMutator added in v0.11.0 

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 added in v0.8.0 

type Query struct{}

type RawParams added in v0.11.0 

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 added in v0.11.0 

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 deprecated 

type RequestContext = OperationContext

Deprecated: Please update all references to OperationContext instead

func GetRequestContext deprecated 

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 deprecated 

type ResolverContext = FieldContext

Deprecated: Use FieldContext instead

func GetResolverContext deprecated 

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 added in v0.11.0 

type ResponseHandler func(ctx context.Context) *Response

func OneShot 

func OneShot(resp *Response) ResponseHandler

type ResponseInterceptor added in v0.11.0 

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 added in v0.11.0 

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

type Stats added in v0.11.0 

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

func (*Stats) GetExtension added in v0.11.0 

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

func (*Stats) SetExtension added in v0.11.0 

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

type Status added in v0.11.0 

type Status int

type Subscription added in v0.8.0 

type Subscription struct{}

type TraceTiming added in v0.11.0 

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

type Transport added in v0.11.0 

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 added in v0.9.0 

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

func UnmarshalUpload added in v0.9.0 

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

type WriterFunc 

type WriterFunc func(writer io.Writer)

func (WriterFunc) MarshalGQL 

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

Source Files

View all Source files

Directories

Path Synopsis
apollotracing
debug
extension
lru
testserver
transport
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

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.