@mikemajesty/microservice-crud 6.0.14 → 6.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikemajesty/microservice-crud",
-  "version": "6.0.14",
+  "version": "6.0.16",
   "description": "Monorepo CLI",
   "main": "src/cli.js",
   "scripts": {

package/src/cli.js

@@ -327,7 +327,7 @@ export async function cli(args) {
     return
   }
 
-  userInput.name = name
+  userInput.name = name.replace("_", "-").replace(" ", "-")
 
   const options = await parseArgumentsInoOptions(userInput)
 

package/src/templates/infra/adapter.js

@@ -1,12 +1,9 @@
+const { dashToPascal } = require("../../textUtils")
 
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
-
-const getAdapterInfra = (name) => `import { ${capitalizeFirstLetter(name)}GetInput, ${capitalizeFirstLetter(name)}GetOutput } from './service';
+const getAdapterInfra = (name) => `import { ${dashToPascal(name)}GetInput, ${dashToPascal(name)}GetOutput } from './service';
 
-export abstract class I${capitalizeFirstLetter(name)}Adapter {
-  abstract get(input: ${capitalizeFirstLetter(name)}GetInput): ${capitalizeFirstLetter(name)}GetOutput;
+export abstract class I${dashToPascal(name)}Adapter {
+  abstract get(input: ${dashToPascal(name)}GetInput): ${dashToPascal(name)}GetOutput;
 }
 `
 

package/src/templates/infra/module.js

@@ -1,24 +1,21 @@
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require("../../textUtils")
 
 const getModuleInfa = (name) => `import { Module } from '@nestjs/common';
 
-import { I${capitalizeFirstLetter(name)}Adapter } from './adapter';
-import { ${capitalizeFirstLetter(name)}Service } from './service';
+import { I${dashToPascal(name)}Adapter } from './adapter';
+import { ${dashToPascal(name)}Service } from './service';
 
 @Module({
   imports: [],
   providers: [
     {
-      provide: I${capitalizeFirstLetter(name)}Adapter,
-      useClass: ${capitalizeFirstLetter(name)}Service
+      provide: I${dashToPascal(name)}Adapter,
+      useClass: ${dashToPascal(name)}Service
     }
   ],
-  exports: [I${capitalizeFirstLetter(name)}Adapter]
+  exports: [I${dashToPascal(name)}Adapter]
 })
-export class ${capitalizeFirstLetter(name)}Module {}
+export class ${dashToPascal(name)}Module {}
 `
 
 module.exports = {

package/src/templates/infra/service.js

@@ -1,18 +1,15 @@
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require("../../textUtils")
 
 const getServiceInfra = (name) => `import { Injectable } from '@nestjs/common';
 
-import { I${capitalizeFirstLetter(name)}Adapter } from './adapter';
+import { I${dashToPascal(name)}Adapter } from './adapter';
 
-export type ${capitalizeFirstLetter(name)}GetInput = {};
-export type ${capitalizeFirstLetter(name)}GetOutput = {};
+export type ${dashToPascal(name)}GetInput = {};
+export type ${dashToPascal(name)}GetOutput = {};
 
 @Injectable()
-export class ${capitalizeFirstLetter(name)}Service implements I${capitalizeFirstLetter(name)}Adapter {
-  get(input: ${capitalizeFirstLetter(name)}GetInput): ${capitalizeFirstLetter(name)}GetOutput {
+export class ${dashToPascal(name)}Service implements I${dashToPascal(name)}Adapter {
+  get(input: ${dashToPascal(name)}GetInput): ${dashToPascal(name)}GetOutput {
     return input;
   }
 }

package/src/templates/libs/adapter.js

@@ -1,12 +1,9 @@
+const { dashToPascal } = require("../../textUtils")
 
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
-
-const getAdapterLib = (name) => `import { ${capitalizeFirstLetter(name)}Input, ${capitalizeFirstLetter(name)}Output } from './service';
+const getAdapterLib = (name) => `import { ${dashToPascal(name)}Input, ${dashToPascal(name)}Output } from './service';
 
-export abstract class I${capitalizeFirstLetter(name)}Adapter {
-  abstract get(input: ${capitalizeFirstLetter(name)}Input): ${capitalizeFirstLetter(name)}Output;
+export abstract class I${dashToPascal(name)}Adapter {
+  abstract get(input: ${dashToPascal(name)}Input): ${dashToPascal(name)}Output;
 }
 `
 

package/src/templates/libs/module.js

@@ -1,24 +1,21 @@
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require("../../textUtils")
 
 const getModuleLib = (name) => `import { Module } from '@nestjs/common';
 
-import { I${capitalizeFirstLetter(name)}Adapter } from './adapter';
-import { ${capitalizeFirstLetter(name)}Service } from './service';
+import { I${dashToPascal(name)}Adapter } from './adapter';
+import { ${dashToPascal(name)}Service } from './service';
 
 @Module({
   imports: [],
   providers: [
     {
-      provide: I${capitalizeFirstLetter(name)}Adapter,
-      useFactory: () => new ${capitalizeFirstLetter(name)}Service()
+      provide: I${dashToPascal(name)}Adapter,
+      useFactory: () => new ${dashToPascal(name)}Service()
     }
   ],
-  exports: [I${capitalizeFirstLetter(name)}Adapter]
+  exports: [I${dashToPascal(name)}Adapter]
 })
-export class ${capitalizeFirstLetter(name)}LibModule {}
+export class ${dashToPascal(name)}LibModule {}
 `
 
 module.exports = {

package/src/templates/libs/service.js

@@ -1,25 +1,22 @@
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require("../../textUtils")
 
 const getServiceLib = (name) => `import { Injectable } from '@nestjs/common';
 import { z } from 'zod';
 
 import { ValidateSchema } from '@/utils/decorators';
 
-import { I${capitalizeFirstLetter(name)}Adapter } from './adapter';
+import { I${dashToPascal(name)}Adapter } from './adapter';
 
-const ${capitalizeFirstLetter(name)}Schema = z.object({ name: z.string().trim() });
+const ${dashToPascal(name)}Schema = z.object({ name: z.string().trim() });
 
-export type ${capitalizeFirstLetter(name)}Input = z.infer<typeof ${capitalizeFirstLetter(name)}Schema>;
+export type ${dashToPascal(name)}Input = z.infer<typeof ${dashToPascal(name)}Schema>;
 
-export type ${capitalizeFirstLetter(name)}Output = string;
+export type ${dashToPascal(name)}Output = string;
 
 @Injectable()
-export class ${capitalizeFirstLetter(name)}Service implements I${capitalizeFirstLetter(name)}Adapter {
-  @ValidateSchema(${capitalizeFirstLetter(name)}Schema)
-  get({ name }: ${capitalizeFirstLetter(name)}Input): ${capitalizeFirstLetter(name)}Output {
+export class ${dashToPascal(name)}Service implements I${dashToPascal(name)}Adapter {
+  @ValidateSchema(${dashToPascal(name)}Schema)
+  get({ name }: ${dashToPascal(name)}Input): ${dashToPascal(name)}Output {
     return name;
   }
 }

package/src/templates/module/controller.js

@@ -1,9 +1,6 @@
 
 const pluralize = require('pluralize')
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require('../../textUtils')
 
 const getModuleControllerModule = (name) => `import { Controller, Get, Req } from '@nestjs/common';
 import { ApiResponse, ApiTags } from '@nestjs/swagger';
@@ -14,7 +11,7 @@ import { SwaggerResponse } from './swagger';
 
 @Controller('${pluralize(name)}')
 @ApiTags('${pluralize(name)}')
-export class ${capitalizeFirstLetter(name)}Controller {
+export class ${dashToPascal(name)}Controller {
   @Get()
   @ApiResponse(SwaggerResponse.get[200])
   async get(@Req() {}: ApiRequest): Promise<string> {

package/src/templates/module/module.js

@@ -1,16 +1,14 @@
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require("../../textUtils")
 
 const getModuleModule = (name) => `import { Module } from '@nestjs/common';
 
-import { ${capitalizeFirstLetter(name)}Controller } from './controller';
+import { ${dashToPascal(name)}Controller } from './controller';
 
 @Module({
   imports: [],
-  controllers: [${capitalizeFirstLetter(name)}Controller]
+  controllers: [${dashToPascal(name)}Controller]
 })
-export class ${capitalizeFirstLetter(name)}Module {}
+export class ${dashToPascal(name)}Module {}
 `
 
 module.exports = {

package/src/templates/mongo/core/entity/entity.js

@@ -1,7 +1,4 @@
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require("../../../../textUtils")
 
 const getCoreEntity = (name) => `import { z } from 'zod';
 
@@ -13,7 +10,7 @@ const CreatedAt = z.date().nullish();
 const UpdatedAt = z.date().nullish();
 const DeletedAt = z.date().nullish();
 
-export const ${capitalizeFirstLetter(name)}EntitySchema = z.object({
+export const ${dashToPascal(name)}EntitySchema = z.object({
   id: ID,
   name: Name,
   createdAt: CreatedAt,
@@ -21,12 +18,12 @@ export const ${capitalizeFirstLetter(name)}EntitySchema = z.object({
   deletedAt: DeletedAt
 });
 
-type ${capitalizeFirstLetter(name)} = z.infer<typeof ${capitalizeFirstLetter(name)}EntitySchema>;
+type ${dashToPascal(name)} = z.infer<typeof ${dashToPascal(name)}EntitySchema>;
 
-export class ${capitalizeFirstLetter(name)}Entity extends BaseEntity<${capitalizeFirstLetter(name)}Entity>(${capitalizeFirstLetter(name)}EntitySchema) {
+export class ${dashToPascal(name)}Entity extends BaseEntity<${dashToPascal(name)}Entity>(${dashToPascal(name)}EntitySchema) {
   name!: string;
 
-  constructor(entity: ${capitalizeFirstLetter(name)}) {
+  constructor(entity: ${dashToPascal(name)}) {
     super();
     Object.assign(this, this.validate(entity));
   }

package/src/templates/mongo/core/repository/repository.js

@@ -1,15 +1,12 @@
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require("../../../../textUtils")
 
 const getCoreRepository = (name) => `import { IRepository } from '@/infra/repository';
 
-import { ${capitalizeFirstLetter(name)}Entity } from '../entity/${name}';
-import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from '../use-cases/${name}-list';
+import { ${dashToPascal(name)}Entity } from '../entity/${name}';
+import { ${dashToPascal(name)}ListInput, ${dashToPascal(name)}ListOutput } from '../use-cases/${name}-list';
 
-export abstract class I${capitalizeFirstLetter(name)}Repository extends IRepository<${capitalizeFirstLetter(name)}Entity> {
-  abstract paginate(input: ${capitalizeFirstLetter(name)}ListInput): Promise<${capitalizeFirstLetter(name)}ListOutput>;
+export abstract class I${dashToPascal(name)}Repository extends IRepository<${dashToPascal(name)}Entity> {
+  abstract paginate(input: ${dashToPascal(name)}ListInput): Promise<${dashToPascal(name)}ListOutput>;
 }
 `
 

package/src/templates/mongo/core/use-cases/__tests__/create.spec.js

@@ -1,28 +1,25 @@
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require("../../../../../textUtils")
 
 const getCoreUsecaseCreateTest = (name) => `import { Test } from '@nestjs/testing';
 import { ZodIssue } from 'zod';
 
 import { ILoggerAdapter } from '@/infra/logger';
-import { I${capitalizeFirstLetter(name)}CreateAdapter } from '@/modules/${name}/adapter';
+import { I${dashToPascal(name)}CreateAdapter } from '@/modules/${name}/adapter';
 import { TestUtils } from '@/utils/tests';
 
-import { ${capitalizeFirstLetter(name)}Entity } from '../../entity/${name}';
-import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
-import { ${capitalizeFirstLetter(name)}CreateInput, ${capitalizeFirstLetter(name)}CreateOutput, ${capitalizeFirstLetter(name)}CreateUsecase } from '../${name}-create';
+import { ${dashToPascal(name)}Entity } from '../../entity/${name}';
+import { I${dashToPascal(name)}Repository } from '../../repository/${name}';
+import { ${dashToPascal(name)}CreateInput, ${dashToPascal(name)}CreateOutput, ${dashToPascal(name)}CreateUsecase } from '../${name}-create';
 
-describe(${capitalizeFirstLetter(name)}CreateUsecase.name, () => {
-  let usecase: I${capitalizeFirstLetter(name)}CreateAdapter;
-  let repository: I${capitalizeFirstLetter(name)}Repository;
+describe(${dashToPascal(name)}CreateUsecase.name, () => {
+  let usecase: I${dashToPascal(name)}CreateAdapter;
+  let repository: I${dashToPascal(name)}Repository;
 
   beforeEach(async () => {
     const app = await Test.createTestingModule({
       providers: [
         {
-          provide: I${capitalizeFirstLetter(name)}Repository,
+          provide: I${dashToPascal(name)}Repository,
           useValue: {}
         },
         {
@@ -32,34 +29,34 @@ describe(${capitalizeFirstLetter(name)}CreateUsecase.name, () => {
           }
         },
         {
-          provide: I${capitalizeFirstLetter(name)}CreateAdapter,
-          useFactory: (${name}Repository: I${capitalizeFirstLetter(name)}Repository, logger: ILoggerAdapter) => {
-            return new ${capitalizeFirstLetter(name)}CreateUsecase(${name}Repository, logger);
+          provide: I${dashToPascal(name)}CreateAdapter,
+          useFactory: (${name}Repository: I${dashToPascal(name)}Repository, logger: ILoggerAdapter) => {
+            return new ${dashToPascal(name)}CreateUsecase(${name}Repository, logger);
           },
-          inject: [I${capitalizeFirstLetter(name)}Repository, ILoggerAdapter]
+          inject: [I${dashToPascal(name)}Repository, ILoggerAdapter]
         }
       ]
     }).compile();
 
-    usecase = app.get(I${capitalizeFirstLetter(name)}CreateAdapter);
-    repository = app.get(I${capitalizeFirstLetter(name)}Repository);
+    usecase = app.get(I${dashToPascal(name)}CreateAdapter);
+    repository = app.get(I${dashToPascal(name)}Repository);
   });
 
   test('when no input is specified, should expect an error', async () => {
     await TestUtils.expectZodError(
-      () => usecase.execute({} as ${capitalizeFirstLetter(name)}CreateInput),
+      () => usecase.execute({} as ${dashToPascal(name)}CreateInput),
       (issues: ZodIssue[]) => {
-        expect(issues).toEqual([{ message: 'Required', path: ${capitalizeFirstLetter(name)}Entity.nameOf('name') }]);
+        expect(issues).toEqual([{ message: 'Required', path: ${dashToPascal(name)}Entity.nameOf('name') }]);
       }
     );
   });
 
-  const input: ${capitalizeFirstLetter(name)}CreateInput = {
+  const input: ${dashToPascal(name)}CreateInput = {
     name: 'name'
   };
 
   test('when ${name} created successfully, should expect a ${name}', async () => {
-    const output: ${capitalizeFirstLetter(name)}CreateOutput = { created: true, id: TestUtils.getMockUUID() };
+    const output: ${dashToPascal(name)}CreateOutput = { created: true, id: TestUtils.getMockUUID() };
     repository.findOne = jest.fn().mockResolvedValue(null);
     repository.create = jest.fn().mockResolvedValue(output);
 

package/src/templates/mongo/core/use-cases/__tests__/delete.spec.js

@@ -1,55 +1,52 @@
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require("../../../../../textUtils")
 
 const getCoreUsecaseDeleteTest = (name) => `import { Test } from '@nestjs/testing';
 import { ZodIssue } from 'zod';
 
-import { I${capitalizeFirstLetter(name)}DeleteAdapter } from '@/modules/${name}/adapter';
+import { I${dashToPascal(name)}DeleteAdapter } from '@/modules/${name}/adapter';
 import { ApiNotFoundException } from '@/utils/exception';
 import { TestUtils } from '@/utils/tests';
 
-import { ${capitalizeFirstLetter(name)}Entity } from '../../entity/${name}';
-import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
-import { ${capitalizeFirstLetter(name)}DeleteInput, ${capitalizeFirstLetter(name)}DeleteUsecase } from '../${name}-delete';
+import { ${dashToPascal(name)}Entity } from '../../entity/${name}';
+import { I${dashToPascal(name)}Repository } from '../../repository/${name}';
+import { ${dashToPascal(name)}DeleteInput, ${dashToPascal(name)}DeleteUsecase } from '../${name}-delete';
 
-describe(${capitalizeFirstLetter(name)}DeleteUsecase.name, () => {
-  let usecase: I${capitalizeFirstLetter(name)}DeleteAdapter;
-  let repository: I${capitalizeFirstLetter(name)}Repository;
+describe(${dashToPascal(name)}DeleteUsecase.name, () => {
+  let usecase: I${dashToPascal(name)}DeleteAdapter;
+  let repository: I${dashToPascal(name)}Repository;
 
   beforeEach(async () => {
     const app = await Test.createTestingModule({
       imports: [],
       providers: [
         {
-          provide: I${capitalizeFirstLetter(name)}Repository,
+          provide: I${dashToPascal(name)}Repository,
           useValue: {}
         },
         {
-          provide: I${capitalizeFirstLetter(name)}DeleteAdapter,
-          useFactory: (${name}Repository: I${capitalizeFirstLetter(name)}Repository) => {
-            return new ${capitalizeFirstLetter(name)}DeleteUsecase(${name}Repository);
+          provide: I${dashToPascal(name)}DeleteAdapter,
+          useFactory: (${name}Repository: I${dashToPascal(name)}Repository) => {
+            return new ${dashToPascal(name)}DeleteUsecase(${name}Repository);
           },
-          inject: [I${capitalizeFirstLetter(name)}Repository]
+          inject: [I${dashToPascal(name)}Repository]
         }
       ]
     }).compile();
 
-    usecase = app.get(I${capitalizeFirstLetter(name)}DeleteAdapter);
-    repository = app.get(I${capitalizeFirstLetter(name)}Repository);
+    usecase = app.get(I${dashToPascal(name)}DeleteAdapter);
+    repository = app.get(I${dashToPascal(name)}Repository);
   });
 
   test('when no input is specified, should expect an error', async () => {
     await TestUtils.expectZodError(
-      () => usecase.execute({} as ${capitalizeFirstLetter(name)}DeleteInput),
+      () => usecase.execute({} as ${dashToPascal(name)}DeleteInput),
       (issues: ZodIssue[]) => {
-        expect(issues).toEqual([{ message: 'Required', path: ${capitalizeFirstLetter(name)}Entity.nameOf('id') }]);
+        expect(issues).toEqual([{ message: 'Required', path: ${dashToPascal(name)}Entity.nameOf('id') }]);
       }
     );
   });
 
-  const input: ${capitalizeFirstLetter(name)}DeleteInput = {
+  const input: ${dashToPascal(name)}DeleteInput = {
     id: TestUtils.getMockUUID()
   };
 
@@ -59,7 +56,7 @@ describe(${capitalizeFirstLetter(name)}DeleteUsecase.name, () => {
     await expect(usecase.execute(input)).rejects.toThrow(ApiNotFoundException);
   });
 
-  const ${name} = new ${capitalizeFirstLetter(name)}Entity({
+  const ${name} = new ${dashToPascal(name)}Entity({
     id: TestUtils.getMockUUID(),
     name: 'dummy'
   });

package/src/templates/mongo/core/use-cases/__tests__/get-by-id.spec.js

@@ -1,55 +1,52 @@
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require("../../../../../textUtils")
 
 const getCoreUsecaseGetByIdTest = (name) => `import { Test } from '@nestjs/testing';
 import { ZodIssue } from 'zod';
 
-import { I${capitalizeFirstLetter(name)}GetByIdAdapter } from '@/modules/${name}/adapter';
+import { I${dashToPascal(name)}GetByIdAdapter } from '@/modules/${name}/adapter';
 import { ApiNotFoundException } from '@/utils/exception';
 import { TestUtils } from '@/utils/tests';
 
-import { ${capitalizeFirstLetter(name)}Entity } from '../../entity/${name}';
-import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
-import { ${capitalizeFirstLetter(name)}GetByIdInput, ${capitalizeFirstLetter(name)}GetByIdUsecase } from '../${name}-get-by-id';
+import { ${dashToPascal(name)}Entity } from '../../entity/${name}';
+import { I${dashToPascal(name)}Repository } from '../../repository/${name}';
+import { ${dashToPascal(name)}GetByIdInput, ${dashToPascal(name)}GetByIdUsecase } from '../${name}-get-by-id';
 
-describe(${capitalizeFirstLetter(name)}GetByIdUsecase.name, () => {
-  let usecase: I${capitalizeFirstLetter(name)}GetByIdAdapter;
-  let repository: I${capitalizeFirstLetter(name)}Repository;
+describe(${dashToPascal(name)}GetByIdUsecase.name, () => {
+  let usecase: I${dashToPascal(name)}GetByIdAdapter;
+  let repository: I${dashToPascal(name)}Repository;
 
   beforeEach(async () => {
     const app = await Test.createTestingModule({
       imports: [],
       providers: [
         {
-          provide: I${capitalizeFirstLetter(name)}Repository,
+          provide: I${dashToPascal(name)}Repository,
           useValue: {}
         },
         {
-          provide: I${capitalizeFirstLetter(name)}GetByIdAdapter,
-          useFactory: (${name}Repository: I${capitalizeFirstLetter(name)}Repository) => {
-            return new ${capitalizeFirstLetter(name)}GetByIdUsecase(${name}Repository);
+          provide: I${dashToPascal(name)}GetByIdAdapter,
+          useFactory: (${name}Repository: I${dashToPascal(name)}Repository) => {
+            return new ${dashToPascal(name)}GetByIdUsecase(${name}Repository);
           },
-          inject: [I${capitalizeFirstLetter(name)}Repository]
+          inject: [I${dashToPascal(name)}Repository]
         }
       ]
     }).compile();
 
-    usecase = app.get(I${capitalizeFirstLetter(name)}GetByIdAdapter);
-    repository = app.get(I${capitalizeFirstLetter(name)}Repository);
+    usecase = app.get(I${dashToPascal(name)}GetByIdAdapter);
+    repository = app.get(I${dashToPascal(name)}Repository);
   });
 
   test('when no input is specified, should expect an error', async () => {
     await TestUtils.expectZodError(
-      () => usecase.execute({} as ${capitalizeFirstLetter(name)}GetByIdInput),
+      () => usecase.execute({} as ${dashToPascal(name)}GetByIdInput),
       (issues: ZodIssue[]) => {
-        expect(issues).toEqual([{ message: 'Required', path: ${capitalizeFirstLetter(name)}Entity.nameOf('id') }]);
+        expect(issues).toEqual([{ message: 'Required', path: ${dashToPascal(name)}Entity.nameOf('id') }]);
       }
     );
   });
 
-  const input: ${capitalizeFirstLetter(name)}GetByIdInput = {
+  const input: ${dashToPascal(name)}GetByIdInput = {
     id: TestUtils.getMockUUID()
   };
 
@@ -59,7 +56,7 @@ describe(${capitalizeFirstLetter(name)}GetByIdUsecase.name, () => {
     await expect(usecase.execute(input)).rejects.toThrow(ApiNotFoundException);
   });
 
-  const ${name} = new ${capitalizeFirstLetter(name)}Entity({
+  const ${name} = new ${dashToPascal(name)}Entity({
     id: '61cc35f3-03d9-4b7f-9c63-59f32b013ef5',
     name: 'dummy'
   });

package/src/templates/mongo/core/use-cases/__tests__/list.spec.js

@@ -1,49 +1,46 @@
 
 const pluralize = require('pluralize')
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require('../../../../../textUtils')
 
 const getCoreUsecaseListTest = (name) => `import { Test } from '@nestjs/testing';
 import { ZodIssue } from 'zod';
 
-import { I${capitalizeFirstLetter(name)}ListAdapter } from '@/modules/${name}/adapter';
+import { I${dashToPascal(name)}ListAdapter } from '@/modules/${name}/adapter';
 import { TestUtils } from '@/utils/tests';
 
-import { ${capitalizeFirstLetter(name)}Entity } from '../../entity/${name}';
-import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
-import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput, ${capitalizeFirstLetter(name)}ListUsecase } from '../${name}-list';
+import { ${dashToPascal(name)}Entity } from '../../entity/${name}';
+import { I${dashToPascal(name)}Repository } from '../../repository/${name}';
+import { ${dashToPascal(name)}ListInput, ${dashToPascal(name)}ListOutput, ${dashToPascal(name)}ListUsecase } from '../${name}-list';
 
-describe(${capitalizeFirstLetter(name)}ListUsecase.name, () => {
-  let usecase: I${capitalizeFirstLetter(name)}ListAdapter;
-  let repository: I${capitalizeFirstLetter(name)}Repository;
+describe(${dashToPascal(name)}ListUsecase.name, () => {
+  let usecase: I${dashToPascal(name)}ListAdapter;
+  let repository: I${dashToPascal(name)}Repository;
 
   beforeEach(async () => {
     const app = await Test.createTestingModule({
       imports: [],
       providers: [
         {
-          provide: I${capitalizeFirstLetter(name)}Repository,
+          provide: I${dashToPascal(name)}Repository,
           useValue: {}
         },
         {
-          provide: I${capitalizeFirstLetter(name)}ListAdapter,
-          useFactory: (${name}Repository: I${capitalizeFirstLetter(name)}Repository) => {
-            return new ${capitalizeFirstLetter(name)}ListUsecase(${name}Repository);
+          provide: I${dashToPascal(name)}ListAdapter,
+          useFactory: (${name}Repository: I${dashToPascal(name)}Repository) => {
+            return new ${dashToPascal(name)}ListUsecase(${name}Repository);
           },
-          inject: [I${capitalizeFirstLetter(name)}Repository]
+          inject: [I${dashToPascal(name)}Repository]
         }
       ]
     }).compile();
 
-    usecase = app.get(I${capitalizeFirstLetter(name)}ListAdapter);
-    repository = app.get(I${capitalizeFirstLetter(name)}Repository);
+    usecase = app.get(I${dashToPascal(name)}ListAdapter);
+    repository = app.get(I${dashToPascal(name)}Repository);
   });
 
   test('when sort input is specified, should expect an error', async () => {
     await TestUtils.expectZodError(
-      () => usecase.execute({} as ${capitalizeFirstLetter(name)}ListInput),
+      () => usecase.execute({} as ${dashToPascal(name)}ListInput),
       (issues: ZodIssue[]) => {
         expect(issues).toEqual([
           { message: 'Required', path: 'sort' },
@@ -53,9 +50,9 @@ describe(${capitalizeFirstLetter(name)}ListUsecase.name, () => {
     );
   });
 
-  const input: ${capitalizeFirstLetter(name)}ListInput = { limit: 1, page: 1, search: {}, sort: { createdAt: -1 } };
+  const input: ${dashToPascal(name)}ListInput = { limit: 1, page: 1, search: {}, sort: { createdAt: -1 } };
 
-  const ${name} = new ${capitalizeFirstLetter(name)}Entity({
+  const ${name} = new ${dashToPascal(name)}Entity({
     id: TestUtils.getMockUUID(),
     name: 'dummy',
     createdAt: new Date(),
@@ -65,7 +62,7 @@ describe(${capitalizeFirstLetter(name)}ListUsecase.name, () => {
   const ${pluralize(name)} = [${name}];
 
   test('when ${name} are found, should expect an ${name} list', async () => {
-    const output: ${capitalizeFirstLetter(name)}ListOutput = { docs: ${pluralize(name)}, page: 1, limit: 1, total: 1 };
+    const output: ${dashToPascal(name)}ListOutput = { docs: ${pluralize(name)}, page: 1, limit: 1, total: 1 };
     repository.paginate = jest.fn().mockResolvedValue(output);
 
     await expect(usecase.execute(input)).resolves.toEqual({
@@ -77,7 +74,7 @@ describe(${capitalizeFirstLetter(name)}ListUsecase.name, () => {
   });
 
   test('when ${name} not found, should expect an empty list', async () => {
-    const output: ${capitalizeFirstLetter(name)}ListOutput = { docs: [], page: 1, limit: 1, total: 1 };
+    const output: ${dashToPascal(name)}ListOutput = { docs: [], page: 1, limit: 1, total: 1 };
     repository.paginate = jest.fn().mockResolvedValue(output);
 
     await expect(usecase.execute(input)).resolves.toEqual(output);