@graphql-tools/merge 8.2.15-alpha-b3ffd406.0 → 8.3.0-alpha-b76ec274.0

package/cjs/extensions.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractExtensionsFromSchema = exports.applyExtensions = exports.mergeExtensions = exports.travelSchemaPossibleExtensions = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+function travelSchemaPossibleExtensions(schema, hooks) {
+    hooks.onSchema(schema);
+    const typesMap = schema.getTypeMap();
+    for (const [, type] of Object.entries(typesMap)) {
+        const isPredefinedScalar = (0, graphql_1.isScalarType)(type) && (0, graphql_1.isSpecifiedScalarType)(type);
+        const isIntrospection = (0, graphql_1.isIntrospectionType)(type);
+        if (isPredefinedScalar || isIntrospection) {
+            continue;
+        }
+        if ((0, graphql_1.isObjectType)(type)) {
+            hooks.onObjectType(type);
+            const fields = type.getFields();
+            for (const [, field] of Object.entries(fields)) {
+                hooks.onObjectField(type, field);
+                const args = field.args || [];
+                for (const arg of args) {
+                    hooks.onObjectFieldArg(type, field, arg);
+                }
+            }
+        }
+        else if ((0, graphql_1.isInterfaceType)(type)) {
+            hooks.onInterface(type);
+            const fields = type.getFields();
+            for (const [, field] of Object.entries(fields)) {
+                hooks.onInterfaceField(type, field);
+                const args = field.args || [];
+                for (const arg of args) {
+                    hooks.onInterfaceFieldArg(type, field, arg);
+                }
+            }
+        }
+        else if ((0, graphql_1.isInputObjectType)(type)) {
+            hooks.onInputType(type);
+            const fields = type.getFields();
+            for (const [, field] of Object.entries(fields)) {
+                hooks.onInputFieldType(type, field);
+            }
+        }
+        else if ((0, graphql_1.isUnionType)(type)) {
+            hooks.onUnion(type);
+        }
+        else if ((0, graphql_1.isScalarType)(type)) {
+            hooks.onScalar(type);
+        }
+        else if ((0, graphql_1.isEnumType)(type)) {
+            hooks.onEnum(type);
+            for (const value of type.getValues()) {
+                hooks.onEnumValue(type, value);
+            }
+        }
+    }
+}
+exports.travelSchemaPossibleExtensions = travelSchemaPossibleExtensions;
+function mergeExtensions(extensions) {
+    return (0, utils_1.mergeDeep)(extensions);
+}
+exports.mergeExtensions = mergeExtensions;
+function applyExtensionObject(obj, extensions) {
+    if (!obj) {
+        return;
+    }
+    obj.extensions = (0, utils_1.mergeDeep)([obj.extensions || {}, extensions || {}]);
+}
+function applyExtensions(schema, extensions) {
+    applyExtensionObject(schema, extensions.schemaExtensions);
+    for (const [typeName, data] of Object.entries(extensions.types || {})) {
+        const type = schema.getType(typeName);
+        if (type) {
+            applyExtensionObject(type, data.extensions);
+            if (data.type === 'object' || data.type === 'interface') {
+                for (const [fieldName, fieldData] of Object.entries(data.fields)) {
+                    const field = type.getFields()[fieldName];
+                    if (field) {
+                        applyExtensionObject(field, fieldData.extensions);
+                        for (const [arg, argData] of Object.entries(fieldData.arguments)) {
+                            applyExtensionObject(field.args.find(a => a.name === arg), argData);
+                        }
+                    }
+                }
+            }
+            else if (data.type === 'input') {
+                for (const [fieldName, fieldData] of Object.entries(data.fields)) {
+                    const field = type.getFields()[fieldName];
+                    applyExtensionObject(field, fieldData.extensions);
+                }
+            }
+            else if (data.type === 'enum') {
+                for (const [valueName, valueData] of Object.entries(data.values)) {
+                    const value = type.getValue(valueName);
+                    applyExtensionObject(value, valueData);
+                }
+            }
+        }
+    }
+    return schema;
+}
+exports.applyExtensions = applyExtensions;
+function extractExtensionsFromSchema(schema) {
+    const result = {
+        schemaExtensions: {},
+        types: {},
+    };
+    travelSchemaPossibleExtensions(schema, {
+        onSchema: schema => (result.schemaExtensions = schema.extensions || {}),
+        onObjectType: type => (result.types[type.name] = { fields: {}, type: 'object', extensions: type.extensions || {} }),
+        onObjectField: (type, field) => (result.types[type.name].fields[field.name] = {
+            arguments: {},
+            extensions: field.extensions || {},
+        }),
+        onObjectFieldArg: (type, field, arg) => (result.types[type.name].fields[field.name].arguments[arg.name] = arg.extensions || {}),
+        onInterface: type => (result.types[type.name] = { fields: {}, type: 'interface', extensions: type.extensions || {} }),
+        onInterfaceField: (type, field) => (result.types[type.name].fields[field.name] = {
+            arguments: {},
+            extensions: field.extensions || {},
+        }),
+        onInterfaceFieldArg: (type, field, arg) => (result.types[type.name].fields[field.name].arguments[arg.name] =
+            arg.extensions || {}),
+        onEnum: type => (result.types[type.name] = { values: {}, type: 'enum', extensions: type.extensions || {} }),
+        onEnumValue: (type, value) => (result.types[type.name].values[value.name] = value.extensions || {}),
+        onScalar: type => (result.types[type.name] = { type: 'scalar', extensions: type.extensions || {} }),
+        onUnion: type => (result.types[type.name] = { type: 'union', extensions: type.extensions || {} }),
+        onInputType: type => (result.types[type.name] = { fields: {}, type: 'input', extensions: type.extensions || {} }),
+        onInputFieldType: (type, field) => (result.types[type.name].fields[field.name] = { extensions: field.extensions || {} }),
+    });
+    return result;
+}
+exports.extractExtensionsFromSchema = extractExtensionsFromSchema;

