Extract check for unique enum value names into separate rule

Replicates graphql/graphql-js@0737212

Author: Cito

graphql/type/validate.py

@@ -4,7 +4,6 @@
 from ..error import GraphQLError
 from ..pyutils import inspect
 from ..language import (
-    EnumValueDefinitionNode,
     FieldDefinitionNode,
     InputValueDefinitionNode,
     NamedTypeNode,
@@ -412,15 +411,6 @@ def validate_enum_values(self, enum_type: GraphQLEnumType):
             )
 
         for value_name, enum_value in enum_values.items():
-            # Ensure no duplicates.
-            all_nodes = get_enum_value_nodes(enum_type, value_name)
-            if all_nodes and len(all_nodes) > 1:
-                self.report_error(
-                    f"Enum type {enum_type.name}"
-                    f" can include value {value_name} only once.",
-                    all_nodes,
-                )
-
             # Ensure valid name.
             self.validate_name(enum_value, value_name)
             if value_name in ("true", "false", "null"):
@@ -604,13 +594,3 @@ def get_union_member_type_nodes(
     return [
         union_node for union_node in union_nodes if union_node.name.value == type_name
     ]
-
-
-def get_enum_value_nodes(
-    enum_type: GraphQLEnumType, value_name: str
-) -> Optional[List[EnumValueDefinitionNode]]:
-    enum_nodes = cast(
-        List[EnumValueDefinitionNode],
-        get_all_sub_nodes(enum_type, attrgetter("values")),
-    )
-    return [enum_node for enum_node in enum_nodes if enum_node.name.value == value_name]

graphql/utilities/extend_schema.py

@@ -228,6 +228,7 @@ def extend_input_field_map(type_: GraphQLInputObjectType) -> GraphQLInputFieldMa
         # If there are any extensions to the fields, apply those here.
         extensions = type_extensions_map.get(type_.name)
         if extensions:
+            build_input_field = ast_builder.build_input_field
             for extension in extensions:
                 for field in extension.fields:
                     new_field_map[field.name.value] = build_input_field(field)
@@ -254,31 +255,23 @@ def extend_enum_type(type_: GraphQLEnumType) -> GraphQLEnumType:
         )
 
     def extend_value_map(type_: GraphQLEnumType) -> GraphQLEnumValueMap:
-        old_value_map = type_.values
         new_value_map = {
             value_name: GraphQLEnumValue(
                 value.value,
                 description=value.description,
                 deprecation_reason=value.deprecation_reason,
                 ast_node=value.ast_node,
             )
-            for value_name, value in old_value_map.items()
+            for value_name, value in type_.values.items()
         }
 
         # If there are any extensions to the values, apply those here.
         extensions = type_extensions_map.get(type_.name)
         if extensions:
+            build_enum_value = ast_builder.build_enum_value
             for extension in extensions:
                 for value in extension.values:
-                    value_name = value.name.value
-                    if value_name in old_value_map:
-                        raise GraphQLError(
-                            f"Enum value '{type_.name}.{value_name}' already"
-                            " exists in the schema. It cannot also be defined"
-                            " in this type extension.",
-                            [value],
-                        )
-                    new_value_map[value_name] = ast_builder.build_enum_value(value)
+                    new_value_map[value.name.value] = build_enum_value(value)
 
         return new_value_map
 
@@ -389,7 +382,7 @@ def extend_possible_types(type_: GraphQLUnionType) -> List[GraphQLObjectType]:
                     # typed values, that would throw immediately while type system
                     # validation with `validate_schema()` will produce more actionable
                     # results.
-                    possible_types.append(ast_builder.build_type(named_type))
+                    possible_types.append(build_type(named_type))
 
         return cast(List[GraphQLObjectType], possible_types)
 
@@ -434,6 +427,7 @@ def extend_field_map(
         }
 
         # If there are any extensions to the fields, apply those here.
+        build_field = ast_builder.build_field
         for extension in type_extensions_map[type_.name]:
             for field in extension.fields:
                 new_field_map[field.name.value] = build_field(field)
@@ -458,8 +452,6 @@ def resolve_type(type_name: str) -> GraphQLNamedType:
     ast_builder = ASTDefinitionBuilder(
         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] = {}

