Validation

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

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

doc, _ := parser.Parse(parser.ParseParams{Source: src})
result := graphql.ValidateDocument(&schema, doc, nil)
if !result.IsValid {
    for _, err := range result.Errors {
        fmt.Println(err.Message)
    }
}

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

var SpecifiedRules = []ValidationRuleFn{
    ArgumentsOfCorrectTypeRule,
    DefaultValuesOfCorrectTypeRule,
    FieldsOnCorrectTypeRule,
    FragmentsOnCompositeTypesRule,
    KnownArgumentNamesRule,
    KnownDirectivesRule,
    KnownFragmentNamesRule,
    KnownTypeNamesRule,
    LoneAnonymousOperationRule,
    NoFragmentCyclesRule,
    NoUndefinedVariablesRule,
    NoUnusedFragmentsRule,
    NoUnusedVariablesRule,
    OverlappingFieldsCanBeMergedRule,
    PossibleFragmentSpreadsRule,
    ProvidedNonNullArgumentsRule,
    ScalarLeafsRule,
    UniqueArgumentNamesRule,
    UniqueFragmentNamesRule,
    UniqueInputFieldNamesRule,
    UniqueOperationNamesRule,
    UniqueVariableNamesRule,
    VariablesAreInputTypesRule,
    VariablesInAllowedPositionRule,
}

type ValidationRuleFn func(context *ValidationContext) *ValidationRuleInstance

type ValidationRuleInstance struct {
    VisitorOpts *visitor.VisitorOptions
}

func ArgumentsOfCorrectTypeRule(context *ValidationContext) *ValidationRuleInstance
// Validates argument literal values are the correct type.

func DefaultValuesOfCorrectTypeRule(context *ValidationContext) *ValidationRuleInstance
// Validates variable default values are of the correct type.

func FieldsOnCorrectTypeRule(context *ValidationContext) *ValidationRuleInstance
// Validates all selected fields are defined on their parent type.

func FragmentsOnCompositeTypesRule(context *ValidationContext) *ValidationRuleInstance
// Validates fragments are spread on composite types (object, interface, union).

func KnownArgumentNamesRule(context *ValidationContext) *ValidationRuleInstance
// Validates all supplied argument names are defined on the field or directive.

func KnownDirectivesRule(context *ValidationContext) *ValidationRuleInstance
// Validates all @directives are known and legally positioned.

func KnownFragmentNamesRule(context *ValidationContext) *ValidationRuleInstance
// Validates all fragment spreads reference defined fragments.

func KnownTypeNamesRule(context *ValidationContext) *ValidationRuleInstance
// Validates all referenced type names are defined in the schema.

func LoneAnonymousOperationRule(context *ValidationContext) *ValidationRuleInstance
// Validates that anonymous operations appear alone in a document.

func NoFragmentCyclesRule(context *ValidationContext) *ValidationRuleInstance
// Validates that no fragments form cycles via fragment spreads.

func NoUndefinedVariablesRule(context *ValidationContext) *ValidationRuleInstance
// Validates all variables referenced are defined in the operation.

func NoUnusedFragmentsRule(context *ValidationContext) *ValidationRuleInstance
// Validates all defined fragments are spread within operations.

func NoUnusedVariablesRule(context *ValidationContext) *ValidationRuleInstance
// Validates all defined variables are used.

func OverlappingFieldsCanBeMergedRule(context *ValidationContext) *ValidationRuleInstance
// Validates that all field selections in a set can be merged without ambiguity.

func PossibleFragmentSpreadsRule(context *ValidationContext) *ValidationRuleInstance
// Validates fragment spreads are on possible types.

func ProvidedNonNullArgumentsRule(context *ValidationContext) *ValidationRuleInstance
// Validates all required (non-null) arguments are provided.

func ScalarLeafsRule(context *ValidationContext) *ValidationRuleInstance
// Validates leaf fields are scalar or enum types.

func UniqueArgumentNamesRule(context *ValidationContext) *ValidationRuleInstance
// Validates all supplied argument names are unique.

