rename DeferredGroupedFieldSets

DeferredGroupedFieldSet => PendingExecutionGroup

DeferredGroupedFieldSetResult => CompletedExecutionGroup

ReconcilableDeferredGroupedFieldSetResult => SuccessfulExecutionGroup

NonReconcilableDeferredGroupedFieldSetResult => FailedExecutionGroup

Author: yaacovCR

src/execution/IncrementalGraph.ts

@@ -7,18 +7,15 @@ import type { GraphQLError } from '../error/GraphQLError.js';
 
 import type {
   DeferredFragmentRecord,
-  DeferredGroupedFieldSetRecord,
   IncrementalDataRecord,
   IncrementalDataRecordResult,
-  ReconcilableDeferredGroupedFieldSetResult,
+  PendingExecutionGroup,
   StreamItemRecord,
   StreamRecord,
   SubsequentResultRecord,
+  SuccessfulExecutionGroup,
 } from './types.js';
-import {
-  isDeferredFragmentRecord,
-  isDeferredGroupedFieldSetRecord,
-} from './types.js';
+import { isDeferredFragmentRecord, isPendingExecutionGroup } from './types.js';
 
 /**
  * @internal
@@ -49,23 +46,25 @@ export class IncrementalGraph {
     return this._promoteNonEmptyToRoot(initialResultChildren);
   }
 
-  addCompletedReconcilableDeferredGroupedFieldSet(
-    reconcilableResult: ReconcilableDeferredGroupedFieldSetResult,
+  addCompletedReconcilableExecutionGroup(
+    successfulExecutionGroup: SuccessfulExecutionGroup,
   ): void {
-    for (const deferredFragmentRecord of reconcilableResult
-      .deferredGroupedFieldSetRecord.deferredFragmentRecords) {
-      deferredFragmentRecord.deferredGroupedFieldSetRecords.delete(
-        reconcilableResult.deferredGroupedFieldSetRecord,
+    for (const deferredFragmentRecord of successfulExecutionGroup
+      .pendingExecutionGroup.deferredFragmentRecords) {
+      deferredFragmentRecord.pendingExecutionGroups.delete(
+        successfulExecutionGroup.pendingExecutionGroup,
+      );
+      deferredFragmentRecord.successfulExecutionGroups.add(
+        successfulExecutionGroup,
       );
-      deferredFragmentRecord.reconcilableResults.add(reconcilableResult);
     }
 
-    const incrementalDataRecords = reconcilableResult.incrementalDataRecords;
+    const incrementalDataRecords =
+      successfulExecutionGroup.incrementalDataRecords;
     if (incrementalDataRecords !== undefined) {
       this._addIncrementalDataRecords(
         incrementalDataRecords,
-        reconcilableResult.deferredGroupedFieldSetRecord
-          .deferredFragmentRecords,
+        successfulExecutionGroup.pendingExecutionGroup.deferredFragmentRecords,
       );
     }
   }
@@ -105,31 +104,31 @@ export class IncrementalGraph {
   completeDeferredFragment(deferredFragmentRecord: DeferredFragmentRecord):
     | {
         newRootNodes: ReadonlyArray<SubsequentResultRecord>;
-        reconcilableResults: ReadonlyArray<ReconcilableDeferredGroupedFieldSetResult>;
+        successfulExecutionGroups: ReadonlyArray<SuccessfulExecutionGroup>;
       }
     | undefined {
     if (
       !this._rootNodes.has(deferredFragmentRecord) ||
-      deferredFragmentRecord.deferredGroupedFieldSetRecords.size > 0
+      deferredFragmentRecord.pendingExecutionGroups.size > 0
     ) {
       return;
     }
-    const reconcilableResults = Array.from(
-      deferredFragmentRecord.reconcilableResults,
+    const successfulExecutionGroups = Array.from(
+      deferredFragmentRecord.successfulExecutionGroups,
     );
     this._removeRootNode(deferredFragmentRecord);
-    for (const reconcilableResult of reconcilableResults) {
-      for (const otherDeferredFragmentRecord of reconcilableResult
-        .deferredGroupedFieldSetRecord.deferredFragmentRecords) {
-        otherDeferredFragmentRecord.reconcilableResults.delete(
-          reconcilableResult,
+    for (const successfulExecutionGroup of successfulExecutionGroups) {
+      for (const otherDeferredFragmentRecord of successfulExecutionGroup
+        .pendingExecutionGroup.deferredFragmentRecords) {
+        otherDeferredFragmentRecord.successfulExecutionGroups.delete(
+          successfulExecutionGroup,
         );
       }
     }
     const newRootNodes = this._promoteNonEmptyToRoot(
       deferredFragmentRecord.children,
     );
-    return { newRootNodes, reconcilableResults };
+    return { newRootNodes, successfulExecutionGroups };
   }
 
   removeDeferredFragment(
@@ -158,18 +157,18 @@ export class IncrementalGraph {
     initialResultChildren?: Set<SubsequentResultRecord> | undefined,
   ): void {
     for (const incrementalDataRecord of incrementalDataRecords) {
-      if (isDeferredGroupedFieldSetRecord(incrementalDataRecord)) {
+      if (isPendingExecutionGroup(incrementalDataRecord)) {
         for (const deferredFragmentRecord of incrementalDataRecord.deferredFragmentRecords) {
           this._addDeferredFragment(
             deferredFragmentRecord,
             initialResultChildren,
           );
-          deferredFragmentRecord.deferredGroupedFieldSetRecords.add(
+          deferredFragmentRecord.pendingExecutionGroups.add(
             incrementalDataRecord,
           );
         }
         if (this._completesRootNode(incrementalDataRecord)) {
-          this._onDeferredGroupedFieldSet(incrementalDataRecord);
+          this._onExecutionGroup(incrementalDataRecord);
         }
       } else if (parents === undefined) {
         invariant(initialResultChildren !== undefined);
@@ -189,10 +188,10 @@ export class IncrementalGraph {
     const newRootNodes: Array<SubsequentResultRecord> = [];
     for (const node of maybeEmptyNewRootNodes) {
       if (isDeferredFragmentRecord(node)) {
-        if (node.deferredGroupedFieldSetRecords.size > 0) {
-          for (const deferredGroupedFieldSetRecord of node.deferredGroupedFieldSetRecords) {
-            if (!this._completesRootNode(deferredGroupedFieldSetRecord)) {
-              this._onDeferredGroupedFieldSet(deferredGroupedFieldSetRecord);
+        if (node.pendingExecutionGroups.size > 0) {
+          for (const pendingExecutionGroup of node.pendingExecutionGroups) {
+            if (!this._completesRootNode(pendingExecutionGroup)) {
+              this._onExecutionGroup(pendingExecutionGroup);
             }
           }
           this._rootNodes.add(node);
@@ -214,9 +213,9 @@ export class IncrementalGraph {
   }
 
   private _completesRootNode(
-    deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord,
+    pendingExecutionGroup: PendingExecutionGroup,
   ): boolean {
-    return deferredGroupedFieldSetRecord.deferredFragmentRecords.some(
+    return pendingExecutionGroup.deferredFragmentRecords.some(
       (deferredFragmentRecord) => this._rootNodes.has(deferredFragmentRecord),
     );
   }
@@ -238,14 +237,14 @@ export class IncrementalGraph {
     this._addDeferredFragment(parent, initialResultChildren);
   }
 
-  private _onDeferredGroupedFieldSet(
-    deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord,
+  private _onExecutionGroup(
+    pendingExecutionGroup: PendingExecutionGroup,
   ): void {
-    let deferredGroupedFieldSetResult = deferredGroupedFieldSetRecord.result;
-    if (!(deferredGroupedFieldSetResult instanceof BoxedPromiseOrValue)) {
-      deferredGroupedFieldSetResult = deferredGroupedFieldSetResult();
+    let completedExecutionGroup = pendingExecutionGroup.result;
+    if (!(completedExecutionGroup instanceof BoxedPromiseOrValue)) {
+      completedExecutionGroup = completedExecutionGroup();
     }
-    const value = deferredGroupedFieldSetResult.value;
+    const value = completedExecutionGroup.value;
     if (isPromise(value)) {
       // eslint-disable-next-line @typescript-eslint/no-floating-promises
       value.then((resolved) => this._enqueue(resolved));

src/execution/IncrementalPublisher.ts

@@ -7,9 +7,9 @@ import type { GraphQLError } from '../error/GraphQLError.js';
 import { IncrementalGraph } from './IncrementalGraph.js';
 import type {
   CancellableStreamRecord,
+  CompletedExecutionGroup,
   CompletedResult,
   DeferredFragmentRecord,
-  DeferredGroupedFieldSetResult,
   ExperimentalIncrementalExecutionResults,
   IncrementalDataRecord,
   IncrementalDataRecordResult,
@@ -24,8 +24,8 @@ import type {
 } from './types.js';
 import {
   isCancellableStreamRecord,
-  isDeferredGroupedFieldSetResult,
-  isNonReconcilableDeferredGroupedFieldSetResult,
+  isCompletedExecutionGroup,
+  isFailedExecutionGroup,
 } from './types.js';
 
 export function buildIncrementalResponse(
@@ -207,27 +207,20 @@ class IncrementalPublisher {
     completedIncrementalData: IncrementalDataRecordResult,
     context: SubsequentIncrementalExecutionResultContext,
   ): void {
-    if (isDeferredGroupedFieldSetResult(completedIncrementalData)) {
-      this._handleCompletedDeferredGroupedFieldSet(
-        completedIncrementalData,
-        context,
-      );
+    if (isCompletedExecutionGroup(completedIncrementalData)) {
+      this._handleCompletedExecutionGroup(completedIncrementalData, context);
     } else {
       this._handleCompletedStreamItems(completedIncrementalData, context);
     }
   }
 
-  private _handleCompletedDeferredGroupedFieldSet(
-    deferredGroupedFieldSetResult: DeferredGroupedFieldSetResult,
+  private _handleCompletedExecutionGroup(
+    completedExecutionGroup: CompletedExecutionGroup,
     context: SubsequentIncrementalExecutionResultContext,
   ): void {
-    if (
-      isNonReconcilableDeferredGroupedFieldSetResult(
-        deferredGroupedFieldSetResult,
-      )
-    ) {
-      for (const deferredFragmentRecord of deferredGroupedFieldSetResult
-        .deferredGroupedFieldSetRecord.deferredFragmentRecords) {
+    if (isFailedExecutionGroup(completedExecutionGroup)) {
+      for (const deferredFragmentRecord of completedExecutionGroup
+        .pendingExecutionGroup.deferredFragmentRecords) {
         const id = deferredFragmentRecord.id;
         if (
           !this._incrementalGraph.removeDeferredFragment(deferredFragmentRecord)
@@ -238,18 +231,18 @@ class IncrementalPublisher {
         invariant(id !== undefined);
         context.completed.push({
           id,
-          errors: deferredGroupedFieldSetResult.errors,
+          errors: completedExecutionGroup.errors,
         });
       }
       return;
     }
 
-    this._incrementalGraph.addCompletedReconcilableDeferredGroupedFieldSet(
-      deferredGroupedFieldSetResult,
+    this._incrementalGraph.addCompletedReconcilableExecutionGroup(
+      completedExecutionGroup,
     );
 
-    for (const deferredFragmentRecord of deferredGroupedFieldSetResult
-      .deferredGroupedFieldSetRecord.deferredFragmentRecords) {
+    for (const deferredFragmentRecord of completedExecutionGroup
+      .pendingExecutionGroup.deferredFragmentRecords) {
       const completion = this._incrementalGraph.completeDeferredFragment(
         deferredFragmentRecord,
       );
@@ -259,16 +252,16 @@ class IncrementalPublisher {
       const id = deferredFragmentRecord.id;
       invariant(id !== undefined);
       const incremental = context.incremental;
-      const { newRootNodes, reconcilableResults } = completion;
+      const { newRootNodes, successfulExecutionGroups } = completion;
       context.pending.push(...this._toPendingResults(newRootNodes));
-      for (const reconcilableResult of reconcilableResults) {
+      for (const successfulExecutionGroup of successfulExecutionGroups) {
         const { bestId, subPath } = this._getBestIdAndSubPath(
           id,
           deferredFragmentRecord,
-          reconcilableResult,
+          successfulExecutionGroup,
         );
         const incrementalEntry: IncrementalDeferResult = {
-          ...reconcilableResult.result,
+          ...successfulExecutionGroup.result,
           id: bestId,
         };
         if (subPath !== undefined) {
@@ -329,13 +322,13 @@ class IncrementalPublisher {
   private _getBestIdAndSubPath(
     initialId: string,
     initialDeferredFragmentRecord: DeferredFragmentRecord,
-    deferredGroupedFieldSetResult: DeferredGroupedFieldSetResult,
+    completedExecutionGroup: CompletedExecutionGroup,
   ): { bestId: string; subPath: ReadonlyArray<string | number> | undefined } {
     let maxLength = pathToArray(initialDeferredFragmentRecord.path).length;
     let bestId = initialId;
 
-    for (const deferredFragmentRecord of deferredGroupedFieldSetResult
-      .deferredGroupedFieldSetRecord.deferredFragmentRecords) {
+    for (const deferredFragmentRecord of completedExecutionGroup
+      .pendingExecutionGroup.deferredFragmentRecords) {
       if (deferredFragmentRecord === initialDeferredFragmentRecord) {
         continue;
       }
@@ -352,7 +345,7 @@ class IncrementalPublisher {
         bestId = id;
       }
     }
-    const subPath = deferredGroupedFieldSetResult.path.slice(maxLength);
+    const subPath = completedExecutionGroup.path.slice(maxLength);
     return {
       bestId,
       subPath: subPath.length > 0 ? subPath : undefined,