package/cjs/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./merge-resolvers.js"), exports);
+tslib_1.__exportStar(require("./typedefs-mergers/index.js"), exports);
+tslib_1.__exportStar(require("./extensions.js"), exports);

package/cjs/merge-resolvers.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeResolvers = void 0;
+const utils_1 = require("@graphql-tools/utils");
+/**
+ * Deep merges multiple resolver definition objects into a single definition.
+ * @param resolversDefinitions Resolver definitions to be merged
+ * @param options Additional options
+ *
+ * ```js
+ * const { mergeResolvers } = require('@graphql-tools/merge');
+ * const clientResolver = require('./clientResolver');
+ * const productResolver = require('./productResolver');
+ *
+ * const resolvers = mergeResolvers([
+ *  clientResolver,
+ *  productResolver,
+ * ]);
+ * ```
+ *
+ * If you don't want to manually create the array of resolver objects, you can
+ * also use this function along with loadFiles:
+ *
+ * ```js
+ * const path = require('path');
+ * const { mergeResolvers } = require('@graphql-tools/merge');
+ * const { loadFilesSync } = require('@graphql-tools/load-files');
+ *
+ * const resolversArray = loadFilesSync(path.join(__dirname, './resolvers'));
+ *
+ * const resolvers = mergeResolvers(resolversArray)
+ * ```
+ */
+function mergeResolvers(resolversDefinitions, options) {
+    if (!resolversDefinitions || (Array.isArray(resolversDefinitions) && resolversDefinitions.length === 0)) {
+        return {};
+    }
+    if (!Array.isArray(resolversDefinitions)) {
+        return resolversDefinitions;
+    }
+    if (resolversDefinitions.length === 1) {
+        return resolversDefinitions[0] || {};
+    }
+    const resolvers = new Array();
+    for (let resolversDefinition of resolversDefinitions) {
+        if (Array.isArray(resolversDefinition)) {
+            resolversDefinition = mergeResolvers(resolversDefinition);
+        }
+        if (typeof resolversDefinition === 'object' && resolversDefinition) {
+            resolvers.push(resolversDefinition);
+        }
+    }
+    const result = (0, utils_1.mergeDeep)(resolvers, true);
+    if (options === null || options === void 0 ? void 0 : options.exclusions) {
+        for (const exclusion of options.exclusions) {
+            const [typeName, fieldName] = exclusion.split('.');
+            if (!fieldName || fieldName === '*') {
+                delete result[typeName];
+            }
+            else if (result[typeName]) {
+                delete result[typeName][fieldName];
+            }
+        }
+    }
+    return result;
+}
+exports.mergeResolvers = mergeResolvers;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/typedefs-mergers/arguments.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeArguments = void 0;
+const utils_1 = require("@graphql-tools/utils");
+function mergeArguments(args1, args2, config) {
+    const result = deduplicateArguments([...args2, ...args1].filter(utils_1.isSome));
+    if (config && config.sort) {
+        result.sort(utils_1.compareNodes);
+    }
+    return result;
+}
+exports.mergeArguments = mergeArguments;
+function deduplicateArguments(args) {
+    return args.reduce((acc, current) => {
+        const dup = acc.find(arg => arg.name.value === current.name.value);
+        if (!dup) {
+            return acc.concat([current]);
+        }
+        return acc;
+    }, []);
+}

