graphql

package module
Version: v0.4.18 Latest Latest
Warning

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

Go to latest
Published: May 30, 2016 License: MIT Imports: 17 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.Fields{
		"hello": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				return "world", nil
			},
		},
	}
	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.Do(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)

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 Boolean = NewScalar(ScalarConfig{
	Name:        "Boolean",
	Description: "The `Boolean` scalar type represents `true` or `false`.",
	Serialize:   coerceBool,
	ParseValue:  coerceBool,
	ParseLiteral: func(valueAST ast.Value) interface{} {
		switch valueAST := valueAST.(type) {
		case *ast.BooleanValue:
			return valueAST.Value
		}
		return nil
	},
})

Boolean is the GraphQL boolean type definition

View Source
var Float = NewScalar(ScalarConfig{
	Name: "Float",
	Description: "The `Float` scalar type represents signed double-precision fractional " +
		"values as specified by " +
		"[IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point). ",
	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 nil
	},
})

Float is the GraphQL float type definition.

View Source
var ID = NewScalar(ScalarConfig{
	Name: "ID",
	Description: "The `ID` scalar type represents a unique identifier, often used to " +
		"refetch an object or as key for a cache. The ID type appears in a JSON " +
		"response as a String; however, it is not intended to be human-readable. " +
		"When expected as an input type, any string (such as `\"4\"`) or integer " +
		"(such as `4`) input value will be accepted as an 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 nil
	},
})

ID is the GraphQL id type definition

View Source
var IncludeDirective = 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,
})

IncludeDirective is used to conditionally include fields or fragments

View Source
var Int = NewScalar(ScalarConfig{
	Name: "Int",
	Description: "The `Int` scalar type represents non-fractional signed whole numeric " +
		"values. Int can represent values between -(2^31) and 2^31 - 1. ",
	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
	},
})

Int is the GraphQL Integer type definition.

View Source
var NameRegExp, _ = regexp.Compile("^[_a-zA-Z][_a-zA-Z0-9]*$")
View Source
var SkipDirective = 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,
})

SkipDirective Used to conditionally skip (exclude) fields or fragments

SpecifiedRules set includes all validation rules defined by the GraphQL spec.

View Source
var String = NewScalar(ScalarConfig{
	Name: "String",
	Description: "The `String` scalar type represents textual data, represented as UTF-8 " +
		"character sequences. The String type is most often used by GraphQL to " +
		"represent free-form human-readable text.",
	Serialize:  coerceString,
	ParseValue: coerceString,
	ParseLiteral: func(valueAST ast.Value) interface{} {
		switch valueAST := valueAST.(type) {
		case *ast.StringValue:
			return valueAST.Value
		}
		return nil
	},
})

String is the GraphQL string type definition

Functions

func CycleErrorMessage

func CycleErrorMessage(fragName string, spreadNames []string) string

func FieldASTsToNodeASTs

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

func IsCompositeType

func IsCompositeType(ttype interface{}) bool

IsCompositeType determines if given type is a GraphQLComposite type

func IsInputType

func IsInputType(ttype Type) bool

IsInputType determines if given type is a GraphQLInputType

func IsLeafType

func IsLeafType(ttype Type) bool

IsLeafType determines if given type is a leaf value

func IsOutputType

func IsOutputType(ttype Type) bool

IsOutputType determines if given type is a GraphQLOutputType

func NewLocatedError

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

func UndefinedFieldMessage

func UndefinedFieldMessage(fieldName string, ttypeName string, suggestedTypes []string) string

func UndefinedVarMessage

func UndefinedVarMessage(varName string, opName string) string

func UnusedVariableMessage

func UnusedVariableMessage(varName string, opName string) string

func VisitUsingRules

func VisitUsingRules(schema *Schema, typeInfo *TypeInfo, astDoc *ast.Document, rules []ValidationRuleFn) []gqlerrors.FormattedError

VisitUsingRules This uses a specialized visitor which runs multiple visitors in parallel, while maintaining the visitor skip and break API.

@internal Had to expose it to unit test experimental customizable validation feature, but not meant for public consumption

Types

type Abstract

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

Abstract interface for types that 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
	Context       context.Context
}

type CollectFieldsParams

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

type Composite

type Composite interface {
	Name() string
}

Composite interface for types that 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"`
}

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

func NewDirective

func NewDirective(config *Directive) *Directive

type Enum

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

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{}

	// Context may be provided to pass application-specific per-request
	// information to resolve functions.
	Context context.Context
}

