@graphql-mesh/transform-rename 1.0.0-alpha-20220804093904-8e2e41f7f → 1.0.0-alpha-20230420220344-25b6b92bf

package/cjs/bareRename.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const shared_js_1 = require("./shared.js");
+// Resolver composer mapping renamed field and arguments
+const defaultResolverComposer = (resolveFn = graphql_1.defaultFieldResolver, originalFieldName, argsMap) => (root, args, context, info) => resolveFn(root, 
+// map renamed arguments to their original value
+argsMap
+    ? Object.keys(args).reduce((acc, key) => ({ ...acc, [argsMap[key] || key]: args[key] }), {})
+    : args, context, 
+// map renamed field name to its original value
+originalFieldName ? { ...info, fieldName: originalFieldName } : info);
+class BareRename {
+    constructor({ config }) {
+        this.noWrap = true;
+        this.typesMap = new Map();
+        this.fieldsMap = new Map();
+        this.argsMap = new Map();
+        for (const rename of config.renames) {
+            const { from: { type: fromTypeName, field: fromFieldName, argument: fromArgName }, to: { type: toTypeName, field: toFieldName, argument: toArgName }, useRegExpForTypes, useRegExpForFields, } = rename;
+            const regExpFlags = rename.regExpFlags || undefined;
+            if (fromTypeName &&
+                !fromFieldName &&
+                toTypeName &&
+                !toFieldName &&
+                fromTypeName !== toTypeName) {
+                this.typesMap.set(useRegExpForTypes ? new RegExp(fromTypeName, regExpFlags) : fromTypeName, toTypeName);
+            }
+            if (fromTypeName &&
+                fromFieldName &&
+                toTypeName &&
+                toFieldName &&
+                fromFieldName !== toFieldName) {
+                const fromName = useRegExpForFields
+                    ? new RegExp(fromFieldName, regExpFlags)
+                    : fromFieldName;
+                const typeMap = this.fieldsMap.get(fromTypeName) || new Map();
+                this.fieldsMap.set(fromTypeName, typeMap.set(fromName, toFieldName));
+            }
+            if (fromTypeName &&
+                fromFieldName &&
+                fromArgName &&
+                toTypeName &&
+                toFieldName &&
+                toArgName &&
+                fromArgName !== toArgName) {
+                const fromName = useRegExpForFields ? new RegExp(fromArgName, regExpFlags) : fromArgName;
+                const key = `${fromTypeName}.${fromFieldName}`;
+                const typeMap = this.argsMap.get(key) || new Map();
+                this.argsMap.set(key, typeMap.set(fromName, toArgName));
+            }
+        }
+    }
+    matchInMap(map, toMatch) {
+        const mapKeyIsString = map.has(toMatch);
+        const mapKey = mapKeyIsString
+            ? toMatch
+            : [...map.keys()].find(key => typeof key !== 'string' && key.test(toMatch));
+        if (!mapKey)
+            return null;
+        const newName = mapKeyIsString ? map.get(mapKey) : toMatch.replace(mapKey, map.get(mapKey));
+        // avoid re-iterating over strings that have already been renamed
+        if (mapKeyIsString)
+            map.delete(mapKey);
+        return newName;
+    }
+    renameType(type) {
+        const newTypeName = shared_js_1.ignoreList.includes(type.toString())
+            ? null
+            : this.matchInMap(this.typesMap, type.toString());
+        return newTypeName ? (0, utils_1.renameType)(type, newTypeName) : undefined;
+    }
+    transformSchema(schema) {
+        return (0, utils_1.mapSchema)(schema, {
+            ...(this.typesMap.size && {
+                [utils_1.MapperKind.TYPE]: type => this.renameType(type),
+                [utils_1.MapperKind.ABSTRACT_TYPE]: type => {
+                    const currentName = type.toString();
+                    const newName = shared_js_1.ignoreList.includes(currentName)
+                        ? null
+                        : this.matchInMap(this.typesMap, currentName);
+                    const existingResolver = type.resolveType;
+                    type.resolveType = async (data, context, info, abstractType) => {
+                        const originalResolvedTypename = await existingResolver(data, context, info, abstractType);
+                        const newTypename = shared_js_1.ignoreList.includes(originalResolvedTypename)
+                            ? null
+                            : this.matchInMap(this.typesMap, originalResolvedTypename);
+                        return newTypename || originalResolvedTypename;
+                    };
+                    if (newName && newName !== currentName) {
+                        return (0, utils_1.renameType)(type, newName);
+                    }
+                    return undefined;
+                },
+                [utils_1.MapperKind.ROOT_OBJECT]: type => this.renameType(type),
+            }),
+            ...((this.fieldsMap.size || this.argsMap.size) && {
+                [utils_1.MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
+                    const typeRules = this.fieldsMap.get(typeName);
+                    const fieldRules = this.argsMap.get(`${typeName}.${fieldName}`);
+                    const newFieldName = typeRules && this.matchInMap(typeRules, fieldName);
+                    const argsMap = fieldRules &&
+                        Array.from(fieldRules.entries()).reduce((acc, [orName, newName]) => ({ ...acc, [newName]: orName }), {});
+                    if (!newFieldName && !fieldRules)
+                        return undefined;
+                    // Rename rules for type might have been emptied by matchInMap, in which case we can cleanup
+                    if (!(typeRules === null || typeRules === void 0 ? void 0 : typeRules.size))
+                        this.fieldsMap.delete(typeName);
+                    if (fieldRules && fieldConfig.args) {
+                        fieldConfig.args = Object.entries(fieldConfig.args).reduce((args, [argName, argConfig]) => ({
+                            ...args,
+                            [this.matchInMap(fieldRules, argName) || argName]: argConfig,
+                        }), {});
+                    }
+                    // Wrap resolve fn to handle mapping renamed field name and/or renamed arguments
+                    fieldConfig.resolve = defaultResolverComposer(fieldConfig.resolve, fieldName, argsMap);
+                    return [newFieldName || fieldName, fieldConfig];
+                },
+            }),
+        });
+    }
+}
+exports.default = BareRename;