package/cjs/typedefs-mergers/directives.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeDirective = exports.mergeDirectives = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+function directiveAlreadyExists(directivesArr, otherDirective) {
+    return !!directivesArr.find(directive => directive.name.value === otherDirective.name.value);
+}
+function nameAlreadyExists(name, namesArr) {
+    return namesArr.some(({ value }) => value === name.value);
+}
+function mergeArguments(a1, a2) {
+    const result = [...a2];
+    for (const argument of a1) {
+        const existingIndex = result.findIndex(a => a.name.value === argument.name.value);
+        if (existingIndex > -1) {
+            const existingArg = result[existingIndex];
+            if (existingArg.value.kind === 'ListValue') {
+                const source = existingArg.value.values;
+                const target = argument.value.values;
+                // merge values of two lists
+                existingArg.value.values = deduplicateLists(source, target, (targetVal, source) => {
+                    const value = targetVal.value;
+                    return !value || !source.some((sourceVal) => sourceVal.value === value);
+                });
+            }
+            else {
+                existingArg.value = argument.value;
+            }
+        }
+        else {
+            result.push(argument);
+        }
+    }
+    return result;
+}
+function deduplicateDirectives(directives) {
+    return directives
+        .map((directive, i, all) => {
+        const firstAt = all.findIndex(d => d.name.value === directive.name.value);
+        if (firstAt !== i) {
+            const dup = all[firstAt];
+            directive.arguments = mergeArguments(directive.arguments, dup.arguments);
+            return null;
+        }
+        return directive;
+    })
+        .filter(utils_1.isSome);
+}
+function mergeDirectives(d1 = [], d2 = [], config) {
+    const reverseOrder = config && config.reverseDirectives;
+    const asNext = reverseOrder ? d1 : d2;
+    const asFirst = reverseOrder ? d2 : d1;
+    const result = deduplicateDirectives([...asNext]);
+    for (const directive of asFirst) {
+        if (directiveAlreadyExists(result, directive)) {
+            const existingDirectiveIndex = result.findIndex(d => d.name.value === directive.name.value);
+            const existingDirective = result[existingDirectiveIndex];
+            result[existingDirectiveIndex].arguments = mergeArguments(directive.arguments || [], existingDirective.arguments || []);
+        }
+        else {
+            result.push(directive);
+        }
+    }
+    return result;
+}
+exports.mergeDirectives = mergeDirectives;
+function validateInputs(node, existingNode) {
+    const printedNode = (0, graphql_1.print)({
+        ...node,
+        description: undefined,
+    });
+    const printedExistingNode = (0, graphql_1.print)({
+        ...existingNode,
+        description: undefined,
+    });
+    // eslint-disable-next-line
+    const leaveInputs = new RegExp('(directive @w*d*)|( on .*$)', 'g');
+    const sameArguments = printedNode.replace(leaveInputs, '') === printedExistingNode.replace(leaveInputs, '');
+    if (!sameArguments) {
+        throw new Error(`Unable to merge GraphQL directive "${node.name.value}". \nExisting directive:  \n\t${printedExistingNode} \nReceived directive: \n\t${printedNode}`);
+    }
+}
+function mergeDirective(node, existingNode) {
+    if (existingNode) {
+        validateInputs(node, existingNode);
+        return {
+            ...node,
+            locations: [
+                ...existingNode.locations,
+                ...node.locations.filter(name => !nameAlreadyExists(name, existingNode.locations)),
+            ],
+        };
+    }
+    return node;
+}
+exports.mergeDirective = mergeDirective;
+function deduplicateLists(source, target, filterFn) {
+    return source.concat(target.filter(val => filterFn(val, source)));
+}

