@mikemajesty/microservice-crud 4.5.13 → 4.5.14

package/package.json

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

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

@@ -7,19 +7,13 @@ 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';
 
-const successInput: ${capitalizeFirstLetter(name)}CreateInput = {
-  name: 'name'
-};
-const failureInput: ${capitalizeFirstLetter(name)}CreateInput = {};
-
-describe('${capitalizeFirstLetter(name)}CreateUsecase', () => {
+describe(${capitalizeFirstLetter(name)}CreateUsecase.name, () => {
   let usecase: I${capitalizeFirstLetter(name)}CreateAdapter;
   let repository: I${capitalizeFirstLetter(name)}Repository;
 
@@ -38,8 +32,8 @@ describe('${capitalizeFirstLetter(name)}CreateUsecase', () => {
         },
         {
           provide: I${capitalizeFirstLetter(name)}CreateAdapter,
-          useFactory: (birdRepository: I${capitalizeFirstLetter(name)}Repository, logger: ILoggerAdapter) => {
-            return new ${capitalizeFirstLetter(name)}CreateUsecase(birdRepository, logger);
+          useFactory: (${name}Repository: I${capitalizeFirstLetter(name)}Repository, logger: ILoggerAdapter) => {
+            return new ${capitalizeFirstLetter(name)}CreateUsecase(${name}Repository, logger);
           },
           inject: [I${capitalizeFirstLetter(name)}Repository, ILoggerAdapter]
         }
@@ -52,34 +46,24 @@ describe('${capitalizeFirstLetter(name)}CreateUsecase', () => {
 
   test('when no input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute(failureInput),
+      () => usecase.execute({}),
       (issues) => {
         expect(issues).toEqual([{ message: 'Required', path: ${capitalizeFirstLetter(name)}Entity.nameOf('name') }]);
       }
     );
   });
 
-  test('when ${name} created successfully, should expect a ${name} that has been created', async () => {
+  const input: ${capitalizeFirstLetter(name)}CreateInput = {
+    name: 'name'
+  };
+
+  test('when ${name} created successfully, should expect a ${name}', 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(successInput)).rejects.toThrow(ApiInternalServerException);
+    await expect(usecase.execute(input)).resolves.toEqual(createOutput);
   });
 });
 `

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

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

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

@@ -13,13 +13,7 @@ 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';
 
-const successInput: ${capitalizeFirstLetter(name)}GetByIdInput = {
-  id: getMockUUID()
-};
-
-const failureInput: ${capitalizeFirstLetter(name)}GetByIdInput = {};
-
-describe('${capitalizeFirstLetter(name)}GetByIdUsecase', () => {
+describe(${capitalizeFirstLetter(name)}GetByIdUsecase.name, () => {
   let usecase: I${capitalizeFirstLetter(name)}GetByIdAdapter;
   let repository: I${capitalizeFirstLetter(name)}Repository;
 
@@ -47,20 +41,24 @@ describe('${capitalizeFirstLetter(name)}GetByIdUsecase', () => {
 
   test('when no input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute(failureInput),
+      () => usecase.execute({}),
       (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(successInput)).rejects.toThrowError(ApiNotFoundException);
+    await expect(usecase.execute(input)).rejects.toThrow(ApiNotFoundException);
   });
 
-  test('when ${name} found, should expect a ${name} that has been found', async () => {
+  test('when ${name} found, should expect a ${name}', async () => {
     const findByIdOutput: ${capitalizeFirstLetter(name)}GetByIdOutput = new ${capitalizeFirstLetter(name)}Entity({
       id: '61cc35f3-03d9-4b7f-9c63-59f32b013ef5',
       name: 'dummy'
@@ -68,7 +66,7 @@ describe('${capitalizeFirstLetter(name)}GetByIdUsecase', () => {
 
     repository.findById = jest.fn().mockResolvedValue(findByIdOutput);
 
-    await expect(usecase.execute(successInput)).resolves.toEqual(findByIdOutput);
+    await expect(usecase.execute(input)).resolves.toEqual(findByIdOutput);
   });
 });
 `

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

@@ -12,11 +12,7 @@ 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';
 
-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', () => {
+describe(${capitalizeFirstLetter(name)}ListUsecase.name, () => {
   let usecase: I${capitalizeFirstLetter(name)}ListAdapter;
   let repository: I${capitalizeFirstLetter(name)}Repository;
 
@@ -44,13 +40,15 @@ describe('${capitalizeFirstLetter(name)}ListUsecase', () => {
 
   test('when sort input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute(failureInput),
+      () => usecase.execute({ search: null, sort: null, limit: 10, page: 1 }),
       (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(),
@@ -63,7 +61,7 @@ describe('${capitalizeFirstLetter(name)}ListUsecase', () => {
 
     repository.paginate = jest.fn().mockResolvedValue(paginateOutput);
 
-    await expect(usecase.execute(successInput)).resolves.toEqual({
+    await expect(usecase.execute(input)).resolves.toEqual({
       docs: [doc],
       page: 1,
       limit: 1,
@@ -76,7 +74,7 @@ describe('${capitalizeFirstLetter(name)}ListUsecase', () => {
 
     repository.paginate = jest.fn().mockResolvedValue(paginateOutput);
 
-    await expect(usecase.execute(successInput)).resolves.toEqual(paginateOutput);
+    await expect(usecase.execute(input)).resolves.toEqual(paginateOutput);
   });
 });
 `

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

@@ -12,16 +12,9 @@ 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 } from '../${name}-update';
-import { ${capitalizeFirstLetter(name)}UpdateUsecase } from '../${name}-update';
+import { ${capitalizeFirstLetter(name)}UpdateInput, ${capitalizeFirstLetter(name)}UpdateOutput, ${capitalizeFirstLetter(name)}UpdateUsecase } from '../${name}-update';
 
-const successInput: ${capitalizeFirstLetter(name)}UpdateInput = {
-  id: getMockUUID()
-};
-
-const failureInput: ${capitalizeFirstLetter(name)}UpdateInput = {};
-
-describe('${capitalizeFirstLetter(name)}UpdateUsecase', () => {
+describe(${capitalizeFirstLetter(name)}UpdateUsecase.name, () => {
   let usecase: I${capitalizeFirstLetter(name)}UpdateAdapter;
   let repository: I${capitalizeFirstLetter(name)}Repository;
 
@@ -49,20 +42,24 @@ describe('${capitalizeFirstLetter(name)}UpdateUsecase', () => {
 
   test('when no input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute(failureInput),
+      () => usecase.execute({}),
       (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(successInput)).rejects.toThrowError(ApiNotFoundException);
+    await expect(usecase.execute(input)).rejects.toThrow(ApiNotFoundException);
   });
 
-  test('when ${name} updated successfully, should expect an ${name} that has been updated', async () => {
+  test('when ${name} updated successfully, should expect an ${name}', async () => {
     const findByIdOutput: ${capitalizeFirstLetter(name)}UpdateOutput = new ${capitalizeFirstLetter(name)}Entity({
       id: getMockUUID(),
       name: 'dummy'
@@ -71,7 +68,7 @@ describe('${capitalizeFirstLetter(name)}UpdateUsecase', () => {
     repository.findById = jest.fn().mockResolvedValue(findByIdOutput);
     repository.updateOne = jest.fn().mockResolvedValue(null);
 
-    await expect(usecase.execute(successInput)).resolves.toEqual(findByIdOutput);
+    await expect(usecase.execute(input)).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 '@/utils/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,25 +21,19 @@ 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 session = await this.${name}Repository.startSession();
-
-    try {
-      const ${name} = await this.${name}Repository.create(entity, { session });
-
-      await session.commitTransaction();
+    const ${name} = await this.${name}Repository.create(entity);
 
-      this.loggerService.info({ message: '${name} created.', obj: { ${name} } });
-      return ${name};
-    } catch (error) {
-      await session.abortTransaction();
-      throw error;
-    }
+    this.loggerService.info({ message: '${name} created.', obj: { ${name} } });
+    return ${name};
   }
 }
 `

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

@@ -27,7 +27,7 @@ export class ${capitalizeFirstLetter(name)}DeleteUsecase implements IUsecase {
     const model = await this.${name}Repository.findById(id);
 
     if (!model) {
-      throw new ApiNotFoundException();
+      throw new ApiNotFoundException('${name}NotFound');
     }
 
     const ${name} = new ${capitalizeFirstLetter(name)}Entity(model);

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

@@ -26,7 +26,7 @@ export class ${capitalizeFirstLetter(name)}GetByIdUsecase implements IUsecase {
     const ${name} = await this.${name}Repository.findById(id);
 
     if (!${name}) {
-      throw new ApiNotFoundException();
+      throw new ApiNotFoundException('${name}NotFound');
     }
 
     const entity = new ${capitalizeFirstLetter(name)}Entity(${name});

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

@@ -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();
+      throw new ApiNotFoundException('${name}NotFound');
     }
 
     const ${name}Finded = new ${capitalizeFirstLetter(name)}Entity(${name});

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

@@ -14,28 +14,30 @@ import { ${capitalizeFirstLetter(name)}UpdateOutput } from '@/core/${name}/use-c
 import { Swagger } from '@/utils/docs/swagger';
 
 const input = new ${capitalizeFirstLetter(name)}Entity({
-  name: '<name>'
+  name: 'name'
 });
 
 const output = new ${capitalizeFirstLetter(name)}Entity({ ...input, updatedAt: new Date(), createdAt: new Date(), deletedAt: null });
 
+const BASE_URL = 'api/v1/${pluralize(name)}';
+
 export const SwaggerResponse = {
   create: {
     200: Swagger.defaultResponseJSON({
       status: 200,
-      json: { created: true, id: '<uuid>' } as ${capitalizeFirstLetter(name)}CreateOutput,
-      description: '${name} created.'
+      json: { created: true, id: 'uuid' } as ${capitalizeFirstLetter(name)}CreateOutput,
+      description: 'create ${name}.'
     })
   },
   update: {
     200: Swagger.defaultResponseJSON({
       status: 200,
       json: output as ${capitalizeFirstLetter(name)}UpdateOutput,
-      description: '${name} updated.'
+      description: 'update ${name}.'
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/v1/${pluralize(name)}',
+      route: BASE_URL.concat('/:id'),
       message: '${name}NotFound',
       description: '${name} not found.'
     })
@@ -44,11 +46,11 @@ export const SwaggerResponse = {
     200: Swagger.defaultResponseJSON({
       status: 200,
       json: output as ${capitalizeFirstLetter(name)}GetByIdOutput,
-      description: '${name} found.'
+      description: 'get ${name}.'
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/v1/${pluralize(name)}/:id',
+      route: BASE_URL.concat('/:id'),
       message: '${name}NotFound',
       description: '${name} not found.'
     })
@@ -57,11 +59,11 @@ export const SwaggerResponse = {
     200: Swagger.defaultResponseJSON({
       status: 200,
       json: output as ${capitalizeFirstLetter(name)}DeleteOutput,
-      description: '${name} found.'
+      description: 'delete ${name}.'
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/v1/${pluralize(name)}/:id',
+      route: BASE_URL.concat('/:id'),
       message: '${name}NotFound',
       description: '${name} not found.'
     })
@@ -70,30 +72,15 @@ export const SwaggerResponse = {
     200: Swagger.defaultResponseJSON({
       status: 200,
       json: { docs: [output], page: 1, limit: 1, total: 1 } as ${capitalizeFirstLetter(name)}ListOutput,
-      description: '${name} created.'
+      description: 'list ${pluralize(name)}.'
     })
   }
 };
 
 export const SwaggerRequest = {
   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 }),
-      page: Swagger.defaultApiQueryOptions({ example: 1, name: 'page', required: false })
-    },
-    sort: Swagger.defaultApiQueryOptions({
-      name: 'sort',
-      required: false,
-      description: '<b>createdAt:desc,name:asc'
-    }),
-    search: Swagger.defaultApiQueryOptions({
-      name: 'search',
-      required: false,
-      description: '<b>name:miau'
-    })
-  }
+  updateBody: Swagger.defaultRequestJSON(input as ${capitalizeFirstLetter(name)}Entity),
+  listQuery: Swagger.defaultRequestListJSON()
 };
 `
 

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

@@ -13,13 +13,7 @@ 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';
 
-const successInput: ${capitalizeFirstLetter(name)}CreateInput = {
-  name: 'dummy'
-};
-
-const failureInput: ${capitalizeFirstLetter(name)}CreateInput = {};
-
-describe('${capitalizeFirstLetter(name)}CreateUsecase', () => {
+describe(${capitalizeFirstLetter(name)}CreateUsecase.name, () => {
   let usecase: I${capitalizeFirstLetter(name)}CreateAdapter;
   let repository: I${capitalizeFirstLetter(name)}Repository;
 
@@ -52,19 +46,23 @@ describe('${capitalizeFirstLetter(name)}CreateUsecase', () => {
 
   test('when no input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute(failureInput),
+      () => usecase.execute({}),
       (issues) => {
         expect(issues).toEqual([{ message: 'Required', path: ${capitalizeFirstLetter(name)}Entity.nameOf('name') }]);
       }
     );
   });
 
-  test('when ${name} created successfully, should expect a ${name} that has been created', async () => {
+  const input: ${capitalizeFirstLetter(name)}CreateInput = {
+    name: 'dummy'
+  };
+
+  test('when ${name} created successfully, should expect a ${name}', async () => {
     const createOutput: ${capitalizeFirstLetter(name)}CreateOutput = { created: true, id: getMockUUID() };
 
     repository.create = jest.fn().mockResolvedValue(createOutput);
-   
-    await expect(usecase.execute(successInput)).resolves.toEqual(createOutput);
+
+    await expect(usecase.execute(input)).resolves.toEqual(createOutput);
   });
 });
 `

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

@@ -13,13 +13,7 @@ import { expectZodError, getMockUUID } from '@/utils/tests';
 import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
 import { ${capitalizeFirstLetter(name)}Entity } from './../../entity/${name}';
 
-const successInput: ${capitalizeFirstLetter(name)}DeleteInput = {
-  id: getMockUUID()
-};
-
-const failureInput: ${capitalizeFirstLetter(name)}DeleteInput = {};
-
-describe('${capitalizeFirstLetter(name)}DeleteUsecase', () => {
+describe(${capitalizeFirstLetter(name)}DeleteUsecase.name, () => {
   let usecase: I${capitalizeFirstLetter(name)}DeleteAdapter;
   let repository: I${capitalizeFirstLetter(name)}Repository;
 
@@ -46,20 +40,24 @@ describe('${capitalizeFirstLetter(name)}DeleteUsecase', () => {
 
   test('when no input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute(failureInput),
+      () => usecase.execute({}),
       (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(successInput)).rejects.toThrowError(ApiNotFoundException);
+    await expect(usecase.execute(input)).rejects.toThrow(ApiNotFoundException);
   });
 
-  test('when ${name} deleted successfully, should expect a ${name} that has been deleted', async () => {
+  test('when ${name} deleted successfully, should expect a ${name}', async () => {
     const findByIdOutput: ${capitalizeFirstLetter(name)}DeleteOutput = new ${capitalizeFirstLetter(name)}Entity({
       id: getMockUUID(),
       name: 'dummy'
@@ -68,7 +66,7 @@ describe('${capitalizeFirstLetter(name)}DeleteUsecase', () => {
     repository.findById = jest.fn().mockResolvedValue(findByIdOutput);
     repository.updateOne = jest.fn();
 
-    await expect(usecase.execute(successInput)).resolves.toEqual({
+    await expect(usecase.execute(input)).resolves.toEqual({
       ...findByIdOutput,
       deletedAt: expect.any(Date)
     });

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

@@ -13,13 +13,7 @@ import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${na
 import { ${capitalizeFirstLetter(name)}GetByIdInput, ${capitalizeFirstLetter(name)}GetByIdOutput, ${capitalizeFirstLetter(name)}GetByIdUsecase } from '../${name}-get-by-id';
 import { ${capitalizeFirstLetter(name)}Entity } from './../../entity/${name}';
 
-const successInput: ${capitalizeFirstLetter(name)}GetByIdInput = {
-  id: getMockUUID()
-};
-
-const failureInput: ${capitalizeFirstLetter(name)}GetByIdInput = {};
-
-describe('${capitalizeFirstLetter(name)}GetByIdUsecase', () => {
+describe(${capitalizeFirstLetter(name)}GetByIdUsecase.name, () => {
   let usecase: I${capitalizeFirstLetter(name)}GetByIdAdapter;
   let repository: I${capitalizeFirstLetter(name)}Repository;
 
@@ -46,27 +40,31 @@ describe('${capitalizeFirstLetter(name)}GetByIdUsecase', () => {
 
   test('when no input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute(failureInput),
+      () => usecase.execute({}),
       (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(successInput)).rejects.toThrowError(ApiNotFoundException);
+    await expect(usecase.execute(input)).rejects.toThrow(ApiNotFoundException);
   });
 
-  test('when ${name} found, should expect a ${name} that has been found', async () => {
+  test('when ${name} found, should expect a ${name}', async () => {
     const findByIdOutput: ${capitalizeFirstLetter(name)}GetByIdOutput = new ${capitalizeFirstLetter(name)}Entity({
       id: getMockUUID(),
       name: 'dummy'
     });
     repository.findById = jest.fn().mockResolvedValue(findByIdOutput);
 
-    await expect(usecase.execute(successInput)).resolves.toEqual(findByIdOutput);
+    await expect(usecase.execute(input)).resolves.toEqual(findByIdOutput);
   });
 });
 `

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

@@ -12,11 +12,7 @@ import { expectZodError, getMockUUID } from '@/utils/tests';
 import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
 import { ${capitalizeFirstLetter(name)}Entity } from './../../entity/${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', () => {
+describe(${capitalizeFirstLetter(name)}ListUsecase.name, () => {
   let usecase: I${capitalizeFirstLetter(name)}ListAdapter;
   let repository: I${capitalizeFirstLetter(name)}Repository;
 
@@ -43,13 +39,15 @@ describe('${capitalizeFirstLetter(name)}ListUsecase', () => {
 
   test('when sort input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute(failureInput),
+      () => usecase.execute({ search: null, sort: null, limit: 10, page: 1 }),
       (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(),
@@ -62,7 +60,7 @@ describe('${capitalizeFirstLetter(name)}ListUsecase', () => {
 
     repository.paginate = jest.fn().mockResolvedValue(paginateOutput);
 
-    await expect(usecase.execute(successInput)).resolves.toEqual({
+    await expect(usecase.execute(input)).resolves.toEqual({
       docs: [doc],
       page: 1,
       limit: 1,
@@ -75,7 +73,7 @@ describe('${capitalizeFirstLetter(name)}ListUsecase', () => {
 
     repository.paginate = jest.fn().mockResolvedValue(paginateOutput);
 
-    await expect(usecase.execute(successInput)).resolves.toEqual(paginateOutput);
+    await expect(usecase.execute(input)).resolves.toEqual(paginateOutput);
   });
 });
 `

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

@@ -14,13 +14,7 @@ import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${na
 import { ${capitalizeFirstLetter(name)}UpdateInput, ${capitalizeFirstLetter(name)}UpdateOutput, ${capitalizeFirstLetter(name)}UpdateUsecase } from '../${name}-update';
 import { ${capitalizeFirstLetter(name)}Entity } from './../../entity/${name}';
 
-const successInput: ${capitalizeFirstLetter(name)}UpdateInput = {
-  id: getMockUUID()
-};
-
-const failureInput: ${capitalizeFirstLetter(name)}UpdateInput = {};
-
-describe('${capitalizeFirstLetter(name)}UpdateUsecase', () => {
+describe(${capitalizeFirstLetter(name)}UpdateUsecase.name, () => {
   let usecase: I${capitalizeFirstLetter(name)}UpdateAdapter;
   let repository: I${capitalizeFirstLetter(name)}Repository;
 
@@ -53,20 +47,24 @@ describe('${capitalizeFirstLetter(name)}UpdateUsecase', () => {
 
   test('when no input is specified, should expect an error', async () => {
     await expectZodError(
-      () => usecase.execute(failureInput),
+      () => usecase.execute({}),
       (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(successInput)).rejects.toThrowError(ApiNotFoundException);
+    await expect(usecase.execute(input)).rejects.toThrow(ApiNotFoundException);
   });
 
-  test('when ${name} updated successfully, should expect an ${name} that has been updated', async () => {
+  test('when ${name} updated successfully, should expect an ${name}', async () => {
     const findByIdOutput: ${capitalizeFirstLetter(name)}UpdateOutput = new ${capitalizeFirstLetter(name)}Entity({
       id: getMockUUID(),
       name: 'dummy'
@@ -75,7 +73,7 @@ describe('${capitalizeFirstLetter(name)}UpdateUsecase', () => {
     repository.findById = jest.fn().mockResolvedValue(findByIdOutput);
     repository.updateOne = jest.fn().mockResolvedValue(null);
 
-    await expect(usecase.execute(successInput)).resolves.toEqual(findByIdOutput);
+    await expect(usecase.execute(input)).resolves.toEqual(findByIdOutput);
   });
 });
 `

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

@@ -28,7 +28,7 @@ export class ${capitalizeFirstLetter(name)}DeleteUsecase implements IUsecase {
     const model = await this.${name}Repository.findById(id);
 
     if (!model) {
-      throw new ApiNotFoundException();
+      throw new ApiNotFoundException('${name}NotFound');
     }
 
     const ${name} = new ${capitalizeFirstLetter(name)}Entity(model);

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

@@ -29,7 +29,7 @@ export class ${capitalizeFirstLetter(name)}GetByIdUsecase implements IUsecase {
     const ${name} = await this.${name}Repository.findById(id);
 
     if (!${name}) {
-      throw new ApiNotFoundException();
+      throw new ApiNotFoundException('${name}NotFound');
     }
 
     return new ${capitalizeFirstLetter(name)}Entity(${name});

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

@@ -29,7 +29,7 @@ export class ${capitalizeFirstLetter(name)}UpdateUsecase implements IUsecase {
     const ${name} = await this.${name}Repository.findById(input.id);
 
     if (!${name}) {
-      throw new ApiNotFoundException();
+      throw new ApiNotFoundException('${name}NotFound');
     }
 
     const ${name}Finded = new ${capitalizeFirstLetter(name)}Entity(${name});

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

@@ -14,17 +14,19 @@ import { ${capitalizeFirstLetter(name)}UpdateOutput } from '@/core/${name}/use-c
 import { Swagger } from '@/utils/docs/swagger';
 
 const input = new ${capitalizeFirstLetter(name)}Entity({
-  name: '<name>'
+  name: 'name'
 });
 
 const output = new ${capitalizeFirstLetter(name)}Entity({ ...input, updatedAt: new Date(), createdAt: new Date(), deletedAt: null });
 
+const BASE_URL = 'api/v1/${pluralize(name)}';
+
 export const SwaggerResponse = {
   create: {
     200: Swagger.defaultResponseJSON({
       status: 200,
-      json: { created: true, id: '<uuid>' } as ${capitalizeFirstLetter(name)}CreateOutput,
-      description: '${name} created.'
+      json: { created: true, id: 'uuid' } as ${capitalizeFirstLetter(name)}CreateOutput,
+      description: 'create ${name}.'
     })
   },
   update: {
@@ -35,9 +37,9 @@ export const SwaggerResponse = {
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/v1/${pluralize(name)}',
+      route: BASE_URL.concat('/:id'),
       message: '${name}NotFound',
-      description: '${name} not found.'
+      description: 'update ${name}.'
     })
   },
   getById: {
@@ -48,52 +50,37 @@ export const SwaggerResponse = {
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/v1/${pluralize(name)}/:id',
+      route: BASE_URL.concat('/:id'),
       message: '${name}NotFound',
-      description: '${name} not found.'
+      description: 'get ${name}.'
     })
   },
   delete: {
     200: Swagger.defaultResponseJSON({
       status: 200,
       json: output as ${capitalizeFirstLetter(name)}DeleteOutput,
-      description: '${name} found.'
+      description: 'delete ${name}.'
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/v1/${pluralize(name)}/:id',
+      route: BASE_URL.concat('/:id'),
       message: '${name}NotFound',
-      description: '${name} not found.'
+      description: '${name}NotFound.'
     })
   },
   list: {
     200: Swagger.defaultResponseJSON({
       status: 200,
       json: { docs: [output], page: 1, limit: 1, total: 1 } as ${capitalizeFirstLetter(name)}ListOutput,
-      description: '${name} created.'
+      description: 'list ${pluralize(name)}.'
     })
   }
 };
 
 export const SwaggerRequest = {
   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 }),
-      page: Swagger.defaultApiQueryOptions({ example: 1, name: 'page', required: false })
-    },
-    sort: Swagger.defaultApiQueryOptions({
-      name: 'sort',
-      required: false,
-      description: '<b>createdAt:desc,name:asc'
-    }),
-    search: Swagger.defaultApiQueryOptions({
-      name: 'search',
-      required: false,
-      description: '<b>name:miau'
-    })
-  }
+  updateBody: Swagger.defaultRequestJSON(input as ${capitalizeFirstLetter(name)}Entity),
+  listQuery: Swagger.defaultRequestListJSON()
 };
 `