package/cjs/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const bareRename_js_1 = tslib_1.__importDefault(require("./bareRename.js"));
+const wrapRename_js_1 = tslib_1.__importDefault(require("./wrapRename.js"));
+exports.default = (function RenameTransform(options) {
+    if (Array.isArray(options.config)) {
+        return new wrapRename_js_1.default({
+            config: {
+                mode: 'wrap',
+                renames: options.config,
+            },
+        });
+    }
+    return options.config.mode === 'bare' ? new bareRename_js_1.default(options) : new wrapRename_js_1.default(options);
+});

package/cjs/package.json

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

package/cjs/shared.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ignoreList = void 0;
+const graphql_scalars_1 = require("graphql-scalars");
+exports.ignoreList = [
+    'Int',
+    'Float',
+    'String',
+    'Boolean',
+    'ID',
+    'date',
+    'hostname',
+    'regex',
+    'json-pointer',
+    'relative-json-pointer',
+    'uri-reference',
+    'uri-template',
+    'ObjMap',
+    'HttpMethod',
+    ...Object.keys(graphql_scalars_1.resolvers),
+];

package/cjs/wrapRename.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@graphql-mesh/utils");
+const wrap_1 = require("@graphql-tools/wrap");
+const shared_js_1 = require("./shared.js");
+class WrapRename {
+    constructor({ config }) {
+        this.transforms = [];
+        for (const change of config.renames) {
+            const { from: { type: fromTypeName, field: fromFieldName, argument: fromArgumentName }, to: { type: toTypeName, field: toFieldName, argument: toArgumentName }, useRegExpForTypes, useRegExpForFields, useRegExpForArguments, } = change;
+            const regExpFlags = change.regExpFlags || undefined;
+            if (fromTypeName !== toTypeName) {
+                let replaceTypeNameFn;
+                if (useRegExpForTypes) {
+                    const typeNameRegExp = new RegExp(fromTypeName, regExpFlags);
+                    replaceTypeNameFn = (t) => t.replace(typeNameRegExp, toTypeName);
+                }
+                else {
+                    replaceTypeNameFn = t => (t === fromTypeName ? toTypeName : t);
+                }
+                this.transforms.push(new wrap_1.RenameTypes(typeName => {
+                    if (shared_js_1.ignoreList.includes(typeName)) {
+                        return typeName;
+                    }
+                    return replaceTypeNameFn(typeName);
+                }));
+            }
+            if (fromFieldName && toFieldName && fromFieldName !== toFieldName) {
+                let replaceFieldNameFn;
+                if (useRegExpForFields) {
+                    const fieldNameRegExp = new RegExp(fromFieldName, regExpFlags);
+                    replaceFieldNameFn = (typeName, fieldName) => typeName === toTypeName ? fieldName.replace(fieldNameRegExp, toFieldName) : fieldName;
+                }
+                else {
+                    replaceFieldNameFn = (typeName, fieldName) => typeName === toTypeName && fieldName === fromFieldName ? toFieldName : fieldName;
+                }
+                this.transforms.push(new wrap_1.RenameObjectFields(replaceFieldNameFn));
+                this.transforms.push(new wrap_1.RenameInputObjectFields(replaceFieldNameFn));
+            }
+            if (fromTypeName &&
+                (fromTypeName === toTypeName || useRegExpForTypes) &&
+                toFieldName &&
+                (fromFieldName === toFieldName || useRegExpForFields) &&
+                fromArgumentName &&
+                fromArgumentName !== toArgumentName) {
+                let replaceArgNameFn;
+                const fieldNameMatch = (fieldName) => fieldName ===
+                    (useRegExpForFields
+                        ? fieldName.replace(new RegExp(fromFieldName, regExpFlags), toFieldName)
+                        : toFieldName);
+                const typeNameMatch = (typeName) => typeName ===
+                    (useRegExpForTypes
+                        ? typeName.replace(new RegExp(fromTypeName, regExpFlags), toTypeName)
+                        : toTypeName);
+                if (useRegExpForArguments) {
+                    const argNameRegExp = new RegExp(fromArgumentName, regExpFlags);
+                    replaceArgNameFn = (typeName, fieldName, argName) => typeNameMatch(typeName) && fieldNameMatch(fieldName)
+                        ? argName.replace(argNameRegExp, toArgumentName)
+                        : argName;
+                }
+                else {
+                    replaceArgNameFn = (typeName, fieldName, argName) => typeNameMatch(typeName) && fieldNameMatch(fieldName) && argName === fromArgumentName
+                        ? toArgumentName
+                        : argName;
+                }
+                this.transforms.push(new wrap_1.RenameObjectFieldArguments(replaceArgNameFn));
+            }
+        }
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return (0, utils_1.applySchemaTransforms)(originalWrappingSchema, subschemaConfig, transformedSchema, this.transforms);
+    }
+    transformRequest(originalRequest, delegationContext, transformationContext) {
+        return (0, utils_1.applyRequestTransforms)(originalRequest, delegationContext, transformationContext, this.transforms);
+    }
+    transformResult(originalResult, delegationContext, transformationContext) {
+        return (0, utils_1.applyResultTransforms)(originalResult, delegationContext, transformationContext, this.transforms);
+    }
+}
+exports.default = WrapRename;

package/esm/bareRename.js

