Reuse 'group_by' in validation rules

Replicates graphql/graphql-js@71c7a14

Author: Cito

src/graphql/pyutils/__init__.py

@@ -17,6 +17,7 @@
     unregister_description,
 )
 from .did_you_mean import did_you_mean
+from .group_by import group_by
 from .identity_func import identity_func
 from .inspect import inspect
 from .is_awaitable import is_awaitable
@@ -38,6 +39,7 @@
     "cached_property",
     "did_you_mean",
     "Description",
+    "group_by",
     "is_description",
     "register_description",
     "unregister_description",

src/graphql/pyutils/group_by.py

@@ -0,0 +1,16 @@
+from collections import defaultdict
+from typing import Callable, Collection, Dict, List, TypeVar
+
+__all__ = ["group_by"]
+
+K = TypeVar("K")
+T = TypeVar("T")
+
+
+def group_by(items: Collection[T], key_fn: Callable[[T], K]) -> Dict[K, List[T]]:
+    """Group an unsorted collection of items by a key derived via a function."""
+    result: Dict[K, List[T]] = defaultdict(list)
+    for item in items:
+        key = key_fn(item)
+        result[key].append(item)
+    return result

src/graphql/validation/rules/unique_argument_definition_names.py

@@ -1,6 +1,5 @@
-from collections import defaultdict
 from operator import attrgetter
-from typing import Any, Callable, Collection, Dict, List, TypeVar
+from typing import Any, Collection
 
 from ...error import GraphQLError
 from ...language import (
@@ -15,6 +14,7 @@
     VisitorAction,
     SKIP,
 )
+from ...pyutils import group_by
 from . import SDLValidationRule
 
 __all__ = ["UniqueArgumentDefinitionNamesRule"]
@@ -81,16 +81,3 @@ def check_arg_uniqueness(
                     )
                 )
         return SKIP
-
-
-K = TypeVar("K")
-T = TypeVar("T")
-
-
-def group_by(items: Collection[T], key_fn: Callable[[T], K]) -> Dict[K, List[T]]:
-    """Group an unsorted collection of items by a key derived via a function."""
-    result: Dict[K, List[T]] = defaultdict(list)
-    for item in items:
-        key = key_fn(item)
-        result[key].append(item)
-    return result

src/graphql/validation/rules/unique_argument_names.py

@@ -1,8 +1,10 @@
-from typing import Any, Dict
+from operator import attrgetter
+from typing import Any, Collection
 
 from ...error import GraphQLError
-from ...language import ArgumentNode, NameNode, VisitorAction, SKIP
-from . import ASTValidationContext, ASTValidationRule
+from ...language import ArgumentNode, DirectiveNode, FieldNode
+from ...pyutils import group_by
+from . import ASTValidationRule
 
 __all__ = ["UniqueArgumentNamesRule"]
 
@@ -16,26 +18,20 @@ class UniqueArgumentNamesRule(ASTValidationRule):
     See https://spec.graphql.org/draft/#sec-Argument-Names
     """
 
-    def __init__(self, context: ASTValidationContext):
-        super().__init__(context)
-        self.known_arg_names: Dict[str, NameNode] = {}
+    def enter_field(self, node: FieldNode, *_args: Any) -> None:
+        self.check_arg_uniqueness(node.arguments)
 
-    def enter_field(self, *_args: Any) -> None:
-        self.known_arg_names.clear()
+    def enter_directive(self, node: DirectiveNode, *args: Any) -> None:
+        self.check_arg_uniqueness(node.arguments)
 
-    def enter_directive(self, *_args: Any) -> None:
-        self.known_arg_names.clear()
+    def check_arg_uniqueness(self, argument_nodes: Collection[ArgumentNode]) -> None:
+        seen_args = group_by(argument_nodes, attrgetter("name.value"))
 
-    def enter_argument(self, node: ArgumentNode, *_args: Any) -> VisitorAction:
-        known_arg_names = self.known_arg_names
-        arg_name = node.name.value
-        if arg_name in known_arg_names:
-            self.report_error(
-                GraphQLError(
-                    f"There can be only one argument named '{arg_name}'.",
-                    [known_arg_names[arg_name], node.name],
+        for arg_name, arg_nodes in seen_args.items():
+            if len(arg_nodes) > 1:
+                self.report_error(
+                    GraphQLError(
+                        f"There can be only one argument named '{arg_name}'.",
+                        [node.name for node in arg_nodes],
+                    )
                 )
-            )
-        else:
-            known_arg_names[arg_name] = node.name
-        return SKIP

src/graphql/validation/rules/unique_variable_names.py

@@ -1,8 +1,10 @@
-from typing import Any, Dict
+from operator import attrgetter
+from typing import Any
 
 from ...error import GraphQLError
-from ...language import NameNode, VariableDefinitionNode
-from . import ASTValidationContext, ASTValidationRule
+from ...language import OperationDefinitionNode
+from ...pyutils import group_by
+from . import ASTValidationRule
 
 __all__ = ["UniqueVariableNamesRule"]
 
@@ -13,24 +15,20 @@ class UniqueVariableNamesRule(ASTValidationRule):
     A GraphQL operation is only valid if all its variables are uniquely named.
     """
 
