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

package/index.esm.js

@@ -1,5 +1,5 @@
-import { mergeDeep, compareNodes, isNotEqual, getDocumentNodeFromSchema, createSchemaDefinition, asArray, getResolversFromSchema, SchemaDirectiveVisitor } from '@graphql-tools/utils';
-import { getDescription, visit, print, Source, Kind, isSchema, parse, isScalarType, isSpecifiedScalarType, isIntrospectionType, isObjectType, isInterfaceType, isInputObjectType, isUnionType, isEnumType, buildSchema, buildASTSchema } from 'graphql';
+import { mergeDeep, compareNodes, isNotEqual, getDocumentNodeFromSchema, asArray, getResolversFromSchema, SchemaDirectiveVisitor } from '@graphql-tools/utils';
+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';
 
 /**
@@ -412,55 +412,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) {
     let 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;
 }
@@ -479,10 +437,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) {
     const result = fieldsArr.find(field => field.name.value === otherField.name.value);
-    if (result) {
+    if (result && !(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) {
         const t1 = extractType(result.type);
         const t2 = extractType(otherField.type);
         if (t1.name.value !== t2.name.value) {
@@ -494,16 +465,18 @@ function fieldAlreadyExists(fieldsArr, otherField) {
 function mergeFields(type, f1, f2, config) {
     const result = [...f2];
     for (const field of f1) {
-        if (fieldAlreadyExists(result, field)) {
+        if (fieldAlreadyExists(result, field, config)) {
             const existing = result.find((f) => f.name.value === field.name.value);
-            if (config && config.throwOnConflict) {
-                preventConflicts(type, existing, field, false);
-            }
-            else {
-                preventConflicts(type, existing, field, true);
-            }
-            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, false);
+                }
+                else {
+                    preventConflicts(type, existing, field, true);
+                }
+                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);
@@ -693,43 +666,95 @@ function mergeUnion(first, second, config) {
         : first;
 }
 
+const operationTypeDefinitionNodeTypeRootTypeMap = {
+    query: 'Query',
+    mutation: 'Mutation',
+    subscription: 'Subscription',
+};
+function mergeOperationTypes(opNodeList = [], existingOpNodeList = []) {
+    const finalOpNodeList = [];
+    for (const opNodeType in operationTypeDefinitionNodeTypeRootTypeMap) {
+        const opNode = opNodeList.find(n => n.operation === opNodeType) || existingOpNodeList.find(n => n.operation === opNodeType);
+        if (opNode) {
+            finalOpNodeList.push(opNode);
+        }
+    }
+    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)
+        ? {
+            ...node,
+            kind: Kind.SCHEMA_EXTENSION,
+        }
+        : node);
+}
+
+function isNamedDefinitionNode(definitionNode) {
+    return 'name' in definitionNode;
+}
+const schemaDefSymbol = Symbol('schemaDefSymbol');
 function mergeGraphQLNodes(nodes, config) {
-    return nodes.reduce((prev, nodeDefinition) => {
-        const node = nodeDefinition;
-        if (node && node.name && node.name.value) {
-            const name = node.name.value;
-            if (config && config.commentDescriptions) {
-                collectComment(node);
+    var _a, _b;
+    const mergedResultMap = {};
+    for (const nodeDefinition of nodes) {
+        if (isNamedDefinitionNode(nodeDefinition)) {
+            const name = nodeDefinition.name.value;
+            if (config === null || config === void 0 ? void 0 : config.commentDescriptions) {
+                collectComment(nodeDefinition);
             }
-            if (config &&
-                config.exclusions &&
-                (config.exclusions.includes(name + '.*') || config.exclusions.includes(name))) {
-                delete prev[name];
+            if (((_a = config === null || config === void 0 ? void 0 : config.exclusions) === null || _a === void 0 ? void 0 : _a.includes(name + '.*')) || ((_b = config === null || config === void 0 ? void 0 : config.exclusions) === null || _b === void 0 ? void 0 : _b.includes(name))) {
+                delete mergedResultMap[name];
             }
-            else if (isGraphQLType(nodeDefinition) || isGraphQLTypeExtension(nodeDefinition)) {
-                prev[name] = mergeType(nodeDefinition, prev[name], config);
-            }
-            else if (isGraphQLEnum(nodeDefinition) || isGraphQLEnumExtension(nodeDefinition)) {
-                prev[name] = mergeEnum(nodeDefinition, prev[name], config);
-            }
-            else if (isGraphQLUnion(nodeDefinition) || isGraphQLUnionExtension(nodeDefinition)) {
-                prev[name] = mergeUnion(nodeDefinition, prev[name], config);
-            }
-            else if (isGraphQLScalar(nodeDefinition) || isGraphQLScalarExtension(nodeDefinition)) {
-                prev[name] = mergeScalar(nodeDefinition, prev[name], config);
-            }
-            else if (isGraphQLInputType(nodeDefinition) || isGraphQLInputTypeExtension(nodeDefinition)) {
-                prev[name] = mergeInputType(nodeDefinition, prev[name], config);
-            }
-            else if (isGraphQLInterface(nodeDefinition) || isGraphQLInterfaceExtension(nodeDefinition)) {
-                prev[name] = mergeInterface(nodeDefinition, prev[name], config);
-            }
-            else if (isGraphQLDirective(nodeDefinition)) {
-                prev[name] = mergeDirective(nodeDefinition, prev[name]);
+            else {
+                switch (nodeDefinition.kind) {
+                    case Kind.OBJECT_TYPE_DEFINITION:
+                    case Kind.OBJECT_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeType(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case Kind.ENUM_TYPE_DEFINITION:
+                    case Kind.ENUM_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeEnum(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case Kind.UNION_TYPE_DEFINITION:
+                    case Kind.UNION_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeUnion(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case Kind.SCALAR_TYPE_DEFINITION:
+                    case Kind.SCALAR_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeScalar(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                    case Kind.INPUT_OBJECT_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeInputType(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case Kind.INTERFACE_TYPE_DEFINITION:
+                    case Kind.INTERFACE_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeInterface(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case Kind.DIRECTIVE_DEFINITION:
+                        mergedResultMap[name] = mergeDirective(nodeDefinition, mergedResultMap[name]);
+                        break;
+                }
             }
         }
-        return prev;
-    }, {});
+        else if (nodeDefinition.kind === Kind.SCHEMA_DEFINITION || nodeDefinition.kind === Kind.SCHEMA_EXTENSION) {
+            mergedResultMap[schemaDefSymbol] = mergeSchemaDefs(nodeDefinition, mergedResultMap[schemaDefSymbol], config);
+        }
+    }
+    return mergedResultMap;
 }
 
 function mergeTypeDefs(types, config) {
@@ -754,58 +779,86 @@ function mergeTypeDefs(types, config) {
     resetComments();
     return result;
 }
+function visitTypeSources(types, allNodes) {
+    for (const type of types) {
+        if (type) {
+            if (Array.isArray(type)) {
+                visitTypeSources(types, allNodes);
+            }
+            else if (isSchema(type)) {
+                const documentNode = getDocumentNodeFromSchema(type);
+                visitTypeSources(documentNode.definitions, allNodes);
+            }
+            else if (isStringTypes(type) || isSourceTypes(type)) {
+                const documentNode = parse(type);
+                visitTypeSources(documentNode.definitions, allNodes);
+            }
+            else if (isDefinitionNode(type)) {
+                allNodes.push(type);
+            }
+            else {
+                visitTypeSources(type.definitions, allNodes);
+            }
+        }
+    }
+}
 function mergeGraphQLTypes(types, config) {
+    var _a, _b;
     resetComments();
-    const allNodes = types
-        .map(type => {
-        if (Array.isArray(type)) {
-            type = mergeTypeDefs(type);
-        }
-        if (isSchema(type)) {
-            return getDocumentNodeFromSchema(type);
-        }
-        else if (isStringTypes(type) || isSourceTypes(type)) {
-            return parse(type);
-        }
-        return type;
-    })
-        .map(ast => ast.definitions)
-        .reduce((defs, newDef = []) => [...defs, ...newDef], []);
-    // XXX: right now we don't handle multiple schema definitions
-    let schemaDef = allNodes.filter(isSchemaDefinition).reduce((def, node) => {
-        node.operationTypes
-            .filter(op => op.type.name.value)
-            .forEach(op => {
-            def[op.operation] = op.type.name.value;
-        });
-        return def;
-    }, {
-        query: null,
-        mutation: null,
-        subscription: null,
-    });
+    const allNodes = [];
+    visitTypeSources(types, allNodes);
     const mergedNodes = mergeGraphQLNodes(allNodes, config);
-    const 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
+    let schemaDef = mergedNodes[schemaDefSymbol] || {
+        kind: Kind.SCHEMA_DEFINITION,
+        operationTypes: [],
+    };
+    if (config === null || config === void 0 ? void 0 : config.useSchemaDefinition) {
+        const operationTypes = schemaDef.operationTypes;
+        for (const opTypeDefNodeType in operationTypeDefinitionNodeTypeRootTypeMap) {
+            const opTypeDefNode = operationTypes.find(operationType => operationType.operation === opTypeDefNodeType);
+            if (!opTypeDefNode) {
+                const existingPossibleRootType = mergedNodes[operationTypeDefinitionNodeTypeRootTypeMap[opTypeDefNodeType]];
+                if (existingPossibleRootType) {
+                    operationTypes.push({
+                        kind: Kind.OPERATION_TYPE_DEFINITION,
+                        type: {
+                            kind: Kind.NAMED_TYPE,
+                            name: existingPossibleRootType.name,
+                        },
+                        operation: opTypeDefNodeType,
+                    });
+                }
+            }
+        }
     }
-    if (config && config.useSchemaDefinition) {
-        const queryType = schemaDef.query ? schemaDef.query : allTypes.find(t => t === 'Query');
-        const mutationType = schemaDef.mutation ? schemaDef.mutation : allTypes.find(t => t === 'Mutation');
-        const subscriptionType = schemaDef.subscription ? schemaDef.subscription : allTypes.find(t => 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',
+                        },
+                    },
+                },
+            ],
         };
     }
-    const schemaDefinition = createSchemaDefinition(schemaDef, {
-        force: config.forceSchemaDefinition,
-    });
-    if (!schemaDefinition) {
-        return Object.values(mergedNodes);
+    const 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) {
+        const sortFn = typeof config.sort === 'function' ? config.sort : defaultStringComparator;
+        mergedNodeDefinitions.sort((a, b) => { var _a, _b; return sortFn((_a = a.name) === null || _a === void 0 ? void 0 : _a.value, (_b = b.name) === null || _b === void 0 ? void 0 : _b.value); });
     }
-    return [...Object.values(mergedNodes), parse(schemaDefinition).definitions[0]];
+    return mergedNodeDefinitions;
 }
 
 function travelSchemaPossibleExtensions(schema, hooks) {
@@ -1000,5 +1053,5 @@ function makeSchema({ resolvers, typeDefs, extensions, }, 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