package/cjs/typedefs-mergers/enum-values.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeEnumValues = void 0;
+const directives_js_1 = require("./directives.js");
+const utils_1 = require("@graphql-tools/utils");
+function mergeEnumValues(first, second, config) {
+    if (config === null || config === void 0 ? void 0 : config.consistentEnumMerge) {
+        const reversed = [];
+        if (first) {
+            reversed.push(...first);
+        }
+        first = second;
+        second = reversed;
+    }
+    const enumValueMap = new Map();
+    if (first) {
+        for (const firstValue of first) {
+            enumValueMap.set(firstValue.name.value, firstValue);
+        }
+    }
+    if (second) {
+        for (const secondValue of second) {
+            const enumValue = secondValue.name.value;
+            if (enumValueMap.has(enumValue)) {
+                const firstValue = enumValueMap.get(enumValue);
+                firstValue.description = secondValue.description || firstValue.description;
+                firstValue.directives = (0, directives_js_1.mergeDirectives)(secondValue.directives, firstValue.directives);
+            }
+            else {
+                enumValueMap.set(enumValue, secondValue);
+            }
+        }
+    }
+    const result = [...enumValueMap.values()];
+    if (config && config.sort) {
+        result.sort(utils_1.compareNodes);
+    }
+    return result;
+}
+exports.mergeEnumValues = mergeEnumValues;

package/cjs/typedefs-mergers/enum.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeEnum = void 0;
+const graphql_1 = require("graphql");
+const directives_js_1 = require("./directives.js");
+const enum_values_js_1 = require("./enum-values.js");
+function mergeEnum(e1, e2, config) {
+    if (e2) {
+        return {
+            name: e1.name,
+            description: e1['description'] || e2['description'],
+            kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) || e1.kind === 'EnumTypeDefinition' || e2.kind === 'EnumTypeDefinition'
+                ? 'EnumTypeDefinition'
+                : 'EnumTypeExtension',
+            loc: e1.loc,
+            directives: (0, directives_js_1.mergeDirectives)(e1.directives, e2.directives, config),
+            values: (0, enum_values_js_1.mergeEnumValues)(e1.values, e2.values, config),
+        };
+    }
+    return (config === null || config === void 0 ? void 0 : config.convertExtensions)
+        ? {
+            ...e1,
+            kind: graphql_1.Kind.ENUM_TYPE_DEFINITION,
+        }
+        : e1;
+}
+exports.mergeEnum = mergeEnum;

