@graphql-tools/executor 4.0.2 → 4.1.0-alpha-20261020141228-0b45c008c3eb39b6b634293732537f794bfeef17

package/cjs/execution/execute.js

@@ -18,6 +18,7 @@ const disposablestack_1 = require("@whatwg-node/disposablestack");
 const promise_helpers_1 = require("@whatwg-node/promise-helpers");
 const coerceError_js_1 = require("./coerceError.js");
 const flattenAsyncIterable_js_1 = require("./flattenAsyncIterable.js");
+const incremental_js_1 = require("./incremental.js");
 const invariant_js_1 = require("./invariant.js");
 const promiseForObject_js_1 = require("./promiseForObject.js");
 const EMPTY_ARGS = Object.freeze(Object.create(null));
@@ -113,12 +114,16 @@ function executeImpl(exeContext) {
     return (0, promise_helpers_1.handleMaybePromise)(() => executeOperation(exeContext), data => {
         const initialResult = buildResponse(data, exeContext.errors);
         if (exeContext.subsequentPayloads.size > 0) {
+            const incrementalInitial = {
+                ...initialResult,
+                hasNext: true,
+            };
+            if (exeContext.incrementalSpec === 'v0.2') {
+                incrementalInitial.pending = (0, incremental_js_1.collectInitialPending)(exeContext);
+            }
             return {
-                initialResult: {
-                    ...initialResult,
-                    hasNext: true,
-                },
-                subsequentResults: yieldSubsequentPayloads(exeContext),
+                initialResult: incrementalInitial,
+                subsequentResults: (0, incremental_js_1.yieldSubsequentPayloads)(exeContext),
             };
         }
         return initialResult;
@@ -190,7 +195,7 @@ function getFragmentsFromDocument(document) {
  * @internal
  */
 function buildExecutionContext(args) {
-    const { schema, document, rootValue, contextValue, variableValues: rawVariableValues, operationName, fieldResolver, typeResolver, subscribeFieldResolver, signal, schemaCoordinateInErrors, hideSuggestions, } = args;
+    const { schema, document, rootValue, contextValue, variableValues: rawVariableValues, operationName, fieldResolver, typeResolver, subscribeFieldResolver, signal, schemaCoordinateInErrors, hideSuggestions, incrementalSpec = 'v0.1', } = args;
     signal?.throwIfAborted();
     // If the schema used for execution is invalid, throw an error.
     (0, graphql_1.assertValidSchema)(schema);
@@ -328,6 +333,8 @@ function buildExecutionContext(args) {
         typeResolver: typeResolver ?? exports.defaultTypeResolver,
         subscribeFieldResolver: subscribeFieldResolver ?? exports.defaultFieldResolver,
         subsequentPayloads: new Set(),
+        incrementalSpec,
+        publisher: incrementalSpec === 'v0.2' ? (0, incremental_js_1.createIncrementalPublisherState)() : undefined,
         errors: [],
         signal,
         getAbortSignal,
@@ -362,6 +369,8 @@ function buildPerEventExecutionContext(exeContext, payload) {
         typeResolver: exeContext.typeResolver,
         subscribeFieldResolver: exeContext.subscribeFieldResolver,
         subsequentPayloads: new Set(),
+        incrementalSpec: exeContext.incrementalSpec,
+        publisher: exeContext.incrementalSpec === 'v0.2' ? (0, incremental_js_1.createIncrementalPublisherState)() : undefined,
         errors: [],
         signal: exeContext.signal,
         getAbortSignal: exeContext.getAbortSignal,
@@ -399,8 +408,8 @@ function executeOperation(exeContext) {
         result = executeFields(exeContext, rootType, rootValue, path, rootFields);
     }
     for (const patch of patches) {
-        const { label, fields: patchFields } = patch;
-        executeDeferredFragment(exeContext, rootType, rootValue, patchFields, label, path);
+        const { label, fields: patchFields, patches: nestedPatches } = patch;
+        executeDeferredFragment(exeContext, rootType, rootValue, patchFields, label, path, undefined, nestedPatches);
     }
     return result;
 }
@@ -676,7 +685,12 @@ async function completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info
     let index = 0;
     while (true) {
         if (stream && typeof stream.initialCount === 'number' && index >= stream.initialCount) {
-            executeStreamIterator(index, iterator, exeContext, fieldNodes, info, itemType, path, stream.label, asyncPayloadRecord);
+            executeStreamIterator(index, iterator, exeContext, fieldNodes, info, itemType, path, stream.label, asyncPayloadRecord, (0, incremental_js_1.createStreamGroupIfV02)(exeContext, {
+                path,
+                label: stream.label,
+                parentContext: asyncPayloadRecord,
+                hasIterator: true,
+            }));
             break;
         }
         const itemPath = (0, utils_1.addPath)(path, index, undefined);
@@ -715,6 +729,7 @@ function completeListValue(exeContext, returnType, fieldNodes, info, path, resul
         throw new graphql_1.GraphQLError(`Expected Iterable, but did not find one for field "${info.parentType.name}.${info.fieldName}".`);
     }
     const stream = getStreamValues(exeContext, fieldNodes, path);
+    let streamGroup;
     // This is specified as a simple map, however we're optimizing the path
     // where the list contains no Promises by avoiding creating another Promise.
     let containsPromise = false;
@@ -726,7 +741,12 @@ function completeListValue(exeContext, returnType, fieldNodes, info, path, resul
         // since from here on it is not ever accessed by resolver functions.
         const itemPath = (0, utils_1.addPath)(path, index, undefined);
         if (stream && typeof stream.initialCount === 'number' && index >= stream.initialCount) {
-            previousAsyncPayloadRecord = executeStreamField(path, itemPath, item, exeContext, fieldNodes, info, itemType, stream.label, previousAsyncPayloadRecord);
+            streamGroup ??= (0, incremental_js_1.createStreamGroupIfV02)(exeContext, {
+                path,
+                label: stream.label,
+                parentContext: asyncPayloadRecord,
+            });
+            previousAsyncPayloadRecord = executeStreamField(path, itemPath, item, exeContext, fieldNodes, info, itemType, stream.label, previousAsyncPayloadRecord, streamGroup);
             index++;
             continue;
         }
@@ -868,8 +888,8 @@ function collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path, re
     const { fields: subFieldNodes, patches: subPatches } = collectSubfields(exeContext, returnType, fieldNodes);
     const subFields = executeFields(exeContext, returnType, result, path, subFieldNodes, asyncPayloadRecord);
     for (const subPatch of subPatches) {
-        const { label, fields: subPatchFieldNodes } = subPatch;
-        executeDeferredFragment(exeContext, returnType, result, subPatchFieldNodes, label, path, asyncPayloadRecord);
+        const { label, fields: subPatchFieldNodes, patches: nestedPatches } = subPatch;
+        executeDeferredFragment(exeContext, returnType, result, subPatchFieldNodes, label, path, asyncPayloadRecord, nestedPatches);
     }
     return subFields;
 }
@@ -1138,11 +1158,12 @@ function assertEventStream(result, signal, onSignalAbort) {
     }
     return result;
 }
-function executeDeferredFragment(exeContext, parentType, sourceValue, fields, label, path, parentContext) {
-    const asyncPayloadRecord = new DeferredFragmentRecord({
+function executeDeferredFragment(exeContext, parentType, sourceValue, fields, label, path, parentContext, nestedPatches, deliveryParent) {
+    const asyncPayloadRecord = new incremental_js_1.DeferredFragmentRecord({
         label,
         path,
         parentContext,
+        deliveryParent: deliveryParent ?? parentContext,
         exeContext,
     });
     let promiseOrData;
@@ -1160,13 +1181,21 @@ function executeDeferredFragment(exeContext, parentType, sourceValue, fields, la
         promiseOrData = null;
     }
     asyncPayloadRecord.addData(promiseOrData);
+    if (nestedPatches) {
+        for (const nested of nestedPatches) {
+            executeDeferredFragment(exeContext, parentType, sourceValue, nested.fields, nested.label, path, 
+            // Keep v0.1 sibling completion; v0.2 pending still nests via deliveryParent.
+            parentContext, nested.patches, asyncPayloadRecord);
+        }
+    }
 }
-function executeStreamField(path, itemPath, item, exeContext, fieldNodes, info, itemType, label, parentContext) {
-    const asyncPayloadRecord = new StreamRecord({
+function executeStreamField(path, itemPath, item, exeContext, fieldNodes, info, itemType, label, parentContext, streamGroup) {
+    const asyncPayloadRecord = new incremental_js_1.StreamRecord({
         label,
         path: itemPath,
         parentContext,
         exeContext,
+        streamGroup,
     });
     let completedItem;
     try {
@@ -1230,7 +1259,11 @@ async function executeStreamIteratorItem(iterator, exeContext, fieldNodes, info,
         const coercedError = (0, coerceError_js_1.coerceError)(rawError);
         const error = (0, utils_1.locatedError)(coercedError, fieldNodes, (0, utils_1.pathToArray)(itemPath), exeContext.schemaCoordinateInErrors && info);
         const value = handleFieldError(error, itemType, asyncPayloadRecord.errors);
-        // don't continue if iterator throws
+        // Mark the group complete without isCompletedIterator, so the error item
+        // is still published. Don't continue if iterator throws.
+        if (asyncPayloadRecord.streamGroup) {
+            asyncPayloadRecord.streamGroup.iteratorCompleted = true;
+        }
         return { done: true, value };
     }
     let completedItem;
@@ -1253,17 +1286,18 @@ async function executeStreamIteratorItem(iterator, exeContext, fieldNodes, info,
         return { done: false, value };
     }
 }
-async function executeStreamIterator(initialIndex, iterator, exeContext, fieldNodes, info, itemType, path, label, parentContext) {
+async function executeStreamIterator(initialIndex, iterator, exeContext, fieldNodes, info, itemType, path, label, parentContext, streamGroup) {
     let index = initialIndex;
     let previousAsyncPayloadRecord = parentContext ?? undefined;
     while (true) {
         const itemPath = (0, utils_1.addPath)(path, index, undefined);
-        const asyncPayloadRecord = new StreamRecord({
+        const asyncPayloadRecord = new incremental_js_1.StreamRecord({
             label,
             path: itemPath,
             parentContext: previousAsyncPayloadRecord,
             iterator,
             exeContext,
+            streamGroup,
         });
         let iteration;
         try {
@@ -1271,6 +1305,9 @@ async function executeStreamIterator(initialIndex, iterator, exeContext, fieldNo
         }
         catch (error) {
             asyncPayloadRecord.errors.push(error);
+            if (streamGroup) {
+                streamGroup.iteratorCompleted = true;
+            }
             filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
             asyncPayloadRecord.addItems(null);
             // entire stream has errored and bubbled upwards
@@ -1315,193 +1352,14 @@ function filterSubsequentPayloads(exeContext, nullPath, currentAsyncRecord) {
             }
         }
         // asyncRecord path points to nulled error field
-        if (isStreamPayload(asyncRecord) && asyncRecord.iterator?.return) {
+        if ((0, incremental_js_1.isStreamPayload)(asyncRecord) && asyncRecord.iterator?.return) {
             asyncRecord.iterator.return().catch(() => {
                 // ignore error
             });
         }
-        exeContext.subsequentPayloads.delete(asyncRecord);
+        (0, incremental_js_1.deleteAsyncPayload)(exeContext, asyncRecord);
     });
 }
-function getCompletedIncrementalResults(exeContext) {
-    const incrementalResults = [];
-    for (const asyncPayloadRecord of exeContext.subsequentPayloads) {
-        const incrementalResult = {};
-        if (!asyncPayloadRecord.isCompleted) {
-            continue;
-        }
-        exeContext.subsequentPayloads.delete(asyncPayloadRecord);
-        if (isStreamPayload(asyncPayloadRecord)) {
-            const items = asyncPayloadRecord.items;
-            if (asyncPayloadRecord.isCompletedIterator) {
-                // async iterable resolver just finished but there may be pending payloads
-                continue;
-            }
-            incrementalResult.items = items;
-        }
-        else {
-            const data = asyncPayloadRecord.data;
-            incrementalResult.data = data ?? null;
-        }
-        incrementalResult.path = asyncPayloadRecord.path;
-        if (asyncPayloadRecord.label) {
-            incrementalResult.label = asyncPayloadRecord.label;
-        }
-        if (asyncPayloadRecord.errors.length > 0) {
-            incrementalResult.errors = asyncPayloadRecord.errors;
-        }
-        incrementalResults.push(incrementalResult);
-    }
-    return incrementalResults;
-}
-function yieldSubsequentPayloads(exeContext) {
-    let isDone = false;
-    async function next() {
-        if (isDone) {
-            return { value: undefined, done: true };
-        }
-        const subSequentPayloadPromises = Array.from(exeContext.subsequentPayloads).map(record => record.promise);
-        if (exeContext.signalPromise) {
-            await Promise.race([exeContext.signalPromise, ...subSequentPayloadPromises]);
-        }
-        else {
-            await Promise.race(subSequentPayloadPromises);
-        }
-        if (isDone) {
-            // a different call to next has exhausted all payloads
-            return { value: undefined, done: true };
-        }
-        const incremental = getCompletedIncrementalResults(exeContext);
-        const hasNext = exeContext.subsequentPayloads.size > 0;
-        if (!incremental.length && hasNext) {
-            return next();
-        }
-        if (!hasNext) {
-            isDone = true;
-        }
-        return {
-            value: incremental.length ? { incremental, hasNext } : { hasNext },
-            done: false,
-        };
-    }
-    function returnStreamIterators() {
-        const promises = [];
-        exeContext.subsequentPayloads.forEach(asyncPayloadRecord => {
-            if (isStreamPayload(asyncPayloadRecord) && asyncPayloadRecord.iterator?.return) {
-                promises.push(asyncPayloadRecord.iterator.return());
-            }
-        });
-        return Promise.all(promises);
-    }
-    return {
-        [Symbol.asyncIterator]() {
-            return this;
-        },
-        next,
-        async return() {
-            await returnStreamIterators();
-            isDone = true;
-            return { value: undefined, done: true };
-        },
-        async throw(error) {
-            await returnStreamIterators();
-            isDone = true;
-            throw error;
-        },
-        async [disposablestack_1.DisposableSymbols.asyncDispose]() {
-            await returnStreamIterators();
-            isDone = true;
-        },
-    };
-}
-class DeferredFragmentRecord {
-    type;
-    errors;
-    label;
-    path;
-    promise;
-    data;
-    parentContext;
-    isCompleted;
-    _exeContext;
-    _resolve;
-    constructor(opts) {
-        this.type = 'defer';
-        this.label = opts.label;
-        this.path = (0, utils_1.pathToArray)(opts.path);
-        this.parentContext = opts.parentContext;
-        this.errors = [];
-        this._exeContext = opts.exeContext;
-        this._exeContext.subsequentPayloads.add(this);
-        this.isCompleted = false;
-        this.data = null;
-        this.promise = new Promise(resolve => {
-            this._resolve = MaybePromise => {
-                resolve(MaybePromise);
-            };
-        }).then(data => {
-            this.data = data;
-            this.isCompleted = true;
-        });
-    }
-    addData(data) {
-        const parentData = this.parentContext?.promise;
-        if (parentData) {
-            this._resolve?.(parentData.then(() => data));
-            return;
-        }
-        this._resolve?.(data);
-    }
-}
-class StreamRecord {
-    type;
-    errors;
-    label;
-    path;
-    items;
-    promise;
-    parentContext;
-    iterator;
-    isCompletedIterator;
-    isCompleted;
-    _exeContext;
-    _resolve;
-    constructor(opts) {
-        this.type = 'stream';
-        this.items = null;
-        this.label = opts.label;
-        this.path = (0, utils_1.pathToArray)(opts.path);
-        this.parentContext = opts.parentContext;
-        this.iterator = opts.iterator;
-        this.errors = [];
-        this._exeContext = opts.exeContext;
-        this._exeContext.subsequentPayloads.add(this);
-        this.isCompleted = false;
-        this.items = null;
-        this.promise = new Promise(resolve => {
-            this._resolve = MaybePromise => {
-                resolve(MaybePromise);
-            };
-        }).then(items => {
-            this.items = items;
-            this.isCompleted = true;
-        });
-    }
-    addItems(items) {
-        const parentData = this.parentContext?.promise;
-        if (parentData) {
-            this._resolve?.(parentData.then(() => items));
-            return;
-        }
-        this._resolve?.(items);
-    }
-    setIsCompletedIterator() {
-        this.isCompletedIterator = true;
-    }
-}
-function isStreamPayload(asyncPayload) {
-    return asyncPayload.type === 'stream';
-}
 /**
  * This method looks up the field on the given type definition.
  * It has special casing for the three introspection fields,