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

package/esm/renameType.js

@@ -0,0 +1,148 @@
+import { GraphQLEnumType, GraphQLInputObjectType, GraphQLInterfaceType, GraphQLObjectType, GraphQLScalarType, GraphQLUnionType, isEnumType, isInterfaceType, isInputObjectType, isObjectType, isScalarType, isUnionType, } from 'graphql';
+export function renameType(type, newTypeName) {
+    if (isObjectType(type)) {
+        return new GraphQLObjectType({
+            ...type.toConfig(),
+            name: newTypeName,
+            astNode: type.astNode == null
+                ? type.astNode
+                : {
+                    ...type.astNode,
+                    name: {
+                        ...type.astNode.name,
+                        value: newTypeName,
+                    },
+                },
+            extensionASTNodes: type.extensionASTNodes == null
+                ? type.extensionASTNodes
+                : type.extensionASTNodes.map(node => ({
+                    ...node,
+                    name: {
+                        ...node.name,
+                        value: newTypeName,
+                    },
+                })),
+        });
+    }
+    else if (isInterfaceType(type)) {
+        return new GraphQLInterfaceType({
+            ...type.toConfig(),
+            name: newTypeName,
+            astNode: type.astNode == null
+                ? type.astNode
+                : {
+                    ...type.astNode,
+                    name: {
+                        ...type.astNode.name,
+                        value: newTypeName,
+                    },
+                },
+            extensionASTNodes: type.extensionASTNodes == null
+                ? type.extensionASTNodes
+                : type.extensionASTNodes.map(node => ({
+                    ...node,
+                    name: {
+                        ...node.name,
+                        value: newTypeName,
+                    },
+                })),
+        });
+    }
+    else if (isUnionType(type)) {
+        return new GraphQLUnionType({
+            ...type.toConfig(),
+            name: newTypeName,
+            astNode: type.astNode == null
+                ? type.astNode
+                : {
+                    ...type.astNode,
+                    name: {
+                        ...type.astNode.name,
+                        value: newTypeName,
+                    },
+                },
+            extensionASTNodes: type.extensionASTNodes == null
+                ? type.extensionASTNodes
+                : type.extensionASTNodes.map(node => ({
+                    ...node,
+                    name: {
+                        ...node.name,
+                        value: newTypeName,
+                    },
+                })),
+        });
+    }
+    else if (isInputObjectType(type)) {
+        return new GraphQLInputObjectType({
+            ...type.toConfig(),
+            name: newTypeName,
+            astNode: type.astNode == null
+                ? type.astNode
+                : {
+                    ...type.astNode,
+                    name: {
+                        ...type.astNode.name,
+                        value: newTypeName,
+                    },
+                },
+            extensionASTNodes: type.extensionASTNodes == null
+                ? type.extensionASTNodes
+                : type.extensionASTNodes.map(node => ({
+                    ...node,
+                    name: {
+                        ...node.name,
+                        value: newTypeName,
+                    },
+                })),
+        });
+    }
+    else if (isEnumType(type)) {
+        return new GraphQLEnumType({
+            ...type.toConfig(),
+            name: newTypeName,
+            astNode: type.astNode == null
+                ? type.astNode
+                : {
+                    ...type.astNode,
+                    name: {
+                        ...type.astNode.name,
+                        value: newTypeName,
+                    },
+                },
+            extensionASTNodes: type.extensionASTNodes == null
+                ? type.extensionASTNodes
+                : type.extensionASTNodes.map(node => ({
+                    ...node,
+                    name: {
+                        ...node.name,
+                        value: newTypeName,
+                    },
+                })),
+        });
+    }
+    else if (isScalarType(type)) {
+        return new GraphQLScalarType({
+            ...type.toConfig(),
+            name: newTypeName,
+            astNode: type.astNode == null
+                ? type.astNode
+                : {
+                    ...type.astNode,
+                    name: {
+                        ...type.astNode.name,
+                        value: newTypeName,
+                    },
+                },
+            extensionASTNodes: type.extensionASTNodes == null
+                ? type.extensionASTNodes
+                : type.extensionASTNodes.map(node => ({
+                    ...node,
+                    name: {
+                        ...node.name,
+                        value: newTypeName,
+                    },
+                })),
+        });
+    }
+    throw new Error(`Unknown type ${type}.`);
+}

package/esm/rewire.js

