@graphql-tools/utils 8.7.0 → 8.8.0-alpha-b76ec274.0

package/cjs/AggregateError.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAggregateError = exports.AggregateError = void 0;
+let AggregateErrorImpl;
+exports.AggregateError = AggregateErrorImpl;
+if (typeof AggregateError === 'undefined') {
+    class AggregateErrorClass extends Error {
+        constructor(errors, message = '') {
+            super(message);
+            this.errors = errors;
+            this.name = 'AggregateError';
+            Error.captureStackTrace(this, AggregateErrorClass);
+        }
+    }
+    exports.AggregateError = AggregateErrorImpl = function (errors, message) {
+        return new AggregateErrorClass(errors, message);
+    };
+}
+else {
+    exports.AggregateError = AggregateErrorImpl = AggregateError;
+}
+function isAggregateError(error) {
+    return 'errors' in error && Array.isArray(error['errors']);
+}
+exports.isAggregateError = isAggregateError;

package/cjs/Interfaces.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapperKind = void 0;
+var MapperKind;
+(function (MapperKind) {
+    MapperKind["TYPE"] = "MapperKind.TYPE";
+    MapperKind["SCALAR_TYPE"] = "MapperKind.SCALAR_TYPE";
+    MapperKind["ENUM_TYPE"] = "MapperKind.ENUM_TYPE";
+    MapperKind["COMPOSITE_TYPE"] = "MapperKind.COMPOSITE_TYPE";
+    MapperKind["OBJECT_TYPE"] = "MapperKind.OBJECT_TYPE";
+    MapperKind["INPUT_OBJECT_TYPE"] = "MapperKind.INPUT_OBJECT_TYPE";
+    MapperKind["ABSTRACT_TYPE"] = "MapperKind.ABSTRACT_TYPE";
+    MapperKind["UNION_TYPE"] = "MapperKind.UNION_TYPE";
+    MapperKind["INTERFACE_TYPE"] = "MapperKind.INTERFACE_TYPE";
+    MapperKind["ROOT_OBJECT"] = "MapperKind.ROOT_OBJECT";
+    MapperKind["QUERY"] = "MapperKind.QUERY";
+    MapperKind["MUTATION"] = "MapperKind.MUTATION";
+    MapperKind["SUBSCRIPTION"] = "MapperKind.SUBSCRIPTION";
+    MapperKind["DIRECTIVE"] = "MapperKind.DIRECTIVE";
+    MapperKind["FIELD"] = "MapperKind.FIELD";
+    MapperKind["COMPOSITE_FIELD"] = "MapperKind.COMPOSITE_FIELD";
+    MapperKind["OBJECT_FIELD"] = "MapperKind.OBJECT_FIELD";
+    MapperKind["ROOT_FIELD"] = "MapperKind.ROOT_FIELD";
+    MapperKind["QUERY_ROOT_FIELD"] = "MapperKind.QUERY_ROOT_FIELD";
+    MapperKind["MUTATION_ROOT_FIELD"] = "MapperKind.MUTATION_ROOT_FIELD";
+    MapperKind["SUBSCRIPTION_ROOT_FIELD"] = "MapperKind.SUBSCRIPTION_ROOT_FIELD";
+    MapperKind["INTERFACE_FIELD"] = "MapperKind.INTERFACE_FIELD";
+    MapperKind["INPUT_OBJECT_FIELD"] = "MapperKind.INPUT_OBJECT_FIELD";
+    MapperKind["ARGUMENT"] = "MapperKind.ARGUMENT";
+    MapperKind["ENUM_VALUE"] = "MapperKind.ENUM_VALUE";
+})(MapperKind = exports.MapperKind || (exports.MapperKind = {}));

package/cjs/addTypes.js

