Extract check for unique operation types into separate rule

Replicates graphql/graphql-js@9b7a8af

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

graphql/utilities/build_ast_schema.py

@@ -172,8 +172,6 @@ def get_operation_types(
     for operation_type in schema.operation_types:
         type_name = operation_type.type.name.value
         operation = operation_type.operation
-        if operation in op_types:
-            raise TypeError(f"Must provide only one {operation.value} type in schema.")
         if type_name not in node_map:
             raise TypeError(
                 f"Specified {operation.value} type '{type_name}'"

graphql/utilities/extend_schema.py

@@ -496,10 +496,6 @@ def resolve_type(type_ref: NamedTypeNode) -> GraphQLNamedType:
     if schema_def:
         for operation_type in schema_def.operation_types:
             operation = operation_type.operation
-            if operation_types[operation]:
-                raise TypeError(
-                    f"Must provide only one {operation.value} type in schema."
-                )
             # 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.
@@ -510,10 +506,6 @@ def resolve_type(type_ref: NamedTypeNode) -> GraphQLNamedType:
         if schema_extension.operation_types:
             for operation_type in schema_extension.operation_types:
                 operation = operation_type.operation
-                if operation_types[operation]:
-                    raise TypeError(
-                        f"Must provide only one {operation.value} type in schema."
-                    )
                 # 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

graphql/validation/rules/unique_operation_types.py

@@ -0,0 +1,80 @@
+from typing import Dict, Optional, Union
+
+from ...error import GraphQLError
+from ...language import (
+    OperationTypeDefinitionNode,
+    OperationType,
+    SchemaDefinitionNode,
+    SchemaExtensionNode,
+)
+from ...type import GraphQLObjectType
+from . import SDLValidationContext, SDLValidationRule
+
+__all__ = [
+    "UniqueOperationTypesRule",
+    "duplicate_operation_type_message",
+    "existed_operation_type_message",
+]
+
+
+def duplicate_operation_type_message(operation: str) -> str:
+    return f"There can be only one '{operation}' type in schema."
+
+
+def existed_operation_type_message(operation: str) -> str:
+    return (
+        f"Type for '{operation}' already defined in the schema."
+        " It cannot be redefined."
+    )
+
+
+class UniqueOperationTypesRule(SDLValidationRule):
+    """Unique operation types
+
+    A GraphQL document is only valid if it has only one type per operation.
+    """
+
+    def __init__(self, context: SDLValidationContext) -> None:
+        super().__init__(context)
+        schema = context.schema
+        self.defined_operation_types: Dict[
+            OperationType, OperationTypeDefinitionNode
+        ] = {}
+        self.existing_operation_types: Dict[
+            OperationType, Optional[GraphQLObjectType]
+        ] = (
+            {
+                OperationType.QUERY: schema.query_type,
+                OperationType.MUTATION: schema.mutation_type,
+                OperationType.SUBSCRIPTION: schema.subscription_type,
+            }
+            if schema
+            else {}
+        )
+        self.schema = schema
+
+    def check_operation_types(
+        self, node: Union[SchemaDefinitionNode, SchemaExtensionNode], *_args
+    ):
+        for operation_type in node.operation_types or []:
+            operation = operation_type.operation
+            already_defined_operation_type = self.defined_operation_types.get(operation)
+
+            if self.existing_operation_types.get(operation):
+                self.report_error(
+                    GraphQLError(
+                        existed_operation_type_message(operation.value), operation_type
+                    )
+                )
+            elif already_defined_operation_type:
+                self.report_error(
+                    GraphQLError(
+                        duplicate_operation_type_message(operation.value),
+                        [already_defined_operation_type, operation_type],
+                    )
+                )
+            else:
+                self.defined_operation_types[operation] = operation_type
+        return self.SKIP
+
+    enter_schema_definition = enter_schema_extension = check_operation_types

graphql/validation/rules/unique_type_names.py

@@ -52,9 +52,6 @@ def check_type_name(self, node: TypeDefinitionNode, *_args):
                 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
+    enter_scalar_type_definition = enter_object_type_definition = check_type_name
+    enter_interface_type_definition = enter_union_type_definition = check_type_name
+    enter_enum_type_definition = 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_operation_types import UniqueOperationTypesRule
 from .rules.unique_type_names import UniqueTypeNamesRule
 from .rules.unique_directive_names import UniqueDirectiveNamesRule
 from .rules.known_argument_names import KnownArgumentNamesOnDirectivesRule
@@ -126,6 +127,7 @@
 
 specified_sdl_rules: List[RuleType] = [
     LoneSchemaDefinitionRule,
+    UniqueOperationTypesRule,
     UniqueTypeNamesRule,
     UniqueDirectiveNamesRule,
     KnownDirectivesRule,

tests/utilities/test_build_ast_schema.py

@@ -776,67 +776,6 @@ def allows_to_disable_sdl_validation():
 
 
 def describe_failures():
-    def allows_only_a_single_query_type():
-        sdl = """
-            schema {
-              query: Hello
-              query: Yellow
-            }
-
-            type Hello {
-              bar: String
-            }
-
-            type Yellow {
-              isColor: Boolean
-            }
-            """
-        with raises(TypeError) as exc_info:
-            build_schema(sdl)
-        msg = str(exc_info.value)
-        assert msg == "Must provide only one query type in schema."
-
-    def allows_only_a_single_mutation_type():
-        sdl = """
-            schema {
-              query: Hello
-              mutation: Hello
-              mutation: Yellow
-            }
-
-            type Hello {
-              bar: String
-            }
-
-            type Yellow {
-              isColor: Boolean
-            }
-            """
-        with raises(TypeError) as exc_info:
-            build_schema(sdl)
-        msg = str(exc_info.value)
-        assert msg == "Must provide only one mutation type in schema."
-
-    def allows_only_a_single_subscription_type():
-        sdl = """
-            schema {
-              query: Hello
-              subscription: Hello
-              subscription: Yellow
-            }
-            type Hello {
-              bar: String
-            }
-
-            type Yellow {
-              isColor: Boolean
-            }
-            """
-        with raises(TypeError) as exc_info:
-            build_schema(sdl)
-        msg = str(exc_info.value)
-        assert msg == "Must provide only one subscription type in schema."
-
     def unknown_type_referenced():
         sdl = """
             schema {

tests/utilities/test_extend_schema.py

@@ -1286,63 +1286,3 @@ def schema_extension_ast_are_available_from_schema_object():
                 extend schema @foo
                 """
             )
-
-        def does_not_allow_redefining_an_existing_root_type():
-            sdl = """
-                extend schema {
-                  query: SomeType
-                }
-
-                type SomeType {
-                  seeSomething: String
-                }
-                """
-            with raises(TypeError) as exc_info:
-                extend_test_schema(sdl)
-            assert str(exc_info.value).startswith(
-                "Must provide only one query type in schema."
-            )
-
-        def does_not_allow_defining_a_root_operation_type_twice():
-            sdl = """
-                extend schema {
-                  mutation: Mutation
-                }
-
-                extend schema {
-                  mutation: Mutation
-                }
-
-                type Mutation {
-                  doSomething: String
-                }
-                """
-            with raises(TypeError) as exc_info:
-                extend_test_schema(sdl)
-            assert str(exc_info.value).startswith(
-                "Must provide only one mutation type in schema."
-            )
-
-        def does_not_allow_defining_root_operation_type_with_different_types():
-            sdl = """
-                extend schema {
-                  mutation: Mutation
-                }
-
-                extend schema {
-                  mutation: SomethingElse
-                }
-
-                type Mutation {
-                  doSomething: String
-                }
-
-                type SomethingElse {
-                  doSomethingElse: String
-                }
-                """
-            with raises(TypeError) as exc_info:
-                extend_test_schema(sdl)
-            assert str(exc_info.value).startswith(
-                "Must provide only one mutation type in schema."
-            )