@graphql-tools/executor 4.1.1 → 4.1.2-alpha-20261020172239-6aecb886558928f54033e77a926c32d55e3e81cc

package/cjs/execution/execute.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultFieldResolver = exports.defaultTypeResolver = exports.CRITICAL_ERROR = void 0;
+exports.CRITICAL_ERROR = exports.defaultTypeResolver = exports.defaultFieldResolver = void 0;
 exports.execute = execute;
 exports.executeSync = executeSync;
 exports.assertValidExecutionArguments = assertValidExecutionArguments;
@@ -13,12 +13,15 @@ exports.flattenIncrementalResults = flattenIncrementalResults;
 exports.getFieldDef = getFieldDef;
 exports.isIncrementalResult = isIncrementalResult;
 const graphql_1 = require("graphql");
+Object.defineProperty(exports, "defaultFieldResolver", { enumerable: true, get: function () { return graphql_1.defaultFieldResolver; } });
+Object.defineProperty(exports, "defaultTypeResolver", { enumerable: true, get: function () { return graphql_1.defaultTypeResolver; } });
 const utils_1 = require("@graphql-tools/utils");
 const disposablestack_1 = require("@whatwg-node/disposablestack");
 const promise_helpers_1 = require("@whatwg-node/promise-helpers");
 const coerceError_js_1 = require("./coerceError.js");
 const flattenAsyncIterable_js_1 = require("./flattenAsyncIterable.js");
 const incremental_js_1 = require("./incremental.js");
+const incrementalCollect_js_1 = require("./incrementalCollect.js");
 const invariant_js_1 = require("./invariant.js");
 const promiseForObject_js_1 = require("./promiseForObject.js");
 const EMPTY_ARGS = Object.freeze(Object.create(null));
