@mikemajesty/microservice-crud 6.0.14 → 6.0.16

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

@@ -1,56 +1,53 @@
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require("../../../../../textUtils")
 
 const getCoreUsecaseUpdateTest = (name) => `import { Test } from '@nestjs/testing';
 import { ZodIssue } from 'zod';
 
 import { ILoggerAdapter, LoggerModule } from '@/infra/logger';
-import { I${capitalizeFirstLetter(name)}UpdateAdapter } from '@/modules/${name}/adapter';
+import { I${dashToPascal(name)}UpdateAdapter } 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)}UpdateInput, ${capitalizeFirstLetter(name)}UpdateOutput, ${capitalizeFirstLetter(name)}UpdateUsecase } from '../${name}-update';
+import { ${dashToPascal(name)}Entity } from '../../entity/${name}';
+import { I${dashToPascal(name)}Repository } from '../../repository/${name}';
+import { ${dashToPascal(name)}UpdateInput, ${dashToPascal(name)}UpdateOutput, ${dashToPascal(name)}UpdateUsecase } from '../${name}-update';
 
-describe(${capitalizeFirstLetter(name)}UpdateUsecase.name, () => {
-  let usecase: I${capitalizeFirstLetter(name)}UpdateAdapter;
-  let repository: I${capitalizeFirstLetter(name)}Repository;
+describe(${dashToPascal(name)}UpdateUsecase.name, () => {
+  let usecase: I${dashToPascal(name)}UpdateAdapter;
+  let repository: I${dashToPascal(name)}Repository;
 
   beforeEach(async () => {
     const app = await Test.createTestingModule({
       imports: [LoggerModule],
       providers: [
         {
-          provide: I${capitalizeFirstLetter(name)}Repository,
+          provide: I${dashToPascal(name)}Repository,
           useValue: {}
         },
         {
-          provide: I${capitalizeFirstLetter(name)}UpdateAdapter,
-          useFactory: (${name}Repository: I${capitalizeFirstLetter(name)}Repository, logger: ILoggerAdapter) => {
-            return new ${capitalizeFirstLetter(name)}UpdateUsecase(${name}Repository, logger);
+          provide: I${dashToPascal(name)}UpdateAdapter,
+          useFactory: (${name}Repository: I${dashToPascal(name)}Repository, logger: ILoggerAdapter) => {
+            return new ${dashToPascal(name)}UpdateUsecase(${name}Repository, logger);
           },
-          inject: [I${capitalizeFirstLetter(name)}Repository, ILoggerAdapter]
+          inject: [I${dashToPascal(name)}Repository, ILoggerAdapter]
         }
       ]
     }).compile();
 
-    usecase = app.get(I${capitalizeFirstLetter(name)}UpdateAdapter);
-    repository = app.get(I${capitalizeFirstLetter(name)}Repository);
+    usecase = app.get(I${dashToPascal(name)}UpdateAdapter);
+    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)}UpdateInput),
+      () => usecase.execute({} as ${dashToPascal(name)}UpdateInput),
       (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)}UpdateInput = {
+  const input: ${dashToPascal(name)}UpdateInput = {
     id: TestUtils.getMockUUID()
   };
 
@@ -60,7 +57,7 @@ describe(${capitalizeFirstLetter(name)}UpdateUsecase.name, () => {
     await expect(usecase.execute(input)).rejects.toThrow(ApiNotFoundException);
   });
 
-  const ${name}: ${capitalizeFirstLetter(name)}UpdateOutput = new ${capitalizeFirstLetter(name)}Entity({
+  const ${name}: ${dashToPascal(name)}UpdateOutput = new ${dashToPascal(name)}Entity({
     id: TestUtils.getMockUUID(),
     name: 'dummy'
   });

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

@@ -1,7 +1,4 @@
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require("../../../../textUtils")
 
 const getCoreUsecaseCreate = (name) => `import { z } from 'zod';
 
@@ -11,25 +8,25 @@ import { ValidateSchema } from '@/utils/decorators';
 import { IUsecase } from '@/utils/usecase';
 import { UUIDUtils } from '@/utils/uuid';
 
-import { ${capitalizeFirstLetter(name)}Entity, ${capitalizeFirstLetter(name)}EntitySchema } from '../entity/${name}';
-import { I${capitalizeFirstLetter(name)}Repository } from '../repository/${name}';
+import { ${dashToPascal(name)}Entity, ${dashToPascal(name)}EntitySchema } from '../entity/${name}';
+import { I${dashToPascal(name)}Repository } from '../repository/${name}';
 
