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

package/cjs/execution/execute.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isIncrementalResult = exports.getFieldDef = exports.flattenIncrementalResults = exports.subscribe = exports.defaultFieldResolver = exports.defaultTypeResolver = exports.buildResolveInfo = exports.buildExecutionContext = exports.getFragmentsFromDocument = exports.assertValidExecutionArguments = exports.executeSync = exports.execute = void 0;
+exports.isIncrementalResult = exports.getFieldDef = exports.flattenIncrementalResults = exports.subscribe = exports.defaultFieldResolver = exports.defaultTypeResolver = exports.CRITICAL_ERROR = exports.buildResolveInfo = exports.buildExecutionContext = exports.getFragmentsFromDocument = exports.assertValidExecutionArguments = exports.executeSync = exports.execute = void 0;
 const graphql_1 = require("graphql");
 const utils_1 = require("@graphql-tools/utils");
+const AccumulatorMap_js_1 = require("./AccumulatorMap.js");
 const BoxedPromiseOrValue_js_1 = require("./BoxedPromiseOrValue.js");
-const buildFieldPlan_js_1 = require("./buildFieldPlan.js");
+const buildExecutionPlan_js_1 = require("./buildExecutionPlan.js");
 const coerceError_js_1 = require("./coerceError.js");
 const collectFields_js_1 = require("./collectFields.js");
 const flattenAsyncIterable_js_1 = require("./flattenAsyncIterable.js");
