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

package/cjs/execution/IncrementalGraph.js

@@ -22,15 +22,16 @@ 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() {
@@ -59,42 +60,39 @@ 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 ((0, types_js_1.isDeferredGroupedFieldSetRecord)(incrementalDataRecord)) {
+            if ((0, types_js_1.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) {
@@ -111,49 +109,50 @@ class IncrementalGraph {
     }
     _promoteNonEmptyToRoot(maybeEmptyNewPending) {
         const newPending = [];
-        for (const subsequentResultRecord of maybeEmptyNewPending) {
-            if ((0, types_js_1.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 ((0, types_js_1.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) {
-            (0, invariant_js_1.invariant)(subsequentResultRecords !== undefined);
-            subsequentResultRecords.add(deferredFragmentRecord);
+            (0, invariant_js_1.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 ((0, utils_1.isPromise)(result)) {
             result.then(resolved => this._enqueue(resolved));
         }

package/cjs/execution/IncrementalPublisher.js

@@ -147,17 +147,17 @@ class IncrementalPublisher {
         };
     }
     _handleCompletedIncrementalData(completedIncrementalData, context) {
-        if ((0, types_js_1.isDeferredGroupedFieldSetResult)(completedIncrementalData)) {
-            this._handleCompletedDeferredGroupedFieldSet(completedIncrementalData, context);
+        if ((0, types_js_1.isCompletedExecutionGroup)(completedIncrementalData)) {
+            this._handleCompletedExecutionGroup(completedIncrementalData, context);
         }
         else {
             this._handleCompletedStreamItems(completedIncrementalData, context);
         }
     }
-    _handleCompletedDeferredGroupedFieldSet(deferredGroupedFieldSetResult, context) {
-        if ((0, types_js_1.isNonReconcilableDeferredGroupedFieldSetResult)(deferredGroupedFieldSetResult)) {
-            for (const deferredFragmentRecord of deferredGroupedFieldSetResult
-                .deferredGroupedFieldSetRecord.deferredFragmentRecords) {
+    _handleCompletedExecutionGroup(completedExecutionGroup, context) {
+        if ((0, types_js_1.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.
@@ -168,7 +168,7 @@ class IncrementalPublisher {
                     const incrementalEntry = {
                         id,
                         data: null,
-                        errors: deferredGroupedFieldSetResult.errors,
+                        errors: completedExecutionGroup.errors,
                     };
                     if (this._context.sendPathAndLabelOnIncremental) {
                         const { path, label } = deferredFragmentRecord;
@@ -183,14 +183,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) {
@@ -199,12 +199,12 @@ class IncrementalPublisher {
             const id = deferredFragmentRecord.id;
             (0, invariant_js_1.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) {
@@ -289,10 +289,10 @@ class IncrementalPublisher {
             }
         }
     }
-    _getBestIdAndSubPath(initialId, initialDeferredFragmentRecord, deferredGroupedFieldSetResult) {
+    _getBestIdAndSubPath(initialId, initialDeferredFragmentRecord, completedExecutionGroup) {
         let maxLength = (0, utils_1.pathToArray)(initialDeferredFragmentRecord.path).length;
         let bestId = initialId;
-        for (const deferredFragmentRecord of deferredGroupedFieldSetResult.deferredGroupedFieldSetRecord
+        for (const deferredFragmentRecord of completedExecutionGroup.pendingExecutionGroup
             .deferredFragmentRecords) {
             if (deferredFragmentRecord === initialDeferredFragmentRecord) {
                 continue;
@@ -310,7 +310,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/cjs/execution/{buildFieldPlan.js → buildExecutionPlan.js}

@@ -1,48 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildBranchingFieldPlan = exports.buildFieldPlan = void 0;
+exports.buildBranchingExecutionPlan = exports.buildExecutionPlan = void 0;
 const AccumulatorMap_js_1 = require("./AccumulatorMap.js");
 const getBySet_js_1 = require("./getBySet.js");
 const isSameSet_js_1 = require("./isSameSet.js");
-function buildFieldPlan(originalGroupedFieldSet, parentDeferUsages = new Set()) {
+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 ((0, isSameSet_js_1.isSameSet)(deferUsageSet, parentDeferUsages)) {
+        const filteredDeferUsageSet = getFilteredDeferUsageSet(fieldGroup);
+        if ((0, isSameSet_js_1.isSameSet)(filteredDeferUsageSet, parentDeferUsages)) {
             groupedFieldSet.set(responseKey, fieldGroup);
             continue;
         }
-        let newGroupedFieldSet = (0, getBySet_js_1.getBySet)(newGroupedFieldSets, deferUsageSet);
+        let newGroupedFieldSet = (0, getBySet_js_1.getBySet)(newGroupedFieldSets, filteredDeferUsageSet);
         if (newGroupedFieldSet === undefined) {
             newGroupedFieldSet = new Map();
-            newGroupedFieldSets.set(deferUsageSet, newGroupedFieldSet);
+            newGroupedFieldSets.set(filteredDeferUsageSet, newGroupedFieldSet);
         }
         newGroupedFieldSet.set(responseKey, fieldGroup);
     }
@@ -51,17 +25,30 @@ function buildFieldPlan(originalGroupedFieldSet, parentDeferUsages = new Set())
         newGroupedFieldSets,
     };
 }
-exports.buildFieldPlan = buildFieldPlan;
-function getAncestors(deferUsage) {
-    const ancestors = [];
-    let parentDeferUsage = deferUsage.parentDeferUsage;
-    while (parentDeferUsage !== undefined) {
-        ancestors.unshift(parentDeferUsage);
-        parentDeferUsage = parentDeferUsage.parentDeferUsage;
+exports.buildExecutionPlan = buildExecutionPlan;
+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;
 }
-function buildBranchingFieldPlan(originalGroupedFieldSet, parentDeferUsages = new Set()) {
+function buildBranchingExecutionPlan(originalGroupedFieldSet, parentDeferUsages = new Set()) {
     const groupedFieldSet = new AccumulatorMap_js_1.AccumulatorMap();
     const newGroupedFieldSets = new Map();
     for (const [responseKey, fieldGroup] of originalGroupedFieldSet) {
@@ -86,4 +73,4 @@ function buildBranchingFieldPlan(originalGroupedFieldSet, parentDeferUsages = ne
         newGroupedFieldSets,
     };
 }
-exports.buildBranchingFieldPlan = buildBranchingFieldPlan;
+exports.buildBranchingExecutionPlan = buildBranchingExecutionPlan;