@graphql-tools/merge 6.2.17 → 8.0.1

package/es5/index.mjs

@@ -1,7 +1,6 @@
-import { __values, __read, __spreadArray, __assign, __awaiter, __generator } from 'tslib';
-import { mergeDeep, isSome, compareNodes, isNotEqual, getDocumentNodeFromSchema, isDocumentNode, getResolversFromSchema, asArray } from '@graphql-tools/utils/es5';
-import { getDescription, visit, print, Source, Kind, isSchema, parse, isDefinitionNode, isScalarType, isSpecifiedScalarType, isIntrospectionType, isObjectType, isInterfaceType, isInputObjectType, isUnionType, isEnumType, buildSchema, buildASTSchema } from 'graphql';
-import { addResolversToSchema } from '@graphql-tools/schema/es5';
+import { __values, __read, __spreadArray, __assign } from 'tslib';
+import { mergeDeep, isSome, compareNodes, isNotEqual, collectComment, resetComments, printWithComments, getDocumentNodeFromSchema, isDocumentNode } from '@graphql-tools/utils/es5';
+import { print, Source, Kind, isSchema, parse, isDefinitionNode, isScalarType, isSpecifiedScalarType, isIntrospectionType, isObjectType, isInterfaceType, isInputObjectType, isUnionType, isEnumType } from 'graphql';
 
 /**
  * Deep merges multiple resolver definition objects into a single definition.
@@ -104,432 +103,6 @@ function deduplicateArguments(args) {
     }, []);
 }
 
-var MAX_LINE_LENGTH = 80;
-var commentsRegistry = {};
-function resetComments() {
-    commentsRegistry = {};
-}
-function collectComment(node) {
-    var e_1, _a, e_2, _b, e_3, _c;
-    var _d;
-    var entityName = (_d = node.name) === null || _d === void 0 ? void 0 : _d.value;
-    if (entityName == null) {
-        return;
-    }
-    pushComment(node, entityName);
-    switch (node.kind) {
-        case 'EnumTypeDefinition':
-            if (node.values) {
-                try {
-                    for (var _e = __values(node.values), _f = _e.next(); !_f.done; _f = _e.next()) {
-                        var value = _f.value;
-                        pushComment(value, entityName, value.name.value);
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-            }
-            break;
-        case 'ObjectTypeDefinition':
-        case 'InputObjectTypeDefinition':
-        case 'InterfaceTypeDefinition':
-            if (node.fields) {
-                try {
-                    for (var _g = __values(node.fields), _h = _g.next(); !_h.done; _h = _g.next()) {
-                        var field = _h.value;
-                        pushComment(field, entityName, field.name.value);
-                        if (isFieldDefinitionNode(field) && field.arguments) {
-                            try {
-                                for (var _j = (e_3 = void 0, __values(field.arguments)), _k = _j.next(); !_k.done; _k = _j.next()) {
-                                    var arg = _k.value;
-                                    pushComment(arg, entityName, field.name.value, arg.name.value);
-                                }
-                            }
-                            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                            finally {
-                                try {
-                                    if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
-                                }
-                                finally { if (e_3) throw e_3.error; }
-                            }
-                        }
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                }
-            }
-            break;
-    }
-}
-function pushComment(node, entity, field, argument) {
-    var comment = getDescription(node, { commentDescriptions: true });
-    if (typeof comment !== 'string' || comment.length === 0) {
-        return;
-    }
-    var keys = [entity];
-    if (field) {
-        keys.push(field);
-        if (argument) {
-            keys.push(argument);
-        }
-    }
-    var 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(function (x) { return x; }).join(separator || '') : '';
-}
-function hasMultilineItems(maybeArray) {
-    var _a;
-    return (_a = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.some(function (str) { return str.includes('\n'); })) !== null && _a !== void 0 ? _a : false;
-}
-function addDescription(cb) {
-    return function (node, _key, _parent, path, ancestors) {
-        var _a;
-        var keys = [];
-        var parent = path.reduce(function (prev, key) {
-            if (['fields', 'arguments', 'values'].includes(key) && prev.name) {
-                keys.push(prev.name.value);
-            }
-            return prev[key];
-        }, ancestors[0]);
-        var key = __spreadArray(__spreadArray([], __read(keys)), [(_a = parent === null || parent === void 0 ? void 0 : parent.name) === null || _a === void 0 ? void 0 : _a.value]).filter(Boolean).join('.');
-        var items = [];
-        if (node.kind.includes('Definition') && commentsRegistry[key]) {
-            items.push.apply(items, __spreadArray([], __read(commentsRegistry[key])));
-        }
-        return join(__spreadArray(__spreadArray([], __read(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) {
-    if (isDescription === void 0) { isDescription = false; }
-    var escaped = value.replace(/"""/g, '\\"""');
-    return (value[0] === ' ' || value[0] === '\t') && value.indexOf('\n') === -1
-        ? "\"\"\"" + escaped.replace(/"$/, '"\n') + "\"\"\""
-        : "\"\"\"\n" + (isDescription ? escaped : indent(escaped)) + "\n\"\"\"";
-}
-var printDocASTReducer = {
-    Name: { leave: function (node) { return node.value; } },
-    Variable: { leave: function (node) { return '$' + node.name; } },
-    // Document
-    Document: {
-        leave: function (node) { return join(node.definitions, '\n\n'); },
-    },
-    OperationDefinition: {
-        leave: function (node) {
-            var varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');
-            var prefix = join([node.operation, join([node.name, varDefs]), join(node.directives, ' ')], ' ');
-            // the query short form.
-            return prefix + ' ' + node.selectionSet;
-        },
-    },
-    VariableDefinition: {
-        leave: function (_a) {
-            var variable = _a.variable, type = _a.type, defaultValue = _a.defaultValue, directives = _a.directives;
-            return variable + ': ' + type + wrap(' = ', defaultValue) + wrap(' ', join(directives, ' '));
-        },
-    },
-    SelectionSet: { leave: function (_a) {
-            var selections = _a.selections;
-            return block(selections);
-        } },
-    Field: {
-        leave: function (_a) {
-            var alias = _a.alias, name = _a.name, args = _a.arguments, directives = _a.directives, selectionSet = _a.selectionSet;
-            var prefix = wrap('', alias, ': ') + name;
-            var 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: function (_a) {
-            var name = _a.name, value = _a.value;
-            return name + ': ' + value;
-        } },
-    // Fragments
-    FragmentSpread: {
-        leave: function (_a) {
-            var name = _a.name, directives = _a.directives;
-            return '...' + name + wrap(' ', join(directives, ' '));
-        },
-    },
-    InlineFragment: {
-        leave: function (_a) {
-            var typeCondition = _a.typeCondition, directives = _a.directives, selectionSet = _a.selectionSet;
-            return join(['...', wrap('on ', typeCondition), join(directives, ' '), selectionSet], ' ');
-        },
-    },
-    FragmentDefinition: {
-        leave: function (_a) {
-            var name = _a.name, typeCondition = _a.typeCondition, variableDefinitions = _a.variableDefinitions, directives = _a.directives, selectionSet = _a.selectionSet;
-            // Note: fragment variable definitions are experimental and may be changed
-            // or removed in the future.
-            return "fragment " + name + wrap('(', join(variableDefinitions, ', '), ')') + " " +
-                ("on " + typeCondition + " " + wrap('', join(directives, ' '), ' ')) +
-                selectionSet;
-        },
-    },
-    // Value
-    IntValue: { leave: function (_a) {
-            var value = _a.value;
-            return value;
-        } },
-    FloatValue: { leave: function (_a) {
-            var value = _a.value;
-            return value;
-        } },
-    StringValue: {
-        leave: function (_a) {
-            var value = _a.value, isBlockString = _a.block;
-            return (isBlockString ? printBlockString(value) : JSON.stringify(value));
-        },
-    },
-    BooleanValue: { leave: function (_a) {
-            var value = _a.value;
-            return (value ? 'true' : 'false');
-        } },
-    NullValue: { leave: function () { return 'null'; } },
-    EnumValue: { leave: function (_a) {
-            var value = _a.value;
-            return value;
-        } },
-    ListValue: { leave: function (_a) {
-            var values = _a.values;
-            return '[' + join(values, ', ') + ']';
-        } },
-    ObjectValue: { leave: function (_a) {
-            var fields = _a.fields;
-            return '{' + join(fields, ', ') + '}';
-        } },
-    ObjectField: { leave: function (_a) {
-            var name = _a.name, value = _a.value;
-            return name + ': ' + value;
-        } },
-    // Directive
-    Directive: {
-        leave: function (_a) {
-            var name = _a.name, args = _a.arguments;
-            return '@' + name + wrap('(', join(args, ', '), ')');
-        },
-    },
-    // Type
-    NamedType: { leave: function (_a) {
-            var name = _a.name;
-            return name;
-        } },
-    ListType: { leave: function (_a) {
-            var type = _a.type;
-            return '[' + type + ']';
-        } },
-    NonNullType: { leave: function (_a) {
-            var type = _a.type;
-            return type + '!';
-        } },
-    // Type System Definitions
-    SchemaDefinition: {
-        leave: function (_a) {
-            var description = _a.description, directives = _a.directives, operationTypes = _a.operationTypes;
-            return wrap('', description, '\n') + join(['schema', join(directives, ' '), block(operationTypes)], ' ');
-        },
-    },
-    OperationTypeDefinition: {
-        leave: function (_a) {
-            var operation = _a.operation, type = _a.type;
-            return operation + ': ' + type;
-        },
-    },
-    ScalarTypeDefinition: {
-        leave: function (_a) {
-            var description = _a.description, name = _a.name, directives = _a.directives;
-            return wrap('', description, '\n') + join(['scalar', name, join(directives, ' ')], ' ');
-        },
-    },
-    ObjectTypeDefinition: {
-        leave: function (_a) {
-            var description = _a.description, name = _a.name, interfaces = _a.interfaces, directives = _a.directives, fields = _a.fields;
-            return wrap('', description, '\n') +
-                join(['type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');
-        },
-    },
-    FieldDefinition: {
-        leave: function (_a) {
-            var description = _a.description, name = _a.name, args = _a.arguments, type = _a.type, directives = _a.directives;
-            return wrap('', description, '\n') +
-                name +
-                (hasMultilineItems(args)
-                    ? wrap('(\n', indent(join(args, '\n')), '\n)')
-                    : wrap('(', join(args, ', '), ')')) +
-                ': ' +
-                type +
-                wrap(' ', join(directives, ' '));
-        },
-    },
-    InputValueDefinition: {
-        leave: function (_a) {
-            var description = _a.description, name = _a.name, type = _a.type, defaultValue = _a.defaultValue, directives = _a.directives;
-            return wrap('', description, '\n') + join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' ');
-        },
-    },
-    InterfaceTypeDefinition: {
-        leave: function (_a) {
-            var description = _a.description, name = _a.name, interfaces = _a.interfaces, directives = _a.directives, fields = _a.fields;
-            return wrap('', description, '\n') +
-                join(['interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');
-        },
-    },
-    UnionTypeDefinition: {
-        leave: function (_a) {
-            var description = _a.description, name = _a.name, directives = _a.directives, types = _a.types;
-            return wrap('', description, '\n') + join(['union', name, join(directives, ' '), wrap('= ', join(types, ' | '))], ' ');
-        },
-    },
-    EnumTypeDefinition: {
-        leave: function (_a) {
-            var description = _a.description, name = _a.name, directives = _a.directives, values = _a.values;
-            return wrap('', description, '\n') + join(['enum', name, join(directives, ' '), block(values)], ' ');
-        },
-    },
-    EnumValueDefinition: {
-        leave: function (_a) {
-            var description = _a.description, name = _a.name, directives = _a.directives;
-            return wrap('', description, '\n') + join([name, join(directives, ' ')], ' ');
-        },
-    },
-    InputObjectTypeDefinition: {
-        leave: function (_a) {
-            var description = _a.description, name = _a.name, directives = _a.directives, fields = _a.fields;
-            return wrap('', description, '\n') + join(['input', name, join(directives, ' '), block(fields)], ' ');
-        },
-    },
-    DirectiveDefinition: {
-        leave: function (_a) {
-            var description = _a.description, name = _a.name, args = _a.arguments, repeatable = _a.repeatable, locations = _a.locations;
-            return wrap('', description, '\n') +
-                'directive @' +
-                name +
-                (hasMultilineItems(args)
-                    ? wrap('(\n', indent(join(args, '\n')), '\n)')
-                    : wrap('(', join(args, ', '), ')')) +
-                (repeatable ? ' repeatable' : '') +
-                ' on ' +
-                join(locations, ' | ');
-        },
-    },
-    SchemaExtension: {
-        leave: function (_a) {
-            var directives = _a.directives, operationTypes = _a.operationTypes;
-            return join(['extend schema', join(directives, ' '), block(operationTypes)], ' ');
-        },
-    },
-    ScalarTypeExtension: {
-        leave: function (_a) {
-            var name = _a.name, directives = _a.directives;
-            return join(['extend scalar', name, join(directives, ' ')], ' ');
-        },
-    },
-    ObjectTypeExtension: {
-        leave: function (_a) {
-            var name = _a.name, interfaces = _a.interfaces, directives = _a.directives, fields = _a.fields;
-            return join(['extend type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');
-        },
-    },
-    InterfaceTypeExtension: {
-        leave: function (_a) {
-            var name = _a.name, interfaces = _a.interfaces, directives = _a.directives, fields = _a.fields;
-            return join(['extend interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');
-        },
-    },
-    UnionTypeExtension: {
-        leave: function (_a) {
-            var name = _a.name, directives = _a.directives, types = _a.types;
-            return join(['extend union', name, join(directives, ' '), wrap('= ', join(types, ' | '))], ' ');
-        },
-    },
-    EnumTypeExtension: {
-        leave: function (_a) {
-            var name = _a.name, directives = _a.directives, values = _a.values;
-            return join(['extend enum', name, join(directives, ' '), block(values)], ' ');
-        },
-    },
-    InputObjectTypeExtension: {
-        leave: function (_a) {
-            var name = _a.name, directives = _a.directives, fields = _a.fields;
-            return join(['extend input', name, join(directives, ' '), block(fields)], ' ');
-        },
-    },
-};
-var printDocASTReducerWithComments = Object.keys(printDocASTReducer).reduce(function (prev, key) {
-    var _a;
-    return (__assign(__assign({}, prev), (_a = {}, _a[key] = {
-        leave: addDescription(printDocASTReducer[key].leave),
-    }, _a)));
-}, {});
-/**
- * Converts an AST into a string, using one set of reasonable
- * formatting rules.
- */
-function printWithComments(ast) {
-    return visit(ast, printDocASTReducerWithComments);
-}
-function isFieldDefinitionNode(node) {
-    return node.kind === 'FieldDefinition';
-}
-
 function directiveAlreadyExists(directivesArr, otherDirective) {
     return !!directivesArr.find(function (directive) { return directive.name.value === otherDirective.name.value; });
 }
