@graphql-mesh/transform-naming-convention/index.mjs

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 {
    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));
        }
        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,
                fieldConfig,
            ]), new 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 RenameObjectFieldArguments((_typeName, _fieldName, argName) => fieldArgNamingConventionFn(argName)));
        }
        if (options.config.enumValues) {
            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,
                    },
                ];
            }));
        }
    }
    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);
    }
}

export default NamingConventionTransform;