@@ -0,0 +1,62 @@
+"use strict";
+// addTypes uses toConfig to create a new schema with a new or replaced
+// type or directive. Rewiring is employed so that the replaced type can be
+// reconnected with the existing types.
+//
+// Rewiring is employed even for new types or directives as a convenience, so
+// that type references within the new type or directive do not have to be to
+// the identical objects within the original schema.
+//
+// In fact, the type references could even be stub types with entirely different
+// fields, as long as the type references share the same name as the desired
+// type within the original schema's type map.
+//
+// This makes it easy to perform simple schema operations (e.g. adding a new
+// type with a fiew fields removed from an existing type) that could normally be
+// performed by using toConfig directly, but is blocked if any intervening
+// more advanced schema operations have caused the types to be recreated via
+// rewiring.
+//
+// Type recreation happens, for example, with every use of mapSchema, as the
+// types are always rewired. If fields are selected and removed using
+// mapSchema, adding those fields to a new type can no longer be simply done
+// by toConfig, as the types are not the identical JavaScript objects, and
+// schema creation will fail with errors referencing multiple types with the
+// same names.
+//
+// enhanceSchema can fill this gap by adding an additional round of rewiring.
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addTypes = void 0;
+const graphql_1 = require("graphql");
+const getObjectTypeFromTypeMap_js_1 = require("./getObjectTypeFromTypeMap.js");
+const rewire_js_1 = require("./rewire.js");
+function addTypes(schema, newTypesOrDirectives) {
+    const config = schema.toConfig();
+    const originalTypeMap = {};
+    for (const type of config.types) {
+        originalTypeMap[type.name] = type;
+    }
+    const originalDirectiveMap = {};
+    for (const directive of config.directives) {
+        originalDirectiveMap[directive.name] = directive;
+    }
+    for (const newTypeOrDirective of newTypesOrDirectives) {
+        if ((0, graphql_1.isNamedType)(newTypeOrDirective)) {
+            originalTypeMap[newTypeOrDirective.name] = newTypeOrDirective;
+        }
+        else if ((0, graphql_1.isDirective)(newTypeOrDirective)) {
+            originalDirectiveMap[newTypeOrDirective.name] = newTypeOrDirective;
+        }
+    }
+    const { typeMap, directives } = (0, rewire_js_1.rewireTypes)(originalTypeMap, Object.values(originalDirectiveMap));
+    return new graphql_1.GraphQLSchema({
+        ...config,
+        query: (0, getObjectTypeFromTypeMap_js_1.getObjectTypeFromTypeMap)(typeMap, schema.getQueryType()),
+        mutation: (0, getObjectTypeFromTypeMap_js_1.getObjectTypeFromTypeMap)(typeMap, schema.getMutationType()),
+        subscription: (0, getObjectTypeFromTypeMap_js_1.getObjectTypeFromTypeMap)(typeMap, schema.getSubscriptionType()),
+        types: Object.values(typeMap),
+        directives,
+    });
+}
+exports.addTypes = addTypes;

package/cjs/astFromType.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.astFromType = void 0;
+const graphql_1 = require("graphql");
+const inspect_js_1 = require("./inspect.js");
+function astFromType(type) {
+    if ((0, graphql_1.isNonNullType)(type)) {
+        const innerType = astFromType(type.ofType);
+        if (innerType.kind === graphql_1.Kind.NON_NULL_TYPE) {
+            throw new Error(`Invalid type node ${(0, inspect_js_1.inspect)(type)}. Inner type of non-null type cannot be a non-null type.`);
+        }
+        return {
+            kind: graphql_1.Kind.NON_NULL_TYPE,
+            type: innerType,
+        };
+    }
+    else if ((0, graphql_1.isListType)(type)) {
+        return {
+            kind: graphql_1.Kind.LIST_TYPE,
+            type: astFromType(type.ofType),
+        };
+    }
+    return {
+        kind: graphql_1.Kind.NAMED_TYPE,
+        name: {
+            kind: graphql_1.Kind.NAME,
+            value: type.name,
+        },
+    };
+}
+exports.astFromType = astFromType;

