@graphql-tools/merge 8.4.1 → 8.4.2-alpha-20230508170453-7db2a594

package/cjs/typedefs-mergers/directives.js

@@ -6,6 +6,10 @@ const utils_1 = require("@graphql-tools/utils");
 function directiveAlreadyExists(directivesArr, otherDirective) {
     return !!directivesArr.find(directive => directive.name.value === otherDirective.name.value);
 }
+function isRepeatableDirective(directive, directives) {
+    var _a;
+    return !!((_a = directives === null || directives === void 0 ? void 0 : directives[directive.name.value]) === null || _a === void 0 ? void 0 : _a.repeatable);
+}
 function nameAlreadyExists(name, namesArr) {
     return namesArr.some(({ value }) => value === name.value);
 }
@@ -34,11 +38,11 @@ function mergeArguments(a1, a2) {
     }
     return result;
 }
-function deduplicateDirectives(directives) {
+function deduplicateDirectives(directives, definitions) {
     return directives
         .map((directive, i, all) => {
         const firstAt = all.findIndex(d => d.name.value === directive.name.value);
-        if (firstAt !== i) {
+        if (firstAt !== i && !isRepeatableDirective(directive, definitions)) {
             const dup = all[firstAt];
             directive.arguments = mergeArguments(directive.arguments, dup.arguments);
             return null;
@@ -47,13 +51,13 @@ function deduplicateDirectives(directives) {
     })
         .filter(utils_1.isSome);
 }
-function mergeDirectives(d1 = [], d2 = [], config) {
+function mergeDirectives(d1 = [], d2 = [], config, directives) {
     const reverseOrder = config && config.reverseDirectives;
     const asNext = reverseOrder ? d1 : d2;
     const asFirst = reverseOrder ? d2 : d1;
-    const result = deduplicateDirectives([...asNext]);
+    const result = deduplicateDirectives([...asNext], directives);
     for (const directive of asFirst) {
-        if (directiveAlreadyExists(result, directive)) {
+        if (directiveAlreadyExists(result, directive) && !isRepeatableDirective(directive, directives)) {
             const existingDirectiveIndex = result.findIndex(d => d.name.value === directive.name.value);
             const existingDirective = result[existingDirectiveIndex];
             result[existingDirectiveIndex].arguments = mergeArguments(directive.arguments || [], existingDirective.arguments || []);

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

@@ -3,7 +3,7 @@ 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) {
+function mergeEnumValues(first, second, config, directives) {
     if (config === null || config === void 0 ? void 0 : config.consistentEnumMerge) {
         const reversed = [];
         if (first) {
@@ -24,7 +24,7 @@ function mergeEnumValues(first, second, config) {
             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);
+                firstValue.directives = (0, directives_js_1.mergeDirectives)(secondValue.directives, firstValue.directives, directives);
             }
             else {
                 enumValueMap.set(enumValue, secondValue);

package/cjs/typedefs-mergers/enum.js

@@ -4,7 +4,7 @@ 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) {
+function mergeEnum(e1, e2, config, directives) {
     if (e2) {
         return {
             name: e1.name,
@@ -13,7 +13,7 @@ function mergeEnum(e1, e2, config) {
                 ? 'EnumTypeDefinition'
                 : 'EnumTypeExtension',
             loc: e1.loc,
-            directives: (0, directives_js_1.mergeDirectives)(e1.directives, e2.directives, config),
+            directives: (0, directives_js_1.mergeDirectives)(e1.directives, e2.directives, config, directives),
             values: (0, enum_values_js_1.mergeEnumValues)(e1.values, e2.values, config),
         };
     }

package/cjs/typedefs-mergers/fields.js

@@ -9,7 +9,7 @@ function fieldAlreadyExists(fieldsArr, otherField) {
     const resultIndex = fieldsArr.findIndex(field => field.name.value === otherField.name.value);
     return [resultIndex > -1 ? fieldsArr[resultIndex] : null, resultIndex];
 }
-function mergeFields(type, f1, f2, config) {
+function mergeFields(type, f1, f2, config, directives) {
     const result = [];
     if (f2 != null) {
         result.push(...f2);
@@ -21,7 +21,7 @@ function mergeFields(type, f1, f2, config) {
                 const newField = ((config === null || config === void 0 ? void 0 : config.onFieldTypeConflict) && config.onFieldTypeConflict(existing, field, type, config === null || config === void 0 ? void 0 : config.throwOnConflict)) ||
                     preventConflicts(type, existing, field, config === null || config === void 0 ? void 0 : config.throwOnConflict);
                 newField.arguments = (0, arguments_js_1.mergeArguments)(field['arguments'] || [], existing['arguments'] || [], config);
-                newField.directives = (0, directives_js_1.mergeDirectives)(field.directives, existing.directives, config);
+                newField.directives = (0, directives_js_1.mergeDirectives)(field.directives, existing.directives, config, directives);
                 newField.description = field.description || existing.description;
                 result[existingIndex] = newField;
             }

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

@@ -4,7 +4,7 @@ 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) {
+function mergeInputType(node, existingNode, config, directives) {
     if (existingNode) {
         try {
             return {
@@ -17,7 +17,7 @@ function mergeInputType(node, existingNode, config) {
                     : '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),
+                directives: (0, directives_js_1.mergeDirectives)(node.directives, existingNode.directives, config, directives),
             };
         }
         catch (e) {

package/cjs/typedefs-mergers/interface.js

@@ -5,7 +5,7 @@ const graphql_1 = require("graphql");
 const fields_js_1 = require("./fields.js");
 const directives_js_1 = require("./directives.js");
 const merge_named_type_array_js_1 = require("./merge-named-type-array.js");
-function mergeInterface(node, existingNode, config) {
+function mergeInterface(node, existingNode, config, directives) {
     if (existingNode) {
         try {
             return {
@@ -18,7 +18,7 @@ function mergeInterface(node, existingNode, config) {
                     : '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),
+                directives: (0, directives_js_1.mergeDirectives)(node.directives, existingNode.directives, config, directives),
                 interfaces: node['interfaces']
                     ? (0, merge_named_type_array_js_1.mergeNamedTypeArray)(node['interfaces'], existingNode['interfaces'], config)
                     : undefined,

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

@@ -16,9 +16,9 @@ function isNamedDefinitionNode(definitionNode) {
     return 'name' in definitionNode;
 }
 exports.isNamedDefinitionNode = isNamedDefinitionNode;
-function mergeGraphQLNodes(nodes, config) {
+function mergeGraphQLNodes(nodes, config, directives = {}) {
     var _a, _b, _c;
-    const mergedResultMap = {};
+    const mergedResultMap = directives;
     for (const nodeDefinition of nodes) {
         if (isNamedDefinitionNode(nodeDefinition)) {
             const name = (_a = nodeDefinition.name) === null || _a === void 0 ? void 0 : _a.value;
@@ -35,27 +35,27 @@ function mergeGraphQLNodes(nodes, config) {
                 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);
+                        mergedResultMap[name] = (0, type_js_1.mergeType)(nodeDefinition, mergedResultMap[name], config, directives);
                         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);
+                        mergedResultMap[name] = (0, enum_js_1.mergeEnum)(nodeDefinition, mergedResultMap[name], config, directives);
                         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);
+                        mergedResultMap[name] = (0, union_js_1.mergeUnion)(nodeDefinition, mergedResultMap[name], config, directives);
                         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);
+                        mergedResultMap[name] = (0, scalar_js_1.mergeScalar)(nodeDefinition, mergedResultMap[name], config, directives);
                         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);
+                        mergedResultMap[name] = (0, input_type_js_1.mergeInputType)(nodeDefinition, mergedResultMap[name], config, directives);
                         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);
+                        mergedResultMap[name] = (0, interface_js_1.mergeInterface)(nodeDefinition, mergedResultMap[name], config, directives);
                         break;
                     case graphql_1.Kind.DIRECTIVE_DEFINITION:
                         mergedResultMap[name] = (0, directives_js_1.mergeDirective)(nodeDefinition, mergedResultMap[name]);

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

@@ -29,42 +29,48 @@ function mergeTypeDefs(typeSource, config) {
     return result;
 }
 exports.mergeTypeDefs = mergeTypeDefs;
-function visitTypeSources(typeSource, options, allNodes = [], visitedTypeSources = new Set()) {
+function visitTypeSources(typeSource, options, allDirectives = [], allNodes = [], visitedTypeSources = new Set()) {
     if (typeSource && !visitedTypeSources.has(typeSource)) {
         visitedTypeSources.add(typeSource);
         if (typeof typeSource === 'function') {
-            visitTypeSources(typeSource(), options, allNodes, visitedTypeSources);
+            visitTypeSources(typeSource(), options, allDirectives, allNodes, visitedTypeSources);
         }
         else if (Array.isArray(typeSource)) {
             for (const type of typeSource) {
-                visitTypeSources(type, options, allNodes, visitedTypeSources);
+                visitTypeSources(type, options, allDirectives, allNodes, visitedTypeSources);
             }
         }
         else if ((0, graphql_1.isSchema)(typeSource)) {
             const documentNode = (0, utils_1.getDocumentNodeFromSchema)(typeSource, options);
-            visitTypeSources(documentNode.definitions, options, allNodes, visitedTypeSources);
+            visitTypeSources(documentNode.definitions, options, allDirectives, allNodes, visitedTypeSources);
         }
         else if ((0, utils_js_1.isStringTypes)(typeSource) || (0, utils_js_1.isSourceTypes)(typeSource)) {
             const documentNode = (0, graphql_1.parse)(typeSource, options);
-            visitTypeSources(documentNode.definitions, options, allNodes, visitedTypeSources);
+            visitTypeSources(documentNode.definitions, options, allDirectives, allNodes, visitedTypeSources);
         }
         else if (typeof typeSource === 'object' && (0, graphql_1.isDefinitionNode)(typeSource)) {
-            allNodes.push(typeSource);
+            if (typeSource.kind === graphql_1.Kind.DIRECTIVE_DEFINITION) {
+                allDirectives.push(typeSource);
+            }
+            else {
+                allNodes.push(typeSource);
+            }
         }
         else if ((0, utils_1.isDocumentNode)(typeSource)) {
-            visitTypeSources(typeSource.definitions, options, allNodes, visitedTypeSources);
+            visitTypeSources(typeSource.definitions, options, allDirectives, allNodes, visitedTypeSources);
         }
         else {
             throw new Error(`typeDefs must contain only strings, documents, schemas, or functions, got ${typeof typeSource}`);
         }
     }
-    return allNodes;
+    return { allDirectives, allNodes };
 }
 function mergeGraphQLTypes(typeSource, config) {
     var _a, _b, _c;
     (0, utils_1.resetComments)();
-    const allNodes = visitTypeSources(typeSource, config);
-    const mergedNodes = (0, merge_nodes_js_1.mergeGraphQLNodes)(allNodes, config);
+    const { allDirectives, allNodes } = visitTypeSources(typeSource, config);
+    const mergedDirectives = (0, merge_nodes_js_1.mergeGraphQLNodes)(allDirectives, config);
+    const mergedNodes = (0, merge_nodes_js_1.mergeGraphQLNodes)(allNodes, config, mergedDirectives);
     if (config === null || config === void 0 ? void 0 : config.useSchemaDefinition) {
         // XXX: right now we don't handle multiple schema definitions
         const schemaDef = mergedNodes[merge_nodes_js_1.schemaDefSymbol] || {

package/cjs/typedefs-mergers/scalar.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeScalar = void 0;
 const graphql_1 = require("graphql");
 const directives_js_1 = require("./directives.js");
-function mergeScalar(node, existingNode, config) {
+function mergeScalar(node, existingNode, config, directives) {
     if (existingNode) {
         return {
             name: node.name,
@@ -14,7 +14,7 @@ function mergeScalar(node, existingNode, config) {
                 ? 'ScalarTypeDefinition'
                 : 'ScalarTypeExtension',
             loc: node.loc,
-            directives: (0, directives_js_1.mergeDirectives)(node.directives, existingNode.directives, config),
+            directives: (0, directives_js_1.mergeDirectives)(node.directives, existingNode.directives, config, directives),
         };
     }
     return (config === null || config === void 0 ? void 0 : config.convertExtensions)

package/cjs/typedefs-mergers/schema-def.js

@@ -18,14 +18,14 @@ function mergeOperationTypes(opNodeList = [], existingOpNodeList = []) {
     }
     return finalOpNodeList;
 }
-function mergeSchemaDefs(node, existingNode, config) {
+function mergeSchemaDefs(node, existingNode, config, directives) {
     if (existingNode) {
         return {
             kind: node.kind === graphql_1.Kind.SCHEMA_DEFINITION || existingNode.kind === graphql_1.Kind.SCHEMA_DEFINITION
                 ? graphql_1.Kind.SCHEMA_DEFINITION
                 : graphql_1.Kind.SCHEMA_EXTENSION,
             description: node['description'] || existingNode['description'],
-            directives: (0, directives_js_1.mergeDirectives)(node.directives, existingNode.directives, config),
+            directives: (0, directives_js_1.mergeDirectives)(node.directives, existingNode.directives, config, directives),
             operationTypes: mergeOperationTypes(node.operationTypes, existingNode.operationTypes),
         };
     }

package/cjs/typedefs-mergers/type.js

@@ -5,7 +5,7 @@ const graphql_1 = require("graphql");
 const fields_js_1 = require("./fields.js");
 const directives_js_1 = require("./directives.js");
 const merge_named_type_array_js_1 = require("./merge-named-type-array.js");
-function mergeType(node, existingNode, config) {
+function mergeType(node, existingNode, config, directives) {
     if (existingNode) {
         try {
             return {
@@ -18,7 +18,7 @@ function mergeType(node, existingNode, config) {
                     : 'ObjectTypeExtension',
                 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),
+                directives: (0, directives_js_1.mergeDirectives)(node.directives, existingNode.directives, config, directives),
                 interfaces: (0, merge_named_type_array_js_1.mergeNamedTypeArray)(node.interfaces, existingNode.interfaces, config),
             };
         }

package/cjs/typedefs-mergers/union.js

@@ -4,13 +4,13 @@ exports.mergeUnion = void 0;
 const graphql_1 = require("graphql");
 const directives_js_1 = require("./directives.js");
 const merge_named_type_array_js_1 = require("./merge-named-type-array.js");
-function mergeUnion(first, second, config) {
+function mergeUnion(first, second, config, directives) {
     if (second) {
         return {
             name: first.name,
             description: first['description'] || second['description'],
             // ConstXNode has been introduced in v16 but it is not compatible with XNode so we do `as any` for backwards compatibility
-            directives: (0, directives_js_1.mergeDirectives)(first.directives, second.directives, config),
+            directives: (0, directives_js_1.mergeDirectives)(first.directives, second.directives, config, directives),
             kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) || first.kind === 'UnionTypeDefinition' || second.kind === 'UnionTypeDefinition'
                 ? graphql_1.Kind.UNION_TYPE_DEFINITION
                 : graphql_1.Kind.UNION_TYPE_EXTENSION,

package/esm/typedefs-mergers/directives.js

@@ -3,6 +3,10 @@ import { isSome } from '@graphql-tools/utils';
 function directiveAlreadyExists(directivesArr, otherDirective) {
     return !!directivesArr.find(directive => directive.name.value === otherDirective.name.value);
 }
+function isRepeatableDirective(directive, directives) {
+    var _a;
+    return !!((_a = directives === null || directives === void 0 ? void 0 : directives[directive.name.value]) === null || _a === void 0 ? void 0 : _a.repeatable);
+}
 function nameAlreadyExists(name, namesArr) {
     return namesArr.some(({ value }) => value === name.value);
 }
@@ -31,11 +35,11 @@ function mergeArguments(a1, a2) {
     }
     return result;
 }
-function deduplicateDirectives(directives) {
+function deduplicateDirectives(directives, definitions) {
     return directives
         .map((directive, i, all) => {
         const firstAt = all.findIndex(d => d.name.value === directive.name.value);
-        if (firstAt !== i) {
+        if (firstAt !== i && !isRepeatableDirective(directive, definitions)) {
             const dup = all[firstAt];
             directive.arguments = mergeArguments(directive.arguments, dup.arguments);
             return null;
@@ -44,13 +48,13 @@ function deduplicateDirectives(directives) {
     })
         .filter(isSome);
 }
-export function mergeDirectives(d1 = [], d2 = [], config) {
+export function mergeDirectives(d1 = [], d2 = [], config, directives) {
     const reverseOrder = config && config.reverseDirectives;
     const asNext = reverseOrder ? d1 : d2;
     const asFirst = reverseOrder ? d2 : d1;
-    const result = deduplicateDirectives([...asNext]);
+    const result = deduplicateDirectives([...asNext], directives);
     for (const directive of asFirst) {
-        if (directiveAlreadyExists(result, directive)) {
+        if (directiveAlreadyExists(result, directive) && !isRepeatableDirective(directive, directives)) {
             const existingDirectiveIndex = result.findIndex(d => d.name.value === directive.name.value);
             const existingDirective = result[existingDirectiveIndex];
             result[existingDirectiveIndex].arguments = mergeArguments(directive.arguments || [], existingDirective.arguments || []);

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

@@ -1,6 +1,6 @@
 import { mergeDirectives } from './directives.js';
 import { compareNodes } from '@graphql-tools/utils';
-export function mergeEnumValues(first, second, config) {
+export function mergeEnumValues(first, second, config, directives) {
     if (config === null || config === void 0 ? void 0 : config.consistentEnumMerge) {
         const reversed = [];
         if (first) {
@@ -21,7 +21,7 @@ export function mergeEnumValues(first, second, config) {
             if (enumValueMap.has(enumValue)) {
                 const firstValue = enumValueMap.get(enumValue);
                 firstValue.description = secondValue.description || firstValue.description;
-                firstValue.directives = mergeDirectives(secondValue.directives, firstValue.directives);
+                firstValue.directives = mergeDirectives(secondValue.directives, firstValue.directives, directives);
             }
             else {
                 enumValueMap.set(enumValue, secondValue);

package/esm/typedefs-mergers/enum.js

@@ -1,7 +1,7 @@
 import { Kind } from 'graphql';
 import { mergeDirectives } from './directives.js';
 import { mergeEnumValues } from './enum-values.js';
-export function mergeEnum(e1, e2, config) {
+export function mergeEnum(e1, e2, config, directives) {
     if (e2) {
         return {
             name: e1.name,
@@ -10,7 +10,7 @@ export function mergeEnum(e1, e2, config) {
                 ? 'EnumTypeDefinition'
                 : 'EnumTypeExtension',
             loc: e1.loc,
-            directives: mergeDirectives(e1.directives, e2.directives, config),
+            directives: mergeDirectives(e1.directives, e2.directives, config, directives),
             values: mergeEnumValues(e1.values, e2.values, config),
         };
     }

package/esm/typedefs-mergers/fields.js

@@ -6,7 +6,7 @@ function fieldAlreadyExists(fieldsArr, otherField) {
     const resultIndex = fieldsArr.findIndex(field => field.name.value === otherField.name.value);
     return [resultIndex > -1 ? fieldsArr[resultIndex] : null, resultIndex];
 }
-export function mergeFields(type, f1, f2, config) {
+export function mergeFields(type, f1, f2, config, directives) {
     const result = [];
     if (f2 != null) {
         result.push(...f2);
@@ -18,7 +18,7 @@ export function mergeFields(type, f1, f2, config) {
                 const newField = ((config === null || config === void 0 ? void 0 : config.onFieldTypeConflict) && config.onFieldTypeConflict(existing, field, type, config === null || config === void 0 ? void 0 : config.throwOnConflict)) ||
                     preventConflicts(type, existing, field, config === null || config === void 0 ? void 0 : config.throwOnConflict);
                 newField.arguments = mergeArguments(field['arguments'] || [], existing['arguments'] || [], config);
-                newField.directives = mergeDirectives(field.directives, existing.directives, config);
+                newField.directives = mergeDirectives(field.directives, existing.directives, config, directives);
                 newField.description = field.description || existing.description;
                 result[existingIndex] = newField;
             }

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

@@ -1,7 +1,7 @@
-import { Kind } from 'graphql';
+import { Kind, } from 'graphql';
 import { mergeFields } from './fields.js';
 import { mergeDirectives } from './directives.js';
-export function mergeInputType(node, existingNode, config) {
+export function mergeInputType(node, existingNode, config, directives) {
     if (existingNode) {
         try {
             return {
@@ -14,7 +14,7 @@ export function mergeInputType(node, existingNode, config) {
                     : 'InputObjectTypeExtension',
                 loc: node.loc,
                 fields: mergeFields(node, node.fields, existingNode.fields, config),
-                directives: mergeDirectives(node.directives, existingNode.directives, config),
+                directives: mergeDirectives(node.directives, existingNode.directives, config, directives),
             };
         }
         catch (e) {

package/esm/typedefs-mergers/interface.js

@@ -2,7 +2,7 @@ import { Kind } from 'graphql';
 import { mergeFields } from './fields.js';
 import { mergeDirectives } from './directives.js';
 import { mergeNamedTypeArray } from './merge-named-type-array.js';
-export function mergeInterface(node, existingNode, config) {
+export function mergeInterface(node, existingNode, config, directives) {
     if (existingNode) {
         try {
             return {
@@ -15,7 +15,7 @@ export function mergeInterface(node, existingNode, config) {
                     : 'InterfaceTypeExtension',
                 loc: node.loc,
                 fields: mergeFields(node, node.fields, existingNode.fields, config),
-                directives: mergeDirectives(node.directives, existingNode.directives, config),
+                directives: mergeDirectives(node.directives, existingNode.directives, config, directives),
                 interfaces: node['interfaces']
                     ? mergeNamedTypeArray(node['interfaces'], existingNode['interfaces'], config)
                     : undefined,

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

@@ -12,9 +12,9 @@ export const schemaDefSymbol = 'SCHEMA_DEF_SYMBOL';
 export function isNamedDefinitionNode(definitionNode) {
     return 'name' in definitionNode;
 }
-export function mergeGraphQLNodes(nodes, config) {
+export function mergeGraphQLNodes(nodes, config, directives = {}) {
     var _a, _b, _c;
-    const mergedResultMap = {};
+    const mergedResultMap = directives;
     for (const nodeDefinition of nodes) {
         if (isNamedDefinitionNode(nodeDefinition)) {
             const name = (_a = nodeDefinition.name) === null || _a === void 0 ? void 0 : _a.value;
@@ -31,27 +31,27 @@ export function mergeGraphQLNodes(nodes, config) {
                 switch (nodeDefinition.kind) {
                     case Kind.OBJECT_TYPE_DEFINITION:
                     case Kind.OBJECT_TYPE_EXTENSION:
-                        mergedResultMap[name] = mergeType(nodeDefinition, mergedResultMap[name], config);
+                        mergedResultMap[name] = mergeType(nodeDefinition, mergedResultMap[name], config, directives);
                         break;
                     case Kind.ENUM_TYPE_DEFINITION:
                     case Kind.ENUM_TYPE_EXTENSION:
-                        mergedResultMap[name] = mergeEnum(nodeDefinition, mergedResultMap[name], config);
+                        mergedResultMap[name] = mergeEnum(nodeDefinition, mergedResultMap[name], config, directives);
                         break;
                     case Kind.UNION_TYPE_DEFINITION:
                     case Kind.UNION_TYPE_EXTENSION:
-                        mergedResultMap[name] = mergeUnion(nodeDefinition, mergedResultMap[name], config);
+                        mergedResultMap[name] = mergeUnion(nodeDefinition, mergedResultMap[name], config, directives);
                         break;
                     case Kind.SCALAR_TYPE_DEFINITION:
                     case Kind.SCALAR_TYPE_EXTENSION:
-                        mergedResultMap[name] = mergeScalar(nodeDefinition, mergedResultMap[name], config);
+                        mergedResultMap[name] = mergeScalar(nodeDefinition, mergedResultMap[name], config, directives);
                         break;
                     case Kind.INPUT_OBJECT_TYPE_DEFINITION:
                     case Kind.INPUT_OBJECT_TYPE_EXTENSION:
-                        mergedResultMap[name] = mergeInputType(nodeDefinition, mergedResultMap[name], config);
+                        mergedResultMap[name] = mergeInputType(nodeDefinition, mergedResultMap[name], config, directives);
                         break;
                     case Kind.INTERFACE_TYPE_DEFINITION:
                     case Kind.INTERFACE_TYPE_EXTENSION:
-                        mergedResultMap[name] = mergeInterface(nodeDefinition, mergedResultMap[name], config);
+                        mergedResultMap[name] = mergeInterface(nodeDefinition, mergedResultMap[name], config, directives);
                         break;
                     case Kind.DIRECTIVE_DEFINITION:
                         mergedResultMap[name] = mergeDirective(nodeDefinition, mergedResultMap[name]);

package/esm/typedefs-mergers/merge-typedefs.js

@@ -25,42 +25,48 @@ export function mergeTypeDefs(typeSource, config) {
     resetComments();
     return result;
 }
-function visitTypeSources(typeSource, options, allNodes = [], visitedTypeSources = new Set()) {
+function visitTypeSources(typeSource, options, allDirectives = [], allNodes = [], visitedTypeSources = new Set()) {
     if (typeSource && !visitedTypeSources.has(typeSource)) {
         visitedTypeSources.add(typeSource);
         if (typeof typeSource === 'function') {
-            visitTypeSources(typeSource(), options, allNodes, visitedTypeSources);
+            visitTypeSources(typeSource(), options, allDirectives, allNodes, visitedTypeSources);
         }
         else if (Array.isArray(typeSource)) {
             for (const type of typeSource) {
-                visitTypeSources(type, options, allNodes, visitedTypeSources);
+                visitTypeSources(type, options, allDirectives, allNodes, visitedTypeSources);
             }
         }
         else if (isSchema(typeSource)) {
             const documentNode = getDocumentNodeFromSchema(typeSource, options);
-            visitTypeSources(documentNode.definitions, options, allNodes, visitedTypeSources);
+            visitTypeSources(documentNode.definitions, options, allDirectives, allNodes, visitedTypeSources);
         }
         else if (isStringTypes(typeSource) || isSourceTypes(typeSource)) {
             const documentNode = parse(typeSource, options);
-            visitTypeSources(documentNode.definitions, options, allNodes, visitedTypeSources);
+            visitTypeSources(documentNode.definitions, options, allDirectives, allNodes, visitedTypeSources);
         }
         else if (typeof typeSource === 'object' && isDefinitionNode(typeSource)) {
-            allNodes.push(typeSource);
+            if (typeSource.kind === Kind.DIRECTIVE_DEFINITION) {
+                allDirectives.push(typeSource);
+            }
+            else {
+                allNodes.push(typeSource);
+            }
         }
         else if (isDocumentNode(typeSource)) {
-            visitTypeSources(typeSource.definitions, options, allNodes, visitedTypeSources);
+            visitTypeSources(typeSource.definitions, options, allDirectives, allNodes, visitedTypeSources);
         }
         else {
             throw new Error(`typeDefs must contain only strings, documents, schemas, or functions, got ${typeof typeSource}`);
         }
     }
-    return allNodes;
+    return { allDirectives, allNodes };
 }
 export function mergeGraphQLTypes(typeSource, config) {
     var _a, _b, _c;
     resetComments();
-    const allNodes = visitTypeSources(typeSource, config);
-    const mergedNodes = mergeGraphQLNodes(allNodes, config);
+    const { allDirectives, allNodes } = visitTypeSources(typeSource, config);
+    const mergedDirectives = mergeGraphQLNodes(allDirectives, config);
+    const mergedNodes = mergeGraphQLNodes(allNodes, config, mergedDirectives);
     if (config === null || config === void 0 ? void 0 : config.useSchemaDefinition) {
         // XXX: right now we don't handle multiple schema definitions
         const schemaDef = mergedNodes[schemaDefSymbol] || {

package/esm/typedefs-mergers/scalar.js

@@ -1,6 +1,6 @@
 import { Kind } from 'graphql';
 import { mergeDirectives } from './directives.js';
-export function mergeScalar(node, existingNode, config) {
+export function mergeScalar(node, existingNode, config, directives) {
     if (existingNode) {
         return {
             name: node.name,
@@ -11,7 +11,7 @@ export function mergeScalar(node, existingNode, config) {
                 ? 'ScalarTypeDefinition'
                 : 'ScalarTypeExtension',
             loc: node.loc,
-            directives: mergeDirectives(node.directives, existingNode.directives, config),
+            directives: mergeDirectives(node.directives, existingNode.directives, config, directives),
         };
     }
     return (config === null || config === void 0 ? void 0 : config.convertExtensions)

package/esm/typedefs-mergers/schema-def.js

@@ -1,4 +1,4 @@
-import { Kind } from 'graphql';
+import { Kind, } from 'graphql';
 import { mergeDirectives } from './directives.js';
 export const DEFAULT_OPERATION_TYPE_NAME_MAP = {
     query: 'Query',
@@ -15,14 +15,14 @@ function mergeOperationTypes(opNodeList = [], existingOpNodeList = []) {
     }
     return finalOpNodeList;
 }
-export function mergeSchemaDefs(node, existingNode, config) {
+export function mergeSchemaDefs(node, existingNode, config, directives) {
     if (existingNode) {
         return {
             kind: 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),
+            directives: mergeDirectives(node.directives, existingNode.directives, config, directives),
             operationTypes: mergeOperationTypes(node.operationTypes, existingNode.operationTypes),
         };
     }

package/esm/typedefs-mergers/type.js

@@ -2,7 +2,7 @@ import { Kind } from 'graphql';
 import { mergeFields } from './fields.js';
 import { mergeDirectives } from './directives.js';
 import { mergeNamedTypeArray } from './merge-named-type-array.js';
-export function mergeType(node, existingNode, config) {
+export function mergeType(node, existingNode, config, directives) {
     if (existingNode) {
         try {
             return {
@@ -15,7 +15,7 @@ export function mergeType(node, existingNode, config) {
                     : 'ObjectTypeExtension',
                 loc: node.loc,
                 fields: mergeFields(node, node.fields, existingNode.fields, config),
-                directives: mergeDirectives(node.directives, existingNode.directives, config),
+                directives: mergeDirectives(node.directives, existingNode.directives, config, directives),
                 interfaces: mergeNamedTypeArray(node.interfaces, existingNode.interfaces, config),
             };
         }

package/esm/typedefs-mergers/union.js

@@ -1,13 +1,13 @@
 import { Kind } from 'graphql';
 import { mergeDirectives } from './directives.js';
 import { mergeNamedTypeArray } from './merge-named-type-array.js';
-export function mergeUnion(first, second, config) {
+export function mergeUnion(first, second, config, directives) {
     if (second) {
         return {
             name: first.name,
             description: first['description'] || second['description'],
             // ConstXNode has been introduced in v16 but it is not compatible with XNode so we do `as any` for backwards compatibility
-            directives: mergeDirectives(first.directives, second.directives, config),
+            directives: mergeDirectives(first.directives, second.directives, config, directives),
             kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) || first.kind === 'UnionTypeDefinition' || second.kind === 'UnionTypeDefinition'
                 ? Kind.UNION_TYPE_DEFINITION
                 : Kind.UNION_TYPE_EXTENSION,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/merge",
-  "version": "8.4.1",
+  "version": "8.4.2-alpha-20230508170453-7db2a594",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {

package/typings/typedefs-mergers/directives.d.cts

@@ -1,4 +1,4 @@
 import { DirectiveNode, DirectiveDefinitionNode } from 'graphql';
 import { Config } from './merge-typedefs.cjs';
-export declare function mergeDirectives(d1?: ReadonlyArray<DirectiveNode>, d2?: ReadonlyArray<DirectiveNode>, config?: Config): DirectiveNode[];
+export declare function mergeDirectives(d1?: ReadonlyArray<DirectiveNode>, d2?: ReadonlyArray<DirectiveNode>, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): DirectiveNode[];
 export declare function mergeDirective(node: DirectiveDefinitionNode, existingNode?: DirectiveDefinitionNode): DirectiveDefinitionNode;

package/typings/typedefs-mergers/directives.d.ts

@@ -1,4 +1,4 @@
 import { DirectiveNode, DirectiveDefinitionNode } from 'graphql';
 import { Config } from './merge-typedefs.js';
-export declare function mergeDirectives(d1?: ReadonlyArray<DirectiveNode>, d2?: ReadonlyArray<DirectiveNode>, config?: Config): DirectiveNode[];
+export declare function mergeDirectives(d1?: ReadonlyArray<DirectiveNode>, d2?: ReadonlyArray<DirectiveNode>, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): DirectiveNode[];
 export declare function mergeDirective(node: DirectiveDefinitionNode, existingNode?: DirectiveDefinitionNode): DirectiveDefinitionNode;

package/typings/typedefs-mergers/enum-values.d.cts

@@ -1,3 +1,3 @@
-import { EnumValueDefinitionNode } from 'graphql';
+import { DirectiveDefinitionNode, EnumValueDefinitionNode } from 'graphql';
 import { Config } from './merge-typedefs.cjs';
-export declare function mergeEnumValues(first: ReadonlyArray<EnumValueDefinitionNode> | undefined, second: ReadonlyArray<EnumValueDefinitionNode> | undefined, config?: Config): EnumValueDefinitionNode[];
+export declare function mergeEnumValues(first: ReadonlyArray<EnumValueDefinitionNode> | undefined, second: ReadonlyArray<EnumValueDefinitionNode> | undefined, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): EnumValueDefinitionNode[];

package/typings/typedefs-mergers/enum-values.d.ts

@@ -1,3 +1,3 @@
-import { EnumValueDefinitionNode } from 'graphql';
+import { DirectiveDefinitionNode, EnumValueDefinitionNode } from 'graphql';
 import { Config } from './merge-typedefs.js';
-export declare function mergeEnumValues(first: ReadonlyArray<EnumValueDefinitionNode> | undefined, second: ReadonlyArray<EnumValueDefinitionNode> | undefined, config?: Config): EnumValueDefinitionNode[];
+export declare function mergeEnumValues(first: ReadonlyArray<EnumValueDefinitionNode> | undefined, second: ReadonlyArray<EnumValueDefinitionNode> | undefined, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): EnumValueDefinitionNode[];

package/typings/typedefs-mergers/enum.d.cts

@@ -1,3 +1,3 @@
-import { EnumTypeDefinitionNode, EnumTypeExtensionNode } from 'graphql';
+import { DirectiveDefinitionNode, EnumTypeDefinitionNode, EnumTypeExtensionNode } from 'graphql';
 import { Config } from './merge-typedefs.cjs';
-export declare function mergeEnum(e1: EnumTypeDefinitionNode | EnumTypeExtensionNode, e2: EnumTypeDefinitionNode | EnumTypeExtensionNode, config?: Config): EnumTypeDefinitionNode | EnumTypeExtensionNode;
+export declare function mergeEnum(e1: EnumTypeDefinitionNode | EnumTypeExtensionNode, e2: EnumTypeDefinitionNode | EnumTypeExtensionNode, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): EnumTypeDefinitionNode | EnumTypeExtensionNode;

package/typings/typedefs-mergers/enum.d.ts

@@ -1,3 +1,3 @@
-import { EnumTypeDefinitionNode, EnumTypeExtensionNode } from 'graphql';
+import { DirectiveDefinitionNode, EnumTypeDefinitionNode, EnumTypeExtensionNode } from 'graphql';
 import { Config } from './merge-typedefs.js';
-export declare function mergeEnum(e1: EnumTypeDefinitionNode | EnumTypeExtensionNode, e2: EnumTypeDefinitionNode | EnumTypeExtensionNode, config?: Config): EnumTypeDefinitionNode | EnumTypeExtensionNode;
+export declare function mergeEnum(e1: EnumTypeDefinitionNode | EnumTypeExtensionNode, e2: EnumTypeDefinitionNode | EnumTypeExtensionNode, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): EnumTypeDefinitionNode | EnumTypeExtensionNode;

package/typings/typedefs-mergers/fields.d.cts

@@ -1,5 +1,5 @@
 import { Config } from './merge-typedefs.cjs';
-import { FieldDefinitionNode, InputValueDefinitionNode, NameNode } from 'graphql';
+import { FieldDefinitionNode, InputValueDefinitionNode, NameNode, DirectiveDefinitionNode } from 'graphql';
 type FieldDefNode = FieldDefinitionNode | InputValueDefinitionNode;
 type NamedDefNode = {
     name: NameNode;
@@ -7,5 +7,5 @@ type NamedDefNode = {
 export type OnFieldTypeConflict = (existingField: FieldDefNode, otherField: FieldDefNode, type: NamedDefNode, ignoreNullability: boolean | undefined) => FieldDefNode;
 export declare function mergeFields<T extends FieldDefNode>(type: {
     name: NameNode;
-}, f1: ReadonlyArray<T> | undefined, f2: ReadonlyArray<T> | undefined, config?: Config): T[];
+}, f1: ReadonlyArray<T> | undefined, f2: ReadonlyArray<T> | undefined, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): T[];
 export {};

package/typings/typedefs-mergers/fields.d.ts

@@ -1,5 +1,5 @@
 import { Config } from './merge-typedefs.js';
-import { FieldDefinitionNode, InputValueDefinitionNode, NameNode } from 'graphql';
+import { FieldDefinitionNode, InputValueDefinitionNode, NameNode, DirectiveDefinitionNode } from 'graphql';
 type FieldDefNode = FieldDefinitionNode | InputValueDefinitionNode;
 type NamedDefNode = {
     name: NameNode;
@@ -7,5 +7,5 @@ type NamedDefNode = {
 export type OnFieldTypeConflict = (existingField: FieldDefNode, otherField: FieldDefNode, type: NamedDefNode, ignoreNullability: boolean | undefined) => FieldDefNode;
 export declare function mergeFields<T extends FieldDefNode>(type: {
     name: NameNode;
-}, f1: ReadonlyArray<T> | undefined, f2: ReadonlyArray<T> | undefined, config?: Config): T[];
+}, f1: ReadonlyArray<T> | undefined, f2: ReadonlyArray<T> | undefined, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): T[];
 export {};

package/typings/typedefs-mergers/input-type.d.cts

@@ -1,3 +1,3 @@
 import { Config } from './merge-typedefs.cjs';
-import { InputObjectTypeDefinitionNode, InputObjectTypeExtensionNode } from 'graphql';
-export declare function mergeInputType(node: InputObjectTypeDefinitionNode | InputObjectTypeExtensionNode, existingNode: InputObjectTypeDefinitionNode | InputObjectTypeExtensionNode, config?: Config): InputObjectTypeDefinitionNode | InputObjectTypeExtensionNode;
+import { InputObjectTypeDefinitionNode, InputObjectTypeExtensionNode, DirectiveDefinitionNode } from 'graphql';
+export declare function mergeInputType(node: InputObjectTypeDefinitionNode | InputObjectTypeExtensionNode, existingNode: InputObjectTypeDefinitionNode | InputObjectTypeExtensionNode, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): InputObjectTypeDefinitionNode | InputObjectTypeExtensionNode;

package/typings/typedefs-mergers/input-type.d.ts

@@ -1,3 +1,3 @@
 import { Config } from './merge-typedefs.js';
-import { InputObjectTypeDefinitionNode, InputObjectTypeExtensionNode } from 'graphql';
-export declare function mergeInputType(node: InputObjectTypeDefinitionNode | InputObjectTypeExtensionNode, existingNode: InputObjectTypeDefinitionNode | InputObjectTypeExtensionNode, config?: Config): InputObjectTypeDefinitionNode | InputObjectTypeExtensionNode;
+import { InputObjectTypeDefinitionNode, InputObjectTypeExtensionNode, DirectiveDefinitionNode } from 'graphql';
+export declare function mergeInputType(node: InputObjectTypeDefinitionNode | InputObjectTypeExtensionNode, existingNode: InputObjectTypeDefinitionNode | InputObjectTypeExtensionNode, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): InputObjectTypeDefinitionNode | InputObjectTypeExtensionNode;

package/typings/typedefs-mergers/interface.d.cts

@@ -1,3 +1,3 @@
 import { Config } from './merge-typedefs.cjs';
-import { InterfaceTypeDefinitionNode, InterfaceTypeExtensionNode } from 'graphql';
-export declare function mergeInterface(node: InterfaceTypeDefinitionNode | InterfaceTypeExtensionNode, existingNode: InterfaceTypeDefinitionNode | InterfaceTypeExtensionNode, config?: Config): InterfaceTypeDefinitionNode | InterfaceTypeExtensionNode;
+import { DirectiveDefinitionNode, InterfaceTypeDefinitionNode, InterfaceTypeExtensionNode } from 'graphql';
+export declare function mergeInterface(node: InterfaceTypeDefinitionNode | InterfaceTypeExtensionNode, existingNode: InterfaceTypeDefinitionNode | InterfaceTypeExtensionNode, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): InterfaceTypeDefinitionNode | InterfaceTypeExtensionNode;

package/typings/typedefs-mergers/interface.d.ts

@@ -1,3 +1,3 @@
 import { Config } from './merge-typedefs.js';
-import { InterfaceTypeDefinitionNode, InterfaceTypeExtensionNode } from 'graphql';
-export declare function mergeInterface(node: InterfaceTypeDefinitionNode | InterfaceTypeExtensionNode, existingNode: InterfaceTypeDefinitionNode | InterfaceTypeExtensionNode, config?: Config): InterfaceTypeDefinitionNode | InterfaceTypeExtensionNode;
+import { DirectiveDefinitionNode, InterfaceTypeDefinitionNode, InterfaceTypeExtensionNode } from 'graphql';
+export declare function mergeInterface(node: InterfaceTypeDefinitionNode | InterfaceTypeExtensionNode, existingNode: InterfaceTypeDefinitionNode | InterfaceTypeExtensionNode, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): InterfaceTypeDefinitionNode | InterfaceTypeExtensionNode;

package/typings/typedefs-mergers/merge-nodes.d.cts

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

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

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

package/typings/typedefs-mergers/scalar.d.cts

@@ -1,3 +1,3 @@
-import { ScalarTypeDefinitionNode, ScalarTypeExtensionNode } from 'graphql';
+import { DirectiveDefinitionNode, ScalarTypeDefinitionNode, ScalarTypeExtensionNode } from 'graphql';
 import { Config } from './merge-typedefs.cjs';
-export declare function mergeScalar(node: ScalarTypeDefinitionNode | ScalarTypeExtensionNode, existingNode: ScalarTypeDefinitionNode | ScalarTypeExtensionNode, config?: Config): ScalarTypeDefinitionNode | ScalarTypeExtensionNode;
+export declare function mergeScalar(node: ScalarTypeDefinitionNode | ScalarTypeExtensionNode, existingNode: ScalarTypeDefinitionNode | ScalarTypeExtensionNode, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): ScalarTypeDefinitionNode | ScalarTypeExtensionNode;

package/typings/typedefs-mergers/scalar.d.ts

@@ -1,3 +1,3 @@
-import { ScalarTypeDefinitionNode, ScalarTypeExtensionNode } from 'graphql';
+import { DirectiveDefinitionNode, ScalarTypeDefinitionNode, ScalarTypeExtensionNode } from 'graphql';
 import { Config } from './merge-typedefs.js';
-export declare function mergeScalar(node: ScalarTypeDefinitionNode | ScalarTypeExtensionNode, existingNode: ScalarTypeDefinitionNode | ScalarTypeExtensionNode, config?: Config): ScalarTypeDefinitionNode | ScalarTypeExtensionNode;
+export declare function mergeScalar(node: ScalarTypeDefinitionNode | ScalarTypeExtensionNode, existingNode: ScalarTypeDefinitionNode | ScalarTypeExtensionNode, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): ScalarTypeDefinitionNode | ScalarTypeExtensionNode;

package/typings/typedefs-mergers/schema-def.d.cts

@@ -1,8 +1,8 @@
-import { SchemaDefinitionNode, SchemaExtensionNode } from 'graphql';
+import { DirectiveDefinitionNode, SchemaDefinitionNode, SchemaExtensionNode } from 'graphql';
 import { Config } from './merge-typedefs.cjs';
 export declare const DEFAULT_OPERATION_TYPE_NAME_MAP: {
     readonly query: "Query";
     readonly mutation: "Mutation";
     readonly subscription: "Subscription";
 };
-export declare function mergeSchemaDefs(node: SchemaDefinitionNode | SchemaExtensionNode, existingNode: SchemaDefinitionNode | SchemaExtensionNode, config?: Config): SchemaDefinitionNode | SchemaExtensionNode;
+export declare function mergeSchemaDefs(node: SchemaDefinitionNode | SchemaExtensionNode, existingNode: SchemaDefinitionNode | SchemaExtensionNode, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): SchemaDefinitionNode | SchemaExtensionNode;

package/typings/typedefs-mergers/schema-def.d.ts

@@ -1,8 +1,8 @@
-import { SchemaDefinitionNode, SchemaExtensionNode } from 'graphql';
+import { DirectiveDefinitionNode, SchemaDefinitionNode, SchemaExtensionNode } from 'graphql';
 import { Config } from './merge-typedefs.js';
 export declare const DEFAULT_OPERATION_TYPE_NAME_MAP: {
     readonly query: "Query";
     readonly mutation: "Mutation";
     readonly subscription: "Subscription";
 };
-export declare function mergeSchemaDefs(node: SchemaDefinitionNode | SchemaExtensionNode, existingNode: SchemaDefinitionNode | SchemaExtensionNode, config?: Config): SchemaDefinitionNode | SchemaExtensionNode;
+export declare function mergeSchemaDefs(node: SchemaDefinitionNode | SchemaExtensionNode, existingNode: SchemaDefinitionNode | SchemaExtensionNode, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): SchemaDefinitionNode | SchemaExtensionNode;

package/typings/typedefs-mergers/type.d.cts

@@ -1,3 +1,3 @@
 import { Config } from './merge-typedefs.cjs';
-import { ObjectTypeDefinitionNode, ObjectTypeExtensionNode } from 'graphql';
-export declare function mergeType(node: ObjectTypeDefinitionNode | ObjectTypeExtensionNode, existingNode: ObjectTypeDefinitionNode | ObjectTypeExtensionNode, config?: Config): ObjectTypeDefinitionNode | ObjectTypeExtensionNode;
+import { DirectiveDefinitionNode, ObjectTypeDefinitionNode, ObjectTypeExtensionNode } from 'graphql';
+export declare function mergeType(node: ObjectTypeDefinitionNode | ObjectTypeExtensionNode, existingNode: ObjectTypeDefinitionNode | ObjectTypeExtensionNode, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): ObjectTypeDefinitionNode | ObjectTypeExtensionNode;

package/typings/typedefs-mergers/type.d.ts

@@ -1,3 +1,3 @@
 import { Config } from './merge-typedefs.js';
-import { ObjectTypeDefinitionNode, ObjectTypeExtensionNode } from 'graphql';
-export declare function mergeType(node: ObjectTypeDefinitionNode | ObjectTypeExtensionNode, existingNode: ObjectTypeDefinitionNode | ObjectTypeExtensionNode, config?: Config): ObjectTypeDefinitionNode | ObjectTypeExtensionNode;
+import { DirectiveDefinitionNode, ObjectTypeDefinitionNode, ObjectTypeExtensionNode } from 'graphql';
+export declare function mergeType(node: ObjectTypeDefinitionNode | ObjectTypeExtensionNode, existingNode: ObjectTypeDefinitionNode | ObjectTypeExtensionNode, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): ObjectTypeDefinitionNode | ObjectTypeExtensionNode;

package/typings/typedefs-mergers/union.d.cts

@@ -1,3 +1,3 @@
-import { UnionTypeDefinitionNode, UnionTypeExtensionNode } from 'graphql';
+import { DirectiveDefinitionNode, UnionTypeDefinitionNode, UnionTypeExtensionNode } from 'graphql';
 import { Config } from './merge-typedefs.cjs';
-export declare function mergeUnion(first: UnionTypeDefinitionNode | UnionTypeExtensionNode, second: UnionTypeDefinitionNode | UnionTypeExtensionNode, config?: Config): UnionTypeDefinitionNode | UnionTypeExtensionNode;
+export declare function mergeUnion(first: UnionTypeDefinitionNode | UnionTypeExtensionNode, second: UnionTypeDefinitionNode | UnionTypeExtensionNode, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): UnionTypeDefinitionNode | UnionTypeExtensionNode;

package/typings/typedefs-mergers/union.d.ts

@@ -1,3 +1,3 @@
-import { UnionTypeDefinitionNode, UnionTypeExtensionNode } from 'graphql';
+import { DirectiveDefinitionNode, UnionTypeDefinitionNode, UnionTypeExtensionNode } from 'graphql';
 import { Config } from './merge-typedefs.js';
-export declare function mergeUnion(first: UnionTypeDefinitionNode | UnionTypeExtensionNode, second: UnionTypeDefinitionNode | UnionTypeExtensionNode, config?: Config): UnionTypeDefinitionNode | UnionTypeExtensionNode;
+export declare function mergeUnion(first: UnionTypeDefinitionNode | UnionTypeExtensionNode, second: UnionTypeDefinitionNode | UnionTypeExtensionNode, config?: Config, directives?: Record<string, DirectiveDefinitionNode>): UnionTypeDefinitionNode | UnionTypeExtensionNode;