graphql

package module
v0.0.0-...-474a9cf Latest Latest
Warning

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

Go to latest
Published: Nov 18, 2015 License: MIT Imports: 14 Imported by: 0

README

graphql Build Status GoDoc Coverage Status

A work-in-progress implementation of GraphQL for Go.

Getting Started

To install the library, run:

go get github.com/graphql-go/graphql

The following is a simple example which defines a schema with a single hello string-type field and a Resolve method which returns the string world. A GraphQL query is performed against this schema with the resulting output printed in JSON format.

package main

import (
	"encoding/json"
	"fmt"
	"log"

	"github.com/graphql-go/graphql"
)

func main() {
	// Schema
	fields := graphql.FieldConfigMap{
		"hello": &graphql.FieldConfig{
			Type: graphql.String,
			Resolve: func(p graphql.GQLFRParams) interface{} {
				return "world"
			},
		},
	}
	rootQuery := graphql.ObjectConfig{Name: "RootQuery", Fields: fields}
	schemaConfig := graphql.SchemaConfig{Query: graphql.NewObject(rootQuery)}
	schema, err := graphql.NewSchema(schemaConfig)
	if err != nil {
		log.Fatalf("failed to create new schema, error: %v", err)
	}

	// Query
	query := `
		{
			hello
		}
	`
	params := graphql.Params{Schema: schema, RequestString: query}
	r := graphql.Graphql(params)
	if len(r.Errors) > 0 {
		log.Fatalf("failed to execute graphql operation, errors: %+v", r.Errors)
	}
	rJSON, _ := json.Marshal(r)
	fmt.Printf("%s \n", rJSON) // {“data”:{“hello”:”world”}}
}

For more complex examples, refer to the examples/ directory and graphql_test.go.

Origin and Current Direction

This project was originally a port of v0.4.3 of graphql-js (excluding the Validator), which was based on the July 2015 GraphQL specification. graphql is currently several versions behind graphql-js, however future efforts will be guided directly by the latest formal GraphQL specification (currently: October 2015).

