resolvers

type Cache struct {
	// contains filtered or unexported fields
}

type DirectiveResolver struct {
	Directive string
	Create    func(request *ResolveRequest, next Resolution, args map[string]interface{}) Resolution
}

type ExecutionContext interface {
	GetRoot() interface{}
	FireSubscriptionEvent(value reflect.Value, err error)
	FireSubscriptionClose()
	GetSchema() *schema.Schema
	GetContext() context.Context
	GetLimiter() *chan byte
	HandlePanic(selectionPath []string) error
	GetQuery() string
	GetDocument() *schema.QueryDocument
	GetOperation() *schema.Operation
	GetVars() map[string]interface{}
}

type Func func(request *ResolveRequest, next Resolution) Resolution

type RawMessage json.RawMessage

type Resolution func() (reflect.Value, error)

type ResolveRequest struct {
	Context          context.Context
	ExecutionContext ExecutionContext
	ParentResolve    *ResolveRequest
	SelectionPath    func() []string
	ParentType       schema.Type
	Parent           reflect.Value
	Field            *schema.Field
	Args             map[string]interface{}
	Selection        *schema.FieldSelection
}

type Resolver interface {
	// Resolve allows you to inspect a ResolveRequest to see if your resolver can resolve it.
	// If you can resolve it, return a new Resolution that computes the value of the field.
	// If you don't know how to resolve that request, return next.
	//
	// The next variable hold the Resolution of the previous resolver, this allows your resolver
	// to filter it's results.  next may be nil if no resolution has been found yet.
	Resolve(request *ResolveRequest, next Resolution) Resolution
}

type ResolverList []Resolver

type TypeAndFieldKey struct {
	Type  string
	Field string
}

type TypeAndFieldResolver map[TypeAndFieldKey]Func

type TypeResolver map[string]Resolver

type ValueWithContext struct {
	Value   reflect.Value
	Context context.Context
}