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

package/esm/get-directives.js

@@ -0,0 +1,96 @@
+import { getArgumentValues } from './getArgumentValues.js';
+export function getDirectivesInExtensions(node, pathToDirectivesInExtensions = ['directives']) {
+    return pathToDirectivesInExtensions.reduce((acc, pathSegment) => (acc == null ? acc : acc[pathSegment]), node === null || node === void 0 ? void 0 : node.extensions);
+}
+function _getDirectiveInExtensions(directivesInExtensions, directiveName) {
+    const directiveInExtensions = directivesInExtensions.filter(directiveAnnotation => directiveAnnotation.name === directiveName);
+    if (!directiveInExtensions.length) {
+        return undefined;
+    }
+    return directiveInExtensions.map(directive => { var _a; return (_a = directive.args) !== null && _a !== void 0 ? _a : {}; });
+}
+export function getDirectiveInExtensions(node, directiveName, pathToDirectivesInExtensions = ['directives']) {
+    const directivesInExtensions = pathToDirectivesInExtensions.reduce((acc, pathSegment) => (acc == null ? acc : acc[pathSegment]), node === null || node === void 0 ? void 0 : node.extensions);
+    if (directivesInExtensions === undefined) {
+        return undefined;
+    }
+    if (Array.isArray(directivesInExtensions)) {
+        return _getDirectiveInExtensions(directivesInExtensions, directiveName);
+    }
+    // Support condensed format by converting to longer format
+    // The condensed format does not preserve ordering of directives when  repeatable directives are used.
+    // See https://github.com/ardatan/graphql-tools/issues/2534
+    const reformattedDirectivesInExtensions = [];
+    for (const [name, argsOrArrayOfArgs] of Object.entries(directivesInExtensions)) {
+        if (Array.isArray(argsOrArrayOfArgs)) {
+            for (const args of argsOrArrayOfArgs) {
+                reformattedDirectivesInExtensions.push({ name, args });
+            }
+        }
+        else {
+            reformattedDirectivesInExtensions.push({ name, args: argsOrArrayOfArgs });
+        }
+    }
+    return _getDirectiveInExtensions(reformattedDirectivesInExtensions, directiveName);
+}
+export function getDirectives(schema, node, pathToDirectivesInExtensions = ['directives']) {
+    const directivesInExtensions = getDirectivesInExtensions(node, pathToDirectivesInExtensions);
+    if (directivesInExtensions != null && directivesInExtensions.length > 0) {
+        return directivesInExtensions;
+    }
+    const schemaDirectives = schema && schema.getDirectives ? schema.getDirectives() : [];
+    const schemaDirectiveMap = schemaDirectives.reduce((schemaDirectiveMap, schemaDirective) => {
+        schemaDirectiveMap[schemaDirective.name] = schemaDirective;
+        return schemaDirectiveMap;
+    }, {});
+    let astNodes = [];
+    if (node.astNode) {
+        astNodes.push(node.astNode);
+    }
+    if ('extensionASTNodes' in node && node.extensionASTNodes) {
+        astNodes = [...astNodes, ...node.extensionASTNodes];
+    }
+    const result = [];
+    for (const astNode of astNodes) {
+        if (astNode.directives) {
+            for (const directiveNode of astNode.directives) {
+                const schemaDirective = schemaDirectiveMap[directiveNode.name.value];
+                if (schemaDirective) {
+                    result.push({ name: directiveNode.name.value, args: getArgumentValues(schemaDirective, directiveNode) });
+                }
+            }
+        }
+    }
+    return result;
+}
+export function getDirective(schema, node, directiveName, pathToDirectivesInExtensions = ['directives']) {
+    const directiveInExtensions = getDirectiveInExtensions(node, directiveName, pathToDirectivesInExtensions);
+    if (directiveInExtensions != null) {
+        return directiveInExtensions;
+    }
+    const schemaDirective = schema && schema.getDirective ? schema.getDirective(directiveName) : undefined;
+    if (schemaDirective == null) {
+        return undefined;
+    }
+    let astNodes = [];
+    if (node.astNode) {
+        astNodes.push(node.astNode);
+    }
+    if ('extensionASTNodes' in node && node.extensionASTNodes) {
+        astNodes = [...astNodes, ...node.extensionASTNodes];
+    }
+    const result = [];
+    for (const astNode of astNodes) {
+        if (astNode.directives) {
+            for (const directiveNode of astNode.directives) {
+                if (directiveNode.name.value === directiveName) {
+                    result.push(getArgumentValues(schemaDirective, directiveNode));
+                }
+            }
+        }
+    }
+    if (!result.length) {
+        return undefined;
+    }
+    return result;
+}