@@ -625,8 +198,8 @@ function mergeDirectives(d1, d2, config) {
     return result;
 }
 function validateInputs(node, existingNode) {
-    var printedNode = print(node);
-    var printedExistingNode = print(existingNode);
+    var printedNode = print(__assign(__assign({}, node), { description: undefined }));
+    var printedExistingNode = print(__assign(__assign({}, existingNode), { description: undefined }));
     // eslint-disable-next-line
     var leaveInputs = new RegExp('(directive @w*d*)|( on .*$)', 'g');
     var sameArguments = printedNode.replace(leaveInputs, '') === printedExistingNode.replace(leaveInputs, '');
@@ -1480,88 +1053,4 @@ function extractExtensionsFromSchema(schema) {
     return result;
 }
 
-var 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) {
-    var e_1, _a;
-    var typeDefs = mergeTypeDefs([config.schemas, config.typeDefs || []], config);
-    var extractedResolvers = [];
-    var extractedExtensions = [];
-    try {
-        for (var _b = __values(config.schemas), _c = _b.next(); !_c.done; _c = _b.next()) {
-            var schema = _c.value;
-            extractedResolvers.push(getResolversFromSchema(schema));
-            extractedExtensions.push(extractExtensionsFromSchema(schema));
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-    extractedResolvers.push.apply(extractedResolvers, __spreadArray([], __read(ensureResolvers(config))));
-    var resolvers = mergeResolvers(extractedResolvers, config);
-    var extensions = mergeExtensions(extractedExtensions);
-    return makeSchema({ resolvers: resolvers, typeDefs: typeDefs, extensions: extensions }, config);
-}
-/**
- * Asynchronously merges multiple schemas, typeDefinitions and/or resolvers into a single schema.
- * @param config Configuration object
- */
-function mergeSchemasAsync(config) {
-    return __awaiter(this, void 0, void 0, function () {
-        var _a, typeDefs, resolvers, extensions;
-        var _this = this;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, Promise.all([
-                        mergeTypeDefs([config.schemas, config.typeDefs || []], config),
-                        Promise.all(config.schemas.map(function (schema) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
-                            return [2 /*return*/, getResolversFromSchema(schema)];
-                        }); }); })).then(function (extractedResolvers) {
-                            return mergeResolvers(__spreadArray(__spreadArray([], __read(extractedResolvers)), __read(ensureResolvers(config))), config);
-                        }),
-                        Promise.all(config.schemas.map(function (schema) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
-                            return [2 /*return*/, extractExtensionsFromSchema(schema)];
-                        }); }); })).then(function (extractedExtensions) {
-                            return mergeExtensions(extractedExtensions);
-                        }),
-                    ])];
-                case 1:
-                    _a = __read.apply(void 0, [_b.sent(), 3]), typeDefs = _a[0], resolvers = _a[1], extensions = _a[2];
-                    return [2 /*return*/, makeSchema({ resolvers: resolvers, typeDefs: typeDefs, extensions: extensions }, config)];
-            }
-        });
-    });
-}
-function ensureResolvers(config) {
-    return config.resolvers ? asArray(config.resolvers) : [];
-}
-function makeSchema(_a, config) {
-    var resolvers = _a.resolvers, typeDefs = _a.typeDefs, extensions = _a.extensions;
-    var schema = typeof typeDefs === 'string' ? buildSchema(typeDefs, config) : buildASTSchema(typeDefs, config);
-    // add resolvers
-    if (resolvers) {
-        schema = addResolversToSchema({
-            schema: schema,
-            resolvers: resolvers,
-            resolverValidationOptions: __assign(__assign({}, defaultResolverValidationOptions), (config.resolverValidationOptions || {})),
-        });
-    }
-    // extensions
-    applyExtensions(schema, extensions);
-    return schema;
-}
-
-export { CompareVal, applyExtensions, collectComment, defaultStringComparator, extractExtensionsFromSchema, extractType, isListTypeNode, isNamedDefinitionNode, isNonNullTypeNode, isSourceTypes, isStringTypes, isWrappingTypeNode, mergeArguments, mergeDirective, mergeDirectives, mergeEnum, mergeEnumValues, mergeExtensions, mergeFields, mergeGraphQLNodes, mergeGraphQLTypes, mergeInputType, mergeInterface, mergeNamedTypeArray, mergeResolvers, mergeScalar, mergeSchemas, mergeSchemasAsync, mergeType, mergeTypeDefs, mergeUnion, printComment, printTypeNode, printWithComments, pushComment, resetComments, schemaDefSymbol, travelSchemaPossibleExtensions };
+export { CompareVal, applyExtensions, defaultStringComparator, extractExtensionsFromSchema, extractType, isListTypeNode, isNamedDefinitionNode, isNonNullTypeNode, isSourceTypes, isStringTypes, isWrappingTypeNode, mergeArguments, mergeDirective, mergeDirectives, mergeEnum, mergeEnumValues, mergeExtensions, mergeFields, mergeGraphQLNodes, mergeGraphQLTypes, mergeInputType, mergeInterface, mergeNamedTypeArray, mergeResolvers, mergeScalar, mergeType, mergeTypeDefs, mergeUnion, printTypeNode, schemaDefSymbol, travelSchemaPossibleExtensions };