package/cjs/typedefs-mergers/fields.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeFields = void 0;
+const utils_js_1 = require("./utils.js");
+const directives_js_1 = require("./directives.js");
+const utils_1 = require("@graphql-tools/utils");
+const arguments_js_1 = require("./arguments.js");
+function fieldAlreadyExists(fieldsArr, otherField, config) {
+    const result = fieldsArr.find(field => field.name.value === otherField.name.value);
+    if (result && !(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) {
+        const t1 = (0, utils_js_1.extractType)(result.type);
+        const t2 = (0, utils_js_1.extractType)(otherField.type);
+        if (t1.name.value !== t2.name.value) {
+            throw new Error(`Field "${otherField.name.value}" already defined with a different type. Declared as "${t1.name.value}", but you tried to override with "${t2.name.value}"`);
+        }
+    }
+    return !!result;
+}
+function mergeFields(type, f1, f2, config) {
+    const result = [];
+    if (f2 != null) {
+        result.push(...f2);
+    }
+    if (f1 != null) {
+        for (const field of f1) {
+            if (fieldAlreadyExists(result, field, config)) {
+                const existing = result.find((f) => f.name.value === field.name.value);
+                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 ((0, utils_js_1.isNonNullTypeNode)(field.type) && !(0, utils_js_1.isNonNullTypeNode)(existing.type)) {
+                        existing.type = field.type;
+                    }
+                }
+                existing.arguments = (0, arguments_js_1.mergeArguments)(field['arguments'] || [], existing.arguments || [], config);
+                existing.directives = (0, directives_js_1.mergeDirectives)(field.directives, existing.directives, config);
+                existing.description = field.description || existing.description;
+            }
+            else {
+                result.push(field);
+            }
+        }
+    }
+    if (config && config.sort) {
+        result.sort(utils_1.compareNodes);
+    }
+    if (config && config.exclusions) {
+        const exclusions = config.exclusions;
+        return result.filter(field => !exclusions.includes(`${type.name.value}.${field.name.value}`));
+    }
+    return result;
+}
+exports.mergeFields = mergeFields;
+function preventConflicts(type, a, b, ignoreNullability = false) {
+    const aType = (0, utils_js_1.printTypeNode)(a.type);
+    const bType = (0, utils_js_1.printTypeNode)(b.type);
+    if (aType !== bType && !safeChangeForFieldType(a.type, b.type, ignoreNullability)) {
+        throw new Error(`Field '${type.name.value}.${a.name.value}' changed type from '${aType}' to '${bType}'`);
+    }
+}
+function safeChangeForFieldType(oldType, newType, ignoreNullability = false) {
+    // both are named
+    if (!(0, utils_js_1.isWrappingTypeNode)(oldType) && !(0, utils_js_1.isWrappingTypeNode)(newType)) {
+        return oldType.toString() === newType.toString();
+    }
+    // new is non-null
+    if ((0, utils_js_1.isNonNullTypeNode)(newType)) {
+        const ofType = (0, utils_js_1.isNonNullTypeNode)(oldType) ? oldType.type : oldType;
+        return safeChangeForFieldType(ofType, newType.type);
+    }
+    // old is non-null
+    if ((0, utils_js_1.isNonNullTypeNode)(oldType)) {
+        return safeChangeForFieldType(newType, oldType, ignoreNullability);
+    }
+    // old is list
+    if ((0, utils_js_1.isListTypeNode)(oldType)) {
+        return (((0, utils_js_1.isListTypeNode)(newType) && safeChangeForFieldType(oldType.type, newType.type)) ||
+            ((0, utils_js_1.isNonNullTypeNode)(newType) && safeChangeForFieldType(oldType, newType['type'])));
+    }
+    return false;
+}

