Split out 'ASTValidationContext'

Replicates graphql/graphql-js@0a9a533

Author: Cito

graphql/language/ast.py

@@ -146,6 +146,7 @@ class DefinitionNode(Node):
 class ExecutableDefinitionNode(DefinitionNode):
     __slots__ = 'name', 'directives', 'variable_definitions', 'selection_set'
 
+    name: Optional[NameNode]
     directives: Optional[List['DirectiveNode']]
     variable_definitions: List['VariableDefinitionNode']
     selection_set: 'SelectionSetNode'
@@ -155,7 +156,6 @@ class OperationDefinitionNode(ExecutableDefinitionNode):
     __slots__ = 'operation',
 
     operation: OperationType
-    name: Optional[NameNode]
 
 
 class VariableDefinitionNode(Node):
@@ -328,7 +328,7 @@ class SchemaDefinitionNode(TypeSystemDefinitionNode):
     operation_types: List['OperationTypeDefinitionNode']
 
 
-class OperationTypeDefinitionNode(TypeSystemDefinitionNode):
+class OperationTypeDefinitionNode(Node):
     __slots__ = 'operation', 'type'
 
     operation: OperationType

graphql/validation/rules/__init__.py

@@ -4,18 +4,28 @@
 
 from ...error import GraphQLError
 from ...language.visitor import Visitor
-from ..validation_context import ValidationContext
+from ..validation_context import ASTValidationContext, ValidationContext
 
-__all__ = ['ValidationRule', 'RuleType']
+__all__ = ['ASTValidationRule', 'ValidationRule', 'RuleType']
 
 
-class ValidationRule(Visitor):
+class ASTValidationRule(Visitor):
 
-    def __init__(self, context: ValidationContext) -> None:
+    context: ASTValidationContext
+
+    def __init__(self, context: ASTValidationContext) -> None:
         self.context = context
 
     def report_error(self, error: GraphQLError):
         self.context.report_error(error)
 
 
-RuleType = Type[ValidationRule]
+class ValidationRule(ASTValidationRule):
+
+    context: ValidationContext
+
+    def __init__(self, context: ValidationContext) -> None:
+        super().__init__(context)
+
+
+RuleType = Type[ASTValidationRule]

graphql/validation/rules/executable_definitions.py

@@ -1,8 +1,11 @@
+from typing import Union, cast
+
 from ...error import GraphQLError
 from ...language import (
-    FragmentDefinitionNode, OperationDefinitionNode,
-    SchemaDefinitionNode, SchemaExtensionNode)
-from . import ValidationRule
+    DirectiveDefinitionNode, DocumentNode, FragmentDefinitionNode,
+    OperationDefinitionNode, SchemaDefinitionNode, SchemaExtensionNode,
+    TypeDefinitionNode)
+from . import ASTValidationRule
 
 __all__ = ['ExecutableDefinitionsRule', 'non_executable_definitions_message']
 
@@ -11,20 +14,22 @@ def non_executable_definitions_message(def_name: str) -> str:
     return f'The {def_name} definition is not executable.'
 
 
-class ExecutableDefinitionsRule(ValidationRule):
+class ExecutableDefinitionsRule(ASTValidationRule):
     """Executable definitions
 
     A GraphQL document is only valid for execution if all definitions are
     either operation or fragment definitions.
     """
 
-    def enter_document(self, node, *_args):
+    def enter_document(self, node: DocumentNode, *_args):
         for definition in node.definitions:
             if not isinstance(definition, (
                     OperationDefinitionNode, FragmentDefinitionNode)):
                 self.report_error(GraphQLError(
                     non_executable_definitions_message(
                         'schema' if isinstance(definition, (
                             SchemaDefinitionNode, SchemaExtensionNode))
-                        else definition.name.value), [definition]))
+                        else cast(Union[
+                            DirectiveDefinitionNode, TypeDefinitionNode],
+                            definition).name.value), [definition]))
         return self.SKIP

graphql/validation/rules/fields_on_correct_type.py

@@ -5,6 +5,7 @@
     GraphQLAbstractType, GraphQLSchema, GraphQLOutputType,
     is_abstract_type, is_interface_type, is_object_type)
 from ...error import GraphQLError
+from ...language import FieldNode
 from ...pyutils import quoted_or_list, suggestion_list
 from . import ValidationRule
 
@@ -32,7 +33,7 @@ class FieldsOnCorrectTypeRule(ValidationRule):
     parent type, or are an allowed meta field such as __typename.
     """
 
-    def enter_field(self, node, *_args):
+    def enter_field(self, node: FieldNode, *_args):
         type_ = self.context.get_parent_type()
         if not type_:
             return

graphql/validation/rules/fragments_on_composite_types.py

@@ -1,5 +1,5 @@
 from ...error import GraphQLError
-from ...language.printer import print_ast
+from ...language import FragmentDefinitionNode, InlineFragmentNode, print_ast
 from ...type import is_composite_type
 from ...utilities import type_from_ast
 from . import ValidationRule
@@ -29,7 +29,7 @@ class FragmentsOnCompositeTypesRule(ValidationRule):
     type condition must also be a composite type.
     """
 
