feat: initial support for case type selection

actions/generate.action.ts

@@ -19,6 +19,7 @@ import {
   shouldGenerateSpec,
 } from '../lib/utils/project-utils';
 import { AbstractAction } from './abstract.action';
+import { CaseType, normalizeToCase } from '../lib/utils/formatting';
 
 export class GenerateAction extends AbstractAction {
   public async handle(inputs: Input[], options: Input[]) {
@@ -44,10 +45,22 @@ const generateFiles = async (inputs: Input[]) => {
   const collection: AbstractCollection = CollectionFactory.create(
     collectionOption || configuration.collection || Collection.NESTJS,
   );
+
+  const optionsCaseType = (
+      inputs.find((option) => option.name === 'caseNaming')?.value
+  ) as CaseType | undefined;
+  const configCaseType = (
+      configuration?.generateOptions?.caseNaming
+  ) as CaseType | undefined;
+  const caseType = optionsCaseType || configCaseType || 'kebab-or-snake';
+
+  const inputName = inputs.find((option) => option.name === 'name');
+  const name = normalizeToCase(inputName?.value as string, caseType);
+
   const schematicOptions: SchematicOption[] = mapSchematicOptions(inputs);
-  schematicOptions.push(
-    new SchematicOption('language', configuration.language),
-  );
+  schematicOptions.push(new SchematicOption('name', name));
+  schematicOptions.push(new SchematicOption('caseNaming', caseType));
+  schematicOptions.push(new SchematicOption('language', configuration.language));
   const configurationProjects = configuration.projects;
 
   let sourceRoot = appName
@@ -128,9 +141,7 @@ 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),
-  );
+  schematicOptions.push(new SchematicOption('specFileSuffix', generateSpecFileSuffix));
   try {
     const schematicInput = inputs.find((input) => input.name === 'schematic');
     if (!schematicInput) {
@@ -144,8 +155,10 @@ const generateFiles = async (inputs: Input[]) => {
   }
 };
 
-const mapSchematicOptions = (inputs: Input[]): SchematicOption[] => {
-  const excludedInputNames = ['schematic', 'spec', 'flat', 'specFileSuffix'];
+const mapSchematicOptions = (
+  inputs: Input[],
+): SchematicOption[] => {
+  const excludedInputNames = ['name','schematic', 'spec', 'flat', 'specFileSuffix'];
   const options: SchematicOption[] = [];
   inputs.forEach((input) => {
     if (!excludedInputNames.includes(input.name) && input.value !== undefined) {

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", "kebab-or-snake" (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 });

commands/new.command.ts

@@ -32,6 +32,10 @@ export class NewCommand extends AbstractCommand {
         Collection.NESTJS,
       )
       .option('--strict', 'Enables strict mode in TypeScript.', false)
+      .option(
+            '--caseNaming [caseType]',
+            `Casing type for generated elements. Available options: "pascal", "camel", "kebab-or-snake" (default).`,
+      )
       .action(async (name: string, command: Command) => {
         const options: Input[] = [];
         const availableLanguages = ['js', 'ts', 'javascript', 'typescript'];
@@ -46,6 +50,11 @@ export class NewCommand extends AbstractCommand {
         });
         options.push({ name: 'collection', value: command.collection });
 
+        options.push({
+          name: 'caseNaming',
+          value: command.caseNaming,
+        });
+
         if (!!command.language) {
           const lowercasedLanguage = command.language.toLowerCase();
           const langMatch = availableLanguages.includes(lowercasedLanguage);

lib/configuration/configuration.ts

@@ -77,6 +77,7 @@ export interface GenerateOptions {
   spec?: boolean | Record<string, boolean>;
   flat?: boolean;
   specFileSuffix?: string;
+  caseNaming?: string;
 }
 
 export interface ProjectConfiguration {

lib/schematics/schematic.option.ts

@@ -1,4 +1,4 @@
-import { normalizeToKebabOrSnakeCase } from '../utils/formatting';
+import { normalizeToCase, formatString } from '../utils/formatting';
 
 export class SchematicOption {
   constructor(
@@ -7,7 +7,7 @@ export class SchematicOption {
   ) {}
 
   get normalizedName() {
-    return normalizeToKebabOrSnakeCase(this.name);
+    return normalizeToCase(this.name, 'kebab-or-snake');
   }
 
   public toCommandString(): string {
@@ -28,13 +28,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,
+        'kebab-or-snake',
+      ),
+    );
   }
 }

lib/utils/formatting.ts

@@ -1,7 +1,61 @@
+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 CaseType
+ * @returns formatted string
+ * @description normalizes input to a given case format.
+ */
+export const normalizeToCase = (
+  str: string,
+  caseType: CaseType,
+) => {
+  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':
+    default:
+      return normalizeToKebabOrSnakeCase(str);
+  }
+};
+
+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.1.18",
   "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 kebab to camel',
+      input: 'my-app',
+      caseType: 'camel',
+      expected: 'myApp',
+    },
+  ];
+
+  tests.forEach((test) => {
+    it(test.description, () => {
+      expect(normalizeToCase(test.input, test.caseType)).toEqual(test.expected);
+    });
+  });
+});