aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/github.com/graphql-go/graphql/rules.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/graphql-go/graphql/rules.go')
-rw-r--r--vendor/github.com/graphql-go/graphql/rules.go1907
1 files changed, 1907 insertions, 0 deletions
diff --git a/vendor/github.com/graphql-go/graphql/rules.go b/vendor/github.com/graphql-go/graphql/rules.go
new file mode 100644
index 00000000..95d80aad
--- /dev/null
+++ b/vendor/github.com/graphql-go/graphql/rules.go
@@ -0,0 +1,1907 @@
+package graphql
+
+import (
+ "fmt"
+ "math"
+ "sort"
+ "strings"
+
+ "github.com/graphql-go/graphql/gqlerrors"
+ "github.com/graphql-go/graphql/language/ast"
+ "github.com/graphql-go/graphql/language/kinds"
+ "github.com/graphql-go/graphql/language/printer"
+ "github.com/graphql-go/graphql/language/visitor"
+)
+
+// SpecifiedRules set includes all validation rules defined by the GraphQL spec.
+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 ValidationRuleInstance struct {
+ VisitorOpts *visitor.VisitorOptions
+}
+type ValidationRuleFn func(context *ValidationContext) *ValidationRuleInstance
+
+func newValidationError(message string, nodes []ast.Node) *gqlerrors.Error {
+ return gqlerrors.NewError(
+ message,
+ nodes,
+ "",
+ nil,
+ []int{},
+ nil, // TODO: this is interim, until we port "better-error-messages-for-inputs"
+ )
+}
+
+func reportError(context *ValidationContext, message string, nodes []ast.Node) (string, interface{}) {
+ context.ReportError(newValidationError(message, nodes))
+ return visitor.ActionNoChange, nil
+}
+
+// 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 ArgumentsOfCorrectTypeRule(context *ValidationContext) *ValidationRuleInstance {
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.Argument: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if argAST, ok := p.Node.(*ast.Argument); ok {
+ value := argAST.Value
+ argDef := context.Argument()
+ if argDef != nil {
+ isValid, messages := isValidLiteralValue(argDef.Type, value)
+ if !isValid {
+ argNameValue := ""
+ if argAST.Name != nil {
+ argNameValue = argAST.Name.Value
+ }
+
+ messagesStr := ""
+ if len(messages) > 0 {
+ messagesStr = "\n" + strings.Join(messages, "\n")
+ }
+ reportError(
+ context,
+ fmt.Sprintf(`Argument "%v" has invalid value %v.%v`,
+ argNameValue, printer.Print(value), messagesStr),
+ []ast.Node{value},
+ )
+ }
+
+ }
+ }
+ return visitor.ActionSkip, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+// 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 DefaultValuesOfCorrectTypeRule(context *ValidationContext) *ValidationRuleInstance {
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.VariableDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if varDefAST, ok := p.Node.(*ast.VariableDefinition); ok {
+ name := ""
+ if varDefAST.Variable != nil && varDefAST.Variable.Name != nil {
+ name = varDefAST.Variable.Name.Value
+ }
+ defaultValue := varDefAST.DefaultValue
+ ttype := context.InputType()
+
+ if ttype, ok := ttype.(*NonNull); ok && defaultValue != nil {
+ reportError(
+ context,
+ fmt.Sprintf(`Variable "$%v" of type "%v" is required and will not use the default value. Perhaps you meant to use type "%v".`,
+ name, ttype, ttype.OfType),
+ []ast.Node{defaultValue},
+ )
+ }
+ isValid, messages := isValidLiteralValue(ttype, defaultValue)
+ if ttype != nil && defaultValue != nil && !isValid {
+ messagesStr := ""
+ if len(messages) > 0 {
+ messagesStr = "\n" + strings.Join(messages, "\n")
+ }
+ reportError(
+ context,
+ fmt.Sprintf(`Variable "$%v" has invalid default value: %v.%v`,
+ name, printer.Print(defaultValue), messagesStr),
+ []ast.Node{defaultValue},
+ )
+ }
+ }
+ return visitor.ActionSkip, nil
+ },
+ },
+ kinds.SelectionSet: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ return visitor.ActionSkip, nil
+ },
+ },
+ kinds.FragmentDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ return visitor.ActionSkip, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+func quoteStrings(slice []string) []string {
+ quoted := []string{}
+ for _, s := range slice {
+ quoted = append(quoted, fmt.Sprintf(`"%v"`, s))
+ }
+ return quoted
+}
+
+// quotedOrList Given [ A, B, C ] return '"A", "B", or "C"'.
+// Notice oxford comma
+func quotedOrList(slice []string) string {
+ maxLength := 5
+ if len(slice) == 0 {
+ return ""
+ }
+ quoted := quoteStrings(slice)
+ if maxLength > len(quoted) {
+ maxLength = len(quoted)
+ }
+ if maxLength > 2 {
+ return fmt.Sprintf("%v, or %v", strings.Join(quoted[0:maxLength-1], ", "), quoted[maxLength-1])
+ }
+ if maxLength > 1 {
+ return fmt.Sprintf("%v or %v", strings.Join(quoted[0:maxLength-1], ", "), quoted[maxLength-1])
+ }
+ return quoted[0]
+}
+func UndefinedFieldMessage(fieldName string, ttypeName string, suggestedTypeNames []string, suggestedFieldNames []string) string {
+ message := fmt.Sprintf(`Cannot query field "%v" on type "%v".`, fieldName, ttypeName)
+ if len(suggestedTypeNames) > 0 {
+ message = fmt.Sprintf(`%v Did you mean to use an inline fragment on %v?`, message, quotedOrList(suggestedTypeNames))
+ } else if len(suggestedFieldNames) > 0 {
+ message = fmt.Sprintf(`%v Did you mean %v?`, message, quotedOrList(suggestedFieldNames))
+ }
+ return message
+}
+
+// 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 FieldsOnCorrectTypeRule(context *ValidationContext) *ValidationRuleInstance {
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.Field: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ var action = visitor.ActionNoChange
+ var result interface{}
+ if node, ok := p.Node.(*ast.Field); ok {
+ ttype := context.ParentType()
+ if ttype == nil {
+ return action, result
+ }
+ if t, ok := ttype.(*Object); ok && t == nil {
+ return action, result
+ }
+ if t, ok := ttype.(*Interface); ok && t == nil {
+ return action, result
+ }
+ if t, ok := ttype.(*Union); ok && t == nil {
+ return action, result
+ }
+ fieldDef := context.FieldDef()
+ if fieldDef == nil {
+ // This field doesn't exist, lets look for suggestions.
+ nodeName := ""
+ if node.Name != nil {
+ nodeName = node.Name.Value
+ }
+ // First determine if there are any suggested types to condition on.
+ suggestedTypeNames := getSuggestedTypeNames(context.Schema(), ttype, nodeName)
+
+ // If there are no suggested types, then perhaps this was a typo?
+ suggestedFieldNames := []string{}
+ if len(suggestedTypeNames) == 0 {
+ suggestedFieldNames = getSuggestedFieldNames(context.Schema(), ttype, nodeName)
+ }
+ reportError(
+ context,
+ UndefinedFieldMessage(nodeName, ttype.Name(), suggestedTypeNames, suggestedFieldNames),
+ []ast.Node{node},
+ )
+ }
+ }
+ return action, result
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+// getSuggestedTypeNames Go through all of the implementations of type, as well as the interfaces
+// that they implement. If any of those types include the provided field,
+// suggest them, sorted by how often the type is referenced, starting
+// with Interfaces.
+func getSuggestedTypeNames(schema *Schema, ttype Output, fieldName string) []string {
+
+ possibleTypes := schema.PossibleTypes(ttype)
+
+ suggestedObjectTypes := []string{}
+ suggestedInterfaces := []*suggestedInterface{}
+ // stores a map of interface name => index in suggestedInterfaces
+ suggestedInterfaceMap := map[string]int{}
+ // stores a maps of object name => true to remove duplicates from results
+ suggestedObjectMap := map[string]bool{}
+
+ for _, possibleType := range possibleTypes {
+ if field, ok := possibleType.Fields()[fieldName]; !ok || field == nil {
+ continue
+ }
+ // This object type defines this field.
+ suggestedObjectTypes = append(suggestedObjectTypes, possibleType.Name())
+ suggestedObjectMap[possibleType.Name()] = true
+
+ for _, possibleInterface := range possibleType.Interfaces() {
+ if field, ok := possibleInterface.Fields()[fieldName]; !ok || field == nil {
+ continue
+ }
+
+ // This interface type defines this field.
+
+ // - find the index of the suggestedInterface and retrieving the interface
+ // - increase count
+ index, ok := suggestedInterfaceMap[possibleInterface.Name()]
+ if !ok {
+ suggestedInterfaces = append(suggestedInterfaces, &suggestedInterface{
+ name: possibleInterface.Name(),
+ count: 0,
+ })
+ index = len(suggestedInterfaces) - 1
+ suggestedInterfaceMap[possibleInterface.Name()] = index
+ }
+ if index < len(suggestedInterfaces) {
+ s := suggestedInterfaces[index]
+ if s.name == possibleInterface.Name() {
+ s.count = s.count + 1
+ }
+ }
+ }
+ }
+
+ // sort results (by count usage for interfaces, alphabetical order for objects)
+ sort.Sort(suggestedInterfaceSortedSlice(suggestedInterfaces))
+ sort.Sort(sort.StringSlice(suggestedObjectTypes))
+
+ // return concatenated slices of both interface and object type names
+ // and removing duplicates
+ // ordered by: interface (sorted) and object (sorted)
+ results := []string{}
+ for _, s := range suggestedInterfaces {
+ if _, ok := suggestedObjectMap[s.name]; !ok {
+ results = append(results, s.name)
+
+ }
+ }
+ results = append(results, suggestedObjectTypes...)
+ return results
+}
+
+// getSuggestedFieldNames For the field name provided, determine if there are any similar field names
+// that may be the result of a typo.
+func getSuggestedFieldNames(schema *Schema, ttype Output, fieldName string) []string {
+
+ fields := FieldDefinitionMap{}
+ switch ttype := ttype.(type) {
+ case *Object:
+ fields = ttype.Fields()
+ case *Interface:
+ fields = ttype.Fields()
+ default:
+ return []string{}
+ }
+
+ possibleFieldNames := []string{}
+ for possibleFieldName := range fields {
+ possibleFieldNames = append(possibleFieldNames, possibleFieldName)
+ }
+ return suggestionList(fieldName, possibleFieldNames)
+}
+
+// suggestedInterface an internal struct to sort interface by usage count
+type suggestedInterface struct {
+ name string
+ count int
+}
+type suggestedInterfaceSortedSlice []*suggestedInterface
+
+func (s suggestedInterfaceSortedSlice) Len() int {
+ return len(s)
+}
+func (s suggestedInterfaceSortedSlice) Swap(i, j int) {
+ s[i], s[j] = s[j], s[i]
+}
+func (s suggestedInterfaceSortedSlice) Less(i, j int) bool {
+ if s[i].count == s[j].count {
+ return s[i].name < s[j].name
+ }
+ return s[i].count > s[j].count
+}
+
+// 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 FragmentsOnCompositeTypesRule(context *ValidationContext) *ValidationRuleInstance {
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.InlineFragment: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.InlineFragment); ok {
+ ttype := context.Type()
+ if node.TypeCondition != nil && ttype != nil && !IsCompositeType(ttype) {
+ reportError(
+ context,
+ fmt.Sprintf(`Fragment cannot condition on non composite type "%v".`, ttype),
+ []ast.Node{node.TypeCondition},
+ )
+ }
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ kinds.FragmentDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.FragmentDefinition); ok {
+ ttype := context.Type()
+ if ttype != nil && !IsCompositeType(ttype) {
+ nodeName := ""
+ if node.Name != nil {
+ nodeName = node.Name.Value
+ }
+ reportError(
+ context,
+ fmt.Sprintf(`Fragment "%v" cannot condition on non composite type "%v".`, nodeName, printer.Print(node.TypeCondition)),
+ []ast.Node{node.TypeCondition},
+ )
+ }
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+func unknownArgMessage(argName string, fieldName string, parentTypeName string, suggestedArgs []string) string {
+ message := fmt.Sprintf(`Unknown argument "%v" on field "%v" of type "%v".`, argName, fieldName, parentTypeName)
+
+ if len(suggestedArgs) > 0 {
+ message = fmt.Sprintf(`%v Did you mean %v?`, message, quotedOrList(suggestedArgs))
+ }
+
+ return message
+}
+
+func unknownDirectiveArgMessage(argName string, directiveName string, suggestedArgs []string) string {
+ message := fmt.Sprintf(`Unknown argument "%v" on directive "@%v".`, argName, directiveName)
+
+ if len(suggestedArgs) > 0 {
+ message = fmt.Sprintf(`%v Did you mean %v?`, message, quotedOrList(suggestedArgs))
+ }
+
+ return message
+}
+
+// KnownArgumentNamesRule Known argument names
+//
+// A GraphQL field is only valid if all supplied arguments are defined by
+// that field.
+func KnownArgumentNamesRule(context *ValidationContext) *ValidationRuleInstance {
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.Argument: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ var action = visitor.ActionNoChange
+ var result interface{}
+ if node, ok := p.Node.(*ast.Argument); ok {
+ var argumentOf ast.Node
+ if len(p.Ancestors) > 0 {
+ argumentOf = p.Ancestors[len(p.Ancestors)-1]
+ }
+ if argumentOf == nil {
+ return action, result
+ }
+ var fieldArgDef *Argument
+ if argumentOf.GetKind() == kinds.Field {
+ fieldDef := context.FieldDef()
+ if fieldDef == nil {
+ return action, result
+ }
+ nodeName := ""
+ if node.Name != nil {
+ nodeName = node.Name.Value
+ }
+ argNames := []string{}
+ for _, arg := range fieldDef.Args {
+ argNames = append(argNames, arg.Name())
+ if arg.Name() == nodeName {
+ fieldArgDef = arg
+ }
+ }
+ if fieldArgDef == nil {
+ parentType := context.ParentType()
+ parentTypeName := ""
+ if parentType != nil {
+ parentTypeName = parentType.Name()
+ }
+ reportError(
+ context,
+ unknownArgMessage(nodeName, fieldDef.Name, parentTypeName, suggestionList(nodeName, argNames)),
+ []ast.Node{node},
+ )
+ }
+ } else if argumentOf.GetKind() == kinds.Directive {
+ directive := context.Directive()
+ if directive == nil {
+ return action, result
+ }
+ nodeName := ""
+ if node.Name != nil {
+ nodeName = node.Name.Value
+ }
+ argNames := []string{}
+ var directiveArgDef *Argument
+ for _, arg := range directive.Args {
+ argNames = append(argNames, arg.Name())
+ if arg.Name() == nodeName {
+ directiveArgDef = arg
+ }
+ }
+ if directiveArgDef == nil {
+ reportError(
+ context,
+ unknownDirectiveArgMessage(nodeName, directive.Name, suggestionList(nodeName, argNames)),
+ []ast.Node{node},
+ )
+ }
+ }
+
+ }
+ return action, result
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+func MisplaceDirectiveMessage(directiveName string, location string) string {
+ return fmt.Sprintf(`Directive "%v" may not be used on %v.`, directiveName, location)
+}
+
+// KnownDirectivesRule Known directives
+//
+// A GraphQL document is only valid if all `@directives` are known by the
+// schema and legally positioned.
+func KnownDirectivesRule(context *ValidationContext) *ValidationRuleInstance {
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.Directive: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ var action = visitor.ActionNoChange
+ var result interface{}
+ if node, ok := p.Node.(*ast.Directive); ok {
+
+ nodeName := ""
+ if node.Name != nil {
+ nodeName = node.Name.Value
+ }
+
+ var directiveDef *Directive
+ for _, def := range context.Schema().Directives() {
+ if def.Name == nodeName {
+ directiveDef = def
+ }
+ }
+ if directiveDef == nil {
+ return reportError(
+ context,
+ fmt.Sprintf(`Unknown directive "%v".`, nodeName),
+ []ast.Node{node},
+ )
+ }
+
+ candidateLocation := getDirectiveLocationForASTPath(p.Ancestors)
+
+ directiveHasLocation := false
+ for _, loc := range directiveDef.Locations {
+ if loc == candidateLocation {
+ directiveHasLocation = true
+ break
+ }
+ }
+
+ if candidateLocation == "" {
+ reportError(
+ context,
+ MisplaceDirectiveMessage(nodeName, node.GetKind()),
+ []ast.Node{node},
+ )
+ } else if !directiveHasLocation {
+ reportError(
+ context,
+ MisplaceDirectiveMessage(nodeName, candidateLocation),
+ []ast.Node{node},
+ )
+ }
+
+ }
+ return action, result
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+func getDirectiveLocationForASTPath(ancestors []ast.Node) string {
+ var appliedTo ast.Node
+ if len(ancestors) > 0 {
+ appliedTo = ancestors[len(ancestors)-1]
+ }
+ if appliedTo == nil {
+ return ""
+ }
+ kind := appliedTo.GetKind()
+ if kind == kinds.OperationDefinition {
+ appliedTo, _ := appliedTo.(*ast.OperationDefinition)
+ if appliedTo.Operation == ast.OperationTypeQuery {
+ return DirectiveLocationQuery
+ }
+ if appliedTo.Operation == ast.OperationTypeMutation {
+ return DirectiveLocationMutation
+ }
+ if appliedTo.Operation == ast.OperationTypeSubscription {
+ return DirectiveLocationSubscription
+ }
+ }
+ if kind == kinds.Field {
+ return DirectiveLocationField
+ }
+ if kind == kinds.FragmentSpread {
+ return DirectiveLocationFragmentSpread
+ }
+ if kind == kinds.InlineFragment {
+ return DirectiveLocationInlineFragment
+ }
+ if kind == kinds.FragmentDefinition {
+ return DirectiveLocationFragmentDefinition
+ }
+ if kind == kinds.SchemaDefinition {
+ return DirectiveLocationSchema
+ }
+ if kind == kinds.ScalarDefinition {
+ return DirectiveLocationScalar
+ }
+ if kind == kinds.ObjectDefinition {
+ return DirectiveLocationObject
+ }
+ if kind == kinds.FieldDefinition {
+ return DirectiveLocationFieldDefinition
+ }
+ if kind == kinds.InterfaceDefinition {
+ return DirectiveLocationInterface
+ }
+ if kind == kinds.UnionDefinition {
+ return DirectiveLocationUnion
+ }
+ if kind == kinds.EnumDefinition {
+ return DirectiveLocationEnum
+ }
+ if kind == kinds.EnumValueDefinition {
+ return DirectiveLocationEnumValue
+ }
+ if kind == kinds.InputObjectDefinition {
+ return DirectiveLocationInputObject
+ }
+ if kind == kinds.InputValueDefinition {
+ var parentNode ast.Node
+ if len(ancestors) >= 3 {
+ parentNode = ancestors[len(ancestors)-3]
+ }
+ if parentNode.GetKind() == kinds.InputObjectDefinition {
+ return DirectiveLocationInputFieldDefinition
+ } else {
+ return DirectiveLocationArgumentDefinition
+ }
+ }
+ return ""
+}
+
+// KnownFragmentNamesRule Known fragment names
+//
+// A GraphQL document is only valid if all `...Fragment` fragment spreads refer
+// to fragments defined in the same document.
+func KnownFragmentNamesRule(context *ValidationContext) *ValidationRuleInstance {
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.FragmentSpread: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ var action = visitor.ActionNoChange
+ var result interface{}
+ if node, ok := p.Node.(*ast.FragmentSpread); ok {
+
+ fragmentName := ""
+ if node.Name != nil {
+ fragmentName = node.Name.Value
+ }
+
+ fragment := context.Fragment(fragmentName)
+ if fragment == nil {
+ reportError(
+ context,
+ fmt.Sprintf(`Unknown fragment "%v".`, fragmentName),
+ []ast.Node{node.Name},
+ )
+ }
+ }
+ return action, result
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+func unknownTypeMessage(typeName string, suggestedTypes []string) string {
+ message := fmt.Sprintf(`Unknown type "%v".`, typeName)
+ if len(suggestedTypes) > 0 {
+ message = fmt.Sprintf(`%v Did you mean %v?`, message, quotedOrList(suggestedTypes))
+ }
+
+ return message
+}
+
+// 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 KnownTypeNamesRule(context *ValidationContext) *ValidationRuleInstance {
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.ObjectDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ return visitor.ActionSkip, nil
+ },
+ },
+ kinds.InterfaceDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ return visitor.ActionSkip, nil
+ },
+ },
+ kinds.UnionDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ return visitor.ActionSkip, nil
+ },
+ },
+ kinds.InputObjectDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ return visitor.ActionSkip, nil
+ },
+ },
+ kinds.Named: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.Named); ok {
+ typeNameValue := ""
+ typeName := node.Name
+ if typeName != nil {
+ typeNameValue = typeName.Value
+ }
+ ttype := context.Schema().Type(typeNameValue)
+ if ttype == nil {
+ suggestedTypes := []string{}
+ for key := range context.Schema().TypeMap() {
+ suggestedTypes = append(suggestedTypes, key)
+ }
+ reportError(
+ context,
+ unknownTypeMessage(typeNameValue, suggestionList(typeNameValue, suggestedTypes)),
+ []ast.Node{node},
+ )
+ }
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+// 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 LoneAnonymousOperationRule(context *ValidationContext) *ValidationRuleInstance {
+ var operationCount = 0
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.Document: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.Document); ok {
+ operationCount = 0
+ for _, definition := range node.Definitions {
+ if definition.GetKind() == kinds.OperationDefinition {
+ operationCount = operationCount + 1
+ }
+ }
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ kinds.OperationDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.OperationDefinition); ok {
+ if node.Name == nil && operationCount > 1 {
+ reportError(
+ context,
+ `This anonymous operation must be the only defined operation.`,
+ []ast.Node{node},
+ )
+ }
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+func CycleErrorMessage(fragName string, spreadNames []string) string {
+ via := ""
+ if len(spreadNames) > 0 {
+ via = " via " + strings.Join(spreadNames, ", ")
+ }
+ return fmt.Sprintf(`Cannot spread fragment "%v" within itself%v.`, fragName, via)
+}
+
+// NoFragmentCyclesRule No fragment cycles
+func NoFragmentCyclesRule(context *ValidationContext) *ValidationRuleInstance {
+
+ // Tracks already visited fragments to maintain O(N) and to ensure that cycles
+ // are not redundantly reported.
+ visitedFrags := map[string]bool{}
+
+ // Array of AST nodes used to produce meaningful errors
+ spreadPath := []*ast.FragmentSpread{}
+
+ // Position in the spread path
+ spreadPathIndexByName := map[string]int{}
+
+ // This does a straight-forward DFS to find cycles.
+ // It does not terminate when a cycle was found but continues to explore
+ // the graph to find all possible cycles.
+ var detectCycleRecursive func(fragment *ast.FragmentDefinition)
+ detectCycleRecursive = func(fragment *ast.FragmentDefinition) {
+
+ fragmentName := ""
+ if fragment.Name != nil {
+ fragmentName = fragment.Name.Value
+ }
+ visitedFrags[fragmentName] = true
+
+ spreadNodes := context.FragmentSpreads(fragment.SelectionSet)
+ if len(spreadNodes) == 0 {
+ return
+ }
+
+ spreadPathIndexByName[fragmentName] = len(spreadPath)
+
+ for _, spreadNode := range spreadNodes {
+
+ spreadName := ""
+ if spreadNode.Name != nil {
+ spreadName = spreadNode.Name.Value
+ }
+ cycleIndex, ok := spreadPathIndexByName[spreadName]
+ if !ok {
+ spreadPath = append(spreadPath, spreadNode)
+ if visited, ok := visitedFrags[spreadName]; !ok || !visited {
+ spreadFragment := context.Fragment(spreadName)
+ if spreadFragment != nil {
+ detectCycleRecursive(spreadFragment)
+ }
+ }
+ spreadPath = spreadPath[:len(spreadPath)-1]
+ } else {
+ cyclePath := spreadPath[cycleIndex:]
+
+ spreadNames := []string{}
+ for _, s := range cyclePath {
+ name := ""
+ if s.Name != nil {
+ name = s.Name.Value
+ }
+ spreadNames = append(spreadNames, name)
+ }
+
+ nodes := []ast.Node{}
+ for _, c := range cyclePath {
+ nodes = append(nodes, c)
+ }
+ nodes = append(nodes, spreadNode)
+
+ reportError(
+ context,
+ CycleErrorMessage(spreadName, spreadNames),
+ nodes,
+ )
+ }
+
+ }
+ delete(spreadPathIndexByName, fragmentName)
+
+ }
+
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.OperationDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ return visitor.ActionSkip, nil
+ },
+ },
+ kinds.FragmentDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.FragmentDefinition); ok && node != nil {
+ nodeName := ""
+ if node.Name != nil {
+ nodeName = node.Name.Value
+ }
+ if _, ok := visitedFrags[nodeName]; !ok {
+ detectCycleRecursive(node)
+ }
+ }
+ return visitor.ActionSkip, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+func UndefinedVarMessage(varName string, opName string) string {
+ if opName != "" {
+ return fmt.Sprintf(`Variable "$%v" is not defined by operation "%v".`, varName, opName)
+ }
+ return fmt.Sprintf(`Variable "$%v" is not defined.`, varName)
+}
+
+// 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 NoUndefinedVariablesRule(context *ValidationContext) *ValidationRuleInstance {
+ var variableNameDefined = map[string]bool{}
+
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.OperationDefinition: {
+ Enter: func(p visitor.VisitFuncParams) (string, interface{}) {
+ variableNameDefined = map[string]bool{}
+ return visitor.ActionNoChange, nil
+ },
+ Leave: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if operation, ok := p.Node.(*ast.OperationDefinition); ok && operation != nil {
+ usages := context.RecursiveVariableUsages(operation)
+
+ for _, usage := range usages {
+ if usage == nil {
+ continue
+ }
+ if usage.Node == nil {
+ continue
+ }
+ varName := ""
+ if usage.Node.Name != nil {
+ varName = usage.Node.Name.Value
+ }
+ opName := ""
+ if operation.Name != nil {
+ opName = operation.Name.Value
+ }
+ if res, ok := variableNameDefined[varName]; !ok || !res {
+ reportError(
+ context,
+ UndefinedVarMessage(varName, opName),
+ []ast.Node{usage.Node, operation},
+ )
+ }
+ }
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ kinds.VariableDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.VariableDefinition); ok && node != nil {
+ variableName := ""
+ if node.Variable != nil && node.Variable.Name != nil {
+ variableName = node.Variable.Name.Value
+ }
+ variableNameDefined[variableName] = true
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+// 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 NoUnusedFragmentsRule(context *ValidationContext) *ValidationRuleInstance {
+
+ var fragmentDefs = []*ast.FragmentDefinition{}
+ var operationDefs = []*ast.OperationDefinition{}
+
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.OperationDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.OperationDefinition); ok && node != nil {
+ operationDefs = append(operationDefs, node)
+ }
+ return visitor.ActionSkip, nil
+ },
+ },
+ kinds.FragmentDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.FragmentDefinition); ok && node != nil {
+ fragmentDefs = append(fragmentDefs, node)
+ }
+ return visitor.ActionSkip, nil
+ },
+ },
+ kinds.Document: {
+ Leave: func(p visitor.VisitFuncParams) (string, interface{}) {
+ fragmentNameUsed := map[string]bool{}
+ for _, operation := range operationDefs {
+ fragments := context.RecursivelyReferencedFragments(operation)
+ for _, fragment := range fragments {
+ fragName := ""
+ if fragment.Name != nil {
+ fragName = fragment.Name.Value
+ }
+ fragmentNameUsed[fragName] = true
+ }
+ }
+
+ for _, def := range fragmentDefs {
+ defName := ""
+ if def.Name != nil {
+ defName = def.Name.Value
+ }
+
+ isFragNameUsed, ok := fragmentNameUsed[defName]
+ if !ok || isFragNameUsed != true {
+ reportError(
+ context,
+ fmt.Sprintf(`Fragment "%v" is never used.`, defName),
+ []ast.Node{def},
+ )
+ }
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+func UnusedVariableMessage(varName string, opName string) string {
+ if opName != "" {
+ return fmt.Sprintf(`Variable "$%v" is never used in operation "%v".`, varName, opName)
+ }
+ return fmt.Sprintf(`Variable "$%v" is never used.`, varName)
+}
+
+// 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 NoUnusedVariablesRule(context *ValidationContext) *ValidationRuleInstance {
+
+ var variableDefs = []*ast.VariableDefinition{}
+
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.OperationDefinition: {
+ Enter: func(p visitor.VisitFuncParams) (string, interface{}) {
+ variableDefs = []*ast.VariableDefinition{}
+ return visitor.ActionNoChange, nil
+ },
+ Leave: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if operation, ok := p.Node.(*ast.OperationDefinition); ok && operation != nil {
+ variableNameUsed := map[string]bool{}
+ usages := context.RecursiveVariableUsages(operation)
+
+ for _, usage := range usages {
+ varName := ""
+ if usage != nil && usage.Node != nil && usage.Node.Name != nil {
+ varName = usage.Node.Name.Value
+ }
+ if varName != "" {
+ variableNameUsed[varName] = true
+ }
+ }
+ for _, variableDef := range variableDefs {
+ variableName := ""
+ if variableDef != nil && variableDef.Variable != nil && variableDef.Variable.Name != nil {
+ variableName = variableDef.Variable.Name.Value
+ }
+ opName := ""
+ if operation.Name != nil {
+ opName = operation.Name.Value
+ }
+ if res, ok := variableNameUsed[variableName]; !ok || !res {
+ reportError(
+ context,
+ UnusedVariableMessage(variableName, opName),
+ []ast.Node{variableDef},
+ )
+ }
+ }
+
+ }
+
+ return visitor.ActionNoChange, nil
+ },
+ },
+ kinds.VariableDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if def, ok := p.Node.(*ast.VariableDefinition); ok && def != nil {
+ variableDefs = append(variableDefs, def)
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+func getFragmentType(context *ValidationContext, name string) Type {
+ frag := context.Fragment(name)
+ if frag == nil {
+ return nil
+ }
+ ttype, _ := typeFromAST(*context.Schema(), frag.TypeCondition)
+ return ttype
+}
+
+func doTypesOverlap(schema *Schema, t1 Type, t2 Type) bool {
+ if t1 == t2 {
+ return true
+ }
+ if _, ok := t1.(*Object); ok {
+ if _, ok := t2.(*Object); ok {
+ return false
+ }
+ if t2, ok := t2.(Abstract); ok {
+ for _, ttype := range schema.PossibleTypes(t2) {
+ if ttype == t1 {
+ return true
+ }
+ }
+ return false
+ }
+ }
+ if t1, ok := t1.(Abstract); ok {
+ if _, ok := t2.(*Object); ok {
+ for _, ttype := range schema.PossibleTypes(t1) {
+ if ttype == t2 {
+ return true
+ }
+ }
+ return false
+ }
+ t1TypeNames := map[string]bool{}
+ for _, ttype := range schema.PossibleTypes(t1) {
+ t1TypeNames[ttype.Name()] = true
+ }
+ if t2, ok := t2.(Abstract); ok {
+ for _, ttype := range schema.PossibleTypes(t2) {
+ if hasT1TypeName, _ := t1TypeNames[ttype.Name()]; hasT1TypeName {
+ return true
+ }
+ }
+ return false
+ }
+ }
+ return false
+}
+
+// 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 PossibleFragmentSpreadsRule(context *ValidationContext) *ValidationRuleInstance {
+
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.InlineFragment: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.InlineFragment); ok && node != nil {
+ fragType := context.Type()
+ parentType, _ := context.ParentType().(Type)
+
+ if fragType != nil && parentType != nil && !doTypesOverlap(context.Schema(), fragType, parentType) {
+ reportError(
+ context,
+ fmt.Sprintf(`Fragment cannot be spread here as objects of `+
+ `type "%v" can never be of type "%v".`, parentType, fragType),
+ []ast.Node{node},
+ )
+ }
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ kinds.FragmentSpread: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.FragmentSpread); ok && node != nil {
+ fragName := ""
+ if node.Name != nil {
+ fragName = node.Name.Value
+ }
+ fragType := getFragmentType(context, fragName)
+ parentType, _ := context.ParentType().(Type)
+ if fragType != nil && parentType != nil && !doTypesOverlap(context.Schema(), fragType, parentType) {
+ reportError(
+ context,
+ fmt.Sprintf(`Fragment "%v" cannot be spread here as objects of `+
+ `type "%v" can never be of type "%v".`, fragName, parentType, fragType),
+ []ast.Node{node},
+ )
+ }
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+// ProvidedNonNullArgumentsRule Provided required arguments
+//
+// A field or directive is only valid if all required (non-null) field arguments
+// have been provided.
+func ProvidedNonNullArgumentsRule(context *ValidationContext) *ValidationRuleInstance {
+
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.Field: {
+ Leave: func(p visitor.VisitFuncParams) (string, interface{}) {
+ // Validate on leave to allow for deeper errors to appear first.
+ if fieldAST, ok := p.Node.(*ast.Field); ok && fieldAST != nil {
+ fieldDef := context.FieldDef()
+ if fieldDef == nil {
+ return visitor.ActionSkip, nil
+ }
+
+ argASTs := fieldAST.Arguments
+
+ argASTMap := map[string]*ast.Argument{}
+ for _, arg := range argASTs {
+ name := ""
+ if arg.Name != nil {
+ name = arg.Name.Value
+ }
+ argASTMap[name] = arg
+ }
+ for _, argDef := range fieldDef.Args {
+ argAST, _ := argASTMap[argDef.Name()]
+ if argAST == nil {
+ if argDefType, ok := argDef.Type.(*NonNull); ok {
+ fieldName := ""
+ if fieldAST.Name != nil {
+ fieldName = fieldAST.Name.Value
+ }
+ reportError(
+ context,
+ fmt.Sprintf(`Field "%v" argument "%v" of type "%v" `+
+ `is required but not provided.`, fieldName, argDef.Name(), argDefType),
+ []ast.Node{fieldAST},
+ )
+ }
+ }
+ }
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ kinds.Directive: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ // Validate on leave to allow for deeper errors to appear first.
+
+ if directiveAST, ok := p.Node.(*ast.Directive); ok && directiveAST != nil {
+ directiveDef := context.Directive()
+ if directiveDef == nil {
+ return visitor.ActionSkip, nil
+ }
+ argASTs := directiveAST.Arguments
+
+ argASTMap := map[string]*ast.Argument{}
+ for _, arg := range argASTs {
+ name := ""
+ if arg.Name != nil {
+ name = arg.Name.Value
+ }
+ argASTMap[name] = arg
+ }
+
+ for _, argDef := range directiveDef.Args {
+ argAST, _ := argASTMap[argDef.Name()]
+ if argAST == nil {
+ if argDefType, ok := argDef.Type.(*NonNull); ok {
+ directiveName := ""
+ if directiveAST.Name != nil {
+ directiveName = directiveAST.Name.Value
+ }
+ reportError(
+ context,
+ fmt.Sprintf(`Directive "@%v" argument "%v" of type `+
+ `"%v" is required but not provided.`, directiveName, argDef.Name(), argDefType),
+ []ast.Node{directiveAST},
+ )
+ }
+ }
+ }
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+// ScalarLeafsRule Scalar leafs
+//
+// A GraphQL document is valid only if all leaf fields (fields without
+// sub selections) are of scalar or enum types.
+func ScalarLeafsRule(context *ValidationContext) *ValidationRuleInstance {
+
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.Field: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.Field); ok && node != nil {
+ nodeName := ""
+ if node.Name != nil {
+ nodeName = node.Name.Value
+ }
+ ttype := context.Type()
+ if ttype != nil {
+ if IsLeafType(ttype) {
+ if node.SelectionSet != nil {
+ reportError(
+ context,
+ fmt.Sprintf(`Field "%v" of type "%v" must not have a sub selection.`, nodeName, ttype),
+ []ast.Node{node.SelectionSet},
+ )
+ }
+ } else if node.SelectionSet == nil {
+ reportError(
+ context,
+ fmt.Sprintf(`Field "%v" of type "%v" must have a sub selection.`, nodeName, ttype),
+ []ast.Node{node},
+ )
+ }
+ }
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+// UniqueArgumentNamesRule Unique argument names
+//
+// A GraphQL field or directive is only valid if all supplied arguments are
+// uniquely named.
+func UniqueArgumentNamesRule(context *ValidationContext) *ValidationRuleInstance {
+ knownArgNames := map[string]*ast.Name{}
+
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.Field: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ knownArgNames = map[string]*ast.Name{}
+ return visitor.ActionNoChange, nil
+ },
+ },
+ kinds.Directive: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ knownArgNames = map[string]*ast.Name{}
+ return visitor.ActionNoChange, nil
+ },
+ },
+ kinds.Argument: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.Argument); ok {
+ argName := ""
+ if node.Name != nil {
+ argName = node.Name.Value
+ }
+ if nameAST, ok := knownArgNames[argName]; ok {
+ reportError(
+ context,
+ fmt.Sprintf(`There can be only one argument named "%v".`, argName),
+ []ast.Node{nameAST, node.Name},
+ )
+ } else {
+ knownArgNames[argName] = node.Name
+ }
+ }
+ return visitor.ActionSkip, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+// UniqueFragmentNamesRule Unique fragment names
+//
+// A GraphQL document is only valid if all defined fragments have unique names.
+func UniqueFragmentNamesRule(context *ValidationContext) *ValidationRuleInstance {
+ knownFragmentNames := map[string]*ast.Name{}
+
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.OperationDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ return visitor.ActionSkip, nil
+ },
+ },
+ kinds.FragmentDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.FragmentDefinition); ok && node != nil {
+ fragmentName := ""
+ if node.Name != nil {
+ fragmentName = node.Name.Value
+ }
+ if nameAST, ok := knownFragmentNames[fragmentName]; ok {
+ reportError(
+ context,
+ fmt.Sprintf(`There can only be one fragment named "%v".`, fragmentName),
+ []ast.Node{nameAST, node.Name},
+ )
+ } else {
+ knownFragmentNames[fragmentName] = node.Name
+ }
+ }
+ return visitor.ActionSkip, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+// UniqueInputFieldNamesRule Unique input field names
+//
+// A GraphQL input object value is only valid if all supplied fields are
+// uniquely named.
+func UniqueInputFieldNamesRule(context *ValidationContext) *ValidationRuleInstance {
+ knownNameStack := []map[string]*ast.Name{}
+ knownNames := map[string]*ast.Name{}
+
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.ObjectValue: {
+ Enter: func(p visitor.VisitFuncParams) (string, interface{}) {
+ knownNameStack = append(knownNameStack, knownNames)
+ knownNames = map[string]*ast.Name{}
+ return visitor.ActionNoChange, nil
+ },
+ Leave: func(p visitor.VisitFuncParams) (string, interface{}) {
+ // pop
+ knownNames, knownNameStack = knownNameStack[len(knownNameStack)-1], knownNameStack[:len(knownNameStack)-1]
+ return visitor.ActionNoChange, nil
+ },
+ },
+ kinds.ObjectField: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.ObjectField); ok {
+ fieldName := ""
+ if node.Name != nil {
+ fieldName = node.Name.Value
+ }
+ if knownNameAST, ok := knownNames[fieldName]; ok {
+ reportError(
+ context,
+ fmt.Sprintf(`There can be only one input field named "%v".`, fieldName),
+ []ast.Node{knownNameAST, node.Name},
+ )
+ } else {
+ knownNames[fieldName] = node.Name
+ }
+
+ }
+ return visitor.ActionSkip, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+// UniqueOperationNamesRule Unique operation names
+//
+// A GraphQL document is only valid if all defined operations have unique names.
+func UniqueOperationNamesRule(context *ValidationContext) *ValidationRuleInstance {
+ knownOperationNames := make(map[string]ast.Node)
+
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.OperationDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.OperationDefinition); ok && node != nil {
+ operationName := ""
+ if node.Name != nil {
+ operationName = node.Name.Value
+ }
+ var errNode ast.Node = node
+ if node.Name != nil {
+ errNode = node.Name
+ }
+ if nameAST, ok := knownOperationNames[operationName]; ok {
+ reportError(
+ context,
+ fmt.Sprintf(`There can only be one operation named "%v".`, operationName),
+ []ast.Node{nameAST, errNode},
+ )
+ } else {
+ knownOperationNames[operationName] = errNode
+ }
+ }
+ return visitor.ActionSkip, nil
+ },
+ },
+ kinds.FragmentDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ return visitor.ActionSkip, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+// UniqueVariableNamesRule Unique variable names
+//
+// A GraphQL operation is only valid if all its variables are uniquely named.
+func UniqueVariableNamesRule(context *ValidationContext) *ValidationRuleInstance {
+ knownVariableNames := map[string]*ast.Name{}
+
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.OperationDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.OperationDefinition); ok && node != nil {
+ knownVariableNames = map[string]*ast.Name{}
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ kinds.VariableDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.VariableDefinition); ok && node != nil {
+ variableName := ""
+ var variableNameAST *ast.Name
+ if node.Variable != nil && node.Variable.Name != nil {
+ variableNameAST = node.Variable.Name
+ variableName = node.Variable.Name.Value
+ }
+ if nameAST, ok := knownVariableNames[variableName]; ok {
+ reportError(
+ context,
+ fmt.Sprintf(`There can only be one variable named "%v".`, variableName),
+ []ast.Node{nameAST, variableNameAST},
+ )
+ } else {
+ knownVariableNames[variableName] = variableNameAST
+ }
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+// 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 VariablesAreInputTypesRule(context *ValidationContext) *ValidationRuleInstance {
+
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.VariableDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if node, ok := p.Node.(*ast.VariableDefinition); ok && node != nil {
+ ttype, _ := typeFromAST(*context.Schema(), node.Type)
+
+ // If the variable type is not an input type, return an error.
+ if ttype != nil && !IsInputType(ttype) {
+ variableName := ""
+ if node.Variable != nil && node.Variable.Name != nil {
+ variableName = node.Variable.Name.Value
+ }
+ reportError(
+ context,
+ fmt.Sprintf(`Variable "$%v" cannot be non-input type "%v".`,
+ variableName, printer.Print(node.Type)),
+ []ast.Node{node.Type},
+ )
+ }
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+// If a variable definition has a default value, it's effectively non-null.
+func effectiveType(varType Type, varDef *ast.VariableDefinition) Type {
+ if varDef.DefaultValue == nil {
+ return varType
+ }
+ if _, ok := varType.(*NonNull); ok {
+ return varType
+ }
+ return NewNonNull(varType)
+}
+
+// VariablesInAllowedPositionRule Variables passed to field arguments conform to type
+func VariablesInAllowedPositionRule(context *ValidationContext) *ValidationRuleInstance {
+
+ varDefMap := map[string]*ast.VariableDefinition{}
+
+ visitorOpts := &visitor.VisitorOptions{
+ KindFuncMap: map[string]visitor.NamedVisitFuncs{
+ kinds.OperationDefinition: {
+ Enter: func(p visitor.VisitFuncParams) (string, interface{}) {
+ varDefMap = map[string]*ast.VariableDefinition{}
+ return visitor.ActionNoChange, nil
+ },
+ Leave: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if operation, ok := p.Node.(*ast.OperationDefinition); ok {
+
+ usages := context.RecursiveVariableUsages(operation)
+ for _, usage := range usages {
+ varName := ""
+ if usage != nil && usage.Node != nil && usage.Node.Name != nil {
+ varName = usage.Node.Name.Value
+ }
+ varDef, _ := varDefMap[varName]
+ if varDef != nil && usage.Type != nil {
+ varType, err := typeFromAST(*context.Schema(), varDef.Type)
+ if err != nil {
+ varType = nil
+ }
+ if varType != nil && !isTypeSubTypeOf(context.Schema(), effectiveType(varType, varDef), usage.Type) {
+ reportError(
+ context,
+ fmt.Sprintf(`Variable "$%v" of type "%v" used in position `+
+ `expecting type "%v".`, varName, varType, usage.Type),
+ []ast.Node{varDef, usage.Node},
+ )
+ }
+ }
+ }
+
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ kinds.VariableDefinition: {
+ Kind: func(p visitor.VisitFuncParams) (string, interface{}) {
+ if varDefAST, ok := p.Node.(*ast.VariableDefinition); ok {
+ defName := ""
+ if varDefAST.Variable != nil && varDefAST.Variable.Name != nil {
+ defName = varDefAST.Variable.Name.Value
+ }
+ if defName != "" {
+ varDefMap[defName] = varDefAST
+ }
+ }
+ return visitor.ActionNoChange, nil
+ },
+ },
+ },
+ }
+ return &ValidationRuleInstance{
+ VisitorOpts: visitorOpts,
+ }
+}
+
+// Utility for validators which determines if a value literal AST is valid given
+// an input type.
+//
+// Note that this only validates literal values, variables are assumed to
+// provide values of the correct type.
+func isValidLiteralValue(ttype Input, valueAST ast.Value) (bool, []string) {
+ // A value must be provided if the type is non-null.
+ if ttype, ok := ttype.(*NonNull); ok {
+ if e := ttype.Error(); e != nil {
+ return false, []string{e.Error()}
+ }
+ if valueAST == nil {
+ if ttype.OfType.Name() != "" {
+ return false, []string{fmt.Sprintf(`Expected "%v!", found null.`, ttype.OfType.Name())}
+ }
+ return false, []string{"Expected non-null value, found null."}
+ }
+ ofType, _ := ttype.OfType.(Input)
+ return isValidLiteralValue(ofType, valueAST)
+ }
+
+ if valueAST == nil {
+ return true, nil
+ }
+
+ // This function only tests literals, and assumes variables will provide
+ // values of the correct type.
+ if valueAST.GetKind() == kinds.Variable {
+ return true, nil
+ }
+
+ // Lists accept a non-list value as a list of one.
+ if ttype, ok := ttype.(*List); ok {
+ itemType, _ := ttype.OfType.(Input)
+ if valueAST, ok := valueAST.(*ast.ListValue); ok {
+ messagesReduce := []string{}
+ for _, value := range valueAST.Values {
+ _, messages := isValidLiteralValue(itemType, value)
+ for idx, message := range messages {
+ messagesReduce = append(messagesReduce, fmt.Sprintf(`In element #%v: %v`, idx+1, message))
+ }
+ }
+ return (len(messagesReduce) == 0), messagesReduce
+ }
+ return isValidLiteralValue(itemType, valueAST)
+
+ }
+
+ // Input objects check each defined field and look for undefined fields.
+ if ttype, ok := ttype.(*InputObject); ok {
+ valueAST, ok := valueAST.(*ast.ObjectValue)
+ if !ok {
+ return false, []string{fmt.Sprintf(`Expected "%v", found not an object.`, ttype.Name())}
+ }
+ fields := ttype.Fields()
+ messagesReduce := []string{}
+
+ // Ensure every provided field is defined.
+ fieldASTs := valueAST.Fields
+ fieldASTMap := map[string]*ast.ObjectField{}
+ for _, fieldAST := range fieldASTs {
+ fieldASTName := ""
+ if fieldAST.Name != nil {
+ fieldASTName = fieldAST.Name.Value
+ }
+
+ fieldASTMap[fieldASTName] = fieldAST
+
+ field, ok := fields[fieldASTName]
+ if !ok || field == nil {
+ messagesReduce = append(messagesReduce, fmt.Sprintf(`In field "%v": Unknown field.`, fieldASTName))
+ }
+ }
+ // Ensure every defined field is valid.
+ for fieldName, field := range fields {
+ fieldAST, _ := fieldASTMap[fieldName]
+ var fieldASTValue ast.Value
+ if fieldAST != nil {
+ fieldASTValue = fieldAST.Value
+ }
+ if isValid, messages := isValidLiteralValue(field.Type, fieldASTValue); !isValid {
+ for _, message := range messages {
+ messagesReduce = append(messagesReduce, fmt.Sprintf("In field \"%v\": %v", fieldName, message))
+ }
+ }
+ }
+ return (len(messagesReduce) == 0), messagesReduce
+ }
+
+ if ttype, ok := ttype.(*Scalar); ok {
+ if isNullish(ttype.ParseLiteral(valueAST)) {
+ return false, []string{fmt.Sprintf(`Expected type "%v", found %v.`, ttype.Name(), printer.Print(valueAST))}
+ }
+ }
+ if ttype, ok := ttype.(*Enum); ok {
+ if isNullish(ttype.ParseLiteral(valueAST)) {
+ return false, []string{fmt.Sprintf(`Expected type "%v", found %v.`, ttype.Name(), printer.Print(valueAST))}
+ }
+ }
+
+ return true, nil
+}
+
+// Internal struct to sort results from suggestionList()
+type suggestionListResult struct {
+ Options []string
+ Distances []float64
+}
+
+func (s suggestionListResult) Len() int {
+ return len(s.Options)
+}
+func (s suggestionListResult) Swap(i, j int) {
+ s.Options[i], s.Options[j] = s.Options[j], s.Options[i]
+}
+func (s suggestionListResult) Less(i, j int) bool {
+ return s.Distances[i] < s.Distances[j]
+}
+
+// suggestionList Given an invalid input string and a list of valid options, returns a filtered
+// list of valid options sorted based on their similarity with the input.
+func suggestionList(input string, options []string) []string {
+ dists := []float64{}
+ filteredOpts := []string{}
+ inputThreshold := float64(len(input) / 2)
+
+ for _, opt := range options {
+ dist := lexicalDistance(input, opt)
+ threshold := math.Max(inputThreshold, float64(len(opt)/2))
+ threshold = math.Max(threshold, 1)
+ if dist <= threshold {
+ filteredOpts = append(filteredOpts, opt)
+ dists = append(dists, dist)
+ }
+ }
+ //sort results
+ suggested := suggestionListResult{filteredOpts, dists}
+ sort.Sort(suggested)
+ return suggested.Options
+}
+
+// lexicalDistance Computes the lexical distance between strings A and B.
+// The "distance" between two strings is given by counting the minimum number
+// of edits needed to transform string A into string B. An edit can be an
+// insertion, deletion, or substitution of a single character, or a swap of two
+// adjacent characters.
+// This distance can be useful for detecting typos in input or sorting
+func lexicalDistance(a, b string) float64 {
+ d := [][]float64{}
+ aLen := len(a)
+ bLen := len(b)
+ for i := 0; i <= aLen; i++ {
+ d = append(d, []float64{float64(i)})
+ }
+ for k := 1; k <= bLen; k++ {
+ d[0] = append(d[0], float64(k))
+ }
+
+ for i := 1; i <= aLen; i++ {
+ for k := 1; k <= bLen; k++ {
+ cost := 1.0
+ if a[i-1] == b[k-1] {
+ cost = 0.0
+ }
+ minCostFloat := math.Min(
+ d[i-1][k]+1.0,
+ d[i][k-1]+1.0,
+ )
+ minCostFloat = math.Min(
+ minCostFloat,
+ d[i-1][k-1]+cost,
+ )
+ d[i] = append(d[i], minCostFloat)
+
+ if i > 1 && k < 1 &&
+ a[i-1] == b[k-2] &&
+ a[i-2] == b[k-1] {
+ d[i][k] = math.Min(d[i][k], d[i-2][k-2]+cost)
+ }
+ }
+ }
+
+ return d[aLen][bLen]
+}
generated by cgit (git 2.34.1) at 2024-09-20 11:49:31 +0000