package/cjs/astFromValueUntyped.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.astFromValueUntyped = void 0;
+const graphql_1 = require("graphql");
+/**
+ * Produces a GraphQL Value AST given a JavaScript object.
+ * Function will match JavaScript/JSON values to GraphQL AST schema format
+ * by using the following mapping.
+ *
+ * | JSON Value    | GraphQL Value        |
+ * | ------------- | -------------------- |
+ * | Object        | Input Object         |
+ * | Array         | List                 |
+ * | Boolean       | Boolean              |
+ * | String        | String               |
+ * | Number        | Int / Float          |
+ * | null          | NullValue            |
+ *
+ */
+function astFromValueUntyped(value) {
+    // only explicit null, not undefined, NaN
+    if (value === null) {
+        return { kind: graphql_1.Kind.NULL };
+    }
+    // undefined
+    if (value === undefined) {
+        return null;
+    }
+    // Convert JavaScript array to GraphQL list. If the GraphQLType is a list, but
+    // the value is not an array, convert the value using the list's item type.
+    if (Array.isArray(value)) {
+        const valuesNodes = [];
+        for (const item of value) {
+            const itemNode = astFromValueUntyped(item);
+            if (itemNode != null) {
+                valuesNodes.push(itemNode);
+            }
+        }
+        return { kind: graphql_1.Kind.LIST, values: valuesNodes };
+    }
+    if (typeof value === 'object') {
+        const fieldNodes = [];
+        for (const fieldName in value) {
+            const fieldValue = value[fieldName];
+            const ast = astFromValueUntyped(fieldValue);
+            if (ast) {
+                fieldNodes.push({
+                    kind: graphql_1.Kind.OBJECT_FIELD,
+                    name: { kind: graphql_1.Kind.NAME, value: fieldName },
+                    value: ast,
+                });
+            }
+        }
+        return { kind: graphql_1.Kind.OBJECT, fields: fieldNodes };
+    }
+    // Others serialize based on their corresponding JavaScript scalar types.
+    if (typeof value === 'boolean') {
+        return { kind: graphql_1.Kind.BOOLEAN, value };
+    }
+    // JavaScript numbers can be Int or Float values.
+    if (typeof value === 'number' && isFinite(value)) {
+        const stringNum = String(value);
+        return integerStringRegExp.test(stringNum)
+            ? { kind: graphql_1.Kind.INT, value: stringNum }
+            : { kind: graphql_1.Kind.FLOAT, value: stringNum };
+    }
+    if (typeof value === 'string') {
+        return { kind: graphql_1.Kind.STRING, value };
+    }
+    throw new TypeError(`Cannot convert value to AST: ${value}.`);
+}
+exports.astFromValueUntyped = astFromValueUntyped;
+/**
+ * IntValue:
+ *   - NegativeSign? 0
+ *   - NegativeSign? NonZeroDigit ( Digit+ )?
+ */
+const integerStringRegExp = /^-?(?:0|[1-9][0-9]*)$/;

package/cjs/build-operation-for-field.js

