fix(types): path is required within incremental results

Replicates graphql/graphql-js@d1d66a3

Author: Cito

src/graphql/execution/incremental_publisher.py

@@ -364,51 +364,52 @@ class ExperimentalIncrementalExecutionResults(NamedTuple):
 class FormattedIncrementalDeferResult(TypedDict, total=False):
     """Formatted incremental deferred execution result"""
 
-    data: dict[str, Any] | None
-    errors: list[GraphQLFormattedError]
+    data: dict[str, Any]
     path: list[str | int]
+    errors: list[GraphQLFormattedError]
     extensions: dict[str, Any]
 
 
 class IncrementalDeferResult:
     """Incremental deferred execution result"""
 
-    data: dict[str, Any] | None
+    data: dict[str, Any]
+    path: list[str | int]
     errors: list[GraphQLError] | None
-    path: list[str | int] | None
     extensions: dict[str, Any] | None
 
     __slots__ = "data", "errors", "extensions", "path"
 
     def __init__(
         self,
-        data: dict[str, Any] | None = None,
+        data: dict[str, Any],
+        path: list[str | int],
         errors: list[GraphQLError] | None = None,
-        path: list[str | int] | None = None,
         extensions: dict[str, Any] | None = None,
     ) -> None:
         self.data = data
-        self.errors = errors
         self.path = path
+        self.errors = errors
         self.extensions = extensions
 
     def __repr__(self) -> str:
         name = self.__class__.__name__
-        args: list[str] = [f"data={self.data!r}, errors={self.errors!r}"]
-        if self.path:
-            args.append(f"path={self.path!r}")
+        args: list[str] = [f"data={self.data!r}, path={self.path!r}"]
+        if self.errors:
+            args.append(f"errors={self.errors!r}")
         if self.extensions:
             args.append(f"extensions={self.extensions}")
         return f"{name}({', '.join(args)})"
 
     @property
     def formatted(self) -> FormattedIncrementalDeferResult:
         """Get execution result formatted according to the specification."""
-        formatted: FormattedIncrementalDeferResult = {"data": self.data}
+        formatted: FormattedIncrementalDeferResult = {
+            "data": self.data,
+            "path": self.path,
+        }
         if self.errors is not None:
             formatted["errors"] = [error.formatted for error in self.errors]
-        if self.path is not None:
-            formatted["path"] = self.path
         if self.extensions is not None:
             formatted["extensions"] = self.extensions
         return formatted
@@ -442,51 +443,52 @@ def __ne__(self, other: object) -> bool:
 class FormattedIncrementalStreamResult(TypedDict, total=False):
     """Formatted incremental stream execution result"""
 
-    items: list[Any] | None
-    errors: list[GraphQLFormattedError]
+    items: list[Any]
     path: list[str | int]
+    errors: list[GraphQLFormattedError]
     extensions: dict[str, Any]
 
 
 class IncrementalStreamResult:
     """Incremental streamed execution result"""
 
-    items: list[Any] | None
+    items: list[Any]
+    path: list[str | int]
     errors: list[GraphQLError] | None
-    path: list[str | int] | None
     extensions: dict[str, Any] | None
 
     __slots__ = "errors", "extensions", "items", "label", "path"
 
     def __init__(
         self,
-        items: list[Any] | None = None,
+        items: list[Any],
+        path: list[str | int],
         errors: list[GraphQLError] | None = None,
-        path: list[str | int] | None = None,
         extensions: dict[str, Any] | None = None,
     ) -> None:
         self.items = items
-        self.errors = errors
         self.path = path
+        self.errors = errors
         self.extensions = extensions
 
     def __repr__(self) -> str:
         name = self.__class__.__name__
-        args: list[str] = [f"items={self.items!r}, errors={self.errors!r}"]
-        if self.path:
-            args.append(f"path={self.path!r}")
+        args: list[str] = [f"items={self.items!r}, path={self.path!r}"]
+        if self.errors:
+            args.append(f"errors={self.errors!r}")
         if self.extensions:
             args.append(f"extensions={self.extensions}")
         return f"{name}({', '.join(args)})"
 
     @property
     def formatted(self) -> FormattedIncrementalStreamResult:
         """Get execution result formatted according to the specification."""
-        formatted: FormattedIncrementalStreamResult = {"items": self.items}
-        if self.errors is not None:
+        formatted: FormattedIncrementalStreamResult = {
+            "items": self.items,
+            "path": self.path,
+        }
+        if self.errors:
             formatted["errors"] = [error.formatted for error in self.errors]
-        if self.path is not None:
-            formatted["path"] = self.path
         if self.extensions is not None:
             formatted["extensions"] = self.extensions
         return formatted
