FieldsOnCorrectType, ScalarLeafs, VariablesAreInputTypes rules

+ stubs for all validation rules

Author: dittos

graphql/core/type/definition.py

@@ -2,91 +2,6 @@
 from ..error import Error
 from ..language import ast
 
-'''
-/**
- * These are all of the possible kinds of types.
- */
-export type GraphQLType =
-  GraphQLScalarType |
-  GraphQLObjectType |
-  GraphQLInterfaceType |
-  GraphQLUnionType |
-  GraphQLEnumType |
-  GraphQLInputObjectType |
-  GraphQLList |
-  GraphQLNonNull;
-
-// Predicates
-
-/**
- * These types may be used as output types as the result of fields.
- */
-export type GraphQLOutputType =
-  GraphQLScalarType |
-  GraphQLObjectType |
-  GraphQLInterfaceType |
-  GraphQLUnionType |
-  GraphQLEnumType |
-  GraphQLList |
-  GraphQLNonNull;
-
-export function isOutputType(type: ?GraphQLType): boolean {
-  var nakedType = getUnmodifiedType(type);
-  return (
-    nakedType instanceof GraphQLScalarType ||
-    nakedType instanceof GraphQLObjectType ||
-    nakedType instanceof GraphQLInterfaceType ||
-    nakedType instanceof GraphQLUnionType ||
-    nakedType instanceof GraphQLEnumType
-  );
-}
-
-/**
- * These types may describe types which may be leaf values.
- */
-export type GraphQLLeafType =
-  GraphQLScalarType |
-  GraphQLEnumType;
-
-export function isLeafType(type: ?GraphQLType): boolean {
-  var nakedType = getUnmodifiedType(type);
-  return (
-    nakedType instanceof GraphQLScalarType ||
-    nakedType instanceof GraphQLEnumType
-  );
-}
-
-/**
- * These types may describe the parent context of a selection set.
- */
-export type GraphQLAbstractType =
-  GraphQLInterfaceType |
-  GraphQLUnionType;
-
-export function isAbstractType(type: ?GraphQLType): boolean {
-  return (
-    type instanceof GraphQLInterfaceType ||
-    type instanceof GraphQLUnionType
-  );
-}
-
-/**
- * These types can all accept null as a value.
- */
-export type GraphQLNullableType =
-  GraphQLScalarType |
-  GraphQLObjectType |
-  GraphQLInterfaceType |
-  GraphQLUnionType |
-  GraphQLEnumType |
-  GraphQLInputObjectType |
-  GraphQLList;
-
-export function getNullableType(type: ?GraphQLType): ?GraphQLNullableType {
-  return type instanceof GraphQLNonNull ? type.ofType : type;
-}
-'''
-
 
 def is_input_type(type):
     named_type = get_named_type(type)
@@ -98,13 +13,22 @@ def is_input_type(type):
 
 
 def is_composite_type(type):
