refactor(IncrementalGraph): use set of pending deferred grouped field set results to reduce mutation

Replicates graphql/graphql-js@15ab731

Author: Cito

src/graphql/execution/execute.py

@@ -1626,15 +1626,19 @@ def execute_deferred_grouped_field_sets(
                 defer_usage_set, defer_map
             )
 
+            deferred_grouped_field_set_record = DeferredGroupedFieldSetRecord(
+                deferred_fragment_records, cast("DeferredGroupedFieldSetResult", None)
+            )
+
             if should_defer(parent_defer_usages, defer_usage_set):
 
                 async def executor(
-                    deferred_fragment_records: list[DeferredFragmentRecord],
+                    deferred_grouped_field_set_record: DeferredGroupedFieldSetRecord,
                     grouped_field_set: GroupedFieldSet,
                     defer_usage_set: DeferUsageSet,
                 ) -> DeferredGroupedFieldSetResult:
                     result = self.execute_deferred_grouped_field_set(
-                        deferred_fragment_records,
+                        deferred_grouped_field_set_record,
                         parent_type,
                         source_value,
                         path,
@@ -1646,33 +1650,30 @@ async def executor(
                         return await result
                     return cast("DeferredGroupedFieldSetResult", result)
 
-                deferred_grouped_field_set_record = DeferredGroupedFieldSetRecord(
-                    deferred_fragment_records,
-                    executor(
-                        deferred_fragment_records, grouped_field_set, defer_usage_set
-                    ),
+                deferred_grouped_field_set_record.result = executor(
+                    deferred_grouped_field_set_record,
+                    grouped_field_set,
+                    defer_usage_set,
                 )
             else:
                 executed = self.execute_deferred_grouped_field_set(
-                    deferred_fragment_records,
+                    deferred_grouped_field_set_record,
                     parent_type,
                     source_value,
                     path,
                     grouped_field_set,
                     IncrementalContext(defer_usage_set),
                     defer_map,
                 )
-                deferred_grouped_field_set_record = DeferredGroupedFieldSetRecord(
-                    deferred_fragment_records, executed
-                )
+                deferred_grouped_field_set_record.result = executed
 
             append_record(deferred_grouped_field_set_record)
 
         return new_deferred_grouped_field_set_records
 
     def execute_deferred_grouped_field_set(
         self,
-        deferred_fragment_records: list[DeferredFragmentRecord],
+        deferred_grouped_field_set_record: DeferredGroupedFieldSetRecord,
         parent_type: GraphQLObjectType,
         source_value: Any,
         path: Path | None,
@@ -1692,7 +1693,7 @@ def execute_deferred_grouped_field_set(
             )
         except GraphQLError as error:
             return NonReconcilableDeferredGroupedFieldSetResult(
-                deferred_fragment_records,
+                deferred_grouped_field_set_record,
                 path.as_list() if path else [],
                 with_error(incremental_context.errors, error),
             )
@@ -1704,13 +1705,13 @@ async def await_result() -> DeferredGroupedFieldSetResult:
                     awaited_result = await result
                 except GraphQLError as error:
                     return NonReconcilableDeferredGroupedFieldSetResult(
-                        deferred_fragment_records,
+                        deferred_grouped_field_set_record,
                         path.as_list() if path else [],
                         with_error(incremental_context.errors, error),
                     )
                 return build_deferred_grouped_field_set_result(
                     incremental_context.errors,
-                    deferred_fragment_records,
+                    deferred_grouped_field_set_record,
                     path,
                     awaited_result,
                 )
@@ -1719,7 +1720,7 @@ async def await_result() -> DeferredGroupedFieldSetResult:
 
         return build_deferred_grouped_field_set_result(
             incremental_context.errors,
-            deferred_fragment_records,
+            deferred_grouped_field_set_record,
             path,
             result,  # type: ignore
         )
@@ -2330,13 +2331,13 @@ def should_defer(
 
 def build_deferred_grouped_field_set_result(
     errors: list[GraphQLError] | None,
-    deferred_fragment_records: list[DeferredFragmentRecord],
+    deferred_grouped_field_set_record: DeferredGroupedFieldSetRecord,
     path: Path | None,
     result: GraphQLWrappedResult[dict[str, Any]],
 ) -> DeferredGroupedFieldSetResult:
     """Build a deferred grouped fieldset result."""
     return ReconcilableDeferredGroupedFieldSetResult(
-        deferred_fragment_records=deferred_fragment_records,
+        deferred_grouped_field_set_record=deferred_grouped_field_set_record,
         path=path.as_list() if path else [],
         result=BareDeferredGroupedFieldSetResult(result.result, errors or None),
         incremental_data_records=result.increments,

src/graphql/execution/incremental_graph.py

@@ -25,6 +25,7 @@
 if TYPE_CHECKING:
     from graphql.execution.types import (
         DeferredFragmentRecord,
+        DeferredGroupedFieldSetRecord,
         DeferredGroupedFieldSetResult,
         IncrementalDataRecord,
         IncrementalDataRecordResult,
@@ -48,23 +49,23 @@ class DeferredFragmentNode:
     __slots__ = (
         "children",
         "deferred_fragment_record",
-        "expected_reconcilable_results",
+        "deferred_grouped_field_set_records",
         "reconcilable_results",
         "results",
     )
 
     deferred_fragment_record: DeferredFragmentRecord
-    expected_reconcilable_results: int
+    deferred_grouped_field_set_records: dict[DeferredGroupedFieldSetRecord, None]
     results: list[DeferredGroupedFieldSetResult]
-    reconcilable_results: list[ReconcilableDeferredGroupedFieldSetResult]
+    reconcilable_results: dict[ReconcilableDeferredGroupedFieldSetResult, None]
     children: list[DeferredFragmentNode]
 
     def __init__(self, deferred_fragment_record: DeferredFragmentRecord) -> None:
         """Initialize the DeferredFragmentNode."""
         self.deferred_fragment_record = deferred_fragment_record
-        self.expected_reconcilable_results = 0
+        self.deferred_grouped_field_set_records = {}
         self.results = []
-        self.reconcilable_results = []
+        self.reconcilable_results = {}
         self.children = []
 
 
@@ -120,7 +121,9 @@ def add_incremental_data_records(
                     deferred_fragment_node = self._add_deferred_fragment_node(
                         deferred_fragment_record
                     )
-                    deferred_fragment_node.expected_reconcilable_results += 1
+                    deferred_fragment_node.deferred_grouped_field_set_records[
+                        incremental_data_record
+                    ] = None
 
                 deferred_result = incremental_data_record.result
                 if is_awaitable(deferred_result):
@@ -160,15 +163,17 @@ def add_completed_reconcilable_deferred_grouped_field_set(
         self, reconcilable_result: ReconcilableDeferredGroupedFieldSetResult
     ) -> None:
         """Add a completed reconcilable deferred grouped field set result."""
+        record = reconcilable_result.deferred_grouped_field_set_record
         deferred_fragment_nodes = filter(
             is_deferred_fragment_node,
             map(
                 self._deferred_fragment_nodes.get,
-                reconcilable_result.deferred_fragment_records,
+                record.deferred_fragment_records,
             ),
         )
         for deferred_fragment_node in deferred_fragment_nodes:
-            deferred_fragment_node.reconcilable_results.append(reconcilable_result)
+            del deferred_fragment_node.deferred_grouped_field_set_records[record]
+            deferred_fragment_node.reconcilable_results[reconcilable_result] = None
 
     def get_new_pending(self) -> list[SubsequentResultRecord]:
         """Get new pending subsequent result records."""
@@ -183,7 +188,7 @@ def get_new_pending(self) -> list[SubsequentResultRecord]:
             if is_stream_node(node):
                 _pending[node] = None
                 add_result(node)
-            elif node.expected_reconcilable_results:  # type: ignore
+            elif node.deferred_grouped_field_set_records:  # type: ignore
                 _pending[node] = None
                 add_result(node.deferred_fragment_record)  # type: ignore
             else:
@@ -218,17 +223,26 @@ def complete_deferred_fragment(
         deferred_fragment_record: DeferredFragmentRecord,
     ) -> list[ReconcilableDeferredGroupedFieldSetResult] | None:
         """Complete a deferred fragment."""
+        deferred_fragment_nodes = self._deferred_fragment_nodes
         try:
-            deferred_fragment_node = self._deferred_fragment_nodes[
-                deferred_fragment_record
-            ]
+            deferred_fragment_node = deferred_fragment_nodes[deferred_fragment_record]
         except KeyError:  # pragma: no cover
             return None
-        reconcilable_results = deferred_fragment_node.reconcilable_results
-        if deferred_fragment_node.expected_reconcilable_results != len(
-            reconcilable_results
-        ):
+        if deferred_fragment_node.deferred_grouped_field_set_records:
             return None
+        reconcilable_results = list(deferred_fragment_node.reconcilable_results)
+        for reconcilable_result in reconcilable_results:
+            record = reconcilable_result.deferred_grouped_field_set_record
+            for other_deferred_fragment_record in record.deferred_fragment_records:
+                try:
+                    other_deferred_fragment_node = deferred_fragment_nodes[
+                        other_deferred_fragment_record
+                    ]
+                except KeyError:  # pragma: no cover
+                    continue
+                del other_deferred_fragment_node.reconcilable_results[
+                    reconcilable_result
+                ]
         self._remove_pending(deferred_fragment_node)
         new_pending = self._new_pending
         for child in deferred_fragment_node.children:
@@ -288,11 +302,11 @@ def _enqueue_completed_deferred_grouped_field_set(
     ) -> None:
         """Enqueue completed deferred grouped field set result."""
         is_pending = False
-        for deferred_fragment_record in result.deferred_fragment_records:
+        nodes = self._deferred_fragment_nodes
+        record = result.deferred_grouped_field_set_record
+        for deferred_fragment_record in record.deferred_fragment_records:
             try:
-                deferred_fragment_node = self._deferred_fragment_nodes[
-                    deferred_fragment_record
-                ]
+                deferred_fragment_node = nodes[deferred_fragment_record]
             except KeyError:  # pragma: no cover
                 continue
             if deferred_fragment_node in self._pending:

src/graphql/execution/incremental_publisher.py

@@ -215,13 +215,12 @@ def _handle_completed_deferred_grouped_field_set(
         """Handle completed deferred grouped field set result."""
         append_completed = context.completed.append
         append_incremental = context.incremental.append
+        record = deferred_grouped_field_set_result.deferred_grouped_field_set_record
         if is_non_reconcilable_deferred_grouped_field_set_result(
             deferred_grouped_field_set_result
         ):
             remove_deferred = self._incremental_graph.remove_deferred_fragment
-            for deferred_fragment_record in (
-                deferred_grouped_field_set_result.deferred_fragment_records
-            ):  # pragma: no branch
+            for deferred_fragment_record in record.deferred_fragment_records:
                 id_ = deferred_fragment_record.id
                 if id_ is not None:  # pragma: no branch
                     append_completed(
@@ -244,20 +243,16 @@ def _handle_completed_deferred_grouped_field_set(
             self._incremental_graph.add_incremental_data_records(
                 incremental_data_records
             )
+
         complete_deferred = self._incremental_graph.complete_deferred_fragment
-        for deferred_fragment_record in (
-            deferred_grouped_field_set_result.deferred_fragment_records
-        ):  # pragma: no branch
+        for deferred_fragment_record in record.deferred_fragment_records:
             id_ = deferred_fragment_record.id
             if id_ is None:
                 continue  # pragma: no cover
             reconcilable_results = complete_deferred(deferred_fragment_record)
             if reconcilable_results is None:
                 continue
             for reconcilable_result in reconcilable_results:
-                if reconcilable_result.sent:
-                    continue
-                reconcilable_result.sent = True
                 best_id, sub_path = self._get_best_id_and_sub_path(
                     id_, deferred_fragment_record, reconcilable_result
                 )
@@ -320,9 +315,8 @@ def _get_best_id_and_sub_path(
         path = initial_deferred_fragment_record.path
         max_length = len(path.as_list()) if path else 0
         best_id = initial_id
-        for deferred_fragment_record in (
-            deferred_grouped_field_set_result.deferred_fragment_records
-        ):  # pragma: no branch
+        record = deferred_grouped_field_set_result.deferred_grouped_field_set_record
+        for deferred_fragment_record in record.deferred_fragment_records:
             if deferred_fragment_record is initial_deferred_fragment_record:
                 continue
             id_ = deferred_fragment_record.id

src/graphql/execution/types.py

@@ -704,52 +704,49 @@ def is_deferred_grouped_field_set_record(
 class ReconcilableDeferredGroupedFieldSetResult:
     """Reconcilable deferred grouped field set result"""
 
-    deferred_fragment_records: list[DeferredFragmentRecord]
+    deferred_grouped_field_set_record: DeferredGroupedFieldSetRecord
     path: list[str | int]
     result: BareDeferredGroupedFieldSetResult
     incremental_data_records: list[IncrementalDataRecord] | None
-    sent: bool
     errors: None = None
 
     __slots__ = (
-        "deferred_fragment_records",
+        "deferred_grouped_field_set_record",
         "incremental_data_records",
         "path",
         "result",
-        "sent",
     )
 
     def __init__(
         self,
-        deferred_fragment_records: list[DeferredFragmentRecord],
+        deferred_grouped_field_set_record: DeferredGroupedFieldSetRecord,
         path: list[str | int],
         result: BareDeferredGroupedFieldSetResult,
         incremental_data_records: list[IncrementalDataRecord] | None = None,
     ) -> None:
-        self.deferred_fragment_records = deferred_fragment_records
+        self.deferred_grouped_field_set_record = deferred_grouped_field_set_record
         self.path = path
         self.result = result
         self.incremental_data_records = incremental_data_records
-        self.sent = False
 
 
 class NonReconcilableDeferredGroupedFieldSetResult:
     """Non-reconcilable deferred grouped field set result"""
 
-    errors: list[GraphQLError]
-    deferred_fragment_records: list[DeferredFragmentRecord]
+    deferred_grouped_field_set_record: DeferredGroupedFieldSetRecord
     path: list[str | int]
+    errors: list[GraphQLError]
     result: None = None
 
-    __slots__ = "deferred_fragment_records", "errors", "path"
+    __slots__ = "deferred_grouped_field_set_record", "errors", "path"
 
     def __init__(
         self,
-        deferred_fragment_records: list[DeferredFragmentRecord],
+        deferred_grouped_field_set_record: DeferredGroupedFieldSetRecord,
         path: list[str | int],
         errors: list[GraphQLError],
     ) -> None:
-        self.deferred_fragment_records = deferred_fragment_records
+        self.deferred_grouped_field_set_record = deferred_grouped_field_set_record
         self.path = path
         self.errors = errors