Extract check for unique field names into separate rule

Replicates graphql/graphql-js@6be63f0

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

graphql/utilities/extend_schema.py

@@ -230,15 +230,7 @@ def extend_input_field_map(type_: GraphQLInputObjectType) -> GraphQLInputFieldMa
         if extensions:
             for extension in extensions:
                 for field in extension.fields:
-                    field_name = field.name.value
-                    if field_name in old_field_map:
-                        raise GraphQLError(
-                            f"Field '{type_.name}.{field_name}' already"
-                            " exists in the schema. It cannot also be defined"
-                            " in this type extension.",
-                            [field],
-                        )
-                    new_field_map[field_name] = ast_builder.build_input_field(field)
+                    new_field_map[field.name.value] = build_input_field(field)
 
         return new_field_map
 
@@ -444,15 +436,7 @@ def extend_field_map(
         # If there are any extensions to the fields, apply those here.
         for extension in type_extensions_map[type_.name]:
             for field in extension.fields:
-                field_name = field.name.value
-                if field_name in old_field_map:
-                    raise GraphQLError(
-                        f"Field '{type_.name}.{field_name}'"
-                        " already exists in the schema."
-                        " It cannot also be defined in this type extension.",
-                        [field],
-                    )
-                new_field_map[field_name] = build_field(field)
+                new_field_map[field.name.value] = build_field(field)
 
         return new_field_map
 
@@ -475,6 +459,7 @@ def resolve_type(type_name: str) -> GraphQLNamedType:
         type_definition_map, assume_valid=assume_valid, resolve_type=resolve_type
     )
     build_field = ast_builder.build_field
+    build_input_field = ast_builder.build_input_field
     build_type = ast_builder.build_type
 
     extend_type_cache: Dict[str, GraphQLNamedType] = {}
@@ -492,7 +477,7 @@ def resolve_type(type_name: str) -> GraphQLNamedType:
             # Note: While this could make early assertions to get the correctly typed
             # values, that would throw immediately while type system validation with
             # `validate_schema()` will produce more actionable results.
-            operation_types[operation] = ast_builder.build_type(operation_type.type)
+            operation_types[operation] = build_type(operation_type.type)
 
     # Then, incorporate schema definition and all schema extensions.
     for schema_extension in schema_extensions:
@@ -503,7 +488,7 @@ def resolve_type(type_name: str) -> GraphQLNamedType:
                 # typed values, that would throw immediately while type system
                 # validation with `validate_schema()` will produce more actionable
                 # results.
-                operation_types[operation] = ast_builder.build_type(operation_type.type)
+                operation_types[operation] = build_type(operation_type.type)
 
     schema_extension_ast_nodes = (
         schema.extension_ast_nodes or cast(Tuple[SchemaExtensionNode], ())
@@ -513,7 +498,7 @@ def resolve_type(type_name: str) -> GraphQLNamedType:
     # any type not directly referenced by a value will get created.
     types = list(map(extend_named_type, schema.type_map.values()))
     # do the same with new types
-    types.extend(map(ast_builder.build_type, type_definition_map.values()))
+    types.extend(map(build_type, type_definition_map.values()))
 
     # Then produce and return a Schema with these types.
     return GraphQLSchema(  # type: ignore

graphql/validation/rules/unique_field_definition_names.py

@@ -0,0 +1,86 @@
+from typing import Any, Dict
+
+from ...error import GraphQLError
+from ...language import NameNode, ObjectTypeDefinitionNode
+from ...type import is_object_type, is_interface_type, is_input_object_type
+from . import SDLValidationContext, SDLValidationRule
+
+__all__ = [
+    "UniqueFieldDefinitionNamesRule",
+    "duplicate_field_definition_name_message",
+    "existed_field_definition_name_message",
+]
+
+
+def duplicate_field_definition_name_message(type_name: str, field_name: str) -> str:
+    return f"Field '{type_name}.{field_name}' can only be defined once."
+
+
+def existed_field_definition_name_message(type_name: str, field_name: str) -> str:
+    return (
+        f"Field '{type_name}.{field_name}' already exists in the schema."
+        " It cannot also be defined in this type extension."
+    )
+
+
+class UniqueFieldDefinitionNamesRule(SDLValidationRule):
+    """Unique field definition names
+
+    A GraphQL complex type is only valid if all its fields are uniquely named.
+    """
+
+    def __init__(self, context: SDLValidationContext) -> None:
+        super().__init__(context)
+        schema = context.schema
+        self.existing_type_map = schema.type_map if schema else {}
+        self.known_field_names: Dict[str, Dict[str, NameNode]] = {}
+
+    def check_field_uniqueness(self, node: ObjectTypeDefinitionNode, *_args):
+        type_name = node.name.value
+
+        known_field_names = self.known_field_names
+        if type_name not in known_field_names:
+            known_field_names[type_name] = {}
+
+        if node.fields:
+            field_names = known_field_names[type_name]
+            existing_type_map = self.existing_type_map
+
+            for field_def in node.fields:
+                field_name = field_def.name.value
+
+                if has_field(existing_type_map.get(type_name), field_name):
+                    self.report_error(
+                        GraphQLError(
+                            existed_field_definition_name_message(
+                                type_name, field_name
+                            ),
+                            [field_def.name],
+                        )
+                    )
+                elif field_name in field_names:
+                    self.report_error(
+                        GraphQLError(
+                            duplicate_field_definition_name_message(
+                                type_name, field_name
+                            ),
+                            [field_names[field_name], field_def.name],
+                        )
+                    )
+                else:
+                    field_names[field_name] = field_def.name
+
+        return self.SKIP
+
+    enter_input_object_type_definition = check_field_uniqueness
+    enter_input_object_type_extension = check_field_uniqueness
+    enter_interface_type_definition = check_field_uniqueness
+    enter_interface_type_extension = check_field_uniqueness
+    enter_object_type_definition = check_field_uniqueness
+    enter_object_type_extension = check_field_uniqueness
+
+
+def has_field(type_: Any, field_name: str) -> bool:
+    if is_object_type(type_) or is_interface_type(type_) or is_input_object_type(type_):
+        return field_name in type_.fields
+    return False

graphql/validation/specified_rules.py

@@ -84,6 +84,7 @@
 from .rules.lone_schema_definition import LoneSchemaDefinitionRule
 from .rules.unique_operation_types import UniqueOperationTypesRule
 from .rules.unique_type_names import UniqueTypeNamesRule
+from .rules.unique_field_definition_names import UniqueFieldDefinitionNamesRule
 from .rules.unique_directive_names import UniqueDirectiveNamesRule
 from .rules.known_argument_names import KnownArgumentNamesOnDirectivesRule
 from .rules.provided_required_arguments import ProvidedRequiredArgumentsOnDirectivesRule
@@ -129,6 +130,7 @@
     LoneSchemaDefinitionRule,
     UniqueOperationTypesRule,
     UniqueTypeNamesRule,
+    UniqueFieldDefinitionNamesRule,
     UniqueDirectiveNamesRule,
     KnownTypeNamesRule,
     KnownDirectivesRule,

tests/utilities/test_extend_schema.py

@@ -774,7 +774,6 @@ def extends_different_types_multiple_times():
             }
 
             extend type Biz {
-              newFieldA: Int
               newFieldB: Float
             }