@graphql-tools/executor - npm Package Compare versions

Comparing version 2.0.0-alpha-20240709213044-006da37e240c6ccb1d305e19ade18dd70384cb22 to 2.0.0-alpha-20240804112853-812acba5ea59541106a53f872874fd7aebcffcfc

cjs/execution/IncrementalGraph.js

@@ -25,11 +25,12 @@ "use strict";
     }
-    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);
         }
@@ -63,15 +64,15 @@ }
         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 };
     }
@@ -82,20 +83,17 @@ removeDeferredFragment(deferredFragmentRecord) {
         }
-        this._removePending(deferredFragmentRecord);
+        this._rootNodes.delete(deferredFragmentRecord);
         return true;
     }
     removeStream(streamRecord) {
-        this._removePending(streamRecord);
+        this._rootNodes.delete(streamRecord);
     }
-    _removePending(subsequentResultRecord) {
-        this._rootNodes.delete(subsequentResultRecord);
-    }
     _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);
                 }
@@ -117,16 +115,16 @@ }
         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);
@@ -136,5 +134,5 @@ }
             else {
-                this._rootNodes.add(subsequentResultRecord);
-                newPending.push(subsequentResultRecord);
-                this._onStreamItems(subsequentResultRecord);
+                this._rootNodes.add(deliveryGroup);
+                newPending.push(deliveryGroup);
+                this._onStreamItems(deliveryGroup);
             }
@@ -144,6 +142,6 @@ }
     }
-    _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)) {
@@ -154,11 +152,12 @@ return;
         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)) {
@@ -165,0 +164,0 @@ result.then(resolved => this._enqueue(resolved));

cjs/execution/IncrementalPublisher.js

@@ -150,4 +150,4 @@ "use strict";
     _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);
         }
@@ -158,6 +158,6 @@ else {
     }
-    _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;
@@ -173,3 +173,3 @@ if (!this._incrementalGraph.removeDeferredFragment(deferredFragmentRecord)) {
                         data: null,
-                        errors: deferredGroupedFieldSetResult.errors,
+                        errors: completedExecutionGroup.errors,
                     };
@@ -189,3 +189,3 @@ if (this._context.sendPathAndLabelOnIncremental) {
                         id,
-                        errors: deferredGroupedFieldSetResult.errors,
+                        errors: completedExecutionGroup.errors,
                     });
@@ -196,4 +196,4 @@ }
         }
-        this._incrementalGraph.addCompletedReconcilableDeferredGroupedFieldSet(deferredGroupedFieldSetResult);
-        for (const deferredFragmentRecord of deferredGroupedFieldSetResult.deferredGroupedFieldSetRecord
+        this._incrementalGraph.addCompletedSuccessfulExecutionGroup(completedExecutionGroup);
+        for (const deferredFragmentRecord of completedExecutionGroup.pendingExecutionGroup
             .deferredFragmentRecords) {
@@ -207,8 +207,8 @@ const completion = this._incrementalGraph.completeDeferredFragment(deferredFragmentRecord);
             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,
@@ -298,6 +298,6 @@ };
     }
