@graphql-tools/merge 8.2.15 → 8.3.0-alpha-6c480b2d.0

package/esm/typedefs-mergers/enum.js

@@ -0,0 +1,23 @@
+import { Kind } from 'graphql';
+import { mergeDirectives } from './directives.js';
+import { mergeEnumValues } from './enum-values.js';
+export function mergeEnum(e1, e2, config) {
+    if (e2) {
+        return {
+            name: e1.name,
+            description: e1['description'] || e2['description'],
+            kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) || e1.kind === 'EnumTypeDefinition' || e2.kind === 'EnumTypeDefinition'
+                ? 'EnumTypeDefinition'
+                : 'EnumTypeExtension',
+            loc: e1.loc,
+            directives: mergeDirectives(e1.directives, e2.directives, config),
+            values: mergeEnumValues(e1.values, e2.values, config),
+        };
+    }
+    return (config === null || config === void 0 ? void 0 : config.convertExtensions)
+        ? {
+            ...e1,
+            kind: Kind.ENUM_TYPE_DEFINITION,
+        }
+        : e1;
+}

package/esm/typedefs-mergers/fields.js

@@ -0,0 +1,81 @@
+import { extractType, isWrappingTypeNode, isListTypeNode, isNonNullTypeNode, printTypeNode } from './utils.js';
+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;
+}
+export function mergeFields(type, f1, f2, config) {
+    const result = [];
+    if (f2 != null) {
+        result.push(...f2);
+    }
+    if (f1 != null) {
+        for (const field of f1) {
+            if (fieldAlreadyExists(result, field, config)) {
+                const existing = result.find((f) => f.name.value === field.name.value);
+                if (!(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) {
+                    if (config === null || config === void 0 ? void 0 : config.throwOnConflict) {
+                        preventConflicts(type, existing, field, false);
+                    }
+                    else {
+                        preventConflicts(type, existing, field, true);
+                    }
+                    if (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;
+            }
+            else {
+                result.push(field);
+            }
+        }
+    }
+    if (config && config.sort) {
+        result.sort(compareNodes);
+    }
+    if (config && config.exclusions) {
+        const exclusions = config.exclusions;
+        return result.filter(field => !exclusions.includes(`${type.name.value}.${field.name.value}`));
+    }
+    return result;
+}
+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}'`);
+    }
+}
+function safeChangeForFieldType(oldType, newType, ignoreNullability = false) {
+    // both are named
+    if (!isWrappingTypeNode(oldType) && !isWrappingTypeNode(newType)) {
+        return oldType.toString() === newType.toString();
+    }
+    // new is non-null
+    if (isNonNullTypeNode(newType)) {
+        const ofType = isNonNullTypeNode(oldType) ? oldType.type : oldType;
+        return safeChangeForFieldType(ofType, newType.type);
+    }
+    // old is non-null
+    if (isNonNullTypeNode(oldType)) {
+        return safeChangeForFieldType(newType, oldType, ignoreNullability);
+    }
+    // old is list
+    if (isListTypeNode(oldType)) {
+        return ((isListTypeNode(newType) && safeChangeForFieldType(oldType.type, newType.type)) ||
+            (isNonNullTypeNode(newType) && safeChangeForFieldType(oldType, newType['type'])));
+    }
+    return false;
+}

package/esm/typedefs-mergers/index.js

@@ -0,0 +1,14 @@
+export * from './arguments.js';
+export * from './directives.js';
+export * from './enum-values.js';
+export * from './enum.js';
+export * from './fields.js';
+export * from './input-type.js';
+export * from './interface.js';
+export * from './merge-named-type-array.js';
+export * from './merge-nodes.js';
+export * from './merge-typedefs.js';
+export * from './scalar.js';
+export * from './type.js';
+export * from './union.js';
+export * from './utils.js';

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

@@ -0,0 +1,30 @@
+import { Kind } from 'graphql';
+import { mergeFields } from './fields.js';
+import { mergeDirectives } from './directives.js';
+export function mergeInputType(node, existingNode, config) {
+    if (existingNode) {
+        try {
+            return {
+                name: node.name,
+                description: node['description'] || existingNode['description'],
+                kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) ||
+                    node.kind === 'InputObjectTypeDefinition' ||
+                    existingNode.kind === 'InputObjectTypeDefinition'
+                    ? 'InputObjectTypeDefinition'
+                    : 'InputObjectTypeExtension',
+                loc: node.loc,
+                fields: mergeFields(node, node.fields, existingNode.fields, config),
+                directives: mergeDirectives(node.directives, existingNode.directives, config),
+            };
+        }
+        catch (e) {
+            throw new Error(`Unable to merge GraphQL input type "${node.name.value}": ${e.message}`);
+        }
+    }
+    return (config === null || config === void 0 ? void 0 : config.convertExtensions)
+        ? {
+            ...node,
+            kind: Kind.INPUT_OBJECT_TYPE_DEFINITION,
+        }
+        : node;
+}

