Validation: add support of SDL to KnownTypeNamesRule

Replicates graphql/graphql-js@3b9ea61

Author: Cito

README.md

@@ -13,7 +13,7 @@ a query language for APIs created by Facebook.
 [![Code Style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
 
 The current version 1.0.1 of GraphQL-core-next is up-to-date with GraphQL.js version
-14.0.2. All parts of the API are covered by an extensive test suite of currently 1683
+14.0.2. All parts of the API are covered by an extensive test suite of currently 1679
 unit tests.
 
 

graphql/utilities/build_ast_schema.py

@@ -106,9 +106,7 @@ def build_ast_schema(
             append_directive_def(def_)
 
     if schema_def:
-        operation_types: Dict[OperationType, Any] = get_operation_types(
-            schema_def, node_map
-        )
+        operation_types: Dict[OperationType, Any] = get_operation_types(schema_def)
     else:
         operation_types = {
             OperationType.QUERY: node_map.get("Query"),
@@ -162,18 +160,11 @@ def resolve_type(type_ref: NamedTypeNode):
 
 
 def get_operation_types(
-    schema: SchemaDefinitionNode, node_map: TypeDefinitionsMap
+    schema: SchemaDefinitionNode
 ) -> Dict[OperationType, NamedTypeNode]:
     op_types: Dict[OperationType, NamedTypeNode] = {}
     for operation_type in schema.operation_types:
-        type_name = operation_type.type.name.value
-        operation = operation_type.operation
-        if type_name not in node_map:
-            raise TypeError(
-                f"Specified {operation.value} type '{type_name}'"
-                " not found in document."
-            )
-        op_types[operation] = operation_type.type
+        op_types[operation_type.operation] = operation_type.type
     return op_types
 
 

graphql/utilities/extend_schema.py

@@ -469,14 +469,9 @@ def extend_type(type_def: GraphQLType) -> GraphQLType:
     def resolve_type(type_ref: NamedTypeNode) -> GraphQLNamedType:
         type_name = type_ref.name.value
         existing_type = schema.get_type(type_name)
-        if existing_type:
-            return extend_named_type(existing_type)
-        raise GraphQLError(
-            f"Unknown type: '{type_name}'."
-            " Ensure that this type exists either in the original schema,"
-            " or is added in a type definition.",
-            [type_ref],
-        )
+        if not existing_type:
+            raise TypeError(f"Unknown type: '{type_name}'.")
+        return extend_named_type(existing_type)
 
     ast_builder = ASTDefinitionBuilder(
         type_definition_map, assume_valid=assume_valid, resolve_type=resolve_type

graphql/validation/rules/known_type_names.py

@@ -1,48 +1,82 @@
-from typing import List
+from typing import List, Sequence, Union, cast
 
 from ...error import GraphQLError
-from ...language import NamedTypeNode
-from ...pyutils import suggestion_list
-from . import ValidationRule
+from ...language import (
+    is_type_definition_node,
+    is_type_system_definition_node,
+    is_type_system_extension_node,
+    Node,
+    NamedTypeNode,
+    TypeDefinitionNode,
+)
+from ...type import specified_scalar_types
+from ...pyutils import quoted_or_list, suggestion_list
+from . import ASTValidationRule, ValidationContext, SDLValidationContext
 
 __all__ = ["KnownTypeNamesRule", "unknown_type_message"]
 
 
 def unknown_type_message(type_name: str, suggested_types: List[str]) -> str:
     message = f"Unknown type '{type_name}'."
     if suggested_types:
-        message += " Perhaps you meant {quoted_or_list(suggested_types)}?"
+        message += f" Perhaps you meant {quoted_or_list(suggested_types)}?"
     return message
 
 
-class KnownTypeNamesRule(ValidationRule):
+class KnownTypeNamesRule(ASTValidationRule):
     """Known type names
 
     A GraphQL document is only valid if referenced types (specifically variable
     definitions and fragment conditions) are defined by the type schema.
     """
 
-    def enter_object_type_definition(self, *_args):
-        return self.SKIP
+    def __init__(self, context: Union[ValidationContext, SDLValidationContext]) -> None:
+        super().__init__(context)
+        schema = context.schema
+        self.existing_types_map = schema.type_map if schema else {}
 
-    def enter_interface_type_definition(self, *_args):
-        return self.SKIP
+        defined_types = []
+        for def_ in context.document.definitions:
+            if is_type_definition_node(def_):
+                def_ = cast(TypeDefinitionNode, def_)
+                defined_types.append(def_.name.value)
+        self.defined_types = set(defined_types)
 
-    def enter_union_type_definition(self, *_args):
-        return self.SKIP
+        self.type_names = list(self.existing_types_map) + defined_types
 
-    def enter_input_object_type_definition(self, *_args):
-        return self.SKIP
-
-    def enter_named_type(self, node: NamedTypeNode, *_args):
-        schema = self.context.schema
+    def enter_named_type(
+        self, node: NamedTypeNode, _key, parent: Node, _path, ancestors: List[Node]
+    ):
         type_name = node.name.value
-        if not schema.get_type(type_name):
+        if (
+            type_name not in self.existing_types_map
+            and type_name not in self.defined_types
+        ):
+            try:
+                definition_node = ancestors[2]
+            except IndexError:
+                definition_node = parent
+            is_sdl = is_sdl_node(definition_node)
+            if is_sdl and type_name in specified_scalar_types:
+                return
+
+            suggested_types = suggestion_list(
+                type_name,
+                list(specified_scalar_types) + self.type_names
+                if is_sdl
+                else self.type_names,
+            )
             self.report_error(
-                GraphQLError(
-                    unknown_type_message(
-                        type_name, suggestion_list(type_name, list(schema.type_map))
-                    ),
-                    [node],
-                )
+                GraphQLError(unknown_type_message(type_name, suggested_types), node)
             )
+
+
+def is_sdl_node(value: Union[Node, Sequence[Node], None]) -> bool:
+    return (
+        value is not None
+        and not isinstance(value, list)
+        and (
+            is_type_system_definition_node(cast(Node, value))
+            or is_type_system_extension_node(cast(Node, value))
+        )
+    )

graphql/validation/specified_rules.py

@@ -130,6 +130,7 @@
     UniqueOperationTypesRule,
     UniqueTypeNamesRule,
     UniqueDirectiveNamesRule,
+    KnownTypeNamesRule,
     KnownDirectivesRule,
     UniqueDirectivesPerLocationRule,
     KnownArgumentNamesOnDirectivesRule,

tests/utilities/test_build_ast_schema.py

@@ -773,134 +773,3 @@ def allows_to_disable_sdl_validation():
             """
         build_schema(sdl, assume_valid=True)
         build_schema(sdl, assume_valid_sdl=True)
-
-
-def describe_failures():
-    def unknown_type_referenced():
-        sdl = """
-            schema {
-              query: Hello
-            }
-
-            type Hello {
-              bar: Bar
-            }
-            """
-        with raises(TypeError) as exc_info:
-            build_schema(sdl)
-        msg = str(exc_info.value)
-        assert "Type 'Bar' not found in document." in msg
-
-    def unknown_type_in_interface_list():
-        sdl = """
-            type Query implements Bar {
-              field: String
-            }
-            """
-        with raises(TypeError) as exc_info:
-            build_schema(sdl)
-        msg = str(exc_info.value)
-        assert "Type 'Bar' not found in document." in msg
-
-    def unknown_type_in_union_list():
-        sdl = """
-            union TestUnion = Bar
-            type Query { testUnion: TestUnion }
-            """
-        with raises(TypeError) as exc_info:
-            build_schema(sdl)
-        msg = str(exc_info.value)
-        assert "Type 'Bar' not found in document." in msg
-
-    def unknown_query_type():
-        sdl = """
-            schema {
-              query: Wat
-            }
-
-            type Hello {
-              str: String
-            }
-            """
-        with raises(TypeError) as exc_info:
-            build_schema(sdl)
-        msg = str(exc_info.value)
-        assert msg == "Specified query type 'Wat' not found in document."
-
-    def unknown_mutation_type():
-        sdl = """
-            schema {
-              query: Hello
-              mutation: Wat
-            }
-
-            type Hello {
-              str: String
-            }
-            """
-        with raises(TypeError) as exc_info:
-            build_schema(sdl)
-        msg = str(exc_info.value)
-        assert msg == "Specified mutation type 'Wat' not found in document."
-
-    def unknown_subscription_type():
-        sdl = """
-            schema {
-              query: Hello
-              mutation: Wat
-              subscription: Awesome
-            }
-
-            type Hello {
-              str: String
-            }
-
-            type Wat {
-              str: String
-            }
-            """
-        with raises(TypeError) as exc_info:
-            build_schema(sdl)
-        msg = str(exc_info.value)
-        assert msg == "Specified subscription type 'Awesome' not found in document."
-
-    def does_not_consider_directive_names():
-        sdl = """
-            schema {
-              query: Foo
-            }
-
-            directive @ Foo on QUERY
-            """
-        with raises(TypeError) as exc_info:
-            build_schema(sdl)
-        msg = str(exc_info.value)
-        assert msg == "Specified query type 'Foo' not found in document."
-
-    def does_not_consider_operation_names():
-        sdl = """
-            schema {
-              query: Foo
-            }
-
-            type Hello {
-              str: String
-            }
-            """
-        with raises(TypeError) as exc_info:
-            build_schema(sdl)
-        msg = str(exc_info.value)
-        assert msg == "Specified query type 'Foo' not found in document."
-
-    def does_not_consider_fragment_names():
-        sdl = """
-            schema {
-              query: Foo
-            }
-
-            fragment Foo on Type { field }
-            """
-        with raises(TypeError) as exc_info:
-            build_schema(sdl)
-        msg = str(exc_info.value)
-        assert msg == "Specified query type 'Foo' not found in document."

tests/utilities/test_extend_schema.py

@@ -1069,39 +1069,6 @@ def does_not_allow_replacing_an_existing_enum_value():
             " It cannot also be defined in this type extension."
         )
 
-    def does_not_allow_referencing_an_unknown_type():
-        unknown_type_error = (
-            "Unknown type: 'Quix'. Ensure that this type exists either"
-            " in the original schema, or is added in a type definition."
-        )
-
-        type_sdl = """
-            extend type Bar {
-              quix: Quix
-            }
-            """
-        with raises(GraphQLError) as exc_info:
-            extend_test_schema(type_sdl)
-        assert str(exc_info.value).startswith(unknown_type_error)
-
-        interface_sdl = """
-            extend interface SomeInterface {
-              quix: Quix
-            }
-            """
-        with raises(GraphQLError) as exc_info:
-            extend_test_schema(interface_sdl)
-        assert str(exc_info.value).startswith(unknown_type_error)
-
-        input_sdl = """
-            extend input SomeInput {
-              quix: Quix
-            }
-            """
-        with raises(GraphQLError) as exc_info:
-            extend_test_schema(input_sdl)
-        assert str(exc_info.value).startswith(unknown_type_error)
-
     def does_not_allow_extending_an_unknown_type():
         for sdl in [
             "extend scalar UnknownType @foo",