@graphql-tools/executor 2.0.0-alpha-20240709212042-9a70c086fa543c594055305622a600bb95343b42 → 2.0.0-alpha-20240804112853-812acba5ea59541106a53f872874fd7aebcffcfc

package/esm/execution/IncrementalGraph.js

@@ -1,7 +1,7 @@
 import { createDeferred, isPromise } from '@graphql-tools/utils';
 import { BoxedPromiseOrValue } from './BoxedPromiseOrValue.js';
 import { invariant } from './invariant.js';
-import { isDeferredFragmentRecord, isDeferredGroupedFieldSetRecord } from './types.js';
+import { isDeferredFragmentRecord, isPendingExecutionGroup } from './types.js';
 /**
  * @internal
  */
@@ -19,15 +19,16 @@ export class IncrementalGraph {
         this._addIncrementalDataRecords(incrementalDataRecords, undefined, initialResultChildren);
         return this._promoteNonEmptyToRoot(initialResultChildren);
     }
-    addCompletedReconcilableDeferredGroupedFieldSet(reconcilableResult) {
-        for (const deferredFragmentRecord of reconcilableResult.deferredGroupedFieldSetRecord
-            .deferredFragmentRecords) {
-            deferredFragmentRecord.deferredGroupedFieldSetRecords.delete(reconcilableResult.deferredGroupedFieldSetRecord);
-            deferredFragmentRecord.reconcilableResults.add(reconcilableResult);
+    addCompletedSuccessfulExecutionGroup(successfulExecutionGroup) {
+        const { pendingExecutionGroup, incrementalDataRecords } = successfulExecutionGroup;
+        const deferredFragmentRecords = pendingExecutionGroup.deferredFragmentRecords;
+        for (const deferredFragmentRecord of deferredFragmentRecords) {
+            const { pendingExecutionGroups, successfulExecutionGroups } = deferredFragmentRecord;
+            pendingExecutionGroups.delete(successfulExecutionGroup.pendingExecutionGroup);
+            successfulExecutionGroups.add(successfulExecutionGroup);
         }
-        const incrementalDataRecords = reconcilableResult.incrementalDataRecords;
         if (incrementalDataRecords !== undefined) {
-            this._addIncrementalDataRecords(incrementalDataRecords, reconcilableResult.deferredGroupedFieldSetRecord.deferredFragmentRecords);
+            this._addIncrementalDataRecords(incrementalDataRecords, deferredFragmentRecords);
         }
     }
     *currentCompletedBatch() {
@@ -56,42 +57,39 @@ export class IncrementalGraph {
     }
     completeDeferredFragment(deferredFragmentRecord) {
         if (!this._rootNodes.has(deferredFragmentRecord) ||
-            deferredFragmentRecord.deferredGroupedFieldSetRecords.size > 0) {
+            deferredFragmentRecord.pendingExecutionGroups.size > 0) {
             return;
         }
-        const reconcilableResults = Array.from(deferredFragmentRecord.reconcilableResults);
-        this._removePending(deferredFragmentRecord);
-        for (const reconcilableResult of reconcilableResults) {
-            for (const otherDeferredFragmentRecord of reconcilableResult.deferredGroupedFieldSetRecord
+        const successfulExecutionGroups = Array.from(deferredFragmentRecord.successfulExecutionGroups);
+        this._rootNodes.delete(deferredFragmentRecord);
+        for (const successfulExecutionGroup of successfulExecutionGroups) {
+            for (const otherDeferredFragmentRecord of successfulExecutionGroup.pendingExecutionGroup
                 .deferredFragmentRecords) {
-                otherDeferredFragmentRecord.reconcilableResults.delete(reconcilableResult);
+                otherDeferredFragmentRecord.successfulExecutionGroups.delete(successfulExecutionGroup);
             }
         }
         const newPending = this._promoteNonEmptyToRoot(deferredFragmentRecord.children);
-        return { newPending, reconcilableResults };
+        return { newPending, successfulExecutionGroups };
     }
     removeDeferredFragment(deferredFragmentRecord) {
         if (!this._rootNodes.has(deferredFragmentRecord)) {
             return false;
         }
-        this._removePending(deferredFragmentRecord);
+        this._rootNodes.delete(deferredFragmentRecord);
         return true;
     }
     removeStream(streamRecord) {
-        this._removePending(streamRecord);
-    }
-    _removePending(subsequentResultRecord) {
-        this._rootNodes.delete(subsequentResultRecord);
+        this._rootNodes.delete(streamRecord);
     }
     _addIncrementalDataRecords(incrementalDataRecords, parents, initialResultChildren) {
         for (const incrementalDataRecord of incrementalDataRecords) {
-            if (isDeferredGroupedFieldSetRecord(incrementalDataRecord)) {
+            if (isPendingExecutionGroup(incrementalDataRecord)) {
                 for (const deferredFragmentRecord of incrementalDataRecord.deferredFragmentRecords) {
                     this._addDeferredFragment(deferredFragmentRecord, initialResultChildren);
-                    deferredFragmentRecord.deferredGroupedFieldSetRecords.add(incrementalDataRecord);
+                    deferredFragmentRecord.pendingExecutionGroups.add(incrementalDataRecord);
                 }
                 if (this._hasPendingFragment(incrementalDataRecord)) {
-                    this._onDeferredGroupedFieldSet(incrementalDataRecord);
+                    this._onExecutionGroup(incrementalDataRecord);
                 }
             }
             else if (parents === undefined) {
@@ -108,49 +106,50 @@ export class IncrementalGraph {
     }
     _promoteNonEmptyToRoot(maybeEmptyNewPending) {
         const newPending = [];
-        for (const subsequentResultRecord of maybeEmptyNewPending) {
-            if (isDeferredFragmentRecord(subsequentResultRecord)) {
-                if (subsequentResultRecord.deferredGroupedFieldSetRecords.size > 0) {
-                    subsequentResultRecord.setAsPending();
-                    for (const deferredGroupedFieldSetRecord of subsequentResultRecord.deferredGroupedFieldSetRecords) {
-                        if (!this._hasPendingFragment(deferredGroupedFieldSetRecord)) {
-                            this._onDeferredGroupedFieldSet(deferredGroupedFieldSetRecord);
+        for (const deliveryGroup of maybeEmptyNewPending) {
+            if (isDeferredFragmentRecord(deliveryGroup)) {
+                if (deliveryGroup.pendingExecutionGroups.size > 0) {
+                    deliveryGroup.setAsPending();
+                    for (const pendingExecutionGroup of deliveryGroup.pendingExecutionGroups) {
+                        if (!this._hasPendingFragment(pendingExecutionGroup)) {
+                            this._onExecutionGroup(pendingExecutionGroup);
                         }
                     }
-                    this._rootNodes.add(subsequentResultRecord);
-                    newPending.push(subsequentResultRecord);
+                    this._rootNodes.add(deliveryGroup);
+                    newPending.push(deliveryGroup);
                     continue;
                 }
-                for (const child of subsequentResultRecord.children) {
+                for (const child of deliveryGroup.children) {
                     maybeEmptyNewPending.add(child);
                 }
             }
             else {
-                this._rootNodes.add(subsequentResultRecord);
-                newPending.push(subsequentResultRecord);
-                this._onStreamItems(subsequentResultRecord);
+                this._rootNodes.add(deliveryGroup);
+                newPending.push(deliveryGroup);
+                this._onStreamItems(deliveryGroup);
             }
         }
         return newPending;
     }
-    _hasPendingFragment(deferredGroupedFieldSetRecord) {
-        return deferredGroupedFieldSetRecord.deferredFragmentRecords.some(deferredFragmentRecord => this._rootNodes.has(deferredFragmentRecord));
+    _hasPendingFragment(pendingExecutionGroup) {
+        return pendingExecutionGroup.deferredFragmentRecords.some(deferredFragmentRecord => this._rootNodes.has(deferredFragmentRecord));
     }
-    _addDeferredFragment(deferredFragmentRecord, subsequentResultRecords) {
+    _addDeferredFragment(deferredFragmentRecord, deliveryGroups) {
         if (this._rootNodes.has(deferredFragmentRecord)) {
             return;
         }
         const parent = deferredFragmentRecord.parent;
         if (parent === undefined) {
-            invariant(subsequentResultRecords !== undefined);
-            subsequentResultRecords.add(deferredFragmentRecord);
+            invariant(deliveryGroups !== undefined);
+            deliveryGroups.add(deferredFragmentRecord);
             return;
         }
         parent.children.add(deferredFragmentRecord);
-        this._addDeferredFragment(parent, subsequentResultRecords);
+        this._addDeferredFragment(parent, deliveryGroups);
     }
-    _onDeferredGroupedFieldSet(deferredGroupedFieldSetRecord) {
-        const result = deferredGroupedFieldSetRecord.result.value;
+    _onExecutionGroup(pendingExecutionGroup) {
+        const result = pendingExecutionGroup.result
+            .value;
         if (isPromise(result)) {
             result.then(resolved => this._enqueue(resolved));
         }

package/esm/execution/IncrementalPublisher.js

@@ -1,7 +1,7 @@
 import { addPath, pathToArray } from '@graphql-tools/utils';
 import { IncrementalGraph } from './IncrementalGraph.js';
 import { invariant } from './invariant.js';
-import { isCancellableStreamRecord, isDeferredGroupedFieldSetResult, isNonReconcilableDeferredGroupedFieldSetResult, } from './types.js';
+import { isCancellableStreamRecord, isCompletedExecutionGroup, isFailedExecutionGroup, } from './types.js';
 export function buildIncrementalResponse(context, result, errors, incrementalDataRecords) {
     const incrementalPublisher = new IncrementalPublisher(context);
     return incrementalPublisher.buildResponse(result, errors, incrementalDataRecords);
@@ -143,17 +143,17 @@ class IncrementalPublisher {
         };
     }
     _handleCompletedIncrementalData(completedIncrementalData, context) {
-        if (isDeferredGroupedFieldSetResult(completedIncrementalData)) {
-            this._handleCompletedDeferredGroupedFieldSet(completedIncrementalData, context);
+        if (isCompletedExecutionGroup(completedIncrementalData)) {
+            this._handleCompletedExecutionGroup(completedIncrementalData, context);
         }
         else {
             this._handleCompletedStreamItems(completedIncrementalData, context);
         }
     }
-    _handleCompletedDeferredGroupedFieldSet(deferredGroupedFieldSetResult, context) {
-        if (isNonReconcilableDeferredGroupedFieldSetResult(deferredGroupedFieldSetResult)) {
-            for (const deferredFragmentRecord of deferredGroupedFieldSetResult
-                .deferredGroupedFieldSetRecord.deferredFragmentRecords) {
+    _handleCompletedExecutionGroup(completedExecutionGroup, context) {
+        if (isFailedExecutionGroup(completedExecutionGroup)) {
+            for (const deferredFragmentRecord of completedExecutionGroup.pendingExecutionGroup
+                .deferredFragmentRecords) {
                 const id = deferredFragmentRecord.id;
                 if (!this._incrementalGraph.removeDeferredFragment(deferredFragmentRecord)) {
                     // This can occur if multiple deferred grouped field sets error for a fragment.
@@ -164,7 +164,7 @@ class IncrementalPublisher {
                     const incrementalEntry = {
                         id,
                         data: null,
-                        errors: deferredGroupedFieldSetResult.errors,
+                        errors: completedExecutionGroup.errors,
                     };
                     if (this._context.sendPathAndLabelOnIncremental) {
                         const { path, label } = deferredFragmentRecord;
@@ -179,14 +179,14 @@ class IncrementalPublisher {
                 else {
                     context.completed.push({
                         id,
-                        errors: deferredGroupedFieldSetResult.errors,
+                        errors: completedExecutionGroup.errors,
                     });
                 }
             }
             return;
         }
-        this._incrementalGraph.addCompletedReconcilableDeferredGroupedFieldSet(deferredGroupedFieldSetResult);
-        for (const deferredFragmentRecord of deferredGroupedFieldSetResult.deferredGroupedFieldSetRecord
+        this._incrementalGraph.addCompletedSuccessfulExecutionGroup(completedExecutionGroup);
+        for (const deferredFragmentRecord of completedExecutionGroup.pendingExecutionGroup
             .deferredFragmentRecords) {
             const completion = this._incrementalGraph.completeDeferredFragment(deferredFragmentRecord);
             if (completion === undefined) {
@@ -195,12 +195,12 @@ class IncrementalPublisher {
             const id = deferredFragmentRecord.id;
             invariant(id !== undefined);
             const incremental = context.incremental;
-            const { newPending, reconcilableResults } = completion;
+            const { newPending, successfulExecutionGroups } = completion;
             context.pending.push(...this._pendingSourcesToResults(newPending));
-            for (const reconcilableResult of reconcilableResults) {
-                const { bestId, subPath } = this._getBestIdAndSubPath(id, deferredFragmentRecord, reconcilableResult);
+            for (const successfulExecutionGroup of successfulExecutionGroups) {
+                const { bestId, subPath } = this._getBestIdAndSubPath(id, deferredFragmentRecord, successfulExecutionGroup);
                 const incrementalEntry = {
-                    ...reconcilableResult.result,
+                    ...successfulExecutionGroup.result,
                     id: bestId,
                 };
                 if (this._context.sendPathAndLabelOnIncremental) {
@@ -285,10 +285,10 @@ class IncrementalPublisher {
             }
         }
     }
-    _getBestIdAndSubPath(initialId, initialDeferredFragmentRecord, deferredGroupedFieldSetResult) {
+    _getBestIdAndSubPath(initialId, initialDeferredFragmentRecord, completedExecutionGroup) {
         let maxLength = pathToArray(initialDeferredFragmentRecord.path).length;
         let bestId = initialId;
-        for (const deferredFragmentRecord of deferredGroupedFieldSetResult.deferredGroupedFieldSetRecord
+        for (const deferredFragmentRecord of completedExecutionGroup.pendingExecutionGroup
             .deferredFragmentRecords) {
             if (deferredFragmentRecord === initialDeferredFragmentRecord) {
                 continue;
@@ -306,7 +306,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,

package/esm/execution/{buildFieldPlan.js → buildExecutionPlan.js}

@@ -1,45 +1,19 @@
 import { AccumulatorMap } from './AccumulatorMap.js';
 import { getBySet } from './getBySet.js';
 import { isSameSet } from './isSameSet.js';
-export function buildFieldPlan(originalGroupedFieldSet, parentDeferUsages = new Set()) {
+export function buildExecutionPlan(originalGroupedFieldSet, parentDeferUsages = new Set()) {
     const groupedFieldSet = new Map();
     const newGroupedFieldSets = new Map();
-    const map = new Map();
     for (const [responseKey, fieldGroup] of originalGroupedFieldSet) {
-        const deferUsageSet = new Set();
-        let inOriginalResult = false;
-        for (const fieldDetails of fieldGroup) {
-            const deferUsage = fieldDetails.deferUsage;
-            if (deferUsage === undefined) {
-                inOriginalResult = true;
-                continue;
-            }
-            deferUsageSet.add(deferUsage);
-        }
-        if (inOriginalResult) {
-            deferUsageSet.clear();
-        }
-        else {
-            deferUsageSet.forEach(deferUsage => {
-                const ancestors = getAncestors(deferUsage);
-                for (const ancestor of ancestors) {
-                    if (deferUsageSet.has(ancestor)) {
-                        deferUsageSet.delete(deferUsage);
-                    }
-                }
-            });
-        }
-        map.set(responseKey, { deferUsageSet, fieldGroup });
-    }
-    for (const [responseKey, { deferUsageSet, fieldGroup }] of map) {
-        if (isSameSet(deferUsageSet, parentDeferUsages)) {
+        const filteredDeferUsageSet = getFilteredDeferUsageSet(fieldGroup);
+        if (isSameSet(filteredDeferUsageSet, parentDeferUsages)) {
             groupedFieldSet.set(responseKey, fieldGroup);
             continue;
         }
-        let newGroupedFieldSet = getBySet(newGroupedFieldSets, deferUsageSet);
+        let newGroupedFieldSet = getBySet(newGroupedFieldSets, filteredDeferUsageSet);
         if (newGroupedFieldSet === undefined) {
             newGroupedFieldSet = new Map();
-            newGroupedFieldSets.set(deferUsageSet, newGroupedFieldSet);
+            newGroupedFieldSets.set(filteredDeferUsageSet, newGroupedFieldSet);
         }
         newGroupedFieldSet.set(responseKey, fieldGroup);
     }
@@ -48,16 +22,29 @@ export function buildFieldPlan(originalGroupedFieldSet, parentDeferUsages = new
         newGroupedFieldSets,
     };
 }
-function getAncestors(deferUsage) {
-    const ancestors = [];
-    let parentDeferUsage = deferUsage.parentDeferUsage;
-    while (parentDeferUsage !== undefined) {
-        ancestors.unshift(parentDeferUsage);
-        parentDeferUsage = parentDeferUsage.parentDeferUsage;
+function getFilteredDeferUsageSet(fieldGroup) {
+    const filteredDeferUsageSet = new Set();
+    for (const fieldDetails of fieldGroup) {
+        const deferUsage = fieldDetails.deferUsage;
+        if (deferUsage === undefined) {
+            filteredDeferUsageSet.clear();
+            return filteredDeferUsageSet;
+        }
+        filteredDeferUsageSet.add(deferUsage);
+    }
+    for (const deferUsage of filteredDeferUsageSet) {
+        let parentDeferUsage = deferUsage.parentDeferUsage;
+        while (parentDeferUsage !== undefined) {
+            if (filteredDeferUsageSet.has(parentDeferUsage)) {
+                filteredDeferUsageSet.delete(deferUsage);
+                break;
+            }
+            parentDeferUsage = parentDeferUsage.parentDeferUsage;
+        }
     }
-    return ancestors;
+    return filteredDeferUsageSet;
 }
-export function buildBranchingFieldPlan(originalGroupedFieldSet, parentDeferUsages = new Set()) {
+export function buildBranchingExecutionPlan(originalGroupedFieldSet, parentDeferUsages = new Set()) {
     const groupedFieldSet = new AccumulatorMap();
     const newGroupedFieldSets = new Map();
     for (const [responseKey, fieldGroup] of originalGroupedFieldSet) {