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

package/esm/execution/execute.js

@@ -1,7 +1,8 @@
 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';
 import { collectSubfields as _collectSubfields, collectFields, } from './collectFields.js';
 import { flattenAsyncIterable } from './flattenAsyncIterable.js';
@@ -80,10 +81,10 @@ function buildDataResponse(exeContext, data) {
     if (filteredIncrementalDataRecords.length === 0) {
         return buildSingleResult(data, errors);
     }
-    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 };
 }
 function filterIncrementalDataRecords(initialPath, errors, incrementalDataRecords) {
     const filteredIncrementalDataRecords = [];
@@ -112,6 +113,10 @@ function filterIncrementalDataRecords(initialPath, errors, incrementalDataRecord
     }
     return filteredIncrementalDataRecords;
 }
+function flattenErrors(errors) {
+    const errorsByPath = [...errors.values()];
+    return errorsByPath.flat();
+}
 /**
  * Essential assertions before executing to provide developer feedback for
  * improper use of the GraphQL library.
@@ -234,16 +239,16 @@ function executeOperation(exeContext) {
             data = executeRootGroupedFieldSet(exeContext, operation.operation, rootType, rootValue, groupedFieldSet, undefined);
         }
         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);
             }
         }
         if (isPromise(data)) {
@@ -285,7 +290,8 @@ function addIncrementalDataRecords(context, newIncrementalDataRecords) {
     incrementalDataRecords.push(...newIncrementalDataRecords);
 }
 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];
 }
 /**
  * Implements the "Executing selection sets" section of the spec
@@ -418,22 +424,32 @@ export function buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, p
         variableValues: exeContext.variableValues,
     };
 }
+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));
     // If the field type is non-nullable, then it is resolved without any
     // protection from errors, however it still properly locates the error.
     if (isNonNullType(returnType)) {
         throw error;
     }
+    if (error.extensions?.[CRITICAL_ERROR]) {
+        throw error;
+    }
     // Otherwise, error protection is applied, logging the error and resolving
     // a null value for this field if one is encountered.
     const context = incrementalContext ?? exeContext;
     let errors = context.errors;
     if (errors === undefined) {
-        errors = new Map();
+        errors = new AccumulatorMap();
         context.errors = errors;
     }
-    errors.set(path, error);
+    errors.add(path, error);
 }
 /**
  * Implements the instructions for completeValue as defined in the
@@ -561,66 +577,77 @@ async function completeAsyncIteratorValue(exeContext, itemType, fieldGroup, info
     const completedResults = [];
     let index = 0;
     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;
+            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++;
         }
-        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;
+    }
+    catch (error) {
+        if (earlyReturn !== undefined) {
+            earlyReturn().catch(() => {
+                /* c8 ignore next 1 */
+                // ignore error
+            });
         }
-        /* c8 ignore stop */
-        index++;
+        throw error;
     }
     return containsPromise
         ? /* c8 ignore start */ Promise.all(completedResults)
