Add Node Predicates

Replicates graphql/graphql-js@4fd9260

Author: Cito

README.md

@@ -13,7 +13,7 @@ a query language for APIs created by Facebook.
 
 The current version 1.0.0rc2 of GraphQL-core-next is up-to-date with GraphQL.js
 version 14.0.0rc2. All parts of the API are covered by an extensive test
-suite of currently 1552 unit tests.
+suite of currently 1561 unit tests.
 
 
 ## Documentation

graphql/__init__.py

@@ -172,6 +172,16 @@
     TokenKind,
     DirectiveLocation,
     BREAK, SKIP, REMOVE, IDLE,
+    # Predicates
+    is_definition_node,
+    is_executable_definition_node,
+    is_selection_node,
+    is_value_node,
+    is_type_node,
+    is_type_system_definition_node,
+    is_type_definition_node,
+    is_type_system_extension_node,
+    is_type_extension_node,
     # Types
     Lexer,
     SourceLocation,
@@ -389,6 +399,10 @@
     'parse', 'parse_value', 'parse_type',
     'print_ast', 'visit', 'ParallelVisitor', 'TypeInfoVisitor', 'Visitor',
     'TokenKind', 'DirectiveLocation', 'BREAK', 'SKIP', 'REMOVE', 'IDLE',
+    'is_definition_node', 'is_executable_definition_node',
+    'is_selection_node', 'is_value_node', 'is_type_node',
+    'is_type_system_definition_node', 'is_type_definition_node',
+    'is_type_system_extension_node', 'is_type_extension_node',
     'Lexer', 'SourceLocation', 'Location', 'Token',
     'NameNode', 'DocumentNode', 'DefinitionNode', 'ExecutableDefinitionNode',
     'OperationDefinitionNode', 'OperationType', 'VariableDefinitionNode',

graphql/language/__init__.py

@@ -38,6 +38,11 @@
     ObjectTypeExtensionNode, InterfaceTypeExtensionNode,
     UnionTypeExtensionNode, EnumTypeExtensionNode,
     InputObjectTypeExtensionNode)
+from .predicates import (
+    is_definition_node, is_executable_definition_node,
+    is_selection_node, is_value_node, is_type_node,
+    is_type_system_definition_node, is_type_definition_node,
+    is_type_system_extension_node, is_type_extension_node)
 from .directive_locations import DirectiveLocation
 
 __all__ = [
@@ -70,4 +75,8 @@
     'SchemaExtensionNode', 'TypeExtensionNode', 'ScalarTypeExtensionNode',
     'ObjectTypeExtensionNode', 'InterfaceTypeExtensionNode',
     'UnionTypeExtensionNode', 'EnumTypeExtensionNode',
-    'InputObjectTypeExtensionNode']
+    'InputObjectTypeExtensionNode',
+    'is_definition_node', 'is_executable_definition_node',
+    'is_selection_node', 'is_value_node', 'is_type_node',
+    'is_type_system_definition_node', 'is_type_definition_node',
+    'is_type_system_extension_node', 'is_type_extension_node']

graphql/language/predicates.py

@@ -0,0 +1,46 @@
+from .ast import (
+    Node, DefinitionNode, ExecutableDefinitionNode, SchemaExtensionNode,
+    SelectionNode, TypeDefinitionNode, TypeExtensionNode, TypeNode,
+    TypeSystemDefinitionNode, ValueNode)
+
+__all__ = [
+    'is_definition_node', 'is_executable_definition_node',
+    'is_selection_node', 'is_value_node', 'is_type_node',
+    'is_type_system_definition_node', 'is_type_definition_node',
+    'is_type_system_extension_node', 'is_type_extension_node']
+
+
+def is_definition_node(node: Node) -> bool:
+    return isinstance(node, DefinitionNode)
+
+
+def is_executable_definition_node(node: Node) -> bool:
+    return isinstance(node, ExecutableDefinitionNode)
+
+
+def is_selection_node(node: Node) -> bool:
+    return isinstance(node, SelectionNode)
+
+
+def is_value_node(node: Node) -> bool:
+    return isinstance(node, ValueNode)
+
+
+def is_type_node(node: Node) -> bool:
+    return isinstance(node, TypeNode)
+
+
+def is_type_system_definition_node(node: Node) -> bool:
+    return isinstance(node, TypeSystemDefinitionNode)
+
+
+def is_type_definition_node(node: Node) -> bool:
+    return isinstance(node, TypeDefinitionNode)
+
+
+def is_type_system_extension_node(node: Node) -> bool:
+    return isinstance(node, (SchemaExtensionNode, TypeExtensionNode))
+
+
+def is_type_extension_node(node: Node) -> bool:
+    return isinstance(node, TypeExtensionNode)

graphql/utilities/build_ast_schema.py

@@ -59,26 +59,19 @@ def build_ast_schema(
     node_map: TypeDefinitionsMap = {}
     directive_defs: List[DirectiveDefinitionNode] = []
     append_directive_def = directive_defs.append
-    type_definition_nodes = (
-        ScalarTypeDefinitionNode,
-        ObjectTypeDefinitionNode,
-        InterfaceTypeDefinitionNode,
-        EnumTypeDefinitionNode,
-        UnionTypeDefinitionNode,
-        InputObjectTypeDefinitionNode)
-    for d in document_ast.definitions:
-        if isinstance(d, SchemaDefinitionNode):
-            schema_def = d
-        elif isinstance(d, type_definition_nodes):
-            d = cast(TypeDefinitionNode, d)
-            type_name = d.name.value
+    for def_ in document_ast.definitions:
+        if isinstance(def_, SchemaDefinitionNode):
+            schema_def = def_
+        elif isinstance(def_, TypeDefinitionNode):
+            def_ = cast(TypeDefinitionNode, def_)
+            type_name = def_.name.value
             if type_name in node_map:
                 raise TypeError(
                     f"Type '{type_name}' was defined more than once.")
-            append_type_def(d)
-            node_map[type_name] = d
-        elif isinstance(d, DirectiveDefinitionNode):
-            append_directive_def(d)
+            append_type_def(def_)
+            node_map[type_name] = def_
+        elif isinstance(def_, DirectiveDefinitionNode):
+            append_directive_def(def_)
 
     if schema_def:
         operation_types: Dict[OperationType, Any] = get_operation_types(

graphql/utilities/extend_schema.py

@@ -6,14 +6,10 @@
 
 from ..error import GraphQLError
 from ..language import (
-    DirectiveDefinitionNode, DocumentNode,
-    EnumTypeDefinitionNode, EnumTypeExtensionNode,
-    InputObjectTypeDefinitionNode, InputObjectTypeExtensionNode,
-    InterfaceTypeDefinitionNode, InterfaceTypeExtensionNode,
-    ObjectTypeDefinitionNode, ObjectTypeExtensionNode, OperationType,
-    ScalarTypeDefinitionNode, ScalarTypeExtensionNode,
-    SchemaExtensionNode, SchemaDefinitionNode,
-    UnionTypeDefinitionNode, UnionTypeExtensionNode,
+    DirectiveDefinitionNode, DocumentNode, EnumTypeExtensionNode,
+    InputObjectTypeExtensionNode, InterfaceTypeExtensionNode,
+    ObjectTypeExtensionNode, OperationType, SchemaExtensionNode,
+    SchemaDefinitionNode, TypeDefinitionNode, UnionTypeExtensionNode,
     NamedTypeNode, TypeExtensionNode)
 from ..type import (
     GraphQLArgument, GraphQLArgumentMap, GraphQLDirective,
@@ -79,13 +75,7 @@ def extend_schema(
             schema_def = def_
         elif isinstance(def_, SchemaExtensionNode):
             schema_extensions.append(def_)
-        elif isinstance(def_, (
-                ObjectTypeDefinitionNode,
-                InterfaceTypeDefinitionNode,
-                EnumTypeDefinitionNode,
-                UnionTypeDefinitionNode,
-                ScalarTypeDefinitionNode,
-                InputObjectTypeDefinitionNode)):
+        elif isinstance(def_, TypeDefinitionNode):
             # Sanity check that none of the defined types conflict with the
             # schema's existing types.
             type_name = def_.name.value
@@ -95,13 +85,7 @@ def extend_schema(
                     ' It cannot also be defined in this type definition.',
                     [def_])
             type_definition_map[type_name] = def_
-        elif isinstance(def_, (
-                ScalarTypeExtensionNode,
-                ObjectTypeExtensionNode,
-                InterfaceTypeExtensionNode,
-                EnumTypeExtensionNode,
-                InputObjectTypeExtensionNode,
-                UnionTypeExtensionNode)):
+        elif isinstance(def_, TypeExtensionNode):
             # Sanity check that this type extension exists within the
             # schema's existing types.
             extended_type_name = def_.name.value

graphql/validation/rules/executable_definitions.py

@@ -2,9 +2,8 @@
 
 from ...error import GraphQLError
 from ...language import (
-    DirectiveDefinitionNode, DocumentNode, FragmentDefinitionNode,
-    OperationDefinitionNode, SchemaDefinitionNode, SchemaExtensionNode,
-    TypeDefinitionNode)
+    DirectiveDefinitionNode, DocumentNode, ExecutableDefinitionNode,
+    SchemaDefinitionNode, SchemaExtensionNode, TypeDefinitionNode)
 from . import ASTValidationRule
 
 __all__ = ['ExecutableDefinitionsRule', 'non_executable_definitions_message']
@@ -23,8 +22,7 @@ class ExecutableDefinitionsRule(ASTValidationRule):
 
     def enter_document(self, node: DocumentNode, *_args):
         for definition in node.definitions:
-            if not isinstance(definition, (
-                    OperationDefinitionNode, FragmentDefinitionNode)):
+            if not isinstance(definition, ExecutableDefinitionNode):
                 self.report_error(GraphQLError(
                     non_executable_definitions_message(
                         'schema' if isinstance(definition, (

tests/language/test_predicates.py

@@ -0,0 +1,89 @@
+from graphql.language import (
+    DefinitionNode, DocumentNode, ExecutableDefinitionNode,
+    FieldDefinitionNode, FieldNode, InlineFragmentNode, IntValueNode, Node,
+    NonNullTypeNode, ObjectValueNode, ScalarTypeDefinitionNode,
+    ScalarTypeExtensionNode, SchemaDefinitionNode, SchemaExtensionNode,
+    SelectionNode, SelectionSetNode, TypeDefinitionNode, TypeExtensionNode,
+    TypeNode, TypeSystemDefinitionNode, ValueNode,
+    is_definition_node, is_executable_definition_node,
+    is_selection_node, is_value_node, is_type_node,
+    is_type_system_definition_node, is_type_definition_node,
+    is_type_system_extension_node, is_type_extension_node)
+
+
+def describe_predicates():
+
+    def check_definition_node():
+        assert not is_definition_node(Node())
+        assert not is_definition_node(DocumentNode())
+        assert is_definition_node(DefinitionNode())
+        assert is_definition_node(ExecutableDefinitionNode())
+        assert is_definition_node(TypeSystemDefinitionNode())
+
+    def check_exectuable_definition_node():
+        assert not is_executable_definition_node(Node())
+        assert not is_executable_definition_node(DocumentNode())
+        assert not is_executable_definition_node(DefinitionNode())
+        assert is_executable_definition_node(ExecutableDefinitionNode())
+        assert not is_executable_definition_node(TypeSystemDefinitionNode())
+
+    def check_selection_node():
+        assert not is_selection_node(Node())
+        assert not is_selection_node(DocumentNode())
+        assert is_selection_node(SelectionNode())
+        assert is_selection_node(FieldNode())
+        assert is_selection_node(InlineFragmentNode())
+        assert not is_selection_node(SelectionSetNode())
+
+    def check_value_node():
+        assert not is_value_node(Node())
+        assert not is_value_node(DocumentNode())
+        assert is_value_node(ValueNode())
+        assert is_value_node(IntValueNode())
+        assert is_value_node(ObjectValueNode())
+        assert not is_value_node(TypeNode())
+
+    def check_type_node():
+        assert not is_type_node(Node())
+        assert not is_type_node(DocumentNode())
+        assert not is_type_node(ValueNode())
+        assert is_type_node(TypeNode())
+        assert is_type_node(NonNullTypeNode())
+
+    def check_type_system_definition_node():
+        assert not is_type_system_definition_node(Node())
+        assert not is_type_system_definition_node(DocumentNode())
+        assert is_type_system_definition_node(TypeSystemDefinitionNode())
+        assert not is_type_system_definition_node(TypeNode())
+        assert not is_type_system_definition_node(DefinitionNode())
+        assert is_type_system_definition_node(TypeDefinitionNode())
+        assert is_type_system_definition_node(SchemaDefinitionNode())
+        assert is_type_system_definition_node(ScalarTypeDefinitionNode())
+        assert is_type_system_definition_node(FieldDefinitionNode())
+
+    def check_type_definition_node():
+        assert not is_type_definition_node(Node())
+        assert not is_type_definition_node(DocumentNode())
+        assert is_type_definition_node(TypeDefinitionNode())
+        assert is_type_definition_node(ScalarTypeDefinitionNode())
+        assert not is_type_definition_node(TypeSystemDefinitionNode())
+        assert not is_type_definition_node(DefinitionNode())
+        assert not is_type_definition_node(TypeNode())
+
+    def check_type_system_extension_node():
+        assert not is_type_system_extension_node(Node())
+        assert not is_type_system_extension_node(DocumentNode())
+        assert is_type_system_extension_node(SchemaExtensionNode())
+        assert is_type_system_extension_node(TypeExtensionNode())
+        assert not is_type_system_extension_node(TypeSystemDefinitionNode())
+        assert not is_type_system_extension_node(DefinitionNode())
+        assert not is_type_system_extension_node(TypeNode())
+
+    def check_type_extension_node():
+        assert not is_type_extension_node(Node())
+        assert not is_type_extension_node(DocumentNode())
+        assert is_type_extension_node(TypeExtensionNode())
+        assert not is_type_extension_node(ScalarTypeDefinitionNode())
+        assert is_type_extension_node(ScalarTypeExtensionNode())
+        assert not is_type_extension_node(DefinitionNode())
+        assert not is_type_extension_node(TypeNode())