@graphql-tools/merge 8.3.18 → 8.4.0-alpha-20230301043849-3d59d581

package/cjs/typedefs-mergers/arguments.js

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

package/cjs/typedefs-mergers/fields.js

@@ -5,16 +5,9 @@ const utils_js_1 = require("./utils.js");
 const directives_js_1 = require("./directives.js");
 const utils_1 = require("@graphql-tools/utils");
 const arguments_js_1 = require("./arguments.js");
-function fieldAlreadyExists(fieldsArr, otherField, config) {
-    const result = fieldsArr.find(field => field.name.value === otherField.name.value);
-    if (result && !(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) {
-        const t1 = (0, utils_js_1.extractType)(result.type);
-        const t2 = (0, utils_js_1.extractType)(otherField.type);
-        if (t1.name.value !== t2.name.value) {
-            throw new Error(`Field "${otherField.name.value}" already defined with a different type. Declared as "${t1.name.value}", but you tried to override with "${t2.name.value}"`);
-        }
-    }
-    return !!result;
+function 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) {
     const result = [];
@@ -23,22 +16,14 @@ function mergeFields(type, f1, f2, config) {
     }
     if (f1 != null) {
         for (const field of f1) {
-            if (fieldAlreadyExists(result, field, config)) {
-                const existing = result.find((f) => f.name.value === field.name.value);
-                if (!(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) {
-                    if (config === null || config === void 0 ? void 0 : config.throwOnConflict) {
-                        preventConflicts(type, existing, field, false);
-                    }
-                    else {
-                        preventConflicts(type, existing, field, true);
-                    }
-                    if ((0, utils_js_1.isNonNullTypeNode)(field.type) && !(0, utils_js_1.isNonNullTypeNode)(existing.type)) {
-                        existing.type = field.type;
-                    }
-                }
-                existing.arguments = (0, arguments_js_1.mergeArguments)(field['arguments'] || [], existing.arguments || [], config);
-                existing.directives = (0, directives_js_1.mergeDirectives)(field.directives, existing.directives, config);
-                existing.description = field.description || existing.description;
+            const [existing, existingIndex] = fieldAlreadyExists(result, field);
+            if (existing && !(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) {
+                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.description = field.description || existing.description;
+                result[existingIndex] = newField;
             }
             else {
                 result.push(field);
@@ -58,9 +43,20 @@ exports.mergeFields = mergeFields;
 function preventConflicts(type, a, b, ignoreNullability = false) {
     const aType = (0, utils_js_1.printTypeNode)(a.type);
     const bType = (0, utils_js_1.printTypeNode)(b.type);
-    if (aType !== bType && !safeChangeForFieldType(a.type, b.type, ignoreNullability)) {
-        throw new Error(`Field '${type.name.value}.${a.name.value}' changed type from '${aType}' to '${bType}'`);
+    if (aType !== bType) {
+        const t1 = (0, utils_js_1.extractType)(a.type);
+        const t2 = (0, utils_js_1.extractType)(b.type);
+        if (t1.name.value !== t2.name.value) {
+            throw new Error(`Field "${b.name.value}" already defined with a different type. Declared as "${t1.name.value}", but you tried to override with "${t2.name.value}"`);
+        }
+        if (!safeChangeForFieldType(a.type, b.type, !ignoreNullability)) {
+            throw new Error(`Field '${type.name.value}.${a.name.value}' changed type from '${aType}' to '${bType}'`);
+        }
+    }
+    if ((0, utils_js_1.isNonNullTypeNode)(b.type) && !(0, utils_js_1.isNonNullTypeNode)(a.type)) {
+        a.type = b.type;
     }
+    return a;
 }
 function safeChangeForFieldType(oldType, newType, ignoreNullability = false) {
     // both are named

package/esm/typedefs-mergers/arguments.js

@@ -1,17 +1,20 @@
 import { compareNodes, isSome } from '@graphql-tools/utils';
 export function mergeArguments(args1, args2, config) {
-    const result = deduplicateArguments([...args2, ...args1].filter(isSome));
+    const result = deduplicateArguments([...args2, ...args1].filter(isSome), config);
     if (config && config.sort) {
         result.sort(compareNodes);
     }
     return result;
 }
-function deduplicateArguments(args) {
+function deduplicateArguments(args, config) {
     return args.reduce((acc, current) => {
-        const dup = acc.find(arg => arg.name.value === current.name.value);
-        if (!dup) {
+        const dupIndex = acc.findIndex(arg => arg.name.value === current.name.value);
+        if (dupIndex === -1) {
             return acc.concat([current]);
         }
+        else if (!(config === null || config === void 0 ? void 0 : config.reverseArguments)) {
+            acc[dupIndex] = current;
+        }
         return acc;
     }, []);
 }

package/esm/typedefs-mergers/fields.js

@@ -2,16 +2,9 @@ import { extractType, isWrappingTypeNode, isListTypeNode, isNonNullTypeNode, pri
 import { mergeDirectives } from './directives.js';
 import { compareNodes } from '@graphql-tools/utils';
 import { mergeArguments } from './arguments.js';
-function fieldAlreadyExists(fieldsArr, otherField, config) {
-    const result = fieldsArr.find(field => field.name.value === otherField.name.value);
-    if (result && !(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) {
-        const t1 = extractType(result.type);
-        const t2 = extractType(otherField.type);
-        if (t1.name.value !== t2.name.value) {
-            throw new Error(`Field "${otherField.name.value}" already defined with a different type. Declared as "${t1.name.value}", but you tried to override with "${t2.name.value}"`);
-        }
-    }
-    return !!result;
+function 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) {
     const result = [];
@@ -20,22 +13,14 @@ export function mergeFields(type, f1, f2, config) {
     }
     if (f1 != null) {
         for (const field of f1) {
-            if (fieldAlreadyExists(result, field, config)) {
-                const existing = result.find((f) => f.name.value === field.name.value);
-                if (!(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) {
-                    if (config === null || config === void 0 ? void 0 : config.throwOnConflict) {
-                        preventConflicts(type, existing, field, false);
-                    }
-                    else {
-                        preventConflicts(type, existing, field, true);
-                    }
-                    if (isNonNullTypeNode(field.type) && !isNonNullTypeNode(existing.type)) {
-                        existing.type = field.type;
-                    }
-                }
-                existing.arguments = mergeArguments(field['arguments'] || [], existing.arguments || [], config);
-                existing.directives = mergeDirectives(field.directives, existing.directives, config);
-                existing.description = field.description || existing.description;
+            const [existing, existingIndex] = fieldAlreadyExists(result, field);
+            if (existing && !(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) {
+                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.description = field.description || existing.description;
+                result[existingIndex] = newField;
             }
             else {
                 result.push(field);
@@ -54,9 +39,20 @@ export function mergeFields(type, f1, f2, config) {
 function preventConflicts(type, a, b, ignoreNullability = false) {
     const aType = printTypeNode(a.type);
     const bType = printTypeNode(b.type);
-    if (aType !== bType && !safeChangeForFieldType(a.type, b.type, ignoreNullability)) {
-        throw new Error(`Field '${type.name.value}.${a.name.value}' changed type from '${aType}' to '${bType}'`);
+    if (aType !== bType) {
+        const t1 = extractType(a.type);
+        const t2 = extractType(b.type);
+        if (t1.name.value !== t2.name.value) {
+            throw new Error(`Field "${b.name.value}" already defined with a different type. Declared as "${t1.name.value}", but you tried to override with "${t2.name.value}"`);
+        }
+        if (!safeChangeForFieldType(a.type, b.type, !ignoreNullability)) {
+            throw new Error(`Field '${type.name.value}.${a.name.value}' changed type from '${aType}' to '${bType}'`);
+        }
+    }
+    if (isNonNullTypeNode(b.type) && !isNonNullTypeNode(a.type)) {
+        a.type = b.type;
     }
+    return a;
 }
 function safeChangeForFieldType(oldType, newType, ignoreNullability = false) {
     // both are named

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/merge",
-  "version": "8.3.18",
+  "version": "8.4.0-alpha-20230301043849-3d59d581",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {

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

@@ -1,5 +1,11 @@
 import { Config } from './merge-typedefs.cjs';
 import { FieldDefinitionNode, InputValueDefinitionNode, NameNode } from 'graphql';
-export declare function mergeFields<T extends FieldDefinitionNode | InputValueDefinitionNode>(type: {
+type FieldDefNode = FieldDefinitionNode | InputValueDefinitionNode;
+type NamedDefNode = {
+    name: NameNode;
+};
+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[];
+export {};

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

@@ -1,5 +1,11 @@
 import { Config } from './merge-typedefs.js';
 import { FieldDefinitionNode, InputValueDefinitionNode, NameNode } from 'graphql';
-export declare function mergeFields<T extends FieldDefinitionNode | InputValueDefinitionNode>(type: {
+type FieldDefNode = FieldDefinitionNode | InputValueDefinitionNode;
+type NamedDefNode = {
+    name: NameNode;
+};
+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[];
+export {};

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

@@ -1,6 +1,7 @@
 import { DefinitionNode, DocumentNode, ParseOptions } from 'graphql';
 import { CompareFn } from './utils.cjs';
 import { GetDocumentNodeFromSchemaOptions, TypeSource } from '@graphql-tools/utils';
+import { OnFieldTypeConflict } from './fields.cjs';
 type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
 export interface Config extends ParseOptions, GetDocumentNodeFromSchemaOptions {
     /**
@@ -54,6 +55,23 @@ export interface Config extends ParseOptions, GetDocumentNodeFromSchemaOptions {
     convertExtensions?: boolean;
     consistentEnumMerge?: boolean;
     ignoreFieldConflicts?: boolean;
+    /**
+     * Called if types of the same fields are different
+     *
+     * Default: false
+     *
+     * @example:
+     * Given:
+     * ```graphql
+     *  type User { a: String }
+     *  type User { a: Int }
+     * ```
+     *
+     * Instead of throwing `already defined with a different type` error,
+     * `onFieldTypeConflict` function is called.
+     */
+    onFieldTypeConflict?: OnFieldTypeConflict;
+    reverseArguments?: boolean;
 }
 /**
  * Merges multiple type definitions into a single `DocumentNode`

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

@@ -1,6 +1,7 @@
 import { DefinitionNode, DocumentNode, ParseOptions } from 'graphql';
 import { CompareFn } from './utils.js';
 import { GetDocumentNodeFromSchemaOptions, TypeSource } from '@graphql-tools/utils';
+import { OnFieldTypeConflict } from './fields.js';
 type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
 export interface Config extends ParseOptions, GetDocumentNodeFromSchemaOptions {
     /**
@@ -54,6 +55,23 @@ export interface Config extends ParseOptions, GetDocumentNodeFromSchemaOptions {
     convertExtensions?: boolean;
     consistentEnumMerge?: boolean;
     ignoreFieldConflicts?: boolean;
+    /**
+     * Called if types of the same fields are different
+     *
+     * Default: false
+     *
+     * @example:
+     * Given:
+     * ```graphql
+     *  type User { a: String }
+     *  type User { a: Int }
+     * ```
+     *
+     * Instead of throwing `already defined with a different type` error,
+     * `onFieldTypeConflict` function is called.
+     */
+    onFieldTypeConflict?: OnFieldTypeConflict;
+    reverseArguments?: boolean;
 }
 /**
  * Merges multiple type definitions into a single `DocumentNode`