CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/golang-github-com--graphql-go--graphql

Complete GraphQL implementation in Go with schema definition, query execution, and validation.

Overview
Eval results
Files

language.mddocs/reference/

Language Layer

The language layer provides GraphQL source parsing, AST representation, printing, and AST traversal/transformation.

Source

Import: "github.com/graphql-go/graphql/language/source"

type Source struct {
    Body []byte
    Name string
}

func NewSource(s *Source) *Source

Parser

Import: "github.com/graphql-go/graphql/language/parser"

Parses GraphQL source text into an AST Document.

type ParseParams struct {
    Source  interface{} // string, []byte, or *source.Source
    Options ParseOptions
}

type ParseOptions struct {
    NoLocation bool // omit location info from nodes
    NoSource   bool // omit source reference from locations
}

func Parse(p ParseParams) (*ast.Document, error)

func ParseValue(p ParseParams) (ast.Value, error)
// Parses a standalone GraphQL value (e.g., for default value parsing).
type Parser struct {
    LexToken lexer.Lexer
    Source   *source.Source
    Options  ParseOptions
    PrevEnd  int
    Token    lexer.Token
}

Example:

import (
    "github.com/graphql-go/graphql/language/parser"
    "github.com/graphql-go/graphql/language/source"
)

src := source.NewSource(&source.Source{
    Body: []byte(`{ hero { name } }`),
    Name: "MyQuery",
})
doc, err := parser.Parse(parser.ParseParams{Source: src})
// or with a string:
doc, err := parser.Parse(parser.ParseParams{Source: `{ hero { name } }`})

Printer

Import: "github.com/graphql-go/graphql/language/printer"

Prints an AST node back to GraphQL source text.

func Print(astNode ast.Node) (printed interface{})

Returns a string representation of the AST node. The return type is interface{} but is typically a string.

Example:

import "github.com/graphql-go/graphql/language/printer"

printed := printer.Print(doc)
fmt.Println(printed) // "{\n  hero {\n    name\n  }\n}"

AST

Import: "github.com/graphql-go/graphql/language/ast"

All AST node types.

Core Interfaces

type Node interface {
    GetKind() string
    GetLoc() *Location
}

type Value interface {
    GetValue() interface{}
    GetKind() string
    GetLoc() *Location
}

type Type interface {
    GetKind() string
    GetLoc() *Location
    String() string
}

type Selection interface {
    GetSelectionSet() *SelectionSet
}

type Definition interface {
    GetOperation() string
    GetVariableDefinitions() []*VariableDefinition
    GetSelectionSet() *SelectionSet
    GetKind() string
    GetLoc() *Location
}

type TypeDefinition interface {
    DescribableNode
    GetOperation() string
    GetVariableDefinitions() []*VariableDefinition
    GetSelectionSet() *SelectionSet
    GetKind() string
    GetLoc() *Location
}

type TypeSystemDefinition interface {
    GetOperation() string
    GetVariableDefinitions() []*VariableDefinition
    GetSelectionSet() *SelectionSet
    GetKind() string
    GetLoc() *Location
}

type DescribableNode interface {
    GetDescription() *StringValue
}

Location

type Location struct {
    Start  int
    End    int
    Source *source.Source
}

func NewLocation(loc *Location) *Location

Document

type Document struct {
    Kind        string // "Document"
    Loc         *Location
    Definitions []Node
}

func NewDocument(d *Document) *Document
func (node *Document) GetKind() string
func (node *Document) GetLoc() *Location

Operation Nodes

type OperationDefinition struct {
    Kind                string
    Loc                 *Location
    Operation           string // "query", "mutation", "subscription"
    Name                *Name
    VariableDefinitions []*VariableDefinition
    Directives          []*Directive
    SelectionSet        *SelectionSet
}
func NewOperationDefinition(op *OperationDefinition) *OperationDefinition
func (op *OperationDefinition) GetKind() string
func (op *OperationDefinition) GetLoc() *Location
func (op *OperationDefinition) GetOperation() string
func (op *OperationDefinition) GetName() *Name
func (op *OperationDefinition) GetDirectives() []*Directive
func (op *OperationDefinition) GetSelectionSet() *SelectionSet
func (op *OperationDefinition) GetVariableDefinitions() []*VariableDefinition