@@ -0,0 +1,121 @@
+import { defaultFieldResolver, } from 'graphql';
+import { MapperKind, mapSchema, renameType } from '@graphql-tools/utils';
+import { ignoreList } from './shared.js';
+// Resolver composer mapping renamed field and arguments
+const defaultResolverComposer = (resolveFn = defaultFieldResolver, originalFieldName, argsMap) => (root, args, context, info) => resolveFn(root, 
+// map renamed arguments to their original value
+argsMap
+    ? Object.keys(args).reduce((acc, key) => ({ ...acc, [argsMap[key] || key]: args[key] }), {})
+    : args, context, 
+// map renamed field name to its original value
+originalFieldName ? { ...info, fieldName: originalFieldName } : info);
+export default class BareRename {
+    constructor({ config }) {
+        this.noWrap = true;
+        this.typesMap = new Map();
+        this.fieldsMap = new Map();
+        this.argsMap = new Map();
+        for (const rename of config.renames) {
+            const { from: { type: fromTypeName, field: fromFieldName, argument: fromArgName }, to: { type: toTypeName, field: toFieldName, argument: toArgName }, useRegExpForTypes, useRegExpForFields, } = rename;
+            const regExpFlags = rename.regExpFlags || undefined;
+            if (fromTypeName &&
+                !fromFieldName &&
+                toTypeName &&
+                !toFieldName &&
+                fromTypeName !== toTypeName) {
+                this.typesMap.set(useRegExpForTypes ? new RegExp(fromTypeName, regExpFlags) : fromTypeName, toTypeName);
+            }
+            if (fromTypeName &&
+                fromFieldName &&
+                toTypeName &&
+                toFieldName &&
+                fromFieldName !== toFieldName) {
+                const fromName = useRegExpForFields
+                    ? new RegExp(fromFieldName, regExpFlags)
+                    : fromFieldName;
+                const typeMap = this.fieldsMap.get(fromTypeName) || new Map();
+                this.fieldsMap.set(fromTypeName, typeMap.set(fromName, toFieldName));
+            }
+            if (fromTypeName &&
+                fromFieldName &&
+                fromArgName &&
+                toTypeName &&
+                toFieldName &&
+                toArgName &&
+                fromArgName !== toArgName) {
+                const fromName = useRegExpForFields ? new RegExp(fromArgName, regExpFlags) : fromArgName;
+                const key = `${fromTypeName}.${fromFieldName}`;
+                const typeMap = this.argsMap.get(key) || new Map();
+                this.argsMap.set(key, typeMap.set(fromName, toArgName));
+            }
+        }
+    }
+    matchInMap(map, toMatch) {
+        const mapKeyIsString = map.has(toMatch);
+        const mapKey = mapKeyIsString
+            ? toMatch
+            : [...map.keys()].find(key => typeof key !== 'string' && key.test(toMatch));
+        if (!mapKey)
+            return null;
+        const newName = mapKeyIsString ? map.get(mapKey) : toMatch.replace(mapKey, map.get(mapKey));
+        // avoid re-iterating over strings that have already been renamed
+        if (mapKeyIsString)
+            map.delete(mapKey);
+        return newName;
+    }
+    renameType(type) {
+        const newTypeName = ignoreList.includes(type.toString())
+            ? null
+            : this.matchInMap(this.typesMap, type.toString());
+        return newTypeName ? renameType(type, newTypeName) : undefined;
+    }
+    transformSchema(schema) {
+        return mapSchema(schema, {
+            ...(this.typesMap.size && {
+                [MapperKind.TYPE]: type => this.renameType(type),
+                [MapperKind.ABSTRACT_TYPE]: type => {
+                    const currentName = type.toString();
+                    const newName = ignoreList.includes(currentName)
+                        ? null
+                        : this.matchInMap(this.typesMap, currentName);
+                    const existingResolver = type.resolveType;
+                    type.resolveType = async (data, context, info, abstractType) => {
+                        const originalResolvedTypename = await existingResolver(data, context, info, abstractType);
+                        const newTypename = ignoreList.includes(originalResolvedTypename)
+                            ? null
+                            : this.matchInMap(this.typesMap, originalResolvedTypename);
+                        return newTypename || originalResolvedTypename;
+                    };
+                    if (newName && newName !== currentName) {
+                        return renameType(type, newName);
+                    }
+                    return undefined;
+                },
+                [MapperKind.ROOT_OBJECT]: type => this.renameType(type),
+            }),
+            ...((this.fieldsMap.size || this.argsMap.size) && {
+                [MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
+                    const typeRules = this.fieldsMap.get(typeName);
+                    const fieldRules = this.argsMap.get(`${typeName}.${fieldName}`);
+                    const newFieldName = typeRules && this.matchInMap(typeRules, fieldName);
+                    const argsMap = fieldRules &&
+                        Array.from(fieldRules.entries()).reduce((acc, [orName, newName]) => ({ ...acc, [newName]: orName }), {});
+                    if (!newFieldName && !fieldRules)
+                        return undefined;
+                    // Rename rules for type might have been emptied by matchInMap, in which case we can cleanup
+                    if (!(typeRules === null || typeRules === void 0 ? void 0 : typeRules.size))
+                        this.fieldsMap.delete(typeName);
+                    if (fieldRules && fieldConfig.args) {
+                        fieldConfig.args = Object.entries(fieldConfig.args).reduce((args, [argName, argConfig]) => ({
+                            ...args,
+                            [this.matchInMap(fieldRules, argName) || argName]: argConfig,
+                        }), {});
+                    }
+                    // Wrap resolve fn to handle mapping renamed field name and/or renamed arguments
+                    fieldConfig.resolve = defaultResolverComposer(fieldConfig.resolve, fieldName, argsMap);
+                    return [newFieldName || fieldName, fieldConfig];
+                },
+            }),
+        });
+    }
+}

package/esm/index.js

@@ -0,0 +1,13 @@
+import BareRename from './bareRename.js';
+import WrapRename from './wrapRename.js';
+export default (function RenameTransform(options) {
+    if (Array.isArray(options.config)) {
+        return new WrapRename({
+            config: {
+                mode: 'wrap',
+                renames: options.config,
+            },
+        });
+    }
+    return options.config.mode === 'bare' ? new BareRename(options) : new WrapRename(options);
+});

package/esm/shared.js

@@ -0,0 +1,18 @@
+import { resolvers as scalarsResolversMap } from 'graphql-scalars';
+export const ignoreList = [
+    'Int',
+    'Float',
+    'String',
+    'Boolean',
+    'ID',
+    'date',
+    'hostname',
+    'regex',
+    'json-pointer',
+    'relative-json-pointer',
+    'uri-reference',
+    'uri-template',
+    'ObjMap',
+    'HttpMethod',
+    ...Object.keys(scalarsResolversMap),
+];

package/esm/wrapRename.js