package/esm/typedefs-mergers/interface.js

@@ -0,0 +1,34 @@
+import { Kind } from 'graphql';
+import { mergeFields } from './fields.js';
+import { mergeDirectives } from './directives.js';
+import { mergeNamedTypeArray } from './index.js';
+export function mergeInterface(node, existingNode, config) {
+    if (existingNode) {
+        try {
+            return {
+                name: node.name,
+                description: node['description'] || existingNode['description'],
+                kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) ||
+                    node.kind === 'InterfaceTypeDefinition' ||
+                    existingNode.kind === 'InterfaceTypeDefinition'
+                    ? 'InterfaceTypeDefinition'
+                    : 'InterfaceTypeExtension',
+                loc: node.loc,
+                fields: mergeFields(node, node.fields, existingNode.fields, config),
+                directives: mergeDirectives(node.directives, existingNode.directives, config),
+                interfaces: node['interfaces']
+                    ? mergeNamedTypeArray(node['interfaces'], existingNode['interfaces'], config)
+                    : undefined,
+            };
+        }
+        catch (e) {
+            throw new Error(`Unable to merge GraphQL interface "${node.name.value}": ${e.message}`);
+        }
+    }
+    return (config === null || config === void 0 ? void 0 : config.convertExtensions)
+        ? {
+            ...node,
+            kind: Kind.INTERFACE_TYPE_DEFINITION,
+        }
+        : node;
+}

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

@@ -0,0 +1,11 @@
+import { compareNodes } from '@graphql-tools/utils';
+function alreadyExists(arr, other) {
+    return !!arr.find(i => i.name.value === other.name.value);
+}
+export function mergeNamedTypeArray(first = [], second = [], config = {}) {
+    const result = [...second, ...first.filter(d => !alreadyExists(second, d))];
+    if (config && config.sort) {
+        result.sort(compareNodes);
+    }
+    return result;
+}

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

