@graphql-tools/executor 4.1.1 → 4.1.2-alpha-20261020170708-72d61a1bbfbf64a0a9d61e801c80001b7ea79dc3

package/cjs/execution/incrementalCollect.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectIncrementalFields = collectIncrementalFields;
+exports.collectIncrementalSubfields = collectIncrementalSubfields;
+exports.buildExecutionPlan = buildExecutionPlan;
+exports.deferUsageForFieldNode = deferUsageForFieldNode;
+exports.groupedFieldSetToFieldMap = groupedFieldSetToFieldMap;
+exports.rootDeferUsage = rootDeferUsage;
+exports.labelForDeferUsageSet = labelForDeferUsageSet;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const getBySet_js_1 = require("./getBySet.js");
+const isSameSet_js_1 = require("./isSameSet.js");
+class FieldDetailsMap extends Map {
+    add(key, item) {
+        const group = this.get(key);
+        if (group === undefined) {
+            this.set(key, [item]);
+        }
+        else {
+            group.push(item);
+        }
+    }
+}
+function collectIncrementalFields(schema, fragments, variableValues, runtimeType, selectionSet, parentDeferUsage) {
+    const groupedFieldSet = new FieldDetailsMap();
+    const newDeferUsages = [];
+    const context = {
+        schema,
+        fragments,
+        variableValues,
+        runtimeType,
+        visitedFragmentNames: new Map(),
+    };
+    collectFieldsImpl(context, selectionSet, groupedFieldSet, newDeferUsages, parentDeferUsage);
+    return { groupedFieldSet, newDeferUsages };
+}
+const deferUsageByFieldNode = new WeakMap();
+function collectIncrementalSubfields(schema, fragments, variableValues, returnType, fieldNodes, parentDeferUsage) {
+    const groupedFieldSet = new FieldDetailsMap();
+    const newDeferUsages = [];
+    const context = {
+        schema,
+        fragments,
+        variableValues,
+        runtimeType: returnType,
+        visitedFragmentNames: new Map(),
+    };
+    for (const node of fieldNodes) {
+        if (node.selectionSet) {
+            const deferUsage = deferUsageByFieldNode.has(node)
+                ? deferUsageByFieldNode.get(node)
+                : parentDeferUsage;
+            collectFieldsImpl(context, node.selectionSet, groupedFieldSet, newDeferUsages, deferUsage);
+        }
+    }
+    return { groupedFieldSet, newDeferUsages };
+}
+function collectFieldsImpl(context, selectionSet, groupedFieldSet, newDeferUsages, deferUsage) {
+    const { schema, fragments, variableValues, runtimeType, visitedFragmentNames } = context;
+    for (const selection of selectionSet.selections) {
+        switch (selection.kind) {
+            case graphql_1.Kind.FIELD: {
+                if (!(0, utils_1.shouldIncludeNode)(variableValues, selection)) {
+                    continue;
+                }
+                groupedFieldSet.add((0, utils_1.getFieldEntryKey)(selection), {
+                    node: selection,
+                    deferUsage,
+                });
+                break;
+            }
+            case graphql_1.Kind.INLINE_FRAGMENT: {
+                if (!(0, utils_1.shouldIncludeNode)(variableValues, selection) ||
+                    !(0, utils_1.doesFragmentConditionMatch)(schema, selection, runtimeType)) {
+                    continue;
+                }
+                const newDeferUsage = getDeferUsage(variableValues, selection, deferUsage);
+                if (!newDeferUsage) {
+                    collectFieldsImpl(context, selection.selectionSet, groupedFieldSet, newDeferUsages, deferUsage);
+                }
+                else {
+                    newDeferUsages.push(newDeferUsage);
+                    collectFieldsImpl(context, selection.selectionSet, groupedFieldSet, newDeferUsages, newDeferUsage);
+                }
+                break;
+            }
+            case graphql_1.Kind.FRAGMENT_SPREAD: {
+                const fragName = selection.name.value;
+                if (!(0, utils_1.shouldIncludeNode)(variableValues, selection)) {
+                    continue;
+                }
+                const fragment = fragments[fragName];
+                if (!fragment || !(0, utils_1.doesFragmentConditionMatch)(schema, fragment, runtimeType)) {
+                    continue;
+                }
+                const newDeferUsage = getDeferUsage(variableValues, selection, deferUsage);
+                const visitedAsDeferred = visitedFragmentNames.get(fragName);
+                let maybeNewDeferUsage;
+                if (!newDeferUsage) {
+                    if (visitedAsDeferred === false) {
+                        continue;
+                    }
+                    visitedFragmentNames.set(fragName, false);
+                    maybeNewDeferUsage = deferUsage;
+                }
+                else {
+                    if (visitedAsDeferred !== undefined) {
+                        continue;
+                    }
+                    visitedFragmentNames.set(fragName, true);
+                    newDeferUsages.push(newDeferUsage);
+                    maybeNewDeferUsage = newDeferUsage;
+                }
+                collectFieldsImpl(context, fragment.selectionSet, groupedFieldSet, newDeferUsages, maybeNewDeferUsage);
+                break;
+            }
+        }
+    }
+}
+function getDeferUsage(variableValues, node, parentDeferUsage) {
+    const defer = (0, utils_1.getDirectiveValues)(utils_1.GraphQLDeferDirective, node, variableValues);
+    if (!defer || defer['if'] === false) {
+        return;
+    }
+    return {
+        label: typeof defer['label'] === 'string' ? defer['label'] : undefined,
+        parentDeferUsage,
+    };
+}
+function buildExecutionPlan(originalGroupedFieldSet, parentDeferUsages = new Set()) {
+    const groupedFieldSet = new Map();
+    const newGroupedFieldSets = new Map();
+    for (const [responseKey, fieldDetailsList] of originalGroupedFieldSet) {
+        const filteredDeferUsageSet = getFilteredDeferUsageSet(fieldDetailsList);
+        if ((0, isSameSet_js_1.isSameSet)(filteredDeferUsageSet, parentDeferUsages)) {
+            groupedFieldSet.set(responseKey, fieldDetailsList);
+            continue;
+        }
+        let newGroupedFieldSet = (0, getBySet_js_1.getBySet)(newGroupedFieldSets, filteredDeferUsageSet);
+        if (newGroupedFieldSet === undefined) {
+            newGroupedFieldSet = new Map();
+            newGroupedFieldSets.set(filteredDeferUsageSet, newGroupedFieldSet);
+        }
+        newGroupedFieldSet.set(responseKey, fieldDetailsList);
+    }
+    return { groupedFieldSet, newGroupedFieldSets };
+}
+function getFilteredDeferUsageSet(fieldDetailsList) {
+    const filteredDeferUsageSet = new Set();
+    for (const fieldDetails of fieldDetailsList) {
+        const deferUsage = fieldDetails.deferUsage;
+        if (deferUsage === undefined) {
+            filteredDeferUsageSet.clear();
+            return filteredDeferUsageSet;
+        }
+        filteredDeferUsageSet.add(deferUsage);
+    }
+    for (const deferUsage of filteredDeferUsageSet) {
+        let parentDeferUsage = deferUsage.parentDeferUsage;
+        while (parentDeferUsage !== undefined) {
+            if (filteredDeferUsageSet.has(parentDeferUsage)) {
+                filteredDeferUsageSet.delete(deferUsage);
+                break;
+            }
+            parentDeferUsage = parentDeferUsage.parentDeferUsage;
+        }
+    }
+    return filteredDeferUsageSet;
+}
+function deferUsageForFieldNode(node) {
+    return deferUsageByFieldNode.get(node);
+}
+function groupedFieldSetToFieldMap(groupedFieldSet) {
+    const fields = new Map();
+    for (const [responseKey, fieldDetailsList] of groupedFieldSet) {
+        fields.set(responseKey, fieldDetailsList.map(details => {
+            deferUsageByFieldNode.set(details.node, details.deferUsage);
+            return details.node;
+        }));
+    }
+    return fields;
+}
+function rootDeferUsage(deferUsageSet) {
+    for (const usage of deferUsageSet) {
+        if (usage.parentDeferUsage == null || !deferUsageSet.has(usage.parentDeferUsage)) {
+            return usage;
+        }
+    }
+    return undefined;
+}
+function labelForDeferUsageSet(deferUsageSet) {
+    return rootDeferUsage(deferUsageSet)?.label;
+}

