feat: initial support for case type selection

actions/add.action.ts

@@ -19,6 +19,7 @@ import {
   shouldAskForProject,
 } from '../lib/utils/project-utils';
 import { AbstractAction } from './abstract.action';
+import { CaseType } from '../lib/utils/formatting';
 
 const schematicName = 'nest-add';
 
@@ -122,12 +123,16 @@ export class AddAction extends AbstractAction {
   ) {
     console.info(MESSAGES.LIBRARY_INSTALLATION_STARTS);
     const schematicOptions: SchematicOption[] = [];
+    const caseType = options.find((option) => option.name === 'caseNaming')
+      ?.value as CaseType;
     schematicOptions.push(
       new SchematicOption(
         'sourceRoot',
         options.find((option) => option.name === 'sourceRoot')!.value as string,
+        { caseType },
       ),
     );
+
     const extraFlagsString = extraFlags ? extraFlags.join(' ') : undefined;
 
     try {

actions/generate.action.ts

@@ -7,6 +7,7 @@ import {
   Collection,
   CollectionFactory,
   SchematicOption,
+  SchematicOptionConfig,
 } from '../lib/schematics';
 import { MESSAGES } from '../lib/ui';
 import { loadConfiguration } from '../lib/utils/load-configuration';
@@ -19,6 +20,7 @@ import {
   shouldGenerateSpec,
 } from '../lib/utils/project-utils';
 import { AbstractAction } from './abstract.action';
+import { CaseType } from '../lib/utils/formatting';
 
 export class GenerateAction extends AbstractAction {
   public async handle(inputs: Input[], options: Input[]) {
@@ -44,9 +46,15 @@ const generateFiles = async (inputs: Input[]) => {
   const collection: AbstractCollection = CollectionFactory.create(
     collectionOption || configuration.collection || Collection.NESTJS,
   );
-  const schematicOptions: SchematicOption[] = mapSchematicOptions(inputs);
+
+  const caseType = inputs.find((option) => option.name === 'case')!
+    .value as CaseType;
+
+  const schematicOptions: SchematicOption[] = mapSchematicOptions(inputs, {
+    caseType,
+  });
   schematicOptions.push(
-    new SchematicOption('language', configuration.language),
+    new SchematicOption('language', configuration.language, { caseType }),
   );
   const configurationProjects = configuration.projects;
 
@@ -125,11 +133,17 @@ const generateFiles = async (inputs: Input[]) => {
     }
   }
 
-  schematicOptions.push(new SchematicOption('sourceRoot', sourceRoot));
-  schematicOptions.push(new SchematicOption('spec', generateSpec));
-  schematicOptions.push(new SchematicOption('flat', generateFlat));
   schematicOptions.push(
-    new SchematicOption('specFileSuffix', generateSpecFileSuffix),
+    new SchematicOption('sourceRoot', sourceRoot, { caseType }),
+  );
+  schematicOptions.push(
+    new SchematicOption('spec', generateSpec, { caseType }),
+  );
+  schematicOptions.push(
+    new SchematicOption('flat', generateFlat, { caseType }),
+  );
+  schematicOptions.push(
+    new SchematicOption('specFileSuffix', generateSpecFileSuffix, { caseType }),
   );
   try {
     const schematicInput = inputs.find((input) => input.name === 'schematic');
@@ -144,12 +158,15 @@ const generateFiles = async (inputs: Input[]) => {
   }
 };
 
-const mapSchematicOptions = (inputs: Input[]): SchematicOption[] => {
+const mapSchematicOptions = (
+  inputs: Input[],
+  config: SchematicOptionConfig,
+): SchematicOption[] => {
   const excludedInputNames = ['schematic', 'spec', 'flat', 'specFileSuffix'];
   const options: SchematicOption[] = [];
   inputs.forEach((input) => {
     if (!excludedInputNames.includes(input.name) && input.value !== undefined) {
-      options.push(new SchematicOption(input.name, input.value));
+      options.push(new SchematicOption(input.name, input.value, config));
     }
   });
   return options;

actions/new.action.ts

@@ -130,7 +130,11 @@ const mapSchematicOptions = (options: Input[]): SchematicOption[] => {
   return options.reduce(
     (schematicOptions: SchematicOption[], option: Input) => {
       if (option.name !== 'skip-install') {
-        schematicOptions.push(new SchematicOption(option.name, option.value));
+        schematicOptions.push(
+          new SchematicOption(option.name, option.value, {
+            caseType: 'kebab-or-snake',
+          }),
+        );
       }
       return schematicOptions;
     },

commands/generate.command.ts

@@ -48,6 +48,10 @@ export class GenerateCommand extends AbstractCommand {
         '-c, --collection [collectionName]',
         'Schematics collection to use.',
       )
+      .option(
+        '--caseNaming [caseType]',
+        `Casing type for generated elements. Available options: "pascal", "camel", "snake-or-kebap" (default).`,
+      )
       .action(
         async (
           schematic: string,
@@ -93,6 +97,11 @@ export class GenerateCommand extends AbstractCommand {
             value: command.skipImport,
           });
 
+          options.push({
+            name: 'caseNaming',
+            value: command.caseNaming,
+          });
+
           const inputs: Input[] = [];
           inputs.push({ name: 'schematic', value: schematic });
           inputs.push({ name: 'name', value: name });

lib/schematics/schematic.option.ts

@@ -1,13 +1,22 @@
-import { normalizeToKebabOrSnakeCase } from '../utils/formatting';
+import { normalizeToCase, formatString, CaseType } from '../utils/formatting';
+
+export type SchematicOptionConfig = {
+  caseType?: CaseType;
+};
+
+const defaultSchematicOptionConfig: SchematicOptionConfig = {
+  caseType: 'kebab-or-snake',
+};
 
 export class SchematicOption {
   constructor(
     private name: string,
     private value: boolean | string,
+    private schematicOptionConfig = defaultSchematicOptionConfig,
   ) {}
 
   get normalizedName() {
-    return normalizeToKebabOrSnakeCase(this.name);
+    return normalizeToCase(this.name, 'kebab-or-snake');
   }
 
   public toCommandString(): string {
@@ -28,13 +37,11 @@ export class SchematicOption {
   }
 
   private format() {
-    return normalizeToKebabOrSnakeCase(this.value as string)
-      .split('')
-      .reduce((content, char) => {
-        if (char === '(' || char === ')' || char === '[' || char === ']') {
-          return `${content}\\${char}`;
-        }
-        return `${content}${char}`;
-      }, '');
+    return formatString(
+      normalizeToCase(
+        this.value as string,
+        this.schematicOptionConfig.caseType || 'kebab-or-snake',
+      ),
+    );
   }
 }

lib/utils/formatting.ts

@@ -1,7 +1,63 @@
+import {
+  camelCase,
+  kebabCase,
+  pascalCase,
+  snakeCase,
+  capitalCase,
+} from 'case-anything';
+
+export type CaseType =
+  | 'kebab'
+  | 'snake'
+  | 'camel'
+  | 'pascal'
+  | 'capital'
+  | 'kebab-or-snake';
+
 /**
  *
  * @param str
- * @returns formated string
+ * @param caseType
+ * @returns formatted string
+ * @description normalizes input to a given case format.
+ * Available formats are: 'kebab' | 'snake' | 'camel' | 'pascal' | 'capital'.
+ */
+export const normalizeToCase = (
+  str: string,
+  caseType: CaseType = 'kebab-or-snake',
+) => {
+  switch (caseType) {
+    case 'kebab':
+      return kebabCase(str);
+    case 'snake':
+      return snakeCase(str);
+    case 'camel':
+      return camelCase(str);
+    case 'pascal':
+      return pascalCase(str);
+    case 'capital':
+      return capitalCase(str);
+    // For legacy purposes
+    case 'kebab-or-snake':
+      return normalizeToKebabOrSnakeCase(str);
+    default:
+      throw new Error(`Error! case type ${caseType} is not supported.`);
+  }
+};
+
+export const formatString = (str: string) => {
+  return str.split('').reduce((content, char) => {
+    if (char === '(' || char === ')' || char === '[' || char === ']') {
+      return `${content}\\${char}`;
+    }
+    return `${content}${char}`;
+  }, '');
+};
+
+/**
+ *
+ * @param str
+ * @returns formatted string
  * @description normalizes input to supported path and file name format.
  * Changes camelCase strings to kebab-case, replaces spaces with dash and keeps underscores.
  */

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/cli",
-  "version": "10.1.11",
+  "version": "10.2.0",
   "description": "Nest - modern, fast, powerful node.js web framework (@cli)",
   "publishConfig": {
     "access": "public"
@@ -42,6 +42,7 @@
     "@angular-devkit/schematics": "16.1.4",
     "@angular-devkit/schematics-cli": "16.1.4",
     "@nestjs/schematics": "^10.0.1",
+    "case-anything": "2.1.13",
     "chalk": "4.1.2",
     "chokidar": "3.5.3",
     "cli-table3": "0.6.3",

test/lib/schematics/schematic.option.spec.ts

@@ -1,4 +1,7 @@
-import { SchematicOption } from '../../../lib/schematics';
+import {
+  SchematicOption,
+  SchematicOptionConfig,
+} from '../../../lib/schematics';
 
 interface TestOption {
   input: string;

test/lib/utils/formatting.spec.ts

@@ -0,0 +1,25 @@
+import { normalizeToCase, CaseType } from '../../../lib/utils/formatting';
+
+type TestSuite = {
+  description: string;
+  input: string;
+  caseType: CaseType;
+  expected: string;
+};
+
+describe('Format strings', () => {
+  const tests: TestSuite[] = [
+    {
+      description: 'From kebap to camel',
+      input: 'my-app',
+      caseType: 'camel',
+      expected: 'myApp',
+    },
+  ];
+
+  tests.forEach((test) => {
+    it(test.description, () => {
+      expect(normalizeToCase(test.input, test.caseType)).toEqual(test.expected);
+    });
+  });
+});