-    def __init__(self, context: ASTValidationContext):
-        super().__init__(context)
-        self.known_variable_names: Dict[str, NameNode] = {}
-
-    def enter_operation_definition(self, *_args: Any) -> None:
-        self.known_variable_names.clear()
-
-    def enter_variable_definition(
-        self, node: VariableDefinitionNode, *_args: Any
+    def enter_operation_definition(
+        self, node: OperationDefinitionNode, *_args: Any
     ) -> None:
-        known_variable_names = self.known_variable_names
-        variable_name = node.variable.name.value
-        if variable_name in known_variable_names:
-            self.report_error(
-                GraphQLError(
-                    f"There can be only one variable named '${variable_name}'.",
-                    [known_variable_names[variable_name], node.variable.name],
+        variable_definitions = node.variable_definitions
+
+        seen_variable_definitions = group_by(
+            variable_definitions, attrgetter("variable.name.value")
+        )
+
+        for variable_name, variable_nodes in seen_variable_definitions.items():
+            if len(variable_nodes) > 1:
+                self.report_error(
+                    GraphQLError(
+                        f"There can be only one variable named '${variable_name}'.",
+                        [node.variable.name for node in variable_nodes],
+                    )
                 )
-            )
-        else:
-            known_variable_names[variable_name] = node.variable.name

tests/pyutils/test_group_by.py

@@ -0,0 +1,56 @@
+from graphql.pyutils import group_by
+
+
+def describe_group_by():
+    def does_accept_an_empty_list():
+        def key_fn(_x: str) -> str:
+            raise TypeError("Unexpected call of key function.")
+
+        assert group_by([], key_fn) == {}
+
+    def does_not_change_order():
+        def key_fn(_x: int) -> str:
+            return "all"
+
+        assert group_by([3, 1, 5, 4, 2, 6], key_fn) == {
+            "all": [3, 1, 5, 4, 2, 6],
+        }
+
+    def can_group_by_odd_and_even():
+        def key_fn(x: int) -> str:
+            return "odd" if x % 2 else "even"
+
+        assert group_by([3, 1, 5, 4, 2, 6], key_fn) == {
+            "odd": [3, 1, 5],
+            "even": [4, 2, 6],
+        }
+
+    def can_group_by_string_length():
+        def key_fn(s: str) -> int:
+            return len(s)
+
+        assert group_by(
+            [
+                "alpha",
+                "beta",
+                "gamma",
+                "delta",
+                "epsilon",
+                "zeta",
+                "eta",
+                "iota",
+                "kapp",
+                "lambda",
+                "my",
+                "ny",
+                "omikron",
+            ],
+            key_fn,
+        ) == {
+            2: ["my", "ny"],
+            3: ["eta"],
+            4: ["beta", "zeta", "iota", "kapp"],
+            5: ["alpha", "gamma", "delta"],
+            6: ["lambda"],
+            7: ["epsilon", "omikron"],
+        }

tests/validation/test_unique_argument_names.py

@@ -116,11 +116,7 @@ def many_duplicate_field_arguments():
             [
                 {
                     "message": "There can be only one argument named 'arg1'.",
-                    "locations": [(3, 21), (3, 36)],
-                },
-                {
-                    "message": "There can be only one argument named 'arg1'.",
-                    "locations": [(3, 21), (3, 51)],
+                    "locations": [(3, 21), (3, 36), (3, 51)],
                 },
             ],
         )
@@ -150,11 +146,7 @@ def many_duplicate_directive_arguments():
             [
                 {
                     "message": "There can be only one argument named 'arg1'.",
-                    "locations": [(3, 32), (3, 47)],
-                },
-                {
-                    "message": "There can be only one argument named 'arg1'.",
-                    "locations": [(3, 32), (3, 62)],
+                    "locations": [(3, 32), (3, 47), (3, 62)],
                 },
             ],
         )

tests/validation/test_unique_variable_names.py

@@ -28,11 +28,7 @@ def duplicate_variable_names():
             [
                 {
                     "message": "There can be only one variable named '$x'.",
-                    "locations": [(2, 22), (2, 31)],
-                },
-                {
-                    "message": "There can be only one variable named '$x'.",
-                    "locations": [(2, 22), (2, 40)],
+                    "locations": [(2, 22), (2, 31), (2, 40)],
                 },
                 {
                     "message": "There can be only one variable named '$x'.",