@@ -329,9 +332,9 @@ function buildExecutionContext(args) {
         operation,
         variableValues,
         resolveInfoVariableValues,
-        fieldResolver: fieldResolver ?? exports.defaultFieldResolver,
-        typeResolver: typeResolver ?? exports.defaultTypeResolver,
-        subscribeFieldResolver: subscribeFieldResolver ?? exports.defaultFieldResolver,
+        fieldResolver: fieldResolver ?? graphql_1.defaultFieldResolver,
+        typeResolver: typeResolver ?? graphql_1.defaultTypeResolver,
+        subscribeFieldResolver: subscribeFieldResolver ?? graphql_1.defaultFieldResolver,
         subsequentPayloads: new Set(),
         incrementalSpec,
         publisher: incrementalSpec === 'v0.2' ? (0, incremental_js_1.createIncrementalPublisherState)() : undefined,
@@ -401,18 +404,125 @@ function executeOperation(exeContext) {
     const { fields: rootFields, patches } = (0, utils_1.collectFields)(schema, fragments, variableValues, rootType, operation.selectionSet);
     const path = undefined;
     let result;
+    if (patches.length === 0) {
+        if (operation.operation === 'mutation') {
+            result = executeFieldsSerially(exeContext, rootType, rootValue, path, rootFields);
+        }
+        else {
+            result = executeFields(exeContext, rootType, rootValue, path, rootFields);
+        }
+        return result;
+    }
+    ensureIncrementalCollectState(exeContext);
+    const { groupedFieldSet } = (0, incrementalCollect_js_1.collectIncrementalFields)(schema, fragments, variableValues, rootType, operation.selectionSet);
+    const { groupedFieldSet: initialFields, newGroupedFieldSets } = (0, incrementalCollect_js_1.buildExecutionPlan)(groupedFieldSet);
+    const plannedRootFields = (0, incrementalCollect_js_1.groupedFieldSetToFieldMap)(initialFields, exeContext.deferUsageByFieldNode);
     if (operation.operation === 'mutation') {
-        result = executeFieldsSerially(exeContext, rootType, rootValue, path, rootFields);
+        result = executeFieldsSerially(exeContext, rootType, rootValue, path, plannedRootFields);
     }
     else {
-        result = executeFields(exeContext, rootType, rootValue, path, rootFields);
-    }
-    for (const patch of patches) {
-        const { label, fields: patchFields, patches: nestedPatches } = patch;
-        executeDeferredFragment(exeContext, rootType, rootValue, patchFields, label, path, undefined, nestedPatches);
+        result = executeFields(exeContext, rootType, rootValue, path, plannedRootFields);
     }
+    executeDeferredGroups(exeContext, rootType, rootValue, path, newGroupedFieldSets, undefined);
     return result;
 }
+function executeDeferredGroups(exeContext, parentType, sourceValue, path, newGroupedFieldSets, parentContext) {
+    if ((0, incremental_js_1.isAtOrUnderNulledPath)((0, utils_1.pathToArray)(path), exeContext.nulledPaths)) {
+        return;
+    }
+    const records = new Map();
+    const remainingGroups = new Map();
+    const parts = new Map();
+    const groups = [...newGroupedFieldSets.entries()].sort(([a], [b]) => deferUsageDepth((0, incrementalCollect_js_1.rootDeferUsage)(a)) - deferUsageDepth((0, incrementalCollect_js_1.rootDeferUsage)(b)));
+    for (const [deferUsageSet] of groups) {
+        for (const usage of deferUsageSet) {
+            remainingGroups.set(usage, (remainingGroups.get(usage) ?? 0) + 1);
+        }
+    }
+    const usages = [...remainingGroups.keys()].sort((a, b) => deferUsageDepth(a) - deferUsageDepth(b));
+    for (const usage of usages) {
+        const deliveryParent = (usage.parentDeferUsage && records.get(usage.parentDeferUsage)) ?? parentContext;
+        records.set(usage, new incremental_js_1.DeferredFragmentRecord({
+            label: usage.label,
+            path,
+            parentContext,
+            deliveryParent,
+            exeContext,
+            deferUsage: usage,
+        }));
+    }
+    for (const [deferUsageSet, groupedFieldSet] of groups) {
+        const fields = (0, incrementalCollect_js_1.groupedFieldSetToFieldMap)(groupedFieldSet, exeContext.deferUsageByFieldNode);
+        const fieldUsageStore = (exeContext.deferUsagesForFieldNodes ??= new WeakMap());
+        for (const fieldNodes of fields.values()) {
+            fieldUsageStore.set(fieldNodes, deferUsageSet);
+        }
+        const primaryUsage = (0, incrementalCollect_js_1.rootDeferUsage)(deferUsageSet);
+        const primaryRecord = primaryUsage ? records.get(primaryUsage) : undefined;
+        const data = executeDeferredGroupedFields(exeContext, parentType, sourceValue, path, fields, primaryRecord, [...deferUsageSet].map(usage => records.get(usage)).filter(record => record != null));
+        for (const usage of deferUsageSet) {
+            const list = parts.get(usage) ?? [];
+            list.push(data);
+            parts.set(usage, list);
+            const left = (remainingGroups.get(usage) ?? 1) - 1;
+            remainingGroups.set(usage, left);
+            if (left === 0) {
+                records.get(usage)?.addData(mergeDeferredParts(list));
+            }
+        }
+    }
+}
+function executeDeferredGroupedFields(exeContext, parentType, sourceValue, path, fields, primaryRecord, records) {
+    try {
+        const data = executeFields(exeContext, parentType, sourceValue, path, fields, primaryRecord);
+        if ((0, promise_helpers_1.isPromise)(data)) {
+            return data.then(null, e => {
+                for (const record of records) {
+                    record.errors.push(e);
+                }
+                return null;
+            });
+        }
+        return data;
+    }
+    catch (e) {
+        for (const record of records) {
+            record.errors.push(e);
+        }
+        return null;
+    }
+}
+function mergeDeferredParts(parts) {
+    if (parts.some(promise_helpers_1.isPromise)) {
+        return Promise.all(parts).then(mergeDeferredObjects);
+    }
+    return mergeDeferredObjects(parts);
+}
+function mergeDeferredObjects(parts) {
+    const result = Object.create(null);
+    let sawObject = false;
+    for (const part of parts) {
+        if (part == null) {
+            continue;
+        }
+        sawObject = true;
+        Object.assign(result, part);
+    }
+    return sawObject ? result : null;
+}
+function ensureIncrementalCollectState(exeContext) {
+    exeContext.nulledPaths ??= [];
+    exeContext.deferUsageByFieldNode ??= new WeakMap();
+}
+function deferUsageDepth(usage) {
+    let depth = 0;
+    let current = usage;
+    while (current?.parentDeferUsage) {
+        depth++;
+        current = current.parentDeferUsage;
+    }
+    return depth;
+}
 /**
  * Implements the "Executing selection sets" section of the spec
  * for fields that must be executed serially.
@@ -886,71 +996,41 @@ function invalidReturnTypeError(returnType, result, fieldNodes) {
 function collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path, result, asyncPayloadRecord) {
     // Collect sub-fields to execute to complete this value.
     const { fields: subFieldNodes, patches: subPatches } = collectSubfields(exeContext, returnType, fieldNodes);
-    const subFields = executeFields(exeContext, returnType, result, path, subFieldNodes, asyncPayloadRecord);
-    for (const subPatch of subPatches) {
-        const { label, fields: subPatchFieldNodes, patches: nestedPatches } = subPatch;
-        executeDeferredFragment(exeContext, returnType, result, subPatchFieldNodes, label, path, asyncPayloadRecord, nestedPatches);
-    }
-    return subFields;
-}
-/**
- * If a resolveType function is not given, then a default resolve behavior is
- * used which attempts two strategies:
- *
- * First, See if the provided value has a `__typename` field defined, if so, use
- * that value as name of the resolved type.
- *
- * Otherwise, test each possible type for the abstract type by calling
- * isTypeOf for the object being coerced, returning the first type that matches.
- */
-const defaultTypeResolver = function (value, contextValue, info, abstractType) {
-    // First, look for `__typename`.
-    if ((0, utils_1.isObjectLike)(value) && typeof value['__typename'] === 'string') {
-        return value['__typename'];
-    }
-    // Otherwise, test each possible type.
-    const possibleTypes = info.schema.getPossibleTypes(abstractType);
-    const promisedIsTypeOfResults = [];
-    for (let i = 0; i < possibleTypes.length; i++) {
-        const type = possibleTypes[i];
-        if (type.isTypeOf) {
-            const isTypeOfResult = type.isTypeOf(value, contextValue, info);
-            if ((0, promise_helpers_1.isPromise)(isTypeOfResult)) {
-                promisedIsTypeOfResults[i] = isTypeOfResult;
-            }
-            else if (isTypeOfResult) {
-                return type.name;
-            }
+    if (subPatches.length === 0 && exeContext.nulledPaths == null) {
+        return executeFields(exeContext, returnType, result, path, subFieldNodes, asyncPayloadRecord);
+    }
+    ensureIncrementalCollectState(exeContext);
+    const parentDeferUsage = asyncPayloadRecord?.type === 'defer' ? asyncPayloadRecord.deferUsage : undefined;
+    const subfieldCache = (exeContext.incrementalSubfieldCache ??= new WeakMap());
+    let collected = subfieldCache.get(fieldNodes);
+    if (collected == null) {
+        collected = (0, incrementalCollect_js_1.collectIncrementalSubfields)(exeContext.schema, exeContext.fragments, exeContext.variableValues, returnType, fieldNodes, parentDeferUsage, exeContext.deferUsageByFieldNode);
+        subfieldCache.set(fieldNodes, collected);
+    }
+    const { groupedFieldSet } = collected;
+    const parentDeferUsages = new Set();
+    const plannedUsages = exeContext.deferUsagesForFieldNodes?.get(fieldNodes);
+    if (plannedUsages) {
+        for (const usage of plannedUsages) {
+            parentDeferUsages.add(usage);
         }
     }
-    if (promisedIsTypeOfResults.length) {
-        return Promise.all(promisedIsTypeOfResults).then(isTypeOfResults => {
-            for (let i = 0; i < isTypeOfResults.length; i++) {
-                if (isTypeOfResults[i]) {
-                    return possibleTypes[i].name;
-                }
-            }
-        });
+    else if (parentDeferUsage) {
+        parentDeferUsages.add(parentDeferUsage);
     }
-};
-exports.defaultTypeResolver = defaultTypeResolver;
-/**
- * If a resolve function is not given, then a default resolve behavior is used
- * which takes the property of the source object of the same name as the field
- * and returns it as the result, or if it's a function, returns the result
- * of calling that function while passing along args and context value.
- */
-const defaultFieldResolver = function (source, args, contextValue, info) {
-    // ensure source is a value for which property access is acceptable.
-    if ((0, utils_1.isObjectLike)(source) || typeof source === 'function') {
-        const property = source[info.fieldName];
-        if (typeof property === 'function') {
-            return source[info.fieldName](args, contextValue, info);
+    else if (asyncPayloadRecord?.type === 'stream') {
+        for (const node of fieldNodes) {
+            const usage = exeContext.deferUsageByFieldNode?.get(node);
+            if (usage) {
+                parentDeferUsages.add(usage);
+            }
         }
-        return property;
     }
-};
-exports.defaultFieldResolver = defaultFieldResolver;
+    const { groupedFieldSet: initialFields, newGroupedFieldSets } = (0, incrementalCollect_js_1.buildExecutionPlan)(groupedFieldSet, parentDeferUsages);
+    const subFields = executeFields(exeContext, returnType, result, path, (0, incrementalCollect_js_1.groupedFieldSetToFieldMap)(initialFields, exeContext.deferUsageByFieldNode), asyncPayloadRecord);
+    executeDeferredGroups(exeContext, returnType, result, path, newGroupedFieldSets, asyncPayloadRecord);
+    return subFields;
+}
 /**
  * Implements the "Subscribe" algorithm described in the GraphQL specification,
  * including `@defer` and `@stream` as proposed in
@@ -1158,37 +1238,6 @@ function assertEventStream(result, signal, onSignalAbort) {
     }
     return result;
 }
-function executeDeferredFragment(exeContext, parentType, sourceValue, fields, label, path, parentContext, nestedPatches, deliveryParent) {
-    const asyncPayloadRecord = new incremental_js_1.DeferredFragmentRecord({
-        label,
-        path,
-        parentContext,
-        deliveryParent: deliveryParent ?? parentContext,
-        exeContext,
-    });
-    let promiseOrData;
-    try {
-        promiseOrData = executeFields(exeContext, parentType, sourceValue, path, fields, asyncPayloadRecord);
-        if ((0, promise_helpers_1.isPromise)(promiseOrData)) {
-            promiseOrData = promiseOrData.then(null, e => {
-                asyncPayloadRecord.errors.push(e);
-                return null;
-            });
-        }
-    }
-    catch (e) {
-        asyncPayloadRecord.errors.push(e);
-        promiseOrData = null;
-    }
-    asyncPayloadRecord.addData(promiseOrData);
-    if (nestedPatches) {
-        for (const nested of nestedPatches) {
-            executeDeferredFragment(exeContext, parentType, sourceValue, nested.fields, nested.label, path, 
-            // Keep v0.1 sibling completion; v0.2 pending still nests via deliveryParent.
-            parentContext, nested.patches, asyncPayloadRecord);
-        }
-    }
-}
 function executeStreamField(path, itemPath, item, exeContext, fieldNodes, info, itemType, label, parentContext, streamGroup) {
     const asyncPayloadRecord = new incremental_js_1.StreamRecord({
         label,
@@ -1197,6 +1246,10 @@ function executeStreamField(path, itemPath, item, exeContext, fieldNodes, info,
         exeContext,
         streamGroup,
     });
+    if ((0, incremental_js_1.isAtOrUnderNulledPath)(asyncPayloadRecord.path, exeContext.nulledPaths)) {
+        (0, incremental_js_1.cancelAsyncPayload)(exeContext, asyncPayloadRecord);
+        return asyncPayloadRecord;
+    }
     let completedItem;
     try {
         try {
@@ -1299,6 +1352,15 @@ async function executeStreamIterator(initialIndex, iterator, exeContext, fieldNo
             exeContext,
             streamGroup,
         });
+        if ((0, incremental_js_1.isAtOrUnderNulledPath)(asyncPayloadRecord.path, exeContext.nulledPaths)) {
+            (0, incremental_js_1.cancelAsyncPayload)(exeContext, asyncPayloadRecord);
+            if (iterator.return) {
+                iterator.return().catch(() => {
+                    // ignore errors
+                });
+            }
+            break;
+        }
         let iteration;
         try {
             iteration = await executeStreamIteratorItem(iterator, exeContext, fieldNodes, info, itemType, asyncPayloadRecord, itemPath);
@@ -1340,24 +1402,22 @@ async function executeStreamIterator(initialIndex, iterator, exeContext, fieldNo
 }
 function filterSubsequentPayloads(exeContext, nullPath, currentAsyncRecord) {
     const nullPathArray = (0, utils_1.pathToArray)(nullPath);
+    if (exeContext.nulledPaths) {
+        exeContext.nulledPaths.push(nullPathArray);
+    }
+    else if (exeContext.subsequentPayloads.size === 0) {
+        return;
+    }
     exeContext.subsequentPayloads.forEach(asyncRecord => {
-        if (asyncRecord === currentAsyncRecord) {
+        if (asyncRecord === currentAsyncRecord || asyncRecord.cancelled) {
             // don't remove payload from where error originates
             return;
         }
-        for (let i = 0; i < nullPathArray.length; i++) {
-            if (asyncRecord.path[i] !== nullPathArray[i]) {
-                // asyncRecord points to a path unaffected by this payload
-                return;
-            }
-        }
-        // asyncRecord path points to nulled error field
-        if ((0, incremental_js_1.isStreamPayload)(asyncRecord) && asyncRecord.iterator?.return) {
-            asyncRecord.iterator.return().catch(() => {
-                // ignore error
-            });
+        if (!(0, incremental_js_1.pathStartsWith)(asyncRecord.path, nullPathArray)) {
+            // ancestor or a different branch: ancestor patches are pruned at yield
+            return;
         }
-        (0, incremental_js_1.deleteAsyncPayload)(exeContext, asyncRecord);
+        (0, incremental_js_1.cancelAsyncPayload)(exeContext, asyncRecord);
     });
 }
 /**

package/cjs/execution/getBySet.js

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

package/cjs/execution/incremental.js

@@ -4,6 +4,10 @@ exports.StreamRecord = exports.DeferredFragmentRecord = exports.StreamGroup = vo
 exports.createIncrementalPublisherState = createIncrementalPublisherState;
 exports.createStreamGroupIfV02 = createStreamGroupIfV02;
 exports.deleteAsyncPayload = deleteAsyncPayload;
+exports.pathStartsWith = pathStartsWith;
+exports.isAtOrUnderNulledPath = isAtOrUnderNulledPath;
+exports.pruneUnmergeableIncrementalData = pruneUnmergeableIncrementalData;
+exports.cancelAsyncPayload = cancelAsyncPayload;
 exports.isStreamPayload = isStreamPayload;
 exports.collectInitialPending = collectInitialPending;
 exports.yieldSubsequentPayloads = yieldSubsequentPayloads;
@@ -54,6 +58,122 @@ function deleteAsyncPayload(exeContext, record) {
         record.streamGroup?.release();
     }
 }
+function pathStartsWith(path, prefix) {
+    if (prefix.length > path.length) {
+        return false;
+    }
+    for (let i = 0; i < prefix.length; i++) {
+        if (path[i] !== prefix[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+function isAtOrUnderNulledPath(path, nulledPaths) {
+    if (nulledPaths == null || nulledPaths.length === 0) {
+        return false;
+    }
+    for (const nulledPath of nulledPaths) {
+        if (pathStartsWith(path, nulledPath)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isStrictlyUnderNulledPath(path, nulledPaths) {
+    for (const nulledPath of nulledPaths) {
+        if (path.length > nulledPath.length && pathStartsWith(path, nulledPath)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isExactNulledPath(path, nulledPaths) {
+    for (const nulledPath of nulledPaths) {
+        if (path.length === nulledPath.length && pathStartsWith(path, nulledPath)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isEmptyIncrementalData(data) {
+    if (data == null) {
+        return true;
+    }
+    return (typeof data === 'object' &&
+        !Array.isArray(data) &&
+        Object.keys(data).length === 0);
+}
+/**
+ * Drop keys that would write into a subtree already nulled by error bubbling.
+ * Ancestor deferred records can still deliver sibling fields (e.g. `someField`
+ * next to a nulled `b.c`).
+ */
+function pruneUnmergeableIncrementalData(data, basePath, nulledPaths) {
+    if (nulledPaths == null || nulledPaths.length === 0 || data == null || typeof data !== 'object') {
+        return data;
+    }
+    if (Array.isArray(data)) {
+        return data.map((item, index) => {
+            const itemPath = [...basePath, index];
+            if (isAtOrUnderNulledPath(itemPath, nulledPaths)) {
+                return null;
+            }
+            return pruneUnmergeableIncrementalData(item, itemPath, nulledPaths);
+        });
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        const childPath = [...basePath, key];
+        if (isStrictlyUnderNulledPath(childPath, nulledPaths)) {
+            continue;
+        }
+        if (isExactNulledPath(childPath, nulledPaths)) {
+            // Keep a null delivered by this payload; drop a non-null write into an
+            // already-nulled object (Yaacov: unmergeable incremental).
+            if (value != null) {
+                continue;
+            }
+            result[key] = null;
+            continue;
+        }
+        result[key] = pruneUnmergeableIncrementalData(value, childPath, nulledPaths);
+    }
+    return result;
+}
+function isAnnounced(exeContext, record) {
+    const state = exeContext.publisher;
+    if (state == null) {
+        return false;
+    }
+    return state.announced.has(getPublishNode(record));
+}
+/**
+ * Cancel a subsequent record whose path is at or under a nulled position
+ * (graphql-js 17 `hasNulledPosition`). v0.2 records that were already
+ * announced stay in the set so the publisher can emit `completed` without
+ * incremental data.
+ */
+function cancelAsyncPayload(exeContext, record) {
+    record.cancelled = true;
+    if (isStreamPayload(record) && record.iterator?.return) {
+        record.iterator.return().catch(() => {
+            // ignore error
+        });
+    }
+    if (!record.isCompleted) {
+        if (isStreamPayload(record)) {
+            record.addItems(null);
+        }
+        else {
+            record.addData(null);
+        }
+    }
+    if (exeContext.incrementalSpec === 'v0.2' && isAnnounced(exeContext, record)) {
+        return;
+    }
+    deleteAsyncPayload(exeContext, record);
+}
 class DeferredFragmentRecord {
     type;
     errors;
@@ -63,7 +183,9 @@ class DeferredFragmentRecord {
     data;
     parentContext;
     deliveryParent;
+    deferUsage;
     isCompleted;
+    cancelled;
     _exeContext;
     _resolve;
     constructor(opts) {
@@ -72,10 +194,12 @@ class DeferredFragmentRecord {
         this.path = (0, utils_1.pathToArray)(opts.path);
         this.parentContext = opts.parentContext;
         this.deliveryParent = opts.deliveryParent ?? opts.parentContext;
+        this.deferUsage = opts.deferUsage;
         this.errors = [];
         this._exeContext = opts.exeContext;
         this._exeContext.subsequentPayloads.add(this);
         this.isCompleted = false;
+        this.cancelled = false;
         this.data = null;
         this.promise = new Promise(resolve => {
             this._resolve = MaybePromise => {
@@ -107,6 +231,7 @@ class StreamRecord {
     iterator;
     isCompletedIterator;
     isCompleted;
+    cancelled;
     streamGroup;
     _exeContext;
     _resolve;
@@ -123,6 +248,7 @@ class StreamRecord {
         this._exeContext.subsequentPayloads.add(this);
         this.streamGroup?.retain();
         this.isCompleted = false;
+        this.cancelled = false;
         this.items = null;
         this.promise = new Promise(resolve => {
             this._resolve = MaybePromise => {
@@ -190,6 +316,9 @@ function toPendingResult(state, record) {
     return pending;
 }
 function announceIfNeeded(record, state, pending) {
+    if (record.cancelled) {
+        return;
+    }
     const node = getPublishNode(record);
     if (state.announced.has(node)) {
         return;
@@ -222,6 +351,9 @@ function getCompletedIncrementalResults(exeContext) {
             continue;
         }
         deleteAsyncPayload(exeContext, asyncPayloadRecord);
+        if (asyncPayloadRecord.cancelled) {
+            continue;
+        }
         if (isStreamPayload(asyncPayloadRecord)) {
             const items = asyncPayloadRecord.items;
             if (asyncPayloadRecord.isCompletedIterator) {
@@ -231,8 +363,12 @@ function getCompletedIncrementalResults(exeContext) {
             incrementalResult.items = items;
         }
         else {
-            const data = asyncPayloadRecord.data;
-            incrementalResult.data = data ?? null;
+            const data = pruneUnmergeableIncrementalData(asyncPayloadRecord.data, asyncPayloadRecord.path, exeContext.nulledPaths);
+            if (isEmptyIncrementalData(data) && asyncPayloadRecord.errors.length === 0) {
+                continue;
+            }
+            incrementalResult.data =
+                data ?? null;
         }
         incrementalResult.path = asyncPayloadRecord.path;
         if (asyncPayloadRecord.label) {
@@ -272,13 +408,22 @@ function buildSubsequentV02(exeContext, completedRecords) {
                 continue;
             }
             const id = ensureId(state, record);
-            if (record.data == null && record.errors.length > 0) {
+            if (record.cancelled) {
+                completed.push({ id });
+                continue;
+            }
+            const data = pruneUnmergeableIncrementalData(record.data, record.path, exeContext.nulledPaths);
+            if ((record.data == null && record.errors.length > 0) ||
+                (isEmptyIncrementalData(data) && record.errors.length > 0)) {
                 completed.push({ id, errors: record.errors });
             }
+            else if (isEmptyIncrementalData(data) && record.errors.length === 0) {
+                completed.push({ id });
+            }
             else {
                 const incrementalResult = {
                     id,
-                    data: record.data ?? null,
+                    data: data ?? null,
                 };
                 if (record.errors.length > 0) {
                     incrementalResult.errors = record.errors;