OverlappingFieldsCanBeMerged: sort argument values before comparing

Replicates graphql/graphql-js@40c160e

Author: Cito

src/graphql/utilities/find_breaking_changes.py

@@ -1,8 +1,8 @@
 from enum import Enum
 from typing import Any, Collection, Dict, List, NamedTuple, Union, cast
 
-from ..language import print_ast, visit, ObjectValueNode, Visitor
-from ..pyutils import inspect, natural_comparison_key, Undefined
+from ..language import print_ast
+from ..pyutils import inspect, Undefined
 from ..type import (
     GraphQLEnumType,
     GraphQLField,
@@ -28,6 +28,7 @@
     is_specified_scalar_type,
     is_union_type,
 )
+from ..utilities.sort_value_node import sort_value_node
 from .ast_from_value import ast_from_value
 
 __all__ = [
@@ -555,24 +556,7 @@ def stringify_value(value: Any, type_: GraphQLInputType) -> str:
     ast = ast_from_value(value, type_)
     if ast is None:  # pragma: no cover
         raise TypeError(f"Invalid value: {inspect(value)}")
-
-    class SortVisitor(Visitor):
-        @staticmethod
-        def enter_object_value(
-            object_value_node: ObjectValueNode, *_args: Any
-        ) -> ObjectValueNode:
-            object_value_node.fields = tuple(
-                sorted(
-                    object_value_node.fields,
-                    key=lambda node: natural_comparison_key(node.name.value),
-                )
-            )
-
-            return object_value_node
-
-    sorted_ast = visit(ast, SortVisitor())
-
-    return print_ast(sorted_ast)
+    return print_ast(sort_value_node(ast))
 
 
 class ListDiff(NamedTuple):

src/graphql/utilities/sort_value_node.py

@@ -0,0 +1,38 @@
+from copy import copy
+from typing import Tuple
+
+from ..language import ListValueNode, ObjectFieldNode, ObjectValueNode, ValueNode
+from ..pyutils import natural_comparison_key
+
+__all__ = ["sort_value_node"]
+
+
+def sort_value_node(value_node: ValueNode) -> ValueNode:
+    """Sort ValueNode.
+
+    This function returns a sorted copy of the given ValueNode
+
+    For internal use only.
+    """
+    if isinstance(value_node, ObjectValueNode):
+        value_node = copy(value_node)
+        value_node.fields = sort_fields(value_node.fields)
+    elif isinstance(value_node, ListValueNode):
+        value_node = copy(value_node)
+        value_node.values = tuple(sort_value_node(value) for value in value_node.values)
+    return value_node
+
+
+def sort_field(field: ObjectFieldNode) -> ObjectFieldNode:
+    field = copy(field)
+    field.value = sort_value_node(field.value)
+    return field
+
+
+def sort_fields(fields: Tuple[ObjectFieldNode, ...]) -> Tuple[ObjectFieldNode, ...]:
+    return tuple(
+        sorted(
+            (sort_field(field) for field in fields),
+            key=lambda field: natural_comparison_key(field.name.value),
+        )
+    )

src/graphql/validation/rules/overlapping_fields_can_be_merged.py

@@ -27,6 +27,7 @@
     is_object_type,
 )
 from ...utilities import type_from_ast
+from ...utilities.sort_value_node import sort_value_node
 from . import ValidationContext, ValidationRule
 
 MYPY = False
@@ -589,16 +590,16 @@ def same_arguments(
     for argument1 in arguments1:
         for argument2 in arguments2:
             if argument2.name.value == argument1.name.value:
-                if not same_value(argument1.value, argument2.value):
+                if stringify_value(argument1.value) != stringify_value(argument2.value):
                     return False
                 break
         else:
             return False
     return True
 
 
-def same_value(value1: ValueNode, value2: ValueNode) -> bool:
-    return print_ast(value1) == print_ast(value2)
+def stringify_value(value: ValueNode) -> str:
+    return print_ast(sort_value_node(value))
 
 
 def do_types_conflict(type1: GraphQLOutputType, type2: GraphQLOutputType) -> bool:

tests/utilities/test_sort_value_node.py

@@ -0,0 +1,33 @@
+from graphql.language import parse_value, print_ast
+from graphql.utilities.sort_value_node import sort_value_node
+
+
+def describe_sort_value_node():
+    def _expect_sorted_value(source: str, expected: str) -> None:
+        assert print_ast(sort_value_node(parse_value(source))) == expected
+
+    def do_not_change_non_object_values():
+        _expect_sorted_value("1", "1")
+        _expect_sorted_value("3.14", "3.14")
+        _expect_sorted_value("null", "null")
+        _expect_sorted_value("true", "true")
+        _expect_sorted_value("false", "false")
+        _expect_sorted_value('"cba"', '"cba"')
+        _expect_sorted_value(
+            '[1, 3.14, null, false, "cba"]', '[1, 3.14, null, false, "cba"]'
+        )
+        _expect_sorted_value(
+            '[[1, 3.14, null, false, "cba"]]', '[[1, 3.14, null, false, "cba"]]'
+        )
+
+    def sort_input_object_fields():
+        _expect_sorted_value("{ b: 2, a: 1 }", "{a: 1, b: 2}")
+        _expect_sorted_value("{ a: { c: 3, b: 2 } }", "{a: {b: 2, c: 3}}")
+        _expect_sorted_value(
+            "[{ b: 2, a: 1 }, { d: 4, c: 3}]",
+            "[{a: 1, b: 2}, {c: 3, d: 4}]",
+        )
+        _expect_sorted_value(
+            "{ b: { g: 7, f: 6 }, c: 3 , a: { d: 4, e: 5 } }",
+            "{a: {d: 4, e: 5}, b: {f: 6, g: 7}, c: 3}",
+        )

tests/validation/test_overlapping_fields_can_be_merged.py

@@ -229,6 +229,53 @@ def allows_different_args_where_no_conflict_is_possible():
             """
         )
 
+    def allows_different_order_of_args():
+        schema = build_schema(
+            """
+            type Query {
+              someField(a: String, b: String): String
+            }
+            """
+        )
+        # This is valid since arguments are unordered, see:
+        # https://spec.graphql.org/draft/#
+        # sec-Language.Arguments.Arguments-are-unordered
+        assert_valid(
+            """
+            {
+              someField(a: null, b: null)
+              someField(b: null, a: null)
+            }
+            """,
+            schema=schema,
+        )
+
+    def allows_different_order_of_input_object_fields_in_arg_values():
+        schema = build_schema(
+            """
+            input SomeInput {
+              a: String
+              b: String
+            }
+
+            type Query {
+              someField(arg: SomeInput): String
+            }
+            """
+        )
+        # This is valid since input object fields are unordered, see:
+        # https://spec.graphql.org/draft/#
+        # sec-Input-Object-Values.Input-object-fields-are-unordered
+        assert_valid(
+            """
+            {
+              someField(arg: { a: null, b: null })
+              someField(arg: { b: null, a: null })
+            }
+            """,
+            schema=schema,
+        )
+
     def encounters_conflict_in_fragments():
         assert_errors(
             """