const (
    OperationTypeQuery        = "query"
    OperationTypeMutation     = "mutation"
    OperationTypeSubscription = "subscription"
)
type VariableDefinition struct {
    Kind         string
    Loc          *Location
    Variable     *Variable
    Type         Type
    DefaultValue Value
}
func NewVariableDefinition(vd *VariableDefinition) *VariableDefinition
func (vd *VariableDefinition) GetKind() string
func (vd *VariableDefinition) GetLoc() *Location

type Variable struct {
    Kind string
    Loc  *Location
    Name *Name
}
func NewVariable(v *Variable) *Variable
func (v *Variable) GetKind() string
func (v *Variable) GetLoc() *Location
func (v *Variable) GetName() interface{}
func (v *Variable) GetValue() interface{} // alias to GetName()
type SelectionSet struct {
    Kind       string
    Loc        *Location
    Selections []Selection
}
func NewSelectionSet(ss *SelectionSet) *SelectionSet
func (ss *SelectionSet) GetKind() string
func (ss *SelectionSet) GetLoc() *Location
type Field struct {
    Kind         string
    Loc          *Location
    Alias        *Name
    Name         *Name
    Arguments    []*Argument
    Directives   []*Directive
    SelectionSet *SelectionSet
}
func NewField(f *Field) *Field
func (f *Field) GetKind() string
func (f *Field) GetLoc() *Location
func (f *Field) GetSelectionSet() *SelectionSet
type Argument struct {
    Kind  string
    Loc   *Location
    Name  *Name
    Value Value
}
func NewArgument(arg *Argument) *Argument
func (arg *Argument) GetKind() string
func (arg *Argument) GetLoc() *Location

type Name struct {
    Kind  string
    Loc   *Location
    Value string
}
func NewName(node *Name) *Name
func (node *Name) GetKind() string
func (node *Name) GetLoc() *Location

Fragment Nodes

type FragmentSpread struct {
    Kind       string
    Loc        *Location
    Name       *Name
    Directives []*Directive
}
func NewFragmentSpread(fs *FragmentSpread) *FragmentSpread
func (fs *FragmentSpread) GetKind() string
func (fs *FragmentSpread) GetLoc() *Location
func (fs *FragmentSpread) GetSelectionSet() *SelectionSet

type InlineFragment struct {
    Kind          string
    Loc           *Location
    TypeCondition *Named
    Directives    []*Directive
    SelectionSet  *SelectionSet
}
func NewInlineFragment(f *InlineFragment) *InlineFragment
func (f *InlineFragment) GetKind() string
func (f *InlineFragment) GetLoc() *Location
func (f *InlineFragment) GetSelectionSet() *SelectionSet

type FragmentDefinition struct {
    Kind                string
    Loc                 *Location
    Operation           string
    Name                *Name
    VariableDefinitions []*VariableDefinition
    TypeCondition       *Named
    Directives          []*Directive
    SelectionSet        *SelectionSet
}
func NewFragmentDefinition(fd *FragmentDefinition) *FragmentDefinition
func (fd *FragmentDefinition) GetKind() string
func (fd *FragmentDefinition) GetLoc() *Location
func (fd *FragmentDefinition) GetName() *Name
func (fd *FragmentDefinition) GetOperation() string
func (fd *FragmentDefinition) GetSelectionSet() *SelectionSet
func (fd *FragmentDefinition) GetVariableDefinitions() []*VariableDefinition

Value Nodes

type IntValue struct {
    Kind  string
    Loc   *Location
    Value string // raw integer string
}
func NewIntValue(v *IntValue) *IntValue
func (v *IntValue) GetKind() string
func (v *IntValue) GetLoc() *Location
func (v *IntValue) GetValue() interface{}

type FloatValue struct {
    Kind  string
    Loc   *Location
    Value string // raw float string
}
func NewFloatValue(v *FloatValue) *FloatValue
func (v *FloatValue) GetKind() string
func (v *FloatValue) GetLoc() *Location
func (v *FloatValue) GetValue() interface{}

type StringValue struct {
    Kind  string
    Loc   *Location
    Value string
}
func NewStringValue(v *StringValue) *StringValue
func (v *StringValue) GetKind() string
func (v *StringValue) GetLoc() *Location
func (v *StringValue) GetValue() interface{}

type BooleanValue struct {
    Kind  string
    Loc   *Location
    Value bool
}
func NewBooleanValue(v *BooleanValue) *BooleanValue
func (v *BooleanValue) GetKind() string
func (v *BooleanValue) GetLoc() *Location
func (v *BooleanValue) GetValue() interface{}

type EnumValue struct {
    Kind  string
    Loc   *Location
    Value string
}
func NewEnumValue(v *EnumValue) *EnumValue
func (v *EnumValue) GetKind() string
func (v *EnumValue) GetLoc() *Location
func (v *EnumValue) GetValue() interface{}

type ListValue struct {
    Kind   string
    Loc    *Location
    Values []Value
}
func NewListValue(v *ListValue) *ListValue
func (v *ListValue) GetKind() string
func (v *ListValue) GetLoc() *Location
func (v *ListValue) GetValue() interface{} // alias to GetValues()
func (v *ListValue) GetValues() interface{}

type ObjectValue struct {
    Kind   string
    Loc    *Location
    Fields []*ObjectField
}
func NewObjectValue(v *ObjectValue) *ObjectValue
func (v *ObjectValue) GetKind() string
func (v *ObjectValue) GetLoc() *Location
func (v *ObjectValue) GetValue() interface{}

type ObjectField struct {
    Kind  string
    Name  *Name
    Loc   *Location
    Value Value
}
func NewObjectField(f *ObjectField) *ObjectField
func (f *ObjectField) GetKind() string
func (f *ObjectField) GetLoc() *Location
func (f *ObjectField) GetValue() interface{}

Directive Node

type Directive struct {
    Kind      string
    Loc       *Location
    Name      *Name
    Arguments []*Argument
}
func NewDirective(dir *Directive) *Directive
func (dir *Directive) GetKind() string
func (dir *Directive) GetLoc() *Location

Type Reference Nodes

type Named struct {
    Kind string
    Loc  *Location
    Name *Name
}
func NewNamed(t *Named) *Named
func (t *Named) GetKind() string
func (t *Named) GetLoc() *Location
func (t *Named) String() string

type List struct {
    Kind string
    Loc  *Location
    Type Type
}
func NewList(t *List) *List
func (t *List) GetKind() string
func (t *List) GetLoc() *Location
func (t *List) String() string

type NonNull struct {
    Kind string
    Loc  *Location
    Type Type
}
func NewNonNull(t *NonNull) *NonNull
func (t *NonNull) GetKind() string
func (t *NonNull) GetLoc() *Location
func (t *NonNull) String() string

Schema Definition Nodes

type SchemaDefinition struct {
    Kind           string
    Loc            *Location
    Directives     []*Directive
    OperationTypes []*OperationTypeDefinition
}
func NewSchemaDefinition(def *SchemaDefinition) *SchemaDefinition
func (def *SchemaDefinition) GetKind() string
func (def *SchemaDefinition) GetLoc() *Location
func (def *SchemaDefinition) GetOperation() string
func (def *SchemaDefinition) GetSelectionSet() *SelectionSet
func (def *SchemaDefinition) GetVariableDefinitions() []*VariableDefinition

type OperationTypeDefinition struct {
    Kind      string
    Loc       *Location
    Operation string
    Type      *Named
}
func NewOperationTypeDefinition(def *OperationTypeDefinition) *OperationTypeDefinition
func (def *OperationTypeDefinition) GetKind() string
func (def *OperationTypeDefinition) GetLoc() *Location

Type Definition Nodes

type ScalarDefinition struct {
    Kind        string
    Loc         *Location
    Description *StringValue
    Name        *Name
    Directives  []*Directive
}
func NewScalarDefinition(def *ScalarDefinition) *ScalarDefinition
func (def *ScalarDefinition) GetKind() string
func (def *ScalarDefinition) GetLoc() *Location
func (def *ScalarDefinition) GetName() *Name
func (def *ScalarDefinition) GetDescription() *StringValue
func (def *ScalarDefinition) GetOperation() string
func (def *ScalarDefinition) GetSelectionSet() *SelectionSet
func (def *ScalarDefinition) GetVariableDefinitions() []*VariableDefinition

type ObjectDefinition struct {
    Kind        string
    Loc         *Location
    Name        *Name
    Description *StringValue
    Interfaces  []*Named
    Directives  []*Directive
    Fields      []*FieldDefinition
}
func NewObjectDefinition(def *ObjectDefinition) *ObjectDefinition
func (def *ObjectDefinition) GetKind() string
func (def *ObjectDefinition) GetLoc() *Location
func (def *ObjectDefinition) GetName() *Name
func (def *ObjectDefinition) GetDescription() *StringValue
func (def *ObjectDefinition) GetOperation() string
func (def *ObjectDefinition) GetSelectionSet() *SelectionSet
func (def *ObjectDefinition) GetVariableDefinitions() []*VariableDefinition

type FieldDefinition struct {
    Kind        string
    Loc         *Location
    Name        *Name
    Description *StringValue
    Arguments   []*InputValueDefinition
    Type        Type
    Directives  []*Directive
}
func NewFieldDefinition(def *FieldDefinition) *FieldDefinition
func (def *FieldDefinition) GetKind() string
func (def *FieldDefinition) GetLoc() *Location
func (def *FieldDefinition) GetDescription() *StringValue

type InputValueDefinition struct {
    Kind         string
    Loc          *Location
    Name         *Name
    Description  *StringValue
    Type         Type
    DefaultValue Value
    Directives   []*Directive
}
func NewInputValueDefinition(def *InputValueDefinition) *InputValueDefinition
func (def *InputValueDefinition) GetKind() string
func (def *InputValueDefinition) GetLoc() *Location
func (def *InputValueDefinition) GetDescription() *StringValue

type InterfaceDefinition struct {
    Kind        string
    Loc         *Location
    Name        *Name
    Description *StringValue
    Directives  []*Directive
    Fields      []*FieldDefinition
}
func NewInterfaceDefinition(def *InterfaceDefinition) *InterfaceDefinition
func (def *InterfaceDefinition) GetKind() string
func (def *InterfaceDefinition) GetLoc() *Location
func (def *InterfaceDefinition) GetName() *Name
func (def *InterfaceDefinition) GetDescription() *StringValue
func (def *InterfaceDefinition) GetOperation() string
func (def *InterfaceDefinition) GetSelectionSet() *SelectionSet
func (def *InterfaceDefinition) GetVariableDefinitions() []*VariableDefinition

type UnionDefinition struct {
    Kind        string
    Loc         *Location
    Name        *Name
    Description *StringValue
    Directives  []*Directive
    Types       []*Named
}
func NewUnionDefinition(def *UnionDefinition) *UnionDefinition
func (def *UnionDefinition) GetKind() string
func (def *UnionDefinition) GetLoc() *Location
func (def *UnionDefinition) GetName() *Name
func (def *UnionDefinition) GetDescription() *StringValue
func (def *UnionDefinition) GetOperation() string
func (def *UnionDefinition) GetSelectionSet() *SelectionSet
func (def *UnionDefinition) GetVariableDefinitions() []*VariableDefinition

type EnumDefinition struct {
    Kind        string
    Loc         *Location
    Name        *Name
    Description *StringValue
    Directives  []*Directive
    Values      []*EnumValueDefinition
}
func NewEnumDefinition(def *EnumDefinition) *EnumDefinition
func (def *EnumDefinition) GetKind() string
func (def *EnumDefinition) GetLoc() *Location
func (def *EnumDefinition) GetName() *Name
func (def *EnumDefinition) GetDescription() *StringValue
func (def *EnumDefinition) GetOperation() string
func (def *EnumDefinition) GetSelectionSet() *SelectionSet
func (def *EnumDefinition) GetVariableDefinitions() []*VariableDefinition

type EnumValueDefinition struct {
    Kind        string
    Loc         *Location
    Name        *Name
    Description *StringValue
    Directives  []*Directive
}
func NewEnumValueDefinition(def *EnumValueDefinition) *EnumValueDefinition
func (def *EnumValueDefinition) GetKind() string
func (def *EnumValueDefinition) GetLoc() *Location
func (def *EnumValueDefinition) GetDescription() *StringValue