@@ -982,8 +984,8 @@ def _process_pending(
                     continue
                 incremental_result = IncrementalStreamResult(
                     subsequent_result_record.items,
-                    subsequent_result_record.errors or None,
                     subsequent_result_record.stream_record.path,
+                    subsequent_result_record.errors or None,
                 )
                 incremental_results.append(incremental_result)
             else:
@@ -997,9 +999,9 @@ def _process_pending(
                     if not deferred_grouped_field_set_record.sent:
                         deferred_grouped_field_set_record.sent = True
                         incremental_result = IncrementalDeferResult(
-                            deferred_grouped_field_set_record.data,
-                            deferred_grouped_field_set_record.errors or None,
+                            deferred_grouped_field_set_record.data,  # type: ignore
                             deferred_grouped_field_set_record.path,
+                            deferred_grouped_field_set_record.errors or None,
                         )
                         incremental_results.append(incremental_result)
         return IncrementalUpdate(

tests/execution/test_defer.py

@@ -256,9 +256,9 @@ def can_compare_completed_result():
         assert result != {**args, "errors": [{"message": "oops"}]}
 
     def can_format_and_print_incremental_defer_result():
-        result = IncrementalDeferResult()
-        assert result.formatted == {"data": None}
-        assert str(result) == "IncrementalDeferResult(data=None, errors=None)"
+        result = IncrementalDeferResult(data={}, path=[])
+        assert result.formatted == {"data": {}, "path": []}
+        assert str(result) == "IncrementalDeferResult(data={}, path=[])"
 
         result = IncrementalDeferResult(
             data={"hello": "world"},
@@ -274,7 +274,7 @@ def can_format_and_print_incremental_defer_result():
         }
         assert (
             str(result) == "IncrementalDeferResult(data={'hello': 'world'},"
-            " errors=[GraphQLError('msg')], path=['foo', 1], extensions={'baz': 2})"
+            " path=['foo', 1], errors=[GraphQLError('msg')], extensions={'baz': 2})"
         )
 
     # noinspection PyTypeChecker
@@ -422,7 +422,7 @@ def can_format_and_print_subsequent_incremental_execution_result():
         assert str(result) == "SubsequentIncrementalExecutionResult(has_next)"
 
         pending = [PendingResult(["bar"])]
-        incremental = [cast(IncrementalResult, IncrementalDeferResult())]
+        incremental = [cast(IncrementalResult, IncrementalDeferResult({"one": 1}, [1]))]
         completed = [CompletedResult(["foo", 1])]
         result = SubsequentIncrementalExecutionResult(
             has_next=True,
@@ -434,7 +434,7 @@ def can_format_and_print_subsequent_incremental_execution_result():
         assert result.formatted == {
             "hasNext": True,
             "pending": [{"path": ["bar"]}],
-            "incremental": [{"data": None}],
+            "incremental": [{"data": {"one": 1}, "path": [1]}],
             "completed": [{"path": ["foo", 1]}],
             "extensions": {"baz": 2},
         }
@@ -445,7 +445,7 @@ def can_format_and_print_subsequent_incremental_execution_result():
 
     def can_compare_subsequent_incremental_execution_result():
         pending = [PendingResult(["bar"])]
-        incremental = [cast(IncrementalResult, IncrementalDeferResult())]
+        incremental = [cast(IncrementalResult, IncrementalDeferResult({"one": 1}, [1]))]
         completed = [CompletedResult(path=["foo", 1])]
         args: dict[str, Any] = {
             "has_next": True,

tests/execution/test_stream.py

@@ -148,9 +148,9 @@ def modified_args(args: dict[str, Any], **modifications: Any) -> dict[str, Any]:
 
 def describe_execute_stream_directive():
     def can_format_and_print_incremental_stream_result():
-        result = IncrementalStreamResult()
-        assert result.formatted == {"items": None}
-        assert str(result) == "IncrementalStreamResult(items=None, errors=None)"
+        result = IncrementalStreamResult(items=[], path=[])
+        assert result.formatted == {"items": [], "path": []}
+        assert str(result) == "IncrementalStreamResult(items=[], path=[])"
 
         result = IncrementalStreamResult(
             items=["hello", "world"],
@@ -166,7 +166,7 @@ def can_format_and_print_incremental_stream_result():
         }
         assert (
             str(result) == "IncrementalStreamResult(items=['hello', 'world'],"
-            " errors=[GraphQLError('msg')], path=['foo', 1], extensions={'baz': 2})"
+            " path=['foo', 1], errors=[GraphQLError('msg')], extensions={'baz': 2})"
         )
 
     def can_print_stream_record():