@@ -85,10 +86,10 @@ function buildDataResponse(exeContext, data) {
     if (filteredIncrementalDataRecords.length === 0) {
         return buildSingleResult(data, errors);
     }
-    return (0, IncrementalPublisher_js_1.buildIncrementalResponse)(exeContext, data, Array.from(errors.values()), filteredIncrementalDataRecords);
+    return (0, IncrementalPublisher_js_1.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 = [];
@@ -117,6 +118,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.
@@ -241,16 +246,16 @@ function executeOperation(exeContext) {
             data = executeRootGroupedFieldSet(exeContext, operation.operation, rootType, rootValue, groupedFieldSet, undefined);
         }
         else {
-            const fieldPLan = deduplicateDefers
-                ? (0, buildFieldPlan_js_1.buildFieldPlan)(groupedFieldSet)
-                : (0, buildFieldPlan_js_1.buildBranchingFieldPlan)(groupedFieldSet);
-            groupedFieldSet = fieldPLan.groupedFieldSet;
-            const newGroupedFieldSets = fieldPLan.newGroupedFieldSets;
+            const executionPlan = deduplicateDefers
+                ? (0, buildExecutionPlan_js_1.buildExecutionPlan)(groupedFieldSet)
+                : (0, buildExecutionPlan_js_1.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 ((0, utils_1.isPromise)(data)) {
@@ -292,7 +297,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
@@ -426,22 +432,32 @@ function buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path) {
     };
 }
 exports.buildResolveInfo = buildResolveInfo;
+exports.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 = (0, graphql_1.locatedError)((0, coerceError_js_1.coerceError)(rawError), toNodes(fieldGroup), (0, utils_1.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 ((0, graphql_1.isNonNullType)(returnType)) {
         throw error;
     }
+    if (error.extensions?.[exports.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_js_1.AccumulatorMap();
         context.errors = errors;
     }
-    errors.set(path, error);
+    errors.add(path, error);
 }
 /**
  * Implements the instructions for completeValue as defined in the
@@ -569,66 +585,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 = (0, utils_1.addPath)(path, index, undefined);
-        let iteration;
-        try {
-            iteration = await asyncIterator.next();
-        }
-        catch (rawError) {
-            throw (0, graphql_1.locatedError)((0, coerceError_js_1.coerceError)(rawError), toNodes(fieldGroup), (0, utils_1.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 ((0, utils_1.isPromise)(item)) {
-            completedResults.push(completePromisedListItemValue(item, exeContext, itemType, fieldGroup, info, itemPath, incrementalContext, deferMap));
-            containsPromise = true;
+            const itemPath = (0, utils_1.addPath)(path, index, undefined);
+            let iteration;
+            try {
+                iteration = await asyncIterator.next();
+            }
+            catch (rawError) {
+                throw (0, graphql_1.locatedError)((0, coerceError_js_1.coerceError)(rawError), toNodes(fieldGroup), (0, utils_1.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 ((0, utils_1.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)
@@ -842,28 +869,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
-        ? (0, buildFieldPlan_js_1.buildFieldPlan)(originalGroupedFieldSet, deferUsageSet)
-        : (0, buildFieldPlan_js_1.buildBranchingFieldPlan)(originalGroupedFieldSet, deferUsageSet);
-    originalGroupedFieldSet._fieldPlan = fieldPlan;
-    return fieldPlan;
+function buildSubExecutionPlan(originalGroupedFieldSet, deferUsageSet, deduplicateDefers) {
+    let executionPlan = originalGroupedFieldSet
+        ._executionPlan;
+    if (executionPlan !== undefined) {
+        return executionPlan;
+    }
+    executionPlan = deduplicateDefers
+        ? (0, buildExecutionPlan_js_1.buildExecutionPlan)(originalGroupedFieldSet, deferUsageSet)
+        : (0, buildExecutionPlan_js_1.buildBranchingExecutionPlan)(originalGroupedFieldSet, deferUsageSet);
+    originalGroupedFieldSet._executionPlan =
+        executionPlan;
+    return executionPlan;
 }
 /**
  * If a resolveType function is not given, then a default resolve behavior is
@@ -1005,13 +1034,18 @@ function mapSourceToResponse(exeContext, resultOrStream) {
     // "ExecuteSubscriptionEvent" algorithm, as it is nearly identical to the
     // "ExecuteQuery" algorithm, for which `execute` is also used.
     return (0, flattenAsyncIterable_js_1.flattenAsyncIterable)((0, utils_1.mapAsyncIterator)(resultOrStream[Symbol.asyncIterator](), async (payload) => ensureAsyncIterable(await executeOperation(buildPerEventExecutionContext(exeContext, payload))), (error) => {
-        const wrappedError = (0, utils_1.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 (0, utils_1.createGraphQLError)(error.message, {
+        originalError: error,
+        nodes: [operation],
+    });
+}
 function createSourceEventStreamImpl(exeContext) {
     try {
         const eventStream = executeSubscription(exeContext);
@@ -1087,40 +1121,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_js_1.BoxedPromiseOrValue(shouldDefer(parentDeferUsages, deferUsageSet)
+            pendingExecutionGroup.result = new BoxedPromiseOrValue_js_1.BoxedPromiseOrValue(shouldDefer(parentDeferUsages, deferUsageSet)
                 ? Promise.resolve().then(executor)
                 : executor());
         }
         else {
-            deferredGroupedFieldSetRecord.result = () => new BoxedPromiseOrValue_js_1.BoxedPromiseOrValue(executor());
+            pendingExecutionGroup.result = () => new BoxedPromiseOrValue_js_1.BoxedPromiseOrValue(executor());
             const resolveThunk = () => {
-                const maybeThunk = deferredGroupedFieldSetRecord.result;
+                const maybeThunk = pendingExecutionGroup.result;
                 if (!(maybeThunk instanceof BoxedPromiseOrValue_js_1.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.
@@ -1130,49 +1164,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: (0, utils_1.pathToArray)(path),
             errors: withError(incrementalContext.errors, error),
         };
     }
     if ((0, utils_1.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: (0, utils_1.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: (0, utils_1.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: (0, utils_1.pathToArray)(path),
             result: { data },
             incrementalDataRecords,
         };
     }
     return {
-        deferredGroupedFieldSetRecord,
+        pendingExecutionGroup,
         path: (0, utils_1.pathToArray)(path),
-        result: { data, errors: [...errors.values()] },
+        result: { data, errors: [...flattenErrors(errors)] },
         incrementalDataRecords: filterIncrementalDataRecords(path, errors, incrementalDataRecords),
     };
 }
@@ -1231,7 +1265,7 @@ async function getNextAsyncStreamItemResult(streamItemQueue, streamPath, index,
     catch (error) {
         return {
             path: streamPath,
-            errors: [(0, graphql_1.locatedError)(error, toNodes(fieldGroup), (0, utils_1.pathToArray)(streamPath))],
+            errors: [(0, graphql_1.locatedError)((0, coerceError_js_1.coerceError)(error), toNodes(fieldGroup), (0, utils_1.pathToArray)(streamPath))],
         };
     }
     if (iteration.done) {
@@ -1287,7 +1321,7 @@ function buildStreamItemResult(incrementalContext, streamPath, item) {
         return {
             path: streamPath,
             item,
-            errors: errors === undefined ? undefined : [...errors.values()],
+            errors: errors === undefined ? undefined : [...flattenErrors(errors)],
             incrementalDataRecords,
         };
     }
@@ -1302,7 +1336,7 @@ function buildStreamItemResult(incrementalContext, streamPath, item) {
     return {
         path: streamPath,
         item,
-        errors: [...errors.values()],
+        errors: [...flattenErrors(errors)],
         incrementalDataRecords: filterIncrementalDataRecords(streamPath, errors, incrementalDataRecords),
     };
 }

package/cjs/execution/types.js

@@ -1,26 +1,26 @@
 "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 */
 class DeferredFragmentRecord {
     path;
     label;
     id;
     parent;
-    deferredGroupedFieldSetRecords;
-    reconcilableResults;
+    pendingExecutionGroups;
+    successfulExecutionGroups;
     children;
     pending;
     fns;
@@ -28,8 +28,8 @@ 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 = [];
@@ -45,11 +45,11 @@ class DeferredFragmentRecord {
     }
 }
 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;