func UniqueFragmentNamesRule(context *ValidationContext) *ValidationRuleInstance
// Validates all fragment definitions have unique names.

func UniqueInputFieldNamesRule(context *ValidationContext) *ValidationRuleInstance
// Validates all input object fields are uniquely named.

func UniqueOperationNamesRule(context *ValidationContext) *ValidationRuleInstance
// Validates all operations have unique names.

func UniqueVariableNamesRule(context *ValidationContext) *ValidationRuleInstance
// Validates all variables in an operation are uniquely named.

func VariablesAreInputTypesRule(context *ValidationContext) *ValidationRuleInstance
// Validates all variable types are input types.

func VariablesInAllowedPositionRule(context *ValidationContext) *ValidationRuleInstance
// Validates variables are used in positions where their type is compatible.

myRule := func(ctx *graphql.ValidationContext) *graphql.ValidationRuleInstance {
    return &graphql.ValidationRuleInstance{
        VisitorOpts: &visitor.VisitorOptions{
            EnterKindMap: map[string]visitor.VisitFunc{
                "Field": func(p visitor.VisitFuncParams) (string, interface{}) {
                    // inspect the field node
                    if field, ok := p.Node.(*ast.Field); ok {
                        if field.Name.Value == "forbidden" {
                            ctx.ReportError(fmt.Errorf("field 'forbidden' is not allowed"))
                        }
                    }
                    return visitor.ActionNoChange, nil
                },
            },
        },
    }
}

result := graphql.ValidateDocument(&schema, doc, []graphql.ValidationRuleFn{myRule})

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

func (ctx *ValidationContext) Schema() *Schema
func (ctx *ValidationContext) Document() *ast.Document
func (ctx *ValidationContext) Type() Output
func (ctx *ValidationContext) ParentType() Composite
func (ctx *ValidationContext) InputType() Input
func (ctx *ValidationContext) FieldDef() *FieldDefinition
func (ctx *ValidationContext) Directive() *Directive
func (ctx *ValidationContext) Argument() *Argument
func (ctx *ValidationContext) Fragment(name string) *ast.FragmentDefinition
func (ctx *ValidationContext) FragmentSpreads(node *ast.SelectionSet) []*ast.FragmentSpread
func (ctx *ValidationContext) RecursivelyReferencedFragments(operation *ast.OperationDefinition) []*ast.FragmentDefinition
func (ctx *ValidationContext) VariableUsages(node HasSelectionSet) []*VariableUsage
func (ctx *ValidationContext) RecursiveVariableUsages(operation *ast.OperationDefinition) []*VariableUsage
func (ctx *ValidationContext) Errors() []gqlerrors.FormattedError
func (ctx *ValidationContext) ReportError(err error)

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

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

type TypeInfoConfig struct {
    Schema *Schema
    // FieldDefFn is an experimental optional parameter; not for general use.
}

func NewTypeInfo(opts *TypeInfoConfig) *TypeInfo

func (ti *TypeInfo) Type() Output
func (ti *TypeInfo) ParentType() Composite
func (ti *TypeInfo) InputType() Input
func (ti *TypeInfo) FieldDef() *FieldDefinition
func (ti *TypeInfo) Directive() *Directive
func (ti *TypeInfo) Argument() *Argument
func (ti *TypeInfo) Enter(node ast.Node)
func (ti *TypeInfo) Leave(node ast.Node)

func CycleErrorMessage(fragName string, spreadNames []string) string
func MisplaceDirectiveMessage(directiveName string, location string) string
func UndefinedFieldMessage(fieldName string, ttypeName string, suggestedTypeNames []string, suggestedFieldNames []string) string
func UndefinedVarMessage(varName string, opName string) string
func UnusedVariableMessage(varName string, opName string) string
func FieldASTsToNodeASTs(fieldASTs []*ast.Field) []ast.Node
func DefaultTypeInfoFieldDef(schema *Schema, parentType Type, fieldAST *ast.Field) *FieldDefinition