package/esm/get-fields-with-directives.js

@@ -0,0 +1,48 @@
+import { Kind, } from 'graphql';
+function parseDirectiveValue(value) {
+    switch (value.kind) {
+        case Kind.INT:
+            return parseInt(value.value);
+        case Kind.FLOAT:
+            return parseFloat(value.value);
+        case Kind.BOOLEAN:
+            return Boolean(value.value);
+        case Kind.STRING:
+        case Kind.ENUM:
+            return value.value;
+        case Kind.LIST:
+            return value.values.map(v => parseDirectiveValue(v));
+        case Kind.OBJECT:
+            return value.fields.reduce((prev, v) => ({ ...prev, [v.name.value]: parseDirectiveValue(v.value) }), {});
+        case Kind.NULL:
+            return null;
+        default:
+            return null;
+    }
+}
+export function getFieldsWithDirectives(documentNode, options = {}) {
+    const result = {};
+    let selected = ['ObjectTypeDefinition', 'ObjectTypeExtension'];
+    if (options.includeInputTypes) {
+        selected = [...selected, 'InputObjectTypeDefinition', 'InputObjectTypeExtension'];
+    }
+    const allTypes = documentNode.definitions.filter(obj => selected.includes(obj.kind));
+    for (const type of allTypes) {
+        const typeName = type.name.value;
+        if (type.fields == null) {
+            continue;
+        }
+        for (const field of type.fields) {
+            if (field.directives && field.directives.length > 0) {
+                const fieldName = field.name.value;
+                const key = `${typeName}.${fieldName}`;
+                const directives = field.directives.map(d => ({
+                    name: d.name.value,
+                    args: (d.arguments || []).reduce((prev, arg) => ({ ...prev, [arg.name.value]: parseDirectiveValue(arg.value) }), {}),
+                }));
+                result[key] = directives;
+            }
+        }
+    }
+    return result;
+}

package/esm/get-implementing-types.js

@@ -0,0 +1,15 @@
+import { isObjectType } from 'graphql';
+export function getImplementingTypes(interfaceName, schema) {
+    const allTypesMap = schema.getTypeMap();
+    const result = [];
+    for (const graphqlTypeName in allTypesMap) {
+        const graphqlType = allTypesMap[graphqlTypeName];
+        if (isObjectType(graphqlType)) {
+            const allInterfaces = graphqlType.getInterfaces();
+            if (allInterfaces.find(int => int.name === interfaceName)) {
+                result.push(graphqlType.name);
+            }
+        }
+    }
+    return result;
+}

package/esm/getArgumentValues.js

