@graphql-tools/executor 2.0.0-alpha-20240606224953-6d3be8381f7a6b24f2793457d1f05f89f1ae953a → 2.0.0-alpha-20240620034109-2a2878866aed08fedf5baaa5878414b9de79fdb2

package/cjs/execution/IncrementalGraph.js

@@ -3,86 +3,33 @@ 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 invariant_js_1 = require("./invariant.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._rootNodes = 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);
-            }
-        }
+    getNewPending(incrementalDataRecords) {
+        const initialResultChildren = new Set();
+        this._addIncrementalDataRecords(incrementalDataRecords, undefined, initialResultChildren);
+        return this._promoteNonEmptyToRoot(initialResultChildren);
     }
     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);
-                }
-            }
+        for (const deferredFragmentRecord of reconcilableResult.deferredGroupedFieldSetRecord
+            .deferredFragmentRecords) {
+            deferredFragmentRecord.deferredGroupedFieldSetRecords.delete(reconcilableResult.deferredGroupedFieldSetRecord);
+            deferredFragmentRecord.reconcilableResults.add(reconcilableResult);
         }
-        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);
-                }
-            }
+        const incrementalDataRecords = reconcilableResult.incrementalDataRecords;
+        if (incrementalDataRecords !== undefined) {
+            this._addIncrementalDataRecords(incrementalDataRecords, reconcilableResult.deferredGroupedFieldSetRecord.deferredFragmentRecords);
         }
-        this._newIncrementalDataRecords.clear();
-        return newPending;
     }
     completedIncrementalData() {
         return {
@@ -110,100 +57,127 @@ class IncrementalGraph {
         };
     }
     hasNext() {
-        return this._pending.size > 0;
+        return this._rootNodes.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) {
+        if (!this._rootNodes.has(deferredFragmentRecord) ||
+            deferredFragmentRecord.deferredGroupedFieldSetRecords.size > 0) {
             return;
         }
-        const reconcilableResults = Array.from(deferredFragmentNode.reconcilableResults);
+        const reconcilableResults = Array.from(deferredFragmentRecord.reconcilableResults);
+        this._removePending(deferredFragmentRecord);
         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);
+                otherDeferredFragmentRecord.reconcilableResults.delete(reconcilableResult);
             }
         }
-        this._removePending(deferredFragmentNode);
-        for (const child of deferredFragmentNode.children) {
-            this._newPending.add(child);
-        }
-        return reconcilableResults;
+        const newPending = this._promoteNonEmptyToRoot(deferredFragmentRecord.children);
+        return { newPending, reconcilableResults };
     }
     removeDeferredFragment(deferredFragmentRecord) {
-        const deferredFragmentNode = this._deferredFragmentNodes.get(deferredFragmentRecord);
-        if (deferredFragmentNode === undefined) {
+        if (!this._rootNodes.has(deferredFragmentRecord)) {
             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);
-        }
+        this._removePending(deferredFragmentRecord);
         return true;
     }
     removeStream(streamRecord) {
         this._removePending(streamRecord);
     }
