@graphql-mesh/transform-naming-convention 1.0.0-alpha-3fc47d119.0 → 1.0.0-alpha-20230420181317-a95037648

package/cjs/bareNamingConvention.js

@@ -0,0 +1,192 @@
+"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");
+const isObject = (input) => typeof input === 'object' && input !== null && !Array.isArray(input) && true;
+const getUnderlyingType = (type) => type.ofType
+    ? getUnderlyingType(type.ofType)
+    : type;
+// Resolver composer mapping renamed field and arguments
+const defaultResolverComposer = (resolveFn = graphql_1.defaultFieldResolver, originalFieldName, argsMap, resultMap) => (root, args, context, info) => {
+    const originalResult = resolveFn(root, 
+    // map renamed arguments to their original value
+    argsMap ? argsFromArgMap(argsMap, args) : args, context, 
+    // map renamed field name to its original value
+    originalFieldName ? { ...info, fieldName: originalFieldName } : info);
+    // map result values from original value to new renamed value
+    return resultMap
+        ? Array.isArray(originalResult)
+            ? originalResult.map(result => resultMap[result] || originalResult)
+            : resultMap[originalResult] || originalResult
+        : originalResult;
+};
+class NamingConventionTransform {
+    constructor(options) {
+        this.noWrap = true;
+        this.config = { ...options.config };
+    }
+    transformSchema(schema) {
+        return (0, utils_1.mapSchema)(schema, {
+            ...(this.config.typeNames && {
+                [utils_1.MapperKind.TYPE]: type => {
+                    const oldName = type.name;
+                    const namingConventionFn = shared_js_1.NAMING_CONVENTIONS[this.config.typeNames];
+                    const newName = shared_js_1.IGNORED_TYPE_NAMES.includes(oldName)
+                        ? oldName
+                        : namingConventionFn(oldName);
+                    if (newName !== undefined && newName !== oldName) {
+                        return (0, utils_1.renameType)(type, newName);
+                    }
+                    return undefined;
+                },
+                [utils_1.MapperKind.ABSTRACT_TYPE]: type => {
+                    const currentName = type.name;
+                    const existingResolver = type.resolveType;
+                    const namingConventionFn = shared_js_1.NAMING_CONVENTIONS[this.config.typeNames];
+                    const newName = shared_js_1.IGNORED_TYPE_NAMES.includes(currentName)
+                        ? currentName
+                        : namingConventionFn(currentName);
+                    type.resolveType = async (data, context, info, abstractType) => {
+                        const originalResolvedTypename = await existingResolver(data, context, info, abstractType);
+                        return shared_js_1.IGNORED_TYPE_NAMES.includes(originalResolvedTypename)
+                            ? originalResolvedTypename
+                            : namingConventionFn(originalResolvedTypename);
+                    };
+                    if (newName !== undefined && newName !== currentName) {
+                        return (0, utils_1.renameType)(type, newName);
+                    }
+                    return undefined;
+                },
+            }),
+            ...(this.config.enumValues && {
+                [utils_1.MapperKind.ENUM_VALUE]: (valueConfig, _typeName, _schema, externalValue) => {
+                    const namingConventionFn = shared_js_1.NAMING_CONVENTIONS[this.config.enumValues];
+                    const newEnumValue = namingConventionFn(externalValue);
+                    if (newEnumValue === externalValue) {
+                        return undefined;
+                    }
+                    return [
+                        newEnumValue,
+                        {
+                            ...valueConfig,
+                            value: newEnumValue,
+                            astNode: {
+                                ...valueConfig.astNode,
+                                name: {
+                                    ...valueConfig.astNode.name,
+                                    value: newEnumValue,
+                                },
+                            },
+                        },
+                    ];
+                },
+            }),
+            ...((this.config.fieldNames || this.config.fieldArgumentNames) && {
+                [utils_1.MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName) => {
+                    const enumNamingConventionFn = shared_js_1.NAMING_CONVENTIONS[this.config.enumValues];
+                    const fieldNamingConventionFn = this.config.fieldNames && shared_js_1.NAMING_CONVENTIONS[this.config.fieldNames];
+                    const argNamingConventionFn = this.config.fieldArgumentNames && shared_js_1.NAMING_CONVENTIONS[this.config.fieldArgumentNames];
+                    const argsMap = fieldConfig.args && {};
+                    const newFieldName = this.config.fieldNames &&
+                        !shared_js_1.IGNORED_ROOT_FIELD_NAMES.includes(fieldName) &&
+                        fieldNamingConventionFn(fieldName);
+                    const fieldActualType = getUnderlyingType(fieldConfig.type);
+                    const resultMap = this.config.enumValues &&
+                        (0, graphql_1.isEnumType)(fieldActualType) &&
+                        Object.keys(fieldActualType.toConfig().values).reduce((map, value) => {
+                            if (Number.isFinite(value)) {
+                                return map;
+                            }
+                            const newValue = enumNamingConventionFn(value);
+                            return newValue === value
+                                ? map
+                                : {
+                                    ...map,
+                                    [value]: newValue,
+                                };
+                        }, {});
+                    if (fieldConfig.args) {
+                        fieldConfig.args = Object.entries(fieldConfig.args).reduce((args, [argName, argConfig]) => {
+                            const newArgName = this.config.fieldArgumentNames && argNamingConventionFn(argName);
+                            const useArgName = newArgName || argName;
+                            const argIsInputObjectType = (0, graphql_1.isInputObjectType)(argConfig.type);
+                            if (argIsInputObjectType) {
+                                argsMap[useArgName] = {
+                                    originalName: argName,
+                                    fields: generateArgsMapForInput(argConfig.type, fieldNamingConventionFn),
+                                };
+                            }
+                            else if (argName !== useArgName) {
+                                argsMap[useArgName] = argName;
+                            }
+                            return {
+                                ...args,
+                                [useArgName]: argConfig,
+                            };
+                        }, {});
+                    }
+                    // Wrap resolve fn to handle mapping renamed field and argument names as well as results (for enums)
+                    fieldConfig.resolve = defaultResolverComposer(fieldConfig.resolve, fieldName, argsMap, resultMap);
+                    return [newFieldName || fieldName, fieldConfig];
+                },
+            }),
+            ...(this.config.fieldNames && {
+                [utils_1.MapperKind.INPUT_OBJECT_FIELD]: (inputFieldConfig, fieldName) => {
+                    const namingConventionFn = this.config.fieldNames && shared_js_1.NAMING_CONVENTIONS[this.config.fieldNames];
+                    const newName = namingConventionFn(fieldName);
+                    if (newName === fieldName) {
+                        return undefined;
+                    }
+                    return [newName, inputFieldConfig];
+                },
+            }),
+        });
+    }
+}
+exports.default = NamingConventionTransform;
+function generateArgsMapForInput(input, fieldNamingConventionFn) {
+    const inputConfig = input.toConfig();
+    const inputFields = inputConfig.fields;
+    const argsMap = {};
+    Object.keys(inputFields).forEach(argName => {
+        if (typeof argName === 'number')
+            return;
+        const newArgName = fieldNamingConventionFn ? fieldNamingConventionFn(argName) : argName;
+        const argConfig = inputFields[argName];
+        // Unwind any list / nulls etc
+        const type = (0, graphql_1.getNamedType)(argConfig.type);
+        const argIsInputObjectType = (0, graphql_1.isInputObjectType)(type);
+        if (argIsInputObjectType) {
+            argsMap[newArgName] = {
+                originalName: argName,
+                fields: generateArgsMapForInput(type, fieldNamingConventionFn),
+            };
+        }
+        else {
+            argsMap[newArgName] = argName;
+        }
+    });
+    return argsMap;
+}
+// Map back from new arg name to the original one
+function argsFromArgMap(argMap, args) {
+    const originalArgs = {};
+    Object.keys(args).forEach(newArgName => {
+        if (typeof newArgName !== 'string')
+            return;
+        const argMapVal = argMap[newArgName];
+        const originalArgName = typeof argMapVal === 'string' ? argMapVal : argMapVal.originalName;
+        const val = args[newArgName];
+        if (Array.isArray(val) && typeof argMapVal !== 'string') {
+            originalArgs[originalArgName] = val.map(v => isObject(v) ? argsFromArgMap(argMapVal.fields, v) : v);
+        }
+        else if (isObject(val) && typeof argMapVal !== 'string') {
+            originalArgs[originalArgName] = argsFromArgMap(argMapVal.fields, val);
+        }
+        else {
+            originalArgs[originalArgName] = val;
+        }
+    });
+    return originalArgs;
+}