@@ -0,0 +1,67 @@
+import { Kind } from 'graphql';
+import { mergeType } from './type.js';
+import { mergeEnum } from './enum.js';
+import { mergeScalar } from './scalar.js';
+import { mergeUnion } from './union.js';
+import { mergeInputType } from './input-type.js';
+import { mergeInterface } from './interface.js';
+import { mergeDirective } from './directives.js';
+import { mergeSchemaDefs } from './schema-def.js';
+import { collectComment } from '@graphql-tools/utils';
+export const schemaDefSymbol = 'SCHEMA_DEF_SYMBOL';
+export function isNamedDefinitionNode(definitionNode) {
+    return 'name' in definitionNode;
+}
+export function mergeGraphQLNodes(nodes, config) {
+    var _a, _b, _c;
+    const mergedResultMap = {};
+    for (const nodeDefinition of nodes) {
+        if (isNamedDefinitionNode(nodeDefinition)) {
+            const name = (_a = nodeDefinition.name) === null || _a === void 0 ? void 0 : _a.value;
+            if (config === null || config === void 0 ? void 0 : config.commentDescriptions) {
+                collectComment(nodeDefinition);
+            }
+            if (name == null) {
+                continue;
+            }
+            if (((_b = config === null || config === void 0 ? void 0 : config.exclusions) === null || _b === void 0 ? void 0 : _b.includes(name + '.*')) || ((_c = config === null || config === void 0 ? void 0 : config.exclusions) === null || _c === void 0 ? void 0 : _c.includes(name))) {
+                delete mergedResultMap[name];
+            }
+            else {
+                switch (nodeDefinition.kind) {
+                    case Kind.OBJECT_TYPE_DEFINITION:
+                    case Kind.OBJECT_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeType(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case Kind.ENUM_TYPE_DEFINITION:
+                    case Kind.ENUM_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeEnum(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case Kind.UNION_TYPE_DEFINITION:
+                    case Kind.UNION_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeUnion(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case Kind.SCALAR_TYPE_DEFINITION:
+                    case Kind.SCALAR_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeScalar(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                    case Kind.INPUT_OBJECT_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeInputType(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case Kind.INTERFACE_TYPE_DEFINITION:
+                    case Kind.INTERFACE_TYPE_EXTENSION:
+                        mergedResultMap[name] = mergeInterface(nodeDefinition, mergedResultMap[name], config);
+                        break;
+                    case Kind.DIRECTIVE_DEFINITION:
+                        mergedResultMap[name] = mergeDirective(nodeDefinition, mergedResultMap[name]);
+                        break;
+                }
+            }
+        }
+        else if (nodeDefinition.kind === Kind.SCHEMA_DEFINITION || nodeDefinition.kind === Kind.SCHEMA_EXTENSION) {
+            mergedResultMap[schemaDefSymbol] = mergeSchemaDefs(nodeDefinition, mergedResultMap[schemaDefSymbol], config);
+        }
+    }
+    return mergedResultMap;
+}

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

@@ -0,0 +1,116 @@
+import { parse, Kind, isSchema, isDefinitionNode, } from 'graphql';
+import { defaultStringComparator, isSourceTypes, isStringTypes } from './utils.js';
+import { mergeGraphQLNodes, schemaDefSymbol } from './merge-nodes.js';
+import { getDocumentNodeFromSchema, isDocumentNode, resetComments, printWithComments, } from '@graphql-tools/utils';
+import { DEFAULT_OPERATION_TYPE_NAME_MAP } from './schema-def.js';
+export function mergeTypeDefs(typeSource, config) {
+    resetComments();
+    const doc = {
+        kind: Kind.DOCUMENT,
+        definitions: mergeGraphQLTypes(typeSource, {
+            useSchemaDefinition: true,
+            forceSchemaDefinition: false,
+            throwOnConflict: false,
+            commentDescriptions: false,
+            ...config,
+        }),
+    };
+    let result;
+    if (config === null || config === void 0 ? void 0 : config.commentDescriptions) {
+        result = printWithComments(doc);
+    }
+    else {
+        result = doc;
+    }
+    resetComments();
+    return result;
+}
+function visitTypeSources(typeSource, options, allNodes = [], visitedTypeSources = new Set()) {
+    if (typeSource && !visitedTypeSources.has(typeSource)) {
+        visitedTypeSources.add(typeSource);
+        if (typeof typeSource === 'function') {
+            visitTypeSources(typeSource(), options, allNodes, visitedTypeSources);
+        }
+        else if (Array.isArray(typeSource)) {
+            for (const type of typeSource) {
+                visitTypeSources(type, options, allNodes, visitedTypeSources);
+            }
+        }
+        else if (isSchema(typeSource)) {
+            const documentNode = getDocumentNodeFromSchema(typeSource, options);
+            visitTypeSources(documentNode.definitions, options, allNodes, visitedTypeSources);
+        }
+        else if (isStringTypes(typeSource) || isSourceTypes(typeSource)) {
+            const documentNode = parse(typeSource, options);
+            visitTypeSources(documentNode.definitions, options, allNodes, visitedTypeSources);
+        }
+        else if (typeof typeSource === 'object' && isDefinitionNode(typeSource)) {
+            allNodes.push(typeSource);
+        }
+        else if (isDocumentNode(typeSource)) {
+            visitTypeSources(typeSource.definitions, options, allNodes, visitedTypeSources);
+        }
+        else {
+            throw new Error(`typeDefs must contain only strings, documents, schemas, or functions, got ${typeof typeSource}`);
+        }
+    }
+    return allNodes;
+}
+export function mergeGraphQLTypes(typeSource, config) {
+    var _a, _b, _c;
+    resetComments();
+    const allNodes = visitTypeSources(typeSource, config);
+    const mergedNodes = mergeGraphQLNodes(allNodes, config);
+    if (config === null || config === void 0 ? void 0 : config.useSchemaDefinition) {
+        // XXX: right now we don't handle multiple schema definitions
+        const schemaDef = mergedNodes[schemaDefSymbol] || {
+            kind: Kind.SCHEMA_DEFINITION,
+            operationTypes: [],
+        };
+        const operationTypes = schemaDef.operationTypes;
+        for (const opTypeDefNodeType in DEFAULT_OPERATION_TYPE_NAME_MAP) {
+            const opTypeDefNode = operationTypes.find(operationType => operationType.operation === opTypeDefNodeType);
+            if (!opTypeDefNode) {
+                const possibleRootTypeName = DEFAULT_OPERATION_TYPE_NAME_MAP[opTypeDefNodeType];
+                const existingPossibleRootType = mergedNodes[possibleRootTypeName];
+                if (existingPossibleRootType != null && existingPossibleRootType.name != null) {
+                    operationTypes.push({
+                        kind: Kind.OPERATION_TYPE_DEFINITION,
+                        type: {
+                            kind: Kind.NAMED_TYPE,
+                            name: existingPossibleRootType.name,
+                        },
+                        operation: opTypeDefNodeType,
+                    });
+                }
+            }
+        }
+        if (((_a = schemaDef === null || schemaDef === void 0 ? void 0 : schemaDef.operationTypes) === null || _a === void 0 ? void 0 : _a.length) != null && schemaDef.operationTypes.length > 0) {
+            mergedNodes[schemaDefSymbol] = schemaDef;
+        }
+    }
+    if ((config === null || config === void 0 ? void 0 : config.forceSchemaDefinition) && !((_c = (_b = mergedNodes[schemaDefSymbol]) === null || _b === void 0 ? void 0 : _b.operationTypes) === null || _c === void 0 ? void 0 : _c.length)) {
+        mergedNodes[schemaDefSymbol] = {
+            kind: Kind.SCHEMA_DEFINITION,
+            operationTypes: [
+                {
+                    kind: Kind.OPERATION_TYPE_DEFINITION,
+                    operation: 'query',
+                    type: {
+                        kind: Kind.NAMED_TYPE,
+                        name: {
+                            kind: Kind.NAME,
+                            value: 'Query',
+                        },
+                    },
+                },
+            ],
+        };
+    }
+    const mergedNodeDefinitions = Object.values(mergedNodes);
+    if (config === null || config === void 0 ? void 0 : config.sort) {
+        const sortFn = typeof config.sort === 'function' ? config.sort : defaultStringComparator;
+        mergedNodeDefinitions.sort((a, b) => { var _a, _b; return sortFn((_a = a.name) === null || _a === void 0 ? void 0 : _a.value, (_b = b.name) === null || _b === void 0 ? void 0 : _b.value); });
+    }
+    return mergedNodeDefinitions;
+}

package/esm/typedefs-mergers/scalar.js

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

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

@@ -0,0 +1,35 @@
+import { Kind } from 'graphql';
+import { mergeDirectives } from './directives.js';
+export const DEFAULT_OPERATION_TYPE_NAME_MAP = {
+    query: 'Query',
+    mutation: 'Mutation',
+    subscription: 'Subscription',
+};
+function mergeOperationTypes(opNodeList = [], existingOpNodeList = []) {
+    const finalOpNodeList = [];
+    for (const opNodeType in DEFAULT_OPERATION_TYPE_NAME_MAP) {
+        const opNode = opNodeList.find(n => n.operation === opNodeType) || existingOpNodeList.find(n => n.operation === opNodeType);
+        if (opNode) {
+            finalOpNodeList.push(opNode);
+        }
+    }
+    return finalOpNodeList;
+}
+export function mergeSchemaDefs(node, existingNode, config) {
+    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),
+            operationTypes: mergeOperationTypes(node.operationTypes, existingNode.operationTypes),
+        };
+    }
+    return ((config === null || config === void 0 ? void 0 : config.convertExtensions)
+        ? {
+            ...node,
+            kind: Kind.SCHEMA_DEFINITION,
+        }
+        : node);
+}

package/esm/typedefs-mergers/type.js

@@ -0,0 +1,32 @@
+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) {
+    if (existingNode) {
+        try {
+            return {
+                name: node.name,
+                description: node['description'] || existingNode['description'],
+                kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) ||
+                    node.kind === 'ObjectTypeDefinition' ||
+                    existingNode.kind === 'ObjectTypeDefinition'
+                    ? 'ObjectTypeDefinition'
+                    : 'ObjectTypeExtension',
+                loc: node.loc,
+                fields: mergeFields(node, node.fields, existingNode.fields, config),
+                directives: mergeDirectives(node.directives, existingNode.directives, config),
+                interfaces: mergeNamedTypeArray(node.interfaces, existingNode.interfaces, config),
+            };
+        }
+        catch (e) {
+            throw new Error(`Unable to merge GraphQL type "${node.name.value}": ${e.message}`);
+        }
+    }
+    return (config === null || config === void 0 ? void 0 : config.convertExtensions)
+        ? {
+            ...node,
+            kind: Kind.OBJECT_TYPE_DEFINITION,
+        }
+        : node;
+}