package/cjs/typedefs-mergers/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./arguments.js"), exports);
+tslib_1.__exportStar(require("./directives.js"), exports);
+tslib_1.__exportStar(require("./enum-values.js"), exports);
+tslib_1.__exportStar(require("./enum.js"), exports);
+tslib_1.__exportStar(require("./fields.js"), exports);
+tslib_1.__exportStar(require("./input-type.js"), exports);
+tslib_1.__exportStar(require("./interface.js"), exports);
+tslib_1.__exportStar(require("./merge-named-type-array.js"), exports);
+tslib_1.__exportStar(require("./merge-nodes.js"), exports);
+tslib_1.__exportStar(require("./merge-typedefs.js"), exports);
+tslib_1.__exportStar(require("./scalar.js"), exports);
+tslib_1.__exportStar(require("./type.js"), exports);
+tslib_1.__exportStar(require("./union.js"), exports);
+tslib_1.__exportStar(require("./utils.js"), exports);

package/cjs/typedefs-mergers/input-type.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeInputType = void 0;
+const graphql_1 = require("graphql");
+const fields_js_1 = require("./fields.js");
+const directives_js_1 = require("./directives.js");
+function mergeInputType(node, existingNode, config) {
+    if (existingNode) {
+        try {
+            return {
+                name: node.name,
+                description: node['description'] || existingNode['description'],
+                kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) ||
+                    node.kind === 'InputObjectTypeDefinition' ||
+                    existingNode.kind === 'InputObjectTypeDefinition'
+                    ? 'InputObjectTypeDefinition'
+                    : 'InputObjectTypeExtension',
+                loc: node.loc,
+                fields: (0, fields_js_1.mergeFields)(node, node.fields, existingNode.fields, config),
+                directives: (0, directives_js_1.mergeDirectives)(node.directives, existingNode.directives, config),
+            };
+        }
+        catch (e) {
+            throw new Error(`Unable to merge GraphQL input type "${node.name.value}": ${e.message}`);
+        }
+    }
+    return (config === null || config === void 0 ? void 0 : config.convertExtensions)
+        ? {
+            ...node,
+            kind: graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+        }
+        : node;
+}
+exports.mergeInputType = mergeInputType;

package/cjs/typedefs-mergers/interface.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeInterface = void 0;
+const graphql_1 = require("graphql");
+const fields_js_1 = require("./fields.js");
+const directives_js_1 = require("./directives.js");
+const index_js_1 = require("./index.js");
+function mergeInterface(node, existingNode, config) {
+    if (existingNode) {
+        try {
+            return {
+                name: node.name,
+                description: node['description'] || existingNode['description'],
+                kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) ||
+                    node.kind === 'InterfaceTypeDefinition' ||
+                    existingNode.kind === 'InterfaceTypeDefinition'
+                    ? 'InterfaceTypeDefinition'
+                    : 'InterfaceTypeExtension',
+                loc: node.loc,
+                fields: (0, fields_js_1.mergeFields)(node, node.fields, existingNode.fields, config),
+                directives: (0, directives_js_1.mergeDirectives)(node.directives, existingNode.directives, config),
+                interfaces: node['interfaces']
+                    ? (0, index_js_1.mergeNamedTypeArray)(node['interfaces'], existingNode['interfaces'], config)
+                    : undefined,
+            };
+        }
+        catch (e) {
+            throw new Error(`Unable to merge GraphQL interface "${node.name.value}": ${e.message}`);
+        }
+    }
+    return (config === null || config === void 0 ? void 0 : config.convertExtensions)
+        ? {
+            ...node,
+            kind: graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
+        }
+        : node;
+}
+exports.mergeInterface = mergeInterface;

package/cjs/typedefs-mergers/merge-named-type-array.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeNamedTypeArray = void 0;
+const utils_1 = require("@graphql-tools/utils");
+function alreadyExists(arr, other) {
+    return !!arr.find(i => i.name.value === other.name.value);
+}
+function mergeNamedTypeArray(first = [], second = [], config = {}) {
+    const result = [...second, ...first.filter(d => !alreadyExists(second, d))];
+    if (config && config.sort) {
+        result.sort(utils_1.compareNodes);
+    }
+    return result;
+}
+exports.mergeNamedTypeArray = mergeNamedTypeArray;