graphql/validation/rules/unique_enum_value_names.py

@@ -0,0 +1,76 @@
+from typing import cast, Dict
+
+from ...error import GraphQLError
+from ...language import NameNode, EnumTypeDefinitionNode
+from ...type import is_enum_type, GraphQLEnumType
+from . import SDLValidationContext, SDLValidationRule
+
+__all__ = [
+    "UniqueEnumValueNamesRule",
+    "duplicate_enum_value_name_message",
+    "existed_enum_value_name_message",
+]
+
+
+def duplicate_enum_value_name_message(type_name: str, value_name: str) -> str:
+    return f"Enum value '{type_name}.{value_name}' can only be defined once."
+
+
+def existed_enum_value_name_message(type_name: str, value_name: str) -> str:
+    return (
+        f"Enum value '{type_name}.{value_name}' already exists in the schema."
+        " It cannot also be defined in this type extension."
+    )
+
+
+class UniqueEnumValueNamesRule(SDLValidationRule):
+    """Unique enum value names
+
+    A GraphQL enum type is only valid if all its values 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_value_names: Dict[str, Dict[str, NameNode]] = {}
+
+    def check_value_uniqueness(self, node: EnumTypeDefinitionNode, *_args):
+        type_name = node.name.value
+
+        known_value_names = self.known_value_names
+        if type_name not in known_value_names:
+            known_value_names[type_name] = {}
+
+        if node.values:
+            value_names = known_value_names[type_name]
+            existing_type_map = self.existing_type_map
+
+            for value_def in node.values:
+                value_name = value_def.name.value
+
+                existing_type = existing_type_map.get(type_name)
+                if (
+                    is_enum_type(existing_type)
+                    and value_name in cast(GraphQLEnumType, existing_type).values
+                ):
+                    self.report_error(
+                        GraphQLError(
+                            existed_enum_value_name_message(type_name, value_name),
+                            [value_def.name],
+                        )
+                    )
+                elif value_name in value_names:
+                    self.report_error(
+                        GraphQLError(
+                            duplicate_enum_value_name_message(type_name, value_name),
+                            [value_names[value_name], value_def.name],
+                        )
+                    )
+                else:
+                    value_names[value_name] = value_def.name
+
+        return self.SKIP
+
+    enter_enum_type_definition = check_value_uniqueness
+    enter_enum_type_extension = check_value_uniqueness

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_enum_value_names import UniqueEnumValueNamesRule
 from .rules.unique_field_definition_names import UniqueFieldDefinitionNamesRule
 from .rules.unique_directive_names import UniqueDirectiveNamesRule
 from .rules.known_argument_names import KnownArgumentNamesOnDirectivesRule
@@ -130,6 +131,7 @@
     LoneSchemaDefinitionRule,
     UniqueOperationTypesRule,
     UniqueTypeNamesRule,
+    UniqueEnumValueNamesRule,
     UniqueFieldDefinitionNamesRule,
     UniqueDirectiveNamesRule,
     KnownTypeNamesRule,

tests/type/test_validation.py

@@ -725,27 +725,6 @@ def rejects_an_enum_type_without_values():
             }
         ]
 
-    def rejects_an_enum_type_with_duplicate_values():
-        schema = build_schema(
-            """
-            type Query {
-              field: SomeEnum
-            }
-
-            enum SomeEnum {
-              SOME_VALUE
-              SOME_VALUE
-            }
-            """
-        )
-        assert validate_schema(schema) == [
-            {
-                "message": "Enum type SomeEnum can include value SOME_VALUE"
-                " only once.",
-                "locations": [(7, 15), (8, 15)],
-            }
-        ]
-
     def rejects_an_enum_type_with_incorrectly_named_values():
         def schema_with_enum(name):
             return schema_with_field_type(

tests/utilities/test_extend_schema.py

@@ -1061,7 +1061,7 @@ def does_not_allow_replacing_an_existing_enum_value():
               ONE
             }
             """
-        with raises(GraphQLError) as exc_info:
+        with raises(TypeError) as exc_info:
             extend_test_schema(sdl)
         assert str(exc_info.value).startswith(
             "Enum value 'SomeEnum.ONE' already exists in the schema."