@@ -0,0 +1,72 @@
+import { valueFromAST, isNonNullType, Kind, print, } from 'graphql';
+import { createGraphQLError } from './errors.js';
+import { inspect } from './inspect.js';
+/**
+ * Prepares an object map of argument values given a list of argument
+ * definitions and list of argument AST nodes.
+ *
+ * Note: The returned value is a plain Object with a prototype, since it is
+ * exposed to user code. Care should be taken to not pull values from the
+ * Object prototype.
+ */
+export function getArgumentValues(def, node, variableValues = {}) {
+    var _a;
+    const variableMap = Object.entries(variableValues).reduce((prev, [key, value]) => ({
+        ...prev,
+        [key]: value,
+    }), {});
+    const coercedValues = {};
+    const argumentNodes = (_a = node.arguments) !== null && _a !== void 0 ? _a : [];
+    const argNodeMap = argumentNodes.reduce((prev, arg) => ({
+        ...prev,
+        [arg.name.value]: arg,
+    }), {});
+    for (const { name, type: argType, defaultValue } of def.args) {
+        const argumentNode = argNodeMap[name];
+        if (!argumentNode) {
+            if (defaultValue !== undefined) {
+                coercedValues[name] = defaultValue;
+            }
+            else if (isNonNullType(argType)) {
+                throw createGraphQLError(`Argument "${name}" of required type "${inspect(argType)}" ` + 'was not provided.', {
+                    nodes: [node],
+                });
+            }
+            continue;
+        }
+        const valueNode = argumentNode.value;
+        let isNull = valueNode.kind === Kind.NULL;
+        if (valueNode.kind === Kind.VARIABLE) {
+            const variableName = valueNode.name.value;
+            if (variableValues == null || variableMap[variableName] == null) {
+                if (defaultValue !== undefined) {
+                    coercedValues[name] = defaultValue;
+                }
+                else if (isNonNullType(argType)) {
+                    throw createGraphQLError(`Argument "${name}" of required type "${inspect(argType)}" ` +
+                        `was provided the variable "$${variableName}" which was not provided a runtime value.`, {
+                        nodes: [valueNode],
+                    });
+                }
+                continue;
+            }
+            isNull = variableValues[variableName] == null;
+        }
+        if (isNull && isNonNullType(argType)) {
+            throw createGraphQLError(`Argument "${name}" of non-null type "${inspect(argType)}" ` + 'must not be null.', {
+                nodes: [valueNode],
+            });
+        }
+        const coercedValue = valueFromAST(valueNode, argType, variableValues);
+        if (coercedValue === undefined) {
+            // Note: ValuesOfCorrectTypeRule validation should catch this before
+            // execution. This is a runtime check to ensure execution does not
+            // continue with an invalid argument value.
+            throw createGraphQLError(`Argument "${name}" has invalid value ${print(valueNode)}.`, {
+                nodes: [valueNode],
+            });
+        }
+        coercedValues[name] = coercedValue;
+    }
+    return coercedValues;
+}

package/esm/getObjectTypeFromTypeMap.js

@@ -0,0 +1,9 @@
+import { isObjectType } from 'graphql';
+export function getObjectTypeFromTypeMap(typeMap, type) {
+    if (type) {
+        const maybeObjectType = typeMap[type.name];
+        if (isObjectType(maybeObjectType)) {
+            return maybeObjectType;
+        }
+    }
+}

package/esm/getOperationASTFromRequest.js

@@ -0,0 +1,12 @@
+import { getOperationAST } from 'graphql';
+import { memoize1 } from './memoize.js';
+export function getOperationASTFromDocument(documentNode, operationName) {
+    const doc = getOperationAST(documentNode, operationName);
+    if (!doc) {
+        throw new Error(`Cannot infer operation ${operationName || ''}`);
+    }
+    return doc;
+}
+export const getOperationASTFromRequest = memoize1(function getOperationASTFromRequest(request) {
+    return getOperationASTFromDocument(request.document, request.operationName);
+});

package/esm/getResolversFromSchema.js