package/cjs/execution/isSameSet.js

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

package/esm/execution/execute.js

@@ -1,12 +1,14 @@
-import { assertValidSchema, getArgumentValues, getVariableValues, GraphQLError, isAbstractType, isLeafType, isListType, isNonNullType, isObjectType, Kind, SchemaMetaFieldDef, TypeMetaFieldDef, TypeNameMetaFieldDef, versionInfo, } from 'graphql';
+import { assertValidSchema, defaultFieldResolver, defaultTypeResolver, getArgumentValues, getVariableValues, GraphQLError, isAbstractType, isLeafType, isListType, isNonNullType, isObjectType, Kind, SchemaMetaFieldDef, TypeMetaFieldDef, TypeNameMetaFieldDef, versionInfo, } from 'graphql';
 import { collectSubFields as _collectSubfields, addPath, collectFields, getDefinedRootType, getDirectiveValues, GraphQLStreamDirective, inspect, isAsyncIterable, isIterableObject, isObjectLike, locatedError, memoize2, memoize3, pathToArray, promiseReduce, } from '@graphql-tools/utils';
 import { DisposableSymbols } from '@whatwg-node/disposablestack';
 import { fakePromise, handleMaybePromise, isPromise, mapAsyncIterator, } from '@whatwg-node/promise-helpers';
 import { coerceError } from './coerceError.js';
 import { flattenAsyncIterable } from './flattenAsyncIterable.js';
