graphql

type BatchResolver ¶

type BatchResolver func(ctx context.Context, sources []interface{}, args interface{}, selectionSet *SelectionSet) ([]interface{}, error)

A BatchResolver calculates the value of a field for a slice of objects.

type Directive ¶

type Directive struct {
	Name string
	Args interface{}
}

type Enum ¶

type Enum struct {
	Type       string
	Values     []string
	ReverseMap map[interface{}]string
}

Enum is a leaf value

func (e *Enum) String() string

type Executor ¶

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

func (e *Executor) Execute(ctx context.Context, typ Type, source interface{}, query *Query) (interface{}, error)

type Field ¶

type Field struct {
	Resolve        Resolver
	Type           Type
	Args           map[string]Type
	ParseArguments func(json interface{}) (interface{}, error)

	External  bool
	Expensive bool

	LazyExecution bool
	LazyResolver  func(ctx context.Context, fun interface{}) (interface{}, error)
}

Field knows how to compute field values of an Object

Fields are responsible for computing their value themselves.

type FragmentDefinition ¶

type FragmentDefinition struct {
	Name         string
	On           string
	SelectionSet *SelectionSet
}

A FragmentDefinition represents a reusable part of a GraphQL query

The On part of a FragmentDefinition represents the type of source object for which this FragmentDefinition should be used. That is not currently implemented in this package.

type FragmentSpread ¶

type FragmentSpread struct {
	Fragment   *FragmentDefinition
	Directives []*Directive
}

FragmentSpread represents a usage of a FragmentDefinition. Alongside the information about the fragment, it includes any directives used at that spread location.

type InputObject ¶

type InputObject struct {
	Name        string
	InputFields map[string]Type
}

InputObject defines the object in argument of a query, mutation or subscription

func (io *InputObject) String() string

type Interface ¶

type Interface struct {
	Name        string
	Description string
	Types       map[string]*Object
	Fields      map[string]*Field
}

Interface defines the graphql interface

func (i *Interface) String() string

type List ¶

type List struct {
	Type Type
}

List is a collection of other values

func (l *List) String() string

type NonNull ¶

type NonNull struct {
	Type Type
}

NonNull is a non-nullable other value

func (n *NonNull) String() string

type Object ¶

type Object struct {
	Name        string
	Description string
	KeyField    *Field
	Fields      map[string]*Field
	Interfaces  map[string]*Interface //For introspection only
}

Object is a value with several fields

func (o *Object) String() string

type Query ¶

type Query struct {
	Name string
	Kind string
	*SelectionSet
}

func Parse(source string, vars map[string]interface{}) (*Query, error)

type Resolver ¶

type Resolver func(ctx context.Context, source, args interface{}, selectionSet *SelectionSet) (interface{}, error)

A Resolver calculates the value of a field of an object

type Scalar ¶

type Scalar struct {
	Type      string
	Unwrapper func(interface{}) (interface{}, error)
}

Scalar is a leaf value. A custom "Unwrapper" can be attached to the scalar so it can have a custom unwrapping (if nil we will use the default unwrapper).

func (s *Scalar) String() string

type Schema ¶

type Schema struct {
	Query        Type
	Mutation     Type
	Subscription Type
}

Schema used to validate and resolve the queries

type Selection ¶

type Selection struct {
	Name         string
	Alias        string
	Args         interface{}
	SelectionSet *SelectionSet
	Directives   []*Directive

	UseBatch bool
	// contains filtered or unexported fields
}

Selection : A selection represents a part of a GraphQL query

The selection

me: user(id: 166) { name }

has name "user" (representing the source field to be queried), alias "me" (representing the name to be used in the output), args id: 166 (representing arguments passed to the source field to be queried), and subselection name representing the information to be queried from the resulting object.

func Flatten(selectionSet *SelectionSet) ([]*Selection, error)

{
  groups { name }
  groups { name id }
  ... on Organization { groups { widgets { name } } }
}

groups: { name name id { widgets { name } } }

type SelectionSet ¶

type SelectionSet struct {
	Selections []*Selection
	Fragments  []*FragmentSpread
}

SelectionSet represents a core GraphQL query

A SelectionSet can contain multiple fields and multiple fragments. For example, the query

{
  name
  ... UserFragment
  memberships {
    organization { name }
  }
}

results in a root SelectionSet with two selections (name and memberships), and one fragment (UserFragment). The subselection `organization { name }` is stored in the memberships selection.

Because GraphQL allows multiple fragments with the same name or alias, selections are stored in an array instead of a map.

type Type ¶

type Type interface {
	String() string
	// contains filtered or unexported methods
}

Type represents a GraphQL type, and should be either an Object, a Scalar, or a List

type Union ¶

type Union struct {
	Name        string
	Description string
	Types       map[string]*Object
}

Union is a option between multiple types

func (u *Union) String() string