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

package/cjs/execution/collectFields.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSubfields = exports.collectFields = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const AccumulatorMap_js_1 = require("./AccumulatorMap.js");
+const invariant_js_1 = require("./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
+ */
+function collectFields(schema, fragments, variableValues, runtimeType, operation) {
+    const groupedFieldSet = new AccumulatorMap_js_1.AccumulatorMap();
+    const newDeferUsages = [];
+    const context = {
+        schema,
+        fragments,
+        variableValues,
+        runtimeType,
+        operation,
+        visitedFragmentNames: new Set(),
+    };
+    collectFieldsImpl(context, operation.selectionSet, groupedFieldSet, newDeferUsages);
+    return { groupedFieldSet, newDeferUsages };
+}
+exports.collectFields = collectFields;
+/**
+ * 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
+ */
+function collectSubfields(schema, fragments, variableValues, operation, returnType, fieldGroup) {
+    const context = {
+        schema,
+        fragments,
+        variableValues,
+        runtimeType: returnType,
+        operation,
+        visitedFragmentNames: new Set(),
+    };
+    const subGroupedFieldSet = new AccumulatorMap_js_1.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,
+    };
+}
+exports.collectSubfields = collectSubfields;
+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 graphql_1.Kind.FIELD: {
+                if (!shouldIncludeNode(variableValues, selection)) {
+                    continue;
+                }
+                groupedFieldSet.add(getFieldEntryKey(selection), {
+                    node: selection,
+                    deferUsage,
+                });
+                break;
+            }
+            case graphql_1.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 graphql_1.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 = (0, graphql_1.getDirectiveValues)(utils_1.GraphQLDeferDirective, node, variableValues);
+    if (!defer) {
+        return;
+    }
+    if (defer['if'] === false) {
+        return;
+    }
+    (0, invariant_js_1.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 = (0, graphql_1.getDirectiveValues)(graphql_1.GraphQLSkipDirective, node, variableValues);
+    if (skip?.['if'] === true) {
+        return false;
+    }
+    const include = (0, graphql_1.getDirectiveValues)(graphql_1.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 = (0, graphql_1.typeFromAST)(schema, typeConditionNode);
+    if (conditionalType === type) {
+        return true;
+    }
+    if ((0, graphql_1.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;
+}