package/es5/package.json

@@ -1,14 +1,13 @@
 {
   "name": "@graphql-tools/merge/es5",
-  "version": "6.2.17",
+  "version": "8.0.1",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0"
   },
   "dependencies": {
-    "@graphql-tools/schema": "^8.0.2",
-    "@graphql-tools/utils": "8.0.2",
+    "@graphql-tools/utils": "8.1.1",
     "tslib": "~2.3.0"
   },
   "repository": {

package/es5/typedefs-mergers/index.d.ts

@@ -1,5 +1,4 @@
 export * from './arguments';
-export * from './comments';
 export * from './directives';
 export * from './enum-values';
 export * from './enum';

package/es5/typedefs-mergers/merge-nodes.d.ts

@@ -1,11 +1,9 @@
 import { Config } from './merge-typedefs';
-import { DefinitionNode, NameNode, SchemaDefinitionNode, SchemaExtensionNode } from 'graphql';
+import { DefinitionNode, SchemaDefinitionNode, SchemaExtensionNode } from 'graphql';
+import { NamedDefinitionNode } from '@graphql-tools/utils';
 export declare const schemaDefSymbol = "SCHEMA_DEF_SYMBOL";
 export declare type MergedResultMap = Record<string, NamedDefinitionNode> & {
     [schemaDefSymbol]: SchemaDefinitionNode | SchemaExtensionNode;
 };
-export declare type NamedDefinitionNode = DefinitionNode & {
-    name?: NameNode;
-};
 export declare function isNamedDefinitionNode(definitionNode: DefinitionNode): definitionNode is NamedDefinitionNode;
 export declare function mergeGraphQLNodes(nodes: ReadonlyArray<DefinitionNode>, config?: Config): MergedResultMap;

package/index.d.ts

@@ -1,4 +1,3 @@
 export * from './merge-resolvers';
 export * from './typedefs-mergers';
-export * from './merge-schemas';
 export * from './extensions';