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

package/es5/index.esm.js

@@ -1,6 +1,6 @@
-import { __values, __read, __spread, __assign, __awaiter, __generator, __rest } from 'tslib';
-import { mergeDeep, compareNodes, isNotEqual, getDocumentNodeFromSchema, createSchemaDefinition, asArray, getResolversFromSchema, SchemaDirectiveVisitor } from '@graphql-tools/utils/es5';
-import { getDescription, visit, print, Source, Kind, isSchema, parse, isScalarType, isSpecifiedScalarType, isIntrospectionType, isObjectType, isInterfaceType, isInputObjectType, isUnionType, isEnumType, buildSchema, buildASTSchema } from 'graphql';
+import { __values, __read, __spreadArray, __assign, __awaiter, __generator, __rest } from 'tslib';
+import { mergeDeep, compareNodes, isNotEqual, getDocumentNodeFromSchema, asArray, getResolversFromSchema, SchemaDirectiveVisitor } 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, addErrorLoggingToSchema } from '@graphql-tools/schema/es5';
 
 /**
@@ -74,7 +74,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, __spread(args)); });
+            var resultsOfFactories = resolversFactories.map(function (factory) { return factory.apply(void 0, __spreadArray([], __read(args))); });
             return resolvers.concat(resultsOfFactories).reduce(mergeDeep, {});
         });
     }
@@ -199,12 +199,12 @@ function addDescription(cb) {
             }
             return prev[key];
         }, ancestors[0]);
-        var key = __spread(keys, [parent.name.value]).join('.');
+        var key = __spreadArray(__spreadArray([], __read(keys)), [parent.name.value]).join('.');
         var items = [];
         if (commentsRegistry[key]) {
-            items.push.apply(items, __spread(commentsRegistry[key]));
+            items.push.apply(items, __spreadArray([], __read(commentsRegistry[key])));
         }
-        return join(__spread(items.map(printComment), [node.description, cb(node)]), '\n');
+        return join(__spreadArray(__spreadArray([], __read(items.map(printComment))), [node.description, cb(node)]), '\n');
     };
 }
 function indent(maybeString) {
@@ -407,7 +407,7 @@ function nameAlreadyExists(name, namesArr) {
 }
 function mergeArguments$1(a1, a2) {
     var e_1, _a;
-    var result = __spread(a2);
+    var result = __spreadArray([], __read(a2));
     var _loop_1 = function (argument) {
         var existingIndex = result.findIndex(function (a) { return a.name.value === argument.name.value; });
         if (existingIndex > -1) {
@@ -464,7 +464,7 @@ function mergeDirectives(d1, d2, config) {
     var reverseOrder = config && config.reverseDirectives;
     var asNext = reverseOrder ? d1 : d2;
     var asFirst = reverseOrder ? d2 : d1;
-    var result = deduplicateDirectives(__spread(asNext));
+    var result = deduplicateDirectives(__spreadArray([], __read(asNext)));
     var _loop_2 = function (directive) {
         if (directiveAlreadyExists(result, directive)) {
             var existingDirectiveIndex = result.findIndex(function (d) { return d.name.value === directive.name.value; });
@@ -503,7 +503,7 @@ function validateInputs(node, existingNode) {
 function mergeDirective(node, existingNode) {
     if (existingNode) {
         validateInputs(node, existingNode);
-        return __assign(__assign({}, node), { locations: __spread(existingNode.locations, node.locations.filter(function (name) { return !nameAlreadyExists(name, existingNode.locations); })) });
+        return __assign(__assign({}, node), { locations: __spreadArray(__spreadArray([], __read(existingNode.locations)), __read(node.locations.filter(function (name) { return !nameAlreadyExists(name, existingNode.locations); }))) });
     }
     return node;
 }
@@ -553,7 +553,7 @@ function mergeEnumValues(first, second, config) {
         }
         finally { if (e_2) throw e_2.error; }
     }
-    var result = __spread(enumValueMap.values());
+    var result = __spreadArray([], __read(enumValueMap.values()));
     if (config && config.sort) {
         result.sort(compareNodes);
     }
@@ -583,55 +583,13 @@ function isStringTypes(types) {
 function isSourceTypes(types) {
     return types instanceof 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 === Kind.LIST_TYPE || visitedType.kind === 'NonNullType') {
         visitedType = visitedType.type;
     }
     return visitedType;
 }
-function isSchemaDefinition(node) {
-    return node.kind === 'SchemaDefinition';
-}
 function isWrappingTypeNode(type) {
     return type.kind !== Kind.NAMED_TYPE;
 }
@@ -650,10 +608,23 @@ function printTypeNode(type) {
     }
     return type.name.value;
 }
+var CompareVal;
+(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";
+})(CompareVal || (CompareVal = {}));
+function defaultStringComparator(a, b) {
+    if (a < b)
+        return CompareVal.A_SMALLER_THAN_B;
+    if (a > b)
+        return CompareVal.A_GREATER_THAN_B;
+    return 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) {
@@ -664,18 +635,20 @@ function fieldAlreadyExists(fieldsArr, otherField) {
 }
 function mergeFields(type, f1, f2, config) {
     var e_1, _a;
-    var result = __spread(f2);
+    var result = __spreadArray([], __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);
@@ -789,7 +762,7 @@ function alreadyExists(arr, other) {
     return !!arr.find(function (i) { return i.name.value === other.name.value; });
 }
 function mergeNamedTypeArray(first, second, config) {
-    var result = __spread(second, first.filter(function (d) { return !alreadyExists(second, d); }));
+    var result = __spreadArray(__spreadArray([], __read(second)), __read(first.filter(function (d) { return !alreadyExists(second, d); })));
     if (config && config.sort) {
         result.sort(compareNodes);
     }
@@ -858,43 +831,107 @@ function mergeUnion(first, second, config) {
         ? __assign(__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 === Kind.SCHEMA_DEFINITION ||
+                existingNode.kind === Kind.SCHEMA_DEFINITION
+                ? Kind.SCHEMA_DEFINITION
+                : 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)
+        ? __assign(__assign({}, node), { kind: 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 = __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 Kind.OBJECT_TYPE_DEFINITION:
+                        case Kind.OBJECT_TYPE_EXTENSION:
+                            mergedResultMap[name_1] = mergeType(nodeDefinition, mergedResultMap[name_1], config);
+                            break;
+                        case Kind.ENUM_TYPE_DEFINITION:
+                        case Kind.ENUM_TYPE_EXTENSION:
+                            mergedResultMap[name_1] = mergeEnum(nodeDefinition, mergedResultMap[name_1], config);
+                            break;
+                        case Kind.UNION_TYPE_DEFINITION:
+                        case Kind.UNION_TYPE_EXTENSION:
+                            mergedResultMap[name_1] = mergeUnion(nodeDefinition, mergedResultMap[name_1], config);
+                            break;
+                        case Kind.SCALAR_TYPE_DEFINITION:
+                        case Kind.SCALAR_TYPE_EXTENSION:
+                            mergedResultMap[name_1] = mergeScalar(nodeDefinition, mergedResultMap[name_1], config);
+                            break;
+                        case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                        case Kind.INPUT_OBJECT_TYPE_EXTENSION:
+                            mergedResultMap[name_1] = mergeInputType(nodeDefinition, mergedResultMap[name_1], config);
+                            break;
+                        case Kind.INTERFACE_TYPE_DEFINITION:
+                        case Kind.INTERFACE_TYPE_EXTENSION:
+                            mergedResultMap[name_1] = mergeInterface(nodeDefinition, mergedResultMap[name_1], config);
+                            break;
+                        case 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 === Kind.SCHEMA_DEFINITION || nodeDefinition.kind === 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) {
@@ -913,61 +950,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 (isSchema(type)) {
-            return getDocumentNodeFromSchema(type);
+function visitTypeSources(types, allNodes) {
+    var e_1, _a;
+    try {
+        for (var types_1 = __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 (isSchema(type)) {
+                    var documentNode = getDocumentNodeFromSchema(type);
+                    visitTypeSources(documentNode.definitions, allNodes);
+                }
+                else if (isStringTypes(type) || isSourceTypes(type)) {
+                    var documentNode = parse(type);
+                    visitTypeSources(documentNode.definitions, allNodes);
+                }
+                else if (isDefinitionNode(type)) {
+                    allNodes.push(type);
+                }
+                else {
+                    visitTypeSources(type.definitions, allNodes);
+                }
+            }
         }
-        else if (isStringTypes(type) || isSourceTypes(type)) {
-            return 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 __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: 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: Kind.OPERATION_TYPE_DEFINITION,
+                        type: {
+                            kind: 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: Kind.SCHEMA_DEFINITION,
+            operationTypes: [
+                {
+                    kind: Kind.OPERATION_TYPE_DEFINITION,
+                    operation: 'query',
+                    type: {
+                        kind: Kind.NAMED_TYPE,
+                        name: {
+                            kind: Kind.NAME,
+                            value: 'Query',
+                        },
+                    },
+                },
+            ],
         };
     }
-    var schemaDefinition = 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 __spread(Object.values(mergedNodes), [parse(schemaDefinition).definitions[0]]);
+    return mergedNodeDefinitions;
 }
 
 function travelSchemaPossibleExtensions(schema, hooks) {
@@ -1263,7 +1339,7 @@ function mergeSchemas(config) {
         }
         finally { if (e_1) throw e_1.error; }
     }
-    extractedResolvers.push.apply(extractedResolvers, __spread(ensureResolvers(config)));
+    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);
@@ -1283,7 +1359,7 @@ function mergeSchemasAsync(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(__spread(extractedResolvers, ensureResolvers(config)), config);
+                            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)];
@@ -1300,7 +1376,7 @@ function mergeSchemasAsync(config) {
 }
 function mergeTypes(_a) {
     var schemas = _a.schemas, typeDefs = _a.typeDefs, config = __rest(_a, ["schemas", "typeDefs"]);
-    return mergeTypeDefs(__spread(schemas, (typeDefs ? asArray(typeDefs) : [])), config);
+    return mergeTypeDefs(__spreadArray(__spreadArray([], __read(schemas)), __read((typeDefs ? asArray(typeDefs) : []))), config);
 }
 function ensureResolvers(config) {
     return config.resolvers ? asArray(config.resolvers) : [];
@@ -1329,5 +1405,5 @@ function makeSchema(_a, config) {
     return schema;
 }
 
-export { applyExtensions, collectComment, extractExtensionsFromSchema, extractType, isGraphQLDirective, isGraphQLEnum, isGraphQLEnumExtension, isGraphQLInputType, isGraphQLInputTypeExtension, isGraphQLInterface, isGraphQLInterfaceExtension, isGraphQLScalar, isGraphQLScalarExtension, isGraphQLType, isGraphQLTypeExtension, isGraphQLUnion, isGraphQLUnionExtension, isListTypeNode, isNonNullTypeNode, isSchemaDefinition, 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, travelSchemaPossibleExtensions };
+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 };
 //# sourceMappingURL=index.esm.js.map