@@ -0,0 +1,155 @@
+import { GraphQLDirective, GraphQLEnumType, GraphQLInputObjectType, GraphQLInterfaceType, GraphQLList, GraphQLObjectType, GraphQLNonNull, GraphQLScalarType, GraphQLUnionType, isInterfaceType, isEnumType, isInputObjectType, isListType, isNamedType, isNonNullType, isObjectType, isScalarType, isUnionType, isSpecifiedScalarType, isSpecifiedDirective, } from 'graphql';
+import { getBuiltInForStub, isNamedStub } from './stub.js';
+export function rewireTypes(originalTypeMap, directives) {
+    const referenceTypeMap = Object.create(null);
+    for (const typeName in originalTypeMap) {
+        referenceTypeMap[typeName] = originalTypeMap[typeName];
+    }
+    const newTypeMap = Object.create(null);
+    for (const typeName in referenceTypeMap) {
+        const namedType = referenceTypeMap[typeName];
+        if (namedType == null || typeName.startsWith('__')) {
+            continue;
+        }
+        const newName = namedType.name;
+        if (newName.startsWith('__')) {
+            continue;
+        }
+        if (newTypeMap[newName] != null) {
+            throw new Error(`Duplicate schema type name ${newName}`);
+        }
+        newTypeMap[newName] = namedType;
+    }
+    for (const typeName in newTypeMap) {
+        newTypeMap[typeName] = rewireNamedType(newTypeMap[typeName]);
+    }
+    const newDirectives = directives.map(directive => rewireDirective(directive));
+    return {
+        typeMap: newTypeMap,
+        directives: newDirectives,
+    };
+    function rewireDirective(directive) {
+        if (isSpecifiedDirective(directive)) {
+            return directive;
+        }
+        const directiveConfig = directive.toConfig();
+        directiveConfig.args = rewireArgs(directiveConfig.args);
+        return new GraphQLDirective(directiveConfig);
+    }
+    function rewireArgs(args) {
+        const rewiredArgs = {};
+        for (const argName in args) {
+            const arg = args[argName];
+            const rewiredArgType = rewireType(arg.type);
+            if (rewiredArgType != null) {
+                arg.type = rewiredArgType;
+                rewiredArgs[argName] = arg;
+            }
+        }
+        return rewiredArgs;
+    }
+    function rewireNamedType(type) {
+        if (isObjectType(type)) {
+            const config = type.toConfig();
+            const newConfig = {
+                ...config,
+                fields: () => rewireFields(config.fields),
+                interfaces: () => rewireNamedTypes(config.interfaces),
+            };
+            return new GraphQLObjectType(newConfig);
+        }
+        else if (isInterfaceType(type)) {
+            const config = type.toConfig();
+            const newConfig = {
+                ...config,
+                fields: () => rewireFields(config.fields),
+            };
+            if ('interfaces' in newConfig) {
+                newConfig.interfaces = () => rewireNamedTypes(config.interfaces);
+            }
+            return new GraphQLInterfaceType(newConfig);
+        }
+        else if (isUnionType(type)) {
+            const config = type.toConfig();
+            const newConfig = {
+                ...config,
+                types: () => rewireNamedTypes(config.types),
+            };
+            return new GraphQLUnionType(newConfig);
+        }
+        else if (isInputObjectType(type)) {
+            const config = type.toConfig();
+            const newConfig = {
+                ...config,
+                fields: () => rewireInputFields(config.fields),
+            };
+            return new GraphQLInputObjectType(newConfig);
+        }
+        else if (isEnumType(type)) {
+            const enumConfig = type.toConfig();
+            return new GraphQLEnumType(enumConfig);
+        }
+        else if (isScalarType(type)) {
+            if (isSpecifiedScalarType(type)) {
+                return type;
+            }
+            const scalarConfig = type.toConfig();
+            return new GraphQLScalarType(scalarConfig);
+        }
+        throw new Error(`Unexpected schema type: ${type}`);
+    }
+    function rewireFields(fields) {
+        const rewiredFields = {};
+        for (const fieldName in fields) {
+            const field = fields[fieldName];
+            const rewiredFieldType = rewireType(field.type);
+            if (rewiredFieldType != null && field.args) {
+                field.type = rewiredFieldType;
+                field.args = rewireArgs(field.args);
+                rewiredFields[fieldName] = field;
+            }
+        }
+        return rewiredFields;
+    }
+    function rewireInputFields(fields) {
+        const rewiredFields = {};
+        for (const fieldName in fields) {
+            const field = fields[fieldName];
+            const rewiredFieldType = rewireType(field.type);
+            if (rewiredFieldType != null) {
+                field.type = rewiredFieldType;
+                rewiredFields[fieldName] = field;
+            }
+        }
+        return rewiredFields;
+    }
+    function rewireNamedTypes(namedTypes) {
+        const rewiredTypes = [];
+        for (const namedType of namedTypes) {
+            const rewiredType = rewireType(namedType);
+            if (rewiredType != null) {
+                rewiredTypes.push(rewiredType);
+            }
+        }
+        return rewiredTypes;
+    }
+    function rewireType(type) {
+        if (isListType(type)) {
+            const rewiredType = rewireType(type.ofType);
+            return rewiredType != null ? new GraphQLList(rewiredType) : null;
+        }
+        else if (isNonNullType(type)) {
+            const rewiredType = rewireType(type.ofType);
+            return rewiredType != null ? new GraphQLNonNull(rewiredType) : null;
+        }
+        else if (isNamedType(type)) {
+            let rewiredType = referenceTypeMap[type.name];
+            if (rewiredType === undefined) {
+                rewiredType = isNamedStub(type) ? getBuiltInForStub(type) : rewireNamedType(type);
+                newTypeMap[rewiredType.name] = referenceTypeMap[type.name] = rewiredType;
+            }
+            return rewiredType != null ? newTypeMap[rewiredType.name] : null;
+        }
+        return null;
+    }
+}

