@graphql-tools/merge - npm Package Compare versions

Comparing version 8.4.1 to 8.4.2-rc-20230508125905-a90277cf

cjs/typedefs-mergers/directives.js

@@ -9,2 +9,6 @@ "use strict";
 }
+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) {
@@ -38,7 +42,7 @@ return namesArr.some(({ value }) => value === name.value);
 }
-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];
@@ -52,9 +56,9 @@ directive.arguments = mergeArguments(directive.arguments, dup.arguments);
 }
-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);
@@ -61,0 +65,0 @@ const existingDirective = result[existingDirectiveIndex];

cjs/typedefs-mergers/enum-values.js

@@ -6,3 +6,3 @@ "use strict";
 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) {
@@ -28,3 +28,3 @@ const reversed = [];
                 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);
             }
@@ -31,0 +31,0 @@ else {

cjs/typedefs-mergers/enum.js

@@ -7,3 +7,3 @@ "use strict";
 const enum_values_js_1 = require("./enum-values.js");
-function mergeEnum(e1, e2, config) {
+function mergeEnum(e1, e2, config, directives) {
     if (e2) {
@@ -17,3 +17,3 @@ return {
             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),
@@ -20,0 +20,0 @@ };

cjs/typedefs-mergers/fields.js

@@ -12,3 +12,3 @@ "use strict";
 }
-function mergeFields(type, f1, f2, config) {
+function mergeFields(type, f1, f2, config, directives) {
     const result = [];
@@ -25,3 +25,3 @@ if (f2 != null) {
                 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;
@@ -28,0 +28,0 @@ result[existingIndex] = newField;

cjs/typedefs-mergers/input-type.js

@@ -7,3 +7,3 @@ "use strict";
 const directives_js_1 = require("./directives.js");
-function mergeInputType(node, existingNode, config) {
+function mergeInputType(node, existingNode, config, directives) {
     if (existingNode) {
@@ -21,3 +21,3 @@ try {
                 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),
             };
@@ -24,0 +24,0 @@ }

cjs/typedefs-mergers/interface.js

@@ -8,3 +8,3 @@ "use strict";
 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) {
@@ -22,3 +22,3 @@ try {
                 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']
@@ -25,0 +25,0 @@ ? (0, merge_named_type_array_js_1.mergeNamedTypeArray)(node['interfaces'], existingNode['interfaces'], config)

cjs/typedefs-mergers/merge-nodes.js

@@ -19,5 +19,5 @@ "use strict";
 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) {
@@ -39,23 +39,23 @@ if (isNamedDefinitionNode(nodeDefinition)) {
                     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;
@@ -62,0 +62,0 @@ case graphql_1.Kind.DIRECTIVE_DEFINITION:

cjs/typedefs-mergers/merge-typedefs.js

@@ -32,11 +32,11 @@ "use strict";
 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);
             }
@@ -46,13 +46,18 @@ }
             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);
         }
@@ -63,3 +68,3 @@ else {
     }
-    return allNodes;
+    return { allDirectives, allNodes };
 }
@@ -69,4 +74,5 @@ function mergeGraphQLTypes(typeSource, config) {
     (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) {
@@ -73,0 +79,0 @@ // XXX: right now we don't handle multiple schema definitions

cjs/typedefs-mergers/scalar.js

@@ -6,3 +6,3 @@ "use strict";
 const directives_js_1 = require("./directives.js");
-function mergeScalar(node, existingNode, config) {
+function mergeScalar(node, existingNode, config, directives) {
     if (existingNode) {
@@ -18,3 +18,3 @@ return {
             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),
         };
@@ -21,0 +21,0 @@ }

cjs/typedefs-mergers/schema-def.js

@@ -21,3 +21,3 @@ "use strict";
 }
-function mergeSchemaDefs(node, existingNode, config) {
+function mergeSchemaDefs(node, existingNode, config, directives) {
     if (existingNode) {
@@ -29,3 +29,3 @@ return {
             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),
@@ -32,0 +32,0 @@ };

cjs/typedefs-mergers/type.js

@@ -8,3 +8,3 @@ "use strict";
 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) {
@@ -22,3 +22,3 @@ try {
                 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),
@@ -25,0 +25,0 @@ };

cjs/typedefs-mergers/union.js

@@ -7,3 +7,3 @@ "use strict";
 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) {
@@ -14,3 +14,3 @@ return {
             // 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'
@@ -17,0 +17,0 @@ ? graphql_1.Kind.UNION_TYPE_DEFINITION

esm/typedefs-mergers/directives.js

@@ -6,2 +6,6 @@ import { print } from 'graphql';
 }
+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) {
@@ -35,7 +39,7 @@ return namesArr.some(({ value }) => value === name.value);
 }
-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];
@@ -49,9 +53,9 @@ directive.arguments = mergeArguments(directive.arguments, dup.arguments);
 }
-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);
@@ -58,0 +62,0 @@ const existingDirective = result[existingDirectiveIndex];

esm/typedefs-mergers/enum-values.js

 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) {
@@ -24,3 +24,3 @@ const reversed = [];
                 firstValue.description = secondValue.description || firstValue.description;
-                firstValue.directives = mergeDirectives(secondValue.directives, firstValue.directives);
+                firstValue.directives = mergeDirectives(secondValue.directives, firstValue.directives, directives);
             }
