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

package/esm/execution/buildFieldPlan.js

@@ -0,0 +1,58 @@
+import { getBySet } from './getBySet.js';
+import { isSameSet } from './isSameSet.js';
+export function buildFieldPlan(originalGroupedFieldSet, parentDeferUsages = new Set()) {
+    const groupedFieldSet = new Map();
+    const newGroupedFieldSets = new Map();
+    const map = new Map();
+    for (const [responseKey, fieldGroup] of originalGroupedFieldSet) {
+        const deferUsageSet = new Set();
+        let inOriginalResult = false;
+        for (const fieldDetails of fieldGroup) {
+            const deferUsage = fieldDetails.deferUsage;
+            if (deferUsage === undefined) {
+                inOriginalResult = true;
+                continue;
+            }
+            deferUsageSet.add(deferUsage);
+        }
+        if (inOriginalResult) {
+            deferUsageSet.clear();
+        }
+        else {
+            deferUsageSet.forEach(deferUsage => {
+                const ancestors = getAncestors(deferUsage);
+                for (const ancestor of ancestors) {
+                    if (deferUsageSet.has(ancestor)) {
+                        deferUsageSet.delete(deferUsage);
+                    }
+                }
+            });
+        }
+        map.set(responseKey, { deferUsageSet, fieldGroup });
+    }
+    for (const [responseKey, { deferUsageSet, fieldGroup }] of map) {
+        if (isSameSet(deferUsageSet, parentDeferUsages)) {
+            groupedFieldSet.set(responseKey, fieldGroup);
+            continue;
+        }
+        let newGroupedFieldSet = getBySet(newGroupedFieldSets, deferUsageSet);
+        if (newGroupedFieldSet === undefined) {
+            newGroupedFieldSet = new Map();
+            newGroupedFieldSets.set(deferUsageSet, newGroupedFieldSet);
+        }
+        newGroupedFieldSet.set(responseKey, fieldGroup);
+    }
+    return {
+        groupedFieldSet,
+        newGroupedFieldSets,
+    };
+}
+function getAncestors(deferUsage) {
+    const ancestors = [];
+    let parentDeferUsage = deferUsage.parentDeferUsage;
+    while (parentDeferUsage !== undefined) {
+        ancestors.unshift(parentDeferUsage);
+        parentDeferUsage = parentDeferUsage.parentDeferUsage;
+    }
+    return ancestors;
+}

package/esm/execution/collectFields.js