type InputObjectDefinition struct {
    Kind        string
    Loc         *Location
    Name        *Name
    Description *StringValue
    Directives  []*Directive
    Fields      []*InputValueDefinition
}
func NewInputObjectDefinition(def *InputObjectDefinition) *InputObjectDefinition
func (def *InputObjectDefinition) GetKind() string
func (def *InputObjectDefinition) GetLoc() *Location
func (def *InputObjectDefinition) GetName() *Name
func (def *InputObjectDefinition) GetDescription() *StringValue
func (def *InputObjectDefinition) GetOperation() string
func (def *InputObjectDefinition) GetSelectionSet() *SelectionSet
func (def *InputObjectDefinition) GetVariableDefinitions() []*VariableDefinition

type TypeExtensionDefinition struct {
    Kind       string
    Loc        *Location
    Definition *ObjectDefinition
}
func NewTypeExtensionDefinition(def *TypeExtensionDefinition) *TypeExtensionDefinition
func (def *TypeExtensionDefinition) GetKind() string
func (def *TypeExtensionDefinition) GetLoc() *Location
func (def *TypeExtensionDefinition) GetOperation() string
func (def *TypeExtensionDefinition) GetSelectionSet() *SelectionSet
func (def *TypeExtensionDefinition) GetVariableDefinitions() []*VariableDefinition

type DirectiveDefinition struct {
    Kind        string
    Loc         *Location
    Name        *Name
    Description *StringValue
    Arguments   []*InputValueDefinition
    Locations   []*Name
}
func NewDirectiveDefinition(def *DirectiveDefinition) *DirectiveDefinition
func (def *DirectiveDefinition) GetKind() string
func (def *DirectiveDefinition) GetLoc() *Location
func (def *DirectiveDefinition) GetDescription() *StringValue
func (def *DirectiveDefinition) GetOperation() string
func (def *DirectiveDefinition) GetSelectionSet() *SelectionSet
func (def *DirectiveDefinition) GetVariableDefinitions() []*VariableDefinition

Kinds

Import: "github.com/graphql-go/graphql/language/kinds"

String constants for all AST node kinds:

const (
    Name = "Name"

    // Document
    Document            = "Document"
    OperationDefinition = "OperationDefinition"
    VariableDefinition  = "VariableDefinition"
    Variable            = "Variable"
    SelectionSet        = "SelectionSet"
    Field               = "Field"
    Argument            = "Argument"

    // Fragments
    FragmentSpread     = "FragmentSpread"
    InlineFragment     = "InlineFragment"
    FragmentDefinition = "FragmentDefinition"

    // Values
    IntValue     = "IntValue"
    FloatValue   = "FloatValue"
    StringValue  = "StringValue"
    BooleanValue = "BooleanValue"
    EnumValue    = "EnumValue"
    ListValue    = "ListValue"
    ObjectValue  = "ObjectValue"
    ObjectField  = "ObjectField"

    // Directives
    Directive = "Directive"

    // Types
    Named   = "Named"
    List    = "List"
    NonNull = "NonNull"

    // Type System Definitions
    SchemaDefinition        = "SchemaDefinition"
    OperationTypeDefinition = "OperationTypeDefinition"

    // Type Definitions
    ScalarDefinition      = "ScalarDefinition"
    ObjectDefinition      = "ObjectDefinition"
    FieldDefinition       = "FieldDefinition"
    InputValueDefinition  = "InputValueDefinition"
    InterfaceDefinition   = "InterfaceDefinition"
    UnionDefinition       = "UnionDefinition"
    EnumDefinition        = "EnumDefinition"
    EnumValueDefinition   = "EnumValueDefinition"
    InputObjectDefinition = "InputObjectDefinition"

    // Type Extensions
    TypeExtensionDefinition = "TypeExtensionDefinition"

    // Directive Definitions
    DirectiveDefinition = "DirectiveDefinition"
)

Lexer

Import: "github.com/graphql-go/graphql/language/lexer"

type Lexer func(resetPosition int) (Token, error)

type Token struct {
    Kind  TokenKind
    Start int
    End   int
    Value string // non-empty only for NAME, INT, FLOAT, STRING
}

type TokenKind int

func (kind TokenKind) String() string

func Lex(s *source.Source) Lexer
func GetTokenDesc(token Token) string

TokenKind Constants

const (
    EOF TokenKind = iota + 1
    BANG
    DOLLAR
    PAREN_L
    PAREN_R
    SPREAD
    COLON
    EQUALS
    AT
    BRACKET_L
    BRACKET_R
    BRACE_L
    PIPE
    BRACE_R
    NAME
    INT
    FLOAT
    STRING
    BLOCK_STRING
    AMP
)