package/cjs/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const bareNamingConvention_js_1 = tslib_1.__importDefault(require("./bareNamingConvention.js"));
+const wrapNamingConvention_js_1 = tslib_1.__importDefault(require("./wrapNamingConvention.js"));
+exports.default = (function NamingConventionTransform(options) {
+    return options.config.mode === 'bare'
+        ? new bareNamingConvention_js_1.default(options)
+        : new wrapNamingConvention_js_1.default(options);
+});

package/cjs/package.json

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

package/cjs/shared.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IGNORED_TYPE_NAMES = exports.IGNORED_ROOT_FIELD_NAMES = exports.NAMING_CONVENTIONS = void 0;
+const change_case_1 = require("change-case");
+const graphql_scalars_1 = require("graphql-scalars");
+const lower_case_1 = require("lower-case");
+const upper_case_1 = require("upper-case");
+exports.NAMING_CONVENTIONS = {
+    camelCase: change_case_1.camelCase,
+    capitalCase: change_case_1.capitalCase,
+    constantCase: change_case_1.constantCase,
+    dotCase: change_case_1.dotCase,
+    headerCase: change_case_1.headerCase,
+    noCase: change_case_1.noCase,
+    paramCase: change_case_1.paramCase,
+    pascalCase: change_case_1.pascalCase,
+    pathCase: change_case_1.pathCase,
+    sentenceCase: change_case_1.sentenceCase,
+    snakeCase: change_case_1.snakeCase,
+    upperCase: upper_case_1.upperCase,
+    lowerCase: lower_case_1.lowerCase,
+};
+// Ignore fields needed by Federation spec
+exports.IGNORED_ROOT_FIELD_NAMES = ['_service', '_entities'];
+exports.IGNORED_TYPE_NAMES = [
+    '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/wrapNamingConvention.js

@@ -0,0 +1,50 @@
+"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 NamingConventionTransform {
+    constructor(options) {
+        this.transforms = [];
+        if (options.config.typeNames) {
+            const namingConventionFn = shared_js_1.NAMING_CONVENTIONS[options.config.typeNames];
+            this.transforms.push(new wrap_1.RenameTypes(typeName => shared_js_1.IGNORED_TYPE_NAMES.includes(typeName)
+                ? typeName
+                : namingConventionFn(typeName) || typeName));
+        }
+        if (options.config.fieldNames) {
+            const fieldNamingConventionFn = options.config.fieldNames
+                ? shared_js_1.NAMING_CONVENTIONS[options.config.fieldNames]
+                : (s) => s;
+            this.transforms.push(new wrap_1.RenameInputObjectFields((_, fieldName) => fieldNamingConventionFn(fieldName) || fieldName), new wrap_1.TransformObjectFields((_, fieldName, fieldConfig) => [
+                shared_js_1.IGNORED_ROOT_FIELD_NAMES.includes(fieldName)
+                    ? fieldName
+                    : fieldNamingConventionFn(fieldName) || fieldName,
+                fieldConfig,
+            ]), new wrap_1.RenameInterfaceFields((_, fieldName) => fieldNamingConventionFn(fieldName) || fieldName));
+        }
+        if (options.config.fieldArgumentNames) {
+            const fieldArgNamingConventionFn = options.config.fieldArgumentNames
+                ? shared_js_1.NAMING_CONVENTIONS[options.config.fieldArgumentNames]
+                : (s) => s;
+            this.transforms.push(new wrap_1.RenameObjectFieldArguments((_typeName, _fieldName, argName) => fieldArgNamingConventionFn(argName)));
+        }
+        if (options.config.enumValues) {
+            const namingConventionFn = shared_js_1.NAMING_CONVENTIONS[options.config.enumValues];
+            this.transforms.push(new wrap_1.TransformEnumValues((typeName, externalValue, enumValueConfig) => {
+                const newEnumValue = namingConventionFn(externalValue) || externalValue;
+                return [newEnumValue, enumValueConfig];
+            }));
+        }
+    }
+    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 = NamingConventionTransform;

package/esm/bareNamingConvention.js

@@ -0,0 +1,189 @@
+import { defaultFieldResolver, getNamedType, isEnumType, isInputObjectType, } from 'graphql';
+import { MapperKind, mapSchema, renameType } from '@graphql-tools/utils';
+import { IGNORED_ROOT_FIELD_NAMES, IGNORED_TYPE_NAMES, NAMING_CONVENTIONS } from './shared.js';
+const isObject = (input) => typeof input === 'object' && input !== null && !Array.isArray(input) && true;
+const getUnderlyingType = (type) => type.ofType
+    ? getUnderlyingType(type.ofType)
+    : type;
+// Resolver composer mapping renamed field and arguments
+const defaultResolverComposer = (resolveFn = defaultFieldResolver, originalFieldName, argsMap, resultMap) => (root, args, context, info) => {
+    const originalResult = resolveFn(root, 
+    // map renamed arguments to their original value
+    argsMap ? argsFromArgMap(argsMap, args) : args, context, 
+    // map renamed field name to its original value
+    originalFieldName ? { ...info, fieldName: originalFieldName } : info);
+    // map result values from original value to new renamed value
+    return resultMap
+        ? Array.isArray(originalResult)
+            ? originalResult.map(result => resultMap[result] || originalResult)
+            : resultMap[originalResult] || originalResult
+        : originalResult;
+};
+export default class NamingConventionTransform {
+    constructor(options) {
+        this.noWrap = true;
+        this.config = { ...options.config };
+    }
+    transformSchema(schema) {
+        return mapSchema(schema, {
+            ...(this.config.typeNames && {
+                [MapperKind.TYPE]: type => {
+                    const oldName = type.name;
+                    const namingConventionFn = NAMING_CONVENTIONS[this.config.typeNames];
+                    const newName = IGNORED_TYPE_NAMES.includes(oldName)
+                        ? oldName
+                        : namingConventionFn(oldName);
+                    if (newName !== undefined && newName !== oldName) {
+                        return renameType(type, newName);
+                    }
+                    return undefined;
+                },
+                [MapperKind.ABSTRACT_TYPE]: type => {
+                    const currentName = type.name;
+                    const existingResolver = type.resolveType;
+                    const namingConventionFn = NAMING_CONVENTIONS[this.config.typeNames];
+                    const newName = IGNORED_TYPE_NAMES.includes(currentName)
+                        ? currentName
+                        : namingConventionFn(currentName);
+                    type.resolveType = async (data, context, info, abstractType) => {
+                        const originalResolvedTypename = await existingResolver(data, context, info, abstractType);
+                        return IGNORED_TYPE_NAMES.includes(originalResolvedTypename)
+                            ? originalResolvedTypename
+                            : namingConventionFn(originalResolvedTypename);
+                    };
+                    if (newName !== undefined && newName !== currentName) {
+                        return renameType(type, newName);
+                    }
+                    return undefined;
+                },
+            }),
+            ...(this.config.enumValues && {
+                [MapperKind.ENUM_VALUE]: (valueConfig, _typeName, _schema, externalValue) => {
+                    const namingConventionFn = NAMING_CONVENTIONS[this.config.enumValues];
+                    const newEnumValue = namingConventionFn(externalValue);
+                    if (newEnumValue === externalValue) {
+                        return undefined;
+                    }
+                    return [
+                        newEnumValue,
+                        {
+                            ...valueConfig,
+                            value: newEnumValue,
+                            astNode: {
+                                ...valueConfig.astNode,
+                                name: {
+                                    ...valueConfig.astNode.name,
+                                    value: newEnumValue,
+                                },
+                            },
+                        },
+                    ];
+                },
+            }),
+            ...((this.config.fieldNames || this.config.fieldArgumentNames) && {
+                [MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName) => {
+                    const enumNamingConventionFn = NAMING_CONVENTIONS[this.config.enumValues];
+                    const fieldNamingConventionFn = this.config.fieldNames && NAMING_CONVENTIONS[this.config.fieldNames];
+                    const argNamingConventionFn = this.config.fieldArgumentNames && NAMING_CONVENTIONS[this.config.fieldArgumentNames];
+                    const argsMap = fieldConfig.args && {};
+                    const newFieldName = this.config.fieldNames &&
+                        !IGNORED_ROOT_FIELD_NAMES.includes(fieldName) &&
+                        fieldNamingConventionFn(fieldName);
+                    const fieldActualType = getUnderlyingType(fieldConfig.type);
+                    const resultMap = this.config.enumValues &&
+                        isEnumType(fieldActualType) &&
+                        Object.keys(fieldActualType.toConfig().values).reduce((map, value) => {
+                            if (Number.isFinite(value)) {
+                                return map;
+                            }
+                            const newValue = enumNamingConventionFn(value);
+                            return newValue === value
+                                ? map
+                                : {
+                                    ...map,
+                                    [value]: newValue,
+                                };
+                        }, {});
+                    if (fieldConfig.args) {
+                        fieldConfig.args = Object.entries(fieldConfig.args).reduce((args, [argName, argConfig]) => {
+                            const newArgName = this.config.fieldArgumentNames && argNamingConventionFn(argName);
+                            const useArgName = newArgName || argName;
+                            const argIsInputObjectType = isInputObjectType(argConfig.type);
+                            if (argIsInputObjectType) {
+                                argsMap[useArgName] = {
+                                    originalName: argName,
+                                    fields: generateArgsMapForInput(argConfig.type, fieldNamingConventionFn),
+                                };
+                            }
+                            else if (argName !== useArgName) {
+                                argsMap[useArgName] = argName;
+                            }
+                            return {
+                                ...args,
+                                [useArgName]: argConfig,
+                            };
+                        }, {});
+                    }
+                    // Wrap resolve fn to handle mapping renamed field and argument names as well as results (for enums)
+                    fieldConfig.resolve = defaultResolverComposer(fieldConfig.resolve, fieldName, argsMap, resultMap);
+                    return [newFieldName || fieldName, fieldConfig];
+                },
+            }),
+            ...(this.config.fieldNames && {
+                [MapperKind.INPUT_OBJECT_FIELD]: (inputFieldConfig, fieldName) => {
+                    const namingConventionFn = this.config.fieldNames && NAMING_CONVENTIONS[this.config.fieldNames];
+                    const newName = namingConventionFn(fieldName);
+                    if (newName === fieldName) {
+                        return undefined;
+                    }
+                    return [newName, inputFieldConfig];
+                },
+            }),
+        });
+    }
+}
+function generateArgsMapForInput(input, fieldNamingConventionFn) {
+    const inputConfig = input.toConfig();
+    const inputFields = inputConfig.fields;
+    const argsMap = {};
+    Object.keys(inputFields).forEach(argName => {
+        if (typeof argName === 'number')
+            return;
+        const newArgName = fieldNamingConventionFn ? fieldNamingConventionFn(argName) : argName;
+        const argConfig = inputFields[argName];
+        // Unwind any list / nulls etc
+        const type = getNamedType(argConfig.type);
+        const argIsInputObjectType = isInputObjectType(type);
+        if (argIsInputObjectType) {
+            argsMap[newArgName] = {
+                originalName: argName,
+                fields: generateArgsMapForInput(type, fieldNamingConventionFn),
+            };
+        }
+        else {
+            argsMap[newArgName] = argName;
+        }
+    });
+    return argsMap;
+}
+// Map back from new arg name to the original one
+function argsFromArgMap(argMap, args) {
+    const originalArgs = {};
+    Object.keys(args).forEach(newArgName => {
+        if (typeof newArgName !== 'string')
+            return;
+        const argMapVal = argMap[newArgName];
+        const originalArgName = typeof argMapVal === 'string' ? argMapVal : argMapVal.originalName;
+        const val = args[newArgName];
+        if (Array.isArray(val) && typeof argMapVal !== 'string') {
+            originalArgs[originalArgName] = val.map(v => isObject(v) ? argsFromArgMap(argMapVal.fields, v) : v);
+        }
+        else if (isObject(val) && typeof argMapVal !== 'string') {
+            originalArgs[originalArgName] = argsFromArgMap(argMapVal.fields, val);
+        }
+        else {
+            originalArgs[originalArgName] = val;
+        }
+    });
+    return originalArgs;
+}

package/esm/index.js

@@ -0,0 +1,7 @@
+import BareNamingConvention from './bareNamingConvention.js';
+import WrapNamingConvention from './wrapNamingConvention.js';
+export default (function NamingConventionTransform(options) {
+    return options.config.mode === 'bare'
+        ? new BareNamingConvention(options)
+        : new WrapNamingConvention(options);
+});

package/esm/shared.js

@@ -0,0 +1,38 @@
+import { camelCase, capitalCase, constantCase, dotCase, headerCase, noCase, paramCase, pascalCase, pathCase, sentenceCase, snakeCase, } from 'change-case';
+import { resolvers as scalarsResolversMap } from 'graphql-scalars';
+import { lowerCase } from 'lower-case';
+import { upperCase } from 'upper-case';
+export const NAMING_CONVENTIONS = {
+    camelCase,
+    capitalCase,
+    constantCase,
+    dotCase,
+    headerCase,
+    noCase,
+    paramCase,
+    pascalCase,
+    pathCase,
+    sentenceCase,
+    snakeCase,
+    upperCase,
+    lowerCase,
+};
+// Ignore fields needed by Federation spec
+export const IGNORED_ROOT_FIELD_NAMES = ['_service', '_entities'];
+export const IGNORED_TYPE_NAMES = [
+    'Int',
+    'Float',
+    'String',
+    'Boolean',
+    'ID',
+    'date',
+    'hostname',
+    'regex',
+    'json-pointer',
+    'relative-json-pointer',
+    'uri-reference',
+    'uri-template',
+    'ObjMap',
+    'HttpMethod',
+    ...Object.keys(scalarsResolversMap),
+];

package/{index.mjs → esm/wrapNamingConvention.js}

@@ -1,50 +1,23 @@
-import { RenameTypes, RenameInputObjectFields, TransformObjectFields, RenameInterfaceFields, RenameObjectFieldArguments, TransformEnumValues } from '@graphql-tools/wrap';
-import { applySchemaTransforms, applyRequestTransforms, applyResultTransforms } from '@graphql-mesh/utils';
-import { camelCase, capitalCase, constantCase, dotCase, headerCase, noCase, paramCase, pascalCase, pathCase, sentenceCase, snakeCase } from 'change-case';
-import { upperCase } from 'upper-case';
-import { lowerCase } from 'lower-case';
-import { resolvers } from 'graphql-scalars';
-
-const NAMING_CONVENTIONS = {
-    camelCase,
-    capitalCase,
-    constantCase,
-    dotCase,
-    headerCase,
-    noCase,
-    paramCase,
-    pascalCase,
-    pathCase,
-    sentenceCase,
-    snakeCase,
-    upperCase,
-    lowerCase,
-};
-// Ignore fields needed by Federation spec
-const IGNORED_ROOT_FIELD_NAMES = ['_service', '_entities'];
-const IGNORED_TYPE_NAMES = [
-    'date',
-    'hostname',
-    'regex',
-    'json-pointer',
-    'relative-json-pointer',
-    'uri-reference',
-    'uri-template',
-    ...Object.keys(resolvers),
-];
-class NamingConventionTransform {
+import { applyRequestTransforms, applyResultTransforms, applySchemaTransforms, } from '@graphql-mesh/utils';
+import { RenameInputObjectFields, RenameInterfaceFields, RenameObjectFieldArguments, RenameTypes, TransformEnumValues, TransformObjectFields, } from '@graphql-tools/wrap';
+import { IGNORED_ROOT_FIELD_NAMES, IGNORED_TYPE_NAMES, NAMING_CONVENTIONS } from './shared.js';
+export default class NamingConventionTransform {
     constructor(options) {
         this.transforms = [];
         if (options.config.typeNames) {
             const namingConventionFn = NAMING_CONVENTIONS[options.config.typeNames];
-            this.transforms.push(new RenameTypes(typeName => IGNORED_TYPE_NAMES.includes(typeName) ? typeName : namingConventionFn(typeName) || typeName));
+            this.transforms.push(new RenameTypes(typeName => IGNORED_TYPE_NAMES.includes(typeName)
+                ? typeName
+                : namingConventionFn(typeName) || typeName));
         }
         if (options.config.fieldNames) {
             const fieldNamingConventionFn = options.config.fieldNames
                 ? NAMING_CONVENTIONS[options.config.fieldNames]
                 : (s) => s;
             this.transforms.push(new RenameInputObjectFields((_, fieldName) => fieldNamingConventionFn(fieldName) || fieldName), new TransformObjectFields((_, fieldName, fieldConfig) => [
-                IGNORED_ROOT_FIELD_NAMES.includes(fieldName) ? fieldName : fieldNamingConventionFn(fieldName) || fieldName,
+                IGNORED_ROOT_FIELD_NAMES.includes(fieldName)
+                    ? fieldName
+                    : fieldNamingConventionFn(fieldName) || fieldName,
                 fieldConfig,
             ]), new RenameInterfaceFields((_, fieldName) => fieldNamingConventionFn(fieldName) || fieldName));
         }
@@ -58,13 +31,7 @@ class NamingConventionTransform {
             const namingConventionFn = NAMING_CONVENTIONS[options.config.enumValues];
             this.transforms.push(new TransformEnumValues((typeName, externalValue, enumValueConfig) => {
                 const newEnumValue = namingConventionFn(externalValue) || externalValue;
-                return [
-                    newEnumValue,
-                    {
-                        ...enumValueConfig,
-                        value: newEnumValue,
-                    },
-                ];
+                return [newEnumValue, enumValueConfig];
             }));
         }
     }
@@ -78,5 +45,3 @@ class NamingConventionTransform {
         return applyResultTransforms(originalResult, delegationContext, transformationContext, this.transforms);
     }
 }
-
-export default NamingConventionTransform;

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@graphql-mesh/transform-naming-convention",
-  "version": "1.0.0-alpha-3fc47d119.0",
+  "version": "1.0.0-alpha-20230420181317-a95037648",
   "sideEffects": false,
   "peerDependencies": {
-    "@graphql-mesh/types": "0.79.0-alpha-3fc47d119.0",
-    "@graphql-mesh/utils": "1.0.0-alpha-3fc47d119.0",
-    "graphql": "*"
+    "@graphql-mesh/types": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-mesh/utils": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-tools/utils": "^9.2.1",
+    "graphql": "*",
+    "tslib": "^2.5.0"
   },
   "dependencies": {
-    "@graphql-tools/delegate": "8.8.0",
-    "@graphql-tools/utils": "8.8.0",
-    "@graphql-tools/wrap": "8.5.0",
+    "@graphql-tools/delegate": "9.0.32",
+    "@graphql-tools/wrap": "9.4.2",
     "change-case": "4.1.2",
-    "graphql-scalars": "1.17.0",
+    "graphql-scalars": "^1.20.4",
     "lower-case": "2.0.2",
-    "tslib": "^2.4.0",
     "upper-case": "2.0.2"
   },
   "repository": {
@@ -23,21 +23,28 @@
     "directory": "packages/transforms/naming-convention"
   },
   "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/bareNamingConvention.d.cts

@@ -0,0 +1,9 @@
+import { GraphQLEnumType, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLOutputType, GraphQLScalarType, GraphQLSchema, GraphQLUnionType } from 'graphql';
+import { MeshTransform, MeshTransformOptions, YamlConfig } from '@graphql-mesh/types';
+export declare type GraphQLTypePointer = GraphQLList<GraphQLOutputType> | GraphQLNonNull<GraphQLScalarType | GraphQLObjectType | GraphQLInterfaceType | GraphQLUnionType | GraphQLEnumType | GraphQLList<GraphQLOutputType>>;
+export default class NamingConventionTransform implements MeshTransform {
+    noWrap: boolean;
+    config: Omit<YamlConfig.NamingConventionTransformConfig, 'mode'>;
+    constructor(options: MeshTransformOptions<YamlConfig.NamingConventionTransformConfig>);
+    transformSchema(schema: GraphQLSchema): GraphQLSchema;
+}

package/typings/bareNamingConvention.d.ts

@@ -0,0 +1,9 @@
+import { GraphQLEnumType, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLOutputType, GraphQLScalarType, GraphQLSchema, GraphQLUnionType } from 'graphql';
+import { MeshTransform, MeshTransformOptions, YamlConfig } from '@graphql-mesh/types';
+export declare type GraphQLTypePointer = GraphQLList<GraphQLOutputType> | GraphQLNonNull<GraphQLScalarType | GraphQLObjectType | GraphQLInterfaceType | GraphQLUnionType | GraphQLEnumType | GraphQLList<GraphQLOutputType>>;
+export default class NamingConventionTransform implements MeshTransform {
+    noWrap: boolean;
+    config: Omit<YamlConfig.NamingConventionTransformConfig, 'mode'>;
+    constructor(options: MeshTransformOptions<YamlConfig.NamingConventionTransformConfig>);
+    transformSchema(schema: GraphQLSchema): GraphQLSchema;
+}

package/typings/index.d.cts

@@ -0,0 +1,8 @@
+import { MeshTransformOptions, YamlConfig } from '@graphql-mesh/types';
+import BareNamingConvention from './bareNamingConvention.cjs';
+import WrapNamingConvention from './wrapNamingConvention.cjs';
+interface NamingConventionTransformConstructor {
+    new (options: MeshTransformOptions<YamlConfig.NamingConventionTransformConfig>): WrapNamingConvention | BareNamingConvention;
+}
+declare const _default: NamingConventionTransformConstructor;
+export default _default;

package/typings/index.d.ts

@@ -0,0 +1,8 @@
+import { MeshTransformOptions, YamlConfig } from '@graphql-mesh/types';
+import BareNamingConvention from './bareNamingConvention.js';
+import WrapNamingConvention from './wrapNamingConvention.js';
+interface NamingConventionTransformConstructor {
+    new (options: MeshTransformOptions<YamlConfig.NamingConventionTransformConfig>): WrapNamingConvention | BareNamingConvention;
+}
+declare const _default: NamingConventionTransformConstructor;
+export default _default;

package/typings/shared.d.cts

@@ -0,0 +1,7 @@
+import { YamlConfig } from '@graphql-mesh/types';
+type NamingConventionFn = (input: string) => string;
+type NamingConventionType = YamlConfig.NamingConventionTransformConfig['typeNames'];
+export declare const NAMING_CONVENTIONS: Record<NamingConventionType, NamingConventionFn>;
+export declare const IGNORED_ROOT_FIELD_NAMES: string[];
+export declare const IGNORED_TYPE_NAMES: string[];
+export {};

package/typings/shared.d.ts

@@ -0,0 +1,7 @@
+import { YamlConfig } from '@graphql-mesh/types';
+type NamingConventionFn = (input: string) => string;
+type NamingConventionType = YamlConfig.NamingConventionTransformConfig['typeNames'];
+export declare const NAMING_CONVENTIONS: Record<NamingConventionType, NamingConventionFn>;
+export declare const IGNORED_ROOT_FIELD_NAMES: string[];
+export declare const IGNORED_TYPE_NAMES: string[];
+export {};

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

@@ -1,11 +1,11 @@
 import { GraphQLSchema } from 'graphql';
-import { MeshTransform, YamlConfig, MeshTransformOptions } from '@graphql-mesh/types';
-import { ExecutionResult, ExecutionRequest } from '@graphql-tools/utils';
-import { SubschemaConfig, DelegationContext } from '@graphql-tools/delegate';
+import { MeshTransform, MeshTransformOptions, YamlConfig } from '@graphql-mesh/types';
+import { DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 export default class NamingConventionTransform implements MeshTransform {
     private transforms;
     constructor(options: MeshTransformOptions<YamlConfig.NamingConventionTransformConfig>);
     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/typings/wrapNamingConvention.d.ts

@@ -0,0 +1,11 @@
+import { GraphQLSchema } from 'graphql';
+import { MeshTransform, MeshTransformOptions, YamlConfig } from '@graphql-mesh/types';
+import { DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+export default class NamingConventionTransform implements MeshTransform {
+    private transforms;
+    constructor(options: MeshTransformOptions<YamlConfig.NamingConventionTransformConfig>);
+    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/index.js

@@ -1,84 +0,0 @@
-'use strict';
-
-const wrap = require('@graphql-tools/wrap');
-const utils = require('@graphql-mesh/utils');
-const changeCase = require('change-case');
-const upperCase = require('upper-case');
-const lowerCase = require('lower-case');
-const graphqlScalars = require('graphql-scalars');
-
-const NAMING_CONVENTIONS = {
-    camelCase: changeCase.camelCase,
-    capitalCase: changeCase.capitalCase,
-    constantCase: changeCase.constantCase,
-    dotCase: changeCase.dotCase,
-    headerCase: changeCase.headerCase,
-    noCase: changeCase.noCase,
-    paramCase: changeCase.paramCase,
-    pascalCase: changeCase.pascalCase,
-    pathCase: changeCase.pathCase,
-    sentenceCase: changeCase.sentenceCase,
-    snakeCase: changeCase.snakeCase,
-    upperCase: upperCase.upperCase,
-    lowerCase: lowerCase.lowerCase,
-};
-// Ignore fields needed by Federation spec
-const IGNORED_ROOT_FIELD_NAMES = ['_service', '_entities'];
-const IGNORED_TYPE_NAMES = [
-    'date',
-    'hostname',
-    'regex',
-    'json-pointer',
-    'relative-json-pointer',
-    'uri-reference',
-    'uri-template',
-    ...Object.keys(graphqlScalars.resolvers),
-];
-class NamingConventionTransform {
-    constructor(options) {
-        this.transforms = [];
-        if (options.config.typeNames) {
-            const namingConventionFn = NAMING_CONVENTIONS[options.config.typeNames];
-            this.transforms.push(new wrap.RenameTypes(typeName => IGNORED_TYPE_NAMES.includes(typeName) ? typeName : namingConventionFn(typeName) || typeName));
-        }
-        if (options.config.fieldNames) {
-            const fieldNamingConventionFn = options.config.fieldNames
-                ? NAMING_CONVENTIONS[options.config.fieldNames]
-                : (s) => s;
-            this.transforms.push(new wrap.RenameInputObjectFields((_, fieldName) => fieldNamingConventionFn(fieldName) || fieldName), new wrap.TransformObjectFields((_, fieldName, fieldConfig) => [
-                IGNORED_ROOT_FIELD_NAMES.includes(fieldName) ? fieldName : fieldNamingConventionFn(fieldName) || fieldName,
-                fieldConfig,
-            ]), new wrap.RenameInterfaceFields((_, fieldName) => fieldNamingConventionFn(fieldName) || fieldName));
-        }
-        if (options.config.fieldArgumentNames) {
-            const fieldArgNamingConventionFn = options.config.fieldArgumentNames
-                ? NAMING_CONVENTIONS[options.config.fieldArgumentNames]
-                : (s) => s;
-            this.transforms.push(new wrap.RenameObjectFieldArguments((_typeName, _fieldName, argName) => fieldArgNamingConventionFn(argName)));
-        }
-        if (options.config.enumValues) {
-            const namingConventionFn = NAMING_CONVENTIONS[options.config.enumValues];
-            this.transforms.push(new wrap.TransformEnumValues((typeName, externalValue, enumValueConfig) => {
-                const newEnumValue = namingConventionFn(externalValue) || externalValue;
-                return [
-                    newEnumValue,
-                    {
-                        ...enumValueConfig,
-                        value: newEnumValue,
-                    },
-                ];
-            }));
-        }
-    }
-    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);
-    }
-}
-
-module.exports = NamingConventionTransform;