ast

type Argument ¶

type Argument struct {
	Name       Ident
	Value      Value
	Directives DirectiveList
}

Argument is a representation of the GraphQL Argument.

https://spec.graphql.org/draft/#sec-Language.Arguments

type ArgumentList ¶

type ArgumentList []*Argument

ArgumentList is a collection of GraphQL Arguments.

func (l ArgumentList) Get(name string) (Value, bool)

func (l ArgumentList) MustGet(name string) Value

type ArgumentsDefinition ¶

type ArgumentsDefinition []*InputValueDefinition

func (a ArgumentsDefinition) Get(name string) *InputValueDefinition

func (a ArgumentsDefinition) Names() []string

type Directive ¶

type Directive struct {
	Name      Ident
	Arguments ArgumentList
}

Directive is a representation of the GraphQL Directive.

http://spec.graphql.org/draft/#sec-Language.Directives

type DirectiveDefinition ¶

type DirectiveDefinition struct {
	Name       string
	Desc       string
	Repeatable bool
	Locations  []string
	Arguments  ArgumentsDefinition
	Loc        errors.Location
}

DirectiveDefinition is a representation of the GraphQL DirectiveDefinition.

http://spec.graphql.org/draft/#sec-Type-System.Directives

type DirectiveList ¶

type DirectiveList []*Directive

func (l DirectiveList) Get(name string) *Directive

type EnumTypeDefinition ¶

type EnumTypeDefinition struct {
	Name                 string
	EnumValuesDefinition []*EnumValueDefinition
	Desc                 string
	Directives           DirectiveList
	Loc                  errors.Location
}

EnumTypeDefinition defines a set of possible enum values.

Like scalar types, an EnumTypeDefinition also represents a leaf value in a GraphQL type system.

http://spec.graphql.org/draft/#sec-Enums

func (t *EnumTypeDefinition) Description() string

func (*EnumTypeDefinition) Kind() string

func (t *EnumTypeDefinition) String() string

func (t *EnumTypeDefinition) TypeName() string

type EnumValueDefinition ¶

type EnumValueDefinition struct {
	EnumValue  string
	Directives DirectiveList
	Desc       string
	Loc        errors.Location
}

EnumValueDefinition are unique values that may be serialized as a string: the name of the represented value.

http://spec.graphql.org/draft/#EnumValueDefinition

type ExecutableDefinition ¶

type ExecutableDefinition struct {
	Operations OperationList
	Fragments  FragmentList
}

ExecutableDefinition represents a set of operations or fragments that can be executed against a schema.

http://spec.graphql.org/draft/#ExecutableDefinition

type Extension ¶

type Extension struct {
	Type       NamedType
	Directives DirectiveList
	Loc        errors.Location
}

Extension type defines a GraphQL type extension. Schemas, Objects, Inputs and Scalars can be extended.

https://spec.graphql.org/draft/#sec-Type-System-Extensions

type Field ¶

type Field struct {
	Alias           Ident
	Name            Ident
	Arguments       ArgumentList
	Directives      DirectiveList
	SelectionSet    SelectionSet
	SelectionSetLoc errors.Location
}

Field represents a field used in a query.

type FieldDefinition ¶

type FieldDefinition struct {
	Name       string
	Arguments  ArgumentsDefinition
	Type       Type
	Directives DirectiveList
	Desc       string
	Loc        errors.Location
}

FieldDefinition is a representation of a GraphQL FieldDefinition.

http://spec.graphql.org/draft/#FieldDefinition

type FieldsDefinition ¶

type FieldsDefinition []*FieldDefinition

FieldsDefinition is a list of an ObjectTypeDefinition's Fields.

https://spec.graphql.org/draft/#FieldsDefinition

func (l FieldsDefinition) Get(name string) *FieldDefinition

func (l FieldsDefinition) Names() []string

type Fragment ¶

type Fragment struct {
	On         TypeName
	Selections SelectionSet
}

type FragmentDefinition ¶

