Extract check for unique type names into separate rule

Replicates graphql/graphql-js@257797a

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 1662
+14.0.2. All parts of the API are covered by an extensive test suite of currently 1668
 unit tests.
 
 

graphql/utilities/build_ast_schema.py

@@ -104,8 +104,6 @@ def build_ast_schema(
         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(def_)
             node_map[type_name] = def_
         elif isinstance(def_, DirectiveDefinitionNode):

graphql/utilities/extend_schema.py

@@ -108,15 +108,7 @@ def extend_schema(
         elif isinstance(def_, SchemaExtensionNode):
             schema_extensions.append(def_)
         elif isinstance(def_, TypeDefinitionNode):
-            # Sanity check that none of the defined types conflict with the schema's
-            # existing types.
             type_name = def_.name.value
-            if schema.get_type(type_name):
-                raise GraphQLError(
-                    f"Type '{type_name}' already exists in the schema."
-                    " It cannot also be defined in this type definition.",
-                    [def_],
-                )
             type_definition_map[type_name] = def_
         elif isinstance(def_, TypeExtensionNode):
             # Sanity check that this type extension exists within the schema's existing

graphql/validation/rules/unique_type_names.py

@@ -0,0 +1,56 @@
+from typing import Dict
+
+from ...error import GraphQLError
+from ...language import NameNode, TypeDefinitionNode
+from . import SDLValidationContext, SDLValidationRule
+
+__all__ = ["UniqueTypeNamesRule", "existed_type_name_message"]
+
+
+def duplicate_type_name_message(type_name: str) -> str:
+    return f"There can be only one type named '{type_name}'."
+
+
+def existed_type_name_message(type_name: str) -> str:
+    return (
+        f"Type '{type_name}' already exists in the schema."
+        " It cannot also be defined in this type definition."
+    )
+
+
+class UniqueTypeNamesRule(SDLValidationRule):
+    """Unique type names
+
+    A GraphQL document is only valid if all defined types have unique names.
+    """
+
+    def __init__(self, context: SDLValidationContext) -> None:
+        super().__init__(context)
+        self.known_type_names: Dict[str, NameNode] = {}
+        self.schema = context.schema
+
+    def check_type_name(self, node: TypeDefinitionNode, *_args):
+        type_name = node.name.value
+
+        if self.schema and self.schema.get_type(type_name):
+            self.report_error(
+                GraphQLError(existed_type_name_message(type_name), [node.name])
+            )
+        else:
+            if type_name in self.known_type_names:
+                self.report_error(
+                    GraphQLError(
+                        duplicate_type_name_message(type_name),
+                        [self.known_type_names[type_name], node.name],
+                    )
+                )
+            else:
+                self.known_type_names[type_name] = node.name
+            return self.SKIP
+
+    enter_scalar_type_definition = check_type_name
+    enter_object_type_definition = check_type_name
+    enter_interface_type_definition = check_type_name
+    enter_union_type_definition = check_type_name
+    enter_enum_type_definition = check_type_name
+    enter_input_object_type_definition = check_type_name

graphql/validation/specified_rules.py

@@ -82,6 +82,7 @@
 
 # Schema definition language:
 from .rules.lone_schema_definition import LoneSchemaDefinitionRule
+from .rules.unique_type_names import UniqueTypeNamesRule
 from .rules.known_argument_names import KnownArgumentNamesOnDirectivesRule
 from .rules.provided_required_arguments import ProvidedRequiredArgumentsOnDirectivesRule
 
@@ -124,6 +125,7 @@
 
 specified_sdl_rules: List[RuleType] = [
     LoneSchemaDefinitionRule,
+    UniqueTypeNamesRule,
     KnownDirectivesRule,
     UniqueDirectivesPerLocationRule,
     KnownArgumentNamesOnDirectivesRule,

tests/utilities/test_build_ast_schema.py

@@ -965,22 +965,3 @@ def does_not_consider_fragment_names():
             build_schema(sdl)
         msg = str(exc_info.value)
         assert msg == "Specified query type 'Foo' not found in document."
-
-    def forbids_duplicate_type_definitions():
-        sdl = """
-            schema {
-              query: Repeated
-            }
-
-            type Repeated {
-              id: Int
-            }
-
-            type Repeated {
-              id: String
-            }
-            """
-        with raises(TypeError) as exc_info:
-            build_schema(sdl)
-        msg = str(exc_info.value)
-        assert msg == "Type 'Repeated' was defined more than once."

tests/utilities/test_extend_schema.py

@@ -1075,48 +1075,6 @@ def does_not_allow_replacing_a_custom_directive():
             "Directive 'meow' already exists in the schema. It cannot be redefined."
         )
 
-    def does_not_allow_replacing_an_existing_type():
-        def existing_type_error(type_):
-            return (
-                f"Type '{type_}' already exists in the schema."
-                " It cannot also be defined in this type definition."
-            )
-
-        type_sdl = """
-            type Bar
-            """
-        with raises(GraphQLError) as exc_info:
-            assert extend_test_schema(type_sdl)
-        assert str(exc_info.value).startswith(existing_type_error("Bar"))
-
-        scalar_sdl = """
-            scalar SomeScalar
-            """
-        with raises(GraphQLError) as exc_info:
-            assert extend_test_schema(scalar_sdl)
-        assert str(exc_info.value).startswith(existing_type_error("SomeScalar"))
-
-        enum_sdl = """
-            enum SomeEnum
-            """
-        with raises(GraphQLError) as exc_info:
-            assert extend_test_schema(enum_sdl)
-        assert str(exc_info.value).startswith(existing_type_error("SomeEnum"))
-
-        union_sdl = """
-            union SomeUnion
-            """
-        with raises(GraphQLError) as exc_info:
-            assert extend_test_schema(union_sdl)
-        assert str(exc_info.value).startswith(existing_type_error("SomeUnion"))
-
-        input_sdl = """
-            input SomeInput
-            """
-        with raises(GraphQLError) as exc_info:
-            assert extend_test_schema(input_sdl)
-        assert str(exc_info.value).startswith(existing_type_error("SomeInput"))
-
     def does_not_allow_replacing_an_existing_field():
         def existing_field_error(type_, field):
             return (

tests/validation/test_unique_type_names.py

@@ -0,0 +1,117 @@
+from functools import partial
+
+from graphql.utilities import build_schema
+from graphql.validation.rules.unique_type_names import (
+    UniqueTypeNamesRule,
+    duplicate_type_name_message,
+    existed_type_name_message,
+)
+
+from .harness import assert_sdl_validation_errors
+
+assert_errors = partial(assert_sdl_validation_errors, UniqueTypeNamesRule)
+
+assert_valid = partial(assert_errors, errors=[])
+
+
+def duplicate_type(name, l1, c1, l2, c2):
+    return {
+        "message": duplicate_type_name_message(name),
+        "locations": [(l1, c1), (l2, c2)],
+    }
+
+
+def existed_type(name, line, col):
+    return {"message": existed_type_name_message(name), "locations": [(line, col)]}
+
+
+def describe_validate_unique_type_names():
+    def no_types():
+        assert_valid(
+            """
+            directive @test on SCHEMA
+            """
+        )
+
+    def one_type():
+        assert_valid(
+            """
+            type Foo
+            """
+        )
+
+    def many_types():
+        assert_valid(
+            """
+            type Foo
+            type Bar
+            type Baz
+            """
+        )
+
+    def type_and_non_type_definitions_named_the_same():
+        assert_valid(
+            """
+            query Foo { __typename }
+            fragment Foo on Query { __typename }
+            directive @Foo on SCHEMA
+
+            type Foo
+            """
+        )
+
+    def types_named_the_same():
+        assert_errors(
+            """
+            type Foo
+
+            scalar Foo
+            type Foo
+            interface Foo
+            union Foo
+            enum Foo
+            input Foo
+            """,
+            [
+                duplicate_type("Foo", 2, 18, 4, 20),
+                duplicate_type("Foo", 2, 18, 5, 18),
+                duplicate_type("Foo", 2, 18, 6, 23),
+                duplicate_type("Foo", 2, 18, 7, 19),
+                duplicate_type("Foo", 2, 18, 8, 18),
+                duplicate_type("Foo", 2, 18, 9, 19),
+            ],
+        )
+
+    def adding_new_type_to_existing_schema():
+        schema = build_schema("type Foo")
+
+        assert_valid("type Bar", schema=schema)
+
+    def adding_new_type_to_existing_schema_with_same_named_directive():
+        schema = build_schema("directive @Foo on SCHEMA")
+
+        assert_valid("type Foo", schema=schema)
+
+    def adding_conflicting_types_to_existing_schema():
+        schema = build_schema("type Foo")
+        sdl = """
+            scalar Foo
+            type Foo
+            interface Foo
+            union Foo
+            enum Foo
+            input Foo
+            """
+
+        assert_errors(
+            sdl,
+            [
+                existed_type("Foo", 2, 20),
+                existed_type("Foo", 3, 18),
+                existed_type("Foo", 4, 23),
+                existed_type("Foo", 5, 19),
+                existed_type("Foo", 6, 18),
+                existed_type("Foo", 7, 19),
+            ],
+            schema,
+        )