@@ -0,0 +1,351 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOperationNodeForField = void 0;
+const graphql_1 = require("graphql");
+const rootTypes_js_1 = require("./rootTypes.js");
+let operationVariables = [];
+let fieldTypeMap = new Map();
+function addOperationVariable(variable) {
+    operationVariables.push(variable);
+}
+function resetOperationVariables() {
+    operationVariables = [];
+}
+function resetFieldMap() {
+    fieldTypeMap = new Map();
+}
+function buildOperationNodeForField({ schema, kind, field, models, ignore = [], depthLimit, circularReferenceDepth, argNames, selectedFields = true, }) {
+    resetOperationVariables();
+    resetFieldMap();
+    const rootTypeNames = (0, rootTypes_js_1.getRootTypeNames)(schema);
+    const operationNode = buildOperationAndCollectVariables({
+        schema,
+        fieldName: field,
+        kind,
+        models: models || [],
+        ignore,
+        depthLimit: depthLimit || Infinity,
+        circularReferenceDepth: circularReferenceDepth || 1,
+        argNames,
+        selectedFields,
+        rootTypeNames,
+    });
+    // attach variables
+    operationNode.variableDefinitions = [...operationVariables];
+    resetOperationVariables();
+    resetFieldMap();
+    return operationNode;
+}
+exports.buildOperationNodeForField = buildOperationNodeForField;
+function buildOperationAndCollectVariables({ schema, fieldName, kind, models, ignore, depthLimit, circularReferenceDepth, argNames, selectedFields, rootTypeNames, }) {
+    const type = (0, rootTypes_js_1.getDefinedRootType)(schema, kind);
+    const field = type.getFields()[fieldName];
+    const operationName = `${fieldName}_${kind}`;
+    if (field.args) {
+        for (const arg of field.args) {
+            const argName = arg.name;
+            if (!argNames || argNames.includes(argName)) {
+                addOperationVariable(resolveVariable(arg, argName));
+            }
+        }
+    }
+    return {
+        kind: graphql_1.Kind.OPERATION_DEFINITION,
+        operation: kind,
+        name: {
+            kind: graphql_1.Kind.NAME,
+            value: operationName,
+        },
+        variableDefinitions: [],
+        selectionSet: {
+            kind: graphql_1.Kind.SELECTION_SET,
+            selections: [
+                resolveField({
+                    type,
+                    field,
+                    models,
+                    firstCall: true,
+                    path: [],
+                    ancestors: [],
+                    ignore,
+                    depthLimit,
+                    circularReferenceDepth,
+                    schema,
+                    depth: 0,
+                    argNames,
+                    selectedFields,
+                    rootTypeNames,
+                }),
+            ],
+        },
+    };
+}
+function resolveSelectionSet({ parent, type, models, firstCall, path, ancestors, ignore, depthLimit, circularReferenceDepth, schema, depth, argNames, selectedFields, rootTypeNames, }) {
+    if (typeof selectedFields === 'boolean' && depth > depthLimit) {
+        return;
+    }
+    if ((0, graphql_1.isUnionType)(type)) {
+        const types = type.getTypes();
+        return {
+            kind: graphql_1.Kind.SELECTION_SET,
+            selections: types
+                .filter(t => !hasCircularRef([...ancestors, t], {
+                depth: circularReferenceDepth,
+            }))
+                .map(t => {
+                return {
+                    kind: graphql_1.Kind.INLINE_FRAGMENT,
+                    typeCondition: {
+                        kind: graphql_1.Kind.NAMED_TYPE,
+                        name: {
+                            kind: graphql_1.Kind.NAME,
+                            value: t.name,
+                        },
+                    },
+                    selectionSet: resolveSelectionSet({
+                        parent: type,
+                        type: t,
+                        models,
+                        path,
+                        ancestors,
+                        ignore,
+                        depthLimit,
+                        circularReferenceDepth,
+                        schema,
+                        depth,
+                        argNames,
+                        selectedFields,
+                        rootTypeNames,
+                    }),
+                };
+            })
+                .filter(fragmentNode => { var _a, _b; return ((_b = (_a = fragmentNode === null || fragmentNode === void 0 ? void 0 : fragmentNode.selectionSet) === null || _a === void 0 ? void 0 : _a.selections) === null || _b === void 0 ? void 0 : _b.length) > 0; }),
+        };
+    }
+    if ((0, graphql_1.isInterfaceType)(type)) {
+        const types = Object.values(schema.getTypeMap()).filter((t) => (0, graphql_1.isObjectType)(t) && t.getInterfaces().includes(type));
+        return {
+            kind: graphql_1.Kind.SELECTION_SET,
+            selections: types
+                .filter(t => !hasCircularRef([...ancestors, t], {
+                depth: circularReferenceDepth,
+            }))
+                .map(t => {
+                return {
+                    kind: graphql_1.Kind.INLINE_FRAGMENT,
+                    typeCondition: {
+                        kind: graphql_1.Kind.NAMED_TYPE,
+                        name: {
+                            kind: graphql_1.Kind.NAME,
+                            value: t.name,
+                        },
+                    },
+                    selectionSet: resolveSelectionSet({
+                        parent: type,
+                        type: t,
+                        models,
+                        path,
+                        ancestors,
+                        ignore,
+                        depthLimit,
+                        circularReferenceDepth,
+                        schema,
+                        depth,
+                        argNames,
+                        selectedFields,
+                        rootTypeNames,
+                    }),
+                };
+            })
+                .filter(fragmentNode => { var _a, _b; return ((_b = (_a = fragmentNode === null || fragmentNode === void 0 ? void 0 : fragmentNode.selectionSet) === null || _a === void 0 ? void 0 : _a.selections) === null || _b === void 0 ? void 0 : _b.length) > 0; }),
+        };
+    }
+    if ((0, graphql_1.isObjectType)(type) && !rootTypeNames.has(type.name)) {
+        const isIgnored = ignore.includes(type.name) || ignore.includes(`${parent.name}.${path[path.length - 1]}`);
+        const isModel = models.includes(type.name);
+        if (!firstCall && isModel && !isIgnored) {
+            return {
+                kind: graphql_1.Kind.SELECTION_SET,
+                selections: [
+                    {
+                        kind: graphql_1.Kind.FIELD,
+                        name: {
+                            kind: graphql_1.Kind.NAME,
+                            value: 'id',
+                        },
+                    },
+                ],
+            };
+        }
+        const fields = type.getFields();
+        return {
+            kind: graphql_1.Kind.SELECTION_SET,
+            selections: Object.keys(fields)
+                .filter(fieldName => {
+                return !hasCircularRef([...ancestors, (0, graphql_1.getNamedType)(fields[fieldName].type)], {
+                    depth: circularReferenceDepth,
+                });
+            })
+                .map(fieldName => {
+                const selectedSubFields = typeof selectedFields === 'object' ? selectedFields[fieldName] : true;
+                if (selectedSubFields) {
+                    return resolveField({
+                        type,
+                        field: fields[fieldName],
+                        models,
+                        path: [...path, fieldName],
+                        ancestors,
+                        ignore,
+                        depthLimit,
+                        circularReferenceDepth,
+                        schema,
+                        depth,
+                        argNames,
+                        selectedFields: selectedSubFields,
+                        rootTypeNames,
+                    });
+                }
+                return null;
+            })
+                .filter((f) => {
+                var _a, _b;
+                if (f == null) {
+                    return false;
+                }
+                else if ('selectionSet' in f) {
+                    return !!((_b = (_a = f.selectionSet) === null || _a === void 0 ? void 0 : _a.selections) === null || _b === void 0 ? void 0 : _b.length);
+                }
+                return true;
+            }),
+        };
+    }
+}
+function resolveVariable(arg, name) {
+    function resolveVariableType(type) {
+        if ((0, graphql_1.isListType)(type)) {
+            return {
+                kind: graphql_1.Kind.LIST_TYPE,
+                type: resolveVariableType(type.ofType),
+            };
+        }
+        if ((0, graphql_1.isNonNullType)(type)) {
+            return {
+                kind: graphql_1.Kind.NON_NULL_TYPE,
+                // for v16 compatibility
+                type: resolveVariableType(type.ofType),
+            };
+        }
+        return {
+            kind: graphql_1.Kind.NAMED_TYPE,
+            name: {
+                kind: graphql_1.Kind.NAME,
+                value: type.name,
+            },
+        };
+    }
+    return {
+        kind: graphql_1.Kind.VARIABLE_DEFINITION,
+        variable: {
+            kind: graphql_1.Kind.VARIABLE,
+            name: {
+                kind: graphql_1.Kind.NAME,
+                value: name || arg.name,
+            },
+        },
+        type: resolveVariableType(arg.type),
+    };
+}
+function getArgumentName(name, path) {
+    return [...path, name].join('_');
+}
+function resolveField({ type, field, models, firstCall, path, ancestors, ignore, depthLimit, circularReferenceDepth, schema, depth, argNames, selectedFields, rootTypeNames, }) {
+    const namedType = (0, graphql_1.getNamedType)(field.type);
+    let args = [];
+    let removeField = false;
+    if (field.args && field.args.length) {
+        args = field.args
+            .map(arg => {
+            const argumentName = getArgumentName(arg.name, path);
+            if (argNames && !argNames.includes(argumentName)) {
+                if ((0, graphql_1.isNonNullType)(arg.type)) {
+                    removeField = true;
+                }
+                return null;
+            }
+            if (!firstCall) {
+                addOperationVariable(resolveVariable(arg, argumentName));
+            }
+            return {
+                kind: graphql_1.Kind.ARGUMENT,
+                name: {
+                    kind: graphql_1.Kind.NAME,
+                    value: arg.name,
+                },
+                value: {
+                    kind: graphql_1.Kind.VARIABLE,
+                    name: {
+                        kind: graphql_1.Kind.NAME,
+                        value: getArgumentName(arg.name, path),
+                    },
+                },
+            };
+        })
+            .filter(Boolean);
+    }
+    if (removeField) {
+        return null;
+    }
+    const fieldPath = [...path, field.name];
+    const fieldPathStr = fieldPath.join('.');
+    let fieldName = field.name;
+    if (fieldTypeMap.has(fieldPathStr) && fieldTypeMap.get(fieldPathStr) !== field.type.toString()) {
+        fieldName += field.type.toString().replace('!', 'NonNull');
+    }
+    fieldTypeMap.set(fieldPathStr, field.type.toString());
+    if (!(0, graphql_1.isScalarType)(namedType) && !(0, graphql_1.isEnumType)(namedType)) {
+        return {
+            kind: graphql_1.Kind.FIELD,
+            name: {
+                kind: graphql_1.Kind.NAME,
+                value: field.name,
+            },
+            ...(fieldName !== field.name && { alias: { kind: graphql_1.Kind.NAME, value: fieldName } }),
+            selectionSet: resolveSelectionSet({
+                parent: type,
+                type: namedType,
+                models,
+                firstCall,
+                path: fieldPath,
+                ancestors: [...ancestors, type],
+                ignore,
+                depthLimit,
+                circularReferenceDepth,
+                schema,
+                depth: depth + 1,
+                argNames,
+                selectedFields,
+                rootTypeNames,
+            }) || undefined,
+            arguments: args,
+        };
+    }
+    return {
+        kind: graphql_1.Kind.FIELD,
+        name: {
+            kind: graphql_1.Kind.NAME,
+            value: field.name,
+        },
+        ...(fieldName !== field.name && { alias: { kind: graphql_1.Kind.NAME, value: fieldName } }),
+        arguments: args,
+    };
+}
+function hasCircularRef(types, config = {
+    depth: 1,
+}) {
+    const type = types[types.length - 1];
+    if ((0, graphql_1.isScalarType)(type)) {
+        return false;
+    }
+    const size = types.filter(t => t.name === type.name).length;
+    return size > config.depth;
+}