type FragmentDefinition struct {
	Fragment
	Name       Ident
	Directives DirectiveList
	Loc        errors.Location
}

FragmentDefinition is a representation of the GraphQL FragmentDefinition.

http://spec.graphql.org/draft/#FragmentDefinition

type FragmentList ¶

type FragmentList []*FragmentDefinition

func (l FragmentList) Get(name string) *FragmentDefinition

type FragmentSpread ¶

type FragmentSpread struct {
	Name       Ident
	Directives DirectiveList
	Loc        errors.Location
}

FragmentSpread is a representation of the GraphQL FragmentSpread.

http://spec.graphql.org/draft/#FragmentSpread

type Ident ¶

type Ident struct {
	Name string
	Loc  errors.Location
}

type InlineFragment ¶

type InlineFragment struct {
	Fragment
	Directives DirectiveList
	Loc        errors.Location
}

InlineFragment is a representation of the GraphQL InlineFragment.

http://spec.graphql.org/draft/#InlineFragment

type InputObject ¶

type InputObject struct {
	Name       string
	Desc       string
	Values     ArgumentsDefinition
	Directives DirectiveList
	Loc        errors.Location
}

InputObject types define a set of input fields; the input fields are either scalars, enums, or other input objects.

This allows arguments to accept arbitrarily complex structs.

http://spec.graphql.org/draft/#sec-Input-Objects

func (t *InputObject) Description() string

func (*InputObject) Kind() string

func (t *InputObject) String() string

func (t *InputObject) TypeName() string

type InputValueDefinition ¶

type InputValueDefinition struct {
	Name       Ident
	Type       Type
	Default    Value
	Desc       string
	Directives DirectiveList
	Loc        errors.Location
	TypeLoc    errors.Location
}

InputValueDefinition is a representation of the GraphQL InputValueDefinition.

http://spec.graphql.org/draft/#InputValueDefinition

type InputValueDefinitionList ¶

type InputValueDefinitionList []*InputValueDefinition

func (l InputValueDefinitionList) Get(name string) *InputValueDefinition

type InterfaceTypeDefinition ¶

type InterfaceTypeDefinition struct {
	Name          string
	PossibleTypes []*ObjectTypeDefinition
	Fields        FieldsDefinition
	Desc          string
	Directives    DirectiveList
	Loc           errors.Location
	Interfaces    []*InterfaceTypeDefinition
}

InterfaceTypeDefinition recusrively defines list of named fields with their arguments via the implementation chain of interfaces.

GraphQL objects can then implement these interfaces which requires that the object type will define all fields defined by those interfaces.

http://spec.graphql.org/draft/#sec-Interfaces

func (t *InterfaceTypeDefinition) Description() string

func (*InterfaceTypeDefinition) Kind() string

func (t *InterfaceTypeDefinition) String() string

func (t *InterfaceTypeDefinition) TypeName() string

type List ¶

type List struct {
	// OfType represents the inner-type of a List type.
	// For example, the List type `[Foo]` has an OfType of Foo.
	OfType Type
}

List represents a GraphQL ListType.

http://spec.graphql.org/draft/#ListType

func (*List) Kind() string

func (t *List) String() string

type ListValue ¶

type ListValue struct {
	Values []Value
	Loc    errors.Location
}

ListValue represents a literal list Value in the GraphQL specification.

http://spec.graphql.org/draft/#sec-List-Value

func (val *ListValue) Deserialize(vars map[string]interface{}) interface{}

func (val *ListValue) Location() errors.Location

func (val *ListValue) String() string

type NamedType ¶

type NamedType interface {
	Type
	TypeName() string
	Description() string
}

NamedType represents a type with a name.

http://spec.graphql.org/draft/#NamedType

type NonNull ¶

type NonNull struct {
	// OfType represents the inner-type of a NonNull type.
	// For example, the NonNull type `Foo!` has an OfType of Foo.
	OfType Type
}

NonNull represents a GraphQL NonNullType.

https://spec.graphql.org/draft/#NonNullType

func (*NonNull) Kind() string

func (t *NonNull) String() string

type NullValue ¶

type NullValue struct {
	Loc errors.Location
}

NullValue represents a literal `null` Value in the GraphQL specification.

http://spec.graphql.org/draft/#sec-Null-Value

func (val *NullValue) Deserialize(vars map[string]interface{}) interface{}

func (val *NullValue) Location() errors.Location

func (val *NullValue) String() string

type ObjectField ¶

type ObjectField struct {
	Name  Ident
	Value Value
}

ObjectField represents field/value pairs in a literal ObjectValue.

type ObjectTypeDefinition ¶

type ObjectTypeDefinition struct {
	Name           string
	Interfaces     []*InterfaceTypeDefinition
	Fields         FieldsDefinition
	Desc           string
	Directives     DirectiveList
	InterfaceNames []string
	Loc            errors.Location
}

ObjectTypeDefinition represents a GraphQL ObjectTypeDefinition.

type FooObject {
		foo: String
}

https://spec.graphql.org/draft/#sec-Objects

func (t *ObjectTypeDefinition) Description() string

func (*ObjectTypeDefinition) Kind() string

func (t *ObjectTypeDefinition) String() string

func (t *ObjectTypeDefinition) TypeName() string

type ObjectValue ¶

type ObjectValue struct {
	Fields []*ObjectField
	Loc    errors.Location
}

ObjectValue represents a literal object Value in the GraphQL specification.

http://spec.graphql.org/draft/#sec-Object-Value

func (val *ObjectValue) Deserialize(vars map[string]interface{}) interface{}

func (val *ObjectValue) Location() errors.Location

func (val *ObjectValue) String() string

type OperationDefinition ¶

type OperationDefinition struct {
	Type       OperationType
	Name       Ident
	Vars       ArgumentsDefinition
	Selections SelectionSet
	Directives DirectiveList
	Loc        errors.Location
}

OperationDefinition represents a GraphQL Operation.

https://spec.graphql.org/draft/#sec-Language.Operations

type OperationList ¶

type OperationList []*OperationDefinition

func (l OperationList) Get(name string) *OperationDefinition

type OperationType ¶

type OperationType string

type PrimitiveValue ¶

type PrimitiveValue struct {
	Type rune
	Text string
	Loc  errors.Location
}

PrimitiveValue represents one of the following GraphQL scalars: Int, Float, String, or Boolean

func (val *PrimitiveValue) Deserialize(vars map[string]interface{}) interface{}

func (val *PrimitiveValue) Location() errors.Location

func (val *PrimitiveValue) String() string

type ScalarTypeDefinition ¶

type ScalarTypeDefinition struct {
	Name       string
	Desc       string
	Directives DirectiveList
	Loc        errors.Location
}

ScalarTypeDefinition types represent primitive leaf values (e.g. a string or an integer) in a GraphQL type system.

GraphQL responses take the form of a hierarchical tree; the leaves on these trees are GraphQL scalars.

http://spec.graphql.org/draft/#sec-Scalars

func (t *ScalarTypeDefinition) Description() string

func (*ScalarTypeDefinition) Kind() string

func (t *ScalarTypeDefinition) String() string

func (t *ScalarTypeDefinition) TypeName() string

type Schema ¶

type Schema struct {
	// SchemaDefinition corresponds to the `schema` sdl keyword.
	SchemaDefinition

	// Types are the fundamental unit of any GraphQL schema.
	// There are six kinds of named type definitions in GraphQL, and two wrapping types.
	//
	// http://spec.graphql.org/draft/#sec-Types
	Types map[string]NamedType

	// Directives are used to annotate various parts of a GraphQL document as an indicator that they
	// should be evaluated differently by a validator, executor, or client tool such as a code
	// generator.
	//
	// http://spec.graphql.org/#sec-Type-System.Directives
	Directives map[string]*DirectiveDefinition

	Objects      []*ObjectTypeDefinition
	Unions       []*Union
	Enums        []*EnumTypeDefinition
	Extensions   []*Extension
	SchemaString string
}