package/esm/rootTypes.js

@@ -0,0 +1,33 @@
+import { memoize1 } from './memoize.js';
+export function getDefinedRootType(schema, operation) {
+    const rootTypeMap = getRootTypeMap(schema);
+    const rootType = rootTypeMap.get(operation);
+    if (rootType == null) {
+        throw new Error(`Root type for operation "${operation}" not defined by the given schema.`);
+    }
+    return rootType;
+}
+export const getRootTypeNames = memoize1(function getRootTypeNames(schema) {
+    const rootTypes = getRootTypes(schema);
+    return new Set([...rootTypes].map(type => type.name));
+});
+export const getRootTypes = memoize1(function getRootTypes(schema) {
+    const rootTypeMap = getRootTypeMap(schema);
+    return new Set(rootTypeMap.values());
+});
+export const getRootTypeMap = memoize1(function getRootTypeMap(schema) {
+    const rootTypeMap = new Map();
+    const queryType = schema.getQueryType();
+    if (queryType) {
+        rootTypeMap.set('query', queryType);
+    }
+    const mutationType = schema.getMutationType();
+    if (mutationType) {
+        rootTypeMap.set('mutation', mutationType);
+    }
+    const subscriptionType = schema.getSubscriptionType();
+    if (subscriptionType) {
+        rootTypeMap.set('subscription', subscriptionType);
+    }
+    return rootTypeMap;
+});

package/esm/selectionSets.js

@@ -0,0 +1,5 @@
+import { parse } from 'graphql';
+export function parseSelectionSet(selectionSet, options) {
+    const query = parse(selectionSet, options).definitions[0];
+    return query.selectionSet;
+}

package/esm/stub.js

@@ -0,0 +1,61 @@
+import { GraphQLObjectType, GraphQLInterfaceType, GraphQLInputObjectType, GraphQLString, GraphQLInt, GraphQLFloat, GraphQLBoolean, GraphQLID, Kind, GraphQLList, GraphQLNonNull, } from 'graphql';
+export function createNamedStub(name, type) {
+    let constructor;
+    if (type === 'object') {
+        constructor = GraphQLObjectType;
+    }
+    else if (type === 'interface') {
+        constructor = GraphQLInterfaceType;
+    }
+    else {
+        constructor = GraphQLInputObjectType;
+    }
+    return new constructor({
+        name,
+        fields: {
+            _fake: {
+                type: GraphQLString,
+            },
+        },
+    });
+}
+export function createStub(node, type) {
+    switch (node.kind) {
+        case Kind.LIST_TYPE:
+            return new GraphQLList(createStub(node.type, type));
+        case Kind.NON_NULL_TYPE:
+            return new GraphQLNonNull(createStub(node.type, type));
+        default:
+            if (type === 'output') {
+                return createNamedStub(node.name.value, 'object');
+            }
+            return createNamedStub(node.name.value, 'input');
+    }
+}
+export function isNamedStub(type) {
+    if ('getFields' in type) {
+        const fields = type.getFields();
+        // eslint-disable-next-line no-unreachable-loop
+        for (const fieldName in fields) {
+            const field = fields[fieldName];
+            return field.name === '_fake';
+        }
+    }
+    return false;
+}
+export function getBuiltInForStub(type) {
+    switch (type.name) {
+        case GraphQLInt.name:
+            return GraphQLInt;
+        case GraphQLFloat.name:
+            return GraphQLFloat;
+        case GraphQLString.name:
+            return GraphQLString;
+        case GraphQLBoolean.name:
+            return GraphQLBoolean;
+        case GraphQLID.name:
+            return GraphQLID;
+        default:
+            return type;
+    }
+}