type ExecutionContext

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

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

func DefaultTypeInfoFieldDef

func DefaultTypeInfoFieldDef(schema *Schema, parentType Type, fieldAST *ast.Field) *FieldDefinition

DefaultTypeInfoFieldDef Not exactly the same as the executor's definition of FieldDef, in this statically evaluated environment we do not always have an Object type, and need to handle Interface and Union types.

type FieldDefinitionMap

type FieldDefinitionMap map[string]*FieldDefinition

type FieldResolveFn

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

type Fields

type Fields map[string]*Field

type FieldsThunk

type FieldsThunk func() Fields

type HasSelectionSet

type HasSelectionSet interface {
	GetKind() string
	GetLoc() *ast.Location
	GetSelectionSet() *ast.SelectionSet
}

type Input

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

Input interface for types that 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
}

InputObject 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

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      interface{} `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
}

Named interface for types that do not include modifiers like List or NonNull.

func GetNamed

func GetNamed(ttype Type) Named

GetNamed returns the Named type of the given GraphQL type

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
}

NonNull 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 Nullable

type Nullable interface {
}

Nullable interface for types that can accept null as a value.

func GetNullable

func GetNullable(ttype Type) Nullable

GetNullable returns the Nullable type of the given GraphQL type

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      interface{} `json:"fields"`
	IsTypeOf    IsTypeOfFn  `json:"isTypeOf"`
	Description string      `json:"description"`
}

type Output

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

Output interface for types that may be used as output types as the result of fields.

type Params

type Params struct {
	// The GraphQL type system to use when validating and executing a query.
	Schema Schema

	// A GraphQL language formatted string representing the requested operation.
	RequestString string

	// The value provided as the first argument to resolver functions on the top
	// level type (e.g. the query object type).
	RootObject map[string]interface{}

	// A mapping of variable name to runtime value to use for all variables
	// defined in the requestString.
	VariableValues map[string]interface{}

	// The name of the operation to use if requestString contains multiple
	// possible operations. Can be omitted if requestString contains only
	// one operation.
	OperationName string

	// Context may be provided to pass application-specific per-request
	// information to resolve functions.
	Context context.Context
}

type ParseLiteralFn

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

ParseLiteralFn is a function type for parsing the literal value of a GraphQLScalar type

type ParseValueFn

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

ParseValueFn is a function type for parsing the value of a GraphQLScalar type

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
	//This can be used to provide per-request state
	//from the application.
	Context context.Context
}

ResolveParams Params for FieldResolveFn() 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;
  }
});

func NewScalar

func NewScalar(config ScalarConfig) *Scalar

NewScalar creates a new GraphQLScalar

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
}

ScalarConfig options for creating a new GraphQLScalar

type Schema

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

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

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

func NewSchema

func NewSchema(config SchemaConfig) (Schema, error)

func (*Schema) Directive

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

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) SubscriptionType

func (gq *Schema) SubscriptionType() *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
	Subscription *Object
	Directives   []*Directive
}

type SerializeFn

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

SerializeFn is a function type for serializing a GraphQLScalar type value

type Type

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

Type interface for all of the possible kinds of GraphQL types

type TypeInfo

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

func NewTypeInfo

func NewTypeInfo(opts *TypeInfoConfig) *TypeInfo

func (*TypeInfo) Argument

func (ti *TypeInfo) Argument() *Argument

func (*TypeInfo) Directive

func (ti *TypeInfo) Directive() *Directive

func (*TypeInfo) Enter

func (ti *TypeInfo) Enter(node ast.Node)

func (*TypeInfo) FieldDef

func (ti *TypeInfo) FieldDef() *FieldDefinition

func (*TypeInfo) InputType

func (ti *TypeInfo) InputType() Input

func (*TypeInfo) Leave

func (ti *TypeInfo) Leave(node ast.Node)

func (*TypeInfo) ParentType

func (ti *TypeInfo) ParentType() Composite

func (*TypeInfo) Type

func (ti *TypeInfo) Type() Output

type TypeInfoConfig

type TypeInfoConfig struct {
	Schema *Schema

	// NOTE: this experimental optional second parameter is only needed in order
	// to support non-spec-compliant codebases. You should never need to use it.
	// It may disappear in the future.
	FieldDefFn fieldDefFn
}

type TypeMap

type TypeMap map[string]Type

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 ValidationContext

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

func NewValidationContext

func NewValidationContext(schema *Schema, astDoc *ast.Document, typeInfo *TypeInfo) *ValidationContext

func (*ValidationContext) Argument

func (ctx *ValidationContext) Argument() *Argument

func (*ValidationContext) Directive

func (ctx *ValidationContext) Directive() *Directive

func (*ValidationContext) Document

func (ctx *ValidationContext) Document() *ast.Document

func (*ValidationContext) Errors

func (ctx *ValidationContext) Errors() []gqlerrors.FormattedError

func (*ValidationContext) FieldDef

func (ctx *ValidationContext) FieldDef() *FieldDefinition

func (*ValidationContext) Fragment

func (ctx *ValidationContext) Fragment(name string) *ast.FragmentDefinition

func (*ValidationContext) FragmentSpreads

func (ctx *ValidationContext) FragmentSpreads(node HasSelectionSet) []*ast.FragmentSpread

func (*ValidationContext) InputType

func (ctx *ValidationContext) InputType() Input

func (*ValidationContext) ParentType

func (ctx *ValidationContext) ParentType() Composite

func (*ValidationContext) RecursiveVariableUsages

func (ctx *ValidationContext) RecursiveVariableUsages(operation *ast.OperationDefinition) []*VariableUsage

func (*ValidationContext) RecursivelyReferencedFragments

func (ctx *ValidationContext) RecursivelyReferencedFragments(operation *ast.OperationDefinition) []*ast.FragmentDefinition

func (*ValidationContext) ReportError

func (ctx *ValidationContext) ReportError(err error)

func (*ValidationContext) Schema

func (ctx *ValidationContext) Schema() *Schema

func (*ValidationContext) Type

func (ctx *ValidationContext) Type() Output

func (*ValidationContext) VariableUsages

func (ctx *ValidationContext) VariableUsages(node HasSelectionSet) []*VariableUsage

type ValidationResult

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

func ValidateDocument

func ValidateDocument(schema *Schema, astDoc *ast.Document, rules []ValidationRuleFn) (vr ValidationResult)

type ValidationRuleFn

type ValidationRuleFn func(context *ValidationContext) *ValidationRuleInstance

type ValidationRuleInstance

type ValidationRuleInstance struct {
	VisitorOpts *visitor.VisitorOptions
}

func ArgumentsOfCorrectTypeRule

func ArgumentsOfCorrectTypeRule(context *ValidationContext) *ValidationRuleInstance

ArgumentsOfCorrectTypeRule Argument values of correct type

A GraphQL document is only valid if all field argument literal values are of the type expected by their position.

func DefaultValuesOfCorrectTypeRule

func DefaultValuesOfCorrectTypeRule(context *ValidationContext) *ValidationRuleInstance

DefaultValuesOfCorrectTypeRule Variable default values of correct type

A GraphQL document is only valid if all variable default values are of the type expected by their definition.

func FieldsOnCorrectTypeRule

func FieldsOnCorrectTypeRule(context *ValidationContext) *ValidationRuleInstance

FieldsOnCorrectTypeRule Fields on correct type

A GraphQL document is only valid if all fields selected are defined by the parent type, or are an allowed meta field such as __typenamme

func FragmentsOnCompositeTypesRule

func FragmentsOnCompositeTypesRule(context *ValidationContext) *ValidationRuleInstance

FragmentsOnCompositeTypesRule Fragments on composite type

Fragments use a type condition to determine if they apply, since fragments can only be spread into a composite type (object, interface, or union), the type condition must also be a composite type.

func KnownArgumentNamesRule

func KnownArgumentNamesRule(context *ValidationContext) *ValidationRuleInstance

KnownArgumentNamesRule Known argument names

A GraphQL field is only valid if all supplied arguments are defined by that field.

func KnownDirectivesRule

func KnownDirectivesRule(context *ValidationContext) *ValidationRuleInstance

KnownDirectivesRule Known directives

A GraphQL document is only valid if all `@directives` are known by the schema and legally positioned.

func KnownFragmentNamesRule

func KnownFragmentNamesRule(context *ValidationContext) *ValidationRuleInstance

KnownFragmentNamesRule Known fragment names

A GraphQL document is only valid if all `...Fragment` fragment spreads refer to fragments defined in the same document.

func KnownTypeNamesRule

func KnownTypeNamesRule(context *ValidationContext) *ValidationRuleInstance

KnownTypeNamesRule Known type names

A GraphQL document is only valid if referenced types (specifically variable definitions and fragment conditions) are defined by the type schema.

func LoneAnonymousOperationRule

func LoneAnonymousOperationRule(context *ValidationContext) *ValidationRuleInstance

LoneAnonymousOperationRule Lone anonymous operation

A GraphQL document is only valid if when it contains an anonymous operation (the query short-hand) that it contains only that one operation definition.

func NoFragmentCyclesRule

func NoFragmentCyclesRule(context *ValidationContext) *ValidationRuleInstance

NoFragmentCyclesRule No fragment cycles

func NoUndefinedVariablesRule

func NoUndefinedVariablesRule(context *ValidationContext) *ValidationRuleInstance

NoUndefinedVariablesRule No undefined variables

A GraphQL operation is only valid if all variables encountered, both directly and via fragment spreads, are defined by that operation.

func NoUnusedFragmentsRule

func NoUnusedFragmentsRule(context *ValidationContext) *ValidationRuleInstance

NoUnusedFragmentsRule No unused fragments

A GraphQL document is only valid if all fragment definitions are spread within operations, or spread within other fragments spread within operations.

func NoUnusedVariablesRule

func NoUnusedVariablesRule(context *ValidationContext) *ValidationRuleInstance

NoUnusedVariablesRule No unused variables

A GraphQL operation is only valid if all variables defined by an operation are used, either directly or within a spread fragment.

func OverlappingFieldsCanBeMergedRule

func OverlappingFieldsCanBeMergedRule(context *ValidationContext) *ValidationRuleInstance

OverlappingFieldsCanBeMergedRule Overlapping fields can be merged

A selection set is only valid if all fields (including spreading any fragments) either correspond to distinct response names or can be merged without ambiguity.

func PossibleFragmentSpreadsRule

func PossibleFragmentSpreadsRule(context *ValidationContext) *ValidationRuleInstance

PossibleFragmentSpreadsRule Possible fragment spread

A fragment spread is only valid if the type condition could ever possibly be true: if there is a non-empty intersection of the possible parent types, and possible types which pass the type condition.

func ProvidedNonNullArgumentsRule

func ProvidedNonNullArgumentsRule(context *ValidationContext) *ValidationRuleInstance

ProvidedNonNullArgumentsRule Provided required arguments

A field or directive is only valid if all required (non-null) field arguments have been provided.

func ScalarLeafsRule

func ScalarLeafsRule(context *ValidationContext) *ValidationRuleInstance

ScalarLeafsRule Scalar leafs

A GraphQL document is valid only if all leaf fields (fields without sub selections) are of scalar or enum types.

func UniqueArgumentNamesRule

func UniqueArgumentNamesRule(context *ValidationContext) *ValidationRuleInstance

UniqueArgumentNamesRule Unique argument names

A GraphQL field or directive is only valid if all supplied arguments are uniquely named.

func UniqueFragmentNamesRule

func UniqueFragmentNamesRule(context *ValidationContext) *ValidationRuleInstance

UniqueFragmentNamesRule Unique fragment names

A GraphQL document is only valid if all defined fragments have unique names.

func UniqueInputFieldNamesRule

func UniqueInputFieldNamesRule(context *ValidationContext) *ValidationRuleInstance

UniqueInputFieldNamesRule Unique input field names

A GraphQL input object value is only valid if all supplied fields are uniquely named.

func UniqueOperationNamesRule

func UniqueOperationNamesRule(context *ValidationContext) *ValidationRuleInstance

UniqueOperationNamesRule Unique operation names

A GraphQL document is only valid if all defined operations have unique names.

func UniqueVariableNamesRule

func UniqueVariableNamesRule(context *ValidationContext) *ValidationRuleInstance

UniqueVariableNamesRule Unique variable names

A GraphQL operation is only valid if all its variables are uniquely named.

func VariablesAreInputTypesRule

func VariablesAreInputTypesRule(context *ValidationContext) *ValidationRuleInstance

VariablesAreInputTypesRule Variables are input types

A GraphQL operation is only valid if all the variables it defines are of input types (scalar, enum, or input object).

func VariablesInAllowedPositionRule

func VariablesInAllowedPositionRule(context *ValidationContext) *ValidationRuleInstance

VariablesInAllowedPositionRule Variables passed to field arguments conform to type

type VariableUsage

type VariableUsage struct {
	Node *ast.Variable
	Type Input
}

Directories

Path Synopsis
examples
language
ast

Jump to

Keyboard shortcuts

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