@@ -0,0 +1,77 @@
+import { applyRequestTransforms, applyResultTransforms, applySchemaTransforms, } from '@graphql-mesh/utils';
+import { RenameInputObjectFields, RenameObjectFieldArguments, RenameObjectFields, RenameTypes, } from '@graphql-tools/wrap';
+import { ignoreList } from './shared.js';
+export default class WrapRename {
+    constructor({ config }) {
+        this.transforms = [];
+        for (const change of config.renames) {
+            const { from: { type: fromTypeName, field: fromFieldName, argument: fromArgumentName }, to: { type: toTypeName, field: toFieldName, argument: toArgumentName }, useRegExpForTypes, useRegExpForFields, useRegExpForArguments, } = change;
+            const regExpFlags = change.regExpFlags || undefined;
+            if (fromTypeName !== toTypeName) {
+                let replaceTypeNameFn;
+                if (useRegExpForTypes) {
+                    const typeNameRegExp = new RegExp(fromTypeName, regExpFlags);
+                    replaceTypeNameFn = (t) => t.replace(typeNameRegExp, toTypeName);
+                }
+                else {
+                    replaceTypeNameFn = t => (t === fromTypeName ? toTypeName : t);
+                }
+                this.transforms.push(new RenameTypes(typeName => {
+                    if (ignoreList.includes(typeName)) {
+                        return typeName;
+                    }
+                    return replaceTypeNameFn(typeName);
+                }));
+            }
+            if (fromFieldName && toFieldName && fromFieldName !== toFieldName) {
+                let replaceFieldNameFn;
+                if (useRegExpForFields) {
+                    const fieldNameRegExp = new RegExp(fromFieldName, regExpFlags);
+                    replaceFieldNameFn = (typeName, fieldName) => typeName === toTypeName ? fieldName.replace(fieldNameRegExp, toFieldName) : fieldName;
+                }
+                else {
+                    replaceFieldNameFn = (typeName, fieldName) => typeName === toTypeName && fieldName === fromFieldName ? toFieldName : fieldName;
+                }
+                this.transforms.push(new RenameObjectFields(replaceFieldNameFn));
+                this.transforms.push(new RenameInputObjectFields(replaceFieldNameFn));
+            }
+            if (fromTypeName &&
+                (fromTypeName === toTypeName || useRegExpForTypes) &&
+                toFieldName &&
+                (fromFieldName === toFieldName || useRegExpForFields) &&
+                fromArgumentName &&
+                fromArgumentName !== toArgumentName) {
+                let replaceArgNameFn;
+                const fieldNameMatch = (fieldName) => fieldName ===
+                    (useRegExpForFields
+                        ? fieldName.replace(new RegExp(fromFieldName, regExpFlags), toFieldName)
+                        : toFieldName);
+                const typeNameMatch = (typeName) => typeName ===
+                    (useRegExpForTypes
+                        ? typeName.replace(new RegExp(fromTypeName, regExpFlags), toTypeName)
+                        : toTypeName);
+                if (useRegExpForArguments) {
+                    const argNameRegExp = new RegExp(fromArgumentName, regExpFlags);
+                    replaceArgNameFn = (typeName, fieldName, argName) => typeNameMatch(typeName) && fieldNameMatch(fieldName)
+                        ? argName.replace(argNameRegExp, toArgumentName)
+                        : argName;
+                }
+                else {
+                    replaceArgNameFn = (typeName, fieldName, argName) => typeNameMatch(typeName) && fieldNameMatch(fieldName) && argName === fromArgumentName
+                        ? toArgumentName
+                        : argName;
+                }
+                this.transforms.push(new RenameObjectFieldArguments(replaceArgNameFn));
+            }
+        }
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return applySchemaTransforms(originalWrappingSchema, subschemaConfig, transformedSchema, this.transforms);
+    }
+    transformRequest(originalRequest, delegationContext, transformationContext) {
+        return applyRequestTransforms(originalRequest, delegationContext, transformationContext, this.transforms);
+    }
+    transformResult(originalResult, delegationContext, transformationContext) {
+        return applyResultTransforms(originalResult, delegationContext, transformationContext, this.transforms);
+    }
+}

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "@graphql-mesh/transform-rename",
-  "version": "1.0.0-alpha-20220804093904-8e2e41f7f",
+  "version": "1.0.0-alpha-20230420220344-25b6b92bf",
   "sideEffects": false,
   "peerDependencies": {
-    "@graphql-mesh/types": "0.79.0-alpha-20220804093904-8e2e41f7f",
-    "@graphql-mesh/utils": "1.0.0-alpha-20220804093904-8e2e41f7f",
-    "graphql": "*"
+    "@graphql-mesh/types": "1.0.0-alpha-20230420220344-25b6b92bf",
+    "@graphql-mesh/utils": "1.0.0-alpha-20230420220344-25b6b92bf",
+    "@graphql-tools/utils": "^9.2.1",
+    "graphql": "*",
+    "tslib": "^2.4.0"
   },
   "dependencies": {
-    "@graphql-tools/delegate": "8.8.1",
-    "@graphql-tools/utils": "8.9.0",
-    "@graphql-tools/wrap": "8.5.1",
-    "tslib": "^2.4.0"
+    "@graphql-tools/delegate": "9.0.32",
+    "@graphql-tools/wrap": "9.4.2",
+    "graphql-scalars": "^1.20.4"
   },
   "repository": {
     "type": "git",
@@ -19,21 +20,28 @@
     "directory": "packages/transforms/rename"
   },
   "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": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/typings/bareRename.d.cts

@@ -0,0 +1,16 @@
+import { GraphQLSchema } from 'graphql';
+import { MeshTransform, YamlConfig } from '@graphql-mesh/types';
+type RenameMapObject = Map<string | RegExp, string>;
+export default class BareRename implements MeshTransform {
+    noWrap: boolean;
+    typesMap: RenameMapObject;
+    fieldsMap: Map<string, RenameMapObject>;
+    argsMap: Map<string, RenameMapObject>;
+    constructor({ config }: {
+        config: YamlConfig.RenameTransform;
+    });
+    matchInMap(map: RenameMapObject, toMatch: string): string;
+    renameType(type: any): import("graphql").GraphQLObjectType<any, any>;
+    transformSchema(schema: GraphQLSchema): GraphQLSchema;
+}
+export {};

package/{bareRename.d.ts → typings/bareRename.d.ts}