-export const ${capitalizeFirstLetter(name)}CreateSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
+export const ${dashToPascal(name)}CreateSchema = ${dashToPascal(name)}EntitySchema.pick({
   name: true
 });
 
-export type ${capitalizeFirstLetter(name)}CreateInput = z.infer<typeof ${capitalizeFirstLetter(name)}CreateSchema>;
-export type ${capitalizeFirstLetter(name)}CreateOutput = CreatedModel;
+export type ${dashToPascal(name)}CreateInput = z.infer<typeof ${dashToPascal(name)}CreateSchema>;
+export type ${dashToPascal(name)}CreateOutput = CreatedModel;
 
-export class ${capitalizeFirstLetter(name)}CreateUsecase implements IUsecase {
+export class ${dashToPascal(name)}CreateUsecase implements IUsecase {
   constructor(
-    private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository,
+    private readonly ${name}Repository: I${dashToPascal(name)}Repository,
     private readonly loggerService: ILoggerAdapter
   ) {}
 
-  @ValidateSchema(${capitalizeFirstLetter(name)}CreateSchema)
-  async execute(input: ${capitalizeFirstLetter(name)}CreateInput): Promise<${capitalizeFirstLetter(name)}CreateOutput> {
-    const entity = new ${capitalizeFirstLetter(name)}Entity({ id: UUIDUtils.create(), ...input });
+  @ValidateSchema(${dashToPascal(name)}CreateSchema)
+  async execute(input: ${dashToPascal(name)}CreateInput): Promise<${dashToPascal(name)}CreateOutput> {
+    const entity = new ${dashToPascal(name)}Entity({ id: UUIDUtils.create(), ...input });
 
     const ${name} = await this.${name}Repository.create(entity);
 

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

@@ -1,7 +1,4 @@
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require("../../../../textUtils")
 
 const getCoreUsecaseDelete = (name) => `import { z } from 'zod';
 
@@ -9,28 +6,28 @@ import { ValidateSchema } from '@/utils/decorators';
 import { ApiNotFoundException } from '@/utils/exception';
 import { IUsecase } from '@/utils/usecase';
 
-import { ${capitalizeFirstLetter(name)}Entity, ${capitalizeFirstLetter(name)}EntitySchema } from '../entity/${name}';
-import { I${capitalizeFirstLetter(name)}Repository } from '../repository/${name}';
+import { ${dashToPascal(name)}Entity, ${dashToPascal(name)}EntitySchema } from '../entity/${name}';
+import { I${dashToPascal(name)}Repository } from '../repository/${name}';
 
-export const ${capitalizeFirstLetter(name)}DeleteSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
+export const ${dashToPascal(name)}DeleteSchema = ${dashToPascal(name)}EntitySchema.pick({
   id: true
 });
 
-export type ${capitalizeFirstLetter(name)}DeleteInput = z.infer<typeof ${capitalizeFirstLetter(name)}DeleteSchema>;
-export type ${capitalizeFirstLetter(name)}DeleteOutput = ${capitalizeFirstLetter(name)}Entity;
+export type ${dashToPascal(name)}DeleteInput = z.infer<typeof ${dashToPascal(name)}DeleteSchema>;
+export type ${dashToPascal(name)}DeleteOutput = ${dashToPascal(name)}Entity;
 
-export class ${capitalizeFirstLetter(name)}DeleteUsecase implements IUsecase {
-  constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}
+export class ${dashToPascal(name)}DeleteUsecase implements IUsecase {
+  constructor(private readonly ${name}Repository: I${dashToPascal(name)}Repository) {}
 
-  @ValidateSchema(${capitalizeFirstLetter(name)}DeleteSchema)
-  async execute({ id }: ${capitalizeFirstLetter(name)}DeleteInput): Promise<${capitalizeFirstLetter(name)}DeleteOutput> {
+  @ValidateSchema(${dashToPascal(name)}DeleteSchema)
+  async execute({ id }: ${dashToPascal(name)}DeleteInput): Promise<${dashToPascal(name)}DeleteOutput> {
     const model = await this.${name}Repository.findById(id);
 
     if (!model) {
       throw new ApiNotFoundException('${name}NotFound');
     }
 
-    const ${name} = new ${capitalizeFirstLetter(name)}Entity(model);
+    const ${name} = new ${dashToPascal(name)}Entity(model);
 
     ${name}.deactivated();
 

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

@@ -1,7 +1,4 @@
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require("../../../../textUtils")
 
 const getCoreUsecaseGetById = (name) => `import { z } from 'zod';
 
@@ -9,27 +6,27 @@ import { ValidateSchema } from '@/utils/decorators';
 import { ApiNotFoundException } from '@/utils/exception';
 import { IUsecase } from '@/utils/usecase';
 
-import { ${capitalizeFirstLetter(name)}Entity, ${capitalizeFirstLetter(name)}EntitySchema } from '../entity/${name}';
-import { I${capitalizeFirstLetter(name)}Repository } from '../repository/${name}';
+import { ${dashToPascal(name)}Entity, ${dashToPascal(name)}EntitySchema } from '../entity/${name}';
+import { I${dashToPascal(name)}Repository } from '../repository/${name}';
 
-export const ${capitalizeFirstLetter(name)}GetByIdSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
+export const ${dashToPascal(name)}GetByIdSchema = ${dashToPascal(name)}EntitySchema.pick({
   id: true
 });
-export type ${capitalizeFirstLetter(name)}GetByIdInput = z.infer<typeof ${capitalizeFirstLetter(name)}GetByIdSchema>;
-export type ${capitalizeFirstLetter(name)}GetByIdOutput = ${capitalizeFirstLetter(name)}Entity;
+export type ${dashToPascal(name)}GetByIdInput = z.infer<typeof ${dashToPascal(name)}GetByIdSchema>;
+export type ${dashToPascal(name)}GetByIdOutput = ${dashToPascal(name)}Entity;
 
-export class ${capitalizeFirstLetter(name)}GetByIdUsecase implements IUsecase {
-  constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}
+export class ${dashToPascal(name)}GetByIdUsecase implements IUsecase {
+  constructor(private readonly ${name}Repository: I${dashToPascal(name)}Repository) {}
 
-  @ValidateSchema(${capitalizeFirstLetter(name)}GetByIdSchema)
-  async execute({ id }: ${capitalizeFirstLetter(name)}GetByIdInput): Promise<${capitalizeFirstLetter(name)}GetByIdOutput> {
+  @ValidateSchema(${dashToPascal(name)}GetByIdSchema)
+  async execute({ id }: ${dashToPascal(name)}GetByIdInput): Promise<${dashToPascal(name)}GetByIdOutput> {
     const ${name} = await this.${name}Repository.findById(id);
 
     if (!${name}) {
       throw new ApiNotFoundException('${name}NotFound');
     }
 
-    const entity = new ${capitalizeFirstLetter(name)}Entity(${name});
+    const entity = new ${dashToPascal(name)}Entity(${name});
 
     return entity;
   }

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

@@ -1,8 +1,5 @@
 const pluralize = require('pluralize')
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require('../../../../textUtils')
 
 const getCoreUsecaseList = (name) => `import { z } from 'zod';
 
@@ -12,23 +9,23 @@ import { SearchSchema } from '@/utils/search';
 import { SortSchema } from '@/utils/sort';
 import { IUsecase } from '@/utils/usecase';
 
-import { ${capitalizeFirstLetter(name)}Entity } from '../entity/${name}';
-import { I${capitalizeFirstLetter(name)}Repository } from '../repository/${name}';
+import { ${dashToPascal(name)}Entity } from '../entity/${name}';
+import { I${dashToPascal(name)}Repository } from '../repository/${name}';
 
-export const ${capitalizeFirstLetter(name)}ListSchema = z.intersection(PaginationSchema, SortSchema.merge(SearchSchema));
+export const ${dashToPascal(name)}ListSchema = z.intersection(PaginationSchema, SortSchema.merge(SearchSchema));
 
-export type ${capitalizeFirstLetter(name)}ListInput = PaginationInput<${capitalizeFirstLetter(name)}Entity>;
-export type ${capitalizeFirstLetter(name)}ListOutput = PaginationOutput<${capitalizeFirstLetter(name)}Entity>;
+export type ${dashToPascal(name)}ListInput = PaginationInput<${dashToPascal(name)}Entity>;
+export type ${dashToPascal(name)}ListOutput = PaginationOutput<${dashToPascal(name)}Entity>;
 
-export class ${capitalizeFirstLetter(name)}ListUsecase implements IUsecase {
-  constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}
+export class ${dashToPascal(name)}ListUsecase implements IUsecase {
+  constructor(private readonly ${name}Repository: I${dashToPascal(name)}Repository) {}
 
-  @ValidateSchema(${capitalizeFirstLetter(name)}ListSchema)
-  async execute(input: ${capitalizeFirstLetter(name)}ListInput): Promise<${capitalizeFirstLetter(name)}ListOutput> {
+  @ValidateSchema(${dashToPascal(name)}ListSchema)
+  async execute(input: ${dashToPascal(name)}ListInput): Promise<${dashToPascal(name)}ListOutput> {
     const ${pluralize(name)} = await this.${name}Repository.paginate(input);
 
     return {
-      docs: ${pluralize(name)}.docs.map((u) => new ${capitalizeFirstLetter(name)}Entity(u)),
+      docs: ${pluralize(name)}.docs.map((u) => new ${dashToPascal(name)}Entity(u)),
       limit: ${pluralize(name)}.limit,
       page: ${pluralize(name)}.page,
       total: ${pluralize(name)}.total

package/src/templates/mongo/core/use-cases/update.js

@@ -1,7 +1,4 @@
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require("../../../../textUtils")
 
 const getCoreUsecaseUpdate = (name) => `import { z } from 'zod';
 
@@ -10,33 +7,33 @@ import { ValidateSchema } from '@/utils/decorators';
 import { ApiNotFoundException } from '@/utils/exception';
 import { IUsecase } from '@/utils/usecase';
 
-import { ${capitalizeFirstLetter(name)}Entity, ${capitalizeFirstLetter(name)}EntitySchema } from '../entity/${name}';
-import { I${capitalizeFirstLetter(name)}Repository } from '../repository/${name}';
+import { ${dashToPascal(name)}Entity, ${dashToPascal(name)}EntitySchema } from '../entity/${name}';
+import { I${dashToPascal(name)}Repository } from '../repository/${name}';
 
-export const ${capitalizeFirstLetter(name)}UpdateSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
+export const ${dashToPascal(name)}UpdateSchema = ${dashToPascal(name)}EntitySchema.pick({
   id: true
-}).merge(${capitalizeFirstLetter(name)}EntitySchema.omit({ id: true }).partial());
+}).merge(${dashToPascal(name)}EntitySchema.omit({ id: true }).partial());
 
-export type ${capitalizeFirstLetter(name)}UpdateInput = Partial<z.infer<typeof ${capitalizeFirstLetter(name)}UpdateSchema>>;
-export type ${capitalizeFirstLetter(name)}UpdateOutput = ${capitalizeFirstLetter(name)}Entity;
+export type ${dashToPascal(name)}UpdateInput = Partial<z.infer<typeof ${dashToPascal(name)}UpdateSchema>>;
+export type ${dashToPascal(name)}UpdateOutput = ${dashToPascal(name)}Entity;
 
-export class ${capitalizeFirstLetter(name)}UpdateUsecase implements IUsecase {
+export class ${dashToPascal(name)}UpdateUsecase implements IUsecase {
   constructor(
-    private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository,
+    private readonly ${name}Repository: I${dashToPascal(name)}Repository,
     private readonly loggerService: ILoggerAdapter
   ) {}
 
-  @ValidateSchema(${capitalizeFirstLetter(name)}UpdateSchema)
-  async execute(input: ${capitalizeFirstLetter(name)}UpdateInput): Promise<${capitalizeFirstLetter(name)}UpdateOutput> {
+  @ValidateSchema(${dashToPascal(name)}UpdateSchema)
+  async execute(input: ${dashToPascal(name)}UpdateInput): Promise<${dashToPascal(name)}UpdateOutput> {
     const ${name} = await this.${name}Repository.findById(input.id as string);
 
     if (!${name}) {
       throw new ApiNotFoundException('${name}NotFound');
     }
 
-    const ${name}Found = new ${capitalizeFirstLetter(name)}Entity(${name});
+    const ${name}Found = new ${dashToPascal(name)}Entity(${name});
 
-    const entity = new ${capitalizeFirstLetter(name)}Entity({ ...${name}Found, ...input });
+    const entity = new ${dashToPascal(name)}Entity({ ...${name}Found, ...input });
 
     await this.${name}Repository.updateOne({ id: entity.id }, entity);
 
@@ -44,7 +41,7 @@ export class ${capitalizeFirstLetter(name)}UpdateUsecase implements IUsecase {
 
     const updated = await this.${name}Repository.findById(entity.id);
 
-    return new ${capitalizeFirstLetter(name)}Entity(updated as ${capitalizeFirstLetter(name)}Entity);
+    return new ${dashToPascal(name)}Entity(updated as ${dashToPascal(name)}Entity);
   }
 }
 `

package/src/templates/mongo/modules/adapter.js

@@ -1,33 +1,30 @@
+const { dashToPascal } = require("../../../textUtils")
 
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
-
-const getModuleAdapter = (name) => `import { ${capitalizeFirstLetter(name)}CreateInput, ${capitalizeFirstLetter(name)}CreateOutput } from '@/core/${name}/use-cases/${name}-create';
-import { ${capitalizeFirstLetter(name)}DeleteInput, ${capitalizeFirstLetter(name)}DeleteOutput } from '@/core/${name}/use-cases/${name}-delete';
-import { ${capitalizeFirstLetter(name)}GetByIdInput, ${capitalizeFirstLetter(name)}GetByIdOutput } from '@/core/${name}/use-cases/${name}-get-by-id';
-import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from '@/core/${name}/use-cases/${name}-list';
-import { ${capitalizeFirstLetter(name)}UpdateInput, ${capitalizeFirstLetter(name)}UpdateOutput } from '@/core/${name}/use-cases/${name}-update';
+const getModuleAdapter = (name) => `import { ${dashToPascal(name)}CreateInput, ${dashToPascal(name)}CreateOutput } from '@/core/${name}/use-cases/${name}-create';
+import { ${dashToPascal(name)}DeleteInput, ${dashToPascal(name)}DeleteOutput } from '@/core/${name}/use-cases/${name}-delete';
+import { ${dashToPascal(name)}GetByIdInput, ${dashToPascal(name)}GetByIdOutput } from '@/core/${name}/use-cases/${name}-get-by-id';
+import { ${dashToPascal(name)}ListInput, ${dashToPascal(name)}ListOutput } from '@/core/${name}/use-cases/${name}-list';
+import { ${dashToPascal(name)}UpdateInput, ${dashToPascal(name)}UpdateOutput } from '@/core/${name}/use-cases/${name}-update';
 import { IUsecase } from '@/utils/usecase';
 
-export abstract class I${capitalizeFirstLetter(name)}CreateAdapter implements IUsecase {
-  abstract execute(input: ${capitalizeFirstLetter(name)}CreateInput): Promise<${capitalizeFirstLetter(name)}CreateOutput>;
+export abstract class I${dashToPascal(name)}CreateAdapter implements IUsecase {
+  abstract execute(input: ${dashToPascal(name)}CreateInput): Promise<${dashToPascal(name)}CreateOutput>;
 }
 
-export abstract class I${capitalizeFirstLetter(name)}UpdateAdapter implements IUsecase {
-  abstract execute(input: ${capitalizeFirstLetter(name)}UpdateInput): Promise<${capitalizeFirstLetter(name)}UpdateOutput>;
+export abstract class I${dashToPascal(name)}UpdateAdapter implements IUsecase {
+  abstract execute(input: ${dashToPascal(name)}UpdateInput): Promise<${dashToPascal(name)}UpdateOutput>;
 }
 
-export abstract class I${capitalizeFirstLetter(name)}ListAdapter implements IUsecase {
-  abstract execute(input: ${capitalizeFirstLetter(name)}ListInput): Promise<${capitalizeFirstLetter(name)}ListOutput>;
+export abstract class I${dashToPascal(name)}ListAdapter implements IUsecase {
+  abstract execute(input: ${dashToPascal(name)}ListInput): Promise<${dashToPascal(name)}ListOutput>;
 }
 
-export abstract class I${capitalizeFirstLetter(name)}DeleteAdapter implements IUsecase {
-  abstract execute(input: ${capitalizeFirstLetter(name)}DeleteInput): Promise<${capitalizeFirstLetter(name)}DeleteOutput>;
+export abstract class I${dashToPascal(name)}DeleteAdapter implements IUsecase {
+  abstract execute(input: ${dashToPascal(name)}DeleteInput): Promise<${dashToPascal(name)}DeleteOutput>;
 }
 
-export abstract class I${capitalizeFirstLetter(name)}GetByIdAdapter implements IUsecase {
-  abstract execute(input: ${capitalizeFirstLetter(name)}GetByIdInput): Promise<${capitalizeFirstLetter(name)}GetByIdOutput>;
+export abstract class I${dashToPascal(name)}GetByIdAdapter implements IUsecase {
+  abstract execute(input: ${dashToPascal(name)}GetByIdInput): Promise<${dashToPascal(name)}GetByIdOutput>;
 }
 `
 

package/src/templates/mongo/modules/controller.js

@@ -1,47 +1,44 @@
 const pluralize = require('pluralize')
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+const { dashToPascal } = require('../../../textUtils')
 
 const getModuleController = (name) => `import { Controller, Delete, Get, Post, Put, Req } from '@nestjs/common';
 import { ApiBearerAuth, ApiBody, ApiParam, ApiQuery, ApiResponse, ApiTags } from '@nestjs/swagger';
 
-import { ${capitalizeFirstLetter(name)}CreateInput, ${capitalizeFirstLetter(name)}CreateOutput } from '@/core/${name}/use-cases/${name}-create';
-import { ${capitalizeFirstLetter(name)}DeleteInput, ${capitalizeFirstLetter(name)}DeleteOutput } from '@/core/${name}/use-cases/${name}-delete';
-import { ${capitalizeFirstLetter(name)}GetByIdInput, ${capitalizeFirstLetter(name)}GetByIdOutput } from '@/core/${name}/use-cases/${name}-get-by-id';
-import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from '@/core/${name}/use-cases/${name}-list';
-import { ${capitalizeFirstLetter(name)}UpdateInput, ${capitalizeFirstLetter(name)}UpdateOutput } from '@/core/${name}/use-cases/${name}-update';
+import { ${dashToPascal(name)}CreateInput, ${dashToPascal(name)}CreateOutput } from '@/core/${name}/use-cases/${name}-create';
+import { ${dashToPascal(name)}DeleteInput, ${dashToPascal(name)}DeleteOutput } from '@/core/${name}/use-cases/${name}-delete';
+import { ${dashToPascal(name)}GetByIdInput, ${dashToPascal(name)}GetByIdOutput } from '@/core/${name}/use-cases/${name}-get-by-id';
+import { ${dashToPascal(name)}ListInput, ${dashToPascal(name)}ListOutput } from '@/core/${name}/use-cases/${name}-list';
+import { ${dashToPascal(name)}UpdateInput, ${dashToPascal(name)}UpdateOutput } from '@/core/${name}/use-cases/${name}-update';
 import { ApiRequest } from '@/utils/request';
 import { SearchHttpSchema } from '@/utils/search';
 import { SortHttpSchema } from '@/utils/sort';
 
 import {
-  I${capitalizeFirstLetter(name)}CreateAdapter,
-  I${capitalizeFirstLetter(name)}DeleteAdapter,
-  I${capitalizeFirstLetter(name)}GetByIdAdapter,
-  I${capitalizeFirstLetter(name)}ListAdapter,
-  I${capitalizeFirstLetter(name)}UpdateAdapter
+  I${dashToPascal(name)}CreateAdapter,
+  I${dashToPascal(name)}DeleteAdapter,
+  I${dashToPascal(name)}GetByIdAdapter,
+  I${dashToPascal(name)}ListAdapter,
+  I${dashToPascal(name)}UpdateAdapter
 } from './adapter';
 import { SwaggerRequest, SwaggerResponse } from './swagger';
 
 @Controller('/${pluralize(name)}')
 @ApiTags('${pluralize(name)}')
 @ApiBearerAuth()
-export class ${capitalizeFirstLetter(name)}Controller {
+export class ${dashToPascal(name)}Controller {
   constructor(
-    private readonly ${name}CreateUsecase: I${capitalizeFirstLetter(name)}CreateAdapter,
-    private readonly ${name}UpdateUsecase: I${capitalizeFirstLetter(name)}UpdateAdapter,
-    private readonly ${name}DeleteUsecase: I${capitalizeFirstLetter(name)}DeleteAdapter,
-    private readonly ${name}ListUsecase: I${capitalizeFirstLetter(name)}ListAdapter,
-    private readonly ${name}GetByIdUsecase: I${capitalizeFirstLetter(name)}GetByIdAdapter
+    private readonly ${name}CreateUsecase: I${dashToPascal(name)}CreateAdapter,
+    private readonly ${name}UpdateUsecase: I${dashToPascal(name)}UpdateAdapter,
+    private readonly ${name}DeleteUsecase: I${dashToPascal(name)}DeleteAdapter,
+    private readonly ${name}ListUsecase: I${dashToPascal(name)}ListAdapter,
+    private readonly ${name}GetByIdUsecase: I${dashToPascal(name)}GetByIdAdapter
   ) {}
 
   @Post()
   @ApiResponse(SwaggerResponse.create[200])
   @ApiBody(SwaggerRequest.createBody)
-  async create(@Req() { body }: ApiRequest): Promise<${capitalizeFirstLetter(name)}CreateOutput> {
-    return this.${name}CreateUsecase.execute(body as ${capitalizeFirstLetter(name)}CreateInput);
+  async create(@Req() { body }: ApiRequest): Promise<${dashToPascal(name)}CreateOutput> {
+    return this.${name}CreateUsecase.execute(body as ${dashToPascal(name)}CreateInput);
   }
 
   @Put(':id')
@@ -49,8 +46,8 @@ export class ${capitalizeFirstLetter(name)}Controller {
   @ApiResponse(SwaggerResponse.update[404])
   @ApiBody(SwaggerRequest.updateBody)
   @ApiParam({ name: 'id', required: true })
-  async update(@Req() { body, params }: ApiRequest): Promise<${capitalizeFirstLetter(name)}UpdateOutput> {
-    return this.${name}UpdateUsecase.execute({ ...body, id: params.id } as ${capitalizeFirstLetter(name)}UpdateInput);
+  async update(@Req() { body, params }: ApiRequest): Promise<${dashToPascal(name)}UpdateOutput> {
+    return this.${name}UpdateUsecase.execute({ ...body, id: params.id } as ${dashToPascal(name)}UpdateInput);
   }
 
   @Get()
@@ -59,8 +56,8 @@ export class ${capitalizeFirstLetter(name)}Controller {
   @ApiQuery(SwaggerRequest.listQuery.sort)
   @ApiQuery(SwaggerRequest.listQuery.search)
   @ApiResponse(SwaggerResponse.list[200])
-  async list(@Req() { query }: ApiRequest): Promise<${capitalizeFirstLetter(name)}ListOutput> {
-    const input: ${capitalizeFirstLetter(name)}ListInput = {
+  async list(@Req() { query }: ApiRequest): Promise<${dashToPascal(name)}ListOutput> {
+    const input: ${dashToPascal(name)}ListInput = {
       sort: SortHttpSchema.parse(query.sort),
       search: SearchHttpSchema.parse(query.search),
       limit: Number(query.limit),
@@ -74,16 +71,16 @@ export class ${capitalizeFirstLetter(name)}Controller {
   @ApiParam({ name: 'id', required: true })
   @ApiResponse(SwaggerResponse.getById[200])
   @ApiResponse(SwaggerResponse.getById[404])
-  async getById(@Req() { params }: ApiRequest): Promise<${capitalizeFirstLetter(name)}GetByIdOutput> {
-    return await this.${name}GetByIdUsecase.execute(params as ${capitalizeFirstLetter(name)}GetByIdInput);
+  async getById(@Req() { params }: ApiRequest): Promise<${dashToPascal(name)}GetByIdOutput> {
+    return await this.${name}GetByIdUsecase.execute(params as ${dashToPascal(name)}GetByIdInput);
   }
 
   @Delete('/:id')
   @ApiParam({ name: 'id', required: true })
   @ApiResponse(SwaggerResponse.delete[200])
   @ApiResponse(SwaggerResponse.delete[404])
-  async delete(@Req() { params }: ApiRequest): Promise<${capitalizeFirstLetter(name)}DeleteOutput> {
-    return await this.${name}DeleteUsecase.execute(params as ${capitalizeFirstLetter(name)}DeleteInput);
+  async delete(@Req() { params }: ApiRequest): Promise<${dashToPascal(name)}DeleteOutput> {
+    return await this.${name}DeleteUsecase.execute(params as ${dashToPascal(name)}DeleteInput);
   }
 }
 `