package/cjs/collectFields.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSubFields = exports.collectFields = void 0;
+const memoize_js_1 = require("./memoize.js");
+const graphql_1 = require("graphql");
+// Taken from GraphQL-JS v16 for backwards compat
+function collectFields(schema, fragments, variableValues, runtimeType, selectionSet, fields, visitedFragmentNames) {
+    for (const selection of selectionSet.selections) {
+        switch (selection.kind) {
+            case graphql_1.Kind.FIELD: {
+                if (!shouldIncludeNode(variableValues, selection)) {
+                    continue;
+                }
+                const name = getFieldEntryKey(selection);
+                const fieldList = fields.get(name);
+                if (fieldList !== undefined) {
+                    fieldList.push(selection);
+                }
+                else {
+                    fields.set(name, [selection]);
+                }
+                break;
+            }
+            case graphql_1.Kind.INLINE_FRAGMENT: {
+                if (!shouldIncludeNode(variableValues, selection) ||
+                    !doesFragmentConditionMatch(schema, selection, runtimeType)) {
+                    continue;
+                }
+                collectFields(schema, fragments, variableValues, runtimeType, selection.selectionSet, fields, visitedFragmentNames);
+                break;
+            }
+            case graphql_1.Kind.FRAGMENT_SPREAD: {
+                const fragName = selection.name.value;
+                if (visitedFragmentNames.has(fragName) || !shouldIncludeNode(variableValues, selection)) {
+                    continue;
+                }
+                visitedFragmentNames.add(fragName);
+                const fragment = fragments[fragName];
+                if (!fragment || !doesFragmentConditionMatch(schema, fragment, runtimeType)) {
+                    continue;
+                }
+                collectFields(schema, fragments, variableValues, runtimeType, fragment.selectionSet, fields, visitedFragmentNames);
+                break;
+            }
+        }
+    }
+    return fields;
+}
+exports.collectFields = collectFields;
+/**
+ * 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 === null || skip === void 0 ? void 0 : skip['if']) === true) {
+        return false;
+    }
+    const include = (0, graphql_1.getDirectiveValues)(graphql_1.GraphQLIncludeDirective, node, variableValues);
+    if ((include === null || include === void 0 ? void 0 : 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)) {
+        const possibleTypes = schema.getPossibleTypes(conditionalType);
+        return possibleTypes.includes(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;
+}
+exports.collectSubFields = (0, memoize_js_1.memoize5)(function collectSubFields(schema, fragments, variableValues, type, fieldNodes) {
+    const subFieldNodes = new Map();
+    const visitedFragmentNames = new Set();
+    for (const fieldNode of fieldNodes) {
+        if (fieldNode.selectionSet) {
+            collectFields(schema, fragments, variableValues, type, fieldNode.selectionSet, subFieldNodes, visitedFragmentNames);
+        }
+    }
+    return subFieldNodes;
+});