@graphql-tools/merge 6.2.9-alpha-3e5e5d87.0 → 6.2.11

package/es5/index.cjs.js

@@ -78,7 +78,7 @@ function mergeResolvers(resolversDefinitions, options) {
             for (var _i = 0; _i < arguments.length; _i++) {
                 args[_i] = arguments[_i];
             }
-            var resultsOfFactories = resolversFactories.map(function (factory) { return factory.apply(void 0, tslib.__spread(args)); });
+            var resultsOfFactories = resolversFactories.map(function (factory) { return factory.apply(void 0, tslib.__spreadArray([], tslib.__read(args))); });
             return resolvers.concat(resultsOfFactories).reduce(utils.mergeDeep, {});
         });
     }
@@ -203,12 +203,12 @@ function addDescription(cb) {
             }
             return prev[key];
         }, ancestors[0]);
-        var key = tslib.__spread(keys, [parent.name.value]).join('.');
+        var key = tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(keys)), [parent.name.value]).join('.');
         var items = [];
         if (commentsRegistry[key]) {
-            items.push.apply(items, tslib.__spread(commentsRegistry[key]));
+            items.push.apply(items, tslib.__spreadArray([], tslib.__read(commentsRegistry[key])));
         }
-        return join(tslib.__spread(items.map(printComment), [node.description, cb(node)]), '\n');
+        return join(tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(items.map(printComment))), [node.description, cb(node)]), '\n');
     };
 }
 function indent(maybeString) {
@@ -411,7 +411,7 @@ function nameAlreadyExists(name, namesArr) {
 }
 function mergeArguments$1(a1, a2) {
     var e_1, _a;
-    var result = tslib.__spread(a2);
+    var result = tslib.__spreadArray([], tslib.__read(a2));
     var _loop_1 = function (argument) {
         var existingIndex = result.findIndex(function (a) { return a.name.value === argument.name.value; });
         if (existingIndex > -1) {
@@ -468,7 +468,7 @@ function mergeDirectives(d1, d2, config) {
     var reverseOrder = config && config.reverseDirectives;
     var asNext = reverseOrder ? d1 : d2;
     var asFirst = reverseOrder ? d2 : d1;
-    var result = deduplicateDirectives(tslib.__spread(asNext));
+    var result = deduplicateDirectives(tslib.__spreadArray([], tslib.__read(asNext)));
     var _loop_2 = function (directive) {
         if (directiveAlreadyExists(result, directive)) {
             var existingDirectiveIndex = result.findIndex(function (d) { return d.name.value === directive.name.value; });
@@ -507,7 +507,7 @@ function validateInputs(node, existingNode) {
 function mergeDirective(node, existingNode) {
     if (existingNode) {
         validateInputs(node, existingNode);
-        return tslib.__assign(tslib.__assign({}, node), { locations: tslib.__spread(existingNode.locations, node.locations.filter(function (name) { return !nameAlreadyExists(name, existingNode.locations); })) });
+        return tslib.__assign(tslib.__assign({}, node), { locations: tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(existingNode.locations)), tslib.__read(node.locations.filter(function (name) { return !nameAlreadyExists(name, existingNode.locations); }))) });
     }
     return node;
 }
@@ -557,7 +557,7 @@ function mergeEnumValues(first, second, config) {
         }
         finally { if (e_2) throw e_2.error; }
     }
-    var result = tslib.__spread(enumValueMap.values());
+    var result = tslib.__spreadArray([], tslib.__read(enumValueMap.values()));
     if (config && config.sort) {
         result.sort(utils.compareNodes);
     }
@@ -587,55 +587,13 @@ function isStringTypes(types) {
 function isSourceTypes(types) {
     return types instanceof graphql.Source;
 }
-function isGraphQLType(definition) {
-    return definition.kind === 'ObjectTypeDefinition';
-}
-function isGraphQLTypeExtension(definition) {
-    return definition.kind === 'ObjectTypeExtension';
-}
-function isGraphQLEnum(definition) {
-    return definition.kind === 'EnumTypeDefinition';
-}
-function isGraphQLEnumExtension(definition) {
-    return definition.kind === 'EnumTypeExtension';
-}
-function isGraphQLUnion(definition) {
-    return definition.kind === 'UnionTypeDefinition';
-}
-function isGraphQLUnionExtension(definition) {
-    return definition.kind === 'UnionTypeExtension';
-}
-function isGraphQLScalar(definition) {
-    return definition.kind === 'ScalarTypeDefinition';
-}
-function isGraphQLScalarExtension(definition) {
-    return definition.kind === 'ScalarTypeExtension';
-}
-function isGraphQLInputType(definition) {
-    return definition.kind === 'InputObjectTypeDefinition';
-}
-function isGraphQLInputTypeExtension(definition) {
-    return definition.kind === 'InputObjectTypeExtension';
-}
-function isGraphQLInterface(definition) {
-    return definition.kind === 'InterfaceTypeDefinition';
-}
-function isGraphQLInterfaceExtension(definition) {
-    return definition.kind === 'InterfaceTypeExtension';
-}
-function isGraphQLDirective(definition) {
-    return definition.kind === 'DirectiveDefinition';
-}
 function extractType(type) {
     var visitedType = type;
-    while (visitedType.kind === 'ListType' || visitedType.kind === 'NonNullType') {
+    while (visitedType.kind === graphql.Kind.LIST_TYPE || visitedType.kind === 'NonNullType') {
         visitedType = visitedType.type;
     }
     return visitedType;
 }
-function isSchemaDefinition(node) {
-    return node.kind === 'SchemaDefinition';
-}
 function isWrappingTypeNode(type) {
     return type.kind !== graphql.Kind.NAMED_TYPE;
 }
@@ -654,10 +612,22 @@ function printTypeNode(type) {
     }
     return type.name.value;
 }
+(function (CompareVal) {
+    CompareVal[CompareVal["A_SMALLER_THAN_B"] = -1] = "A_SMALLER_THAN_B";
+    CompareVal[CompareVal["A_EQUALS_B"] = 0] = "A_EQUALS_B";
+    CompareVal[CompareVal["A_GREATER_THAN_B"] = 1] = "A_GREATER_THAN_B";
+})(exports.CompareVal || (exports.CompareVal = {}));
+function defaultStringComparator(a, b) {
+    if (a < b)
+        return exports.CompareVal.A_SMALLER_THAN_B;
+    if (a > b)
+        return exports.CompareVal.A_GREATER_THAN_B;
+    return exports.CompareVal.A_EQUALS_B;
+}
 
-function fieldAlreadyExists(fieldsArr, otherField) {
+function fieldAlreadyExists(fieldsArr, otherField, config) {
     var result = fieldsArr.find(function (field) { return field.name.value === otherField.name.value; });
-    if (result) {
+    if (result && !(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) {
         var t1 = extractType(result.type);
         var t2 = extractType(otherField.type);
         if (t1.name.value !== t2.name.value) {
@@ -668,18 +638,20 @@ function fieldAlreadyExists(fieldsArr, otherField) {
 }
 function mergeFields(type, f1, f2, config) {
     var e_1, _a;
-    var result = tslib.__spread(f2);
+    var result = tslib.__spreadArray([], tslib.__read(f2));
     var _loop_1 = function (field) {
-        if (fieldAlreadyExists(result, field)) {
+        if (fieldAlreadyExists(result, field, config)) {
             var existing = result.find(function (f) { return f.name.value === field.name.value; });
-            if (config && config.throwOnConflict) {
-                preventConflicts(type, existing, field);
-            }
-            else {
-                preventConflicts(type, existing, field);
-            }
-            if (isNonNullTypeNode(field.type) && !isNonNullTypeNode(existing.type)) {
-                existing.type = field.type;
+            if (!(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) {
+                if (config === null || config === void 0 ? void 0 : config.throwOnConflict) {
+                    preventConflicts(type, existing, field);
+                }
+                else {
+                    preventConflicts(type, existing, field);
+                }
+                if (isNonNullTypeNode(field.type) && !isNonNullTypeNode(existing.type)) {
+                    existing.type = field.type;
+                }
             }
             existing.arguments = mergeArguments(field['arguments'] || [], existing.arguments || [], config);
             existing.directives = mergeDirectives(field.directives, existing.directives, config);
@@ -793,7 +765,7 @@ function alreadyExists(arr, other) {
     return !!arr.find(function (i) { return i.name.value === other.name.value; });
 }
 function mergeNamedTypeArray(first, second, config) {
-    var result = tslib.__spread(second, first.filter(function (d) { return !alreadyExists(second, d); }));
+    var result = tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(second)), tslib.__read(first.filter(function (d) { return !alreadyExists(second, d); })));
     if (config && config.sort) {
         result.sort(utils.compareNodes);
     }
@@ -862,43 +834,107 @@ function mergeUnion(first, second, config) {
         ? tslib.__assign(tslib.__assign({}, first), { kind: 'UnionTypeDefinition' }) : first;
 }
 
+var operationTypeDefinitionNodeTypeRootTypeMap = {
+    query: 'Query',
+    mutation: 'Mutation',
+    subscription: 'Subscription',
+};
+function mergeOperationTypes(opNodeList, existingOpNodeList) {
+    if (opNodeList === void 0) { opNodeList = []; }
+    if (existingOpNodeList === void 0) { existingOpNodeList = []; }
+    var finalOpNodeList = [];
+    var _loop_1 = function (opNodeType) {
+        var opNode = opNodeList.find(function (n) { return n.operation === opNodeType; }) || existingOpNodeList.find(function (n) { return n.operation === opNodeType; });
+        if (opNode) {
+            finalOpNodeList.push(opNode);
+        }
+    };
+    for (var opNodeType in operationTypeDefinitionNodeTypeRootTypeMap) {
+        _loop_1(opNodeType);
+    }
+    return finalOpNodeList;
+}
+function mergeSchemaDefs(node, existingNode, config) {
+    if (existingNode) {
+        return {
+            kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) ||
+                node.kind === graphql.Kind.SCHEMA_DEFINITION ||
+                existingNode.kind === graphql.Kind.SCHEMA_DEFINITION
+                ? graphql.Kind.SCHEMA_DEFINITION
+                : graphql.Kind.SCHEMA_EXTENSION,
+            description: node['description'] || existingNode['description'],
+            directives: mergeDirectives(node.directives, existingNode.directives, config),
+            operationTypes: mergeOperationTypes(node.operationTypes, existingNode.operationTypes),
+        };
+    }
+    return ((config === null || config === void 0 ? void 0 : config.convertExtensions)
+        ? tslib.__assign(tslib.__assign({}, node), { kind: graphql.Kind.SCHEMA_EXTENSION }) : node);
+}
+
+function isNamedDefinitionNode(definitionNode) {
+    return 'name' in definitionNode;
+}
+var schemaDefSymbol = Symbol('schemaDefSymbol');
 function mergeGraphQLNodes(nodes, config) {
-    return nodes.reduce(function (prev, nodeDefinition) {
-        var node = nodeDefinition;
-        if (node && node.name && node.name.value) {
-            var name_1 = node.name.value;
-            if (config && config.commentDescriptions) {
-                collectComment(node);
-            }
-            if (config &&
-                config.exclusions &&
-                (config.exclusions.includes(name_1 + '.*') || config.exclusions.includes(name_1))) {
-                delete prev[name_1];
-            }
-            else if (isGraphQLType(nodeDefinition) || isGraphQLTypeExtension(nodeDefinition)) {
-                prev[name_1] = mergeType(nodeDefinition, prev[name_1], config);
-            }
-            else if (isGraphQLEnum(nodeDefinition) || isGraphQLEnumExtension(nodeDefinition)) {
-                prev[name_1] = mergeEnum(nodeDefinition, prev[name_1], config);
-            }
-            else if (isGraphQLUnion(nodeDefinition) || isGraphQLUnionExtension(nodeDefinition)) {
-                prev[name_1] = mergeUnion(nodeDefinition, prev[name_1], config);
-            }
-            else if (isGraphQLScalar(nodeDefinition) || isGraphQLScalarExtension(nodeDefinition)) {
-                prev[name_1] = mergeScalar(nodeDefinition, prev[name_1], config);
-            }
-            else if (isGraphQLInputType(nodeDefinition) || isGraphQLInputTypeExtension(nodeDefinition)) {
-                prev[name_1] = mergeInputType(nodeDefinition, prev[name_1], config);
-            }
-            else if (isGraphQLInterface(nodeDefinition) || isGraphQLInterfaceExtension(nodeDefinition)) {
-                prev[name_1] = mergeInterface(nodeDefinition, prev[name_1], config);
+    var e_1, _a;
+    var _b, _c;
+    var mergedResultMap = {};
+    try {
+        for (var nodes_1 = tslib.__values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) {
+            var nodeDefinition = nodes_1_1.value;
+            if (isNamedDefinitionNode(nodeDefinition)) {
+                var name_1 = nodeDefinition.name.value;
+                if (config === null || config === void 0 ? void 0 : config.commentDescriptions) {
+                    collectComment(nodeDefinition);
+                }
+                if (((_b = config === null || config === void 0 ? void 0 : config.exclusions) === null || _b === void 0 ? void 0 : _b.includes(name_1 + '.*')) || ((_c = config === null || config === void 0 ? void 0 : config.exclusions) === null || _c === void 0 ? void 0 : _c.includes(name_1))) {
+                    delete mergedResultMap[name_1];
+                }
+                else {
+                    switch (nodeDefinition.kind) {
+                        case graphql.Kind.OBJECT_TYPE_DEFINITION:
+                        case graphql.Kind.OBJECT_TYPE_EXTENSION:
+                            mergedResultMap[name_1] = mergeType(nodeDefinition, mergedResultMap[name_1], config);
+                            break;
+                        case graphql.Kind.ENUM_TYPE_DEFINITION:
+                        case graphql.Kind.ENUM_TYPE_EXTENSION:
+                            mergedResultMap[name_1] = mergeEnum(nodeDefinition, mergedResultMap[name_1], config);
+                            break;
+                        case graphql.Kind.UNION_TYPE_DEFINITION:
+                        case graphql.Kind.UNION_TYPE_EXTENSION:
+                            mergedResultMap[name_1] = mergeUnion(nodeDefinition, mergedResultMap[name_1], config);
+                            break;
+                        case graphql.Kind.SCALAR_TYPE_DEFINITION:
+                        case graphql.Kind.SCALAR_TYPE_EXTENSION:
+                            mergedResultMap[name_1] = mergeScalar(nodeDefinition, mergedResultMap[name_1], config);
+                            break;
+                        case graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                        case graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION:
+                            mergedResultMap[name_1] = mergeInputType(nodeDefinition, mergedResultMap[name_1], config);
+                            break;
+                        case graphql.Kind.INTERFACE_TYPE_DEFINITION:
+                        case graphql.Kind.INTERFACE_TYPE_EXTENSION:
+                            mergedResultMap[name_1] = mergeInterface(nodeDefinition, mergedResultMap[name_1], config);
+                            break;
+                        case graphql.Kind.DIRECTIVE_DEFINITION:
+                            mergedResultMap[name_1] = mergeDirective(nodeDefinition, mergedResultMap[name_1]);
+                            break;
+                    }
+                }
             }
-            else if (isGraphQLDirective(nodeDefinition)) {
-                prev[name_1] = mergeDirective(nodeDefinition, prev[name_1]);
+            else if (nodeDefinition.kind === graphql.Kind.SCHEMA_DEFINITION || nodeDefinition.kind === graphql.Kind.SCHEMA_EXTENSION) {
+                mergedResultMap[schemaDefSymbol] = mergeSchemaDefs(nodeDefinition, mergedResultMap[schemaDefSymbol], config);
             }
         }
-        return prev;
-    }, {});
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) _a.call(nodes_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return mergedResultMap;
 }
 
 function mergeTypeDefs(types, config) {
@@ -917,61 +953,100 @@ function mergeTypeDefs(types, config) {
     resetComments();
     return result;
 }
-function mergeGraphQLTypes(types, config) {
-    resetComments();
-    var allNodes = types
-        .map(function (type) {
-        if (Array.isArray(type)) {
-            type = mergeTypeDefs(type);
-        }
-        if (graphql.isSchema(type)) {
-            return utils.getDocumentNodeFromSchema(type);
+function visitTypeSources(types, allNodes) {
+    var e_1, _a;
+    try {
+        for (var types_1 = tslib.__values(types), types_1_1 = types_1.next(); !types_1_1.done; types_1_1 = types_1.next()) {
+            var type = types_1_1.value;
+            if (type) {
+                if (Array.isArray(type)) {
+                    visitTypeSources(types, allNodes);
+                }
+                else if (graphql.isSchema(type)) {
+                    var documentNode = utils.getDocumentNodeFromSchema(type);
+                    visitTypeSources(documentNode.definitions, allNodes);
+                }
+                else if (isStringTypes(type) || isSourceTypes(type)) {
+                    var documentNode = graphql.parse(type);
+                    visitTypeSources(documentNode.definitions, allNodes);
+                }
+                else if (graphql.isDefinitionNode(type)) {
+                    allNodes.push(type);
+                }
+                else {
+                    visitTypeSources(type.definitions, allNodes);
+                }
+            }
         }
-        else if (isStringTypes(type) || isSourceTypes(type)) {
-            return graphql.parse(type);
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (types_1_1 && !types_1_1.done && (_a = types_1.return)) _a.call(types_1);
         }
-        return type;
-    })
-        .map(function (ast) { return ast.definitions; })
-        .reduce(function (defs, newDef) {
-        if (newDef === void 0) { newDef = []; }
-        return tslib.__spread(defs, newDef);
-    }, []);
-    // XXX: right now we don't handle multiple schema definitions
-    var schemaDef = allNodes.filter(isSchemaDefinition).reduce(function (def, node) {
-        node.operationTypes
-            .filter(function (op) { return op.type.name.value; })
-            .forEach(function (op) {
-            def[op.operation] = op.type.name.value;
-        });
-        return def;
-    }, {
-        query: null,
-        mutation: null,
-        subscription: null,
-    });
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+function mergeGraphQLTypes(types, config) {
+    var _a, _b;
+    resetComments();
+    var allNodes = [];
+    visitTypeSources(types, allNodes);
     var mergedNodes = mergeGraphQLNodes(allNodes, config);
-    var allTypes = Object.keys(mergedNodes);
-    if (config && config.sort) {
-        allTypes.sort(typeof config.sort === 'function' ? config.sort : undefined);
+    // XXX: right now we don't handle multiple schema definitions
+    var schemaDef = mergedNodes[schemaDefSymbol] || {
+        kind: graphql.Kind.SCHEMA_DEFINITION,
+        operationTypes: [],
+    };
+    if (config === null || config === void 0 ? void 0 : config.useSchemaDefinition) {
+        var operationTypes = schemaDef.operationTypes;
+        var _loop_1 = function (opTypeDefNodeType) {
+            var opTypeDefNode = operationTypes.find(function (operationType) { return operationType.operation === opTypeDefNodeType; });
+            if (!opTypeDefNode) {
+                var existingPossibleRootType = mergedNodes[operationTypeDefinitionNodeTypeRootTypeMap[opTypeDefNodeType]];
+                if (existingPossibleRootType) {
+                    operationTypes.push({
+                        kind: graphql.Kind.OPERATION_TYPE_DEFINITION,
+                        type: {
+                            kind: graphql.Kind.NAMED_TYPE,
+                            name: existingPossibleRootType.name,
+                        },
+                        operation: opTypeDefNodeType,
+                    });
+                }
+            }
+        };
+        for (var opTypeDefNodeType in operationTypeDefinitionNodeTypeRootTypeMap) {
+            _loop_1(opTypeDefNodeType);
+        }
     }
-    if (config && config.useSchemaDefinition) {
-        var queryType = schemaDef.query ? schemaDef.query : allTypes.find(function (t) { return t === 'Query'; });
-        var mutationType = schemaDef.mutation ? schemaDef.mutation : allTypes.find(function (t) { return t === 'Mutation'; });
-        var subscriptionType = schemaDef.subscription ? schemaDef.subscription : allTypes.find(function (t) { return t === 'Subscription'; });
+    if ((config === null || config === void 0 ? void 0 : config.forceSchemaDefinition) && !((_a = schemaDef === null || schemaDef === void 0 ? void 0 : schemaDef.operationTypes) === null || _a === void 0 ? void 0 : _a.length)) {
         schemaDef = {
-            query: queryType,
-            mutation: mutationType,
-            subscription: subscriptionType,
+            kind: graphql.Kind.SCHEMA_DEFINITION,
+            operationTypes: [
+                {
+                    kind: graphql.Kind.OPERATION_TYPE_DEFINITION,
+                    operation: 'query',
+                    type: {
+                        kind: graphql.Kind.NAMED_TYPE,
+                        name: {
+                            kind: graphql.Kind.NAME,
+                            value: 'Query',
+                        },
+                    },
+                },
+            ],
         };
     }
-    var schemaDefinition = utils.createSchemaDefinition(schemaDef, {
-        force: config.forceSchemaDefinition,
-    });
-    if (!schemaDefinition) {
-        return Object.values(mergedNodes);
+    var mergedNodeDefinitions = Object.values(mergedNodes);
+    if ((_b = schemaDef.operationTypes) === null || _b === void 0 ? void 0 : _b.length) {
+        mergedNodeDefinitions.push(schemaDef);
+    }
+    if (config === null || config === void 0 ? void 0 : config.sort) {
+        var sortFn_1 = typeof config.sort === 'function' ? config.sort : defaultStringComparator;
+        mergedNodeDefinitions.sort(function (a, b) { var _a, _b; return sortFn_1((_a = a.name) === null || _a === void 0 ? void 0 : _a.value, (_b = b.name) === null || _b === void 0 ? void 0 : _b.value); });
     }
-    return tslib.__spread(Object.values(mergedNodes), [graphql.parse(schemaDefinition).definitions[0]]);
+    return mergedNodeDefinitions;
 }
 
 function travelSchemaPossibleExtensions(schema, hooks) {
@@ -1267,7 +1342,7 @@ function mergeSchemas(config) {
         }
         finally { if (e_1) throw e_1.error; }
     }
-    extractedResolvers.push.apply(extractedResolvers, tslib.__spread(ensureResolvers(config)));
+    extractedResolvers.push.apply(extractedResolvers, tslib.__spreadArray([], tslib.__read(ensureResolvers(config))));
     var resolvers = mergeResolvers(extractedResolvers, config);
     var extensions = mergeExtensions(extractedExtensions);
     return makeSchema({ resolvers: resolvers, typeDefs: typeDefs, extensions: extensions }, config);
@@ -1287,7 +1362,7 @@ function mergeSchemasAsync(config) {
                         Promise.all(config.schemas.map(function (schema) { return tslib.__awaiter(_this, void 0, void 0, function () { return tslib.__generator(this, function (_a) {
                             return [2 /*return*/, utils.getResolversFromSchema(schema)];
                         }); }); })).then(function (extractedResolvers) {
-                            return mergeResolvers(tslib.__spread(extractedResolvers, ensureResolvers(config)), config);
+                            return mergeResolvers(tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(extractedResolvers)), tslib.__read(ensureResolvers(config))), config);
                         }),
                         Promise.all(config.schemas.map(function (schema) { return tslib.__awaiter(_this, void 0, void 0, function () { return tslib.__generator(this, function (_a) {
                             return [2 /*return*/, extractExtensionsFromSchema(schema)];
@@ -1304,7 +1379,7 @@ function mergeSchemasAsync(config) {
 }
 function mergeTypes(_a) {
     var schemas = _a.schemas, typeDefs = _a.typeDefs, config = tslib.__rest(_a, ["schemas", "typeDefs"]);
-    return mergeTypeDefs(tslib.__spread(schemas, (typeDefs ? utils.asArray(typeDefs) : [])), config);
+    return mergeTypeDefs(tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(schemas)), tslib.__read((typeDefs ? utils.asArray(typeDefs) : []))), config);
 }
 function ensureResolvers(config) {
     return config.resolvers ? utils.asArray(config.resolvers) : [];
@@ -1335,24 +1410,12 @@ function makeSchema(_a, config) {
 
 exports.applyExtensions = applyExtensions;
 exports.collectComment = collectComment;
+exports.defaultStringComparator = defaultStringComparator;
 exports.extractExtensionsFromSchema = extractExtensionsFromSchema;
 exports.extractType = extractType;
-exports.isGraphQLDirective = isGraphQLDirective;
-exports.isGraphQLEnum = isGraphQLEnum;
-exports.isGraphQLEnumExtension = isGraphQLEnumExtension;
-exports.isGraphQLInputType = isGraphQLInputType;
-exports.isGraphQLInputTypeExtension = isGraphQLInputTypeExtension;
-exports.isGraphQLInterface = isGraphQLInterface;
-exports.isGraphQLInterfaceExtension = isGraphQLInterfaceExtension;
-exports.isGraphQLScalar = isGraphQLScalar;
-exports.isGraphQLScalarExtension = isGraphQLScalarExtension;
-exports.isGraphQLType = isGraphQLType;
-exports.isGraphQLTypeExtension = isGraphQLTypeExtension;
-exports.isGraphQLUnion = isGraphQLUnion;
-exports.isGraphQLUnionExtension = isGraphQLUnionExtension;
 exports.isListTypeNode = isListTypeNode;
+exports.isNamedDefinitionNode = isNamedDefinitionNode;
 exports.isNonNullTypeNode = isNonNullTypeNode;
-exports.isSchemaDefinition = isSchemaDefinition;
 exports.isSourceTypes = isSourceTypes;
 exports.isStringTypes = isStringTypes;
 exports.isWrappingTypeNode = isWrappingTypeNode;
@@ -1380,5 +1443,6 @@ exports.printTypeNode = printTypeNode;
 exports.printWithComments = printWithComments;
 exports.pushComment = pushComment;
 exports.resetComments = resetComments;
+exports.schemaDefSymbol = schemaDefSymbol;
 exports.travelSchemaPossibleExtensions = travelSchemaPossibleExtensions;
 //# sourceMappingURL=index.cjs.js.map