Third Party Libraries
Name Author Description
graphql-go-handler Hafiz Ismail Middleware to handle GraphQL queries through HTTP requests.
graphql-relay-go Hafiz Ismail Lib to construct a graphql-go server supporting react-relay.
golang-relay-starter-kit Hafiz Ismail Barebones starting point for a Relay application with Golang GraphQL server.
Blog Posts
Roadmap
  • Lexer
  • Parser
  • Schema Parser
  • Printer
  • Schema Printer
  • Visitor
  • Executor
  • Validator
  • Examples
    • Basic Usage (see: PR-#21)
    • React/Relay
  • Alpha Release (v0.1)

The Validator is optional, per official GraphQL specification, but it would be a useful addition.

Documentation

Index

Constants

View Source
const (
	TypeKindScalar      = "SCALAR"
	TypeKindObject      = "OBJECT"
	TypeKindInterface   = "INTERFACE"
	TypeKindUnion       = "UNION"
	TypeKindEnum        = "ENUM"
	TypeKindInputObject = "INPUT_OBJECT"
	TypeKindList        = "LIST"
	TypeKindNonNull     = "NON_NULL"
)

Variables

View Source
var (
	MaxInt = 9007199254740991
	MinInt = -9007199254740991
)
View Source
var NAME_REGEXP, _ = regexp.Compile("^[_a-zA-Z][_a-zA-Z0-9]*$")

Functions

func FieldASTsToNodeASTs

func FieldASTsToNodeASTs(fieldASTs []*ast.Field) []ast.Node

func IsInputType

func IsInputType(ttype Type) bool

func IsOutputType

func IsOutputType(ttype Type) bool

func NewLocatedError

func NewLocatedError(err interface{}, nodes []ast.Node) *gqlerrors.Error

Types

type Abstract

type Abstract interface {
	ObjectType(value interface{}, info ResolveInfo) *Object
	PossibleTypes() []*Object
	IsPossibleType(ttype *Object) bool
}

These types may describe the parent context of a selection set.

type Argument

type Argument struct {
	PrivateName        string      `json:"name"`
	Type               Input       `json:"type"`
	DefaultValue       interface{} `json:"defaultValue"`
	PrivateDescription string      `json:"description"`
}

func (*Argument) Description

func (st *Argument) Description() string

func (*Argument) Error

func (st *Argument) Error() error

func (*Argument) Name

func (st *Argument) Name() string

func (*Argument) String

func (st *Argument) String() string

type ArgumentConfig

type ArgumentConfig struct {
	Type         Input       `json:"type"`
	DefaultValue interface{} `json:"defaultValue"`
	Description  string      `json:"description"`
}

type BuildExecutionCtxParams

type BuildExecutionCtxParams struct {
	Schema        Schema
	Root          interface{}
	AST           *ast.Document
	OperationName string
	Args          map[string]interface{}
	Errors        []gqlerrors.FormattedError
	Result        *Result
}

type CollectFieldsParams

type CollectFieldsParams struct {
	ExeContext           *ExecutionContext
	OperationType        *Object
	SelectionSet         *ast.SelectionSet
	Fields               map[string][]*ast.Field
	VisitedFragmentNames map[string]bool
}

type Composite

type Composite interface {
	Name() string
}

These types may describe the parent context of a selection set.

type Directive

type Directive struct {
	Name        string      `json:"name"`
	Description string      `json:"description"`
	Args        []*Argument `json:"args"`
	OnOperation bool        `json:"onOperation"`
	OnFragment  bool        `json:"onFragment"`
	OnField     bool        `json:"onField"`
}
var IncludeDirective *Directive = NewDirective(&Directive{
	Name: "include",
	Description: "Directs the executor to include this field or fragment only when " +
		"the `if` argument is true.",
	Args: []*Argument{
		&Argument{
			PrivateName:        "if",
			Type:               NewNonNull(Boolean),
			PrivateDescription: "Included when true.",
		},
	},
	OnOperation: false,
	OnFragment:  true,
	OnField:     true,
})

*

  • Used to conditionally include fields or fragments
var SkipDirective *Directive = NewDirective(&Directive{
	Name: "skip",
	Description: "Directs the executor to skip this field or fragment when the `if` " +
		"argument is true.",
	Args: []*Argument{
		&Argument{
			PrivateName:        "if",
			Type:               NewNonNull(Boolean),
			PrivateDescription: "Skipped when true.",
		},
	},
	OnOperation: false,
	OnFragment:  true,
	OnField:     true,
})

*

  • Used to conditionally skip (exclude) fields or fragments

func NewDirective

func NewDirective(config *Directive) *Directive

*

  • Directives are used by the GraphQL runtime as a way of modifying execution
  • behavior. Type system creators will usually not create these directly.

type Enum

type Enum struct {
	PrivateName        string `json:"name"`
	PrivateDescription string `json:"description"`
	// contains filtered or unexported fields
}

*

  • Enum Type Definition *
  • Some leaf values of requests and input values are Enums. GraphQL serializes
  • Enum values as strings, however internally Enums can be represented by any
  • kind of type, often integers. *
  • Example: *
  • var RGBType = new Enum({
  • name: 'RGB',
  • values: {
  • RED: { value: 0 },
  • GREEN: { value: 1 },
  • BLUE: { value: 2 }
  • }
  • }); *
  • Note: If a value is not provided in a definition, the name of the enum value
  • will be used as it's internal value.

func NewEnum

func NewEnum(config EnumConfig) *Enum

func (*Enum) Description

func (gt *Enum) Description() string

func (*Enum) Error

func (gt *Enum) Error() error

func (*Enum) Name

func (gt *Enum) Name() string

func (*Enum) ParseLiteral

func (gt *Enum) ParseLiteral(valueAST ast.Value) interface{}

func (*Enum) ParseValue

func (gt *Enum) ParseValue(value interface{}) interface{}

func (*Enum) Serialize

func (gt *Enum) Serialize(value interface{}) interface{}

func (*Enum) String

func (gt *Enum) String() string

func (*Enum) Values

func (gt *Enum) Values() []*EnumValueDefinition

type EnumConfig

type EnumConfig struct {
	Name        string             `json:"name"`
	Values      EnumValueConfigMap `json:"values"`
	Description string             `json:"description"`
}

type EnumValueConfig

type EnumValueConfig struct {
	Value             interface{} `json:"value"`
	DeprecationReason string      `json:"deprecationReason"`
	Description       string      `json:"description"`
}

type EnumValueConfigMap

type EnumValueConfigMap map[string]*EnumValueConfig

type EnumValueDefinition

type EnumValueDefinition struct {
	Name              string      `json:"name"`
	Value             interface{} `json:"value"`
	DeprecationReason string      `json:"deprecationReason"`
	Description       string      `json:"description"`
}

type ExecuteFieldsParams

type ExecuteFieldsParams struct {
	ExecutionContext *ExecutionContext
	ParentType       *Object
	Source           interface{}
	Fields           map[string][]*ast.Field
}

type ExecuteOperationParams

type ExecuteOperationParams struct {
	ExecutionContext *ExecutionContext
	Root             interface{}
	Operation        ast.Definition
}

type ExecuteParams

type ExecuteParams struct {
	Schema        Schema
	Root          interface{}
	AST           *ast.Document
	OperationName string
	Args          map[string]interface{}
}

type ExecutionContext

type ExecutionContext struct {
	Schema         Schema
	Fragments      map[string]ast.Definition
	Root           interface{}
	Operation      ast.Definition
	VariableValues map[string]interface{}
	Errors         []gqlerrors.FormattedError
}

type Field

type Field struct {
	Name              string              `json:"name"` // used by graphlql-relay
	Type              Output              `json:"type"`
	Args              FieldConfigArgument `json:"args"`
	Resolve           FieldResolveFn
	DeprecationReason string `json:"deprecationReason"`
	Description       string `json:"description"`
}

type FieldArgument

type FieldArgument struct {
	Name         string      `json:"name"`
	Type         Type        `json:"type"`
	DefaultValue interface{} `json:"defaultValue"`
	Description  string      `json:"description"`
}

type FieldConfigArgument

type FieldConfigArgument map[string]*ArgumentConfig

type FieldDefinition

type FieldDefinition struct {
	Name              string         `json:"name"`
	Description       string         `json:"description"`
	Type              Output         `json:"type"`
	Args              []*Argument    `json:"args"`
	Resolve           FieldResolveFn `json:"-"`
	DeprecationReason string         `json:"deprecationReason"`
}
var SchemaMetaFieldDef *FieldDefinition
var TypeMetaFieldDef *FieldDefinition
var TypeNameMetaFieldDef *FieldDefinition

type FieldDefinitionMap

type FieldDefinitionMap map[string]*FieldDefinition

type FieldResolveFn

type FieldResolveFn func(p ResolveParams) interface{}

TODO: relook at FieldResolveFn params

type Fields

type Fields map[string]*Field

type Input

type Input interface {
	Name() string
	Description() string
	String() string
	Error() error
}

These types may be used as input types for arguments and directives.

type InputObject

type InputObject struct {
	PrivateName        string `json:"name"`
	PrivateDescription string `json:"description"`
	// contains filtered or unexported fields
}

*

  • Input Object Type Definition *
  • An input object defines a structured collection of fields which may be
  • supplied to a field argument. *
  • Using `NonNull` will ensure that a value must be provided by the query *
  • Example: *
  • var GeoPoint = new InputObject({
  • name: 'GeoPoint',
  • fields: {
  • lat: { type: new NonNull(Float) },
  • lon: { type: new NonNull(Float) },
  • alt: { type: Float, defaultValue: 0 },
  • }
  • }); *

func NewInputObject

func NewInputObject(config InputObjectConfig) *InputObject

TODO: rename InputObjectConfig to GraphQLInputObjecTypeConfig for consistency?

func (*InputObject) Description

func (gt *InputObject) Description() string

func (*InputObject) Error

func (gt *InputObject) Error() error

func (*InputObject) Fields

func (gt *InputObject) Fields() InputObjectFieldMap

func (*InputObject) Name

func (gt *InputObject) Name() string

func (*InputObject) String

func (gt *InputObject) String() string

type InputObjectConfig

type InputObjectConfig struct {
	Name        string      `json:"name"`
	Fields      interface{} `json:"fields"`
	Description string      `json:"description"`
}

type InputObjectConfigFieldMap

type InputObjectConfigFieldMap map[string]*InputObjectFieldConfig

type InputObjectConfigFieldMapThunk

type InputObjectConfigFieldMapThunk func() InputObjectConfigFieldMap

type InputObjectField

type InputObjectField struct {
	PrivateName        string      `json:"name"`
	Type               Input       `json:"type"`
	DefaultValue       interface{} `json:"defaultValue"`
	PrivateDescription string      `json:"description"`
}

func (*InputObjectField) Description

func (st *InputObjectField) Description() string

func (*InputObjectField) Error

func (st *InputObjectField) Error() error

func (*InputObjectField) Name

func (st *InputObjectField) Name() string

func (*InputObjectField) String

func (st *InputObjectField) String() string

type InputObjectFieldConfig

type InputObjectFieldConfig struct {
	Type         Input       `json:"type"`
	DefaultValue interface{} `json:"defaultValue"`
	Description  string      `json:"description"`
}

type InputObjectFieldMap

type InputObjectFieldMap map[string]*InputObjectField

type Interface

type Interface struct {
	PrivateName        string `json:"name"`
	PrivateDescription string `json:"description"`
	ResolveType        ResolveTypeFn
	// contains filtered or unexported fields
}

*

  • Interface Type Definition *
  • When a field can return one of a heterogeneous set of types, a Interface type
  • is used to describe what types are possible, what fields are in common across
  • all types, as well as a function to determine which type is actually used
  • when the field is resolved. *
  • Example: *
  • var EntityType = new Interface({
  • name: 'Entity',
  • fields: {
  • name: { type: String }
  • }
  • }); *

func NewInterface

func NewInterface(config InterfaceConfig) *Interface

func (*Interface) AddFieldConfig

func (it *Interface) AddFieldConfig(fieldName string, fieldConfig *Field)

func (*Interface) Description

func (it *Interface) Description() string

func (*Interface) Error

func (it *Interface) Error() error

func (*Interface) Fields

func (it *Interface) Fields() (fields FieldDefinitionMap)

func (*Interface) IsPossibleType

func (it *Interface) IsPossibleType(ttype *Object) bool

func (*Interface) Name

func (it *Interface) Name() string

func (*Interface) ObjectType

func (it *Interface) ObjectType(value interface{}, info ResolveInfo) *Object

func (*Interface) PossibleTypes

func (it *Interface) PossibleTypes() []*Object

func (*Interface) String

func (it *Interface) String() string

type InterfaceConfig

type InterfaceConfig struct {
	Name        string `json:"name"`
	Fields      Fields `json:"fields"`
	ResolveType ResolveTypeFn
	Description string `json:"description"`
}

type InterfacesThunk

type InterfacesThunk func() []*Interface

type IsTypeOfFn

type IsTypeOfFn func(value interface{}, info ResolveInfo) bool

type List

type List struct {
	OfType Type `json:"ofType"`
	// contains filtered or unexported fields
}

*

  • List Modifier *
  • A list is a kind of type marker, a wrapping type which points to another
  • type. Lists are often created within the context of defining the fields of
  • an object type. *
  • Example: *
  • var PersonType = new Object({
  • name: 'Person',
  • fields: () => ({
  • parents: { type: new List(Person) },
  • children: { type: new List(Person) },
  • })
  • }) *

func NewList

func NewList(ofType Type) *List

func (*List) Description

func (gl *List) Description() string

func (*List) Error

func (gl *List) Error() error

func (*List) Name

func (gl *List) Name() string

func (*List) String

func (gl *List) String() string

type Named

type Named interface {
	String() string
}

These named types do not include modifiers like List or NonNull.

func GetNamed

func GetNamed(ttype Type) Named

type NonNull

type NonNull struct {
	PrivateName string `json:"name"` // added to conform with introspection for NonNull.Name = nil
	OfType      Type   `json:"ofType"`
	// contains filtered or unexported fields
}

*

  • Non-Null Modifier *
  • A non-null is a kind of type marker, a wrapping type which points to another
  • type. Non-null types enforce that their values are never null and can ensure
  • an error is raised if this ever occurs during a request. It is useful for
  • fields which you can make a strong guarantee on non-nullability, for example
  • usually the id field of a database row will never be null. *
  • Example: *
  • var RowType = new Object({
  • name: 'Row',
  • fields: () => ({
  • id: { type: new NonNull(String) },
  • })
  • }) *
  • Note: the enforcement of non-nullability occurs within the executor.

func NewNonNull

func NewNonNull(ofType Type) *NonNull

func (*NonNull) Description

func (gl *NonNull) Description() string

func (*NonNull) Error

func (gl *NonNull) Error() error

func (*NonNull) Name

func (gl *NonNull) Name() string

func (*NonNull) String

func (gl *NonNull) String() string

type Object

type Object struct {
	PrivateName        string `json:"name"`
	PrivateDescription string `json:"description"`
	IsTypeOf           IsTypeOfFn
	// contains filtered or unexported fields
}

*

  • Object Type Definition *
  • Almost all of the GraphQL types you define will be object Object types
  • have a name, but most importantly describe their fields. *
  • Example: *
  • var AddressType = new Object({
  • name: 'Address',
  • fields: {
  • street: { type: String },
  • number: { type: Int },
  • formatted: {
  • type: String,
  • resolve(obj) {
  • return obj.number + ' ' + obj.street
  • }
  • }
  • }
  • }); *
  • When two types need to refer to each other, or a type needs to refer to
  • itself in a field, you can use a function expression (aka a closure or a
  • thunk) to supply the fields lazily. *
  • Example: *
  • var PersonType = new Object({
  • name: 'Person',
  • fields: () => ({
  • name: { type: String },
  • bestFriend: { type: PersonType },
  • })
  • }); *

func NewObject

func NewObject(config ObjectConfig) *Object

func (*Object) AddFieldConfig

func (gt *Object) AddFieldConfig(fieldName string, fieldConfig *Field)

func (*Object) Description

func (gt *Object) Description() string

func (*Object) Error

func (gt *Object) Error() error

func (*Object) Fields

func (gt *Object) Fields() FieldDefinitionMap

func (*Object) Interfaces

func (gt *Object) Interfaces() []*Interface

func (*Object) Name

func (gt *Object) Name() string

func (*Object) String

func (gt *Object) String() string

type ObjectConfig

type ObjectConfig struct {
	Name        string      `json:"description"`
	Interfaces  interface{} `json:"interfaces"`
	Fields      Fields      `json:"fields"`
	IsTypeOf    IsTypeOfFn  `json:"isTypeOf"`
	Description string      `json:"description"`
}

type Output

type Output interface {
	Name() string
	Description() string
	String() string
	Error() error
}

These types may be used as output types as the result of fields.

type Params

type Params struct {
	Schema         Schema
	RequestString  string
	RootObject     map[string]interface{}
	VariableValues map[string]interface{}
	OperationName  string
}

type ParseLiteralFn

type ParseLiteralFn func(valueAST ast.Value) interface{}

type ParseValueFn

type ParseValueFn func(value interface{}) interface{}

type ResolveInfo

type ResolveInfo struct {
	FieldName      string
	FieldASTs      []*ast.Field
	ReturnType     Output
	ParentType     Composite
	Schema         Schema
	Fragments      map[string]ast.Definition
	RootValue      interface{}
	Operation      ast.Definition
	VariableValues map[string]interface{}
}

type ResolveParams

type ResolveParams struct {
	Source interface{}
	Args   map[string]interface{}
	Info   ResolveInfo
	Schema Schema
}

TODO: clean up GQLFRParams fields

type ResolveTypeFn

type ResolveTypeFn func(value interface{}, info ResolveInfo) *Object

type Result

type Result struct {
	Data   interface{}                `json:"data"`
	Errors []gqlerrors.FormattedError `json:"errors,omitempty"`
}

func Do

func Do(p Params) *Result

func Execute

func Execute(p ExecuteParams) (result *Result)

func (*Result) HasErrors

func (r *Result) HasErrors() bool

type Scalar

type Scalar struct {
	PrivateName        string `json:"name"`
	PrivateDescription string `json:"description"`
	// contains filtered or unexported fields
}

*

  • Scalar Type Definition *
  • The leaf values of any request and input values to arguments are
  • Scalars (or Enums) and are defined with a name and a series of functions
  • used to parse input from ast or variables and to ensure validity. *
  • Example: *
  • var OddType = new Scalar({
  • name: 'Odd',
  • serialize(value) {
  • return value % 2 === 1 ? value : null;
  • }
  • }); *
var Boolean *Scalar = NewScalar(ScalarConfig{
	Name:       "Boolean",
	Serialize:  coerceBool,
	ParseValue: coerceBool,
	ParseLiteral: func(valueAST ast.Value) interface{} {
		switch valueAST := valueAST.(type) {
		case *ast.BooleanValue:
			return valueAST.Value
		}
		return false
	},
})
var Float *Scalar = NewScalar(ScalarConfig{
	Name:       "Float",
	Serialize:  coerceFloat32,
	ParseValue: coerceFloat32,
	ParseLiteral: func(valueAST ast.Value) interface{} {
		switch valueAST := valueAST.(type) {
		case *ast.FloatValue:
			if floatValue, err := strconv.ParseFloat(valueAST.Value, 32); err == nil {
				return floatValue
			}
		case *ast.IntValue:
			if floatValue, err := strconv.ParseFloat(valueAST.Value, 32); err == nil {
				return floatValue
			}
		}
		return float32(0)
	},
})
var ID *Scalar = NewScalar(ScalarConfig{
	Name:       "ID",
	Serialize:  coerceString,
	ParseValue: coerceString,
	ParseLiteral: func(valueAST ast.Value) interface{} {
		switch valueAST := valueAST.(type) {
		case *ast.IntValue:
			return valueAST.Value
		case *ast.StringValue:
			return valueAST.Value
		}
		return ""
	},
})
var Int *Scalar = NewScalar(ScalarConfig{
	Name:       "Int",
	Serialize:  coerceInt,
	ParseValue: coerceInt,
	ParseLiteral: func(valueAST ast.Value) interface{} {
		switch valueAST := valueAST.(type) {
		case *ast.IntValue:
			if intValue, err := strconv.Atoi(valueAST.Value); err == nil {
				return intValue
			}
		}
		return nil
	},
})
var String *Scalar = NewScalar(ScalarConfig{
	Name:       "String",
	Serialize:  coerceString,
	ParseValue: coerceString,
	ParseLiteral: func(valueAST ast.Value) interface{} {
		switch valueAST := valueAST.(type) {
		case *ast.StringValue:
			return valueAST.Value
		}
		return ""
	},
})

func NewScalar

func NewScalar(config ScalarConfig) *Scalar

func (*Scalar) Description

func (st *Scalar) Description() string

func (*Scalar) Error

func (st *Scalar) Error() error

func (*Scalar) Name

func (st *Scalar) Name() string

func (*Scalar) ParseLiteral

func (st *Scalar) ParseLiteral(valueAST ast.Value) interface{}

func (*Scalar) ParseValue

func (st *Scalar) ParseValue(value interface{}) interface{}

func (*Scalar) Serialize

func (st *Scalar) Serialize(value interface{}) interface{}

func (*Scalar) String

func (st *Scalar) String() string

type ScalarConfig

type ScalarConfig struct {
	Name         string `json:"name"`
	Description  string `json:"description"`
	Serialize    SerializeFn
	ParseValue   ParseValueFn
	ParseLiteral ParseLiteralFn
}

type Schema

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

func NewSchema

func NewSchema(config SchemaConfig) (Schema, error)

func (*Schema) Directives

func (gq *Schema) Directives() []*Directive

func (*Schema) MutationType

func (gq *Schema) MutationType() *Object

func (*Schema) QueryType

func (gq *Schema) QueryType() *Object

func (*Schema) Type

func (gq *Schema) Type(name string) Type

func (*Schema) TypeMap

func (gq *Schema) TypeMap() TypeMap

type SchemaConfig

type SchemaConfig struct {
	Query    *Object
	Mutation *Object
}

* Schema Definition A Schema is created by supplying the root types of each type of operation, query and mutation (optional). A schema definition is then supplied to the validator and executor. Example:

myAppSchema, err := NewSchema(SchemaConfig({
  Query: MyAppQueryRootType
  Mutation: MyAppMutationRootType
});

type SerializeFn

type SerializeFn func(value interface{}) interface{}

type Type

type Type interface {
	Name() string
	Description() string
	String() string
	Error() error
}

These are all of the possible kinds of

type TypeMap

type TypeMap map[string]Type

chose to name as TypeMap instead of TypeMap

type Union

type Union struct {
	PrivateName        string `json:"name"`
	PrivateDescription string `json:"description"`
	ResolveType        ResolveTypeFn
	// contains filtered or unexported fields
}

*

  • Union Type Definition *
  • When a field can return one of a heterogeneous set of types, a Union type
  • is used to describe what types are possible as well as providing a function
  • to determine which type is actually used when the field is resolved. *
  • Example: *
  • var PetType = new Union({
  • name: 'Pet',
  • types: [ DogType, CatType ],
  • resolveType(value) {
  • if (value instanceof Dog) {
  • return DogType;
  • }
  • if (value instanceof Cat) {
  • return CatType;
  • }
  • }
  • }); *

func NewUnion

func NewUnion(config UnionConfig) *Union

func (*Union) Description

func (ut *Union) Description() string

func (*Union) Error

func (ut *Union) Error() error

func (*Union) IsPossibleType

func (ut *Union) IsPossibleType(ttype *Object) bool

func (*Union) Name

func (ut *Union) Name() string

func (*Union) ObjectType

func (ut *Union) ObjectType(value interface{}, info ResolveInfo) *Object

func (*Union) PossibleTypes

func (ut *Union) PossibleTypes() []*Object

func (*Union) String

func (ut *Union) String() string

type UnionConfig

type UnionConfig struct {
	Name        string    `json:"name"`
	Types       []*Object `json:"types"`
	ResolveType ResolveTypeFn
	Description string `json:"description"`
}

type ValidationResult

type ValidationResult struct {
	IsValid bool
	Errors  []gqlerrors.FormattedError
}

func ValidateDocument

func ValidateDocument(schema Schema, ast *ast.Document) (vr ValidationResult)

Directories

Path Synopsis
examples
language
ast

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL