graphql

type Argument ¶

type Argument struct {
	Type         Type
	DefaultValue interface{}
	Description  string
}

Argument mirrors GraphQL::Argument: a named input to a field.

type ArgumentMap ¶

type ArgumentMap map[string]*Argument

ArgumentMap maps argument names to their definitions.

type EnumType ¶

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

EnumType mirrors GraphQL::EnumType.

func NewEnumType(cfg EnumTypeConfig) *EnumType

type EnumTypeConfig ¶

type EnumTypeConfig struct {
	Name        string
	Description string
	Values      EnumValueMap
}

EnumTypeConfig configures an enum type.

type EnumValue ¶

type EnumValue struct {
	// Value is the internal Go value this enum member coerces to; when nil the
	// member's name is used, mirroring graphql-ruby.
	Value             interface{}
	Description       string
	DeprecationReason string
}

EnumValue mirrors a single graphql-ruby enum value definition.

type EnumValueMap ¶

type EnumValueMap map[string]*EnumValue

EnumValueMap maps enum member names to their definitions.

type ExecuteParams ¶

type ExecuteParams struct {
	Variables     map[string]interface{}
	Context       context.Context
	OperationName string
	RootValue     map[string]interface{}
}

ExecuteParams carries the optional keyword arguments of GraphQL::Schema#execute: query variables, a per-request context, the operation to run when the document defines several, and a root value handed to the query root's resolvers.

type ExecutionError ¶

type ExecutionError struct {
	Message string
	// Extensions is attached to the formatted error under "extensions", mirroring
	// graphql-ruby's error extensions.
	Extensions map[string]interface{}
}

ExecutionError mirrors GraphQL::ExecutionError. A resolver returns one (or any error) to signal a handled, client-facing failure: the field resolves to null and an entry is added to the response "errors" array with the field's path and source location, exactly as graphql-ruby does when a resolver raises a GraphQL::ExecutionError.

func NewExecutionError(message string) *ExecutionError

func (e *ExecutionError) Error() string

type Field ¶

type Field struct {
	Type              Type
	Description       string
	Args              ArgumentMap
	Resolve           ResolveFn
	DeprecationReason string
}

Field mirrors GraphQL::Field: a named, typed, resolvable member of an object or interface type.

type FieldMap ¶

type FieldMap map[string]*Field

FieldMap maps field names to their definitions.

type InputField ¶

type InputField struct {
	Type         Type
	DefaultValue interface{}
	Description  string
}

InputField mirrors a single field of an input object.

type InputFieldMap ¶

type InputFieldMap map[string]*InputField

InputFieldMap maps input-field names to their definitions.

type InputObjectType ¶

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

InputObjectType mirrors GraphQL::InputObjectType: a composite input type used for structured arguments.

func NewInputObjectType(cfg InputObjectTypeConfig) *InputObjectType

type InputObjectTypeConfig ¶

type InputObjectTypeConfig struct {
	Name        string
	Description string
	Fields      InputFieldMap
}

InputObjectTypeConfig configures an input object type.

type InterfaceType ¶

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

InterfaceType mirrors GraphQL::InterfaceType: an abstract type defining a set of fields that implementing object types must provide.

func NewInterfaceType(cfg InterfaceTypeConfig) *InterfaceType

type InterfaceTypeConfig ¶

type InterfaceTypeConfig struct {
	Name        string
	Description string
	Fields      FieldMap
	// ResolveType maps a runtime value to the concrete object type that
	// represents it, mirroring graphql-ruby's resolve_type hook.
	ResolveType func(value interface{}) *ObjectType
}

InterfaceTypeConfig configures an interface type.

type ObjectType ¶

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

ObjectType mirrors GraphQL::ObjectType: a composite type with named, resolvable fields. Query, Mutation and Subscription roots are ordinary object types.

func NewObjectType(cfg ObjectTypeConfig) *ObjectType

type ObjectTypeConfig ¶

type ObjectTypeConfig struct {
	Name        string
	Description string
	Fields      FieldMap
	// Interfaces lists the interface types this object implements.
	Interfaces []*InterfaceType
}