package/cjs/typedefs-mergers/merge-nodes.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeGraphQLNodes = exports.isNamedDefinitionNode = exports.schemaDefSymbol = void 0;
+const graphql_1 = require("graphql");
+const type_js_1 = require("./type.js");
+const enum_js_1 = require("./enum.js");
+const scalar_js_1 = require("./scalar.js");
+const union_js_1 = require("./union.js");
+const input_type_js_1 = require("./input-type.js");
+const interface_js_1 = require("./interface.js");
+const directives_js_1 = require("./directives.js");
+const schema_def_js_1 = require("./schema-def.js");
+const utils_1 = require("@graphql-tools/utils");
+exports.schemaDefSymbol = 'SCHEMA_DEF_SYMBOL';
+function isNamedDefinitionNode(definitionNode) {
+    return 'name' in definitionNode;
+}
+exports.isNamedDefinitionNode = isNamedDefinitionNode;
+function mergeGraphQLNodes(nodes, config) {
+    var _a, _b, _c;
+    const mergedResultMap = {};
+    for (const nodeDefinition of nodes) {
+        if (isNamedDefinitionNode(nodeDefinition)) {
+            const name = (_a = nodeDefinition.name) === null || _a === void 0 ? void 0 : _a.value;
+            if (config === null || config === void 0 ? void 0 : config.commentDescriptions) {
+                (0, utils_1.collectComment)(nodeDefinition);
+            }
+            if (name == null) {
+                continue;
+            }
+            if (((_b = config === null || config === void 0 ? void 0 : config.exclusions) === null || _b === void 0 ? void 0 : _b.includes(name + '.*')) || ((_c = config === null || config === void 0 ? void 0 : config.exclusions) === null || _c === void 0 ? void 0 : _c.includes(name))) {
+                delete mergedResultMap[name];
+            }
+            else {
+                switch (nodeDefinition.kind) {
+                    case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+                    case graphql_1.Kind.OBJECT_TYPE_EXTENSION:
+                        mergedResultMap[name] = (0, type_js_1.mergeType)(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                    case graphql_1.Kind.ENUM_TYPE_EXTENSION:
+                        mergedResultMap[name] = (0, enum_js_1.mergeEnum)(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case graphql_1.Kind.UNION_TYPE_DEFINITION:
+                    case graphql_1.Kind.UNION_TYPE_EXTENSION:
+                        mergedResultMap[name] = (0, union_js_1.mergeUnion)(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+                    case graphql_1.Kind.SCALAR_TYPE_EXTENSION:
+                        mergedResultMap[name] = (0, scalar_js_1.mergeScalar)(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                    case graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION:
+                        mergedResultMap[name] = (0, input_type_js_1.mergeInputType)(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+                    case graphql_1.Kind.INTERFACE_TYPE_EXTENSION:
+                        mergedResultMap[name] = (0, interface_js_1.mergeInterface)(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case graphql_1.Kind.DIRECTIVE_DEFINITION:
+                        mergedResultMap[name] = (0, directives_js_1.mergeDirective)(nodeDefinition, mergedResultMap[name]);
+                        break;
+                }
+            }
+        }
+        else if (nodeDefinition.kind === graphql_1.Kind.SCHEMA_DEFINITION || nodeDefinition.kind === graphql_1.Kind.SCHEMA_EXTENSION) {
+            mergedResultMap[exports.schemaDefSymbol] = (0, schema_def_js_1.mergeSchemaDefs)(nodeDefinition, mergedResultMap[exports.schemaDefSymbol], config);
+        }
+    }
+    return mergedResultMap;
+}
+exports.mergeGraphQLNodes = mergeGraphQLNodes;