@@ -0,0 +1,69 @@
+import { GraphQLScalarType, isScalarType, isEnumType, isInterfaceType, isUnionType, isObjectType, isSpecifiedScalarType, } from 'graphql';
+export function getResolversFromSchema(schema, 
+// Include default merged resolvers
+includeDefaultMergedResolver) {
+    var _a, _b;
+    const resolvers = Object.create(null);
+    const typeMap = schema.getTypeMap();
+    for (const typeName in typeMap) {
+        if (!typeName.startsWith('__')) {
+            const type = typeMap[typeName];
+            if (isScalarType(type)) {
+                if (!isSpecifiedScalarType(type)) {
+                    const config = type.toConfig();
+                    delete config.astNode; // avoid AST duplication elsewhere
+                    resolvers[typeName] = new GraphQLScalarType(config);
+                }
+            }
+            else if (isEnumType(type)) {
+                resolvers[typeName] = {};
+                const values = type.getValues();
+                for (const value of values) {
+                    resolvers[typeName][value.name] = value.value;
+                }
+            }
+            else if (isInterfaceType(type)) {
+                if (type.resolveType != null) {
+                    resolvers[typeName] = {
+                        __resolveType: type.resolveType,
+                    };
+                }
+            }
+            else if (isUnionType(type)) {
+                if (type.resolveType != null) {
+                    resolvers[typeName] = {
+                        __resolveType: type.resolveType,
+                    };
+                }
+            }
+            else if (isObjectType(type)) {
+                resolvers[typeName] = {};
+                if (type.isTypeOf != null) {
+                    resolvers[typeName].__isTypeOf = type.isTypeOf;
+                }
+                const fields = type.getFields();
+                for (const fieldName in fields) {
+                    const field = fields[fieldName];
+                    if (field.subscribe != null) {
+                        resolvers[typeName][fieldName] = resolvers[typeName][fieldName] || {};
+                        resolvers[typeName][fieldName].subscribe = field.subscribe;
+                    }
+                    if (field.resolve != null && ((_a = field.resolve) === null || _a === void 0 ? void 0 : _a.name) !== 'defaultFieldResolver') {
+                        switch ((_b = field.resolve) === null || _b === void 0 ? void 0 : _b.name) {
+                            case 'defaultMergedResolver':
+                                if (!includeDefaultMergedResolver) {
+                                    continue;
+                                }
+                                break;
+                            case 'defaultFieldResolver':
+                                continue;
+                        }
+                        resolvers[typeName][fieldName] = resolvers[typeName][fieldName] || {};
+                        resolvers[typeName][fieldName].resolve = field.resolve;
+                    }
+                }
+            }
+        }
+    }
+    return resolvers;
+}

package/esm/getResponseKeyFromInfo.js

@@ -0,0 +1,8 @@
+/**
+ * Get the key under which the result of this resolver will be placed in the response JSON. Basically, just
+ * resolves aliases.
+ * @param info The info argument to the resolver.
+ */
+export function getResponseKeyFromInfo(info) {
+    return info.fieldNodes[0].alias != null ? info.fieldNodes[0].alias.value : info.fieldName;
+}

package/esm/heal.js

