Add parent type to path to avoid path ambiguity

Replicates graphql/graphql-js@b489677

Author: Cito

src/graphql/execution/execute.py

@@ -369,7 +369,7 @@ def execute_fields_serially(
         results: AwaitableOrValue[Dict[str, Any]] = {}
         is_awaitable = self.is_awaitable
         for response_name, field_nodes in fields.items():
-            field_path = Path(path, response_name)
+            field_path = Path(path, response_name, parent_type.name)
             result = self.resolve_field(
                 parent_type, source_value, field_nodes, field_path
             )
@@ -430,7 +430,7 @@ def execute_fields(
         awaitable_fields: List[str] = []
         append_awaitable = awaitable_fields.append
         for response_name, field_nodes in fields.items():
-            field_path = Path(path, response_name)
+            field_path = Path(path, response_name, parent_type.name)
             result = self.resolve_field(
                 parent_type, source_value, field_nodes, field_path
             )
@@ -825,7 +825,7 @@ def complete_list_value(
         for index, item in enumerate(result):
             # No need to modify the info object containing the path, since from here on
             # it is not ever accessed by resolver functions.
-            field_path = path.add_key(index)
+            field_path = path.add_key(index, None)
             completed_item = self.complete_value_catching_error(
                 item_type, field_nodes, info, field_path, item
             )

src/graphql/pyutils/path.py

@@ -1,4 +1,4 @@
-from typing import Any, List, NamedTuple, Union
+from typing import Any, List, NamedTuple, Optional, Union
 
 __all__ = ["Path"]
 
@@ -10,10 +10,12 @@ class Path(NamedTuple):
     """path with the previous indices"""
     key: Union[str, int]
     """current index in the path (string or integer)"""
+    typename: Optional[str]
+    """name of the parent type to avoid path ambiguity"""
 
-    def add_key(self, key: Union[str, int]) -> "Path":
+    def add_key(self, key: Union[str, int], typename: Optional[str] = None) -> "Path":
         """Return a new Path containing the given key."""
-        return Path(self, key)
+        return Path(self, key, typename)
 
     def as_list(self) -> List[Union[str, int]]:
         """Return a list of the path keys."""

src/graphql/subscription/subscribe.py

@@ -161,7 +161,7 @@ async def create_source_event_stream(
     # AsyncIterable yielding raw payloads.
     resolve_fn = field_def.subscribe or context.field_resolver
 
-    path = Path(None, response_name)
+    path = Path(None, response_name, type_.name)
 
     info = context.build_resolve_info(field_def, field_nodes, type_, path)
 

src/graphql/utilities/coerce_input_value.py

@@ -71,7 +71,7 @@ def coerce_input_value(
             for index, item_value in enumerate(input_value):
                 append_item(
                     coerce_input_value(
-                        item_value, item_type, on_error, Path(path, index)
+                        item_value, item_type, on_error, Path(path, index, None)
                     )
                 )
             return coerced_list
@@ -111,7 +111,7 @@ def coerce_input_value(
                 continue
 
             coerced_dict[field.out_name or field_name] = coerce_input_value(
-                field_value, field.type, on_error, Path(path, field_name)
+                field_value, field.type, on_error, Path(path, field_name, type_.name)
             )
 
         # Ensure every provided field is defined.

tests/execution/test_executor.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import cast, Awaitable
+from typing import cast, Any, Awaitable, Optional
 
 from pytest import raises, mark  # type: ignore
 
@@ -20,6 +20,7 @@
     GraphQLSchema,
     GraphQLScalarType,
     GraphQLString,
+    GraphQLUnionType,
     ResponsePath,
 )
 
@@ -302,7 +303,7 @@ def resolve(_obj, info):
             field_nodes=[field],
             return_type=GraphQLString,
             parent_type=cast(GraphQLObjectType, schema.query_type),
-            path=ResponsePath(None, "result"),
+            path=ResponsePath(None, "result", "Test"),
             schema=schema,
             fragments={},
             root_value=root_value,
@@ -312,6 +313,58 @@ def resolve(_obj, info):
             is_awaitable=resolved_infos[0].is_awaitable,
         )
 
+    def it_populates_path_correctly_with_complex_types():
+        path: Optional[ResponsePath] = None
+
+        def resolve(_val, info):
+            nonlocal path
+            path = info.path
+
+        def resolve_type(_val, _info, _type):
+            return "SomeObject"
+
+        some_object = GraphQLObjectType(
+            "SomeObject", {"test": GraphQLField(GraphQLString, resolve=resolve)}
+        )
+        some_union = GraphQLUnionType(
+            "SomeUnion", [some_object], resolve_type=resolve_type
+        )
+        test_type = GraphQLObjectType(
+            "SomeQuery",
+            {
+                "test": GraphQLField(
+                    GraphQLNonNull(GraphQLList(GraphQLNonNull(some_union)))
+                )
+            },
+        )
+        schema = GraphQLSchema(test_type)
+        root_value: Any = {"test": [{}]}
+        document = parse(
+            """
+            query {
+              l1: test {
+                ... on SomeObject {
+                  l2: test
+                }
+              }
+            }
+            """
+        )
+
+        execute_sync(schema, document, root_value)
+
+        assert path is not None
+        prev, key, typename = path
+        assert key == "l2"
+        assert typename == "SomeObject"
+        prev, key, typename = prev
+        assert key == 0
+        assert typename is None
+        prev, key, typename = prev
+        assert key == "l1"
+        assert typename == "SomeQuery"
+        assert prev is None
+
     def threads_root_value_context_correctly():
         resolved_values = []
 

tests/pyutils/test_path.py

@@ -3,24 +3,24 @@
 
 def describe_path():
     def add_path():
-        path = Path(None, 0)
+        path = Path(None, 0, None)
         assert path.prev is None
         assert path.key == 0
-        prev, path = path, Path(path, 1)
+        prev, path = path, Path(path, 1, None)
         assert path.prev is prev
         assert path.key == 1
-        prev, path = path, Path(path, "two")
+        prev, path = path, Path(path, "two", None)
         assert path.prev is prev
         assert path.key == "two"
 
     def add_key():
-        prev = Path(None, 0)
+        prev = Path(None, 0, None)
         path = prev.add_key("one")
         assert path.prev is prev
         assert path.key == "one"
 
     def as_list():
-        path = Path(None, 1)
+        path = Path(None, 1, None)
         assert path.as_list() == [1]
         path = path.add_key("two")
         assert path.as_list() == [1, "two"]