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

Author: yaacovCR

src/execution/IncrementalGraph.ts

@@ -3,6 +3,7 @@ import { promiseWithResolvers } from '../jsutils/promiseWithResolvers.js';
 
 import type {
   DeferredFragmentRecord,
+  DeferredGroupedFieldSetRecord,
   DeferredGroupedFieldSetResult,
   IncrementalDataRecord,
   IncrementalDataRecordResult,
@@ -14,9 +15,9 @@ import { isDeferredGroupedFieldSetRecord } from './types.js';
 
 interface DeferredFragmentNode {
   deferredFragmentRecord: DeferredFragmentRecord;
-  expectedReconcilableResults: number;
+  deferredGroupedFieldSetRecords: Set<DeferredGroupedFieldSetRecord>;
   results: Array<DeferredGroupedFieldSetResult>;
-  reconcilableResults: Array<ReconcilableDeferredGroupedFieldSetResult>;
+  reconcilableResults: Set<ReconcilableDeferredGroupedFieldSetResult>;
   children: Array<DeferredFragmentNode>;
 }
 
@@ -67,7 +68,9 @@ export class IncrementalGraph {
           const deferredFragmentNode = this._addDeferredFragmentNode(
             deferredFragmentRecord,
           );
-          deferredFragmentNode.expectedReconcilableResults++;
+          deferredFragmentNode.deferredGroupedFieldSetRecords.add(
+            incrementalDataRecord,
+          );
         }
 
         const result = incrementalDataRecord.result;
@@ -104,13 +107,16 @@ export class IncrementalGraph {
     reconcilableResult: ReconcilableDeferredGroupedFieldSetResult,
   ): void {
     const deferredFragmentNodes: Array<DeferredFragmentNode> =
-      reconcilableResult.deferredFragmentRecords
+      reconcilableResult.deferredGroupedFieldSetRecord.deferredFragmentRecords
         .map((deferredFragmentRecord) =>
           this._deferredFragmentNodes.get(deferredFragmentRecord),
         )
         .filter<DeferredFragmentNode>(isDeferredFragmentNode);
     for (const deferredFragmentNode of deferredFragmentNodes) {
-      deferredFragmentNode.reconcilableResults.push(reconcilableResult);
+      deferredFragmentNode.deferredGroupedFieldSetRecords.delete(
+        reconcilableResult.deferredGroupedFieldSetRecord,
+      );
+      deferredFragmentNode.reconcilableResults.add(reconcilableResult);
     }
   }
 
@@ -120,7 +126,7 @@ export class IncrementalGraph {
       if (isStreamNode(node)) {
         this._pending.add(node);
         newPending.push(node);
-      } else if (node.expectedReconcilableResults) {
+      } else if (node.deferredGroupedFieldSetRecords.size > 0) {
         this._pending.add(node);
         newPending.push(node.deferredFragmentRecord);
       } else {
@@ -181,13 +187,26 @@ export class IncrementalGraph {
     if (deferredFragmentNode === undefined) {
       return undefined;
     }
-    const reconcilableResults = deferredFragmentNode.reconcilableResults;
-    if (
-      deferredFragmentNode.expectedReconcilableResults !==
-      reconcilableResults.length
-    ) {
+    if (deferredFragmentNode.deferredGroupedFieldSetRecords.size > 0) {
       return;
     }
+    const reconcilableResults = Array.from(
+      deferredFragmentNode.reconcilableResults,
+    );
+    for (const reconcilableResult of reconcilableResults) {
+      for (const otherDeferredFragmentRecord of reconcilableResult
+        .deferredGroupedFieldSetRecord.deferredFragmentRecords) {
+        const otherDeferredFragmentNode = this._deferredFragmentNodes.get(
+          otherDeferredFragmentRecord,
+        );
+        if (otherDeferredFragmentNode === undefined) {
+          continue;
+        }
+        otherDeferredFragmentNode.reconcilableResults.delete(
+          reconcilableResult,
+        );
+      }
+    }
     this._removePending(deferredFragmentNode);
     for (const child of deferredFragmentNode.children) {
       this._newPending.add(child);
@@ -240,9 +259,9 @@ export class IncrementalGraph {
     }
     deferredFragmentNode = {
       deferredFragmentRecord,
-      expectedReconcilableResults: 0,
+      deferredGroupedFieldSetRecords: new Set(),
       results: [],
-      reconcilableResults: [],
+      reconcilableResults: new Set(),
       children: [],
     };
     this._deferredFragmentNodes.set(
@@ -263,7 +282,8 @@ export class IncrementalGraph {
     result: DeferredGroupedFieldSetResult,
   ): void {
     let isPending = false;
-    for (const deferredFragmentRecord of result.deferredFragmentRecords) {
+    for (const deferredFragmentRecord of result.deferredGroupedFieldSetRecord
+      .deferredFragmentRecords) {
       const deferredFragmentNode = this._deferredFragmentNodes.get(
         deferredFragmentRecord,
       );

src/execution/IncrementalPublisher.ts

@@ -230,7 +230,8 @@ class IncrementalPublisher {
         deferredGroupedFieldSetResult,
       )
     ) {
-      for (const deferredFragmentRecord of deferredGroupedFieldSetResult.deferredFragmentRecords) {
+      for (const deferredFragmentRecord of deferredGroupedFieldSetResult
+        .deferredGroupedFieldSetRecord.deferredFragmentRecords) {
         const id = deferredFragmentRecord.id;
         if (id !== undefined) {
           context.completed.push({
@@ -253,7 +254,8 @@ class IncrementalPublisher {
       this._incrementalGraph.addIncrementalDataRecords(incrementalDataRecords);
     }
 
-    for (const deferredFragmentRecord of deferredGroupedFieldSetResult.deferredFragmentRecords) {
+    for (const deferredFragmentRecord of deferredGroupedFieldSetResult
+      .deferredGroupedFieldSetRecord.deferredFragmentRecords) {
       const id = deferredFragmentRecord.id;
       // TODO: add test case for this.
       // Presumably, this can occur if an error causes a fragment to be completed early,
@@ -269,10 +271,6 @@ class IncrementalPublisher {
       }
       const incremental = context.incremental;
       for (const reconcilableResult of reconcilableResults) {
-        if (reconcilableResult.sent) {
-          continue;
-        }
-        reconcilableResult.sent = true;
         const { bestId, subPath } = this._getBestIdAndSubPath(
           id,
           deferredFragmentRecord,
@@ -343,7 +341,8 @@ class IncrementalPublisher {
     let maxLength = pathToArray(initialDeferredFragmentRecord.path).length;
     let bestId = initialId;
 
-    for (const deferredFragmentRecord of deferredGroupedFieldSetResult.deferredFragmentRecords) {
+    for (const deferredFragmentRecord of deferredGroupedFieldSetResult
+      .deferredGroupedFieldSetRecord.deferredFragmentRecords) {
       if (deferredFragmentRecord === initialDeferredFragmentRecord) {
         continue;
       }

src/execution/execute.ts

@@ -2089,9 +2089,14 @@ function executeDeferredGroupedFieldSets(
       deferMap,
     );
 
+    const deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord = {
+      deferredFragmentRecords,
+      result: undefined as unknown as DeferredGroupedFieldSetResult,
+    };
+
     const executor = () =>
       executeDeferredGroupedFieldSet(
-        deferredFragmentRecords,
+        deferredGroupedFieldSetRecord,
         exeContext,
         parentType,
         sourceValue,
@@ -2104,12 +2109,12 @@ function executeDeferredGroupedFieldSets(
         deferMap,
       );
 
-    const deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord = {
-      deferredFragmentRecords,
-      result: shouldDefer(parentDeferUsages, deferUsageSet)
-        ? Promise.resolve().then(executor)
-        : executor(),
-    };
+    deferredGroupedFieldSetRecord.result = shouldDefer(
+      parentDeferUsages,
+      deferUsageSet,
+    )
+      ? Promise.resolve().then(executor)
+      : executor();
 
     newDeferredGroupedFieldSetRecords.push(deferredGroupedFieldSetRecord);
   }
@@ -2134,7 +2139,7 @@ function shouldDefer(
 }
 
 function executeDeferredGroupedFieldSet(
-  deferredFragmentRecords: ReadonlyArray<DeferredFragmentRecord>,
+  deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord,
   exeContext: ExecutionContext,
   parentType: GraphQLObjectType,
   sourceValue: unknown,
@@ -2156,7 +2161,7 @@ function executeDeferredGroupedFieldSet(
     );
   } catch (error) {
     return {
-      deferredFragmentRecords,
+      deferredGroupedFieldSetRecord,
       path: pathToArray(path),
       errors: withError(incrementalContext.errors, error),
     };
@@ -2167,12 +2172,12 @@ function executeDeferredGroupedFieldSet(
       (resolved) =>
         buildDeferredGroupedFieldSetResult(
           incrementalContext.errors,
-          deferredFragmentRecords,
+          deferredGroupedFieldSetRecord,
           path,
           resolved,
         ),
       (error) => ({
-        deferredFragmentRecords,
+        deferredGroupedFieldSetRecord,
         path: pathToArray(path),
         errors: withError(incrementalContext.errors, error),
       }),
@@ -2181,20 +2186,20 @@ function executeDeferredGroupedFieldSet(
 
   return buildDeferredGroupedFieldSetResult(
     incrementalContext.errors,
-    deferredFragmentRecords,
+    deferredGroupedFieldSetRecord,
     path,
     result,
   );
 }
 
 function buildDeferredGroupedFieldSetResult(
   errors: ReadonlyArray<GraphQLError> | undefined,
-  deferredFragmentRecords: ReadonlyArray<DeferredFragmentRecord>,
+  deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord,
   path: Path | undefined,
   result: GraphQLWrappedResult<ObjMap<unknown>>,
 ): DeferredGroupedFieldSetResult {
   return {
-    deferredFragmentRecords,
+    deferredGroupedFieldSetRecord,
     path: pathToArray(path),
     result:
       errors === undefined ? { data: result[0] } : { data: result[0], errors },

src/execution/types.ts

@@ -179,22 +179,21 @@ export type DeferredGroupedFieldSetResult =
 export function isDeferredGroupedFieldSetResult(
   subsequentResult: DeferredGroupedFieldSetResult | StreamItemsResult,
 ): subsequentResult is DeferredGroupedFieldSetResult {
-  return 'deferredFragmentRecords' in subsequentResult;
+  return 'deferredGroupedFieldSetRecord' in subsequentResult;
 }
 
 export interface ReconcilableDeferredGroupedFieldSetResult {
-  deferredFragmentRecords: ReadonlyArray<DeferredFragmentRecord>;
+  deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord;
   path: Array<string | number>;
   result: BareDeferredGroupedFieldSetResult;
   incrementalDataRecords: ReadonlyArray<IncrementalDataRecord> | undefined;
-  sent?: true | undefined;
   errors?: never;
 }
 
 interface NonReconcilableDeferredGroupedFieldSetResult {
-  errors: ReadonlyArray<GraphQLError>;
-  deferredFragmentRecords: ReadonlyArray<DeferredFragmentRecord>;
+  deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord;
   path: Array<string | number>;
+  errors: ReadonlyArray<GraphQLError>;
   result?: never;
 }