Schema represents a GraphQL service's collective type system capabilities. A schema is defined in terms of the types and directives it supports as well as the root operation types for each kind of operation: `query`, `mutation`, and `subscription`.

For a more formal definition, read the relevant section in the specification:

http://spec.graphql.org/draft/#sec-Schema

func (s *Schema) Resolve(name string) Type

type SchemaDefinition ¶

type SchemaDefinition struct {
	// Present is true if the schema definition is not omitted, false otherwise. For example, in the following schema
	//
	//	type Query {
	//		hello: String!
	//	}
	//
	// the schema keyword is omitted since the default name for Query is used. In that case Present would be false.
	Present bool

	// RootOperationTypes determines the place in the type system where `query`, `mutation`, and
	// `subscription` operations begin.
	//
	// http://spec.graphql.org/draft/#sec-Root-Operation-Types
	RootOperationTypes map[string]NamedType

	EntryPointNames map[string]string
	Desc            string
	Directives      DirectiveList
	Loc             errors.Location
}

SchemaDefinition is an optional schema block. If the schema definition is present it might contain a description and directives. It also contains a map of root operations. For example:

schema {
  query: Query
  mutation: Mutation
  subscription: Subscription
}

type Query {
  # query fields go here
}

type Mutation {
  # mutation fields go here
}

type Subscription {
  # subscription fields go here
}

If the root operations have default names (i.e. Query, Mutation and Subscription), then the schema definition can be omitted. For example, this is equivalent to the above schema:

type Query {
  # query fields go here
}

type Mutation {
  # mutation fields go here
}

type Subscription {
  # subscription fields go here
}

https://spec.graphql.org/October2021/#sec-Schema

type Selection ¶

type Selection interface {
	// contains filtered or unexported methods
}

A Selection is a field requested in a GraphQL operation.

http://spec.graphql.org/draft/#Selection

type SelectionSet ¶

type SelectionSet []Selection

A SelectionSet represents a collection of Selections

http://spec.graphql.org/draft/#sec-Selection-Sets

type Type ¶

type Type interface {
	// Kind returns one possible GraphQL type kind. A type kind must be
	// valid as defined by the GraphQL spec.
	//
	// https://spec.graphql.org/draft/#sec-Type-Kinds
	Kind() string

	// String serializes a Type into a GraphQL specification format type.
	//
	// http://spec.graphql.org/draft/#sec-Serialization-Format
	String() string
}

type TypeName ¶

type TypeName struct {
	Ident
}

TypeName is a base building block for GraphQL type references.

func (*TypeName) Kind() string

func (*TypeName) String() string

type Union ¶

type Union struct {
	Name             string
	UnionMemberTypes []*ObjectTypeDefinition
	Desc             string
	Directives       DirectiveList
	TypeNames        []string
	Loc              errors.Location
}

Union types represent objects that could be one of a list of GraphQL object types, but provides no guaranteed fields between those types.

They also differ from interfaces in that object types declare what interfaces they implement, but are not aware of what unions contain them.

http://spec.graphql.org/draft/#sec-Unions

func (t *Union) Description() string

func (*Union) Kind() string

func (t *Union) String() string

func (t *Union) TypeName() string

type Value ¶

type Value interface {
	// Deserialize transforms a GraphQL specification format literal into a Go type.
	Deserialize(vars map[string]interface{}) interface{}

	// String serializes a Value into a GraphQL specification format literal.
	String() string
	Location() errors.Location
}

Value represents a literal input or literal default value in the GraphQL Specification.

http://spec.graphql.org/draft/#sec-Input-Values

type Variable ¶

type Variable struct {
	Name string
	Loc  errors.Location
}

Variable is used in GraphQL operations to parameterize an input value.

http://spec.graphql.org/draft/#Variable

func (v Variable) Deserialize(vars map[string]interface{}) interface{}

func (v *Variable) Location() errors.Location

func (v Variable) String() string