package/esm/transformInputValue.js

@@ -0,0 +1,48 @@
+import { getNullableType, isLeafType, isListType, isInputObjectType } from 'graphql';
+export function transformInputValue(type, value, inputLeafValueTransformer = null, inputObjectValueTransformer = null) {
+    if (value == null) {
+        return value;
+    }
+    const nullableType = getNullableType(type);
+    if (isLeafType(nullableType)) {
+        return inputLeafValueTransformer != null ? inputLeafValueTransformer(nullableType, value) : value;
+    }
+    else if (isListType(nullableType)) {
+        return value.map((listMember) => transformInputValue(nullableType.ofType, listMember, inputLeafValueTransformer, inputObjectValueTransformer));
+    }
+    else if (isInputObjectType(nullableType)) {
+        const fields = nullableType.getFields();
+        const newValue = {};
+        for (const key in value) {
+            const field = fields[key];
+            if (field != null) {
+                newValue[key] = transformInputValue(field.type, value[key], inputLeafValueTransformer, inputObjectValueTransformer);
+            }
+        }
+        return inputObjectValueTransformer != null ? inputObjectValueTransformer(nullableType, newValue) : newValue;
+    }
+    // unreachable, no other possible return value
+}
+export function serializeInputValue(type, value) {
+    return transformInputValue(type, value, (t, v) => {
+        try {
+            return t.serialize(v);
+        }
+        catch (_a) {
+            return v;
+        }
+    });
+}
+export function parseInputValue(type, value) {
+    return transformInputValue(type, value, (t, v) => {
+        try {
+            return t.parseValue(v);
+        }
+        catch (_a) {
+            return v;
+        }
+    });
+}
+export function parseInputValueLiteral(type, value) {
+    return transformInputValue(type, value, (t, v) => t.parseLiteral(v, {}));
+}

package/esm/types.js

@@ -0,0 +1,24 @@
+export var DirectiveLocation;
+(function (DirectiveLocation) {
+    /** Request Definitions */
+    DirectiveLocation["QUERY"] = "QUERY";
+    DirectiveLocation["MUTATION"] = "MUTATION";
+    DirectiveLocation["SUBSCRIPTION"] = "SUBSCRIPTION";
+    DirectiveLocation["FIELD"] = "FIELD";
+    DirectiveLocation["FRAGMENT_DEFINITION"] = "FRAGMENT_DEFINITION";
+    DirectiveLocation["FRAGMENT_SPREAD"] = "FRAGMENT_SPREAD";
+    DirectiveLocation["INLINE_FRAGMENT"] = "INLINE_FRAGMENT";
+    DirectiveLocation["VARIABLE_DEFINITION"] = "VARIABLE_DEFINITION";
+    /** Type System Definitions */
+    DirectiveLocation["SCHEMA"] = "SCHEMA";
+    DirectiveLocation["SCALAR"] = "SCALAR";
+    DirectiveLocation["OBJECT"] = "OBJECT";
+    DirectiveLocation["FIELD_DEFINITION"] = "FIELD_DEFINITION";
+    DirectiveLocation["ARGUMENT_DEFINITION"] = "ARGUMENT_DEFINITION";
+    DirectiveLocation["INTERFACE"] = "INTERFACE";
+    DirectiveLocation["UNION"] = "UNION";
+    DirectiveLocation["ENUM"] = "ENUM";
+    DirectiveLocation["ENUM_VALUE"] = "ENUM_VALUE";
+    DirectiveLocation["INPUT_OBJECT"] = "INPUT_OBJECT";
+    DirectiveLocation["INPUT_FIELD_DEFINITION"] = "INPUT_FIELD_DEFINITION";
+})(DirectiveLocation || (DirectiveLocation = {}));

package/esm/updateArgument.js

