@mikemajesty/microservice-crud 4.5.14 → 5.0.0

package/package.json

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

package/src/cli.js

@@ -21,8 +21,8 @@ const { getCoreUsecaseCreateTest } = require('./templates/postgres/core/use-case
 const { getCoreUsecaseUpdateTest } = require('./templates/postgres/core/use-cases/__tests__/update.spec');
 const { getCoreUsecaseDeleteTest } = require('./templates/postgres/core/use-cases/__tests__/delete.spec');
 const { getCoreUsecaseListTest } = require('./templates/postgres/core/use-cases/__tests__/list.spec');
-const { getCoreUsecaseGetByIdTest } = require('./templates/postgres/core/use-cases/__tests__/get-by-id.spec');
-const { getCoreUsecaseGetById } = require('./templates/postgres/core/use-cases/get-by-id');
+const { getCoreUsecaseGetByIDTest } = require('./templates/postgres/core/use-cases/__tests__/get-by-id.spec');
+const { getCoreUsecaseGetByID } = require('./templates/postgres/core/use-cases/get-by-id');
 const { getCoreUsecaseList } = require('./templates/postgres/core/use-cases/list');
 const { getCoreEntity } = require('./templates/postgres/core/entity/entity');
 const { getCoreRepository } = require('./templates/postgres/core/repository/repository');
@@ -41,8 +41,8 @@ const { getCoreUsecaseCreateTest: getCoreUsecaseCreateMongoTest } = require('./t
 const { getCoreUsecaseUpdateTest: getCoreUsecaseUpdateMongoTest } = require('./templates/mongo/core/use-cases/__tests__/update.spec');
 const { getCoreUsecaseDeleteTest: getCoreUsecaseDeleteMongoTest } = require('./templates/mongo/core/use-cases/__tests__/delete.spec');
 const { getCoreUsecaseListTest: getCoreUsecaseListMongoTest } = require('./templates/mongo/core/use-cases/__tests__/list.spec');
-const { getCoreUsecaseGetByIdTest: getCoreUsecaseGetByIdMongoTest } = require('./templates/mongo/core/use-cases/__tests__/get-by-id.spec');
-const { getCoreUsecaseGetById: getCoreUsecaseGetByIdMongo } = require('./templates/mongo/core/use-cases/get-by-id');
+const { getCoreUsecaseGetByIDTest: getCoreUsecaseGetByIDMongoTest } = require('./templates/mongo/core/use-cases/__tests__/get-by-id.spec');
+const { getCoreUsecaseGetByID: getCoreUsecaseGetByIDMongo } = require('./templates/mongo/core/use-cases/get-by-id');
 const { getCoreUsecaseList: getCoreUsecaseListMongo } = require('./templates/mongo/core/use-cases/list');
 const { getCoreEntity: getCoreEntityMongo } = require('./templates/mongo/core/entity/entity');
 const { getCoreRepository: getCoreRepositoryMongo } = require('./templates/mongo/core/repository/repository');
@@ -172,7 +172,7 @@ const createPostgresCrud = async (name) => {
 
     fs.writeFileSync(`${useCasesPath}/${name}-create.ts`, getCoreUsecaseCreate(name))
     fs.writeFileSync(`${useCasesPath}/${name}-delete.ts`, getCoreUsecaseDelete(name))
-    fs.writeFileSync(`${useCasesPath}/${name}-get-by-id.ts`, getCoreUsecaseGetById(name))
+    fs.writeFileSync(`${useCasesPath}/${name}-get-by-id.ts`, getCoreUsecaseGetByID(name))
     fs.writeFileSync(`${useCasesPath}/${name}-list.ts`, getCoreUsecaseList(name))
     fs.writeFileSync(`${useCasesPath}/${name}-update.ts`, getCoreUsecaseUpdate(name))
 
@@ -182,7 +182,7 @@ const createPostgresCrud = async (name) => {
     fs.writeFileSync(`${useCasesPathTest}/${name}-update.spec.ts`, getCoreUsecaseUpdateTest(name))
     fs.writeFileSync(`${useCasesPathTest}/${name}-delete.spec.ts`, getCoreUsecaseDeleteTest(name))
     fs.writeFileSync(`${useCasesPathTest}/${name}-list.spec.ts`, getCoreUsecaseListTest(name))
-    fs.writeFileSync(`${useCasesPathTest}/${name}-get-by-id.spec.ts`, getCoreUsecaseGetByIdTest(name))
+    fs.writeFileSync(`${useCasesPathTest}/${name}-get-by-id.spec.ts`, getCoreUsecaseGetByIDTest(name))
 
     const schemasPath = `${__dirname}/scafold/postgres/schemas`;
     if (fs.existsSync(schemasPath)) {
@@ -244,7 +244,7 @@ const createMongoCrud = async (name) => {
 
     fs.writeFileSync(`${useCasesPath}/${name}-create.ts`, getCoreUsecaseCreateMongo(name))
     fs.writeFileSync(`${useCasesPath}/${name}-delete.ts`, getCoreUsecaseDeleteMongo(name))
-    fs.writeFileSync(`${useCasesPath}/${name}-get-by-id.ts`, getCoreUsecaseGetByIdMongo(name))
+    fs.writeFileSync(`${useCasesPath}/${name}-get-by-id.ts`, getCoreUsecaseGetByIDMongo(name))
     fs.writeFileSync(`${useCasesPath}/${name}-list.ts`, getCoreUsecaseListMongo(name))
     fs.writeFileSync(`${useCasesPath}/${name}-update.ts`, getCoreUsecaseUpdateMongo(name))
 
@@ -255,7 +255,7 @@ const createMongoCrud = async (name) => {
     fs.writeFileSync(`${useCasesPathTest}/${name}-update.spec.ts`, getCoreUsecaseUpdateMongoTest(name))
     fs.writeFileSync(`${useCasesPathTest}/${name}-delete.spec.ts`, getCoreUsecaseDeleteMongoTest(name))
     fs.writeFileSync(`${useCasesPathTest}/${name}-list.spec.ts`, getCoreUsecaseListMongoTest(name))
-    fs.writeFileSync(`${useCasesPathTest}/${name}-get-by-id.spec.ts`, getCoreUsecaseGetByIdMongoTest(name))
+    fs.writeFileSync(`${useCasesPathTest}/${name}-get-by-id.spec.ts`, getCoreUsecaseGetByIDMongoTest(name))
 
     const schemasPath = `${__dirname}/scafold/mongo/schemas`;
 

package/src/templates/libs/service.js

@@ -6,7 +6,7 @@ function capitalizeFirstLetter(string) {
 const getServiceLib = (name) => `import { Injectable } from '@nestjs/common';
 import { z } from 'zod';
 
-import { ValidateSchema } from '@/utils/decorators';
+import { ValidateSchema } from '@/common/decorators';
 
 import { I${capitalizeFirstLetter(name)}Adapter } from './adapter';
 

package/src/templates/module/controller.js

@@ -6,18 +6,17 @@ function capitalizeFirstLetter(string) {
 }
 
 const getModuleControllerModule = (name) => `import { Controller, Get, Req } from '@nestjs/common';
-import { ApiBearerAuth, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { ApiResponse, ApiTags } from '@nestjs/swagger';
 
 import { ApiRequest } from '@/utils/request';
 
-import { SwagggerResponse } from './swagger';
+import { SwaggerResponse } from './swagger';
 
 @Controller('${pluralize(name)}')
-@ApiTags('${name}')
-@ApiBearerAuth()
+@ApiTags('${pluralize(name)}')
 export class ${capitalizeFirstLetter(name)}Controller {
   @Get()
-  @ApiResponse(SwagggerResponse.get[200])
+  @ApiResponse(SwaggerResponse.get[200])
   async get(@Req() {}: ApiRequest): Promise<string> {
     return 'text';
   }

package/src/templates/module/module.js

@@ -2,24 +2,15 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getModuleModule = (name) => `import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
-
-import { IsLoggedMiddleware } from '@/observables/middlewares';
-import { RedisCacheModule } from '@/infra/cache/redis';
-import { LoggerModule } from '@/infra/logger';
-import { TokenLibModule } from '@/libs/token';
+const getModuleModule = (name) => `import { Module } from '@nestjs/common';
 
 import { ${capitalizeFirstLetter(name)}Controller } from './controller';
 
 @Module({
-  imports: [TokenLibModule, LoggerModule, RedisCacheModule],
+  imports: [],
   controllers: [${capitalizeFirstLetter(name)}Controller]
 })
-export class ${capitalizeFirstLetter(name)}Module implements NestModule {
-  configure(consumer: MiddlewareConsumer) {
-    consumer.apply(IsLoggedMiddleware).forRoutes(${capitalizeFirstLetter(name)}Controller);
-  }
-}
+export class ${capitalizeFirstLetter(name)}Module {}
 `
 
 module.exports = {

package/src/templates/module/swagger.js

@@ -1,16 +1,16 @@
 const getModuleSwaggerModule = (name) => `import { Swagger } from '@/utils/docs/swagger';
 
-export const SwagggerResponse = {
+export const SwaggerResponse = {
   get: {
     200: Swagger.defaultResponseJSON({
       status: 200,
       json: 'text',
-      description: '${name} get.'
+      description: 'get ${name}.'
     })
   }
 };
 
-export const SwagggerRequest = {};
+export const SwaggerRequest = {};
 `
 
 module.exports = {

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

@@ -7,13 +7,19 @@ 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, getMockUUID } 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';
 
-describe(${capitalizeFirstLetter(name)}CreateUsecase.name, () => {
+const successInput: ${capitalizeFirstLetter(name)}CreateInput = {
+  name: 'name'
+};
+const failureInput: ${capitalizeFirstLetter(name)}CreateInput = {};
+
+describe('${capitalizeFirstLetter(name)}CreateUsecase', () => {
   let usecase: I${capitalizeFirstLetter(name)}CreateAdapter;
   let repository: I${capitalizeFirstLetter(name)}Repository;
 
@@ -32,8 +38,8 @@ 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);
+          useFactory: (birdRepository: I${capitalizeFirstLetter(name)}Repository, logger: ILoggerAdapter) => {
+            return new ${capitalizeFirstLetter(name)}CreateUsecase(birdRepository, logger);
           },
           inject: [I${capitalizeFirstLetter(name)}Repository, ILoggerAdapter]
         }
@@ -46,24 +52,34 @@ describe(${capitalizeFirstLetter(name)}CreateUsecase.name, () => {
 
   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: ${capitalizeFirstLetter(name)}Entity.nameOf('name') }]);
       }
     );
   });
 
-  const input: ${capitalizeFirstLetter(name)}CreateInput = {
-    name: 'name'
-  };
-
-  test('when ${name} created successfully, should expect a ${name}', async () => {
+  test('when ${name} created successfully, should expect a ${name} that has been created', async () => {
     const createOutput: ${capitalizeFirstLetter(name)}CreateOutput = { created: true, id: getMockUUID() };
 
     repository.findOne = jest.fn().mockResolvedValue(null);
     repository.create = jest.fn().mockResolvedValue(createOutput);
+    repository.startSession = jest.fn().mockResolvedValue({
+      commitTransaction: jest.fn()
+    });
+
+    await expect(usecase.execute(successInput)).resolves.toEqual(createOutput);
+  });
+
+  test('when transaction throw an error, should expect an error', async () => {
+    repository.findOne = jest.fn().mockResolvedValue(null);
+    repository.create = jest.fn().mockRejectedValue(new ApiInternalServerException());
+    repository.startSession = jest.fn().mockResolvedValue({
+      commitTransaction: jest.fn(),
+      abortTransaction: jest.fn()
+    });
 
-    await expect(usecase.execute(input)).resolves.toEqual(createOutput);
+    await expect(usecase.execute(successInput)).rejects.toThrow(ApiInternalServerException);
   });
 });
 `

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

@@ -13,7 +13,13 @@ import { ${capitalizeFirstLetter(name)}Entity } from '../../entity/${name}';
 import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
 import { ${capitalizeFirstLetter(name)}DeleteInput, ${capitalizeFirstLetter(name)}DeleteOutput, ${capitalizeFirstLetter(name)}DeleteUsecase } from '../${name}-delete';
 
-describe(${capitalizeFirstLetter(name)}DeleteUsecase.name, () => {
+const successInput: ${capitalizeFirstLetter(name)}DeleteInput = {
+  id: getMockUUID()
+};
+
+const failureInput: ${capitalizeFirstLetter(name)}DeleteInput = {};
+
+describe('${capitalizeFirstLetter(name)}DeleteUsecase', () => {
   let usecase: I${capitalizeFirstLetter(name)}DeleteAdapter;
   let repository: I${capitalizeFirstLetter(name)}Repository;
 
@@ -41,24 +47,20 @@ describe(${capitalizeFirstLetter(name)}DeleteUsecase.name, () => {
 
   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: ${capitalizeFirstLetter(name)}Entity.nameOf('id') }]);
       }
     );
   });
 
-  const input: ${capitalizeFirstLetter(name)}DeleteInput = {
-    id: getMockUUID()
-  };
-
   test('when ${name} not found, should expect an error', async () => {
     repository.findById = jest.fn().mockResolvedValue(null);
 
-    await expect(usecase.execute(input)).rejects.toThrow(ApiNotFoundException);
+    await expect(usecase.execute(successInput)).rejects.toThrowError(ApiNotFoundException);
   });
 
-  test('when ${name} deleted successfully, should expect a ${name}', async () => {
+  test('when ${name} deleted successfully, should expect a ${name} that has been deleted', async () => {
     const findByIdOutput: ${capitalizeFirstLetter(name)}DeleteOutput = new ${capitalizeFirstLetter(name)}Entity({
       id: getMockUUID(),
       name: 'dummy'
@@ -67,7 +69,7 @@ describe(${capitalizeFirstLetter(name)}DeleteUsecase.name, () => {
     repository.findById = jest.fn().mockResolvedValue(findByIdOutput);
     repository.updateOne = jest.fn();
 
-    await expect(usecase.execute(input)).resolves.toEqual({
+    await expect(usecase.execute(successInput)).resolves.toEqual({
       ...findByIdOutput,
       deletedAt: expect.any(Date)
     });

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

@@ -3,18 +3,24 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getCoreUsecaseGetByIdTest = (name) => `import { Test } from '@nestjs/testing';
+const getCoreUsecaseGetByIDTest = (name) => `import { Test } from '@nestjs/testing';
 
-import { I${capitalizeFirstLetter(name)}GetByIdAdapter } from '@/modules/${name}/adapter';
+import { I${capitalizeFirstLetter(name)}GetByIDAdapter } from '@/modules/${name}/adapter';
 import { ApiNotFoundException } from '@/utils/exception';
 import { expectZodError, getMockUUID } from '@/utils/tests';
 
 import { ${capitalizeFirstLetter(name)}Entity } from '../../entity/${name}';
 import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
-import { ${capitalizeFirstLetter(name)}GetByIdInput, ${capitalizeFirstLetter(name)}GetByIdOutput, ${capitalizeFirstLetter(name)}GetByIdUsecase } from '../${name}-get-by-id';
+import { ${capitalizeFirstLetter(name)}GetByIDInput, ${capitalizeFirstLetter(name)}GetByIDOutput, ${capitalizeFirstLetter(name)}GetByIdUsecase } from '../${name}-get-by-id';
 
-describe(${capitalizeFirstLetter(name)}GetByIdUsecase.name, () => {
-  let usecase: I${capitalizeFirstLetter(name)}GetByIdAdapter;
+const successInput: ${capitalizeFirstLetter(name)}GetByIDInput = {
+  id: getMockUUID()
+};
+
+const failureInput: ${capitalizeFirstLetter(name)}GetByIDInput = {};
+
+describe('${capitalizeFirstLetter(name)}GetByIdUsecase', () => {
+  let usecase: I${capitalizeFirstLetter(name)}GetByIDAdapter;
   let repository: I${capitalizeFirstLetter(name)}Repository;
 
   beforeEach(async () => {
@@ -26,7 +32,7 @@ describe(${capitalizeFirstLetter(name)}GetByIdUsecase.name, () => {
           useValue: {}
         },
         {
-          provide: I${capitalizeFirstLetter(name)}GetByIdAdapter,
+          provide: I${capitalizeFirstLetter(name)}GetByIDAdapter,
           useFactory: (${name}Repository: I${capitalizeFirstLetter(name)}Repository) => {
             return new ${capitalizeFirstLetter(name)}GetByIdUsecase(${name}Repository);
           },
@@ -35,42 +41,38 @@ describe(${capitalizeFirstLetter(name)}GetByIdUsecase.name, () => {
       ]
     }).compile();
 
-    usecase = app.get(I${capitalizeFirstLetter(name)}GetByIdAdapter);
+    usecase = app.get(I${capitalizeFirstLetter(name)}GetByIDAdapter);
     repository = app.get(I${capitalizeFirstLetter(name)}Repository);
   });
 
   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: ${capitalizeFirstLetter(name)}Entity.nameOf('id') }]);
       }
     );
   });
 
-  const input: ${capitalizeFirstLetter(name)}GetByIdInput = {
-    id: getMockUUID()
-  };
-
   test('when ${name} not found, should expect an error', async () => {
     repository.findById = jest.fn().mockResolvedValue(null);
 
-    await expect(usecase.execute(input)).rejects.toThrow(ApiNotFoundException);
+    await expect(usecase.execute(successInput)).rejects.toThrowError(ApiNotFoundException);
   });
 
-  test('when ${name} found, should expect a ${name}', async () => {
-    const findByIdOutput: ${capitalizeFirstLetter(name)}GetByIdOutput = new ${capitalizeFirstLetter(name)}Entity({
+  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(input)).resolves.toEqual(findByIdOutput);
+    await expect(usecase.execute(successInput)).resolves.toEqual(findByIdOutput);
   });
 });
 `
 
 module.exports = {
-  getCoreUsecaseGetByIdTest
+  getCoreUsecaseGetByIDTest
 }

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

@@ -12,7 +12,11 @@ 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';
 
-describe(${capitalizeFirstLetter(name)}ListUsecase.name, () => {
+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;
   let repository: I${capitalizeFirstLetter(name)}Repository;
 
@@ -40,15 +44,13 @@ describe(${capitalizeFirstLetter(name)}ListUsecase.name, () => {
 
   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' }]);
       }
     );
   });
 
-  const input: ${capitalizeFirstLetter(name)}ListInput = { limit: 1, page: 1, search: {}, sort: { createdAt: -1 } };
-
   test('when ${name} are found, should expect an ${name} list', async () => {
     const doc = new ${capitalizeFirstLetter(name)}Entity({
       id: getMockUUID(),
@@ -61,7 +63,7 @@ describe(${capitalizeFirstLetter(name)}ListUsecase.name, () => {
 
     repository.paginate = jest.fn().mockResolvedValue(paginateOutput);
 
-    await expect(usecase.execute(input)).resolves.toEqual({
+    await expect(usecase.execute(successInput)).resolves.toEqual({
       docs: [doc],
       page: 1,
       limit: 1,
@@ -74,7 +76,7 @@ describe(${capitalizeFirstLetter(name)}ListUsecase.name, () => {
 
     repository.paginate = jest.fn().mockResolvedValue(paginateOutput);
 
-    await expect(usecase.execute(input)).resolves.toEqual(paginateOutput);
+    await expect(usecase.execute(successInput)).resolves.toEqual(paginateOutput);
   });
 });
 `

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

@@ -12,9 +12,16 @@ import { expectZodError, getMockUUID } 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 { ${capitalizeFirstLetter(name)}UpdateInput, ${capitalizeFirstLetter(name)}UpdateOutput } from '../${name}-update';
+import { ${capitalizeFirstLetter(name)}UpdateUsecase } from '../${name}-update';
 
-describe(${capitalizeFirstLetter(name)}UpdateUsecase.name, () => {
+const successInput: ${capitalizeFirstLetter(name)}UpdateInput = {
+  id: getMockUUID()
+};
+
+const failureInput: ${capitalizeFirstLetter(name)}UpdateInput = {};
+
+describe('${capitalizeFirstLetter(name)}UpdateUsecase', () => {
   let usecase: I${capitalizeFirstLetter(name)}UpdateAdapter;
   let repository: I${capitalizeFirstLetter(name)}Repository;
 
@@ -42,24 +49,20 @@ describe(${capitalizeFirstLetter(name)}UpdateUsecase.name, () => {
 
   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: ${capitalizeFirstLetter(name)}Entity.nameOf('id') }]);
       }
     );
   });
 
-  const input: ${capitalizeFirstLetter(name)}UpdateInput = {
-    id: getMockUUID()
-  };
-
   test('when ${name} not found, should expect an error', async () => {
     repository.findById = jest.fn().mockResolvedValue(null);
 
-    await expect(usecase.execute(input)).rejects.toThrow(ApiNotFoundException);
+    await expect(usecase.execute(successInput)).rejects.toThrowError(ApiNotFoundException);
   });
 
-  test('when ${name} updated successfully, should expect an ${name}', async () => {
+  test('when ${name} updated successfully, should expect an ${name} that has been updated', async () => {
     const findByIdOutput: ${capitalizeFirstLetter(name)}UpdateOutput = new ${capitalizeFirstLetter(name)}Entity({
       id: getMockUUID(),
       name: 'dummy'
@@ -68,7 +71,7 @@ describe(${capitalizeFirstLetter(name)}UpdateUsecase.name, () => {
     repository.findById = jest.fn().mockResolvedValue(findByIdOutput);
     repository.updateOne = jest.fn().mockResolvedValue(null);
 
-    await expect(usecase.execute(input)).resolves.toEqual(findByIdOutput);
+    await expect(usecase.execute(successInput)).resolves.toEqual(findByIdOutput);
   });
 });
 `

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

@@ -5,9 +5,9 @@ function capitalizeFirstLetter(string) {
 
 const getCoreUsecaseCreate = (name) => `import { z } from 'zod';
 
+import { ValidateSchema } from '@/common/decorators';
 import { ILoggerAdapter } from '@/infra/logger';
 import { CreatedModel } from '@/infra/repository';
-import { ValidateSchema } from '@/utils/decorators';
 import { IUsecase } from '@/utils/usecase';
 
 import { ${capitalizeFirstLetter(name)}Entity, ${capitalizeFirstLetter(name)}EntitySchema } from '../entity/${name}';
@@ -21,19 +21,25 @@ export type ${capitalizeFirstLetter(name)}CreateInput = z.infer<typeof ${capital
 export type ${capitalizeFirstLetter(name)}CreateOutput = CreatedModel;
 
 export class ${capitalizeFirstLetter(name)}CreateUsecase implements IUsecase {
-  constructor(
-    private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository,
-    private readonly loggerService: ILoggerAdapter
-  ) {}
+  constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(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(input);
 
-    const ${name} = await this.${name}Repository.create(entity);
+    const session = await this.${name}Repository.startSession();
 
-    this.loggerService.info({ message: '${name} created.', obj: { ${name} } });
-    return ${name};
+    try {
+      const ${name} = await this.${name}Repository.create(entity, { session });
+
+      await session.commitTransaction();
+
+      this.loggerService.info({ message: '${name} created.', obj: { ${name} } });
+      return ${name};
+    } catch (error) {
+      await session.abortTransaction();
+      throw error;
+    }
   }
 }
 `

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

@@ -5,7 +5,7 @@ function capitalizeFirstLetter(string) {
 
 const getCoreUsecaseDelete = (name) => `import { z } from 'zod';
 
-import { ValidateSchema } from '@/utils/decorators';
+import { ValidateSchema } from '@/common/decorators';
 import { ApiNotFoundException } from '@/utils/exception';
 import { IUsecase } from '@/utils/usecase';
 
@@ -27,7 +27,7 @@ export class ${capitalizeFirstLetter(name)}DeleteUsecase implements IUsecase {
     const model = await this.${name}Repository.findById(id);
 
     if (!model) {
-      throw new ApiNotFoundException('${name}NotFound');
+      throw new ApiNotFoundException();
     }
 
     const ${name} = new ${capitalizeFirstLetter(name)}Entity(model);

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

@@ -3,9 +3,9 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getCoreUsecaseGetById = (name) => `import { z } from 'zod';
+const getCoreUsecaseGetByID = (name) => `import { z } from 'zod';
 
-import { ValidateSchema } from '@/utils/decorators';
+import { ValidateSchema } from '@/common/decorators';
 import { ApiNotFoundException } from '@/utils/exception';
 import { IUsecase } from '@/utils/usecase';
 
@@ -15,18 +15,18 @@ import { I${capitalizeFirstLetter(name)}Repository } from '../repository/${name}
 export const ${capitalizeFirstLetter(name)}GetByIdSchema = ${capitalizeFirstLetter(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 ${capitalizeFirstLetter(name)}GetByIDInput = z.infer<typeof ${capitalizeFirstLetter(name)}GetByIdSchema>;
+export type ${capitalizeFirstLetter(name)}GetByIDOutput = ${capitalizeFirstLetter(name)}Entity;
 
 export class ${capitalizeFirstLetter(name)}GetByIdUsecase implements IUsecase {
   constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}
 
   @ValidateSchema(${capitalizeFirstLetter(name)}GetByIdSchema)
-  async execute({ id }: ${capitalizeFirstLetter(name)}GetByIdInput): Promise<${capitalizeFirstLetter(name)}GetByIdOutput> {
+  async execute({ id }: ${capitalizeFirstLetter(name)}GetByIDInput): Promise<${capitalizeFirstLetter(name)}GetByIDOutput> {
     const ${name} = await this.${name}Repository.findById(id);
 
     if (!${name}) {
-      throw new ApiNotFoundException('${name}NotFound');
+      throw new ApiNotFoundException();
     }
 
     const entity = new ${capitalizeFirstLetter(name)}Entity(${name});
@@ -37,5 +37,5 @@ export class ${capitalizeFirstLetter(name)}GetByIdUsecase implements IUsecase {
 `
 
 module.exports = {
-  getCoreUsecaseGetById
+  getCoreUsecaseGetByID
 }

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

@@ -6,7 +6,7 @@ function capitalizeFirstLetter(string) {
 
 const getCoreUsecaseList = (name) => `import { z } from 'zod';
 
-import { ValidateSchema } from '@/utils/decorators';
+import { ValidateSchema } from '@/common/decorators';
 import { PaginationInput, PaginationOutput, PaginationSchema } from '@/utils/pagination';
 import { SearchSchema } from '@/utils/search';
 import { SortSchema } from '@/utils/sort';

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

@@ -5,7 +5,7 @@ function capitalizeFirstLetter(string) {
 
 const getCoreUsecaseUpdate = (name) => `import { z } from 'zod';
 
-import { ValidateSchema } from '@/utils/decorators';
+import { ValidateSchema } from '@/common/decorators';
 import { ILoggerAdapter } from '@/infra/logger';
 import { ApiNotFoundException } from '@/utils/exception';
 import { IUsecase } from '@/utils/usecase';
@@ -28,7 +28,7 @@ export class ${capitalizeFirstLetter(name)}UpdateUsecase implements IUsecase {
     const ${name} = await this.${name}Repository.findById(input.id);
 
     if (!${name}) {
-      throw new ApiNotFoundException('${name}NotFound');
+      throw new ApiNotFoundException();
     }
 
     const ${name}Finded = new ${capitalizeFirstLetter(name)}Entity(${name});

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

@@ -5,7 +5,7 @@ function capitalizeFirstLetter(string) {
 
 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)}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 { IUsecase } from '@/utils/usecase';
@@ -26,8 +26,8 @@ export abstract class I${capitalizeFirstLetter(name)}DeleteAdapter implements IU
   abstract execute(input: ${capitalizeFirstLetter(name)}DeleteInput): Promise<${capitalizeFirstLetter(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${capitalizeFirstLetter(name)}GetByIDAdapter implements IUsecase {
+  abstract execute(input: ${capitalizeFirstLetter(name)}GetByIDInput): Promise<${capitalizeFirstLetter(name)}GetByIDOutput>;
 }
 `