@@ -27,0 +27,0 @@ else {

esm/typedefs-mergers/enum.js

 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) {
@@ -13,3 +13,3 @@ return {
             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),
@@ -16,0 +16,0 @@ };

esm/typedefs-mergers/fields.js

@@ -9,3 +9,3 @@ import { extractType, isWrappingTypeNode, isListTypeNode, isNonNullTypeNode, printTypeNode } from './utils.js';
 }
-export function mergeFields(type, f1, f2, config) {
+export function mergeFields(type, f1, f2, config, directives) {
     const result = [];
@@ -22,3 +22,3 @@ if (f2 != null) {
                 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;
@@ -25,0 +25,0 @@ result[existingIndex] = newField;

esm/typedefs-mergers/input-type.js

@@ -1,5 +0,5 @@
-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) {
@@ -17,3 +17,3 @@ try {
                 fields: mergeFields(node, node.fields, existingNode.fields, config),
-                directives: mergeDirectives(node.directives, existingNode.directives, config),
+                directives: mergeDirectives(node.directives, existingNode.directives, config, directives),
             };
@@ -20,0 +20,0 @@ }

esm/typedefs-mergers/interface.js

@@ -5,3 +5,3 @@ import { Kind } from 'graphql';
 import { mergeNamedTypeArray } from './merge-named-type-array.js';
-export function mergeInterface(node, existingNode, config) {
+export function mergeInterface(node, existingNode, config, directives) {
     if (existingNode) {
@@ -19,3 +19,3 @@ try {
                 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']
@@ -22,0 +22,0 @@ ? mergeNamedTypeArray(node['interfaces'], existingNode['interfaces'], config)

esm/typedefs-mergers/merge-nodes.js

@@ -15,5 +15,5 @@ import { Kind } from 'graphql';
 }
-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) {
@@ -35,23 +35,23 @@ if (isNamedDefinitionNode(nodeDefinition)) {
                     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;
@@ -58,0 +58,0 @@ case Kind.DIRECTIVE_DEFINITION:

esm/typedefs-mergers/merge-typedefs.js

@@ -28,11 +28,11 @@ import { parse, Kind, isSchema, isDefinitionNode, } from 'graphql';
 }
-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);
             }
@@ -42,13 +42,18 @@ }
             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);
         }
@@ -59,3 +64,3 @@ else {
     }
-    return allNodes;
+    return { allDirectives, allNodes };
 }