-    return isinstance(type, (
+    named_type = get_named_type(type)
+    return isinstance(named_type, (
         GraphQLObjectType,
         GraphQLInterfaceType,
         GraphQLUnionType,
     ))
 
 
+def is_leaf_type(type):
+    named_type = get_named_type(type)
+    return isinstance(named_type, (
+        GraphQLScalarType,
+        GraphQLEnumType,
+    ))
+
+
 def get_named_type(type):
     unmodified_type = type
     while isinstance(unmodified_type, (GraphQLList, GraphQLNonNull)):

graphql/core/validation/__init__.py

@@ -10,6 +10,24 @@
     Rules.LoneAnonymousOperation,
     Rules.KnownTypeNames,
     Rules.FragmentsOnCompositeTypes,
+    Rules.VariablesAreInputTypes,
+    Rules.ScalarLeafs,
+    Rules.FieldsOnCorrectType,
+    Rules.UniqueFragmentNames,
+    Rules.KnownFragmentNames,
+    Rules.NoUnusedFragments,
+    Rules.PossibleFragmentSpreads,
+    Rules.NoFragmentCycles,
+    Rules.NoUndefinedVariables,
+    Rules.NoUnusedVariables,
+    Rules.KnownDirectives,
+    Rules.KnownArgumentNames,
+    Rules.UniqueArgumentNames,
+    Rules.ArgumentsOfCorrectType,
+    Rules.ProvidedNonNullArguments,
+    Rules.DefaultValuesOfCorrectType,
+    Rules.VariablesInAllowedPosition,
+    Rules.OverlappingFieldsCanBeMerged,
 ]
 
 
@@ -55,8 +73,11 @@ def enter(self, node, key, parent, path, ancestors):
                 visit(fragment, self)
 
         if result is False:
+            print 'leave', node
             self.type_info.leave(node)
 
+        return result
+
     def leave(self, node, key, parent, path, ancestors):
         result = self.instance.leave(node, key, parent, path, ancestors)
 

graphql/core/validation/rules.py

@@ -1,5 +1,6 @@
+from ..utils import type_from_ast
 from ..error import GraphQLError
-from ..type.definition import is_composite_type
+from ..type.definition import is_composite_type, is_input_type, is_leaf_type
 from ..language.ast import OperationDefinition
 from ..language.visitor import Visitor
 from ..language.printer import print_ast
@@ -87,3 +88,120 @@ def inline_message(type):
     @staticmethod
     def message(frag_name, type):
         return 'Fragment "{}" cannot condition on non composite type "{}".'.format(frag_name, type)
+
+
+class VariablesAreInputTypes(ValidationRule):
+    def enter_VariableDefinition(self, node, *args):
+        type = type_from_ast(self.context.get_schema(), node.type)
+
+        if type and not is_input_type(type):
+            variable_name = node.variable.name.value
+            return GraphQLError(
+                self.message(variable_name, print_ast(node.type)),
+                [node.type]
+            )
+
+    @staticmethod
+    def message(variable_name, type_name):
+        return 'Variable "${}" cannot be non-input type "{}".'.format(variable_name, type_name)
+
+
+class ScalarLeafs(ValidationRule):
+    def enter_Field(self, node, *args):
+        type = self.context.get_type()
+        if type:
+            if is_leaf_type(type):
+                if node.selection_set:
+                    return GraphQLError(
+                        self.not_allowed_message(node.name.value, type),
+                        [node.selection_set]
+                    )
+            elif not node.selection_set:
+                return GraphQLError(
+                    self.required_message(node.name.value, type),
+                    [node]
+                )
+
+    @staticmethod
+    def not_allowed_message(field, type):
+        return 'Field "{}" of type "{}" must not have a sub selection.'.format(field, type)
+
+    @staticmethod
+    def required_message(field, type):
+        return 'Field "{}" of type "{}" must have a sub selection.'.format(field, type)
+
+
+class FieldsOnCorrectType(ValidationRule):
+    def enter_Field(self, node, *args):
+        type = self.context.get_parent_type()
+        if type:
+            field_def = self.context.get_field_def()
+            if not field_def:
+                return GraphQLError(
+                    self.message(node.name.value, type.name),
+                    [node]
+                )
+
+    @staticmethod
+    def message(field_name, type):
+        return 'Cannot query field "{}" on "{}".'.format(field_name, type)
+
+
+class UniqueFragmentNames(ValidationRule):
+    pass
+
+
+class KnownFragmentNames(ValidationRule):
+    pass
+
+
+class NoUnusedFragments(ValidationRule):
+    pass
+
+
+class PossibleFragmentSpreads(ValidationRule):
+    pass
+
+
+class NoFragmentCycles(ValidationRule):
+    pass
+
+
+class NoUndefinedVariables(ValidationRule):
+    pass
+
+
+class NoUnusedVariables(ValidationRule):
+    pass
+
+
+class KnownDirectives(ValidationRule):
+    pass
+
+
+class KnownArgumentNames(ValidationRule):
+    pass
+
+
+class UniqueArgumentNames(ValidationRule):
+    pass
+
+
+class ArgumentsOfCorrectType(ValidationRule):
+    pass
+
+
+class ProvidedNonNullArguments(ValidationRule):
+    pass
+
+
+class DefaultValuesOfCorrectType(ValidationRule):
+    pass
+
+
+class VariablesInAllowedPosition(ValidationRule):
+    pass
+
+
+class OverlappingFieldsCanBeMerged(ValidationRule):
+    pass