@@ -1,6 +1,6 @@
 import { GraphQLSchema } from 'graphql';
 import { MeshTransform, YamlConfig } from '@graphql-mesh/types';
-declare type RenameMapObject = Map<string | RegExp, string>;
+type RenameMapObject = Map<string | RegExp, string>;
 export default class BareRename implements MeshTransform {
     noWrap: boolean;
     typesMap: RenameMapObject;

package/typings/index.d.cts

@@ -0,0 +1,10 @@
+import { YamlConfig } from '@graphql-mesh/types';
+import BareRename from './bareRename.cjs';
+import WrapRename from './wrapRename.cjs';
+interface RenameTransformConstructor {
+    new (options: {
+        config: YamlConfig.RenameTransform;
+    }): BareRename | WrapRename;
+}
+declare const _default: RenameTransformConstructor;
+export default _default;

package/{index.d.ts → typings/index.d.ts}

@@ -1,6 +1,6 @@
 import { YamlConfig } from '@graphql-mesh/types';
-import WrapRename from './wrapRename';
-import BareRename from './bareRename';
+import BareRename from './bareRename.js';
+import WrapRename from './wrapRename.js';
 interface RenameTransformConstructor {
     new (options: {
         config: YamlConfig.RenameTransform;

package/typings/shared.d.cts

@@ -0,0 +1 @@
+export declare const ignoreList: string[];

package/typings/shared.d.ts

@@ -0,0 +1 @@
+export declare const ignoreList: string[];

package/typings/wrapRename.d.cts

@@ -0,0 +1,13 @@
+import { GraphQLSchema } from 'graphql';
+import { YamlConfig } from '@graphql-mesh/types';
+import { DelegationContext, SubschemaConfig, Transform } from '@graphql-tools/delegate';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+export default class WrapRename implements Transform {
+    private transforms;
+    constructor({ config }: {
+        config: YamlConfig.RenameTransform;
+    });
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest<any, any, any, Record<string, any>, any>;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: any): ExecutionResult<any, any>;
+}

package/{wrapRename.d.ts → typings/wrapRename.d.ts}

@@ -1,13 +1,13 @@
 import { GraphQLSchema } from 'graphql';
 import { YamlConfig } from '@graphql-mesh/types';
-import { ExecutionResult, ExecutionRequest } from '@graphql-tools/utils';
-import { Transform, SubschemaConfig, DelegationContext } from '@graphql-tools/delegate';
+import { DelegationContext, SubschemaConfig, Transform } from '@graphql-tools/delegate';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 export default class WrapRename implements Transform {
     private transforms;
     constructor({ config }: {
         config: YamlConfig.RenameTransform;
     });
     transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest<Record<string, any>, any, any, Record<string, any>>;
-    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: any): ExecutionResult<Record<string, any>>;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest<any, any, any, Record<string, any>, any>;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: any): ExecutionResult<any, any>;
 }

package/index.js

@@ -1,243 +0,0 @@
-'use strict';
-
-const wrap = require('@graphql-tools/wrap');
-const utils = require('@graphql-mesh/utils');
-const graphql = require('graphql');
-const utils$1 = require('@graphql-tools/utils');
-
-const ignoreList = [
-    'date',
-    'hostname',
-    'regex',
-    'json-pointer',
-    'relative-json-pointer',
-    'uri-reference',
-    'uri-template',
-    'Date',
-    'Time',
-    'DateTime',
-    'Timestamp',
-    'TimeZone',
-    'UtcOffset',
-    'Duration',
-    'ISO8601Duration',
-    'LocalDate',
-    'LocalTime',
-    'LocalEndTime',
-    'EmailAddress',
-    'NegativeFloat',
-    'NegativeInt',
-    'NonEmptyString',
-    'NonNegativeFloat',
-    'NonNegativeInt',
-    'NonPositiveFloat',
-    'NonPositiveInt',
-    'PhoneNumber',
-    'PositiveFloat',
-    'PositiveInt',
-    'PostalCode',
-    'UnsignedFloat',
-    'UnsignedInt',
-    'URL',
-    'BigInt',
-    'Byte',
-    'Long',
-    'SafeInt',
-    'UUID',
-    'GUID',
-    'Hexadecimal',
-    'HexColorCode',
-    'HSL',
-    'HSLA',
-    'IPv4',
-    'IPv6',
-    'ISBN',
-    'JWT',
-    'Latitude',
-    'Longitude',
-    'MAC',
-    'Port',
-    'RGB',
-    'RGBA',
-    'USCurrency',
-    'Currency',
-    'JSON',
-    'JSONObject',
-    'IBAN',
-    'ObjectID',
-    'Void',
-    'DID',
-    'CountryCode',
-    'Locale',
-    'RoutingNumber',
-    'AccountNumber',
-];
-class WrapRename {
-    constructor({ config }) {
-        this.transforms = [];
-        for (const change of config.renames) {
-            const { from: { type: fromTypeName, field: fromFieldName, argument: fromArgumentName }, to: { type: toTypeName, field: toFieldName, argument: toArgumentName }, useRegExpForTypes, useRegExpForFields, useRegExpForArguments, } = change;
-            const regExpFlags = change.regExpFlags || undefined;
-            if (fromTypeName !== toTypeName) {
-                let replaceTypeNameFn;
-                if (useRegExpForTypes) {
-                    const typeNameRegExp = new RegExp(fromTypeName, regExpFlags);
-                    replaceTypeNameFn = (t) => t.replace(typeNameRegExp, toTypeName);
-                }
-                else {
-                    replaceTypeNameFn = t => (t === fromTypeName ? toTypeName : t);
-                }
-                this.transforms.push(new wrap.RenameTypes(typeName => {
-                    if (ignoreList.includes(typeName)) {
-                        return typeName;
-                    }
-                    return replaceTypeNameFn(typeName);
-                }));
-            }
-            if (fromFieldName && toFieldName && fromFieldName !== toFieldName) {
-                let replaceFieldNameFn;
-                if (useRegExpForFields) {
-                    const fieldNameRegExp = new RegExp(fromFieldName, regExpFlags);
-                    replaceFieldNameFn = (typeName, fieldName) => typeName === toTypeName ? fieldName.replace(fieldNameRegExp, toFieldName) : fieldName;
-                }
-                else {
-                    replaceFieldNameFn = (typeName, fieldName) => typeName === toTypeName && fieldName === fromFieldName ? toFieldName : fieldName;
-                }
-                this.transforms.push(new wrap.RenameObjectFields(replaceFieldNameFn));
-                this.transforms.push(new wrap.RenameInputObjectFields(replaceFieldNameFn));
-            }
-            if (fromTypeName &&
-                (fromTypeName === toTypeName || useRegExpForTypes) &&
-                toFieldName &&
-                (fromFieldName === toFieldName || useRegExpForFields) &&
-                fromArgumentName &&
-                fromArgumentName !== toArgumentName) {
-                let replaceArgNameFn;
-                const fieldNameMatch = (fieldName) => fieldName ===
-                    (useRegExpForFields ? fieldName.replace(new RegExp(fromFieldName, regExpFlags), toFieldName) : toFieldName);
-                const typeNameMatch = (typeName) => typeName ===
-                    (useRegExpForTypes ? typeName.replace(new RegExp(fromTypeName, regExpFlags), toTypeName) : toTypeName);
-                if (useRegExpForArguments) {
-                    const argNameRegExp = new RegExp(fromArgumentName, regExpFlags);
-                    replaceArgNameFn = (typeName, fieldName, argName) => typeNameMatch(typeName) && fieldNameMatch(fieldName)
-                        ? argName.replace(argNameRegExp, toArgumentName)
-                        : argName;
-                }
-                else {
-                    replaceArgNameFn = (typeName, fieldName, argName) => typeNameMatch(typeName) && fieldNameMatch(fieldName) && argName === fromArgumentName
-                        ? toArgumentName
-                        : argName;
-                }
-                this.transforms.push(new wrap.RenameObjectFieldArguments(replaceArgNameFn));
-            }
-        }
-    }
-    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
-        return utils.applySchemaTransforms(originalWrappingSchema, subschemaConfig, transformedSchema, this.transforms);
-    }
-    transformRequest(originalRequest, delegationContext, transformationContext) {
-        return utils.applyRequestTransforms(originalRequest, delegationContext, transformationContext, this.transforms);
-    }
-    transformResult(originalResult, delegationContext, transformationContext) {
-        return utils.applyResultTransforms(originalResult, delegationContext, transformationContext, this.transforms);
-    }
-}
-
-// Resolver composer mapping renamed field and arguments
-const defaultResolverComposer = (resolveFn = graphql.defaultFieldResolver, originalFieldName, argsMap) => (root, args, context, info) => resolveFn(root, 
-// map renamed arguments to their original value
-argsMap
-    ? Object.keys(args).reduce((acc, key) => ({ ...acc, [argsMap[key] || key]: args[key] }), {})
-    : args, context, 
-// map renamed field name to its original value
-originalFieldName ? { ...info, fieldName: originalFieldName } : info);
-class BareRename {
-    constructor({ config }) {
-        this.noWrap = true;
-        this.typesMap = new Map();
-        this.fieldsMap = new Map();
-        this.argsMap = new Map();
-        for (const rename of config.renames) {
-            const { from: { type: fromTypeName, field: fromFieldName, argument: fromArgName }, to: { type: toTypeName, field: toFieldName, argument: toArgName }, useRegExpForTypes, useRegExpForFields, } = rename;
-            const regExpFlags = rename.regExpFlags || undefined;
-            if (fromTypeName && !fromFieldName && toTypeName && !toFieldName && fromTypeName !== toTypeName) {
-                this.typesMap.set(useRegExpForTypes ? new RegExp(fromTypeName, regExpFlags) : fromTypeName, toTypeName);
-            }
-            if (fromTypeName && fromFieldName && toTypeName && toFieldName && fromFieldName !== toFieldName) {
-                const fromName = useRegExpForFields ? new RegExp(fromFieldName, regExpFlags) : fromFieldName;
-                const typeMap = this.fieldsMap.get(fromTypeName) || new Map();
-                this.fieldsMap.set(fromTypeName, typeMap.set(fromName, toFieldName));
-            }
-            if (fromTypeName &&
-                fromFieldName &&
-                fromArgName &&
-                toTypeName &&
-                toFieldName &&
-                toArgName &&
-                fromArgName !== toArgName) {
-                const fromName = useRegExpForFields ? new RegExp(fromArgName, regExpFlags) : fromArgName;
-                const key = `${fromTypeName}.${fromFieldName}`;
-                const typeMap = this.argsMap.get(key) || new Map();
-                this.argsMap.set(key, typeMap.set(fromName, toArgName));
-            }
-        }
-    }
-    matchInMap(map, toMatch) {
-        const mapKeyIsString = map.has(toMatch);
-        const mapKey = mapKeyIsString ? toMatch : [...map.keys()].find(key => typeof key !== 'string' && key.test(toMatch));
-        if (!mapKey)
-            return null;
-        const newName = mapKeyIsString ? map.get(mapKey) : toMatch.replace(mapKey, map.get(mapKey));
-        // avoid re-iterating over strings that have already been renamed
-        if (mapKeyIsString)
-            map.delete(mapKey);
-        return newName;
-    }
-    renameType(type) {
-        const newTypeName = this.matchInMap(this.typesMap, type.toString());
-        return newTypeName ? utils$1.renameType(type, newTypeName) : undefined;
-    }
-    transformSchema(schema) {
-        return utils$1.mapSchema(schema, {
-            ...(this.typesMap.size && { [utils$1.MapperKind.TYPE]: type => this.renameType(type) }),
-            ...(this.typesMap.size && { [utils$1.MapperKind.ROOT_OBJECT]: type => this.renameType(type) }),
-            ...((this.fieldsMap.size || this.argsMap.size) && {
-                [utils$1.MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
-                    const typeRules = this.fieldsMap.get(typeName);
-                    const fieldRules = this.argsMap.get(`${typeName}.${fieldName}`);
-                    const newFieldName = typeRules && this.matchInMap(typeRules, fieldName);
-                    const argsMap = fieldRules &&
-                        Array.from(fieldRules.entries()).reduce((acc, [orName, newName]) => ({ ...acc, [newName]: orName }), {});
-                    if (!newFieldName && !fieldRules)
-                        return undefined;
-                    // Rename rules for type might have been emptied by matchInMap, in which case we can cleanup
-                    if (!(typeRules === null || typeRules === void 0 ? void 0 : typeRules.size))
-                        this.fieldsMap.delete(typeName);
-                    if (fieldRules && fieldConfig.args) {
-                        fieldConfig.args = Object.entries(fieldConfig.args).reduce((args, [argName, argConfig]) => ({
-                            ...args,
-                            [this.matchInMap(fieldRules, argName) || argName]: argConfig,
-                        }), {});
-                    }
-                    // Wrap resolve fn to handle mapping renamed field name and/or renamed arguments
-                    fieldConfig.resolve = defaultResolverComposer(fieldConfig.resolve, fieldName, argsMap);
-                    return [newFieldName || fieldName, fieldConfig];
-                },
-            }),
-        });
-    }
-}
-
-const RenameTransform = (function RenameTransform(options) {
-    if (Array.isArray(options.config)) {
-        return new WrapRename({
-            config: {
-                mode: 'wrap',
-                renames: options.config,
-            },
-        });
-    }
-    return options.config.mode === 'bare' ? new BareRename(options) : new WrapRename(options);
-});
-
-module.exports = RenameTransform;