@@ -0,0 +1,172 @@
+import { GraphQLList, GraphQLNonNull, isNamedType, isObjectType, isInterfaceType, isUnionType, isInputObjectType, isLeafType, isListType, isNonNullType, } from 'graphql';
+// Update any references to named schema types that disagree with the named
+// types found in schema.getTypeMap().
+//
+// healSchema and its callers (visitSchema/visitSchemaDirectives) all modify the schema in place.
+// Therefore, private variables (such as the stored implementation map and the proper root types)
+// are not updated.
+//
+// If this causes issues, the schema could be more aggressively healed as follows:
+//
+// healSchema(schema);
+// const config = schema.toConfig()
+// const healedSchema = new GraphQLSchema({
+//   ...config,
+//   query: schema.getType('<desired new root query type name>'),
+//   mutation: schema.getType('<desired new root mutation type name>'),
+//   subscription: schema.getType('<desired new root subscription type name>'),
+// });
+//
+// One can then also -- if necessary --  assign the correct private variables to the initial schema
+// as follows:
+// Object.assign(schema, healedSchema);
+//
+// These steps are not taken automatically to preserve backwards compatibility with graphql-tools v4.
+// See https://github.com/ardatan/graphql-tools/issues/1462
+//
+// They were briefly taken in v5, but can now be phased out as they were only required when other
+// areas of the codebase were using healSchema and visitSchema more extensively.
+//
+export function healSchema(schema) {
+    healTypes(schema.getTypeMap(), schema.getDirectives());
+    return schema;
+}
+export function healTypes(originalTypeMap, directives) {
+    const actualNamedTypeMap = Object.create(null);
+    // If any of the .name properties of the GraphQLNamedType objects in
+    // schema.getTypeMap() have changed, the keys of the type map need to
+    // be updated accordingly.
+    for (const typeName in originalTypeMap) {
+        const namedType = originalTypeMap[typeName];
+        if (namedType == null || typeName.startsWith('__')) {
+            continue;
+        }
+        const actualName = namedType.name;
+        if (actualName.startsWith('__')) {
+            continue;
+        }
+        if (actualName in actualNamedTypeMap) {
+            throw new Error(`Duplicate schema type name ${actualName}`);
+        }
+        actualNamedTypeMap[actualName] = namedType;
+        // Note: we are deliberately leaving namedType in the schema by its
+        // original name (which might be different from actualName), so that
+        // references by that name can be healed.
+    }
+    // Now add back every named type by its actual name.
+    for (const typeName in actualNamedTypeMap) {
+        const namedType = actualNamedTypeMap[typeName];
+        originalTypeMap[typeName] = namedType;
+    }
+    // Directive declaration argument types can refer to named types.
+    for (const decl of directives) {
+        decl.args = decl.args.filter(arg => {
+            arg.type = healType(arg.type);
+            return arg.type !== null;
+        });
+    }
+    for (const typeName in originalTypeMap) {
+        const namedType = originalTypeMap[typeName];
+        // Heal all named types, except for dangling references, kept only to redirect.
+        if (!typeName.startsWith('__') && typeName in actualNamedTypeMap) {
+            if (namedType != null) {
+                healNamedType(namedType);
+            }
+        }
+    }
+    for (const typeName in originalTypeMap) {
+        if (!typeName.startsWith('__') && !(typeName in actualNamedTypeMap)) {
+            delete originalTypeMap[typeName];
+        }
+    }
+    function healNamedType(type) {
+        if (isObjectType(type)) {
+            healFields(type);
+            healInterfaces(type);
+            return;
+        }
+        else if (isInterfaceType(type)) {
+            healFields(type);
+            if ('getInterfaces' in type) {
+                healInterfaces(type);
+            }
+            return;
+        }
+        else if (isUnionType(type)) {
+            healUnderlyingTypes(type);
+            return;
+        }
+        else if (isInputObjectType(type)) {
+            healInputFields(type);
+            return;
+        }
+        else if (isLeafType(type)) {
+            return;
+        }
+        throw new Error(`Unexpected schema type: ${type}`);
+    }
+    function healFields(type) {
+        const fieldMap = type.getFields();
+        for (const [key, field] of Object.entries(fieldMap)) {
+            field.args
+                .map(arg => {
+                arg.type = healType(arg.type);
+                return arg.type === null ? null : arg;
+            })
+                .filter(Boolean);
+            field.type = healType(field.type);
+            if (field.type === null) {
+                delete fieldMap[key];
+            }
+        }
+    }
+    function healInterfaces(type) {
+        if ('getInterfaces' in type) {
+            const interfaces = type.getInterfaces();
+            interfaces.push(...interfaces
+                .splice(0)
+                .map(iface => healType(iface))
+                .filter(Boolean));
+        }
+    }
+    function healInputFields(type) {
+        const fieldMap = type.getFields();
+        for (const [key, field] of Object.entries(fieldMap)) {
+            field.type = healType(field.type);
+            if (field.type === null) {
+                delete fieldMap[key];
+            }
+        }
+    }
+    function healUnderlyingTypes(type) {
+        const types = type.getTypes();
+        types.push(...types
+            .splice(0)
+            .map(t => healType(t))
+            .filter(Boolean));
+    }
+    function healType(type) {
+        // Unwrap the two known wrapper types
+        if (isListType(type)) {
+            const healedType = healType(type.ofType);
+            return healedType != null ? new GraphQLList(healedType) : null;
+        }
+        else if (isNonNullType(type)) {
+            const healedType = healType(type.ofType);
+            return healedType != null ? new GraphQLNonNull(healedType) : null;
+        }
+        else if (isNamedType(type)) {
+            // If a type annotation on a field or an argument or a union member is
+            // any `GraphQLNamedType` with a `name`, then it must end up identical
+            // to `schema.getType(name)`, since `schema.getTypeMap()` is the source
+            // of truth for all named schema types.
+            // Note that new types can still be simply added by adding a field, as
+            // the official type will be undefined, not null.
+            const officialType = originalTypeMap[type.name];
+            if (officialType && type !== officialType) {
+                return officialType;
+            }
+        }
+        return type;
+    }
+}

package/esm/helpers.js