@@ -65,4 +70,5 @@ export function mergeGraphQLTypes(typeSource, config) {
     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) {
@@ -69,0 +75,0 @@ // XXX: right now we don't handle multiple schema definitions

esm/typedefs-mergers/scalar.js

 import { Kind } from 'graphql';
 import { mergeDirectives } from './directives.js';
-export function mergeScalar(node, existingNode, config) {
+export function mergeScalar(node, existingNode, config, directives) {
     if (existingNode) {
@@ -14,3 +14,3 @@ return {
             loc: node.loc,
-            directives: mergeDirectives(node.directives, existingNode.directives, config),
+            directives: mergeDirectives(node.directives, existingNode.directives, config, directives),
         };
@@ -17,0 +17,0 @@ }

esm/typedefs-mergers/schema-def.js

@@ -1,2 +0,2 @@
-import { Kind } from 'graphql';
+import { Kind, } from 'graphql';
 import { mergeDirectives } from './directives.js';
@@ -18,3 +18,3 @@ export const DEFAULT_OPERATION_TYPE_NAME_MAP = {
 }
-export function mergeSchemaDefs(node, existingNode, config) {
+export function mergeSchemaDefs(node, existingNode, config, directives) {
     if (existingNode) {
@@ -26,3 +26,3 @@ return {
             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),
@@ -29,0 +29,0 @@ };

esm/typedefs-mergers/type.js

@@ -5,3 +5,3 @@ import { Kind } from 'graphql';
 import { mergeNamedTypeArray } from './merge-named-type-array.js';
-export function mergeType(node, existingNode, config) {
+export function mergeType(node, existingNode, config, directives) {
     if (existingNode) {
@@ -19,3 +19,3 @@ try {
                 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),
@@ -22,0 +22,0 @@ };

esm/typedefs-mergers/union.js

 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) {
@@ -10,3 +10,3 @@ return {
             // 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'
@@ -13,0 +13,0 @@ ? Kind.UNION_TYPE_DEFINITION

package.json

 {
   "name": "@graphql-tools/merge",
-  "version": "8.4.1",
+  "version": "8.4.2-rc-20230508125905-a90277cf",
   "description": "A set of utils for faster development of GraphQL tools",
@@ -5,0 +5,0 @@ "sideEffects": false,

typings/typedefs-mergers/directives.d.ts

 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;

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

@@ -1,3 +0,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[];

typings/typedefs-mergers/enum.d.ts

@@ -1,3 +0,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;

typings/typedefs-mergers/fields.d.ts

 import { Config } from './merge-typedefs.js';
-import { FieldDefinitionNode, InputValueDefinitionNode, NameNode } from 'graphql';
+import { FieldDefinitionNode, InputValueDefinitionNode, NameNode, DirectiveDefinitionNode } from 'graphql';
 type FieldDefNode = FieldDefinitionNode | InputValueDefinitionNode;
@@ -10,3 +10,3 @@ type NamedDefNode = {
     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 {};

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

 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;

typings/typedefs-mergers/interface.d.ts

 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;

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

 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';
@@ -9,2 +9,2 @@ export declare const schemaDefSymbol = "SCHEMA_DEF_SYMBOL";
 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;

typings/typedefs-mergers/scalar.d.ts

@@ -1,3 +0,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;

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

@@ -1,2 +0,2 @@
-import { SchemaDefinitionNode, SchemaExtensionNode } from 'graphql';
+import { DirectiveDefinitionNode, SchemaDefinitionNode, SchemaExtensionNode } from 'graphql';
 import { Config } from './merge-typedefs.js';
@@ -8,2 +8,2 @@ export declare const DEFAULT_OPERATION_TYPE_NAME_MAP: {
 };
-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;

typings/typedefs-mergers/type.d.ts

 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;

typings/typedefs-mergers/union.d.ts

@@ -1,3 +0,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;

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

100120

increased by4.04%

Lines of code

1931

increased by1.26%

Worsened metrics

Number of low quality alerts

2

increased by100%

No dependency changes