package/index.mjs

@@ -1,241 +0,0 @@
-import { RenameTypes, RenameObjectFields, RenameInputObjectFields, RenameObjectFieldArguments } from '@graphql-tools/wrap';
-import { applySchemaTransforms, applyRequestTransforms, applyResultTransforms } from '@graphql-mesh/utils';
-import { defaultFieldResolver } from 'graphql';
-import { renameType, mapSchema, MapperKind } from '@graphql-tools/utils';
-
-const ignoreList = [
-    'date',
-    'hostname',
-    'regex',
-    'json-pointer',
-    'relative-json-pointer',
-    'uri-reference',
-    'uri-template',
-    'Date',
-    'Time',
-    'DateTime',
-    'Timestamp',
-    'TimeZone',
-    'UtcOffset',
-    'Duration',
-    'ISO8601Duration',
-    'LocalDate',
-    'LocalTime',
-    'LocalEndTime',
-    'EmailAddress',
-    'NegativeFloat',
-    'NegativeInt',
-    'NonEmptyString',
-    'NonNegativeFloat',
-    'NonNegativeInt',
-    'NonPositiveFloat',
-    'NonPositiveInt',
-    'PhoneNumber',
-    'PositiveFloat',
-    'PositiveInt',
-    'PostalCode',
-    'UnsignedFloat',
-    'UnsignedInt',
-    'URL',
-    'BigInt',
-    'Byte',
-    'Long',
-    'SafeInt',
-    'UUID',
-    'GUID',
-    'Hexadecimal',
-    'HexColorCode',
-    'HSL',
-    'HSLA',
-    'IPv4',
-    'IPv6',
-    'ISBN',
-    'JWT',
-    'Latitude',
-    'Longitude',
-    'MAC',
-    'Port',
-    'RGB',
-    'RGBA',
-    'USCurrency',
-    'Currency',
-    'JSON',
-    'JSONObject',
-    'IBAN',
-    'ObjectID',
-    'Void',
-    'DID',
-    'CountryCode',
-    'Locale',
-    'RoutingNumber',
-    'AccountNumber',
-];
-class WrapRename {
-    constructor({ config }) {
-        this.transforms = [];
-        for (const change of config.renames) {
-            const { from: { type: fromTypeName, field: fromFieldName, argument: fromArgumentName }, to: { type: toTypeName, field: toFieldName, argument: toArgumentName }, useRegExpForTypes, useRegExpForFields, useRegExpForArguments, } = change;
-            const regExpFlags = change.regExpFlags || undefined;
-            if (fromTypeName !== toTypeName) {
-                let replaceTypeNameFn;
-                if (useRegExpForTypes) {
-                    const typeNameRegExp = new RegExp(fromTypeName, regExpFlags);
-                    replaceTypeNameFn = (t) => t.replace(typeNameRegExp, toTypeName);
-                }
-                else {
-                    replaceTypeNameFn = t => (t === fromTypeName ? toTypeName : t);
-                }
-                this.transforms.push(new RenameTypes(typeName => {
-                    if (ignoreList.includes(typeName)) {
-                        return typeName;
-                    }
-                    return replaceTypeNameFn(typeName);
-                }));
-            }
-            if (fromFieldName && toFieldName && fromFieldName !== toFieldName) {
-                let replaceFieldNameFn;
-                if (useRegExpForFields) {
-                    const fieldNameRegExp = new RegExp(fromFieldName, regExpFlags);
-                    replaceFieldNameFn = (typeName, fieldName) => typeName === toTypeName ? fieldName.replace(fieldNameRegExp, toFieldName) : fieldName;
-                }
-                else {
-                    replaceFieldNameFn = (typeName, fieldName) => typeName === toTypeName && fieldName === fromFieldName ? toFieldName : fieldName;
-                }
-                this.transforms.push(new RenameObjectFields(replaceFieldNameFn));
-                this.transforms.push(new RenameInputObjectFields(replaceFieldNameFn));
-            }
-            if (fromTypeName &&
-                (fromTypeName === toTypeName || useRegExpForTypes) &&
-                toFieldName &&
-                (fromFieldName === toFieldName || useRegExpForFields) &&
-                fromArgumentName &&
-                fromArgumentName !== toArgumentName) {
-                let replaceArgNameFn;
-                const fieldNameMatch = (fieldName) => fieldName ===
-                    (useRegExpForFields ? fieldName.replace(new RegExp(fromFieldName, regExpFlags), toFieldName) : toFieldName);
-                const typeNameMatch = (typeName) => typeName ===
-                    (useRegExpForTypes ? typeName.replace(new RegExp(fromTypeName, regExpFlags), toTypeName) : toTypeName);
-                if (useRegExpForArguments) {
-                    const argNameRegExp = new RegExp(fromArgumentName, regExpFlags);
-                    replaceArgNameFn = (typeName, fieldName, argName) => typeNameMatch(typeName) && fieldNameMatch(fieldName)
-                        ? argName.replace(argNameRegExp, toArgumentName)
-                        : argName;
-                }
-                else {
-                    replaceArgNameFn = (typeName, fieldName, argName) => typeNameMatch(typeName) && fieldNameMatch(fieldName) && argName === fromArgumentName
-                        ? toArgumentName
-                        : argName;
-                }
-                this.transforms.push(new RenameObjectFieldArguments(replaceArgNameFn));
-            }
-        }
-    }
-    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
-        return applySchemaTransforms(originalWrappingSchema, subschemaConfig, transformedSchema, this.transforms);
-    }
-    transformRequest(originalRequest, delegationContext, transformationContext) {
-        return applyRequestTransforms(originalRequest, delegationContext, transformationContext, this.transforms);
-    }
-    transformResult(originalResult, delegationContext, transformationContext) {
-        return applyResultTransforms(originalResult, delegationContext, transformationContext, this.transforms);
-    }
-}
-
-// Resolver composer mapping renamed field and arguments
-const defaultResolverComposer = (resolveFn = defaultFieldResolver, originalFieldName, argsMap) => (root, args, context, info) => resolveFn(root, 
-// map renamed arguments to their original value
-argsMap
-    ? Object.keys(args).reduce((acc, key) => ({ ...acc, [argsMap[key] || key]: args[key] }), {})
-    : args, context, 
-// map renamed field name to its original value
-originalFieldName ? { ...info, fieldName: originalFieldName } : info);
-class BareRename {
-    constructor({ config }) {
-        this.noWrap = true;
-        this.typesMap = new Map();
-        this.fieldsMap = new Map();
-        this.argsMap = new Map();
-        for (const rename of config.renames) {
-            const { from: { type: fromTypeName, field: fromFieldName, argument: fromArgName }, to: { type: toTypeName, field: toFieldName, argument: toArgName }, useRegExpForTypes, useRegExpForFields, } = rename;
-            const regExpFlags = rename.regExpFlags || undefined;
-            if (fromTypeName && !fromFieldName && toTypeName && !toFieldName && fromTypeName !== toTypeName) {
-                this.typesMap.set(useRegExpForTypes ? new RegExp(fromTypeName, regExpFlags) : fromTypeName, toTypeName);
-            }
-            if (fromTypeName && fromFieldName && toTypeName && toFieldName && fromFieldName !== toFieldName) {
-                const fromName = useRegExpForFields ? new RegExp(fromFieldName, regExpFlags) : fromFieldName;
-                const typeMap = this.fieldsMap.get(fromTypeName) || new Map();
-                this.fieldsMap.set(fromTypeName, typeMap.set(fromName, toFieldName));
-            }
-            if (fromTypeName &&
-                fromFieldName &&
-                fromArgName &&
-                toTypeName &&
-                toFieldName &&
-                toArgName &&
-                fromArgName !== toArgName) {
-                const fromName = useRegExpForFields ? new RegExp(fromArgName, regExpFlags) : fromArgName;
-                const key = `${fromTypeName}.${fromFieldName}`;
-                const typeMap = this.argsMap.get(key) || new Map();
-                this.argsMap.set(key, typeMap.set(fromName, toArgName));
-            }
-        }
-    }
-    matchInMap(map, toMatch) {
-        const mapKeyIsString = map.has(toMatch);
-        const mapKey = mapKeyIsString ? toMatch : [...map.keys()].find(key => typeof key !== 'string' && key.test(toMatch));
-        if (!mapKey)
-            return null;
-        const newName = mapKeyIsString ? map.get(mapKey) : toMatch.replace(mapKey, map.get(mapKey));
-        // avoid re-iterating over strings that have already been renamed
-        if (mapKeyIsString)
-            map.delete(mapKey);
-        return newName;
-    }
-    renameType(type) {
-        const newTypeName = this.matchInMap(this.typesMap, type.toString());
-        return newTypeName ? renameType(type, newTypeName) : undefined;
-    }
-    transformSchema(schema) {
-        return mapSchema(schema, {
-            ...(this.typesMap.size && { [MapperKind.TYPE]: type => this.renameType(type) }),
-            ...(this.typesMap.size && { [MapperKind.ROOT_OBJECT]: type => this.renameType(type) }),
-            ...((this.fieldsMap.size || this.argsMap.size) && {
-                [MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
-                    const typeRules = this.fieldsMap.get(typeName);
-                    const fieldRules = this.argsMap.get(`${typeName}.${fieldName}`);
-                    const newFieldName = typeRules && this.matchInMap(typeRules, fieldName);
-                    const argsMap = fieldRules &&
-                        Array.from(fieldRules.entries()).reduce((acc, [orName, newName]) => ({ ...acc, [newName]: orName }), {});
-                    if (!newFieldName && !fieldRules)
-                        return undefined;
-                    // Rename rules for type might have been emptied by matchInMap, in which case we can cleanup
-                    if (!(typeRules === null || typeRules === void 0 ? void 0 : typeRules.size))
-                        this.fieldsMap.delete(typeName);
-                    if (fieldRules && fieldConfig.args) {
-                        fieldConfig.args = Object.entries(fieldConfig.args).reduce((args, [argName, argConfig]) => ({
-                            ...args,
-                            [this.matchInMap(fieldRules, argName) || argName]: argConfig,
-                        }), {});
-                    }
-                    // Wrap resolve fn to handle mapping renamed field name and/or renamed arguments
-                    fieldConfig.resolve = defaultResolverComposer(fieldConfig.resolve, fieldName, argsMap);
-                    return [newFieldName || fieldName, fieldConfig];
-                },
-            }),
-        });
-    }
-}
-
-const RenameTransform = (function RenameTransform(options) {
-    if (Array.isArray(options.config)) {
-        return new WrapRename({
-            config: {
-                mode: 'wrap',
-                renames: options.config,
-            },
-        });
-    }
-    return options.config.mode === 'bare' ? new BareRename(options) : new WrapRename(options);
-});
-
-export default RenameTransform;