package/esm/typedefs-mergers/union.js

@@ -0,0 +1,24 @@
+import { Kind } from 'graphql';
+import { mergeDirectives } from './directives.js';
+import { mergeNamedTypeArray } from './merge-named-type-array.js';
+export function mergeUnion(first, second, config) {
+    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),
+            kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) || first.kind === 'UnionTypeDefinition' || second.kind === 'UnionTypeDefinition'
+                ? Kind.UNION_TYPE_DEFINITION
+                : Kind.UNION_TYPE_EXTENSION,
+            loc: first.loc,
+            types: mergeNamedTypeArray(first.types, second.types, config),
+        };
+    }
+    return (config === null || config === void 0 ? void 0 : config.convertExtensions)
+        ? {
+            ...first,
+            kind: Kind.UNION_TYPE_DEFINITION,
+        }
+        : first;
+}

package/esm/typedefs-mergers/utils.js

@@ -0,0 +1,54 @@
+import { Source, Kind } from 'graphql';
+export function isStringTypes(types) {
+    return typeof types === 'string';
+}
+export function isSourceTypes(types) {
+    return types instanceof Source;
+}
+export function extractType(type) {
+    let visitedType = type;
+    while (visitedType.kind === Kind.LIST_TYPE || visitedType.kind === 'NonNullType') {
+        visitedType = visitedType.type;
+    }
+    return visitedType;
+}
+export function isWrappingTypeNode(type) {
+    return type.kind !== Kind.NAMED_TYPE;
+}
+export function isListTypeNode(type) {
+    return type.kind === Kind.LIST_TYPE;
+}
+export function isNonNullTypeNode(type) {
+    return type.kind === Kind.NON_NULL_TYPE;
+}
+export function printTypeNode(type) {
+    if (isListTypeNode(type)) {
+        return `[${printTypeNode(type.type)}]`;
+    }
+    if (isNonNullTypeNode(type)) {
+        return `${printTypeNode(type.type)}!`;
+    }
+    return type.name.value;
+}
+export var CompareVal;
+(function (CompareVal) {
+    CompareVal[CompareVal["A_SMALLER_THAN_B"] = -1] = "A_SMALLER_THAN_B";
+    CompareVal[CompareVal["A_EQUALS_B"] = 0] = "A_EQUALS_B";
+    CompareVal[CompareVal["A_GREATER_THAN_B"] = 1] = "A_GREATER_THAN_B";
+})(CompareVal || (CompareVal = {}));
+export function defaultStringComparator(a, b) {
+    if (a == null && b == null) {
+        return CompareVal.A_EQUALS_B;
+    }
+    if (a == null) {
+        return CompareVal.A_SMALLER_THAN_B;
+    }
+    if (b == null) {
+        return CompareVal.A_GREATER_THAN_B;
+    }
+    if (a < b)
+        return CompareVal.A_SMALLER_THAN_B;
+    if (a > b)
+        return CompareVal.A_GREATER_THAN_B;
+    return CompareVal.A_EQUALS_B;
+}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@graphql-tools/merge",
-  "version": "8.2.15",
+  "version": "8.3.0-alpha-6c480b2d.0",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0"
   },
   "dependencies": {
-    "@graphql-tools/utils": "8.7.0",
+    "@graphql-tools/utils": "8.8.0-alpha-6c480b2d.0",
     "tslib": "^2.4.0"
   },
   "repository": {
@@ -17,21 +17,42 @@
   },
   "author": "Dotan Simha <dotansimha@gmail.com>",
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
+      "require": {
+        "types": "./typings/index.d.ts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/*.d.ts",
+        "default": "./cjs/*.js"
+      },
+      "import": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "default": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/typings/index.d.ts

@@ -0,0 +1,3 @@
+export * from './merge-resolvers.js';
+export * from './typedefs-mergers/index.js';
+export * from './extensions.js';

package/{typedefs-mergers → typings/typedefs-mergers}/arguments.d.ts

@@ -1,3 +1,3 @@
 import { InputValueDefinitionNode } from 'graphql';
-import { Config } from '.';
+import { Config } from './index.js';
 export declare function mergeArguments(args1: InputValueDefinitionNode[], args2: InputValueDefinitionNode[], config?: Config): InputValueDefinitionNode[];

package/{typedefs-mergers → typings/typedefs-mergers}/directives.d.ts

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

package/{typedefs-mergers → typings/typedefs-mergers}/enum-values.d.ts

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

package/{typedefs-mergers → typings/typedefs-mergers}/enum.d.ts

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