-import { collectInitialPending, createIncrementalPublisherState, createStreamGroupIfV02, DeferredFragmentRecord, deleteAsyncPayload, isStreamPayload, StreamRecord, yieldSubsequentPayloads, } from './incremental.js';
+import { cancelAsyncPayload, collectInitialPending, createIncrementalPublisherState, createStreamGroupIfV02, DeferredFragmentRecord, isAtOrUnderNulledPath, pathStartsWith, StreamRecord, yieldSubsequentPayloads, } from './incremental.js';
+import { buildExecutionPlan, collectIncrementalFields, collectIncrementalSubfields, deferUsageForFieldNode, groupedFieldSetToFieldMap, labelForDeferUsageSet, rootDeferUsage, } from './incrementalCollect.js';
 import { invariant } from './invariant.js';
 import { promiseForObject } from './promiseForObject.js';
+export { defaultFieldResolver, defaultTypeResolver };
 const EMPTY_ARGS = Object.freeze(Object.create(null));
 const isGraphQL17 = versionInfo.major >= 17;
 /**
@@ -387,18 +389,52 @@ function executeOperation(exeContext) {
     const { fields: rootFields, patches } = 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;
+    }
+    exeContext.nulledPaths ??= [];
+    const { groupedFieldSet } = collectIncrementalFields(schema, fragments, variableValues, rootType, operation.selectionSet);
+    const { groupedFieldSet: initialFields, newGroupedFieldSets } = buildExecutionPlan(groupedFieldSet);
+    const plannedRootFields = groupedFieldSetToFieldMap(initialFields);
     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 (isAtOrUnderNulledPath(pathToArray(path), exeContext.nulledPaths)) {
+        return;
+    }
+    const records = new Map();
+    const groups = [...newGroupedFieldSets.entries()].sort(([a], [b]) => deferUsageDepth(rootDeferUsage(a)) - deferUsageDepth(rootDeferUsage(b)));
+    for (const [deferUsageSet, groupedFieldSet] of groups) {
+        const usage = rootDeferUsage(deferUsageSet);
+        const deliveryParent = (usage?.parentDeferUsage && records.get(usage.parentDeferUsage)) ?? parentContext;
+        const record = executeDeferredFragment(exeContext, parentType, sourceValue, groupedFieldSetToFieldMap(groupedFieldSet), labelForDeferUsageSet(deferUsageSet), path, parentContext, undefined, deliveryParent, usage);
+        if (usage) {
+            records.set(usage, record);
+        }
+    }
+}
+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.
@@ -872,69 +908,29 @@ 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.
- */
-export const defaultTypeResolver = function (value, contextValue, info, abstractType) {
-    // First, look for `__typename`.
-    if (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 (isPromise(isTypeOfResult)) {
-                promisedIsTypeOfResults[i] = isTypeOfResult;
-            }
-            else if (isTypeOfResult) {
-                return type.name;
-            }
-        }
-    }
-    if (promisedIsTypeOfResults.length) {
-        return Promise.all(promisedIsTypeOfResults).then(isTypeOfResults => {
-            for (let i = 0; i < isTypeOfResults.length; i++) {
-                if (isTypeOfResults[i]) {
-                    return possibleTypes[i].name;
-                }
+    if (subPatches.length === 0 && exeContext.nulledPaths == null) {
+        return executeFields(exeContext, returnType, result, path, subFieldNodes, asyncPayloadRecord);
+    }
+    exeContext.nulledPaths ??= [];
+    const parentDeferUsage = asyncPayloadRecord?.type === 'defer' ? asyncPayloadRecord.deferUsage : undefined;
+    const { groupedFieldSet } = collectIncrementalSubfields(exeContext.schema, exeContext.fragments, exeContext.variableValues, returnType, fieldNodes, parentDeferUsage);
+    const parentDeferUsages = new Set();
+    if (parentDeferUsage) {
+        parentDeferUsages.add(parentDeferUsage);
+    }
+    else if (asyncPayloadRecord?.type === 'stream') {
+        for (const node of fieldNodes) {
+            const usage = deferUsageForFieldNode(node);
+            if (usage) {
+                parentDeferUsages.add(usage);
             }
-        });
-    }
-};
-/**
- * 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.
- */
-export const defaultFieldResolver = function (source, args, contextValue, info) {
-    // ensure source is a value for which property access is acceptable.
-    if (isObjectLike(source) || typeof source === 'function') {
-        const property = source[info.fieldName];
-        if (typeof property === 'function') {
-            return source[info.fieldName](args, contextValue, info);
         }
-        return property;
     }
-};
+    const { groupedFieldSet: initialFields, newGroupedFieldSets } = buildExecutionPlan(groupedFieldSet, parentDeferUsages);
+    const subFields = executeFields(exeContext, returnType, result, path, groupedFieldSetToFieldMap(initialFields), 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
@@ -1142,13 +1138,14 @@ function assertEventStream(result, signal, onSignalAbort) {
     }
     return result;
 }
-function executeDeferredFragment(exeContext, parentType, sourceValue, fields, label, path, parentContext, nestedPatches, deliveryParent) {
+function executeDeferredFragment(exeContext, parentType, sourceValue, fields, label, path, parentContext, nestedPatches, deliveryParent, deferUsage) {
     const asyncPayloadRecord = new DeferredFragmentRecord({
         label,
         path,
         parentContext,
         deliveryParent: deliveryParent ?? parentContext,
         exeContext,
+        deferUsage,
     });
     let promiseOrData;
     try {
@@ -1172,6 +1169,7 @@ function executeDeferredFragment(exeContext, parentType, sourceValue, fields, la
             parentContext, nested.patches, asyncPayloadRecord);
         }
     }
+    return asyncPayloadRecord;
 }
 function executeStreamField(path, itemPath, item, exeContext, fieldNodes, info, itemType, label, parentContext, streamGroup) {
     const asyncPayloadRecord = new StreamRecord({
@@ -1181,6 +1179,10 @@ function executeStreamField(path, itemPath, item, exeContext, fieldNodes, info,
         exeContext,
         streamGroup,
     });
+    if (isAtOrUnderNulledPath(asyncPayloadRecord.path, exeContext.nulledPaths)) {
+        cancelAsyncPayload(exeContext, asyncPayloadRecord);
+        return asyncPayloadRecord;
+    }
     let completedItem;
     try {
         try {
@@ -1283,6 +1285,15 @@ async function executeStreamIterator(initialIndex, iterator, exeContext, fieldNo
             exeContext,
             streamGroup,
         });
+        if (isAtOrUnderNulledPath(asyncPayloadRecord.path, exeContext.nulledPaths)) {
+            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);
@@ -1324,24 +1335,22 @@ async function executeStreamIterator(initialIndex, iterator, exeContext, fieldNo
 }
 function filterSubsequentPayloads(exeContext, nullPath, currentAsyncRecord) {
     const nullPathArray = 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 (isStreamPayload(asyncRecord) && asyncRecord.iterator?.return) {
-            asyncRecord.iterator.return().catch(() => {
-                // ignore error
-            });
+        if (!pathStartsWith(asyncRecord.path, nullPathArray)) {
+            // ancestor or a different branch: ancestor patches are pruned at yield
+            return;
         }
-        deleteAsyncPayload(exeContext, asyncRecord);
+        cancelAsyncPayload(exeContext, asyncRecord);
     });
 }
 /**

package/esm/execution/getBySet.js

@@ -0,0 +1,10 @@
+import { isSameSet } from './isSameSet.js';
+/** @internal */
+export function getBySet(map, setToMatch) {
+    for (const set of map.keys()) {
+        if (isSameSet(set, setToMatch)) {
+            return map.get(set);
+        }
+    }
+    return undefined;
+}