@graphql-tools/merge 6.2.17 → 8.0.1

package/index.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 const utils = require('@graphql-tools/utils');
 const graphql = require('graphql');
-const schema = require('@graphql-tools/schema');
 
 /**
  * Deep merges multiple resolver definition objects into a single definition.
@@ -86,289 +85,6 @@ function deduplicateArguments(args) {
     }, []);
 }
 
-const MAX_LINE_LENGTH = 80;
-let commentsRegistry = {};
-function resetComments() {
-    commentsRegistry = {};
-}
-function collectComment(node) {
-    var _a;
-    const entityName = (_a = node.name) === null || _a === void 0 ? void 0 : _a.value;
-    if (entityName == null) {
-        return;
-    }
-    pushComment(node, entityName);
-    switch (node.kind) {
-        case 'EnumTypeDefinition':
-            if (node.values) {
-                for (const value of node.values) {
-                    pushComment(value, entityName, value.name.value);
-                }
-            }
-            break;
-        case 'ObjectTypeDefinition':
-        case 'InputObjectTypeDefinition':
-        case 'InterfaceTypeDefinition':
-            if (node.fields) {
-                for (const field of node.fields) {
-                    pushComment(field, entityName, field.name.value);
-                    if (isFieldDefinitionNode(field) && field.arguments) {
-                        for (const arg of field.arguments) {
-                            pushComment(arg, entityName, field.name.value, arg.name.value);
-                        }
-                    }
-                }
-            }
-            break;
-    }
-}
-function pushComment(node, entity, field, argument) {
-    const comment = graphql.getDescription(node, { commentDescriptions: true });
-    if (typeof comment !== 'string' || comment.length === 0) {
-        return;
-    }
-    const keys = [entity];
-    if (field) {
-        keys.push(field);
-        if (argument) {
-            keys.push(argument);
-        }
-    }
-    const path = keys.join('.');
-    if (!commentsRegistry[path]) {
-        commentsRegistry[path] = [];
-    }
-    commentsRegistry[path].push(comment);
-}
-function printComment(comment) {
-    return '\n# ' + comment.replace(/\n/g, '\n# ');
-}
-/**
- * Copyright (c) 2015-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-/**
- * NOTE: ==> This file has been modified just to add comments to the printed AST
- * This is a temp measure, we will move to using the original non modified printer.js ASAP.
- */
-// import { visit, VisitFn } from 'graphql';
-/**
- * Given maybeArray, print an empty string if it is null or empty, otherwise
- * print all items together separated by separator if provided
- */
-function join(maybeArray, separator) {
-    return maybeArray ? maybeArray.filter(x => x).join(separator || '') : '';
-}
-function hasMultilineItems(maybeArray) {
-    var _a;
-    return (_a = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.some(str => str.includes('\n'))) !== null && _a !== void 0 ? _a : false;
-}
-function addDescription(cb) {
-    return (node, _key, _parent, path, ancestors) => {
-        var _a;
-        const keys = [];
-        const parent = path.reduce((prev, key) => {
-            if (['fields', 'arguments', 'values'].includes(key) && prev.name) {
-                keys.push(prev.name.value);
-            }
-            return prev[key];
-        }, ancestors[0]);
-        const key = [...keys, (_a = parent === null || parent === void 0 ? void 0 : parent.name) === null || _a === void 0 ? void 0 : _a.value].filter(Boolean).join('.');
-        const items = [];
-        if (node.kind.includes('Definition') && commentsRegistry[key]) {
-            items.push(...commentsRegistry[key]);
-        }
-        return join([...items.map(printComment), node.description, cb(node)], '\n');
-    };
-}
-function indent(maybeString) {
-    return maybeString && `  ${maybeString.replace(/\n/g, '\n  ')}`;
-}
-/**
- * Given array, print each item on its own line, wrapped in an
- * indented "{ }" block.
- */
-function block(array) {
-    return array && array.length !== 0 ? `{\n${indent(join(array, '\n'))}\n}` : '';
-}
-/**
- * If maybeString is not null or empty, then wrap with start and end, otherwise
- * print an empty string.
- */
-function wrap(start, maybeString, end) {
-    return maybeString ? start + maybeString + (end || '') : '';
-}
-/**
- * Print a block string in the indented block form by adding a leading and
- * trailing blank line. However, if a block string starts with whitespace and is
- * a single-line, adding a leading blank line would strip that whitespace.
- */
-function printBlockString(value, isDescription = false) {
-    const escaped = value.replace(/"""/g, '\\"""');
-    return (value[0] === ' ' || value[0] === '\t') && value.indexOf('\n') === -1
-        ? `"""${escaped.replace(/"$/, '"\n')}"""`
-        : `"""\n${isDescription ? escaped : indent(escaped)}\n"""`;
-}
-const printDocASTReducer = {
-    Name: { leave: node => node.value },
-    Variable: { leave: node => '$' + node.name },
-    // Document
-    Document: {
-        leave: node => join(node.definitions, '\n\n'),
-    },
-    OperationDefinition: {
-        leave: node => {
-            const varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');
-            const prefix = join([node.operation, join([node.name, varDefs]), join(node.directives, ' ')], ' ');
-            // the query short form.
-            return prefix + ' ' + node.selectionSet;
-        },
-    },
-    VariableDefinition: {
-        leave: ({ variable, type, defaultValue, directives }) => variable + ': ' + type + wrap(' = ', defaultValue) + wrap(' ', join(directives, ' ')),
-    },
-    SelectionSet: { leave: ({ selections }) => block(selections) },
-    Field: {
-        leave({ alias, name, arguments: args, directives, selectionSet }) {
-            const prefix = wrap('', alias, ': ') + name;
-            let argsLine = prefix + wrap('(', join(args, ', '), ')');
-            if (argsLine.length > MAX_LINE_LENGTH) {
-                argsLine = prefix + wrap('(\n', indent(join(args, '\n')), '\n)');
-            }
-            return join([argsLine, join(directives, ' '), selectionSet], ' ');
-        },
-    },
-    Argument: { leave: ({ name, value }) => name + ': ' + value },
-    // Fragments
-    FragmentSpread: {
-        leave: ({ name, directives }) => '...' + name + wrap(' ', join(directives, ' ')),
-    },
-    InlineFragment: {
-        leave: ({ typeCondition, directives, selectionSet }) => join(['...', wrap('on ', typeCondition), join(directives, ' '), selectionSet], ' '),
-    },
-    FragmentDefinition: {
-        leave: ({ name, typeCondition, variableDefinitions, directives, selectionSet }) => 
-        // Note: fragment variable definitions are experimental and may be changed
-        // or removed in the future.
-        `fragment ${name}${wrap('(', join(variableDefinitions, ', '), ')')} ` +
-            `on ${typeCondition} ${wrap('', join(directives, ' '), ' ')}` +
-            selectionSet,
-    },
-    // Value
-    IntValue: { leave: ({ value }) => value },
-    FloatValue: { leave: ({ value }) => value },
-    StringValue: {
-        leave: ({ value, block: isBlockString }) => (isBlockString ? printBlockString(value) : JSON.stringify(value)),
-    },
-    BooleanValue: { leave: ({ value }) => (value ? 'true' : 'false') },
-    NullValue: { leave: () => 'null' },
-    EnumValue: { leave: ({ value }) => value },
-    ListValue: { leave: ({ values }) => '[' + join(values, ', ') + ']' },
-    ObjectValue: { leave: ({ fields }) => '{' + join(fields, ', ') + '}' },
-    ObjectField: { leave: ({ name, value }) => name + ': ' + value },
-    // Directive
-    Directive: {
-        leave: ({ name, arguments: args }) => '@' + name + wrap('(', join(args, ', '), ')'),
-    },
-    // Type
-    NamedType: { leave: ({ name }) => name },
-    ListType: { leave: ({ type }) => '[' + type + ']' },
-    NonNullType: { leave: ({ type }) => type + '!' },
-    // Type System Definitions
-    SchemaDefinition: {
-        leave: ({ description, directives, operationTypes }) => wrap('', description, '\n') + join(['schema', join(directives, ' '), block(operationTypes)], ' '),
-    },
-    OperationTypeDefinition: {
-        leave: ({ operation, type }) => operation + ': ' + type,
-    },
-    ScalarTypeDefinition: {
-        leave: ({ description, name, directives }) => wrap('', description, '\n') + join(['scalar', name, join(directives, ' ')], ' '),
-    },
-    ObjectTypeDefinition: {
-        leave: ({ description, name, interfaces, directives, fields }) => wrap('', description, '\n') +
-            join(['type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
-    },
-    FieldDefinition: {
-        leave: ({ description, name, arguments: args, type, directives }) => wrap('', description, '\n') +
-            name +
-            (hasMultilineItems(args)
-                ? wrap('(\n', indent(join(args, '\n')), '\n)')
-                : wrap('(', join(args, ', '), ')')) +
-            ': ' +
-            type +
-            wrap(' ', join(directives, ' ')),
-    },
-    InputValueDefinition: {
-        leave: ({ description, name, type, defaultValue, directives }) => wrap('', description, '\n') + join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' '),
-    },
-    InterfaceTypeDefinition: {
-        leave: ({ description, name, interfaces, directives, fields }) => wrap('', description, '\n') +
-            join(['interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
-    },
-    UnionTypeDefinition: {
-        leave: ({ description, name, directives, types }) => wrap('', description, '\n') + join(['union', name, join(directives, ' '), wrap('= ', join(types, ' | '))], ' '),
-    },
-    EnumTypeDefinition: {
-        leave: ({ description, name, directives, values }) => wrap('', description, '\n') + join(['enum', name, join(directives, ' '), block(values)], ' '),
-    },
-    EnumValueDefinition: {
-        leave: ({ description, name, directives }) => wrap('', description, '\n') + join([name, join(directives, ' ')], ' '),
-    },
-    InputObjectTypeDefinition: {
-        leave: ({ description, name, directives, fields }) => wrap('', description, '\n') + join(['input', name, join(directives, ' '), block(fields)], ' '),
-    },
-    DirectiveDefinition: {
-        leave: ({ description, name, arguments: args, repeatable, locations }) => wrap('', description, '\n') +
-            'directive @' +
-            name +
-            (hasMultilineItems(args)
-                ? wrap('(\n', indent(join(args, '\n')), '\n)')
-                : wrap('(', join(args, ', '), ')')) +
-            (repeatable ? ' repeatable' : '') +
-            ' on ' +
-            join(locations, ' | '),
-    },
-    SchemaExtension: {
-        leave: ({ directives, operationTypes }) => join(['extend schema', join(directives, ' '), block(operationTypes)], ' '),
-    },
-    ScalarTypeExtension: {
-        leave: ({ name, directives }) => join(['extend scalar', name, join(directives, ' ')], ' '),
-    },
-    ObjectTypeExtension: {
-        leave: ({ name, interfaces, directives, fields }) => join(['extend type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
-    },
-    InterfaceTypeExtension: {
-        leave: ({ name, interfaces, directives, fields }) => join(['extend interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
-    },
-    UnionTypeExtension: {
-        leave: ({ name, directives, types }) => join(['extend union', name, join(directives, ' '), wrap('= ', join(types, ' | '))], ' '),
-    },
-    EnumTypeExtension: {
-        leave: ({ name, directives, values }) => join(['extend enum', name, join(directives, ' '), block(values)], ' '),
-    },
-    InputObjectTypeExtension: {
-        leave: ({ name, directives, fields }) => join(['extend input', name, join(directives, ' '), block(fields)], ' '),
-    },
-};
-const printDocASTReducerWithComments = Object.keys(printDocASTReducer).reduce((prev, key) => ({
-    ...prev,
-    [key]: {
-        leave: addDescription(printDocASTReducer[key].leave),
-    },
-}), {});
-/**
- * Converts an AST into a string, using one set of reasonable
- * formatting rules.
- */
-function printWithComments(ast) {
-    return graphql.visit(ast, printDocASTReducerWithComments);
-}
-function isFieldDefinitionNode(node) {
-    return node.kind === 'FieldDefinition';
-}
-
 function directiveAlreadyExists(directivesArr, otherDirective) {
     return !!directivesArr.find(directive => directive.name.value === otherDirective.name.value);
 }
@@ -431,8 +147,14 @@ function mergeDirectives(d1 = [], d2 = [], config) {
     return result;
 }
 function validateInputs(node, existingNode) {
-    const printedNode = graphql.print(node);
-    const printedExistingNode = graphql.print(existingNode);
+    const printedNode = graphql.print({
+        ...node,
+        description: undefined,
+    });
+    const printedExistingNode = graphql.print({
+        ...existingNode,
+        description: undefined,
+    });
     // eslint-disable-next-line
     const leaveInputs = new RegExp('(directive @w*d*)|( on .*$)', 'g');
     const sameArguments = printedNode.replace(leaveInputs, '') === printedExistingNode.replace(leaveInputs, '');
@@ -833,7 +555,7 @@ function mergeGraphQLNodes(nodes, config) {
         if (isNamedDefinitionNode(nodeDefinition)) {
             const name = (_a = nodeDefinition.name) === null || _a === void 0 ? void 0 : _a.value;
             if (config === null || config === void 0 ? void 0 : config.commentDescriptions) {
-                collectComment(nodeDefinition);
+                utils.collectComment(nodeDefinition);
             }
             if (name == null) {
                 continue;
@@ -881,7 +603,7 @@ function mergeGraphQLNodes(nodes, config) {
 }
 
 function mergeTypeDefs(typeSource, config) {
-    resetComments();
+    utils.resetComments();
     const doc = {
         kind: graphql.Kind.DOCUMENT,
         definitions: mergeGraphQLTypes(typeSource, {
@@ -894,12 +616,12 @@ function mergeTypeDefs(typeSource, config) {
     };
     let result;
     if (config && config.commentDescriptions) {
-        result = printWithComments(doc);
+        result = utils.printWithComments(doc);
     }
     else {
         result = doc;
     }
-    resetComments();
+    utils.resetComments();
     return result;
 }
 function visitTypeSources(typeSource, options, allNodes = [], visitedTypeSources = new Set()) {
@@ -935,7 +657,7 @@ function visitTypeSources(typeSource, options, allNodes = [], visitedTypeSources
 }
 function mergeGraphQLTypes(typeSource, config) {
     var _a, _b, _c;
-    resetComments();
+    utils.resetComments();
     const allNodes = visitTypeSources(typeSource, config);
     const mergedNodes = mergeGraphQLNodes(allNodes, config);
     if (config === null || config === void 0 ? void 0 : config.useSchemaDefinition) {
@@ -1116,65 +838,7 @@ function extractExtensionsFromSchema(schema) {
     return result;
 }
 
-const defaultResolverValidationOptions = {
-    requireResolversForArgs: 'ignore',
-    requireResolversForNonScalar: 'ignore',
-    requireResolversForAllFields: 'ignore',
-    requireResolversForResolveType: 'ignore',
-    requireResolversToMatchSchema: 'ignore',
-};
-/**
- * Synchronously merges multiple schemas, typeDefinitions and/or resolvers into a single schema.
- * @param config Configuration object
- */
-function mergeSchemas(config) {
-    const typeDefs = mergeTypeDefs([config.schemas, config.typeDefs || []], config);
-    const extractedResolvers = [];
-    const extractedExtensions = [];
-    for (const schema of config.schemas) {
-        extractedResolvers.push(utils.getResolversFromSchema(schema));
-        extractedExtensions.push(extractExtensionsFromSchema(schema));
-    }
-    extractedResolvers.push(...ensureResolvers(config));
-    const resolvers = mergeResolvers(extractedResolvers, config);
-    const extensions = mergeExtensions(extractedExtensions);
-    return makeSchema({ resolvers, typeDefs, extensions }, config);
-}
-/**
- * Asynchronously merges multiple schemas, typeDefinitions and/or resolvers into a single schema.
- * @param config Configuration object
- */
-async function mergeSchemasAsync(config) {
-    const [typeDefs, resolvers, extensions] = await Promise.all([
-        mergeTypeDefs([config.schemas, config.typeDefs || []], config),
-        Promise.all(config.schemas.map(async (schema) => utils.getResolversFromSchema(schema))).then(extractedResolvers => mergeResolvers([...extractedResolvers, ...ensureResolvers(config)], config)),
-        Promise.all(config.schemas.map(async (schema) => extractExtensionsFromSchema(schema))).then(extractedExtensions => mergeExtensions(extractedExtensions)),
-    ]);
-    return makeSchema({ resolvers, typeDefs, extensions }, config);
-}
-function ensureResolvers(config) {
-    return config.resolvers ? utils.asArray(config.resolvers) : [];
-}
-function makeSchema({ resolvers, typeDefs, extensions, }, config) {
-    let schema$1 = typeof typeDefs === 'string' ? graphql.buildSchema(typeDefs, config) : graphql.buildASTSchema(typeDefs, config);
-    // add resolvers
-    if (resolvers) {
-        schema$1 = schema.addResolversToSchema({
-            schema: schema$1,
-            resolvers,
-            resolverValidationOptions: {
-                ...defaultResolverValidationOptions,
-                ...(config.resolverValidationOptions || {}),
-            },
-        });
-    }
-    // extensions
-    applyExtensions(schema$1, extensions);
-    return schema$1;
-}
-
 exports.applyExtensions = applyExtensions;
-exports.collectComment = collectComment;
 exports.defaultStringComparator = defaultStringComparator;
 exports.extractExtensionsFromSchema = extractExtensionsFromSchema;
 exports.extractType = extractType;
@@ -1198,15 +862,9 @@ exports.mergeInterface = mergeInterface;
 exports.mergeNamedTypeArray = mergeNamedTypeArray;
 exports.mergeResolvers = mergeResolvers;
 exports.mergeScalar = mergeScalar;
-exports.mergeSchemas = mergeSchemas;
-exports.mergeSchemasAsync = mergeSchemasAsync;
 exports.mergeType = mergeType;
 exports.mergeTypeDefs = mergeTypeDefs;
 exports.mergeUnion = mergeUnion;
-exports.printComment = printComment;
 exports.printTypeNode = printTypeNode;
-exports.printWithComments = printWithComments;
-exports.pushComment = pushComment;
-exports.resetComments = resetComments;
 exports.schemaDefSymbol = schemaDefSymbol;
 exports.travelSchemaPossibleExtensions = travelSchemaPossibleExtensions;