-    _removePending(subsequentResultNode) {
-        this._pending.delete(subsequentResultNode);
-        if (this._pending.size === 0) {
+    _removePending(subsequentResultRecord) {
+        this._rootNodes.delete(subsequentResultRecord);
+        if (this._rootNodes.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);
+    _addIncrementalDataRecords(incrementalDataRecords, parents, initialResultChildren) {
+        for (const incrementalDataRecord of incrementalDataRecords) {
+            if ((0, types_js_1.isDeferredGroupedFieldSetRecord)(incrementalDataRecord)) {
+                for (const deferredFragmentRecord of incrementalDataRecord.deferredFragmentRecords) {
+                    this._addDeferredFragment(deferredFragmentRecord, initialResultChildren);
+                    deferredFragmentRecord.deferredGroupedFieldSetRecords.add(incrementalDataRecord);
+                }
+                if (this._hasPendingFragment(incrementalDataRecord)) {
+                    this._onDeferredGroupedFieldSet(incrementalDataRecord);
+                }
+            }
+            else if (parents === undefined) {
+                (0, invariant_js_1.invariant)(initialResultChildren !== undefined);
+                initialResultChildren.add(incrementalDataRecord);
+            }
+            else {
+                for (const parent of parents) {
+                    this._addDeferredFragment(parent, initialResultChildren);
+                    parent.children.add(incrementalDataRecord);
+                }
+            }
+        }
+    }
+    _promoteNonEmptyToRoot(maybeEmptyNewPending) {
+        const newPending = [];
+        for (const subsequentResultRecord of maybeEmptyNewPending) {
+            if ((0, types_js_1.isDeferredFragmentRecord)(subsequentResultRecord)) {
+                if (subsequentResultRecord.deferredGroupedFieldSetRecords.size > 0) {
+                    subsequentResultRecord.setAsPending();
+                    for (const deferredGroupedFieldSetRecord of subsequentResultRecord.deferredGroupedFieldSetRecords) {
+                        if (!this._hasPendingFragment(deferredGroupedFieldSetRecord)) {
+                            this._onDeferredGroupedFieldSet(deferredGroupedFieldSetRecord);
+                        }
+                    }
+                    this._rootNodes.add(subsequentResultRecord);
+                    newPending.push(subsequentResultRecord);
+                    continue;
+                }
+                for (const child of subsequentResultRecord.children) {
+                    maybeEmptyNewPending.add(child);
+                }
+            }
+            else {
+                this._rootNodes.add(subsequentResultRecord);
+                newPending.push(subsequentResultRecord);
+                this._onStreamItems(subsequentResultRecord);
             }
-            deferredFragmentNode.deferredGroupedFieldSetRecords.add(deferredGroupedFieldSetRecord);
         }
+        return newPending;
     }
-    _addStreamRecord(streamRecord) {
-        this._newPending.add(streamRecord);
+    _hasPendingFragment(deferredGroupedFieldSetRecord) {
+        return deferredGroupedFieldSetRecord.deferredFragmentRecords.some(deferredFragmentRecord => this._rootNodes.has(deferredFragmentRecord));
     }
-    _addDeferredFragmentNode(deferredFragmentRecord) {
-        let deferredFragmentNode = this._deferredFragmentNodes.get(deferredFragmentRecord);
-        if (deferredFragmentNode !== undefined) {
-            return deferredFragmentNode;
+    _addDeferredFragment(deferredFragmentRecord, subsequentResultRecords) {
+        if (this._rootNodes.has(deferredFragmentRecord)) {
+            return;
         }
-        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;
+            (0, invariant_js_1.invariant)(subsequentResultRecords !== undefined);
+            subsequentResultRecords.add(deferredFragmentRecord);
+            return;
+        }
+        parent.children.add(deferredFragmentRecord);
+        this._addDeferredFragment(parent, subsequentResultRecords);
+    }
+    _onDeferredGroupedFieldSet(deferredGroupedFieldSetRecord) {
+        const result = deferredGroupedFieldSetRecord.result.value;
+        if ((0, utils_1.isPromise)(result)) {
+            result.then(resolved => this._enqueue(resolved));
+        }
+        else {
+            this._enqueue(result);
         }
-        const parentNode = this._addDeferredFragmentNode(parent);
-        parentNode.children.push(deferredFragmentNode);
-        return deferredFragmentNode;
     }
-    async _onStreamItems(streamRecord, streamItemQueue) {
+    async _onStreamItems(streamRecord) {
         let items = [];
         let errors = [];
         let incrementalDataRecords = [];
+        const streamItemQueue = streamRecord.streamItemQueue;
         let streamItemRecord;
         while ((streamItemRecord = streamItemQueue.shift()) !== undefined) {
-            let result = typeof streamItemRecord === 'function' ? streamItemRecord().value : streamItemRecord.value;
+            let result = streamItemRecord instanceof BoxedPromiseOrValue_js_1.BoxedPromiseOrValue
+                ? streamItemRecord.value
+                : streamItemRecord().value;
             if ((0, utils_1.isPromise)(result)) {
                 if (items.length > 0) {
                     this._enqueue({

package/cjs/execution/IncrementalPublisher.js

@@ -23,8 +23,7 @@ class IncrementalPublisher {
         this._incrementalGraph = new IncrementalGraph_js_1.IncrementalGraph();
     }
     buildResponse(data, errors, incrementalDataRecords) {
-        this._incrementalGraph.addIncrementalDataRecords(incrementalDataRecords);
-        const newPending = this._incrementalGraph.getNewPending();
+        const newPending = this._incrementalGraph.getNewPending(incrementalDataRecords);
         const pending = this._pendingSourcesToResults(newPending);
         const initialResult = errors === undefined
             ? { data, pending, hasNext: true }
@@ -132,8 +131,6 @@ class IncrementalPublisher {
         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)) {
@@ -149,30 +146,21 @@ class IncrementalPublisher {
                     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) {
+            const completion = this._incrementalGraph.completeDeferredFragment(deferredFragmentRecord);
+            if (completion === undefined) {
                 continue;
             }
+            const id = deferredFragmentRecord.id;
+            (0, invariant_js_1.invariant)(id !== undefined);
             const incremental = context.incremental;
+            const { newPending, reconcilableResults } = completion;
+            context.pending.push(...this._pendingSourcesToResults(newPending));
             for (const reconcilableResult of reconcilableResults) {
                 const { bestId, subPath } = this._getBestIdAndSubPath(id, deferredFragmentRecord, reconcilableResult);
                 const incrementalEntry = {
@@ -220,8 +208,10 @@ class IncrementalPublisher {
                 ...streamItemsResult.result,
             };
             context.incremental.push(incrementalEntry);
-            if (streamItemsResult.incrementalDataRecords !== undefined) {
-                this._incrementalGraph.addIncrementalDataRecords(streamItemsResult.incrementalDataRecords);
+            const incrementalDataRecords = streamItemsResult.incrementalDataRecords;
+            if (incrementalDataRecords !== undefined) {
+                const newPending = this._incrementalGraph.getNewPending(incrementalDataRecords);
+                context.pending.push(...this._pendingSourcesToResults(newPending));
             }
         }
     }

package/cjs/execution/execute.js

@@ -10,6 +10,7 @@ const collectFields_js_1 = require("./collectFields.js");
 const IncrementalPublisher_js_1 = require("./IncrementalPublisher.js");
 const invariant_js_1 = require("./invariant.js");
 const promiseForObject_js_1 = require("./promiseForObject.js");
+const types_js_1 = require("./types.js");
 const values_js_1 = require("./values.js");
 /**
  * A memoized collection of relevant subfields with regard to the return
@@ -811,11 +812,7 @@ function addNewDeferredFragments(newDeferUsages, newDeferMap, path) {
             ? undefined
             : deferredFragmentRecordFromDeferUsage(parentDeferUsage, newDeferMap);
         // Instantiate the new record.
-        const deferredFragmentRecord = {
-            path,
-            label: newDeferUsage.label,
-            parent,
-        };
+        const deferredFragmentRecord = new types_js_1.DeferredFragmentRecord(path, newDeferUsage.label, parent);
         // Update the map.
         newDeferMap.set(newDeferUsage, deferredFragmentRecord);
     }
@@ -1114,12 +1111,26 @@ function executeDeferredGroupedFieldSets(exeContext, parentType, sourceValue, pa
             deferUsageSet,
             incrementalDataRecords: undefined,
         }, deferMap);
-        const shouldDeferThisDeferUsageSet = shouldDefer(parentDeferUsages, deferUsageSet);
-        deferredGroupedFieldSetRecord.result = shouldDeferThisDeferUsageSet
-            ? exeContext.enableEarlyExecution
-                ? new BoxedPromiseOrValue_js_1.BoxedPromiseOrValue(Promise.resolve().then(executor))
-                : () => new BoxedPromiseOrValue_js_1.BoxedPromiseOrValue(executor())
-            : new BoxedPromiseOrValue_js_1.BoxedPromiseOrValue(executor());
+        if (exeContext.enableEarlyExecution) {
+            deferredGroupedFieldSetRecord.result = new BoxedPromiseOrValue_js_1.BoxedPromiseOrValue(shouldDefer(parentDeferUsages, deferUsageSet)
+                ? Promise.resolve().then(executor)
+                : executor());
+        }
+        else if (deferredFragmentRecords.some(deferredFragmentRecord => deferredFragmentRecord.pending)) {
+            deferredGroupedFieldSetRecord.result = new BoxedPromiseOrValue_js_1.BoxedPromiseOrValue(executor());
+        }
+        else {
+            deferredGroupedFieldSetRecord.result = () => new BoxedPromiseOrValue_js_1.BoxedPromiseOrValue(executor());
+            const resolveThunk = () => {
+                const maybeThunk = deferredGroupedFieldSetRecord.result;
+                if (!(maybeThunk instanceof BoxedPromiseOrValue_js_1.BoxedPromiseOrValue)) {
+                    deferredGroupedFieldSetRecord.result = maybeThunk();
+                }
+            };
+            for (const deferredFragmentRecord of deferredFragmentRecords) {
+                deferredFragmentRecord.onPending(resolveThunk);
+            }
+        }
         newDeferredGroupedFieldSetRecords.push(deferredGroupedFieldSetRecord);
     }
     return newDeferredGroupedFieldSetRecords;

package/cjs/execution/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCancellableStreamRecord = exports.isNonReconcilableDeferredGroupedFieldSetResult = exports.isDeferredGroupedFieldSetResult = exports.isDeferredGroupedFieldSetRecord = void 0;
+exports.isCancellableStreamRecord = exports.isDeferredFragmentRecord = exports.DeferredFragmentRecord = exports.isNonReconcilableDeferredGroupedFieldSetResult = exports.isDeferredGroupedFieldSetResult = exports.isDeferredGroupedFieldSetRecord = void 0;
 function isDeferredGroupedFieldSetRecord(incrementalDataRecord) {
     return 'deferredFragmentRecords' in incrementalDataRecord;
 }
@@ -13,6 +13,33 @@ function isNonReconcilableDeferredGroupedFieldSetResult(deferredGroupedFieldSetR
     return deferredGroupedFieldSetResult.errors !== undefined;
 }
 exports.isNonReconcilableDeferredGroupedFieldSetResult = isNonReconcilableDeferredGroupedFieldSetResult;
+/** @internal */
+class DeferredFragmentRecord {
+    constructor(path, label, parent) {
+        this.path = path;
+        this.label = label;
+        this.parent = parent;
+        this.deferredGroupedFieldSetRecords = new Set();
+        this.reconcilableResults = new Set();
+        this.children = new Set();
+        this.pending = false;
+        this.fns = [];
+    }
+    onPending(fn) {
+        this.fns.push(fn);
+    }
+    setAsPending() {
+        this.pending = true;
+        for (const fn of this.fns) {
+            fn();
+        }
+    }
+}
+exports.DeferredFragmentRecord = DeferredFragmentRecord;
+function isDeferredFragmentRecord(subsequentResultRecord) {
+    return subsequentResultRecord instanceof DeferredFragmentRecord;
+}
+exports.isDeferredFragmentRecord = isDeferredFragmentRecord;
 function isCancellableStreamRecord(subsequentResultRecord) {
     return 'earlyReturn' in subsequentResultRecord;
 }

package/esm/execution/IncrementalGraph.js

@@ -1,85 +1,32 @@
 import { isPromise } from '@graphql-tools/utils';
 import { BoxedPromiseOrValue } from './BoxedPromiseOrValue.js';
+import { invariant } from './invariant.js';
 import { promiseWithResolvers } from './promiseWithResolvers.js';
-import { isDeferredGroupedFieldSetRecord } from './types.js';
-function isDeferredFragmentNode(node) {
-    return node !== undefined;
-}
-function isStreamNode(record) {
-    return 'streamItemQueue' in record;
-}
+import { isDeferredFragmentRecord, isDeferredGroupedFieldSetRecord } from './types.js';
 /**
  * @internal
  */
 export class IncrementalGraph {
     constructor() {
-        this._pending = new Set();
-        this._deferredFragmentNodes = new Map();
-        this._newIncrementalDataRecords = new Set();
-        this._newPending = new Set();
+        this._rootNodes = new Set();
         this._completedQueue = [];
         this._nextQueue = [];
     }
-    addIncrementalDataRecords(incrementalDataRecords) {
-        for (const incrementalDataRecord of incrementalDataRecords) {
-            if (isDeferredGroupedFieldSetRecord(incrementalDataRecord)) {
-                this._addDeferredGroupedFieldSetRecord(incrementalDataRecord);
-            }
-            else {
-                this._addStreamRecord(incrementalDataRecord);
-            }
-        }
+    getNewPending(incrementalDataRecords) {
+        const initialResultChildren = new Set();
+        this._addIncrementalDataRecords(incrementalDataRecords, undefined, initialResultChildren);
+        return this._promoteNonEmptyToRoot(initialResultChildren);
     }
     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);
-                }
-            }
+        for (const deferredFragmentRecord of reconcilableResult.deferredGroupedFieldSetRecord
+            .deferredFragmentRecords) {
+            deferredFragmentRecord.deferredGroupedFieldSetRecords.delete(reconcilableResult.deferredGroupedFieldSetRecord);
+            deferredFragmentRecord.reconcilableResults.add(reconcilableResult);
         }
-        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);
-                }
-            }
+        const incrementalDataRecords = reconcilableResult.incrementalDataRecords;
+        if (incrementalDataRecords !== undefined) {
+            this._addIncrementalDataRecords(incrementalDataRecords, reconcilableResult.deferredGroupedFieldSetRecord.deferredFragmentRecords);
         }
-        this._newIncrementalDataRecords.clear();
-        return newPending;
     }
     completedIncrementalData() {
         return {
@@ -107,100 +54,127 @@ export class IncrementalGraph {
         };
     }
     hasNext() {
-        return this._pending.size > 0;
+        return this._rootNodes.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) {
+        if (!this._rootNodes.has(deferredFragmentRecord) ||
+            deferredFragmentRecord.deferredGroupedFieldSetRecords.size > 0) {
             return;
         }
-        const reconcilableResults = Array.from(deferredFragmentNode.reconcilableResults);
+        const reconcilableResults = Array.from(deferredFragmentRecord.reconcilableResults);
+        this._removePending(deferredFragmentRecord);
         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);
+                otherDeferredFragmentRecord.reconcilableResults.delete(reconcilableResult);
             }
         }
-        this._removePending(deferredFragmentNode);
-        for (const child of deferredFragmentNode.children) {
-            this._newPending.add(child);
-        }
-        return reconcilableResults;
+        const newPending = this._promoteNonEmptyToRoot(deferredFragmentRecord.children);
+        return { newPending, reconcilableResults };
     }
     removeDeferredFragment(deferredFragmentRecord) {
-        const deferredFragmentNode = this._deferredFragmentNodes.get(deferredFragmentRecord);
-        if (deferredFragmentNode === undefined) {
+        if (!this._rootNodes.has(deferredFragmentRecord)) {
             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);
-        }
+        this._removePending(deferredFragmentRecord);
         return true;
     }
     removeStream(streamRecord) {
         this._removePending(streamRecord);
     }
-    _removePending(subsequentResultNode) {
-        this._pending.delete(subsequentResultNode);
-        if (this._pending.size === 0) {
+    _removePending(subsequentResultRecord) {
+        this._rootNodes.delete(subsequentResultRecord);
+        if (this._rootNodes.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);
+    _addIncrementalDataRecords(incrementalDataRecords, parents, initialResultChildren) {
+        for (const incrementalDataRecord of incrementalDataRecords) {
+            if (isDeferredGroupedFieldSetRecord(incrementalDataRecord)) {
+                for (const deferredFragmentRecord of incrementalDataRecord.deferredFragmentRecords) {
+                    this._addDeferredFragment(deferredFragmentRecord, initialResultChildren);
+                    deferredFragmentRecord.deferredGroupedFieldSetRecords.add(incrementalDataRecord);
+                }
+                if (this._hasPendingFragment(incrementalDataRecord)) {
+                    this._onDeferredGroupedFieldSet(incrementalDataRecord);
+                }
+            }
+            else if (parents === undefined) {
+                invariant(initialResultChildren !== undefined);
+                initialResultChildren.add(incrementalDataRecord);
+            }
+            else {
+                for (const parent of parents) {
+                    this._addDeferredFragment(parent, initialResultChildren);
+                    parent.children.add(incrementalDataRecord);
+                }
+            }
+        }
+    }
+    _promoteNonEmptyToRoot(maybeEmptyNewPending) {
+        const newPending = [];
+        for (const subsequentResultRecord of maybeEmptyNewPending) {
+            if (isDeferredFragmentRecord(subsequentResultRecord)) {
+                if (subsequentResultRecord.deferredGroupedFieldSetRecords.size > 0) {
+                    subsequentResultRecord.setAsPending();
+                    for (const deferredGroupedFieldSetRecord of subsequentResultRecord.deferredGroupedFieldSetRecords) {
+                        if (!this._hasPendingFragment(deferredGroupedFieldSetRecord)) {
+                            this._onDeferredGroupedFieldSet(deferredGroupedFieldSetRecord);
+                        }
+                    }
+                    this._rootNodes.add(subsequentResultRecord);
+                    newPending.push(subsequentResultRecord);
+                    continue;
+                }
+                for (const child of subsequentResultRecord.children) {
+                    maybeEmptyNewPending.add(child);
+                }
+            }
+            else {
+                this._rootNodes.add(subsequentResultRecord);
+                newPending.push(subsequentResultRecord);
+                this._onStreamItems(subsequentResultRecord);
             }
-            deferredFragmentNode.deferredGroupedFieldSetRecords.add(deferredGroupedFieldSetRecord);
         }
+        return newPending;
     }
-    _addStreamRecord(streamRecord) {
-        this._newPending.add(streamRecord);
+    _hasPendingFragment(deferredGroupedFieldSetRecord) {
+        return deferredGroupedFieldSetRecord.deferredFragmentRecords.some(deferredFragmentRecord => this._rootNodes.has(deferredFragmentRecord));
     }
-    _addDeferredFragmentNode(deferredFragmentRecord) {
-        let deferredFragmentNode = this._deferredFragmentNodes.get(deferredFragmentRecord);
-        if (deferredFragmentNode !== undefined) {
-            return deferredFragmentNode;
+    _addDeferredFragment(deferredFragmentRecord, subsequentResultRecords) {
+        if (this._rootNodes.has(deferredFragmentRecord)) {
+            return;
         }
-        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;
+            invariant(subsequentResultRecords !== undefined);
+            subsequentResultRecords.add(deferredFragmentRecord);
+            return;
+        }
+        parent.children.add(deferredFragmentRecord);
+        this._addDeferredFragment(parent, subsequentResultRecords);
+    }
+    _onDeferredGroupedFieldSet(deferredGroupedFieldSetRecord) {
+        const result = deferredGroupedFieldSetRecord.result.value;
+        if (isPromise(result)) {
+            result.then(resolved => this._enqueue(resolved));
+        }
+        else {
+            this._enqueue(result);
         }
-        const parentNode = this._addDeferredFragmentNode(parent);
-        parentNode.children.push(deferredFragmentNode);
-        return deferredFragmentNode;
     }
-    async _onStreamItems(streamRecord, streamItemQueue) {
+    async _onStreamItems(streamRecord) {
         let items = [];
         let errors = [];
         let incrementalDataRecords = [];
+        const streamItemQueue = streamRecord.streamItemQueue;
         let streamItemRecord;
         while ((streamItemRecord = streamItemQueue.shift()) !== undefined) {
-            let result = typeof streamItemRecord === 'function' ? streamItemRecord().value : streamItemRecord.value;
+            let result = streamItemRecord instanceof BoxedPromiseOrValue
+                ? streamItemRecord.value
+                : streamItemRecord().value;
             if (isPromise(result)) {
                 if (items.length > 0) {
                     this._enqueue({

package/esm/execution/IncrementalPublisher.js

@@ -19,8 +19,7 @@ class IncrementalPublisher {
         this._incrementalGraph = new IncrementalGraph();
     }
     buildResponse(data, errors, incrementalDataRecords) {
-        this._incrementalGraph.addIncrementalDataRecords(incrementalDataRecords);
-        const newPending = this._incrementalGraph.getNewPending();
+        const newPending = this._incrementalGraph.getNewPending(incrementalDataRecords);
         const pending = this._pendingSourcesToResults(newPending);
         const initialResult = errors === undefined
             ? { data, pending, hasNext: true }
@@ -128,8 +127,6 @@ class IncrementalPublisher {
         else {
             this._handleCompletedStreamItems(completedIncrementalData, context);
         }
-        const newPending = this._incrementalGraph.getNewPending();
-        context.pending.push(...this._pendingSourcesToResults(newPending));
     }
     _handleCompletedDeferredGroupedFieldSet(deferredGroupedFieldSetResult, context) {
         if (isNonReconcilableDeferredGroupedFieldSetResult(deferredGroupedFieldSetResult)) {
@@ -145,30 +142,21 @@ class IncrementalPublisher {
                     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) {
+            const completion = this._incrementalGraph.completeDeferredFragment(deferredFragmentRecord);
+            if (completion === undefined) {
                 continue;
             }
+            const id = deferredFragmentRecord.id;
+            invariant(id !== undefined);
             const incremental = context.incremental;
+            const { newPending, reconcilableResults } = completion;
+            context.pending.push(...this._pendingSourcesToResults(newPending));
             for (const reconcilableResult of reconcilableResults) {
                 const { bestId, subPath } = this._getBestIdAndSubPath(id, deferredFragmentRecord, reconcilableResult);
                 const incrementalEntry = {
@@ -216,8 +204,10 @@ class IncrementalPublisher {
                 ...streamItemsResult.result,
             };
             context.incremental.push(incrementalEntry);
-            if (streamItemsResult.incrementalDataRecords !== undefined) {
-                this._incrementalGraph.addIncrementalDataRecords(streamItemsResult.incrementalDataRecords);
+            const incrementalDataRecords = streamItemsResult.incrementalDataRecords;
+            if (incrementalDataRecords !== undefined) {
+                const newPending = this._incrementalGraph.getNewPending(incrementalDataRecords);
+                context.pending.push(...this._pendingSourcesToResults(newPending));
             }
         }
     }

package/esm/execution/execute.js

@@ -7,6 +7,7 @@ import { collectSubfields as _collectSubfields, collectFields, } from './collect
 import { buildIncrementalResponse } from './IncrementalPublisher.js';
 import { invariant } from './invariant.js';
 import { promiseForObject } from './promiseForObject.js';
+import { DeferredFragmentRecord, } from './types.js';
 import { getVariableValues } from './values.js';
 /**
  * A memoized collection of relevant subfields with regard to the return
@@ -803,11 +804,7 @@ function addNewDeferredFragments(newDeferUsages, newDeferMap, path) {
             ? undefined
             : deferredFragmentRecordFromDeferUsage(parentDeferUsage, newDeferMap);
         // Instantiate the new record.
-        const deferredFragmentRecord = {
-            path,
-            label: newDeferUsage.label,
-            parent,
-        };
+        const deferredFragmentRecord = new DeferredFragmentRecord(path, newDeferUsage.label, parent);
         // Update the map.
         newDeferMap.set(newDeferUsage, deferredFragmentRecord);
     }
@@ -1102,12 +1099,26 @@ function executeDeferredGroupedFieldSets(exeContext, parentType, sourceValue, pa
             deferUsageSet,
             incrementalDataRecords: undefined,
         }, deferMap);
-        const shouldDeferThisDeferUsageSet = shouldDefer(parentDeferUsages, deferUsageSet);
-        deferredGroupedFieldSetRecord.result = shouldDeferThisDeferUsageSet
-            ? exeContext.enableEarlyExecution
-                ? new BoxedPromiseOrValue(Promise.resolve().then(executor))
-                : () => new BoxedPromiseOrValue(executor())
-            : new BoxedPromiseOrValue(executor());
+        if (exeContext.enableEarlyExecution) {
+            deferredGroupedFieldSetRecord.result = new BoxedPromiseOrValue(shouldDefer(parentDeferUsages, deferUsageSet)
+                ? Promise.resolve().then(executor)
+                : executor());
+        }
+        else if (deferredFragmentRecords.some(deferredFragmentRecord => deferredFragmentRecord.pending)) {
+            deferredGroupedFieldSetRecord.result = new BoxedPromiseOrValue(executor());
+        }
+        else {
+            deferredGroupedFieldSetRecord.result = () => new BoxedPromiseOrValue(executor());
+            const resolveThunk = () => {
+                const maybeThunk = deferredGroupedFieldSetRecord.result;
+                if (!(maybeThunk instanceof BoxedPromiseOrValue)) {
+                    deferredGroupedFieldSetRecord.result = maybeThunk();
+                }
+            };
+            for (const deferredFragmentRecord of deferredFragmentRecords) {
+                deferredFragmentRecord.onPending(resolveThunk);
+            }
+        }
         newDeferredGroupedFieldSetRecords.push(deferredGroupedFieldSetRecord);
     }
     return newDeferredGroupedFieldSetRecords;

package/esm/execution/types.js

@@ -7,6 +7,31 @@ export function isDeferredGroupedFieldSetResult(subsequentResult) {
 export function isNonReconcilableDeferredGroupedFieldSetResult(deferredGroupedFieldSetResult) {
     return deferredGroupedFieldSetResult.errors !== undefined;
 }
+/** @internal */
+export class DeferredFragmentRecord {
+    constructor(path, label, parent) {
+        this.path = path;
+        this.label = label;
+        this.parent = parent;
+        this.deferredGroupedFieldSetRecords = new Set();
+        this.reconcilableResults = new Set();
+        this.children = new Set();
+        this.pending = false;
+        this.fns = [];
+    }
+    onPending(fn) {
+        this.fns.push(fn);
+    }
+    setAsPending() {
+        this.pending = true;
+        for (const fn of this.fns) {
+            fn();
+        }
+    }
+}
+export function isDeferredFragmentRecord(subsequentResultRecord) {
+    return subsequentResultRecord instanceof DeferredFragmentRecord;
+}
 export function isCancellableStreamRecord(subsequentResultRecord) {
     return 'earlyReturn' in subsequentResultRecord;
 }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@graphql-tools/executor",
-  "version": "2.0.0-alpha-20240606224953-6d3be8381f7a6b24f2793457d1f05f89f1ae953a",
+  "version": "2.0.0-alpha-20240620034109-2a2878866aed08fedf5baaa5878414b9de79fdb2",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0"
   },
   "dependencies": {
-    "@graphql-tools/utils": "10.3.0-alpha-20240606224953-6d3be8381f7a6b24f2793457d1f05f89f1ae953a",
+    "@graphql-tools/utils": "10.3.0-alpha-20240620034109-2a2878866aed08fedf5baaa5878414b9de79fdb2",
     "@graphql-typed-document-node/core": "3.2.0",
     "@repeaterjs/repeater": "^3.0.4",
     "tslib": "^2.4.0",

package/typings/execution/IncrementalGraph.d.cts

@@ -3,29 +3,30 @@ import type { DeferredFragmentRecord, IncrementalDataRecord, IncrementalDataReco
  * @internal
  */
 export declare class IncrementalGraph {
-    private _pending;
-    private _deferredFragmentNodes;
-    private _newPending;
-    private _newIncrementalDataRecords;
+    private _rootNodes;
     private _completedQueue;
     private _nextQueue;
     constructor();
-    addIncrementalDataRecords(incrementalDataRecords: ReadonlyArray<IncrementalDataRecord>): void;
+    getNewPending(incrementalDataRecords: ReadonlyArray<IncrementalDataRecord>): ReadonlyArray<SubsequentResultRecord>;
     addCompletedReconcilableDeferredGroupedFieldSet(reconcilableResult: ReconcilableDeferredGroupedFieldSetResult): void;
-    getNewPending(): ReadonlyArray<SubsequentResultRecord>;
     completedIncrementalData(): {
         [Symbol.asyncIterator](): any;
         next: () => Promise<IteratorResult<Iterable<IncrementalDataRecordResult>>>;
         return: () => Promise<IteratorResult<Iterable<IncrementalDataRecordResult>>>;
     };
     hasNext(): boolean;
-    completeDeferredFragment(deferredFragmentRecord: DeferredFragmentRecord): Array<ReconcilableDeferredGroupedFieldSetResult> | undefined;
+    completeDeferredFragment(deferredFragmentRecord: DeferredFragmentRecord): {
+        newPending: ReadonlyArray<SubsequentResultRecord>;
+        reconcilableResults: ReadonlyArray<ReconcilableDeferredGroupedFieldSetResult>;
+    } | undefined;
     removeDeferredFragment(deferredFragmentRecord: DeferredFragmentRecord): boolean;
     removeStream(streamRecord: StreamRecord): void;
     private _removePending;
-    private _addDeferredGroupedFieldSetRecord;
-    private _addStreamRecord;
-    private _addDeferredFragmentNode;
+    private _addIncrementalDataRecords;
+    private _promoteNonEmptyToRoot;
+    private _hasPendingFragment;
+    private _addDeferredFragment;
+    private _onDeferredGroupedFieldSet;
     private _onStreamItems;
     private _yieldCurrentCompletedIncrementalData;
     private _enqueue;

package/typings/execution/IncrementalGraph.d.ts

@@ -3,29 +3,30 @@ import type { DeferredFragmentRecord, IncrementalDataRecord, IncrementalDataReco
  * @internal
  */
 export declare class IncrementalGraph {
-    private _pending;
-    private _deferredFragmentNodes;
-    private _newPending;
-    private _newIncrementalDataRecords;
+    private _rootNodes;
     private _completedQueue;
     private _nextQueue;
     constructor();
-    addIncrementalDataRecords(incrementalDataRecords: ReadonlyArray<IncrementalDataRecord>): void;
+    getNewPending(incrementalDataRecords: ReadonlyArray<IncrementalDataRecord>): ReadonlyArray<SubsequentResultRecord>;
     addCompletedReconcilableDeferredGroupedFieldSet(reconcilableResult: ReconcilableDeferredGroupedFieldSetResult): void;
-    getNewPending(): ReadonlyArray<SubsequentResultRecord>;
     completedIncrementalData(): {
         [Symbol.asyncIterator](): any;
         next: () => Promise<IteratorResult<Iterable<IncrementalDataRecordResult>>>;
         return: () => Promise<IteratorResult<Iterable<IncrementalDataRecordResult>>>;
     };
     hasNext(): boolean;
-    completeDeferredFragment(deferredFragmentRecord: DeferredFragmentRecord): Array<ReconcilableDeferredGroupedFieldSetResult> | undefined;
+    completeDeferredFragment(deferredFragmentRecord: DeferredFragmentRecord): {
+        newPending: ReadonlyArray<SubsequentResultRecord>;
+        reconcilableResults: ReadonlyArray<ReconcilableDeferredGroupedFieldSetResult>;
+    } | undefined;
     removeDeferredFragment(deferredFragmentRecord: DeferredFragmentRecord): boolean;
     removeStream(streamRecord: StreamRecord): void;
     private _removePending;
-    private _addDeferredGroupedFieldSetRecord;
-    private _addStreamRecord;
-    private _addDeferredFragmentNode;
+    private _addIncrementalDataRecords;
+    private _promoteNonEmptyToRoot;
+    private _hasPendingFragment;
+    private _addDeferredFragment;
+    private _onDeferredGroupedFieldSet;
     private _onStreamItems;
     private _yieldCurrentCompletedIncrementalData;
     private _enqueue;

package/typings/execution/types.d.cts

@@ -121,12 +121,22 @@ export interface DeferredGroupedFieldSetRecord {
     result: BoxedPromiseOrValue<DeferredGroupedFieldSetResult> | (() => BoxedPromiseOrValue<DeferredGroupedFieldSetResult>);
 }
 export type SubsequentResultRecord = DeferredFragmentRecord | StreamRecord;
-export interface DeferredFragmentRecord {
+/** @internal */
+export declare class DeferredFragmentRecord {
     path: Path | undefined;
     label: string | undefined;
     id?: string | undefined;
     parent: DeferredFragmentRecord | undefined;
-}
+    deferredGroupedFieldSetRecords: Set<DeferredGroupedFieldSetRecord>;
+    reconcilableResults: Set<ReconcilableDeferredGroupedFieldSetResult>;
+    children: Set<SubsequentResultRecord>;
+    pending: boolean;
+    fns: Array<() => void>;
+    constructor(path: Path | undefined, label: string | undefined, parent: DeferredFragmentRecord | undefined);
+    onPending(fn: () => void): void;
+    setAsPending(): void;
+}
+export declare function isDeferredFragmentRecord(subsequentResultRecord: SubsequentResultRecord): subsequentResultRecord is DeferredFragmentRecord;
 export interface StreamItemResult {
     path: Path;
     item?: unknown;

package/typings/execution/types.d.ts

@@ -121,12 +121,22 @@ export interface DeferredGroupedFieldSetRecord {
     result: BoxedPromiseOrValue<DeferredGroupedFieldSetResult> | (() => BoxedPromiseOrValue<DeferredGroupedFieldSetResult>);
 }
 export type SubsequentResultRecord = DeferredFragmentRecord | StreamRecord;
-export interface DeferredFragmentRecord {
+/** @internal */
+export declare class DeferredFragmentRecord {
     path: Path | undefined;
     label: string | undefined;
     id?: string | undefined;
     parent: DeferredFragmentRecord | undefined;
-}
+    deferredGroupedFieldSetRecords: Set<DeferredGroupedFieldSetRecord>;
+    reconcilableResults: Set<ReconcilableDeferredGroupedFieldSetResult>;
+    children: Set<SubsequentResultRecord>;
+    pending: boolean;
+    fns: Array<() => void>;
+    constructor(path: Path | undefined, label: string | undefined, parent: DeferredFragmentRecord | undefined);
+    onPending(fn: () => void): void;
+    setAsPending(): void;
+}
+export declare function isDeferredFragmentRecord(subsequentResultRecord: SubsequentResultRecord): subsequentResultRecord is DeferredFragmentRecord;
 export interface StreamItemResult {
     path: Path;
     item?: unknown;