-    _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) {
@@ -320,3 +320,3 @@ if (deferredFragmentRecord === initialDeferredFragmentRecord) {
         }
-        const subPath = deferredGroupedFieldSetResult.path.slice(maxLength);
+        const subPath = completedExecutionGroup.path.slice(maxLength);
         return {
@@ -323,0 +323,0 @@ bestId,

cjs/execution/types.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCancellableStreamRecord = exports.isDeferredFragmentRecord = exports.DeferredFragmentRecord = exports.isNonReconcilableDeferredGroupedFieldSetResult = exports.isDeferredGroupedFieldSetResult = exports.isDeferredGroupedFieldSetRecord = void 0;
-function isDeferredGroupedFieldSetRecord(incrementalDataRecord) {
+exports.isCancellableStreamRecord = exports.isDeferredFragmentRecord = exports.DeferredFragmentRecord = exports.isFailedExecutionGroup = exports.isCompletedExecutionGroup = exports.isPendingExecutionGroup = void 0;
+function isPendingExecutionGroup(incrementalDataRecord) {
     return 'deferredFragmentRecords' in incrementalDataRecord;
 }
-exports.isDeferredGroupedFieldSetRecord = isDeferredGroupedFieldSetRecord;
-function isDeferredGroupedFieldSetResult(subsequentResult) {
-    return 'deferredGroupedFieldSetRecord' in subsequentResult;
+exports.isPendingExecutionGroup = isPendingExecutionGroup;
+function isCompletedExecutionGroup(incrementalDataRecordResult) {
+    return 'pendingExecutionGroup' in incrementalDataRecordResult;
 }
-exports.isDeferredGroupedFieldSetResult = isDeferredGroupedFieldSetResult;
-function isNonReconcilableDeferredGroupedFieldSetResult(deferredGroupedFieldSetResult) {
-    return deferredGroupedFieldSetResult.errors !== undefined;
+exports.isCompletedExecutionGroup = isCompletedExecutionGroup;
+function isFailedExecutionGroup(completedExecutionGroup) {
+    return completedExecutionGroup.errors !== undefined;
 }
-exports.isNonReconcilableDeferredGroupedFieldSetResult = isNonReconcilableDeferredGroupedFieldSetResult;
+exports.isFailedExecutionGroup = isFailedExecutionGroup;
 /** @internal */
@@ -22,4 +22,4 @@ class DeferredFragmentRecord {
     parent;
-    deferredGroupedFieldSetRecords;
-    reconcilableResults;
+    pendingExecutionGroups;
+    successfulExecutionGroups;
     children;
@@ -32,4 +32,4 @@ pending;
         this.parent = parent;
-        this.deferredGroupedFieldSetRecords = new Set();
-        this.reconcilableResults = new Set();
+        this.pendingExecutionGroups = new Set();
+        this.successfulExecutionGroups = new Set();
         this.children = new Set();
@@ -50,9 +50,9 @@ this.pending = false;
 exports.DeferredFragmentRecord = DeferredFragmentRecord;
-function isDeferredFragmentRecord(subsequentResultRecord) {
-    return subsequentResultRecord instanceof DeferredFragmentRecord;
+function isDeferredFragmentRecord(deliveryGroup) {
+    return deliveryGroup instanceof DeferredFragmentRecord;
 }
 exports.isDeferredFragmentRecord = isDeferredFragmentRecord;
-function isCancellableStreamRecord(subsequentResultRecord) {
-    return 'earlyReturn' in subsequentResultRecord;
+function isCancellableStreamRecord(deliveryGroup) {
+    return 'earlyReturn' in deliveryGroup;
 }
 exports.isCancellableStreamRecord = isCancellableStreamRecord;

esm/execution/execute.js

 import { assertValidSchema, getDirectiveValues, GraphQLError, isAbstractType, isLeafType, isListType, isNonNullType, isObjectType, Kind, locatedError, SchemaMetaFieldDef, TypeMetaFieldDef, TypeNameMetaFieldDef, versionInfo, } from 'graphql';
 import { addPath, createGraphQLError, getArgumentValues, getDefinedRootType, GraphQLStreamDirective, inspect, isAsyncIterable, isIterableObject, isObjectLike, isPromise, mapAsyncIterator, memoize1, memoize3, pathToArray, promiseReduce, } from '@graphql-tools/utils';
+import { AccumulatorMap } from './AccumulatorMap.js';
 import { BoxedPromiseOrValue } from './BoxedPromiseOrValue.js';
-import { buildBranchingFieldPlan, buildFieldPlan, } from './buildFieldPlan.js';
+import { buildBranchingExecutionPlan, buildExecutionPlan, } from './buildExecutionPlan.js';
 import { coerceError } from './coerceError.js';
@@ -83,6 +84,6 @@ import { collectSubfields as _collectSubfields, collectFields, } from './collectFields.js';
     }
-    return buildIncrementalResponse(exeContext, data, Array.from(errors.values()), filteredIncrementalDataRecords);
+    return buildIncrementalResponse(exeContext, data, flattenErrors(errors), filteredIncrementalDataRecords);
 }
 function buildSingleResult(data, errors) {
-    return errors !== undefined ? { errors: Array.from(errors.values()), data } : { data };
+    return errors !== undefined ? { errors: Array.from(errors.values()).flat(), data } : { data };
 }
@@ -116,2 +117,6 @@ function filterIncrementalDataRecords(initialPath, errors, incrementalDataRecords) {
 }
+function flattenErrors(errors) {
+    const errorsByPath = [...errors.values()];
+    return errorsByPath.flat();
+}
 /**
@@ -239,12 +244,12 @@ * Essential assertions before executing to provide developer feedback for
         else {
-            const fieldPLan = deduplicateDefers
-                ? buildFieldPlan(groupedFieldSet)
-                : buildBranchingFieldPlan(groupedFieldSet);
-            groupedFieldSet = fieldPLan.groupedFieldSet;
-            const newGroupedFieldSets = fieldPLan.newGroupedFieldSets;
+            const executionPlan = deduplicateDefers
+                ? buildExecutionPlan(groupedFieldSet)
+                : buildBranchingExecutionPlan(groupedFieldSet);
+            groupedFieldSet = executionPlan.groupedFieldSet;
+            const newGroupedFieldSets = executionPlan.newGroupedFieldSets;
             const newDeferMap = addNewDeferredFragments(newDeferUsages, new Map());
             data = executeRootGroupedFieldSet(exeContext, operation.operation, rootType, rootValue, groupedFieldSet, newDeferMap);
             if (newGroupedFieldSets.size > 0) {
-                const newDeferredGroupedFieldSetRecords = executeDeferredGroupedFieldSets(exeContext, rootType, rootValue, undefined, undefined, newGroupedFieldSets, newDeferMap);
-                addIncrementalDataRecords(exeContext, newDeferredGroupedFieldSetRecords);
+                const newPendingExecutionGroups = collectExecutionGroups(exeContext, rootType, rootValue, undefined, undefined, newGroupedFieldSets, newDeferMap);
+                addIncrementalDataRecords(exeContext, newPendingExecutionGroups);
             }
@@ -291,3 +296,4 @@ }
 function withError(errors, error) {
-    return errors === undefined ? [error] : [...errors.values(), error];
+    const newErrors = 'errors' in error ? error.errors : [error];
+    return errors === undefined ? newErrors : [...flattenErrors(errors), ...newErrors];
 }
@@ -425,3 +431,10 @@ /**
 }
+export const CRITICAL_ERROR = 'CRITICAL_ERROR';
 function handleFieldError(rawError, exeContext, returnType, fieldGroup, path, incrementalContext) {
+    if (rawError instanceof AggregateError) {
+        for (const rawErrorItem of rawError.errors) {
+            handleFieldError(rawErrorItem, exeContext, returnType, fieldGroup, path, incrementalContext);
+        }
+        return;
+    }
     const error = locatedError(coerceError(rawError), toNodes(fieldGroup), pathToArray(path));
@@ -433,2 +446,5 @@ // If the field type is non-nullable, then it is resolved without any
     }
+    if (error.extensions?.[CRITICAL_ERROR]) {
+        throw error;
+    }
     // Otherwise, error protection is applied, logging the error and resolving
@@ -439,6 +455,6 @@ // a null value for this field if one is encountered.
     if (errors === undefined) {
-        errors = new Map();
+        errors = new AccumulatorMap();
         context.errors = errors;
     }
-    errors.set(path, error);
+    errors.add(path, error);
 }
@@ -571,62 +587,73 @@ /**
     const streamUsage = getStreamUsage(exeContext, fieldGroup, path);
-    while (true) {
-        if (streamUsage && index >= streamUsage.initialCount) {
-            const streamItemQueue = buildAsyncStreamItemQueue(index, path, asyncIterator, exeContext, streamUsage.fieldGroup, info, itemType);
-            const returnFn = asyncIterator.return;
-            let streamRecord;
-            if (returnFn === undefined) {
-                streamRecord = {
-                    label: streamUsage.label,
-                    path,
-                    index,
-                    streamItemQueue,
-                };
-            }
-            else {
-                streamRecord = {
-                    label: streamUsage.label,
-                    path,
-                    index,
-                    streamItemQueue,
-                    earlyReturn: returnFn.bind(asyncIterator),
-                };
-                if (exeContext.cancellableStreams === undefined) {
-                    exeContext.cancellableStreams = new Set();
+    const earlyReturn = asyncIterator.return === undefined ? undefined : asyncIterator.return.bind(asyncIterator);
+    try {
+        while (true) {
+            if (streamUsage && index >= streamUsage.initialCount) {
+                const streamItemQueue = buildAsyncStreamItemQueue(index, path, asyncIterator, exeContext, streamUsage.fieldGroup, info, itemType);
+                let streamRecord;
+                if (earlyReturn === undefined) {
+                    streamRecord = {
+                        label: streamUsage.label,
+                        path,
+                        index,
+                        streamItemQueue,
+                    };
                 }
-                exeContext.cancellableStreams.add(streamRecord);
+                else {
+                    streamRecord = {
+                        label: streamUsage.label,
+                        path,
+                        index,
+                        streamItemQueue,
+                        earlyReturn,
+                    };
+                    if (exeContext.cancellableStreams === undefined) {
+                        exeContext.cancellableStreams = new Set();
+                    }
+                    exeContext.cancellableStreams.add(streamRecord);
+                }
+                const context = incrementalContext ?? exeContext;
+                addIncrementalDataRecords(context, [streamRecord]);
+                break;
             }
-            const context = incrementalContext ?? exeContext;
-            addIncrementalDataRecords(context, [streamRecord]);
-            break;
+            const itemPath = addPath(path, index, undefined);
+            let iteration;
+            try {
+                iteration = await asyncIterator.next();
+            }
+            catch (rawError) {
+                throw locatedError(coerceError(rawError), toNodes(fieldGroup), pathToArray(path));
+            }
+            // TODO: add test case for stream returning done before initialCount
+            /* c8 ignore next 3 */
+            if (iteration.done) {
+                break;
+            }
+            const item = iteration.value;
+            // TODO: add tests for stream backed by asyncIterator that returns a promise
+            /* c8 ignore start */
+            if (isPromise(item)) {
+                completedResults.push(completePromisedListItemValue(item, exeContext, itemType, fieldGroup, info, itemPath, incrementalContext, deferMap));
+                containsPromise = true;
+            }
+            else if (
+            /* c8 ignore stop */
+            completeListItemValue(item, completedResults, exeContext, itemType, fieldGroup, info, itemPath, incrementalContext, deferMap)
+            // TODO: add tests for stream backed by asyncIterator that completes to a promise
+            /* c8 ignore start */
+            ) {
+                containsPromise = true;
+            }
+            /* c8 ignore stop */
+            index++;
         }
-        const itemPath = addPath(path, index, undefined);
-        let iteration;
-        try {
-            iteration = await asyncIterator.next();
+    }
+    catch (error) {
+        if (earlyReturn !== undefined) {
+            earlyReturn().catch(() => {
+                /* c8 ignore next 1 */
+                // ignore error
+            });
         }
-        catch (rawError) {
-            throw locatedError(coerceError(rawError), toNodes(fieldGroup), pathToArray(path));
-        }
-        // TODO: add test case for stream returning done before initialCount
-        /* c8 ignore next 3 */
-        if (iteration.done) {
-            break;
-        }
-        const item = iteration.value;
-        // TODO: add tests for stream backed by asyncIterator that returns a promise
-        /* c8 ignore start */
-        if (isPromise(item)) {
-            completedResults.push(completePromisedListItemValue(item, exeContext, itemType, fieldGroup, info, itemPath, incrementalContext, deferMap));
-            containsPromise = true;
-        }
-        else if (
-        /* c8 ignore stop */
-        completeListItemValue(item, completedResults, exeContext, itemType, fieldGroup, info, itemPath, incrementalContext, deferMap)
-        // TODO: add tests for stream backed by asyncIterator that completes to a promise
-        /* c8 ignore start */
-        ) {
-            containsPromise = true;
-        }
-        /* c8 ignore stop */
-        index++;
+        throw error;
     }
@@ -845,24 +872,26 @@ return containsPromise
     }
-    const subFieldPlan = buildSubFieldPlan(groupedFieldSet, incrementalContext?.deferUsageSet, exeContext.deduplicateDefers);
-    groupedFieldSet = subFieldPlan.groupedFieldSet;
-    const newGroupedFieldSets = subFieldPlan.newGroupedFieldSets;
+    const subExecutionPlan = buildSubExecutionPlan(groupedFieldSet, incrementalContext?.deferUsageSet, exeContext.deduplicateDefers);
+    groupedFieldSet = subExecutionPlan.groupedFieldSet;
+    const newGroupedFieldSets = subExecutionPlan.newGroupedFieldSets;
     const newDeferMap = addNewDeferredFragments(newDeferUsages, new Map(deferMap), path);
     const subFields = executeFields(exeContext, returnType, result, path, groupedFieldSet, incrementalContext, newDeferMap);
     if (newGroupedFieldSets.size > 0) {
-        const newDeferredGroupedFieldSetRecords = executeDeferredGroupedFieldSets(exeContext, returnType, result, path, incrementalContext?.deferUsageSet, newGroupedFieldSets, newDeferMap);
+        const newPendingExecutionGroups = collectExecutionGroups(exeContext, returnType, result, path, incrementalContext?.deferUsageSet, newGroupedFieldSets, newDeferMap);
         const context = incrementalContext ?? exeContext;
-        addIncrementalDataRecords(context, newDeferredGroupedFieldSetRecords);
+        addIncrementalDataRecords(context, newPendingExecutionGroups);
     }
     return subFields;
 }
-function buildSubFieldPlan(originalGroupedFieldSet, deferUsageSet, deduplicateDefers) {
-    let fieldPlan = originalGroupedFieldSet._fieldPlan;
-    if (fieldPlan !== undefined) {
-        return fieldPlan;
+function buildSubExecutionPlan(originalGroupedFieldSet, deferUsageSet, deduplicateDefers) {
+    let executionPlan = originalGroupedFieldSet
+        ._executionPlan;
+    if (executionPlan !== undefined) {
+        return executionPlan;
     }
-    fieldPlan = deduplicateDefers
-        ? buildFieldPlan(originalGroupedFieldSet, deferUsageSet)
-        : buildBranchingFieldPlan(originalGroupedFieldSet, deferUsageSet);
-    originalGroupedFieldSet._fieldPlan = fieldPlan;
-    return fieldPlan;
+    executionPlan = deduplicateDefers
+        ? buildExecutionPlan(originalGroupedFieldSet, deferUsageSet)
+        : buildBranchingExecutionPlan(originalGroupedFieldSet, deferUsageSet);
+    originalGroupedFieldSet._executionPlan =
+        executionPlan;
+    return executionPlan;
 }
@@ -1005,9 +1034,14 @@ /**
     return flattenAsyncIterable(mapAsyncIterator(resultOrStream[Symbol.asyncIterator](), async (payload) => ensureAsyncIterable(await executeOperation(buildPerEventExecutionContext(exeContext, payload))), (error) => {
-        const wrappedError = createGraphQLError(error.message, {
-            originalError: error,
-            nodes: [exeContext.operation],
-        });
-        throw wrappedError;
+        if (error instanceof AggregateError) {
+            throw new AggregateError(error.errors.map(e => wrapError(e, exeContext.operation)), error.message);
+        }
+        throw wrapError(error, exeContext.operation);
     }));
 }
+function wrapError(error, operation) {
+    return createGraphQLError(error.message, {
+        originalError: error,
+        nodes: [operation],
+    });
+}
 function createSourceEventStreamImpl(exeContext) {
@@ -1088,7 +1122,7 @@ try {
 }
-function executeDeferredGroupedFieldSets(exeContext, parentType, sourceValue, path, parentDeferUsages, newGroupedFieldSets, deferMap) {
-    const newDeferredGroupedFieldSetRecords = [];
+function collectExecutionGroups(exeContext, parentType, sourceValue, path, parentDeferUsages, newGroupedFieldSets, deferMap) {
+    const newPendingExecutionGroups = [];
     for (const [deferUsageSet, groupedFieldSet] of newGroupedFieldSets) {
         const deferredFragmentRecords = getDeferredFragmentRecords(deferUsageSet, deferMap);
-        const deferredGroupedFieldSetRecord = {
+        const pendingExecutionGroup = {
             path,
@@ -1098,3 +1132,3 @@ deferredFragmentRecords,
         };
-        const executor = () => executeDeferredGroupedFieldSet(deferredGroupedFieldSetRecord, exeContext, parentType, sourceValue, path, groupedFieldSet, {
+        const executor = () => executeExecutionGroup(pendingExecutionGroup, exeContext, parentType, sourceValue, path, groupedFieldSet, {
             errors: undefined,
@@ -1105,3 +1139,3 @@ deferUsageSet,
         if (exeContext.enableEarlyExecution) {
-            deferredGroupedFieldSetRecord.result = new BoxedPromiseOrValue(shouldDefer(parentDeferUsages, deferUsageSet)
+            pendingExecutionGroup.result = new BoxedPromiseOrValue(shouldDefer(parentDeferUsages, deferUsageSet)
                 ? Promise.resolve().then(executor)
@@ -1111,7 +1145,7 @@ : executor());
         else {
-            deferredGroupedFieldSetRecord.result = () => new BoxedPromiseOrValue(executor());
+            pendingExecutionGroup.result = () => new BoxedPromiseOrValue(executor());
             const resolveThunk = () => {
-                const maybeThunk = deferredGroupedFieldSetRecord.result;
+                const maybeThunk = pendingExecutionGroup.result;
                 if (!(maybeThunk instanceof BoxedPromiseOrValue)) {
-                    deferredGroupedFieldSetRecord.result = maybeThunk();
+                    pendingExecutionGroup.result = maybeThunk();
                 }
@@ -1123,5 +1157,5 @@ };
         }
-        newDeferredGroupedFieldSetRecords.push(deferredGroupedFieldSetRecord);
+        newPendingExecutionGroups.push(pendingExecutionGroup);
     }
-    return newDeferredGroupedFieldSetRecords;
+    return newPendingExecutionGroups;
 }
@@ -1136,3 +1170,3 @@ function shouldDefer(parentDeferUsages, deferUsages) {
 }
-function executeDeferredGroupedFieldSet(deferredGroupedFieldSetRecord, exeContext, parentType, sourceValue, path, groupedFieldSet, incrementalContext, deferMap) {
+function executeExecutionGroup(pendingExecutionGroup, exeContext, parentType, sourceValue, path, groupedFieldSet, incrementalContext, deferMap) {
     let result;
@@ -1144,3 +1178,3 @@ try {
         return {
-            deferredGroupedFieldSetRecord,
+            pendingExecutionGroup,
             path: pathToArray(path),
@@ -1151,4 +1185,4 @@ errors: withError(incrementalContext.errors, error),
     if (isPromise(result)) {
-        return result.then(resolved => buildDeferredGroupedFieldSetResult(incrementalContext, deferredGroupedFieldSetRecord, path, resolved), error => ({
-            deferredGroupedFieldSetRecord,
+        return result.then(resolved => buildCompletedExecutionGroup(incrementalContext, pendingExecutionGroup, path, resolved), error => ({
+            pendingExecutionGroup,
             path: pathToArray(path),
@@ -1158,11 +1192,11 @@ errors: withError(incrementalContext.errors, error),
     }
-    return buildDeferredGroupedFieldSetResult(incrementalContext, deferredGroupedFieldSetRecord, path, result);
+    return buildCompletedExecutionGroup(incrementalContext, pendingExecutionGroup, path, result);
 }
-function buildDeferredGroupedFieldSetResult(incrementalContext, deferredGroupedFieldSetRecord, path, data) {
+function buildCompletedExecutionGroup(incrementalContext, pendingExecutionGroup, path, data) {
     const { errors, incrementalDataRecords } = incrementalContext;
     if (incrementalDataRecords === undefined) {
         return {
-            deferredGroupedFieldSetRecord,
+            pendingExecutionGroup,
             path: pathToArray(path),
-            result: errors === undefined ? { data } : { data, errors: [...errors.values()] },
+            result: errors === undefined ? { data } : { data, errors: [...flattenErrors(errors)] },
             incrementalDataRecords,
@@ -1173,3 +1207,3 @@ };
         return {
-            deferredGroupedFieldSetRecord,
+            pendingExecutionGroup,
             path: pathToArray(path),
@@ -1181,5 +1215,5 @@ result: { data },
     return {
-        deferredGroupedFieldSetRecord,
+        pendingExecutionGroup,
         path: pathToArray(path),
-        result: { data, errors: [...errors.values()] },
+        result: { data, errors: [...flattenErrors(errors)] },
         incrementalDataRecords: filterIncrementalDataRecords(path, errors, incrementalDataRecords),
@@ -1243,3 +1277,3 @@ };
             path: streamPath,
-            errors: [locatedError(error, toNodes(fieldGroup), pathToArray(streamPath))],
+            errors: [locatedError(coerceError(error), toNodes(fieldGroup), pathToArray(streamPath))],
         };
@@ -1300,3 +1334,3 @@ }
             item,
-            errors: errors === undefined ? undefined : [...errors.values()],
+            errors: errors === undefined ? undefined : [...flattenErrors(errors)],
             incrementalDataRecords,
@@ -1316,3 +1350,3 @@ };
         item,
-        errors: [...errors.values()],
+        errors: [...flattenErrors(errors)],
         incrementalDataRecords: filterIncrementalDataRecords(streamPath, errors, incrementalDataRecords),
@@ -1319,0 +1353,0 @@ };

esm/execution/IncrementalGraph.js

 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';
 /**
@@ -22,11 +22,12 @@ * @internal
     }
-    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);
         }
@@ -60,15 +61,15 @@ }
         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 };
     }
@@ -79,20 +80,17 @@ removeDeferredFragment(deferredFragmentRecord) {
         }
-        this._removePending(deferredFragmentRecord);
+        this._rootNodes.delete(deferredFragmentRecord);
         return true;
     }
     removeStream(streamRecord) {
-        this._removePending(streamRecord);
+        this._rootNodes.delete(streamRecord);
     }
-    _removePending(subsequentResultRecord) {
-        this._rootNodes.delete(subsequentResultRecord);
-    }
     _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);
                 }
@@ -114,16 +112,16 @@ }
         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);
@@ -133,5 +131,5 @@ }
             else {
-                this._rootNodes.add(subsequentResultRecord);
-                newPending.push(subsequentResultRecord);
-                this._onStreamItems(subsequentResultRecord);
+                this._rootNodes.add(deliveryGroup);
+                newPending.push(deliveryGroup);
+                this._onStreamItems(deliveryGroup);
             }
@@ -141,6 +139,6 @@ }
     }
-    _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)) {
@@ -151,11 +149,12 @@ return;
         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)) {
@@ -162,0 +161,0 @@ result.then(resolved => this._enqueue(resolved));

esm/execution/IncrementalPublisher.js

 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) {
@@ -146,4 +146,4 @@ const incrementalPublisher = new IncrementalPublisher(context);
     _handleCompletedIncrementalData(completedIncrementalData, context) {
-        if (isDeferredGroupedFieldSetResult(completedIncrementalData)) {
-            this._handleCompletedDeferredGroupedFieldSet(completedIncrementalData, context);
+        if (isCompletedExecutionGroup(completedIncrementalData)) {
+            this._handleCompletedExecutionGroup(completedIncrementalData, context);
         }
@@ -154,6 +154,6 @@ else {
     }
-    _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;
@@ -169,3 +169,3 @@ if (!this._incrementalGraph.removeDeferredFragment(deferredFragmentRecord)) {
                         data: null,
-                        errors: deferredGroupedFieldSetResult.errors,
+                        errors: completedExecutionGroup.errors,
                     };
@@ -185,3 +185,3 @@ if (this._context.sendPathAndLabelOnIncremental) {
                         id,
-                        errors: deferredGroupedFieldSetResult.errors,
+                        errors: completedExecutionGroup.errors,
                     });
@@ -192,4 +192,4 @@ }
         }
-        this._incrementalGraph.addCompletedReconcilableDeferredGroupedFieldSet(deferredGroupedFieldSetResult);
-        for (const deferredFragmentRecord of deferredGroupedFieldSetResult.deferredGroupedFieldSetRecord
+        this._incrementalGraph.addCompletedSuccessfulExecutionGroup(completedExecutionGroup);
+        for (const deferredFragmentRecord of completedExecutionGroup.pendingExecutionGroup
             .deferredFragmentRecords) {
@@ -203,8 +203,8 @@ const completion = this._incrementalGraph.completeDeferredFragment(deferredFragmentRecord);
             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,
@@ -294,6 +294,6 @@ };
     }
-    _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) {
@@ -316,3 +316,3 @@ if (deferredFragmentRecord === initialDeferredFragmentRecord) {
         }
-        const subPath = deferredGroupedFieldSetResult.path.slice(maxLength);
+        const subPath = completedExecutionGroup.path.slice(maxLength);
         return {
@@ -319,0 +319,0 @@ bestId,

esm/execution/types.js

@@ -1,9 +0,9 @@
-export function isDeferredGroupedFieldSetRecord(incrementalDataRecord) {
+export function isPendingExecutionGroup(incrementalDataRecord) {
     return 'deferredFragmentRecords' in incrementalDataRecord;
 }
-export function isDeferredGroupedFieldSetResult(subsequentResult) {
-    return 'deferredGroupedFieldSetRecord' in subsequentResult;
+export function isCompletedExecutionGroup(incrementalDataRecordResult) {
+    return 'pendingExecutionGroup' in incrementalDataRecordResult;
 }
-export function isNonReconcilableDeferredGroupedFieldSetResult(deferredGroupedFieldSetResult) {
-    return deferredGroupedFieldSetResult.errors !== undefined;
+export function isFailedExecutionGroup(completedExecutionGroup) {
+    return completedExecutionGroup.errors !== undefined;
 }
@@ -16,4 +16,4 @@ /** @internal */
     parent;
-    deferredGroupedFieldSetRecords;
-    reconcilableResults;
+    pendingExecutionGroups;
+    successfulExecutionGroups;
     children;
@@ -26,4 +26,4 @@ pending;
         this.parent = parent;
-        this.deferredGroupedFieldSetRecords = new Set();
-        this.reconcilableResults = new Set();
+        this.pendingExecutionGroups = new Set();
+        this.successfulExecutionGroups = new Set();
         this.children = new Set();
@@ -43,7 +43,7 @@ this.pending = false;
 }
-export function isDeferredFragmentRecord(subsequentResultRecord) {
-    return subsequentResultRecord instanceof DeferredFragmentRecord;
+export function isDeferredFragmentRecord(deliveryGroup) {
+    return deliveryGroup instanceof DeferredFragmentRecord;
 }
-export function isCancellableStreamRecord(subsequentResultRecord) {
-    return 'earlyReturn' in subsequentResultRecord;
+export function isCancellableStreamRecord(deliveryGroup) {
+    return 'earlyReturn' in deliveryGroup;
 }

package.json

 {
   "name": "@graphql-tools/executor",
-  "version": "2.0.0-alpha-20240709213044-006da37e240c6ccb1d305e19ade18dd70384cb22",
+  "version": "2.0.0-alpha-20240804112853-812acba5ea59541106a53f872874fd7aebcffcfc",
   "sideEffects": false,
@@ -9,3 +9,3 @@ "peerDependencies": {
   "dependencies": {
-    "@graphql-tools/utils": "10.4.0-alpha-20240709213044-006da37e240c6ccb1d305e19ade18dd70384cb22",
+    "@graphql-tools/utils": "10.4.0-alpha-20240804112853-812acba5ea59541106a53f872874fd7aebcffcfc",
     "@graphql-typed-document-node/core": "3.2.0",
@@ -12,0 +12,0 @@ "@repeaterjs/repeater": "^3.0.4",

typings/execution/execute.d.ts

 import { DocumentNode, FieldNode, FragmentDefinitionNode, GraphQLError, GraphQLField, GraphQLFieldResolver, GraphQLObjectType, GraphQLResolveInfo, GraphQLSchema, GraphQLTypeResolver, OperationDefinitionNode } from 'graphql';
 import { Maybe, MaybePromise, Path } from '@graphql-tools/utils';
 import { TypedDocumentNode } from '@graphql-typed-document-node/core';
+import { AccumulatorMap } from './AccumulatorMap.js';
 import { CancellableStreamRecord, IncrementalDataRecord, IncrementalExecutionResults, InitialIncrementalExecutionResult, SingularExecutionResult, SubsequentIncrementalExecutionResult } from './types.js';
@@ -46,3 +47,3 @@ /**
     signal: AbortSignal | undefined;
-    errors: Map<Path | undefined, GraphQLError> | undefined;
+    errors: AccumulatorMap<Path | undefined, GraphQLError> | undefined;
     cancellableStreams: Set<CancellableStreamRecord> | undefined;
@@ -110,2 +111,3 @@ incrementalDataRecords: Array<IncrementalDataRecord> | undefined;
 export declare function buildResolveInfo(exeContext: ExecutionContext, fieldDef: GraphQLField<unknown, unknown>, fieldNodes: Array<FieldNode>, parentType: GraphQLObjectType, path: Path): GraphQLResolveInfo;
+export declare const CRITICAL_ERROR: "CRITICAL_ERROR";
 /**
@@ -112,0 +114,0 @@ * If a resolveType function is not given, then a default resolve behavior is

typings/execution/IncrementalGraph.d.ts

@@ -1,2 +0,2 @@
-import type { DeferredFragmentRecord, IncrementalDataRecord, IncrementalDataRecordResult, ReconcilableDeferredGroupedFieldSetResult, StreamRecord, SubsequentResultRecord } from './types.js';
+import type { DeferredFragmentRecord, DeliveryGroup, IncrementalDataRecord, IncrementalDataRecordResult, StreamRecord, SuccessfulExecutionGroup } from './types.js';
 /**
@@ -10,4 +10,4 @@ * @internal
     constructor();
-    getNewPending(incrementalDataRecords: ReadonlyArray<IncrementalDataRecord>): ReadonlyArray<SubsequentResultRecord>;
-    addCompletedReconcilableDeferredGroupedFieldSet(reconcilableResult: ReconcilableDeferredGroupedFieldSetResult): void;
+    getNewPending(incrementalDataRecords: ReadonlyArray<IncrementalDataRecord>): ReadonlyArray<DeliveryGroup>;
+    addCompletedSuccessfulExecutionGroup(successfulExecutionGroup: SuccessfulExecutionGroup): void;
     currentCompletedBatch(): Generator<IncrementalDataRecordResult>;
@@ -18,8 +18,7 @@ nextCompletedBatch(): Promise<Iterable<IncrementalDataRecordResult> | undefined>;
     completeDeferredFragment(deferredFragmentRecord: DeferredFragmentRecord): {
-        newPending: ReadonlyArray<SubsequentResultRecord>;
-        reconcilableResults: ReadonlyArray<ReconcilableDeferredGroupedFieldSetResult>;
+        newPending: ReadonlyArray<DeliveryGroup>;
+        successfulExecutionGroups: ReadonlyArray<SuccessfulExecutionGroup>;
     } | undefined;
     removeDeferredFragment(deferredFragmentRecord: DeferredFragmentRecord): boolean;
     removeStream(streamRecord: StreamRecord): void;
-    private _removePending;
     private _addIncrementalDataRecords;
@@ -29,3 +28,3 @@ private _promoteNonEmptyToRoot;
     private _addDeferredFragment;
-    private _onDeferredGroupedFieldSet;
+    private _onExecutionGroup;
     private _onStreamItems;
@@ -32,0 +31,0 @@ private _yieldCurrentCompletedIncrementalData;

typings/execution/types.d.ts

@@ -53,3 +53,3 @@ import type { GraphQLError, GraphQLFormattedError } from 'graphql';
 }
-interface BareDeferredGroupedFieldSetResult<TData = Record<string, unknown>> {
+interface ExecutionGroupResult<TData = Record<string, unknown>> {
     errors?: ReadonlyArray<GraphQLError>;
@@ -76,3 +76,3 @@ data: TData;
 }
-interface BareStreamItemsResult<TData = ReadonlyArray<unknown>> {
+interface StreamItemsRecordResult<TData = ReadonlyArray<unknown>> {
     errors?: ReadonlyArray<GraphQLError>;
@@ -113,14 +113,14 @@ items: TData;
 }
-export declare function isDeferredGroupedFieldSetRecord(incrementalDataRecord: IncrementalDataRecord): incrementalDataRecord is DeferredGroupedFieldSetRecord;
-export type DeferredGroupedFieldSetResult = ReconcilableDeferredGroupedFieldSetResult | NonReconcilableDeferredGroupedFieldSetResult;
-export declare function isDeferredGroupedFieldSetResult(subsequentResult: DeferredGroupedFieldSetResult | StreamItemsResult): subsequentResult is DeferredGroupedFieldSetResult;
-export interface ReconcilableDeferredGroupedFieldSetResult {
-    deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord;
+export declare function isPendingExecutionGroup(incrementalDataRecord: IncrementalDataRecord): incrementalDataRecord is PendingExecutionGroup;
+export type CompletedExecutionGroup = SuccessfulExecutionGroup | FailedExecutionGroup;
+export declare function isCompletedExecutionGroup(incrementalDataRecordResult: IncrementalDataRecordResult): incrementalDataRecordResult is CompletedExecutionGroup;
+export interface SuccessfulExecutionGroup {
+    pendingExecutionGroup: PendingExecutionGroup;
     path: Array<string | number>;
-    result: BareDeferredGroupedFieldSetResult;
+    result: ExecutionGroupResult;
     incrementalDataRecords: ReadonlyArray<IncrementalDataRecord> | undefined;
     errors?: never;
 }
-interface NonReconcilableDeferredGroupedFieldSetResult {
-    deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord;
+interface FailedExecutionGroup {
+    pendingExecutionGroup: PendingExecutionGroup;
     path: Array<string | number>;
@@ -130,9 +130,9 @@ errors: ReadonlyArray<GraphQLError>;
 }
-export declare function isNonReconcilableDeferredGroupedFieldSetResult(deferredGroupedFieldSetResult: DeferredGroupedFieldSetResult): deferredGroupedFieldSetResult is NonReconcilableDeferredGroupedFieldSetResult;
-export interface DeferredGroupedFieldSetRecord {
+export declare function isFailedExecutionGroup(completedExecutionGroup: CompletedExecutionGroup): completedExecutionGroup is FailedExecutionGroup;
+export interface PendingExecutionGroup {
     path: Path | undefined;
     deferredFragmentRecords: ReadonlyArray<DeferredFragmentRecord>;
-    result: BoxedPromiseOrValue<DeferredGroupedFieldSetResult> | (() => BoxedPromiseOrValue<DeferredGroupedFieldSetResult>);
+    result: BoxedPromiseOrValue<CompletedExecutionGroup> | (() => BoxedPromiseOrValue<CompletedExecutionGroup>);
 }
-export type SubsequentResultRecord = DeferredFragmentRecord | StreamRecord;
+export type DeliveryGroup = DeferredFragmentRecord | StreamRecord;
 /** @internal */
@@ -144,5 +144,5 @@ export declare class DeferredFragmentRecord {
     parent: DeferredFragmentRecord | undefined;
-    deferredGroupedFieldSetRecords: Set<DeferredGroupedFieldSetRecord>;
-    reconcilableResults: Set<ReconcilableDeferredGroupedFieldSetResult>;
-    children: Set<SubsequentResultRecord>;
+    pendingExecutionGroups: Set<PendingExecutionGroup>;
+    successfulExecutionGroups: Set<SuccessfulExecutionGroup>;
+    children: Set<DeliveryGroup>;
     pending: boolean;
@@ -154,3 +154,3 @@ fns: Array<() => void>;
 }
-export declare function isDeferredFragmentRecord(subsequentResultRecord: SubsequentResultRecord): subsequentResultRecord is DeferredFragmentRecord;
+export declare function isDeferredFragmentRecord(deliveryGroup: DeliveryGroup): deliveryGroup is DeferredFragmentRecord;
 export interface StreamItemResult {
@@ -172,3 +172,3 @@ path: Path;
     streamRecord: StreamRecord;
-    result?: BareStreamItemsResult | undefined;
+    result?: StreamItemsRecordResult | undefined;
     incrementalDataRecords?: ReadonlyArray<IncrementalDataRecord> | undefined;
@@ -180,5 +180,5 @@ errors?: ReadonlyArray<GraphQLError> | undefined;
 }
-export declare function isCancellableStreamRecord(subsequentResultRecord: SubsequentResultRecord): subsequentResultRecord is CancellableStreamRecord;
-export type IncrementalDataRecord = DeferredGroupedFieldSetRecord | StreamRecord;
-export type IncrementalDataRecordResult = DeferredGroupedFieldSetResult | StreamItemsResult;
+export declare function isCancellableStreamRecord(deliveryGroup: DeliveryGroup): deliveryGroup is CancellableStreamRecord;
+export type IncrementalDataRecord = PendingExecutionGroup | StreamRecord;
+export type IncrementalDataRecordResult = CompletedExecutionGroup | StreamItemsResult;
 export {};

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

273306

increased by0.06%

Lines of code

5607

increased by0.74%

Dependency changes

• + Added@graphql-tools/utils@10.4.0-alpha-20240804112853-812acba5ea59541106a53f872874fd7aebcffcfc(transitive)

• - Removed@graphql-tools/utils@10.4.0-alpha-20240709213044-006da37e240c6ccb1d305e19ade18dd70384cb22(transitive)

• Updated@graphql-tools/utils@10.4.0-alpha-20240804112853-812acba5ea59541106a53f872874fd7aebcffcfc