@@ -0,0 +1,65 @@
+import { parse } from 'graphql';
+export const asArray = (fns) => (Array.isArray(fns) ? fns : fns ? [fns] : []);
+const invalidDocRegex = /\.[a-z0-9]+$/i;
+export function isDocumentString(str) {
+    if (typeof str !== 'string') {
+        return false;
+    }
+    // XXX: is-valid-path or is-glob treat SDL as a valid path
+    // (`scalar Date` for example)
+    // this why checking the extension is fast enough
+    // and prevent from parsing the string in order to find out
+    // if the string is a SDL
+    if (invalidDocRegex.test(str)) {
+        return false;
+    }
+    try {
+        parse(str);
+        return true;
+    }
+    catch (e) { }
+    return false;
+}
+const invalidPathRegex = /[‘“!%&^<=>`]/;
+export function isValidPath(str) {
+    return typeof str === 'string' && !invalidPathRegex.test(str);
+}
+export function compareStrings(a, b) {
+    if (String(a) < String(b)) {
+        return -1;
+    }
+    if (String(a) > String(b)) {
+        return 1;
+    }
+    return 0;
+}
+export function nodeToString(a) {
+    var _a, _b;
+    let name;
+    if ('alias' in a) {
+        name = (_a = a.alias) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    if (name == null && 'name' in a) {
+        name = (_b = a.name) === null || _b === void 0 ? void 0 : _b.value;
+    }
+    if (name == null) {
+        name = a.kind;
+    }
+    return name;
+}
+export function compareNodes(a, b, customFn) {
+    const aStr = nodeToString(a);
+    const bStr = nodeToString(b);
+    if (typeof customFn === 'function') {
+        return customFn(aStr, bStr);
+    }
+    return compareStrings(aStr, bStr);
+}
+export function isSome(input) {
+    return input != null;
+}
+export function assertSome(input, message = 'Value should be something') {
+    if (input == null) {
+        throw new Error(message);
+    }
+}

package/esm/implementsAbstractType.js

@@ -0,0 +1,13 @@
+import { doTypesOverlap, isCompositeType } from 'graphql';
+export function implementsAbstractType(schema, typeA, typeB) {
+    if (typeB == null || typeA == null) {
+        return false;
+    }
+    else if (typeA === typeB) {
+        return true;
+    }
+    else if (isCompositeType(typeA) && isCompositeType(typeB)) {
+        return doTypesOverlap(schema, typeA, typeB);
+    }
+    return false;
+}

package/esm/index.js

@@ -0,0 +1,50 @@
+export * from './loaders.js';
+export * from './helpers.js';
+export * from './get-directives.js';
+export * from './get-fields-with-directives.js';
+export * from './get-implementing-types.js';
+export * from './print-schema-with-directives.js';
+export * from './get-fields-with-directives.js';
+export * from './validate-documents.js';
+export * from './parse-graphql-json.js';
+export * from './parse-graphql-sdl.js';
+export * from './build-operation-for-field.js';
+export * from './types.js';
+export * from './filterSchema.js';
+export * from './heal.js';
+export * from './getResolversFromSchema.js';
+export * from './forEachField.js';
+export * from './forEachDefaultValue.js';
+export * from './mapSchema.js';
+export * from './addTypes.js';
+export * from './rewire.js';
+export * from './prune.js';
+export * from './mergeDeep.js';
+export * from './Interfaces.js';
+export * from './stub.js';
+export * from './selectionSets.js';
+export * from './getResponseKeyFromInfo.js';
+export * from './fields.js';
+export * from './renameType.js';
+export * from './transformInputValue.js';
+export * from './mapAsyncIterator.js';
+export * from './updateArgument.js';
+export * from './implementsAbstractType.js';
+export * from './errors.js';
+export * from './observableToAsyncIterable.js';
+export * from './visitResult.js';
+export * from './getArgumentValues.js';
+export * from './valueMatchesCriteria.js';
+export * from './isAsyncIterable.js';
+export * from './isDocumentNode.js';
+export * from './astFromValueUntyped.js';
+export * from './executor.js';
+export * from './withCancel.js';
+export * from './AggregateError.js';
+export * from './rootTypes.js';
+export * from './comments.js';
+export * from './collectFields.js';
+export * from './inspect.js';
+export * from './memoize.js';
+export * from './fixSchemaAst.js';
+export * from './getOperationASTFromRequest.js';