-    def enter_inline_fragment(self, node, *_args):
+    def enter_inline_fragment(self, node: InlineFragmentNode, *_args):
         type_condition = node.type_condition
         if type_condition:
             type_ = type_from_ast(self.context.schema, type_condition)
@@ -38,7 +38,7 @@ def enter_inline_fragment(self, node, *_args):
                     inline_fragment_on_non_composite_error_message(
                         print_ast(type_condition)), [type_condition]))
 
-    def enter_fragment_definition(self, node, *_args):
+    def enter_fragment_definition(self, node: FragmentDefinitionNode, *_args):
         type_condition = node.type_condition
         type_ = type_from_ast(self.context.schema, type_condition)
         if type_ and not is_composite_type(type_):

graphql/validation/rules/known_argument_names.py

@@ -1,7 +1,7 @@
 from typing import List
 
 from ...error import GraphQLError
-from ...language import FieldNode, DirectiveNode
+from ...language import ArgumentNode, FieldNode, DirectiveNode
 from ...pyutils import quoted_or_list, suggestion_list
 from . import ValidationRule
 
@@ -37,7 +37,8 @@ class KnownArgumentNamesRule(ValidationRule):
     that field.
     """
 
-    def enter_argument(self, node, _key, _parent, _path, ancestors):
+    def enter_argument(
+            self, node: ArgumentNode, _key, _parent, _path, ancestors):
         context = self.context
         arg_def = context.get_argument()
         if not arg_def:

graphql/validation/rules/known_directives.py

@@ -1,7 +1,8 @@
 from typing import cast
 
 from ...error import GraphQLError
-from ...language import DirectiveLocation, Node, OperationDefinitionNode
+from ...language import (
+    DirectiveLocation, DirectiveNode, Node, OperationDefinitionNode)
 from . import ValidationRule
 
 __all__ = [
@@ -13,7 +14,7 @@ def unknown_directive_message(directive_name: str) -> str:
     return f"Unknown directive '{directive_name}'."
 
 
-def misplaced_directive_message(directive_name, location):
+def misplaced_directive_message(directive_name: str, location: str) -> str:
     return f"Directive '{directive_name}' may not be used on {location}."
 
 
@@ -24,7 +25,8 @@ class KnownDirectivesRule(ValidationRule):
     schema and legally positioned.
     """
 
-    def enter_directive(self, node, _key, _parent, _path, ancestors):
+    def enter_directive(
+            self, node: DirectiveNode, _key, _parent, _path, ancestors):
         for definition in self.context.schema.directives:
             if definition.name == node.name.value:
                 candidate_location = get_directive_location_for_ast_path(

graphql/validation/rules/known_fragment_names.py

@@ -1,4 +1,5 @@
 from ...error import GraphQLError
+from ...language import FragmentSpreadNode
 from . import ValidationRule
 
 __all__ = ['KnownFragmentNamesRule', 'unknown_fragment_message']
@@ -15,7 +16,7 @@ class KnownFragmentNamesRule(ValidationRule):
     refer to fragments defined in the same document.
     """
 
-    def enter_fragment_spread(self, node, *_args):
+    def enter_fragment_spread(self, node: FragmentSpreadNode, *_args):
         fragment_name = node.name.value
         fragment = self.context.get_fragment(fragment_name)
         if not fragment:

graphql/validation/rules/known_type_names.py

@@ -1,6 +1,7 @@
 from typing import List
 
 from ...error import GraphQLError
+from ...language import NamedTypeNode
 from ...pyutils import suggestion_list
 from . import ValidationRule
 
@@ -33,7 +34,7 @@ def enter_union_type_definition(self, *_args):
     def enter_input_object_type_definition(self, *_args):
         return self.SKIP
 
-    def enter_named_type(self, node, *_args):
+    def enter_named_type(self, node: NamedTypeNode, *_args):
         schema = self.context.schema
         type_name = node.name.value
         if not schema.get_type(type_name):

graphql/validation/rules/lone_anonymous_operation.py

@@ -1,6 +1,6 @@
-from ...language import OperationDefinitionNode
 from ...error import GraphQLError
-from . import ValidationRule
+from ...language import DocumentNode, OperationDefinitionNode
+from . import ASTValidationContext, ASTValidationRule
 
 __all__ = [
     'LoneAnonymousOperationRule', 'anonymous_operation_not_alone_message']
@@ -10,24 +10,25 @@ def anonymous_operation_not_alone_message() -> str:
     return 'This anonymous operation must be the only defined operation.'
 
 
-class LoneAnonymousOperationRule(ValidationRule):
+class LoneAnonymousOperationRule(ASTValidationRule):
     """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.
 
     """
 
-    def __init__(self, context):
+    def __init__(self, context: ASTValidationContext) -> None:
         super().__init__(context)
         self.operation_count = 0
 
-    def enter_document(self, node, *_args):
+    def enter_document(self, node: DocumentNode, *_args):
         self.operation_count = sum(
             1 for definition in node.definitions
             if isinstance(definition, OperationDefinitionNode))
 
-    def enter_operation_definition(self, node, *_args):
+    def enter_operation_definition(
+            self, node: OperationDefinitionNode, *_args):
         if not node.name and self.operation_count > 1:
             self.report_error(GraphQLError(
                 anonymous_operation_not_alone_message(), [node]))