@mikemajesty/microservice-crud 0.1.8 → 0.2.8

package/package.json

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

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

@@ -8,14 +8,16 @@ const getCoreUsecaseCreateTest = (name) => `import { Test } from '@nestjs/testin
 import { ILoggerAdapter } from '@/infra/logger';
 import { I${capitalizeFirstLetter(name)}CreateAdapter } from '@/modules/${name}/adapter';
 import { ApiInternalServerException } from '@/utils/exception';
-import { expectZodError } from '@/utils/tests/tests';;
+import { expectZodError, generateUUID } from '@/utils/tests/tests';;
 
 import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
-import { ${capitalizeFirstLetter(name)}CreateInput, ${capitalizeFirstLetter(name)}CreateUsecase } from '../${name}-create';
+import { ${capitalizeFirstLetter(name)}CreateInput, ${capitalizeFirstLetter(name)}CreateOutput, ${capitalizeFirstLetter(name)}CreateUsecase } from '../${name}-create';
+import { ${capitalizeFirstLetter(name)}Entity } from '../../entity/${name}';
 
-const ${name} = {
-  name: 'dummy'
-} as ${capitalizeFirstLetter(name)}CreateInput;
+const successInput: ${capitalizeFirstLetter(name)}CreateInput = {
+  name: "name"
+}
+const failureInput: ${capitalizeFirstLetter(name)}CreateInput = {}
 
 describe('${capitalizeFirstLetter(name)}CreateUsecase', () => {
   let usecase: I${capitalizeFirstLetter(name)}CreateAdapter;
@@ -36,8 +38,8 @@ describe('${capitalizeFirstLetter(name)}CreateUsecase', () => {
         },
         {
           provide: I${capitalizeFirstLetter(name)}CreateAdapter,
-          useFactory: (${name}Repository: I${capitalizeFirstLetter(name)}Repository, logger: ILoggerAdapter) => {
-            return new ${capitalizeFirstLetter(name)}CreateUsecase(${name}Repository, logger);
+          useFactory: (birdRepository: I${capitalizeFirstLetter(name)}Repository, logger: ILoggerAdapter) => {
+            return new ${capitalizeFirstLetter(name)}CreateUsecase(birdRepository, logger);
           },
           inject: [I${capitalizeFirstLetter(name)}Repository, ILoggerAdapter]
         }
@@ -48,32 +50,36 @@ describe('${capitalizeFirstLetter(name)}CreateUsecase', () => {
     repository = app.get(I${capitalizeFirstLetter(name)}Repository);
   });
 
-  test('should throw error when invalid parameters', async () => {
+  test('when no input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute({}),
+      () => usecase.execute(failureInput),
       (issues) => {
-        expect(issues).toEqual([{ message: 'Required', path: 'name' }]);
+        expect(issues).toEqual([{ message: 'Required', path: ${capitalizeFirstLetter(name)}Entity.nameof('name') }]);
       }
     );
   });
 
-  test('should create successfully', async () => {
+  test('when ${name} created successfully, should expect a ${name} that has been created', async () => {
+    const createOutput: ${capitalizeFirstLetter(name)}CreateOutput = { created: true, id: generateUUID() }
+
     repository.findOne = jest.fn().mockResolvedValue(null);
-    repository.create = jest.fn().mockResolvedValue(${name});
+    repository.create = jest.fn().mockResolvedValue(createOutput);
     repository.startSession = jest.fn().mockResolvedValue({
       commitTransaction: jest.fn()
     });
-    await expect(usecase.execute(${name})).resolves.toEqual(${name});
+
+    await expect(usecase.execute(successInput)).resolves.toEqual(createOutput);
   });
 
-  test('should throw error when create exception', async () => {
+  test('when transaction throw an error, should expect an error', async () => {
     repository.findOne = jest.fn().mockResolvedValue(null);
-    repository.create = jest.fn().mockRejectedValue(new ApiInternalServerException('error'));
+    repository.create = jest.fn().mockRejectedValue(new ApiInternalServerException());
     repository.startSession = jest.fn().mockResolvedValue({
       commitTransaction: jest.fn(),
       abortTransaction: jest.fn()
     });
-    await expect(usecase.execute(${name})).rejects.toThrow(ApiInternalServerException);
+
+    await expect(usecase.execute(successInput)).rejects.toThrow(ApiInternalServerException);
   });
 });
 `

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

@@ -11,12 +11,13 @@ import { expectZodError, generateUUID } from '@/utils/tests/tests';;
 
 import { ${capitalizeFirstLetter(name)}Entity } from '../../entity/${name}';
 import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
-import { ${capitalizeFirstLetter(name)}DeleteUsecase } from '../${name}-delete';
+import { ${capitalizeFirstLetter(name)}DeleteInput, ${capitalizeFirstLetter(name)}DeleteOutput, ${capitalizeFirstLetter(name)}DeleteUsecase } from '../${name}-delete';
 
-const ${name}Response = {
-  id: generateUUID(),
-  name: 'dummy'
-} as ${capitalizeFirstLetter(name)}Entity;
+const successInput: ${capitalizeFirstLetter(name)}DeleteInput = {
+  id: generateUUID()
+};
+
+const failureInput: ${capitalizeFirstLetter(name)}DeleteInput = {};
 
 describe('${capitalizeFirstLetter(name)}DeleteUsecase', () => {
   let usecase: I${capitalizeFirstLetter(name)}DeleteAdapter;
@@ -32,8 +33,8 @@ describe('${capitalizeFirstLetter(name)}DeleteUsecase', () => {
         },
         {
           provide: I${capitalizeFirstLetter(name)}DeleteAdapter,
-          useFactory: (${name}Repository: I${capitalizeFirstLetter(name)}Repository) => {
-            return new ${capitalizeFirstLetter(name)}DeleteUsecase(${name}Repository);
+          useFactory: (birdRepository: I${capitalizeFirstLetter(name)}Repository) => {
+            return new ${capitalizeFirstLetter(name)}DeleteUsecase(birdRepository);
           },
           inject: [I${capitalizeFirstLetter(name)}Repository]
         }
@@ -44,25 +45,32 @@ describe('${capitalizeFirstLetter(name)}DeleteUsecase', () => {
     repository = app.get(I${capitalizeFirstLetter(name)}Repository);
   });
 
-  test('should throw error when invalid parameters', async () => {
+  test('when no input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute({ id: 'uuid' }),
+      () => usecase.execute(failureInput),
       (issues) => {
-        expect(issues).toEqual([{ message: 'Invalid uuid', path: 'id' }]);
+        expect(issues).toEqual([{ message: 'Required', path: ${capitalizeFirstLetter(name)}Entity.nameof("id") }]);
       }
     );
   });
 
-  test('should throw error when ${name} not found', async () => {
+  test('when ${name} not found, should expect an error', async () => {
     repository.findById = jest.fn().mockResolvedValue(null);
-    await expect(usecase.execute({ id: generateUUID() })).rejects.toThrowError(ApiNotFoundException);
+
+    await expect(usecase.execute(successInput)).rejects.toThrowError(ApiNotFoundException);
   });
 
-  test('should delete successfully', async () => {
-    repository.findById = jest.fn().mockResolvedValue(${name}Response);
+  test('when ${name} deleted successfully, should expect a ${name} that has been deleted', async () => {
+    const findByIdOutput: ${capitalizeFirstLetter(name)}DeleteOutput = new ${capitalizeFirstLetter(name)}Entity({
+      id: generateUUID(),
+      name: 'dummy'
+    })
+
+    repository.findById = jest.fn().mockResolvedValue(findByIdOutput);
     repository.updateOne = jest.fn();
-    await expect(usecase.execute({ id: generateUUID() })).resolves.toEqual({
-      ...${name}Response,
+
+    await expect(usecase.execute(successInput)).resolves.toEqual({
+      ...findByIdOutput,
       deletedAt: expect.any(Date)
     });
   });

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

@@ -11,12 +11,14 @@ import { expectZodError, generateUUID } from '@/utils/tests/tests';;
 
 import { ${capitalizeFirstLetter(name)}Entity } from '../../entity/${name}';
 import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
-import { ${capitalizeFirstLetter(name)}GetByIdUsecase } from '../${name}-getByID';
+import { ${capitalizeFirstLetter(name)}GetByIDInput, ${capitalizeFirstLetter(name)}GetByIDOutput, ${capitalizeFirstLetter(name)}GetByIdUsecase } from '../${name}-getByID';
+
+const successInput: ${capitalizeFirstLetter(name)}GetByIDInput = {
+  id: generateUUID()
+};
+
+const failureInput: ${capitalizeFirstLetter(name)}GetByIDInput = {};
 
-const ${name}Response = {
-  id: '61cc35f3-03d9-4b7f-9c63-59f32b013ef5',
-  name: 'dummy'
-} as ${capitalizeFirstLetter(name)}Entity;
 
 describe('${capitalizeFirstLetter(name)}GetByIdUsecase', () => {
   let usecase: I${capitalizeFirstLetter(name)}GetByIDAdapter;
@@ -32,8 +34,8 @@ describe('${capitalizeFirstLetter(name)}GetByIdUsecase', () => {
         },
         {
           provide: I${capitalizeFirstLetter(name)}GetByIDAdapter,
-          useFactory: (${name}Repository: I${capitalizeFirstLetter(name)}Repository) => {
-            return new ${capitalizeFirstLetter(name)}GetByIdUsecase(${name}Repository);
+          useFactory: (birdRepository: I${capitalizeFirstLetter(name)}Repository) => {
+            return new ${capitalizeFirstLetter(name)}GetByIdUsecase(birdRepository);
           },
           inject: [I${capitalizeFirstLetter(name)}Repository]
         }
@@ -44,23 +46,30 @@ describe('${capitalizeFirstLetter(name)}GetByIdUsecase', () => {
     repository = app.get(I${capitalizeFirstLetter(name)}Repository);
   });
 
-  test('should throw error when invalid parameters', async () => {
+  test('when no input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute({}),
+      () => usecase.execute(failureInput),
       (issues) => {
-        expect(issues).toEqual([{ message: 'Required', path: 'id' }]);
+        expect(issues).toEqual([{ message: 'Required', path: ${capitalizeFirstLetter(name)}Entity.nameof("id") }]);
       }
     );
   });
 
-  test('should throw error when ${name} not found', async () => {
+  test('when ${name} not found, should expect an error', async () => {
     repository.findById = jest.fn().mockResolvedValue(null);
-    await expect(usecase.execute({ id: generateUUID() })).rejects.toThrowError(ApiNotFoundException);
+
+    await expect(usecase.execute(successInput)).rejects.toThrowError(ApiNotFoundException);
   });
 
-  test('should getById successfully', async () => {
-    repository.findById = jest.fn().mockResolvedValue(${name}Response);
-    await expect(usecase.execute({ id: generateUUID() })).resolves.toEqual(${name}Response);
+  test('when ${name} found, should expect a ${name} that has been found', async () => {
+    const findByIdOutput: ${capitalizeFirstLetter(name)}GetByIDOutput = new ${capitalizeFirstLetter(name)}Entity({
+      id: '61cc35f3-03d9-4b7f-9c63-59f32b013ef5',
+      name: 'dummy'
+    });
+
+    repository.findById = jest.fn().mockResolvedValue(findByIdOutput);
+
+    await expect(usecase.execute(successInput)).resolves.toEqual(findByIdOutput);
   });
 });
 `

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

@@ -10,14 +10,11 @@ import { expectZodError, generateUUID } from '@/utils/tests/tests';;
 
 import { ${capitalizeFirstLetter(name)}Entity } from '../../entity/${name}';
 import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
-import { ${capitalizeFirstLetter(name)}ListUsecase } from '../${name}-list';
+import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput, ${capitalizeFirstLetter(name)}ListUsecase } from '../${name}-list';
 
-const ${name}Response = {
-  id: generateUUID(),
-  name: 'dummy',
-  createdAt: new Date(),
-  updatedAt: new Date()
-} as ${capitalizeFirstLetter(name)}Entity;
+const successInput: ${capitalizeFirstLetter(name)}ListInput = { limit: 1, page: 1, search: {}, sort: { createdAt: -1 } }
+
+const failureInput: ${capitalizeFirstLetter(name)}ListInput = { search: null, sort: null, limit: 10, page: 1 };
 
 describe('${capitalizeFirstLetter(name)}ListUsecase', () => {
   let usecase: I${capitalizeFirstLetter(name)}ListAdapter;
@@ -33,8 +30,8 @@ describe('${capitalizeFirstLetter(name)}ListUsecase', () => {
         },
         {
           provide: I${capitalizeFirstLetter(name)}ListAdapter,
-          useFactory: (${name}Repository: I${capitalizeFirstLetter(name)}Repository) => {
-            return new ${capitalizeFirstLetter(name)}ListUsecase(${name}Repository);
+          useFactory: (birdRepository: I${capitalizeFirstLetter(name)}Repository) => {
+            return new ${capitalizeFirstLetter(name)}ListUsecase(birdRepository);
           },
           inject: [I${capitalizeFirstLetter(name)}Repository]
         }
@@ -45,31 +42,42 @@ describe('${capitalizeFirstLetter(name)}ListUsecase', () => {
     repository = app.get(I${capitalizeFirstLetter(name)}Repository);
   });
 
-  test('should throw error when invalid parameters', async () => {
+  test('when sort input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute({ search: null, sort: null, limit: 10, page: 1 }),
+      () => usecase.execute(failureInput),
       (issues) => {
         expect(issues).toEqual([{ message: 'Expected object, received null', path: 'sort' }]);
       }
     );
   });
 
-  test('should list successfully', async () => {
-    const response = { docs: [${name}Response], page: 1, limit: 1, total: 1 };
-    repository.paginate = jest.fn().mockResolvedValue(response);
-    await expect(usecase.execute({ limit: 1, page: 1, search: {}, sort: { createdAt: -1 } })).resolves.toEqual({
-      docs: [${name}Response],
+  test('when ${name} are found, should expect an ${name} list', async () => {
+    const doc = new ${capitalizeFirstLetter(name)}Entity({
+      id: generateUUID(),
+      name: 'dummy',
+      createdAt: new Date(),
+      updatedAt: new Date()
+    });
+
+    const paginateOutput: ${capitalizeFirstLetter(name)}ListOutput = { docs: [doc], page: 1, limit: 1, total: 1 };
+
+    repository.paginate = jest.fn().mockResolvedValue(paginateOutput);
+
+    await expect(usecase.execute(successInput)).resolves.toEqual({
+      docs: [doc],
       page: 1,
       limit: 1,
       total: 1
     });
   });
 
-  test('should list successfully when docs is empty', async () => {
-    const response = { docs: [], page: 1, limit: 1, total: 1 };
-    repository.paginate = jest.fn().mockResolvedValue(response);
-    await expect(usecase.execute({ limit: 1, page: 1, search: {}, sort: { createdAt: -1 } })).resolves.toEqual(
-      response
+  test('when ${name} not found, should expect an empty list', async () => {
+    const paginateOutput: ${capitalizeFirstLetter(name)}ListOutput = { docs: [], page: 1, limit: 1, total: 1 };
+
+    repository.paginate = jest.fn().mockResolvedValue(paginateOutput);
+
+    await expect(usecase.execute(successInput)).resolves.toEqual(
+      paginateOutput
     );
   });
 });

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

@@ -12,18 +12,14 @@ import { expectZodError, generateUUID } from '@/utils/tests/tests';;
 
 import { ${capitalizeFirstLetter(name)}Entity } from '../../entity/${name}';
 import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
-import { ${capitalizeFirstLetter(name)}UpdateInput } from '../${name}-update';
+import { ${capitalizeFirstLetter(name)}UpdateInput, ${capitalizeFirstLetter(name)}UpdateOutput } from '../${name}-update';
 import { ${capitalizeFirstLetter(name)}UpdateUsecase } from '../${name}-update';
 
-const ${name}Body = {
-  id: generateUUID(),
-  name: 'dummy'
-} as ${capitalizeFirstLetter(name)}UpdateInput;
+const successInput: ${capitalizeFirstLetter(name)}UpdateInput = {
+  id: generateUUID()
+};
 
-const ${name}Response = {
-  id: generateUUID(),
-  name: 'dummy'
-} as ${capitalizeFirstLetter(name)}Entity;
+const failureInput: ${capitalizeFirstLetter(name)}UpdateInput = {};
 
 describe('${capitalizeFirstLetter(name)}UpdateUsecase', () => {
   let usecase: I${capitalizeFirstLetter(name)}UpdateAdapter;
@@ -39,8 +35,8 @@ describe('${capitalizeFirstLetter(name)}UpdateUsecase', () => {
         },
         {
           provide: I${capitalizeFirstLetter(name)}UpdateAdapter,
-          useFactory: (${name}Repository: I${capitalizeFirstLetter(name)}Repository, logger: ILoggerAdapter) => {
-            return new ${capitalizeFirstLetter(name)}UpdateUsecase(${name}Repository, logger);
+          useFactory: (birdRepository: I${capitalizeFirstLetter(name)}Repository, logger: ILoggerAdapter) => {
+            return new ${capitalizeFirstLetter(name)}UpdateUsecase(birdRepository, logger);
           },
           inject: [I${capitalizeFirstLetter(name)}Repository, ILoggerAdapter]
         }
@@ -51,24 +47,31 @@ describe('${capitalizeFirstLetter(name)}UpdateUsecase', () => {
     repository = app.get(I${capitalizeFirstLetter(name)}Repository);
   });
 
-  test('should throw error when invalid parameters', async () => {
+  test('when no input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute({}),
+      () => usecase.execute(failureInput),
       (issues) => {
-        expect(issues).toEqual([{ message: 'Required', path: 'id' }]);
+        expect(issues).toEqual([{ message: 'Required', path: ${capitalizeFirstLetter(name)}Entity.nameof("id") }]);
       }
     );
   });
 
-  test('should update successfully', async () => {
-    repository.findById = jest.fn().mockResolvedValue(${name}Response);
-    repository.updateOne = jest.fn().mockResolvedValue(null);
-    await expect(usecase.execute(${name}Body)).resolves.toEqual(${name}Response);
+  test('when ${name} not found, should expect an error', async () => {
+    repository.findById = jest.fn().mockResolvedValue(null);
+
+    await expect(usecase.execute(successInput)).rejects.toThrowError(ApiNotFoundException);
   });
 
-  test('should throw error when ${name} not found', async () => {
-    repository.findById = jest.fn().mockResolvedValue(null);
-    await expect(usecase.execute(${name}Body)).rejects.toThrowError(ApiNotFoundException);
+  test('when ${name} updated successfully, should expect an ${name} that has been updated', async () => {
+    const findByIdOutput: ${capitalizeFirstLetter(name)}UpdateOutput = new ${capitalizeFirstLetter(name)}Entity({
+      id: generateUUID(),
+      name: 'dummy'
+    });
+
+    repository.findById = jest.fn().mockResolvedValue(findByIdOutput);
+    repository.updateOne = jest.fn().mockResolvedValue(null);
+
+    await expect(usecase.execute(successInput)).resolves.toEqual(findByIdOutput);
   });
 });
 `

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

@@ -17,7 +17,7 @@ export const ${capitalizeFirstLetter(name)}CreateSchema = ${capitalizeFirstLette
 });
 
 export type ${capitalizeFirstLetter(name)}CreateInput = z.infer<typeof ${capitalizeFirstLetter(name)}CreateSchema>;
-export type ${capitalizeFirstLetter(name)}CreateOutput = Promise<CreatedModel>;
+export type ${capitalizeFirstLetter(name)}CreateOutput = CreatedModel;
 
 export class ${capitalizeFirstLetter(name)}CreateUsecase {
   constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository, private readonly loggerServide: ILoggerAdapter) {}

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

@@ -16,7 +16,7 @@ export const ${capitalizeFirstLetter(name)}DeleteSchema = ${capitalizeFirstLette
 });
 
 export type ${capitalizeFirstLetter(name)}DeleteInput = z.infer<typeof ${capitalizeFirstLetter(name)}DeleteSchema>;
-export type ${capitalizeFirstLetter(name)}DeleteOutput = Promise<${capitalizeFirstLetter(name)}Entity>;
+export type ${capitalizeFirstLetter(name)}DeleteOutput = ${capitalizeFirstLetter(name)}Entity;
 
 export class ${capitalizeFirstLetter(name)}DeleteUsecase {
   constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}

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

@@ -15,7 +15,7 @@ export const ${capitalizeFirstLetter(name)}GetByIdSchema = ${capitalizeFirstLett
   id: true
 });
 export type ${capitalizeFirstLetter(name)}GetByIDInput = z.infer<typeof ${capitalizeFirstLetter(name)}GetByIdSchema>;
-export type ${capitalizeFirstLetter(name)}GetByIDOutput = Promise<${capitalizeFirstLetter(name)}Entity>;
+export type ${capitalizeFirstLetter(name)}GetByIDOutput = ${capitalizeFirstLetter(name)}Entity;
 
 export class ${capitalizeFirstLetter(name)}GetByIdUsecase {
   constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}

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

@@ -17,7 +17,7 @@ import { I${capitalizeFirstLetter(name)}Repository } from '../repository/${name}
 export const ${capitalizeFirstLetter(name)}ListSchema = z.intersection(PaginationSchema, SortSchema.merge(SearchSchema));
 
 export type ${capitalizeFirstLetter(name)}ListInput = PaginationInput<${capitalizeFirstLetter(name)}Entity>;
-export type ${capitalizeFirstLetter(name)}ListOutput = Promise<PaginationOutput<${capitalizeFirstLetter(name)}Entity>>;
+export type ${capitalizeFirstLetter(name)}ListOutput = PaginationOutput<${capitalizeFirstLetter(name)}Entity>;
 
 export class ${capitalizeFirstLetter(name)}ListUsecase {
   constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}

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

@@ -17,7 +17,7 @@ export const ${capitalizeFirstLetter(name)}UpdateSchema = ${capitalizeFirstLette
 }).merge(${capitalizeFirstLetter(name)}EntitySchema.omit({ id: true }).partial());
 
 export type ${capitalizeFirstLetter(name)}UpdateInput = Partial<z.infer<typeof ${capitalizeFirstLetter(name)}UpdateSchema>>;
-export type ${capitalizeFirstLetter(name)}UpdateOutput = Promise<${capitalizeFirstLetter(name)}Entity>;
+export type ${capitalizeFirstLetter(name)}UpdateOutput = ${capitalizeFirstLetter(name)}Entity;
 
 export class ${capitalizeFirstLetter(name)}UpdateUsecase {
   constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository, private readonly loggerServide: ILoggerAdapter) {}

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

@@ -27,10 +27,10 @@ import {
 } from './adapter';
 import { SwagggerRequest, SwagggerResponse } from './swagger';
 
-@Controller()
-@ApiTags('${name}')
+@Controller('/${pluralize(name)}')
+@ApiTags('${pluralize(name)}')
 @ApiBearerAuth()
-@Roles(UserRole.BACKOFFICE)
+@Roles(UserRole.USER)
 export class ${capitalizeFirstLetter(name)}Controller {
   constructor(
     private readonly ${name}CreateUsecase: I${capitalizeFirstLetter(name)}CreateAdapter,
@@ -40,28 +40,28 @@ export class ${capitalizeFirstLetter(name)}Controller {
     private readonly ${name}GetByIDUsecase: I${capitalizeFirstLetter(name)}GetByIDAdapter
   ) {}
 
-  @Post('/${pluralize(name)}')
+  @Post()
   @ApiResponse(SwagggerResponse.create[200])
   @ApiBody(SwagggerRequest.createBody)
-  async create(@Req() { body }: ApiRequest): ${capitalizeFirstLetter(name)}CreateOutput {
+  async create(@Req() { body }: ApiRequest): Promise<${capitalizeFirstLetter(name)}CreateOutput> {
     return this.${name}CreateUsecase.execute(body as ${capitalizeFirstLetter(name)}CreateInput);
   }
 
-  @Put('/${pluralize(name)}')
+  @Put()
   @ApiResponse(SwagggerResponse.update[200])
   @ApiResponse(SwagggerResponse.update[404])
   @ApiBody(SwagggerRequest.updateBody)
-  async update(@Req() { body }: ApiRequest): ${capitalizeFirstLetter(name)}UpdateOutput {
+  async update(@Req() { body }: ApiRequest): Promise<${capitalizeFirstLetter(name)}UpdateOutput> {
     return this.${name}UpdateUsecase.execute(body as ${capitalizeFirstLetter(name)}UpdateInput);
   }
 
-  @Get('/${pluralize(name)}')
+  @Get()
   @ApiQuery(SwagggerRequest.listQuery.pagination.limit)
   @ApiQuery(SwagggerRequest.listQuery.pagination.page)
   @ApiQuery(SwagggerRequest.listQuery.sort)
   @ApiQuery(SwagggerRequest.listQuery.search)
   @ApiResponse(SwagggerResponse.list[200])
-  async list(@Req() { query }: ApiRequest): ${capitalizeFirstLetter(name)}ListOutput {
+  async list(@Req() { query }: ApiRequest): Promise<${capitalizeFirstLetter(name)}ListOutput> {
     const input: ${capitalizeFirstLetter(name)}ListInput = {
       sort: SortHttpSchema.parse(query.sort),
       search: SearchHttpSchema.parse(query.search),
@@ -72,19 +72,19 @@ export class ${capitalizeFirstLetter(name)}Controller {
     return await this.${name}ListUsecase.execute(input);
   }
 
-  @Get('/${pluralize(name)}/:id')
+  @Get('/:id')
   @ApiParam({ name: 'id', required: true })
   @ApiResponse(SwagggerResponse.getByID[200])
   @ApiResponse(SwagggerResponse.getByID[404])
-  async getById(@Req() { params }: ApiRequest): ${capitalizeFirstLetter(name)}GetByIDOutput {
+  async getById(@Req() { params }: ApiRequest): Promise<${capitalizeFirstLetter(name)}GetByIDOutput> {
     return await this.${name}GetByIDUsecase.execute(params as ${capitalizeFirstLetter(name)}GetByIDInput);
   }
 
-  @Delete('/${pluralize(name)}/:id')
+  @Delete('/:id')
   @ApiParam({ name: 'id', required: true })
   @ApiResponse(SwagggerResponse.delete[200])
   @ApiResponse(SwagggerResponse.delete[404])
-  async delete(@Req() { params }: ApiRequest): ${capitalizeFirstLetter(name)}DeleteOutput {
+  async delete(@Req() { params }: ApiRequest): Promise<${capitalizeFirstLetter(name)}DeleteOutput> {
     return await this.${name}DeleteUsecase.execute(params as ${capitalizeFirstLetter(name)}DeleteInput);
   }
 }

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

@@ -1,26 +1,36 @@
 const pluralize = require('pluralize')
 
-const getModuleSwagger = (name) => `import { CreatedModel } from '@/infra/repository/types';
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+
+const getModuleSwagger = (name) => `import { ${capitalizeFirstLetter(name)}Entity } from '@/core/${name}/entity/${name}';
+import { ${capitalizeFirstLetter(name)}CreateOutput } from '@/core/${name}/use-cases/${name}-create';
+import { ${capitalizeFirstLetter(name)}DeleteOutput } from '@/core/${name}/use-cases/${name}-delete';
+import { ${capitalizeFirstLetter(name)}GetByIDOutput } from '@/core/${name}/use-cases/${name}-getByID';
+import { ${capitalizeFirstLetter(name)}ListOutput } from '@/core/${name}/use-cases/${name}-list';
+import { ${capitalizeFirstLetter(name)}UpdateOutput } from '@/core/${name}/use-cases/${name}-update';
 import { Swagger } from '@/utils/docs/swagger';
 
-const entity = {
+const input = new ${capitalizeFirstLetter(name)}Entity({
   name: '<name>'
-};
+});
 
-const entityFull = { ...entity, updatedAt: '<updatedAt>', createdAt: '<createdAt>', deletedAt: '<deletedAt>' };
+const output = new ${capitalizeFirstLetter(name)}Entity({ ...input, updatedAt: new Date(), createdAt: new Date(), deletedAt: null });
 
 export const SwagggerResponse = {
   create: {
     200: Swagger.defaultResponseJSON({
       status: 200,
-      json: { created: true, id: '<uuid>' } as CreatedModel,
+      json: { created: true, id: '<uuid>' } as ${capitalizeFirstLetter(name)}CreateOutput,
       description: '${name} created.'
     })
   },
   update: {
     200: Swagger.defaultResponseJSON({
       status: 200,
-      json: entityFull,
+      json: output as ${capitalizeFirstLetter(name)}UpdateOutput,
       description: '${name} updated.'
     }),
     404: Swagger.defaultResponseError({
@@ -33,7 +43,7 @@ export const SwagggerResponse = {
   getByID: {
     200: Swagger.defaultResponseJSON({
       status: 200,
-      json: entityFull,
+      json: output as ${capitalizeFirstLetter(name)}GetByIDOutput,
       description: '${name} found.'
     }),
     404: Swagger.defaultResponseError({
@@ -46,12 +56,12 @@ export const SwagggerResponse = {
   delete: {
     200: Swagger.defaultResponseJSON({
       status: 200,
-      json: entityFull,
+      json: output as ${capitalizeFirstLetter(name)}DeleteOutput,
       description: '${name} found.'
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/${pluralize(name)}s/:id',
+      route: 'api/${pluralize(name)}/:id',
       message: '${name}NotFound',
       description: '${name} not found.'
     })
@@ -59,15 +69,15 @@ export const SwagggerResponse = {
   list: {
     200: Swagger.defaultResponseJSON({
       status: 200,
-      json: { docs: { docs: [entityFull], page: 1, limit: 1, total: 1 } },
+      json: { docs: [output], page: 1, limit: 1, total: 1 } as ${capitalizeFirstLetter(name)}ListOutput,
       description: '${name} created.'
     })
   }
 };
 
 export const SwagggerRequest = {
-  createBody: Swagger.defaultRequestJSON({ ...entity, id: undefined }),
-  updateBody: Swagger.defaultRequestJSON({ ...entity, id: '<id>' }),
+  createBody: Swagger.defaultRequestJSON({ ...input, id: undefined } as ${capitalizeFirstLetter(name)}Entity),
+  updateBody: Swagger.defaultRequestJSON({ ...input, id: '<id>' } as ${capitalizeFirstLetter(name)}Entity),
   listQuery: {
     pagination: {
       limit: Swagger.defaultApiQueryOptions({ example: 10, name: 'limit', required: false }),

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

@@ -8,10 +8,17 @@ const getCoreUsecaseCreateTest = (name) => `import { Test } from '@nestjs/testin
 import { ILoggerAdapter } from '@/infra/logger';
 import { I${capitalizeFirstLetter(name)}CreateAdapter } from '@/modules/${name}/adapter';
 import { ApiInternalServerException } from '@/utils/exception';
-import { expectZodError } from '@/utils/tests/tests';;
+import { expectZodError, generateUUID } from '@/utils/tests/tests';
 
+import { ${capitalizeFirstLetter(name)}Entity } from '../../entity/${name}';
 import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
-import { ${capitalizeFirstLetter(name)}CreateUsecase } from '../${name}-create';
+import { ${capitalizeFirstLetter(name)}CreateInput, ${capitalizeFirstLetter(name)}CreateOutput, ${capitalizeFirstLetter(name)}CreateUsecase } from '../${name}-create';
+
+const successInput: ${capitalizeFirstLetter(name)}CreateInput = {
+  name: 'dummy'
+};
+
+const failureInput: ${capitalizeFirstLetter(name)}CreateInput = {};
 
 describe('${capitalizeFirstLetter(name)}CreateUsecase', () => {
   let usecase: I${capitalizeFirstLetter(name)}CreateAdapter;
@@ -44,32 +51,34 @@ describe('${capitalizeFirstLetter(name)}CreateUsecase', () => {
     repository = app.get(I${capitalizeFirstLetter(name)}Repository);
   });
 
-  test('should throw error when invalid parameters', async () => {
+  test('when no input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute({}),
+      () => usecase.execute(failureInput),
       (issues) => {
-        expect(issues).toEqual([{ message: 'Required', path: 'name' }]);
+        expect(issues).toEqual([{ message: 'Required', path: ${capitalizeFirstLetter(name)}Entity.nameof('name') }]);
       }
     );
   });
 
-  test('should ${name} create successfully', async () => {
-    const ${name} = { name: 'dummy' };
-    repository.create = jest.fn().mockResolvedValue(${name});
+  test('when ${name} created successfully, should expect a ${name} that has been created', async () => {
+    const createOutput: ${capitalizeFirstLetter(name)}CreateOutput = { created: true, id: generateUUID() };
+
+    repository.create = jest.fn().mockResolvedValue(createOutput);
     repository.startSession = jest.fn().mockResolvedValue({
       commit: jest.fn()
     });
-    await expect(usecase.execute(${name})).resolves.toEqual(${name});
+
+    await expect(usecase.execute(successInput)).resolves.toEqual(createOutput);
   });
 
-  test('should throw error when create exception', async () => {
-    const ${name} = { name: 'dummy' };
-    repository.create = jest.fn().mockRejectedValue(new ApiInternalServerException('error'));
+  test('when transaction throw an error, should expect an error', async () => {
     repository.startSession = jest.fn().mockResolvedValue({
       commit: jest.fn(),
       rollback: jest.fn()
     });
-    await expect(usecase.execute(${name})).rejects.toThrow(ApiInternalServerException);
+    repository.create = jest.fn().mockRejectedValue(new ApiInternalServerException());
+
+    await expect(usecase.execute(successInput)).rejects.toThrow(ApiInternalServerException);
   });
 });
 `

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

@@ -5,18 +5,19 @@ function capitalizeFirstLetter(string) {
 
 const getCoreUsecaseDeleteTest = (name) => `import { Test } from '@nestjs/testing';
 
-import { ${capitalizeFirstLetter(name)}DeleteUsecase } from '@/core/${name}/use-cases/${name}-delete';
+import { ${capitalizeFirstLetter(name)}DeleteInput, ${capitalizeFirstLetter(name)}DeleteOutput, ${capitalizeFirstLetter(name)}DeleteUsecase } from '@/core/${name}/use-cases/${name}-delete';
 import { I${capitalizeFirstLetter(name)}DeleteAdapter } from '@/modules/${name}/adapter';
 import { ApiNotFoundException } from '@/utils/exception';
-import { expectZodError, generateUUID } from '@/utils/tests/tests';;
+import { expectZodError, generateUUID } from '@/utils/tests/tests';
 
 import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
 import { ${capitalizeFirstLetter(name)}Entity } from './../../entity/${name}';
 
-const ${name}Response = {
-  id: generateUUID(),
-  name: 'dummy'
-} as ${capitalizeFirstLetter(name)}Entity;
+const successInput: ${capitalizeFirstLetter(name)}DeleteInput = {
+  id: generateUUID()
+};
+
+const failureInput: ${capitalizeFirstLetter(name)}DeleteInput = {};
 
 describe('${capitalizeFirstLetter(name)}DeleteUsecase', () => {
   let usecase: I${capitalizeFirstLetter(name)}DeleteAdapter;
@@ -43,25 +44,32 @@ describe('${capitalizeFirstLetter(name)}DeleteUsecase', () => {
     repository = app.get(I${capitalizeFirstLetter(name)}Repository);
   });
 
-  test('should throw error when invalid parameters', async () => {
+  test('when no input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute({}),
+      () => usecase.execute(failureInput),
       (issues) => {
-        expect(issues).toEqual([{ message: 'Required', path: 'id' }]);
+        expect(issues).toEqual([{ message: 'Required', path: ${capitalizeFirstLetter(name)}Entity.nameof('id') }]);
       }
     );
   });
 
-  test('should throw error when ${name} not found', async () => {
+  test('when ${name} not found, should expect an error', async () => {
     repository.findById = jest.fn().mockResolvedValue(null);
-    await expect(usecase.execute({ id: generateUUID() })).rejects.toThrowError(ApiNotFoundException);
+
+    await expect(usecase.execute(successInput)).rejects.toThrowError(ApiNotFoundException);
   });
 
-  test('should delete successfully', async () => {
-    repository.findById = jest.fn().mockResolvedValue(${name}Response);
+  test('when ${name} deleted successfully, should expect a ${name} that has been deleted', async () => {
+    const findByIdOutput: ${capitalizeFirstLetter(name)}DeleteOutput = new ${capitalizeFirstLetter(name)}Entity({
+      id: generateUUID(),
+      name: 'dummy'
+    });
+
+    repository.findById = jest.fn().mockResolvedValue(findByIdOutput);
     repository.updateOne = jest.fn();
-    await expect(usecase.execute({ id: generateUUID() })).resolves.toEqual({
-      ...${name}Response,
+
+    await expect(usecase.execute(successInput)).resolves.toEqual({
+      ...findByIdOutput,
       deletedAt: expect.any(Date)
     });
   });

package/src/templates/postgres/core/use-cases/__tests__/getByID.spec.js

@@ -7,16 +7,17 @@ const getCoreUsecaseGetByIDTest = (name) => `import { Test } from '@nestjs/testi
 
 import { I${capitalizeFirstLetter(name)}GetByIDAdapter } from '@/modules/${name}/adapter';
 import { ApiNotFoundException } from '@/utils/exception';
-import { expectZodError, generateUUID } from '@/utils/tests/tests';;
+import { expectZodError, generateUUID } from '@/utils/tests/tests';
 
 import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
-import { ${capitalizeFirstLetter(name)}GetByIdUsecase } from '../${name}-getByID';
+import { ${capitalizeFirstLetter(name)}GetByIDInput, ${capitalizeFirstLetter(name)}GetByIDOutput, ${capitalizeFirstLetter(name)}GetByIdUsecase } from '../${name}-getByID';
 import { ${capitalizeFirstLetter(name)}Entity } from './../../entity/${name}';
 
-const ${name}Response = {
-  id: generateUUID(),
-  name: 'dummy'
-} as ${capitalizeFirstLetter(name)}Entity;
+const successInput: ${capitalizeFirstLetter(name)}GetByIDInput = {
+  id: generateUUID()
+};
+
+const failureInput: ${capitalizeFirstLetter(name)}GetByIDInput = {};
 
 describe('${capitalizeFirstLetter(name)}GetByIdUsecase', () => {
   let usecase: I${capitalizeFirstLetter(name)}GetByIDAdapter;
@@ -43,23 +44,29 @@ describe('${capitalizeFirstLetter(name)}GetByIdUsecase', () => {
     repository = app.get(I${capitalizeFirstLetter(name)}Repository);
   });
 
-  test('should throw error when invalid parameters', async () => {
+  test('when no input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute({}),
+      () => usecase.execute(failureInput),
       (issues) => {
-        expect(issues).toEqual([{ message: 'Required', path: 'id' }]);
+        expect(issues).toEqual([{ message: 'Required', path: ${capitalizeFirstLetter(name)}Entity.nameof('id') }]);
       }
     );
   });
 
-  test('should throw error when ${name} not found', async () => {
+  test('when ${name} not found, should expect an error', async () => {
     repository.findById = jest.fn().mockResolvedValue(null);
-    await expect(usecase.execute({ id: generateUUID() })).rejects.toThrowError(ApiNotFoundException);
+
+    await expect(usecase.execute(successInput)).rejects.toThrowError(ApiNotFoundException);
   });
 
-  test('should getById successfully', async () => {
-    repository.findById = jest.fn().mockResolvedValue(${name}Response);
-    await expect(usecase.execute({ id: generateUUID() })).resolves.toEqual(${name}Response);
+  test('when ${name} found, should expect a ${name} that has been found', async () => {
+    const findByIdOutput: ${capitalizeFirstLetter(name)}GetByIDOutput = new ${capitalizeFirstLetter(name)}Entity({
+      id: generateUUID(),
+      name: 'dummy'
+    });
+    repository.findById = jest.fn().mockResolvedValue(findByIdOutput);
+
+    await expect(usecase.execute(successInput)).resolves.toEqual(findByIdOutput);
   });
 });
 `

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

@@ -5,19 +5,16 @@ function capitalizeFirstLetter(string) {
 
 const getCoreUsecaseListTest = (name) => `import { Test } from '@nestjs/testing';
 
-import { ${capitalizeFirstLetter(name)}ListUsecase } from '@/core/${name}/use-cases/${name}-list';
+import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput, ${capitalizeFirstLetter(name)}ListUsecase } from '@/core/${name}/use-cases/${name}-list';
 import { I${capitalizeFirstLetter(name)}ListAdapter } from '@/modules/${name}/adapter';
-import { expectZodError, generateUUID } from '@/utils/tests/tests';;
+import { expectZodError, generateUUID } from '@/utils/tests/tests';
 
 import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
 import { ${capitalizeFirstLetter(name)}Entity } from './../../entity/${name}';
 
-const ${name}Response = {
-  id: generateUUID(),
-  name: 'dummy',
-  createdAt: new Date(),
-  updatedAt: new Date()
-} as ${capitalizeFirstLetter(name)}Entity;
+const successInput: ${capitalizeFirstLetter(name)}ListInput = { limit: 1, page: 1, search: {}, sort: { createdAt: -1 } };
+
+const failureInput: ${capitalizeFirstLetter(name)}ListInput = { search: null, sort: null, limit: 10, page: 1 };
 
 describe('${capitalizeFirstLetter(name)}ListUsecase', () => {
   let usecase: I${capitalizeFirstLetter(name)}ListAdapter;
@@ -44,32 +41,41 @@ describe('${capitalizeFirstLetter(name)}ListUsecase', () => {
     repository = app.get(I${capitalizeFirstLetter(name)}Repository);
   });
 
-  test('should throw error when invalid parameters', async () => {
+  test('when sort input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute({ search: null, sort: null, limit: 10, page: 1 }),
+      () => usecase.execute(failureInput),
       (issues) => {
         expect(issues).toEqual([{ message: 'Expected object, received null', path: 'sort' }]);
       }
     );
   });
 
-  test('should list successfully', async () => {
-    const response = { docs: [${name}Response], page: 1, limit: 1, total: 1 };
-    repository.paginate = jest.fn().mockResolvedValue(response);
-    await expect(usecase.execute({ limit: 1, page: 1, search: {}, sort: { createdAt: -1 } })).resolves.toEqual({
-      docs: [${name}Response],
+  test('when ${name} are found, should expect an ${name} list', async () => {
+    const doc = new ${capitalizeFirstLetter(name)}Entity({
+      id: generateUUID(),
+      name: 'dummy',
+      createdAt: new Date(),
+      updatedAt: new Date()
+    });
+
+    const paginateOutput: ${capitalizeFirstLetter(name)}ListOutput = { docs: [doc], page: 1, limit: 1, total: 1 };
+
+    repository.paginate = jest.fn().mockResolvedValue(paginateOutput);
+
+    await expect(usecase.execute(successInput)).resolves.toEqual({
+      docs: [doc],
       page: 1,
       limit: 1,
       total: 1
     });
   });
 
-  test('should list successfully when docs is empty', async () => {
-    const response = { docs: [], page: 1, limit: 1, total: 1 };
-    repository.paginate = jest.fn().mockResolvedValue(response);
-    await expect(usecase.execute({ limit: 1, page: 1, search: {}, sort: { createdAt: -1 } })).resolves.toEqual(
-      response
-    );
+  test('when ${name} not found, should expect an empty list', async () => {
+    const paginateOutput: ${capitalizeFirstLetter(name)}ListOutput = { docs: [], page: 1, limit: 1, total: 1 };
+
+    repository.paginate = jest.fn().mockResolvedValue(paginateOutput);
+
+    await expect(usecase.execute(successInput)).resolves.toEqual(paginateOutput);
   });
 });
 `

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

@@ -8,16 +8,17 @@ const getCoreUsecaseUpdateTest = (name) => `import { Test } from '@nestjs/testin
 import { ILoggerAdapter } from '@/infra/logger';
 import { I${capitalizeFirstLetter(name)}UpdateAdapter } from '@/modules/${name}/adapter';
 import { ApiNotFoundException } from '@/utils/exception';
-import { expectZodError, generateUUID } from '@/utils/tests/tests';;
+import { expectZodError, generateUUID } from '@/utils/tests/tests';
 
 import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
-import { ${capitalizeFirstLetter(name)}UpdateUsecase } from '../${name}-update';
+import { ${capitalizeFirstLetter(name)}UpdateInput, ${capitalizeFirstLetter(name)}UpdateOutput, ${capitalizeFirstLetter(name)}UpdateUsecase } from '../${name}-update';
 import { ${capitalizeFirstLetter(name)}Entity } from './../../entity/${name}';
 
-const ${name}Response = {
-  id: generateUUID(),
-  name: 'dummy'
-} as ${capitalizeFirstLetter(name)}Entity;
+const successInput: ${capitalizeFirstLetter(name)}UpdateInput = {
+  id: generateUUID()
+};
+
+const failureInput: ${capitalizeFirstLetter(name)}UpdateInput = {};
 
 describe('${capitalizeFirstLetter(name)}UpdateUsecase', () => {
   let usecase: I${capitalizeFirstLetter(name)}UpdateAdapter;
@@ -50,24 +51,31 @@ describe('${capitalizeFirstLetter(name)}UpdateUsecase', () => {
     repository = app.get(I${capitalizeFirstLetter(name)}Repository);
   });
 
-  test('should throw error when invalid parameters', async () => {
+  test('when no input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute({}),
+      () => usecase.execute(failureInput),
       (issues) => {
-        expect(issues).toEqual([{ message: 'Required', path: 'id' }]);
+        expect(issues).toEqual([{ message: 'Required', path: ${capitalizeFirstLetter(name)}Entity.nameof('id') }]);
       }
     );
   });
 
-  test('should throw error when ${name} not found', async () => {
+  test('when ${name} not found, should expect an error', async () => {
     repository.findById = jest.fn().mockResolvedValue(null);
-    await expect(usecase.execute({ id: generateUUID() })).rejects.toThrowError(ApiNotFoundException);
+
+    await expect(usecase.execute(successInput)).rejects.toThrowError(ApiNotFoundException);
   });
 
-  test('should update successfully', async () => {
-    repository.findById = jest.fn().mockResolvedValue(${name}Response);
+  test('when ${name} updated successfully, should expect an ${name} that has been updated', async () => {
+    const findByIdOutput: ${capitalizeFirstLetter(name)}UpdateOutput = new ${capitalizeFirstLetter(name)}Entity({
+      id: generateUUID(),
+      name: 'dummy'
+    });
+
+    repository.findById = jest.fn().mockResolvedValue(findByIdOutput);
     repository.updateOne = jest.fn().mockResolvedValue(null);
-    await expect(usecase.execute({ id: generateUUID() })).resolves.toEqual(${name}Response);
+
+    await expect(usecase.execute(successInput)).resolves.toEqual(findByIdOutput);
   });
 });
 `

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

@@ -18,7 +18,7 @@ export const ${capitalizeFirstLetter(name)}CreateSchema = ${capitalizeFirstLette
 });
 
 export type ${capitalizeFirstLetter(name)}CreateInput = z.infer<typeof ${capitalizeFirstLetter(name)}CreateSchema>;
-export type ${capitalizeFirstLetter(name)}CreateOutput = Promise<CreatedModel>;
+export type ${capitalizeFirstLetter(name)}CreateOutput = CreatedModel;
 
 export class ${capitalizeFirstLetter(name)}CreateUsecase {
   constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository, private readonly loggerServide: ILoggerAdapter) {}

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

@@ -17,7 +17,7 @@ export const ${capitalizeFirstLetter(name)}DeleteSchema = ${capitalizeFirstLette
 });
 
 export type ${capitalizeFirstLetter(name)}DeleteInput = z.infer<typeof ${capitalizeFirstLetter(name)}DeleteSchema>;
-export type ${capitalizeFirstLetter(name)}DeleteOutput = Promise<${capitalizeFirstLetter(name)}Entity>;
+export type ${capitalizeFirstLetter(name)}DeleteOutput = ${capitalizeFirstLetter(name)}Entity;
 
 export class ${capitalizeFirstLetter(name)}DeleteUsecase {
   constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}

package/src/templates/postgres/core/use-cases/getByID.js

@@ -18,7 +18,7 @@ export const ${capitalizeFirstLetter(name)}GetByIdSchema = ${capitalizeFirstLett
 });
 
 export type ${capitalizeFirstLetter(name)}GetByIDInput = z.infer<typeof ${capitalizeFirstLetter(name)}GetByIdSchema>;
-export type ${capitalizeFirstLetter(name)}GetByIDOutput = Promise<${capitalizeFirstLetter(name)}Entity>;
+export type ${capitalizeFirstLetter(name)}GetByIDOutput = ${capitalizeFirstLetter(name)}Entity;
 
 export class ${capitalizeFirstLetter(name)}GetByIdUsecase {
   constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}

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

@@ -16,7 +16,7 @@ import { I${capitalizeFirstLetter(name)}Repository } from '../repository/${name}
 export const ${capitalizeFirstLetter(name)}ListSchema = z.intersection(PaginationSchema, SortSchema.merge(SearchSchema));
 
 export type ${capitalizeFirstLetter(name)}ListInput = PaginationInput<${capitalizeFirstLetter(name)}Entity>;
-export type ${capitalizeFirstLetter(name)}ListOutput = Promise<PaginationOutput<${capitalizeFirstLetter(name)}Entity>>;
+export type ${capitalizeFirstLetter(name)}ListOutput = PaginationOutput<${capitalizeFirstLetter(name)}Entity>;
 
 export class ${capitalizeFirstLetter(name)}ListUsecase {
   constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}

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

@@ -18,7 +18,7 @@ export const ${capitalizeFirstLetter(name)}UpdateSchema = ${capitalizeFirstLette
 }).merge(${capitalizeFirstLetter(name)}EntitySchema.omit({ id: true }).partial());
 
 export type ${capitalizeFirstLetter(name)}UpdateInput = z.infer<typeof ${capitalizeFirstLetter(name)}UpdateSchema>;
-export type ${capitalizeFirstLetter(name)}UpdateOutput = Promise<${capitalizeFirstLetter(name)}Entity>;
+export type ${capitalizeFirstLetter(name)}UpdateOutput = ${capitalizeFirstLetter(name)}Entity;
 
 export class ${capitalizeFirstLetter(name)}UpdateUsecase {
   constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository, private readonly loggerServide: ILoggerAdapter) {}

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

@@ -27,8 +27,8 @@ import {
 } from './adapter';
 import { SwagggerRequest, SwagggerResponse } from './swagger';
 
-@Controller()
-@ApiTags('${name}')
+@Controller('${pluralize(name)}')
+@ApiTags('${pluralize(name)}')
 @ApiBearerAuth()
 @Roles(UserRole.USER)
 export class ${capitalizeFirstLetter(name)}Controller {
@@ -40,36 +40,36 @@ export class ${capitalizeFirstLetter(name)}Controller {
     private readonly ${name}Delete: I${capitalizeFirstLetter(name)}DeleteAdapter
   ) {}
 
-  @Post('/${pluralize(name)}')
+  @Post()
   @ApiResponse(SwagggerResponse.create[200])
   @ApiBody(SwagggerRequest.createBody)
-  async create(@Req() { body }: ApiRequest): ${capitalizeFirstLetter(name)}CreateOutput {
+  async create(@Req() { body }: ApiRequest): Promise<${capitalizeFirstLetter(name)}CreateOutput> {
     return await this.${name}Create.execute(body as ${capitalizeFirstLetter(name)}CreateInput);
   }
 
-  @Put('/${pluralize(name)}')
+  @Put()
   @ApiResponse(SwagggerResponse.update[200])
   @ApiResponse(SwagggerResponse.update[404])
   @ApiBody(SwagggerRequest.updateBody)
-  async update(@Req() { body }: ApiRequest): ${capitalizeFirstLetter(name)}UpdateOutput {
+  async update(@Req() { body }: ApiRequest): Promise<${capitalizeFirstLetter(name)}UpdateOutput> {
     return await this.${name}Update.execute(body as ${capitalizeFirstLetter(name)}UpdateInput);
   }
 
-  @Get('/${pluralize(name)}/:id')
+  @Get('/:id')
   @ApiParam({ name: 'id', required: true })
   @ApiResponse(SwagggerResponse.getByID[200])
   @ApiResponse(SwagggerResponse.getByID[404])
-  async getById(@Req() { params }: ApiRequest): ${capitalizeFirstLetter(name)}GetByIDOutput {
+  async getById(@Req() { params }: ApiRequest): Promise<${capitalizeFirstLetter(name)}GetByIDOutput> {
     return await this.${name}GetByID.execute(params as ${capitalizeFirstLetter(name)}GetByIDInput);
   }
 
-  @Get('/${pluralize(name)}')
+  @Get()
   @ApiQuery(SwagggerRequest.listQuery.pagination.limit)
   @ApiQuery(SwagggerRequest.listQuery.pagination.page)
   @ApiQuery(SwagggerRequest.listQuery.sort)
   @ApiQuery(SwagggerRequest.listQuery.search)
   @ApiResponse(SwagggerResponse.list[200])
-  async list(@Req() { query }: ApiRequest): ${capitalizeFirstLetter(name)}ListOutput {
+  async list(@Req() { query }: ApiRequest): Promise<${capitalizeFirstLetter(name)}ListOutput> {
     const input: ${capitalizeFirstLetter(name)}ListInput = {
       sort: SortHttpSchema.parse(query.sort),
       search: SearchHttpSchema.parse(query.search),
@@ -80,11 +80,11 @@ export class ${capitalizeFirstLetter(name)}Controller {
     return await this.${name}List.execute(input);
   }
 
-  @Delete('/${pluralize(name)}/:id')
+  @Delete('/:id')
   @ApiParam({ name: 'id', required: true })
   @ApiResponse(SwagggerResponse.delete[200])
   @ApiResponse(SwagggerResponse.delete[404])
-  async delete(@Req() { params }: ApiRequest): ${capitalizeFirstLetter(name)}DeleteOutput {
+  async delete(@Req() { params }: ApiRequest): Promise<${capitalizeFirstLetter(name)}DeleteOutput> {
     return await this.${name}Delete.execute(params as ${capitalizeFirstLetter(name)}DeleteInput);
   }
 }

package/src/templates/postgres/modules/swagger.js

@@ -1,26 +1,36 @@
 const pluralize = require('pluralize')
 
-const getModuleSwagger = (name) => `import { CreatedModel } from '@/infra/repository/types';
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+
+const getModuleSwagger = (name) => `import { ${capitalizeFirstLetter(name)}Entity } from '@/core/${name}/entity/${name}';
+import { ${capitalizeFirstLetter(name)}CreateOutput } from '@/core/${name}/use-cases/${name}-create';
+import { ${capitalizeFirstLetter(name)}DeleteOutput } from '@/core/${name}/use-cases/${name}-delete';
+import { ${capitalizeFirstLetter(name)}GetByIDOutput } from '@/core/${name}/use-cases/${name}-getByID';
+import { ${capitalizeFirstLetter(name)}ListOutput } from '@/core/${name}/use-cases/${name}-list';
+import { ${capitalizeFirstLetter(name)}UpdateOutput } from '@/core/${name}/use-cases/${name}-update';
 import { Swagger } from '@/utils/docs/swagger';
 
-const entity = {
+const input = new ${capitalizeFirstLetter(name)}Entity({
   name: '<name>'
-};
+});
 
-const entityFull = { ...entity, updatedAt: '<updatedAt>', createdAt: '<createdAt>', deletedAt: '<deletedAt>' };
+const output = new ${capitalizeFirstLetter(name)}Entity({ ...input, updatedAt: new Date(), createdAt: new Date(), deletedAt: null });
 
 export const SwagggerResponse = {
   create: {
     200: Swagger.defaultResponseJSON({
       status: 200,
-      json: { created: true, id: '<uuid>' } as CreatedModel,
+      json: { created: true, id: '<uuid>' } as ${capitalizeFirstLetter(name)}CreateOutput,
       description: '${name} created.'
     })
   },
   update: {
     200: Swagger.defaultResponseJSON({
       status: 200,
-      json: entityFull,
+      json: output as ${capitalizeFirstLetter(name)}UpdateOutput,
       description: '${name} updated.'
     }),
     404: Swagger.defaultResponseError({
@@ -33,7 +43,7 @@ export const SwagggerResponse = {
   getByID: {
     200: Swagger.defaultResponseJSON({
       status: 200,
-      json: entityFull,
+      json: output as ${capitalizeFirstLetter(name)}GetByIDOutput,
       description: '${name} found.'
     }),
     404: Swagger.defaultResponseError({
@@ -46,12 +56,12 @@ export const SwagggerResponse = {
   delete: {
     200: Swagger.defaultResponseJSON({
       status: 200,
-      json: entityFull,
+      json: output as ${capitalizeFirstLetter(name)}DeleteOutput,
       description: '${name} found.'
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/${pluralize(name)}s/:id',
+      route: 'api/${pluralize(name)}/:id',
       message: '${name}NotFound',
       description: '${name} not found.'
     })
@@ -59,15 +69,15 @@ export const SwagggerResponse = {
   list: {
     200: Swagger.defaultResponseJSON({
       status: 200,
-      json: { docs: { docs: [entityFull], page: 1, limit: 1, total: 1 } },
+      json: { docs: [output], page: 1, limit: 1, total: 1 } as ${capitalizeFirstLetter(name)}ListOutput,
       description: '${name} created.'
     })
   }
 };
 
 export const SwagggerRequest = {
-  createBody: Swagger.defaultRequestJSON({ ...entity, id: undefined }),
-  updateBody: Swagger.defaultRequestJSON({ ...entity, id: '<id>' }),
+  createBody: Swagger.defaultRequestJSON({ ...input, id: undefined } as ${capitalizeFirstLetter(name)}Entity),
+  updateBody: Swagger.defaultRequestJSON({ ...input, id: '<id>' } as ${capitalizeFirstLetter(name)}Entity),
   listQuery: {
     pagination: {
       limit: Swagger.defaultApiQueryOptions({ example: 10, name: 'limit', required: false }),