@@ -0,0 +1,49 @@
+import { Kind } from 'graphql';
+import { astFromType } from './astFromType.js';
+export function updateArgument(argumentNodes, variableDefinitionsMap, variableValues, argName, varName, type, value) {
+    argumentNodes[argName] = {
+        kind: Kind.ARGUMENT,
+        name: {
+            kind: Kind.NAME,
+            value: argName,
+        },
+        value: {
+            kind: Kind.VARIABLE,
+            name: {
+                kind: Kind.NAME,
+                value: varName,
+            },
+        },
+    };
+    variableDefinitionsMap[varName] = {
+        kind: Kind.VARIABLE_DEFINITION,
+        variable: {
+            kind: Kind.VARIABLE,
+            name: {
+                kind: Kind.NAME,
+                value: varName,
+            },
+        },
+        type: astFromType(type),
+    };
+    if (value !== undefined) {
+        variableValues[varName] = value;
+        return;
+    }
+    // including the variable in the map with value of `undefined`
+    // will actually be translated by graphql-js into `null`
+    // see https://github.com/graphql/graphql-js/issues/2533
+    if (varName in variableValues) {
+        delete variableValues[varName];
+    }
+}
+export function createVariableNameGenerator(variableDefinitionMap) {
+    let varCounter = 0;
+    return (argName) => {
+        let varName;
+        do {
+            varName = `_v${(varCounter++).toString()}_${argName}`;
+        } while (varName in variableDefinitionMap);
+        return varName;
+    };
+}

package/esm/validate-documents.js

@@ -0,0 +1,70 @@
+import { Kind, validate, specifiedRules, concatAST, versionInfo, } from 'graphql';
+import { AggregateError } from './AggregateError.js';
+export async function validateGraphQlDocuments(schema, documentFiles, effectiveRules = createDefaultRules()) {
+    const allFragmentMap = new Map();
+    const documentFileObjectsToValidate = [];
+    for (const documentFile of documentFiles) {
+        if (documentFile.document) {
+            const definitionsToValidate = [];
+            for (const definitionNode of documentFile.document.definitions) {
+                if (definitionNode.kind === Kind.FRAGMENT_DEFINITION) {
+                    allFragmentMap.set(definitionNode.name.value, definitionNode);
+                }
+                else {
+                    definitionsToValidate.push(definitionNode);
+                }
+            }
+            documentFileObjectsToValidate.push({
+                location: documentFile.location,
+                document: {
+                    kind: Kind.DOCUMENT,
+                    definitions: definitionsToValidate,
+                },
+            });
+        }
+    }
+    const allErrors = [];
+    const allFragmentsDocument = {
+        kind: Kind.DOCUMENT,
+        definitions: [...allFragmentMap.values()],
+    };
+    await Promise.all(documentFileObjectsToValidate.map(async (documentFile) => {
+        const documentToValidate = concatAST([allFragmentsDocument, documentFile.document]);
+        const errors = validate(schema, documentToValidate, effectiveRules);
+        if (errors.length > 0) {
+            allErrors.push({
+                filePath: documentFile.location,
+                errors,
+            });
+        }
+    }));
+    return allErrors;
+}
+export function checkValidationErrors(loadDocumentErrors) {
+    if (loadDocumentErrors.length > 0) {
+        const errors = [];
+        for (const loadDocumentError of loadDocumentErrors) {
+            for (const graphQLError of loadDocumentError.errors) {
+                const error = new Error();
+                error.name = 'GraphQLDocumentError';
+                error.message = `${error.name}: ${graphQLError.message}`;
+                error.stack = error.message;
+                if (graphQLError.locations) {
+                    for (const location of graphQLError.locations) {
+                        error.stack += `\n    at ${loadDocumentError.filePath}:${location.line}:${location.column}`;
+                    }
+                }
+                errors.push(error);
+            }
+        }
+        throw new AggregateError(errors, `GraphQL Document Validation failed with ${errors.length} errors;
+  ${errors.map((error, index) => `Error ${index}: ${error.stack}`).join('\n\n')}`);
+    }
+}
+export function createDefaultRules() {
+    let ignored = ['NoUnusedFragmentsRule', 'NoUnusedVariablesRule', 'KnownDirectivesRule'];
+    if (versionInfo.major < 15) {
+        ignored = ignored.map(rule => rule.replace(/Rule$/, ''));
+    }
+    return specifiedRules.filter((f) => !ignored.includes(f.name));
+}

package/esm/valueMatchesCriteria.js

@@ -0,0 +1,17 @@
+export function valueMatchesCriteria(value, criteria) {
+    if (value == null) {
+        return value === criteria;
+    }
+    else if (Array.isArray(value)) {
+        return Array.isArray(criteria) && value.every((val, index) => valueMatchesCriteria(val, criteria[index]));
+    }
+    else if (typeof value === 'object') {
+        return (typeof criteria === 'object' &&
+            criteria &&
+            Object.keys(criteria).every(propertyName => valueMatchesCriteria(value[propertyName], criteria[propertyName])));
+    }
+    else if (criteria instanceof RegExp) {
+        return criteria.test(value);
+    }
+    return value === criteria;
+}