@@ -0,0 +1,169 @@
+import { getDirectiveValues, GraphQLIncludeDirective, GraphQLSkipDirective, isAbstractType, Kind, typeFromAST, } from 'graphql';
+import { GraphQLDeferDirective } from '@graphql-tools/utils';
+import { AccumulatorMap } from './AccumulatorMap.js';
+import { invariant } from './invariant.js';
+/**
+ * Given a selectionSet, collects all of the fields and returns them.
+ *
+ * CollectFields requires the "runtime type" of an object. For a field that
+ * returns an Interface or Union type, the "runtime type" will be the actual
+ * object type returned by that field.
+ *
+ * @internal
+ */
+export function collectFields(schema, fragments, variableValues, runtimeType, operation) {
+    const groupedFieldSet = new AccumulatorMap();
+    const newDeferUsages = [];
+    const context = {
+        schema,
+        fragments,
+        variableValues,
+        runtimeType,
+        operation,
+        visitedFragmentNames: new Set(),
+    };
+    collectFieldsImpl(context, operation.selectionSet, groupedFieldSet, newDeferUsages);
+    return { groupedFieldSet, newDeferUsages };
+}
+/**
+ * Given an array of field nodes, collects all of the subfields of the passed
+ * in fields, and returns them at the end.
+ *
+ * CollectSubFields requires the "return type" of an object. For a field that
+ * returns an Interface or Union type, the "return type" will be the actual
+ * object type returned by that field.
+ *
+ * @internal
+ */
+export function collectSubfields(schema, fragments, variableValues, operation, returnType, fieldGroup) {
+    const context = {
+        schema,
+        fragments,
+        variableValues,
+        runtimeType: returnType,
+        operation,
+        visitedFragmentNames: new Set(),
+    };
+    const subGroupedFieldSet = new AccumulatorMap();
+    const newDeferUsages = [];
+    for (const fieldDetail of fieldGroup) {
+        const node = fieldDetail.node;
+        if (node.selectionSet) {
+            collectFieldsImpl(context, node.selectionSet, subGroupedFieldSet, newDeferUsages, fieldDetail.deferUsage);
+        }
+    }
+    return {
+        groupedFieldSet: subGroupedFieldSet,
+        newDeferUsages,
+    };
+}
+function collectFieldsImpl(context, selectionSet, groupedFieldSet, newDeferUsages, deferUsage) {
+    const { schema, fragments, variableValues, runtimeType, operation, visitedFragmentNames } = context;
+    for (const selection of selectionSet.selections) {
+        switch (selection.kind) {
+            case Kind.FIELD: {
+                if (!shouldIncludeNode(variableValues, selection)) {
+                    continue;
+                }
+                groupedFieldSet.add(getFieldEntryKey(selection), {
+                    node: selection,
+                    deferUsage,
+                });
+                break;
+            }
+            case Kind.INLINE_FRAGMENT: {
+                if (!shouldIncludeNode(variableValues, selection) ||
+                    !doesFragmentConditionMatch(schema, selection, runtimeType)) {
+                    continue;
+                }
+                const newDeferUsage = getDeferUsage(operation, 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 Kind.FRAGMENT_SPREAD: {
+                const fragName = selection.name.value;
+                const newDeferUsage = getDeferUsage(operation, variableValues, selection, deferUsage);
+                if (!newDeferUsage &&
+                    (visitedFragmentNames.has(fragName) || !shouldIncludeNode(variableValues, selection))) {
+                    continue;
+                }
+                const fragment = fragments[fragName];
+                if (fragment == null || !doesFragmentConditionMatch(schema, fragment, runtimeType)) {
+                    continue;
+                }
+                if (!newDeferUsage) {
+                    visitedFragmentNames.add(fragName);
+                    collectFieldsImpl(context, fragment.selectionSet, groupedFieldSet, newDeferUsages, deferUsage);
+                }
+                else {
+                    newDeferUsages.push(newDeferUsage);
+                    collectFieldsImpl(context, fragment.selectionSet, groupedFieldSet, newDeferUsages, newDeferUsage);
+                }
+                break;
+            }
+        }
+    }
+}
+/**
+ * Returns an object containing the `@defer` arguments if a field should be
+ * deferred based on the experimental flag, defer directive present and
+ * not disabled by the "if" argument.
+ */
+function getDeferUsage(operation, variableValues, node, parentDeferUsage) {
+    const defer = getDirectiveValues(GraphQLDeferDirective, node, variableValues);
+    if (!defer) {
+        return;
+    }
+    if (defer['if'] === false) {
+        return;
+    }
+    invariant(operation.operation !== 'subscription', '`@defer` directive not supported on subscription operations. Disable `@defer` by setting the `if` argument to `false`.');
+    return {
+        label: typeof defer['label'] === 'string' ? defer['label'] : undefined,
+        parentDeferUsage,
+    };
+}
+/**
+ * Determines if a field should be included based on the `@include` and `@skip`
+ * directives, where `@skip` has higher precedence than `@include`.
+ */
+function shouldIncludeNode(variableValues, node) {
+    const skip = getDirectiveValues(GraphQLSkipDirective, node, variableValues);
+    if (skip?.['if'] === true) {
+        return false;
+    }
+    const include = getDirectiveValues(GraphQLIncludeDirective, node, variableValues);
+    if (include?.['if'] === false) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Determines if a fragment is applicable to the given type.
+ */
+function doesFragmentConditionMatch(schema, fragment, type) {
+    const typeConditionNode = fragment.typeCondition;
+    if (!typeConditionNode) {
+        return true;
+    }
+    const conditionalType = typeFromAST(schema, typeConditionNode);
+    if (conditionalType === type) {
+        return true;
+    }
+    if (isAbstractType(conditionalType)) {
+        return schema.isSubType(conditionalType, type);
+    }
+    return false;
+}
+/**
+ * Implements the logic to compute the key of a given field's entry
+ */
+function getFieldEntryKey(node) {
+    return node.alias ? node.alias.value : node.name.value;
+}