@@ -834,28 +861,30 @@ function collectAndExecuteSubfields(exeContext, returnType, fieldGroup, path, re
     if (deferMap === undefined && newDeferUsages.length === 0) {
         return executeFields(exeContext, returnType, result, path, groupedFieldSet, incrementalContext, undefined);
     }
-    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;
-    }
-    fieldPlan = deduplicateDefers
-        ? buildFieldPlan(originalGroupedFieldSet, deferUsageSet)
-        : buildBranchingFieldPlan(originalGroupedFieldSet, deferUsageSet);
-    originalGroupedFieldSet._fieldPlan = fieldPlan;
-    return fieldPlan;
+function buildSubExecutionPlan(originalGroupedFieldSet, deferUsageSet, deduplicateDefers) {
+    let executionPlan = originalGroupedFieldSet
+        ._executionPlan;
+    if (executionPlan !== undefined) {
+        return executionPlan;
+    }
+    executionPlan = deduplicateDefers
+        ? buildExecutionPlan(originalGroupedFieldSet, deferUsageSet)
+        : buildBranchingExecutionPlan(originalGroupedFieldSet, deferUsageSet);
+    originalGroupedFieldSet._executionPlan =
+        executionPlan;
+    return executionPlan;
 }
 /**
  * If a resolveType function is not given, then a default resolve behavior is
@@ -993,13 +1022,18 @@ function mapSourceToResponse(exeContext, resultOrStream) {
     // "ExecuteSubscriptionEvent" algorithm, as it is nearly identical to the
     // "ExecuteQuery" algorithm, for which `execute` is also used.
     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) {
     try {
         const eventStream = executeSubscription(exeContext);
@@ -1075,40 +1109,40 @@ function assertEventStream(result, signal) {
         },
     };
 }
-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,
             deferredFragmentRecords,
             result: undefined,
         };
-        const executor = () => executeDeferredGroupedFieldSet(deferredGroupedFieldSetRecord, exeContext, parentType, sourceValue, path, groupedFieldSet, {
+        const executor = () => executeExecutionGroup(pendingExecutionGroup, exeContext, parentType, sourceValue, path, groupedFieldSet, {
             errors: undefined,
             deferUsageSet,
             incrementalDataRecords: undefined,
         }, deferMap);
         if (exeContext.enableEarlyExecution) {
-            deferredGroupedFieldSetRecord.result = new BoxedPromiseOrValue(shouldDefer(parentDeferUsages, deferUsageSet)
+            pendingExecutionGroup.result = new BoxedPromiseOrValue(shouldDefer(parentDeferUsages, deferUsageSet)
                 ? Promise.resolve().then(executor)
                 : 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();
                 }
             };
             for (const deferredFragmentRecord of deferredFragmentRecords) {
                 deferredFragmentRecord.onPending(resolveThunk);
             }
         }
-        newDeferredGroupedFieldSetRecords.push(deferredGroupedFieldSetRecord);
+        newPendingExecutionGroups.push(pendingExecutionGroup);
     }
-    return newDeferredGroupedFieldSetRecords;
+    return newPendingExecutionGroups;
 }
 function shouldDefer(parentDeferUsages, deferUsages) {
     // If we have a new child defer usage, defer.
@@ -1118,49 +1152,49 @@ function shouldDefer(parentDeferUsages, deferUsages) {
     return (parentDeferUsages === undefined ||
         !Array.from(deferUsages).every(deferUsage => parentDeferUsages.has(deferUsage)));
 }
-function executeDeferredGroupedFieldSet(deferredGroupedFieldSetRecord, exeContext, parentType, sourceValue, path, groupedFieldSet, incrementalContext, deferMap) {
+function executeExecutionGroup(pendingExecutionGroup, exeContext, parentType, sourceValue, path, groupedFieldSet, incrementalContext, deferMap) {
     let result;
     try {
         result = executeFields(exeContext, parentType, sourceValue, path, groupedFieldSet, incrementalContext, deferMap);
     }
     catch (error) {
         return {
-            deferredGroupedFieldSetRecord,
+            pendingExecutionGroup,
             path: pathToArray(path),
             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),
             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,
         };
     }
     if (errors === undefined) {
         return {
-            deferredGroupedFieldSetRecord,
+            pendingExecutionGroup,
             path: pathToArray(path),
             result: { data },
             incrementalDataRecords,
         };
     }
     return {
-        deferredGroupedFieldSetRecord,
+        pendingExecutionGroup,
         path: pathToArray(path),
-        result: { data, errors: [...errors.values()] },
+        result: { data, errors: [...flattenErrors(errors)] },
         incrementalDataRecords: filterIncrementalDataRecords(path, errors, incrementalDataRecords),
     };
 }
@@ -1219,7 +1253,7 @@ async function getNextAsyncStreamItemResult(streamItemQueue, streamPath, index,
     catch (error) {
         return {
             path: streamPath,
-            errors: [locatedError(error, toNodes(fieldGroup), pathToArray(streamPath))],
+            errors: [locatedError(coerceError(error), toNodes(fieldGroup), pathToArray(streamPath))],
         };
     }
     if (iteration.done) {
@@ -1275,7 +1309,7 @@ function buildStreamItemResult(incrementalContext, streamPath, item) {
         return {
             path: streamPath,
             item,
-            errors: errors === undefined ? undefined : [...errors.values()],
+            errors: errors === undefined ? undefined : [...flattenErrors(errors)],
             incrementalDataRecords,
         };
     }
@@ -1290,7 +1324,7 @@ function buildStreamItemResult(incrementalContext, streamPath, item) {
     return {
         path: streamPath,
         item,
-        errors: [...errors.values()],
+        errors: [...flattenErrors(errors)],
         incrementalDataRecords: filterIncrementalDataRecords(streamPath, errors, incrementalDataRecords),
     };
 }

package/esm/execution/types.js

@@ -1,11 +1,11 @@
-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;
 }
 /** @internal */
 export class DeferredFragmentRecord {
@@ -13,8 +13,8 @@ export class DeferredFragmentRecord {
     label;
     id;
     parent;
-    deferredGroupedFieldSetRecords;
-    reconcilableResults;
+    pendingExecutionGroups;
+    successfulExecutionGroups;
     children;
     pending;
     fns;
@@ -22,8 +22,8 @@ export class DeferredFragmentRecord {
         this.path = path;
         this.label = label;
         this.parent = parent;
-        this.deferredGroupedFieldSetRecords = new Set();
-        this.reconcilableResults = new Set();
+        this.pendingExecutionGroups = new Set();
+        this.successfulExecutionGroups = new Set();
         this.children = new Set();
         this.pending = false;
         this.fns = [];
@@ -38,9 +38,9 @@ export class DeferredFragmentRecord {
         }
     }
 }
-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/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@graphql-tools/executor",
-  "version": "2.0.0-alpha-20240709212042-9a70c086fa543c594055305622a600bb95343b42",
+  "version": "2.0.0-alpha-20240804112853-812acba5ea59541106a53f872874fd7aebcffcfc",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0"
   },
   "dependencies": {
-    "@graphql-tools/utils": "10.4.0-alpha-20240709212042-9a70c086fa543c594055305622a600bb95343b42",
+    "@graphql-tools/utils": "10.4.0-alpha-20240804112853-812acba5ea59541106a53f872874fd7aebcffcfc",
     "@graphql-typed-document-node/core": "3.2.0",
     "@repeaterjs/repeater": "^3.0.4",
     "tslib": "^2.4.0",

package/typings/execution/IncrementalGraph.d.cts

@@ -1,4 +1,4 @@
-import type { DeferredFragmentRecord, IncrementalDataRecord, IncrementalDataRecordResult, ReconcilableDeferredGroupedFieldSetResult, StreamRecord, SubsequentResultRecord } from './types.cjs';
+import type { DeferredFragmentRecord, DeliveryGroup, IncrementalDataRecord, IncrementalDataRecordResult, StreamRecord, SuccessfulExecutionGroup } from './types.cjs';
 /**
  * @internal
  */
@@ -7,24 +7,23 @@ export declare class IncrementalGraph {
     private _completedQueue;
     private _nextQueue;
     constructor();
-    getNewPending(incrementalDataRecords: ReadonlyArray<IncrementalDataRecord>): ReadonlyArray<SubsequentResultRecord>;
-    addCompletedReconcilableDeferredGroupedFieldSet(reconcilableResult: ReconcilableDeferredGroupedFieldSetResult): void;
+    getNewPending(incrementalDataRecords: ReadonlyArray<IncrementalDataRecord>): ReadonlyArray<DeliveryGroup>;
+    addCompletedSuccessfulExecutionGroup(successfulExecutionGroup: SuccessfulExecutionGroup): void;
     currentCompletedBatch(): Generator<IncrementalDataRecordResult>;
     nextCompletedBatch(): Promise<Iterable<IncrementalDataRecordResult> | undefined>;
     abort(): void;
     hasNext(): boolean;
     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;
     private _promoteNonEmptyToRoot;
     private _hasPendingFragment;
     private _addDeferredFragment;
-    private _onDeferredGroupedFieldSet;
+    private _onExecutionGroup;
     private _onStreamItems;
     private _yieldCurrentCompletedIncrementalData;
     private _enqueue;

package/typings/execution/IncrementalGraph.d.ts

@@ -1,4 +1,4 @@
-import type { DeferredFragmentRecord, IncrementalDataRecord, IncrementalDataRecordResult, ReconcilableDeferredGroupedFieldSetResult, StreamRecord, SubsequentResultRecord } from './types.js';
+import type { DeferredFragmentRecord, DeliveryGroup, IncrementalDataRecord, IncrementalDataRecordResult, StreamRecord, SuccessfulExecutionGroup } from './types.js';
 /**
  * @internal
  */
@@ -7,24 +7,23 @@ export declare class IncrementalGraph {
     private _completedQueue;
     private _nextQueue;
     constructor();
-    getNewPending(incrementalDataRecords: ReadonlyArray<IncrementalDataRecord>): ReadonlyArray<SubsequentResultRecord>;
-    addCompletedReconcilableDeferredGroupedFieldSet(reconcilableResult: ReconcilableDeferredGroupedFieldSetResult): void;
+    getNewPending(incrementalDataRecords: ReadonlyArray<IncrementalDataRecord>): ReadonlyArray<DeliveryGroup>;
+    addCompletedSuccessfulExecutionGroup(successfulExecutionGroup: SuccessfulExecutionGroup): void;
     currentCompletedBatch(): Generator<IncrementalDataRecordResult>;
     nextCompletedBatch(): Promise<Iterable<IncrementalDataRecordResult> | undefined>;
     abort(): void;
     hasNext(): boolean;
     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;
     private _promoteNonEmptyToRoot;
     private _hasPendingFragment;
     private _addDeferredFragment;
-    private _onDeferredGroupedFieldSet;
+    private _onExecutionGroup;
     private _onStreamItems;
     private _yieldCurrentCompletedIncrementalData;
     private _enqueue;

package/typings/execution/buildExecutionPlan.d.cts

@@ -0,0 +1,8 @@
+import type { DeferUsage, GroupedFieldSet } from './collectFields.cjs';
+export type DeferUsageSet = ReadonlySet<DeferUsage>;
+export interface ExecutionPlan {
+    groupedFieldSet: GroupedFieldSet;
+    newGroupedFieldSets: Map<DeferUsageSet, GroupedFieldSet>;
+}
+export declare function buildExecutionPlan(originalGroupedFieldSet: GroupedFieldSet, parentDeferUsages?: DeferUsageSet): ExecutionPlan;
+export declare function buildBranchingExecutionPlan(originalGroupedFieldSet: GroupedFieldSet, parentDeferUsages?: DeferUsageSet): ExecutionPlan;

package/typings/execution/buildExecutionPlan.d.ts

@@ -0,0 +1,8 @@
+import type { DeferUsage, GroupedFieldSet } from './collectFields.js';
+export type DeferUsageSet = ReadonlySet<DeferUsage>;
+export interface ExecutionPlan {
+    groupedFieldSet: GroupedFieldSet;
+    newGroupedFieldSets: Map<DeferUsageSet, GroupedFieldSet>;
+}
+export declare function buildExecutionPlan(originalGroupedFieldSet: GroupedFieldSet, parentDeferUsages?: DeferUsageSet): ExecutionPlan;
+export declare function buildBranchingExecutionPlan(originalGroupedFieldSet: GroupedFieldSet, parentDeferUsages?: DeferUsageSet): ExecutionPlan;

package/typings/execution/execute.d.cts

@@ -1,6 +1,7 @@
 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.cjs';
 import { CancellableStreamRecord, IncrementalDataRecord, IncrementalExecutionResults, InitialIncrementalExecutionResult, SingularExecutionResult, SubsequentIncrementalExecutionResult } from './types.cjs';
 /**
  * Terminology
@@ -43,7 +44,7 @@ export interface ExecutionContext<TVariables = any, TContext = any> {
     sendPathAndLabelOnIncremental: boolean;
     errorWithIncrementalSubscription: boolean;
     signal: AbortSignal | undefined;
-    errors: Map<Path | undefined, GraphQLError> | undefined;
+    errors: AccumulatorMap<Path | undefined, GraphQLError> | undefined;
     cancellableStreams: Set<CancellableStreamRecord> | undefined;
     incrementalDataRecords: Array<IncrementalDataRecord> | undefined;
 }
@@ -106,6 +107,7 @@ export declare function buildExecutionContext<TData = any, TVariables = any, TCo
  * @internal
  */
 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";
 /**
  * If a resolveType function is not given, then a default resolve behavior is
  * used which attempts two strategies: