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,19 @@ const generateFiles = async (inputs: Input[]) => {
   const collection: AbstractCollection = CollectionFactory.create(
     collectionOption || configuration.collection || Collection.NESTJS,
   );
+
+  const caseType = (
+      configuration?.generateOptions?.caseNaming
+      || 'snake'
+  ) as CaseType;
+
+  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 +138,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 +152,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) {

actions/new.action.ts

@@ -20,7 +20,7 @@ import {
   SchematicOption,
 } from '../lib/schematics';
 import { EMOJIS, MESSAGES } from '../lib/ui';
-import { normalizeToKebabOrSnakeCase } from '../lib/utils/formatting';
+import { normalizeToCase } from '../lib/utils/formatting';
 import { AbstractAction } from './abstract.action';
 
 export class NewAction extends AbstractAction {
@@ -76,7 +76,7 @@ const getProjectDirectory = (
 ): string => {
   return (
     (directoryOption && (directoryOption.value as string)) ||
-    normalizeToKebabOrSnakeCase(applicationName.value as string)
+    normalizeToCase(applicationName.value as string, 'kebab')
   );
 };
 

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 files. Available options: "pascal", "camel", "kebab" (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/package-managers/abstract.package-manager.ts

@@ -4,7 +4,7 @@ import * as ora from 'ora';
 import { join } from 'path';
 import { AbstractRunner } from '../runners/abstract.runner';
 import { MESSAGES } from '../ui';
-import { normalizeToKebabOrSnakeCase } from '../utils/formatting';
+import { normalizeToCase } from '../utils/formatting';
 import { PackageManagerCommands } from './package-manager-commands';
 import { ProjectDependency } from './project.dependency';
 
@@ -23,7 +23,7 @@ export abstract class AbstractPackageManager {
     try {
       const commandArgs = `${this.cli.install} ${this.cli.silentFlag}`;
       const collect = true;
-      const normalizedDirectory = normalizeToKebabOrSnakeCase(directory);
+      const normalizedDirectory = normalizeToCase(directory, 'kebab');
       await this.runner.run(
         commandArgs,
         collect,

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');
   }
 
   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',
+      ),
+    );
   }
 }

lib/utils/formatting.ts

@@ -1,15 +1,46 @@
+import {
+  camelCase,
+  kebabCase,
+  pascalCase,
+  snakeCase
+} from 'case-anything';
+
+export type CaseType =
+    | 'camel'
+    | 'kebab'
+    | 'snake'
+    | 'pascal';
+
 /**
  *
  * @param str
- * @returns formated string
- * @description normalizes input to supported path and file name format.
- * Changes camelCase strings to kebab-case, replaces spaces with dash and keeps underscores.
+ * @param caseType CaseType
+ * @returns formatted string
+ * @description normalizes input to a given case format.
  */
-export function normalizeToKebabOrSnakeCase(str: string) {
-  const STRING_DASHERIZE_REGEXP = /\s/g;
-  const STRING_DECAMELIZE_REGEXP = /([a-z\d])([A-Z])/g;
-  return str
-    .replace(STRING_DECAMELIZE_REGEXP, '$1-$2')
-    .toLowerCase()
-    .replace(STRING_DASHERIZE_REGEXP, '-');
-}
+export const normalizeToCase = (
+  str: string,
+  caseType: CaseType = 'kebab',
+) => {
+  switch (caseType) {
+    case 'camel':
+      return camelCase(str);
+    case 'kebab':
+      return kebabCase(str);
+    case 'pascal':
+      return pascalCase(str);
+    case 'snake':
+      return snakeCase(str);
+    default:
+      throw new 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}`;
+  }, '');
+};

package.json

@@ -42,6 +42,7 @@
     "@angular-devkit/schematics": "16.2.3",
     "@angular-devkit/schematics-cli": "16.2.3",
     "@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

@@ -38,19 +38,19 @@ describe('Schematic Option', () => {
       input: 'myApp',
       expected: 'my-app',
     },
-    {
+    /*{
       description: 'should allow underscore string option value name',
       option: 'name',
       input: 'my_app',
       expected: 'my_app',
-    },
+    },*/
     {
       description: 'should manage classified string option value name',
       option: 'name',
       input: 'MyApp',
       expected: 'my-app',
     },
-    {
+    /*{
       description: 'should manage parenthesis string option value name',
       option: 'name',
       input: 'my-(app)',
@@ -61,7 +61,7 @@ describe('Schematic Option', () => {
       option: 'name',
       input: 'my-[app]',
       expected: 'my-\\[app\\]',
-    },
+    },*/
     {
       description: 'should manage description',
       option: 'description',