@graphql-tools/executor 1.2.6 → 2.0.0-alpha-20240606221026-cd2a4fabe51906319f8dc07745f98f37ffbcbdee

package/cjs/execution/AccumulatorMap.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccumulatorMap = void 0;
+/**
+ * ES6 Map with additional `add` method to accumulate items.
+ */
+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);
+        }
+    }
+}
+exports.AccumulatorMap = AccumulatorMap;

package/cjs/execution/BoxedPromiseOrValue.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoxedPromiseOrValue = void 0;
+const utils_1 = require("@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
+ * */
+class BoxedPromiseOrValue {
+    constructor(value) {
+        this.value = value;
+        if ((0, utils_1.isPromise)(value)) {
+            value.then(resolved => {
+                this.value = resolved;
+            });
+        }
+    }
+}
+exports.BoxedPromiseOrValue = BoxedPromiseOrValue;

package/cjs/execution/IncrementalGraph.js

@@ -0,0 +1,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncrementalGraph = void 0;
+const utils_1 = require("@graphql-tools/utils");
+const BoxedPromiseOrValue_js_1 = require("./BoxedPromiseOrValue.js");
+const promiseWithResolvers_js_1 = require("./promiseWithResolvers.js");
+const types_js_1 = require("./types.js");
+function isDeferredFragmentNode(node) {
+    return node !== undefined;
+}
+function isStreamNode(record) {
+    return 'streamItemQueue' in record;
+}
+/**
+ * @internal
+ */
+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 ((0, types_js_1.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_js_1.BoxedPromiseOrValue
+                    ? deferredGroupedFieldSetResult.value
+                    : deferredGroupedFieldSetResult().value;
+                if ((0, utils_1.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 } = (0, promiseWithResolvers_js_1.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 ((0, utils_1.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);
+    }
+}
+exports.IncrementalGraph = IncrementalGraph;

package/cjs/execution/IncrementalPublisher.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildIncrementalResponse = void 0;
+const utils_1 = require("@graphql-tools/utils");
+const IncrementalGraph_js_1 = require("./IncrementalGraph.js");
+const invariant_js_1 = require("./invariant.js");
+const types_js_1 = require("./types.js");
+function buildIncrementalResponse(context, result, errors, incrementalDataRecords) {
+    const incrementalPublisher = new IncrementalPublisher(context);
+    return incrementalPublisher.buildResponse(result, errors, incrementalDataRecords);
+}
+exports.buildIncrementalResponse = buildIncrementalResponse;
+/**
+ * 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_js_1.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: (0, utils_1.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', () => {
+            this._incrementalGraph.completedIncrementalData().return();
+        });
+        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) {
+                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();
+            }
+            if (this._context.signal?.aborted) {
+                throw this._context.signal.reason;
+            }
+            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 ((0, types_js_1.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 ((0, types_js_1.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;
+                }
+                (0, invariant_js_1.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;
+        (0, invariant_js_1.invariant)(id !== undefined);
+        if (streamItemsResult.errors !== undefined) {
+            context.completed.push({
+                id,
+                errors: streamItemsResult.errors,
+            });
+            this._incrementalGraph.removeStream(streamRecord);
+            if ((0, types_js_1.isCancellableStreamRecord)(streamRecord)) {
+                (0, invariant_js_1.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 ((0, types_js_1.isCancellableStreamRecord)(streamRecord)) {
+                (0, invariant_js_1.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 = (0, utils_1.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 = (0, utils_1.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
+        });
+    }
+}

package/cjs/execution/buildFieldPlan.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFieldPlan = void 0;
+const getBySet_js_1 = require("./getBySet.js");
+const isSameSet_js_1 = require("./isSameSet.js");
+function buildFieldPlan(originalGroupedFieldSet, parentDeferUsages = new Set()) {
+    const groupedFieldSet = new Map();
+    const newGroupedFieldSets = new Map();
+    const map = new Map();
+    for (const [responseKey, fieldGroup] of originalGroupedFieldSet) {
+        const deferUsageSet = new Set();
+        let inOriginalResult = false;
+        for (const fieldDetails of fieldGroup) {
+            const deferUsage = fieldDetails.deferUsage;
+            if (deferUsage === undefined) {
+                inOriginalResult = true;
+                continue;
+            }
+            deferUsageSet.add(deferUsage);
+        }
+        if (inOriginalResult) {
+            deferUsageSet.clear();
+        }
+        else {
+            deferUsageSet.forEach(deferUsage => {
+                const ancestors = getAncestors(deferUsage);
+                for (const ancestor of ancestors) {
+                    if (deferUsageSet.has(ancestor)) {
+                        deferUsageSet.delete(deferUsage);
+                    }
+                }
+            });
+        }
+        map.set(responseKey, { deferUsageSet, fieldGroup });
+    }
+    for (const [responseKey, { deferUsageSet, fieldGroup }] of map) {
+        if ((0, isSameSet_js_1.isSameSet)(deferUsageSet, parentDeferUsages)) {
+            groupedFieldSet.set(responseKey, fieldGroup);
+            continue;
+        }
+        let newGroupedFieldSet = (0, getBySet_js_1.getBySet)(newGroupedFieldSets, deferUsageSet);
+        if (newGroupedFieldSet === undefined) {
+            newGroupedFieldSet = new Map();
+            newGroupedFieldSets.set(deferUsageSet, newGroupedFieldSet);
+        }
+        newGroupedFieldSet.set(responseKey, fieldGroup);
+    }
+    return {
+        groupedFieldSet,
+        newGroupedFieldSets,
+    };
+}
+exports.buildFieldPlan = buildFieldPlan;
+function getAncestors(deferUsage) {
+    const ancestors = [];
+    let parentDeferUsage = deferUsage.parentDeferUsage;
+    while (parentDeferUsage !== undefined) {
+        ancestors.unshift(parentDeferUsage);
+        parentDeferUsage = parentDeferUsage.parentDeferUsage;
+    }
+    return ancestors;
+}