ObjectTypeConfig configures an object type.

type ResolveFn ¶

type ResolveFn func(p ResolveParams) (interface{}, error)

ResolveFn is the field-resolver seam: given the resolve parameters it returns the field's value or an error. Returning an *ExecutionError (or any error) collects a field error at the current path, matching graphql-ruby.

type ResolveParams ¶

type ResolveParams struct {
	Source  interface{}
	Args    map[string]interface{}
	Context context.Context
	// contains filtered or unexported fields
}

ResolveParams is passed to a field's resolver. It mirrors the object handed to a graphql-ruby resolver method: the parent object (Source), the coerced arguments (Args) and the per-request context.

type Result ¶

type Result map[string]interface{}

Result mirrors the Hash returned by GraphQL::Schema#execute. It always exposes a "data" key for a query that parsed and validated (its value may be nil), and an "errors" key holding the collected errors when any occurred. A query that fails to parse or validate carries only "errors", with no "data" key — the same shape graphql-ruby produces.

func (r Result) Data() map[string]interface{}

func (r Result) Errors() []map[string]interface{}

func (r Result) HasErrors() bool

type ScalarType ¶

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

ScalarType mirrors a GraphQL scalar (GraphQL::ScalarType). The five built-in scalars are exposed as the package-level values Int, Float, String, Boolean and ID; custom scalars are created with NewScalarType.

func NewScalarType(cfg ScalarTypeConfig) *ScalarType

type ScalarTypeConfig ¶

type ScalarTypeConfig struct {
	Name        string
	Description string
	// Serialize coerces an internal value to the value sent to the client
	// (graphql-ruby's coerce_result). Required.
	Serialize func(value interface{}) interface{}
	// ParseValue coerces a client-supplied value (a variable) to the internal
	// representation (graphql-ruby's coerce_input). Optional; required if the
	// scalar is used as an input type.
	ParseValue func(value interface{}) interface{}
}

ScalarTypeConfig configures a custom scalar. It mirrors a graphql-ruby custom scalar's coerce_result (Serialize) and coerce_input (ParseValue) hooks. The literal form used inside a query document is coerced with the same ParseValue function after the raw literal node is reduced to a Go value.

type Schema ¶

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

Schema mirrors GraphQL::Schema: a validated type system rooted at a query type (and optionally mutation and subscription types) against which query documents are executed.

func NewSchema(cfg SchemaConfig) (*Schema, error)

func (s *Schema) Execute(query string, params ...ExecuteParams) Result

type SchemaConfig ¶

type SchemaConfig struct {
	Query        *ObjectType
	Mutation     *ObjectType
	Subscription *ObjectType
	Types        []Type
}

SchemaConfig configures a schema. Query is required; Mutation and Subscription are optional root types. Types lists extra types that are not reachable from the roots by field traversal (for example the concrete members of a union that is only returned via an interface), mirroring graphql-ruby's orphan_types / extra type registration.

type Type ¶

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

Type is a member of the GraphQL type system. It mirrors the abstract GraphQL::Schema::Member hierarchy of graphql-ruby: every concrete type (scalars, objects, enums, interfaces, unions, input objects, and the List / NonNull wrappers) satisfies it, so it may be used as a field's return type or an argument's input type.

The underlying graphql-go type is intentionally hidden behind an unexported accessor so that callers program against this package's Ruby-flavoured surface rather than graphql-go directly.

func ListType(of Type) Type

func NonNullType(of Type) Type

type UnionType ¶

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

UnionType mirrors GraphQL::UnionType: a type that is exactly one of a fixed set of object types.

func NewUnionType(cfg UnionTypeConfig) *UnionType

type UnionTypeConfig ¶

type UnionTypeConfig struct {
	Name        string
	Description string
	Types       []*ObjectType
	// ResolveType maps a runtime value to its concrete member type.
	ResolveType func(value interface{}) *ObjectType
}

UnionTypeConfig configures a union type.