Keyword String Constants

const (
    FRAGMENT     = "fragment"
    QUERY        = "query"
    MUTATION     = "mutation"
    SUBSCRIPTION = "subscription"
    SCHEMA       = "schema"
    SCALAR       = "scalar"
    TYPE         = "type"
    INTERFACE    = "interface"
    UNION        = "union"
    ENUM         = "enum"
    INPUT        = "input"
    EXTEND       = "extend"
    DIRECTIVE    = "directive"
)

Visitor

Import: "github.com/graphql-go/graphql/language/visitor"

Traverse and optionally transform AST nodes.

func Visit(root ast.Node, visitorOpts *VisitorOptions, keyMap KeyMap) interface{}
  • keyMap: maps node kinds to child field names. Pass nil or QueryDocumentKeys for standard traversal.
  • Returns the (possibly modified) root node.
type VisitorOptions struct {
    // Per-kind enter/leave functions (highest priority)
    KindFuncMap map[string]NamedVisitFuncs

    // Generic enter/leave for all nodes
    Enter VisitFunc
    Leave VisitFunc

    // Per-kind enter/leave maps (lower priority than KindFuncMap)
    EnterKindMap map[string]VisitFunc
    LeaveKindMap map[string]VisitFunc
}

type NamedVisitFuncs struct {
    Kind  VisitFunc // Enter for a specific kind
    Leave VisitFunc
    Enter VisitFunc
}

type VisitFunc func(p VisitFuncParams) (string, interface{})

type VisitFuncParams struct {
    Node      interface{}   // current node
    Key       interface{}   // key in parent
    Parent    ast.Node      // parent node
    Path      []interface{} // path from root
    Ancestors []ast.Node    // ancestor nodes
}

Visitor Action Constants

const (
    ActionNoChange = ""      // keep the node as-is
    ActionBreak    = "BREAK" // stop traversal
    ActionSkip     = "SKIP"  // skip children of this node
    ActionUpdate   = "UPDATE" // replace node with second return value
)

Helper Functions

func VisitInParallel(visitorOptsSlice ...*VisitorOptions) *VisitorOptions
// Creates a composite visitor that runs all provided visitors in parallel.
// If a prior visitor edits a node, subsequent visitors see the original.

func VisitWithTypeInfo(ttypeInfo typeInfo.TypeInfoI, visitorOpts *VisitorOptions) *VisitorOptions
// Creates a visitor that maintains a TypeInfo instance during traversal.

func GetVisitFn(visitorOpts *VisitorOptions, kind string, isLeaving bool) VisitFunc
// Returns the appropriate VisitFunc for a given node kind and enter/leave direction.
// Priority (high to low): KindFuncMap > Enter/Leave > EnterKindMap/LeaveKindMap

var QueryDocumentKeys KeyMap
// Default key map defining traversal order for all node kinds.

type KeyMap map[string][]string

Example usage:

import (
    "github.com/graphql-go/graphql/language/visitor"
    "github.com/graphql-go/graphql/language/ast"
)

var fieldNames []string
visitor.Visit(doc, &visitor.VisitorOptions{
    EnterKindMap: map[string]visitor.VisitFunc{
        "Field": func(p visitor.VisitFuncParams) (string, interface{}) {
            if field, ok := p.Node.(*ast.Field); ok {
                fieldNames = append(fieldNames, field.Name.Value)
            }
            return visitor.ActionNoChange, nil
        },
    },
}, nil)

TypeInfo Interface

Import: "github.com/graphql-go/graphql/language/typeInfo"

type TypeInfoI interface {
    Enter(node ast.Node)
    Leave(node ast.Node)
}

Implemented by graphql.TypeInfo. Used by visitor.VisitWithTypeInfo to track schema type information during traversal.

Location

Import: "github.com/graphql-go/graphql/language/location"

type SourceLocation struct {
    Line   int `json:"line"`
    Column int `json:"column"`
}

func GetLocation(s *source.Source, position int) SourceLocation

Install with Tessl CLI

npx tessl i tessl/golang-github-com--graphql-go--graphql

docs

reference

errors.md

execution.md

language.md

schema.md

validation.md

index.md

tile.json