Documentation ¶
Index ¶
- Constants
- Variables
- func FieldASTsToNodeASTs(fieldASTs []*ast.Field) []ast.Node
- func IsInputType(ttype Type) bool
- func IsOutputType(ttype Type) bool
- func NewLocatedError(err interface{}, nodes []ast.Node) *gqlerrors.Error
- type Abstract
- type Argument
- type ArgumentConfig
- type BuildExecutionCtxParams
- type CollectFieldsParams
- type Composite
- type Directive
- type Enum
- func (gt *Enum) Description() string
- func (gt *Enum) Error() error
- func (gt *Enum) Name() string
- func (gt *Enum) ParseLiteral(valueAST ast.Value) interface{}
- func (gt *Enum) ParseValue(value interface{}) interface{}
- func (gt *Enum) Serialize(value interface{}) interface{}
- func (gt *Enum) String() string
- func (gt *Enum) Values() []*EnumValueDefinition
- type EnumConfig
- type EnumValueConfig
- type EnumValueConfigMap
- type EnumValueDefinition
- type ExecuteFieldsParams
- type ExecuteOperationParams
- type ExecuteParams
- type ExecutionContext
- type Field
- type FieldArgument
- type FieldConfigArgument
- type FieldDefinition
- type FieldDefinitionMap
- type FieldResolveFn
- type Fields
- type Input
- type InputObject
- type InputObjectConfig
- type InputObjectConfigFieldMap
- type InputObjectConfigFieldMapThunk
- type InputObjectField
- type InputObjectFieldConfig
- type InputObjectFieldMap
- type Interface
- func (it *Interface) AddFieldConfig(fieldName string, fieldConfig *Field)
- func (it *Interface) Description() string
- func (it *Interface) Error() error
- func (it *Interface) Fields() (fields FieldDefinitionMap)
- func (it *Interface) IsPossibleType(ttype *Object) bool
- func (it *Interface) Name() string
- func (it *Interface) ObjectType(value interface{}, info ResolveInfo) *Object
- func (it *Interface) PossibleTypes() []*Object
- func (it *Interface) String() string
- type InterfaceConfig
- type InterfacesThunk
- type IsTypeOfFn
- type List
- type Named
- type NonNull
- type Object
- type ObjectConfig
- type Output
- type Params
- type ParseLiteralFn
- type ParseValueFn
- type ResolveInfo
- type ResolveParams
- type ResolveTypeFn
- type Result
- type Scalar
- func (st *Scalar) Description() string
- func (st *Scalar) Error() error
- func (st *Scalar) Name() string
- func (st *Scalar) ParseLiteral(valueAST ast.Value) interface{}
- func (st *Scalar) ParseValue(value interface{}) interface{}
- func (st *Scalar) Serialize(value interface{}) interface{}
- func (st *Scalar) String() string
- type ScalarConfig
- type Schema
- type SchemaConfig
- type SerializeFn
- type Type
- type TypeMap
- type Union
- func (ut *Union) Description() string
- func (ut *Union) Error() error
- func (ut *Union) IsPossibleType(ttype *Object) bool
- func (ut *Union) Name() string
- func (ut *Union) ObjectType(value interface{}, info ResolveInfo) *Object
- func (ut *Union) PossibleTypes() []*Object
- func (ut *Union) String() string
- type UnionConfig
- type ValidationResult
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 IsInputType ¶
func IsOutputType ¶
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 ¶
type ArgumentConfig ¶
type BuildExecutionCtxParams ¶
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 ¶
*
- 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 (*Enum) ParseLiteral ¶
func (*Enum) ParseValue ¶
func (gt *Enum) ParseValue(value interface{}) interface{}
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 EnumValueConfigMap ¶
type EnumValueConfigMap map[string]*EnumValueConfig
type EnumValueDefinition ¶
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 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 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 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 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 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 (*Interface) Description ¶
func (*Interface) Fields ¶
func (it *Interface) Fields() (fields FieldDefinitionMap)
func (*Interface) IsPossibleType ¶
func (*Interface) ObjectType ¶
func (it *Interface) ObjectType(value interface{}, info ResolveInfo) *Object
func (*Interface) PossibleTypes ¶
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 (*List) Description ¶
type Named ¶
type Named interface {
String() string
}
These named types do not include modifiers like List or NonNull.
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 (*NonNull) Description ¶
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 (*Object) Description ¶
func (*Object) Fields ¶
func (gt *Object) Fields() FieldDefinitionMap
func (*Object) Interfaces ¶
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 ParseLiteralFn ¶
type ParseValueFn ¶
type ParseValueFn func(value interface{}) interface{}
type ResolveInfo ¶
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 Execute ¶
func Execute(p ExecuteParams) (result *Result)
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 (*Scalar) ParseLiteral ¶
func (*Scalar) ParseValue ¶
func (st *Scalar) ParseValue(value interface{}) interface{}
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 (*Schema) MutationType ¶
type SchemaConfig ¶
* 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 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 (*Union) IsPossibleType ¶
func (*Union) ObjectType ¶
func (ut *Union) ObjectType(value interface{}, info ResolveInfo) *Object
func (*Union) PossibleTypes ¶
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)
Source Files ¶
Click to show internal directories.
Click to hide internal directories.