@graphql-tools/executor 1.2.6 → 2.0.0-alpha-20240606144658-8963c8b8f661638eaee0e101a55f3b6e46cc03ff

package/cjs/execution/getBySet.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBySet = void 0;
+const isSameSet_js_1 = require("./isSameSet.js");
+function getBySet(map, setToMatch) {
+    for (const set of map.keys()) {
+        if ((0, isSameSet_js_1.isSameSet)(set, setToMatch)) {
+            return map.get(set);
+        }
+    }
+    return undefined;
+}
+exports.getBySet = getBySet;

package/cjs/execution/isSameSet.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSameSet = void 0;
+function isSameSet(setA, setB) {
+    if (setA.size !== setB.size) {
+        return false;
+    }
+    for (const item of setA) {
+        if (!setB.has(item)) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.isSameSet = isSameSet;

package/cjs/execution/promiseWithResolvers.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseWithResolvers = void 0;
+/**
+ * Based on Promise.withResolvers proposal
+ * https://github.com/tc39/proposal-promise-with-resolvers
+ */
+function promiseWithResolvers() {
+    // these are assigned synchronously within the Promise constructor
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+exports.promiseWithResolvers = promiseWithResolvers;

package/cjs/execution/types.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCancellableStreamRecord = exports.isNonReconcilableDeferredGroupedFieldSetResult = exports.isDeferredGroupedFieldSetResult = exports.isDeferredGroupedFieldSetRecord = void 0;
+function isDeferredGroupedFieldSetRecord(incrementalDataRecord) {
+    return 'deferredFragmentRecords' in incrementalDataRecord;
+}
+exports.isDeferredGroupedFieldSetRecord = isDeferredGroupedFieldSetRecord;
+function isDeferredGroupedFieldSetResult(subsequentResult) {
+    return 'deferredGroupedFieldSetRecord' in subsequentResult;
+}
+exports.isDeferredGroupedFieldSetResult = isDeferredGroupedFieldSetResult;
+function isNonReconcilableDeferredGroupedFieldSetResult(deferredGroupedFieldSetResult) {
+    return deferredGroupedFieldSetResult.errors !== undefined;
+}
+exports.isNonReconcilableDeferredGroupedFieldSetResult = isNonReconcilableDeferredGroupedFieldSetResult;
+function isCancellableStreamRecord(subsequentResultRecord) {
+    return 'earlyReturn' in subsequentResultRecord;
+}
+exports.isCancellableStreamRecord = isCancellableStreamRecord;

package/esm/execution/AccumulatorMap.js

@@ -0,0 +1,17 @@
+/**
+ * ES6 Map with additional `add` method to accumulate items.
+ */
+export class AccumulatorMap extends Map {
+    get [Symbol.toStringTag]() {
+        return 'AccumulatorMap';
+    }
+    add(key, item) {
+        const group = this.get(key);
+        if (group === undefined) {
+            this.set(key, [item]);
+        }
+        else {
+            group.push(item);
+        }
+    }
+}

package/esm/execution/BoxedPromiseOrValue.js

@@ -0,0 +1,21 @@
+import { isPromise } from '@graphql-tools/utils';
+/**
+ * A BoxedPromiseOrValue is a container for a value or promise where the value
+ * will be updated when the promise resolves.
+ *
+ * A BoxedPromiseOrValue may only be used with promises whose possible
+ * rejection has already been handled, otherwise this will lead to unhandled
+ * promise rejections.
+ *
+ * @internal
+ * */
+export class BoxedPromiseOrValue {
+    constructor(value) {
+        this.value = value;
+        if (isPromise(value)) {
+            value.then(resolved => {
+                this.value = resolved;
+            });
+        }
+    }
+}

package/esm/execution/IncrementalGraph.js

@@ -0,0 +1,267 @@
+import { isPromise } from '@graphql-tools/utils';
+import { BoxedPromiseOrValue } from './BoxedPromiseOrValue.js';
+import { promiseWithResolvers } from './promiseWithResolvers.js';
+import { isDeferredGroupedFieldSetRecord } from './types.js';
+function isDeferredFragmentNode(node) {
+    return node !== undefined;
+}
+function isStreamNode(record) {
+    return 'streamItemQueue' in record;
+}
+/**
+ * @internal
+ */
+export class IncrementalGraph {
+    constructor() {
+        this._pending = new Set();
+        this._deferredFragmentNodes = new Map();
+        this._newIncrementalDataRecords = new Set();
+        this._newPending = new Set();
+        this._completedQueue = [];
+        this._nextQueue = [];
+    }
+    addIncrementalDataRecords(incrementalDataRecords) {
+        for (const incrementalDataRecord of incrementalDataRecords) {
+            if (isDeferredGroupedFieldSetRecord(incrementalDataRecord)) {
+                this._addDeferredGroupedFieldSetRecord(incrementalDataRecord);
+            }
+            else {
+                this._addStreamRecord(incrementalDataRecord);
+            }
+        }
+    }
+    addCompletedReconcilableDeferredGroupedFieldSet(reconcilableResult) {
+        const deferredFragmentNodes = reconcilableResult.deferredGroupedFieldSetRecord.deferredFragmentRecords
+            .map(deferredFragmentRecord => this._deferredFragmentNodes.get(deferredFragmentRecord))
+            .filter(isDeferredFragmentNode);
+        for (const deferredFragmentNode of deferredFragmentNodes) {
+            deferredFragmentNode.deferredGroupedFieldSetRecords.delete(reconcilableResult.deferredGroupedFieldSetRecord);
+            deferredFragmentNode.reconcilableResults.add(reconcilableResult);
+        }
+    }
+    getNewPending() {
+        const newPending = [];
+        for (const node of this._newPending) {
+            if (isStreamNode(node)) {
+                this._pending.add(node);
+                newPending.push(node);
+                this._newIncrementalDataRecords.add(node);
+            }
+            else if (node.deferredGroupedFieldSetRecords.size > 0) {
+                for (const deferredGroupedFieldSetNode of node.deferredGroupedFieldSetRecords) {
+                    this._newIncrementalDataRecords.add(deferredGroupedFieldSetNode);
+                }
+                this._pending.add(node);
+                newPending.push(node.deferredFragmentRecord);
+            }
+            else {
+                for (const child of node.children) {
+                    this._newPending.add(child);
+                }
+            }
+        }
+        this._newPending.clear();
+        for (const incrementalDataRecord of this._newIncrementalDataRecords) {
+            if (isStreamNode(incrementalDataRecord)) {
+                this._onStreamItems(incrementalDataRecord, incrementalDataRecord.streamItemQueue);
+            }
+            else {
+                const deferredGroupedFieldSetResult = incrementalDataRecord.result;
+                const result = deferredGroupedFieldSetResult instanceof BoxedPromiseOrValue
+                    ? deferredGroupedFieldSetResult.value
+                    : deferredGroupedFieldSetResult().value;
+                if (isPromise(result)) {
+                    result.then(resolved => this._enqueue(resolved));
+                }
+                else {
+                    this._enqueue(result);
+                }
+            }
+        }
+        this._newIncrementalDataRecords.clear();
+        return newPending;
+    }
+    completedIncrementalData() {
+        return {
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+            next: () => {
+                const firstResult = this._completedQueue.shift();
+                if (firstResult !== undefined) {
+                    return Promise.resolve({
+                        value: this._yieldCurrentCompletedIncrementalData(firstResult),
+                        done: false,
+                    });
+                }
+                const { promise, resolve } = promiseWithResolvers();
+                this._nextQueue.push(resolve);
+                return promise;
+            },
+            return: () => {
+                for (const resolve of this._nextQueue) {
+                    resolve({ value: undefined, done: true });
+                }
+                return Promise.resolve({ value: undefined, done: true });
+            },
+        };
+    }
+    hasNext() {
+        return this._pending.size > 0;
+    }
+    completeDeferredFragment(deferredFragmentRecord) {
+        const deferredFragmentNode = this._deferredFragmentNodes.get(deferredFragmentRecord);
+        // TODO: add test case?
+        /* c8 ignore next 3 */
+        if (deferredFragmentNode === undefined) {
+            return undefined;
+        }
+        if (deferredFragmentNode.deferredGroupedFieldSetRecords.size > 0) {
+            return;
+        }
+        const reconcilableResults = Array.from(deferredFragmentNode.reconcilableResults);
+        for (const reconcilableResult of reconcilableResults) {
+            for (const otherDeferredFragmentRecord of reconcilableResult.deferredGroupedFieldSetRecord
+                .deferredFragmentRecords) {
+                const otherDeferredFragmentNode = this._deferredFragmentNodes.get(otherDeferredFragmentRecord);
+                if (otherDeferredFragmentNode === undefined) {
+                    continue;
+                }
+                otherDeferredFragmentNode.reconcilableResults.delete(reconcilableResult);
+            }
+        }
+        this._removePending(deferredFragmentNode);
+        for (const child of deferredFragmentNode.children) {
+            this._newPending.add(child);
+        }
+        return reconcilableResults;
+    }
+    removeDeferredFragment(deferredFragmentRecord) {
+        const deferredFragmentNode = this._deferredFragmentNodes.get(deferredFragmentRecord);
+        if (deferredFragmentNode === undefined) {
+            return false;
+        }
+        this._removePending(deferredFragmentNode);
+        this._deferredFragmentNodes.delete(deferredFragmentRecord);
+        // TODO: add test case for an erroring deferred fragment with child defers
+        /* c8 ignore next 3 */
+        for (const child of deferredFragmentNode.children) {
+            this.removeDeferredFragment(child.deferredFragmentRecord);
+        }
+        return true;
+    }
+    removeStream(streamRecord) {
+        this._removePending(streamRecord);
+    }
+    _removePending(subsequentResultNode) {
+        this._pending.delete(subsequentResultNode);
+        if (this._pending.size === 0) {
+            for (const resolve of this._nextQueue) {
+                resolve({ value: undefined, done: true });
+            }
+        }
+    }
+    _addDeferredGroupedFieldSetRecord(deferredGroupedFieldSetRecord) {
+        for (const deferredFragmentRecord of deferredGroupedFieldSetRecord.deferredFragmentRecords) {
+            const deferredFragmentNode = this._addDeferredFragmentNode(deferredFragmentRecord);
+            if (this._pending.has(deferredFragmentNode)) {
+                this._newIncrementalDataRecords.add(deferredGroupedFieldSetRecord);
+            }
+            deferredFragmentNode.deferredGroupedFieldSetRecords.add(deferredGroupedFieldSetRecord);
+        }
+    }
+    _addStreamRecord(streamRecord) {
+        this._newPending.add(streamRecord);
+    }
+    _addDeferredFragmentNode(deferredFragmentRecord) {
+        let deferredFragmentNode = this._deferredFragmentNodes.get(deferredFragmentRecord);
+        if (deferredFragmentNode !== undefined) {
+            return deferredFragmentNode;
+        }
+        deferredFragmentNode = {
+            deferredFragmentRecord,
+            deferredGroupedFieldSetRecords: new Set(),
+            reconcilableResults: new Set(),
+            children: [],
+        };
+        this._deferredFragmentNodes.set(deferredFragmentRecord, deferredFragmentNode);
+        const parent = deferredFragmentRecord.parent;
+        if (parent === undefined) {
+            this._newPending.add(deferredFragmentNode);
+            return deferredFragmentNode;
+        }
+        const parentNode = this._addDeferredFragmentNode(parent);
+        parentNode.children.push(deferredFragmentNode);
+        return deferredFragmentNode;
+    }
+    async _onStreamItems(streamRecord, streamItemQueue) {
+        let items = [];
+        let errors = [];
+        let incrementalDataRecords = [];
+        let streamItemRecord;
+        while ((streamItemRecord = streamItemQueue.shift()) !== undefined) {
+            let result = typeof streamItemRecord === 'function' ? streamItemRecord().value : streamItemRecord.value;
+            if (isPromise(result)) {
+                if (items.length > 0) {
+                    this._enqueue({
+                        streamRecord,
+                        result: 
+                        // TODO add additional test case or rework for coverage
+                        errors.length > 0 /* c8 ignore start */
+                            ? { items, errors } /* c8 ignore stop */
+                            : { items },
+                        incrementalDataRecords,
+                    });
+                    items = [];
+                    errors = [];
+                    incrementalDataRecords = [];
+                }
+                result = await result;
+                // wait an additional tick to coalesce resolving additional promises
+                // within the queue
+                await Promise.resolve();
+            }
+            if (result.item === undefined) {
+                if (items.length > 0) {
+                    this._enqueue({
+                        streamRecord,
+                        result: errors.length > 0 ? { items, errors } : { items },
+                        incrementalDataRecords,
+                    });
+                }
+                this._enqueue(result.errors === undefined
+                    ? { streamRecord }
+                    : {
+                        streamRecord,
+                        errors: result.errors,
+                    });
+                return;
+            }
+            items.push(result.item);
+            if (result.errors !== undefined) {
+                errors.push(...result.errors);
+            }
+            if (result.incrementalDataRecords !== undefined) {
+                incrementalDataRecords.push(...result.incrementalDataRecords);
+            }
+        }
+    }
+    *_yieldCurrentCompletedIncrementalData(first) {
+        yield first;
+        let completed;
+        while ((completed = this._completedQueue.shift()) !== undefined) {
+            yield completed;
+        }
+    }
+    _enqueue(completed) {
+        const next = this._nextQueue.shift();
+        if (next !== undefined) {
+            next({
+                value: this._yieldCurrentCompletedIncrementalData(completed),
+                done: false,
+            });
+            return;
+        }
+        this._completedQueue.push(completed);
+    }
+}

package/esm/execution/IncrementalPublisher.js

@@ -0,0 +1,270 @@
+import { pathToArray } from '@graphql-tools/utils';
+import { IncrementalGraph } from './IncrementalGraph.js';
+import { invariant } from './invariant.js';
+import { isCancellableStreamRecord, isDeferredGroupedFieldSetResult, isNonReconcilableDeferredGroupedFieldSetResult, } from './types.js';
+export function buildIncrementalResponse(context, result, errors, incrementalDataRecords) {
+    const incrementalPublisher = new IncrementalPublisher(context);
+    return incrementalPublisher.buildResponse(result, errors, incrementalDataRecords);
+}
+/**
+ * This class is used to publish incremental results to the client, enabling semi-concurrent
+ * execution while preserving result order.
+ *
+ * @internal
+ */
+class IncrementalPublisher {
+    constructor(context) {
+        this._context = context;
+        this._nextId = 0;
+        this._incrementalGraph = new IncrementalGraph();
+    }
+    buildResponse(data, errors, incrementalDataRecords) {
+        this._incrementalGraph.addIncrementalDataRecords(incrementalDataRecords);
+        const newPending = this._incrementalGraph.getNewPending();
+        const pending = this._pendingSourcesToResults(newPending);
+        const initialResult = errors === undefined
+            ? { data, pending, hasNext: true }
+            : { errors, data, pending, hasNext: true };
+        return {
+            initialResult,
+            subsequentResults: this._subscribe(),
+        };
+    }
+    _pendingSourcesToResults(newPending) {
+        const pendingResults = [];
+        for (const pendingSource of newPending) {
+            const id = String(this._getNextId());
+            pendingSource.id = id;
+            const pendingResult = {
+                id,
+                path: pathToArray(pendingSource.path),
+            };
+            if (pendingSource.label !== undefined) {
+                pendingResult.label = pendingSource.label;
+            }
+            pendingResults.push(pendingResult);
+        }
+        return pendingResults;
+    }
+    _getNextId() {
+        return String(this._nextId++);
+    }
+    _subscribe() {
+        let isDone = false;
+        this._context.signal?.addEventListener('abort', () => {
+            isDone = true;
+        });
+        const _next = async () => {
+            if (isDone) {
+                await this._returnAsyncIteratorsIgnoringErrors();
+                return { value: undefined, done: true };
+            }
+            const context = {
+                pending: [],
+                incremental: [],
+                completed: [],
+            };
+            const completedIncrementalData = this._incrementalGraph.completedIncrementalData();
+            // use the raw iterator rather than 'for await ... of' so as not to trigger the
+            // '.return()' method on the iterator when exiting the loop with the next value
+            const asyncIterator = completedIncrementalData[Symbol.asyncIterator]();
+            let iteration = await asyncIterator.next();
+            while (!iteration.done) {
+                if (this._context.signal?.aborted) {
+                    throw this._context.signal.reason;
+                }
+                for (const completedResult of iteration.value) {
+                    this._handleCompletedIncrementalData(completedResult, context);
+                }
+                const { incremental, completed } = context;
+                if (incremental.length > 0 || completed.length > 0) {
+                    const hasNext = this._incrementalGraph.hasNext();
+                    if (!hasNext) {
+                        isDone = true;
+                    }
+                    const subsequentIncrementalExecutionResult = {
+                        hasNext,
+                    };
+                    const pending = context.pending;
+                    if (pending.length > 0) {
+                        subsequentIncrementalExecutionResult.pending = pending;
+                    }
+                    if (incremental.length > 0) {
+                        subsequentIncrementalExecutionResult.incremental = incremental;
+                    }
+                    if (completed.length > 0) {
+                        subsequentIncrementalExecutionResult.completed = completed;
+                    }
+                    return { value: subsequentIncrementalExecutionResult, done: false };
+                }
+                iteration = await asyncIterator.next();
+            }
+            await this._returnAsyncIteratorsIgnoringErrors();
+            return { value: undefined, done: true };
+        };
+        const _return = async () => {
+            isDone = true;
+            await this._returnAsyncIterators();
+            return { value: undefined, done: true };
+        };
+        const _throw = async (error) => {
+            isDone = true;
+            await this._returnAsyncIterators();
+            return Promise.reject(error);
+        };
+        return {
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+            next: _next,
+            return: _return,
+            throw: _throw,
+        };
+    }
+    _handleCompletedIncrementalData(completedIncrementalData, context) {
+        if (isDeferredGroupedFieldSetResult(completedIncrementalData)) {
+            this._handleCompletedDeferredGroupedFieldSet(completedIncrementalData, context);
+        }
+        else {
+            this._handleCompletedStreamItems(completedIncrementalData, context);
+        }
+        const newPending = this._incrementalGraph.getNewPending();
+        context.pending.push(...this._pendingSourcesToResults(newPending));
+    }
+    _handleCompletedDeferredGroupedFieldSet(deferredGroupedFieldSetResult, context) {
+        if (isNonReconcilableDeferredGroupedFieldSetResult(deferredGroupedFieldSetResult)) {
+            for (const deferredFragmentRecord of deferredGroupedFieldSetResult
+                .deferredGroupedFieldSetRecord.deferredFragmentRecords) {
+                const id = deferredFragmentRecord.id;
+                if (!this._incrementalGraph.removeDeferredFragment(deferredFragmentRecord)) {
+                    // This can occur if multiple deferred grouped field sets error for a fragment.
+                    continue;
+                }
+                invariant(id !== undefined);
+                context.completed.push({
+                    id,
+                    errors: deferredGroupedFieldSetResult.errors,
+                });
+                this._incrementalGraph.removeDeferredFragment(deferredFragmentRecord);
+            }
+            return;
+        }
+        this._incrementalGraph.addCompletedReconcilableDeferredGroupedFieldSet(deferredGroupedFieldSetResult);
+        const incrementalDataRecords = deferredGroupedFieldSetResult.incrementalDataRecords;
+        if (incrementalDataRecords !== undefined) {
+            this._incrementalGraph.addIncrementalDataRecords(incrementalDataRecords);
+        }
+        for (const deferredFragmentRecord of deferredGroupedFieldSetResult.deferredGroupedFieldSetRecord
+            .deferredFragmentRecords) {
+            const id = deferredFragmentRecord.id;
+            // TODO: add test case for this.
+            // Presumably, this can occur if an error causes a fragment to be completed early,
+            // while an asynchronous deferred grouped field set result is enqueued.
+            /* c8 ignore next 3 */
+            if (id === undefined) {
+                continue;
+            }
+            const reconcilableResults = this._incrementalGraph.completeDeferredFragment(deferredFragmentRecord);
+            if (reconcilableResults === undefined) {
+                continue;
+            }
+            const incremental = context.incremental;
+            for (const reconcilableResult of reconcilableResults) {
+                const { bestId, subPath } = this._getBestIdAndSubPath(id, deferredFragmentRecord, reconcilableResult);
+                const incrementalEntry = {
+                    ...reconcilableResult.result,
+                    id: bestId,
+                };
+                if (subPath !== undefined) {
+                    incrementalEntry.subPath = subPath;
+                }
+                incremental.push(incrementalEntry);
+            }
+            context.completed.push({ id });
+        }
+    }
+    _handleCompletedStreamItems(streamItemsResult, context) {
+        const streamRecord = streamItemsResult.streamRecord;
+        const id = streamRecord.id;
+        invariant(id !== undefined);
+        if (streamItemsResult.errors !== undefined) {
+            context.completed.push({
+                id,
+                errors: streamItemsResult.errors,
+            });
+            this._incrementalGraph.removeStream(streamRecord);
+            if (isCancellableStreamRecord(streamRecord)) {
+                invariant(this._context.cancellableStreams !== undefined);
+                this._context.cancellableStreams.delete(streamRecord);
+                streamRecord.earlyReturn().catch(() => {
+                    /* c8 ignore next 1 */
+                    // ignore error
+                });
+            }
+        }
+        else if (streamItemsResult.result === undefined) {
+            context.completed.push({ id });
+            this._incrementalGraph.removeStream(streamRecord);
+            if (isCancellableStreamRecord(streamRecord)) {
+                invariant(this._context.cancellableStreams !== undefined);
+                this._context.cancellableStreams.delete(streamRecord);
+            }
+        }
+        else {
+            const incrementalEntry = {
+                id,
+                ...streamItemsResult.result,
+            };
+            context.incremental.push(incrementalEntry);
+            if (streamItemsResult.incrementalDataRecords !== undefined) {
+                this._incrementalGraph.addIncrementalDataRecords(streamItemsResult.incrementalDataRecords);
+            }
+        }
+    }
+    _getBestIdAndSubPath(initialId, initialDeferredFragmentRecord, deferredGroupedFieldSetResult) {
+        let maxLength = pathToArray(initialDeferredFragmentRecord.path).length;
+        let bestId = initialId;
+        for (const deferredFragmentRecord of deferredGroupedFieldSetResult.deferredGroupedFieldSetRecord
+            .deferredFragmentRecords) {
+            if (deferredFragmentRecord === initialDeferredFragmentRecord) {
+                continue;
+            }
+            const id = deferredFragmentRecord.id;
+            // TODO: add test case for when an fragment has not been released, but might be processed for the shortest path.
+            /* c8 ignore next 3 */
+            if (id === undefined) {
+                continue;
+            }
+            const fragmentPath = pathToArray(deferredFragmentRecord.path);
+            const length = fragmentPath.length;
+            if (length > maxLength) {
+                maxLength = length;
+                bestId = id;
+            }
+        }
+        const subPath = deferredGroupedFieldSetResult.path.slice(maxLength);
+        return {
+            bestId,
+            subPath: subPath.length > 0 ? subPath : undefined,
+        };
+    }
+    async _returnAsyncIterators() {
+        await this._incrementalGraph.completedIncrementalData().return();
+        const cancellableStreams = this._context.cancellableStreams;
+        if (cancellableStreams === undefined) {
+            return;
+        }
+        const promises = [];
+        for (const streamRecord of cancellableStreams) {
+            if (streamRecord.earlyReturn !== undefined) {
+                promises.push(streamRecord.earlyReturn());
+            }
+        }
+        await Promise.all(promises);
+    }
+    async _returnAsyncIteratorsIgnoringErrors() {
+        await this._returnAsyncIterators().catch(() => {
+            // Ignore errors
+        });
+    }
+}