@mikemajesty/microservice-crud 0.0.7 → 0.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikemajesty/microservice-crud",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Monorepo CLI",
   "main": "src/cli.js",
   "scripts": {
@@ -21,6 +21,7 @@
   "license": "MIT",
   "dependencies": {
     "arg": "^5.0.1",
+    "chmod": "^0.2.1",
     "cli-select": "^1.1.2",
     "colorette": "^2.0.19",
     "esm": "^3.2.25",

package/src/cli.js

@@ -24,7 +24,6 @@ const { getModule } = require('./templates/postgres/modules/module');
 const { getModuleRepository } = require('./templates/postgres/modules/repository');
 const { getModuleSchema } = require('./templates/postgres/schemas/schema');
 const { getModuleSwagger } = require('./templates/postgres/modules/swagger');
-const { getModuleType } = require('./templates/postgres/modules/types');
 
 const { getCoreUsecaseCreateTest: getCoreUsecaseCreateMongoTest } = require('./templates/mongo/core/use-cases/__tests__/create.spec');
 const { getCoreUsecaseUpdateTest: getCoreUsecaseUpdateMongoTest } = require('./templates/mongo/core/use-cases/__tests__/update.spec');
@@ -45,8 +44,6 @@ const { getModule: getModuleMongo } = require('./templates/mongo/modules/module'
 const { getModuleRepository: getModuleRepositoryMongo } = require('./templates/mongo/modules/repository');
 const { getModuleSchema: getModuleSchemaMongo } = require('./templates/mongo/schemas/schema');
 const { getModuleSwagger: getModuleSwaggerMongo } = require('./templates/mongo/modules/swagger');
-const { getModuleType: getModuleTypeMongo } = require('./templates/mongo/modules/types');
-
 
 const createPostgresCrud = async (name) => {
   if (!name) throw new Error('--name is required')
@@ -108,8 +105,6 @@ const createPostgresCrud = async (name) => {
     fs.writeFileSync(`${modulesPath}/module.ts`, getModule(name))
     fs.writeFileSync(`${modulesPath}/repository.ts`, getModuleRepository(name))
     fs.writeFileSync(`${modulesPath}/swagger.ts`, getModuleSwagger(name))
-    fs.writeFileSync(`${modulesPath}/types.ts`, getModuleType(name))
-
 
     return `${name}`
   } catch (error) {
@@ -170,7 +165,7 @@ const createMongoCrud = async (name) => {
     fs.writeFileSync(`${useCasesPathTest}/${name}-getByID.spec.ts`, getCoreUsecaseGetByIDMongoTest(name))
 
     const schemasPath = `${__dirname}/scafold/mongo/schemas`;
-    
+
     if (fs.existsSync(schemasPath)) {
       fs.rmSync(schemasPath, { recursive: true });
     }
@@ -187,7 +182,6 @@ const createMongoCrud = async (name) => {
     fs.writeFileSync(`${modulesPath}/repository.ts`, getModuleRepositoryMongo(name))
     fs.writeFileSync(`${modulesPath}/schema.ts`, getModuleSchemaMongo(name))
     fs.writeFileSync(`${modulesPath}/swagger.ts`, getModuleSwaggerMongo(name))
-    fs.writeFileSync(`${modulesPath}/types.ts`, getModuleTypeMongo(name))
 
     return `${name}`
   } catch (error) {
@@ -294,9 +288,9 @@ export async function cli(args) {
         const destination = `${dest}/src/${folder}`.replace('\n', '');
 
         fse.copySync(source, destination, { overwrite: true });
-        
+
         const destPathSchema = `${dest}/src/infra/database/${userInput.type === 'postgres:crud' ? 'postgres' : 'mongo'}/schemas`;
-        
+
         const pathSchema = path.resolve(src, '../schemas');
 
         fse.copySync(pathSchema, destPathSchema, { overwrite: true });
@@ -304,6 +298,10 @@ export async function cli(args) {
         if (fs.existsSync(source)) {
           fs.rmSync(source, { recursive: true });
         }
+
+        if (fs.existsSync(pathSchema + `/${name}.ts`)) {
+          fs.rmSync(pathSchema + `/${name}.ts`, { recursive: true });
+        }
       }
 
       console.log(bold(green('===done===')))

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

@@ -4,12 +4,14 @@ function capitalizeFirstLetter(string) {
 }
 
 const getCoreRepository = (name) => `import { IRepository } from '@/infra/repository';
-import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from '@/modules/${name}/types';
+import { MongoRepositorySession } from '@/utils/database/mongoose';
 
 import { ${capitalizeFirstLetter(name)}Entity } from '../entity/${name}';
+import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from '../use-cases/${name}-list';
 
 export abstract class I${capitalizeFirstLetter(name)}Repository extends IRepository<${capitalizeFirstLetter(name)}Entity> {
   abstract paginate(input: ${capitalizeFirstLetter(name)}ListInput): Promise<${capitalizeFirstLetter(name)}ListOutput>;
+  abstract startSession(): Promise<MongoRepositorySession>;
 }
 `
 

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

@@ -3,22 +3,42 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getCoreUsecaseCreate = (name) => `import { ${capitalizeFirstLetter(name)}CreateInput, ${capitalizeFirstLetter(name)}CreateOutput, ${capitalizeFirstLetter(name)}CreateSchema } from '@/modules/${name}/types';
+const getCoreUsecaseCreate = (name) => `import { z } from 'zod';
+
+import { ILoggerAdapter } from '@/infra/logger';
+import { CreatedModel } from '@/infra/repository';
 import { ValidateSchema } from '@/utils/decorators/validate-schema.decorator';
 
-import { ${capitalizeFirstLetter(name)}Entity } from '../entity/${name}';
+import { ${capitalizeFirstLetter(name)}Entity, ${capitalizeFirstLetter(name)}EntitySchema } from '../entity/${name}';
 import { I${capitalizeFirstLetter(name)}Repository } from '../repository/${name}';
 
+export const ${capitalizeFirstLetter(name)}CreateSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
+  name: true
+});
+
+export type ${capitalizeFirstLetter(name)}CreateInput = z.infer<typeof ${capitalizeFirstLetter(name)}CreateSchema>;
+export type ${capitalizeFirstLetter(name)}CreateOutput = Promise<CreatedModel>;
+
 export class ${capitalizeFirstLetter(name)}CreateUsecase {
-  constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}
+  constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository, private readonly loggerServide: 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();
+
+    try {
+      const ${name} = await this.${name}Repository.create(entity, { session });
+
+      await session.commitTransaction();
 
-    return ${name};
+      this.loggerServide.info({ message: '${name} created.', obj: { ${name} } });
+      return ${name};
+    } catch (error) {
+      await session.abortTransaction();
+      throw error;
+    }
   }
 }
 `

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

@@ -3,13 +3,21 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getCoreUsecaseDelete = (name) => `import { ${capitalizeFirstLetter(name)}DeleteInput, ${capitalizeFirstLetter(name)}DeleteOutput, ${capitalizeFirstLetter(name)}DeleteSchema } from '@/modules/${name}/types';
+const getCoreUsecaseDelete = (name) => `import { z } from 'zod';
+
 import { ValidateSchema } from '@/utils/decorators/validate-schema.decorator';
 import { ApiNotFoundException } from '@/utils/exception';
 
-import { ${capitalizeFirstLetter(name)}Entity } from '../entity/${name}';
+import { ${capitalizeFirstLetter(name)}Entity, ${capitalizeFirstLetter(name)}EntitySchema } from '../entity/${name}';
 import { I${capitalizeFirstLetter(name)}Repository } from '../repository/${name}';
 
+export const ${capitalizeFirstLetter(name)}DeleteSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
+  id: true
+});
+
+export type ${capitalizeFirstLetter(name)}DeleteInput = z.infer<typeof ${capitalizeFirstLetter(name)}DeleteSchema>;
+export type ${capitalizeFirstLetter(name)}DeleteOutput = Promise<${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

@@ -3,14 +3,20 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getCoreUsecaseGetByID = (name) => `import { ${capitalizeFirstLetter(name)}GetByIdSchema } from '@/modules/${name}/types';
-import { ${capitalizeFirstLetter(name)}GetByIDInput, ${capitalizeFirstLetter(name)}GetByIDOutput } from '@/modules/${name}/types';
+const getCoreUsecaseGetByID = (name) => `import { z } from 'zod';
+
 import { ValidateSchema } from '@/utils/decorators/validate-schema.decorator';
 import { ApiNotFoundException } from '@/utils/exception';
 
-import { ${capitalizeFirstLetter(name)}Entity } from '../entity/${name}';
+import { ${capitalizeFirstLetter(name)}Entity, ${capitalizeFirstLetter(name)}EntitySchema } from '../entity/${name}';
 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 = Promise<${capitalizeFirstLetter(name)}Entity>;
+
 export class ${capitalizeFirstLetter(name)}GetByIdUsecase {
   constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}
 
@@ -22,7 +28,9 @@ export class ${capitalizeFirstLetter(name)}GetByIdUsecase {
       throw new ApiNotFoundException('${name}NotFound');
     }
 
-    return new ${capitalizeFirstLetter(name)}Entity(${name});
+    const entity = new ${capitalizeFirstLetter(name)}Entity(${name});
+
+    return entity;
   }
 }
 `

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

@@ -1,22 +1,37 @@
+const pluralize = require('pluralize')
 
 function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getCoreUsecaseList = (name) => `import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput, ${capitalizeFirstLetter(name)}ListSchema } from '@/modules/${name}/types';
+const getCoreUsecaseList = (name) => `import { z } from 'zod';
+
 import { ValidateSchema } from '@/utils/decorators/validate-schema.decorator';
+import { PaginationInput, PaginationOutput, PaginationSchema } from '@/utils/pagination';
+import { SearchSchema } from '@/utils/search';
+import { SortSchema } from '@/utils/sort';
 
 import { ${capitalizeFirstLetter(name)}Entity } from '../entity/${name}';
 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 class ${capitalizeFirstLetter(name)}ListUsecase {
   constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}
 
   @ValidateSchema(${capitalizeFirstLetter(name)}ListSchema)
   async execute(input: ${capitalizeFirstLetter(name)}ListInput): Promise<${capitalizeFirstLetter(name)}ListOutput> {
-    const ${name}s = await this.${name}Repository.paginate(input);
+    const ${pluralize(name)} = await this.${name}Repository.paginate(input);
 
-    return { docs: ${name}s.docs.map((u) => new ${capitalizeFirstLetter(name)}Entity(u)), limit: ${name}s.limit, page: ${name}s.page, total: ${name}s.total };
+    return {
+      docs: ${pluralize(name)}.docs.map((u) => new ${capitalizeFirstLetter(name)}Entity(u)),
+      limit: ${pluralize(name)}.limit,
+      page: ${pluralize(name)}.page,
+      total: ${pluralize(name)}.total
+    };
   }
 }
 `

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

@@ -3,14 +3,22 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getCoreUsecaseUpdate = (name) => `import { ILoggerAdapter } from '@/infra/logger';
-import { ${capitalizeFirstLetter(name)}UpdateInput, ${capitalizeFirstLetter(name)}UpdateOutput, ${capitalizeFirstLetter(name)}UpdateSchema } from '@/modules/${name}/types';
+const getCoreUsecaseUpdate = (name) => `import { z } from 'zod';
+
+import { ILoggerAdapter } from '@/infra/logger';
 import { ValidateSchema } from '@/utils/decorators/validate-schema.decorator';
 import { ApiNotFoundException } from '@/utils/exception';
 
-import { ${capitalizeFirstLetter(name)}Entity } from '../entity/${name}';
+import { ${capitalizeFirstLetter(name)}Entity, ${capitalizeFirstLetter(name)}EntitySchema } from '../entity/${name}';
 import { I${capitalizeFirstLetter(name)}Repository } from '../repository/${name}';
 
+export const ${capitalizeFirstLetter(name)}UpdateSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
+  id: true
+}).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 class ${capitalizeFirstLetter(name)}UpdateUsecase {
   constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository, private readonly loggerServide: ILoggerAdapter) {}
 

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

@@ -3,18 +3,11 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getModuleAdapter = (name) => `import {
-  ${capitalizeFirstLetter(name)}CreateInput,
-  ${capitalizeFirstLetter(name)}CreateOutput,
-  ${capitalizeFirstLetter(name)}DeleteInput,
-  ${capitalizeFirstLetter(name)}DeleteOutput,
-  ${capitalizeFirstLetter(name)}GetByIDInput,
-  ${capitalizeFirstLetter(name)}GetByIDOutput,
-  ${capitalizeFirstLetter(name)}ListInput,
-  ${capitalizeFirstLetter(name)}ListOutput,
-  ${capitalizeFirstLetter(name)}UpdateInput,
-  ${capitalizeFirstLetter(name)}UpdateOutput
-} from './types';
+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}-getByID';
+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';
 
 export abstract class I${capitalizeFirstLetter(name)}CreateAdapter {
   abstract execute(input: ${capitalizeFirstLetter(name)}CreateInput): Promise<${capitalizeFirstLetter(name)}CreateOutput>;

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

@@ -4,11 +4,17 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getModuleController = (name) => `import { Body, Controller, Delete, Get, Param, Post, Put, Query } from '@nestjs/common';
+const getModuleController = (name) => `import { Controller, Delete, Get, Post, Put, Req } from '@nestjs/common';
 import { ApiBearerAuth, ApiBody, ApiParam, ApiQuery, ApiResponse, ApiTags } from '@nestjs/swagger';
 
+import { ${capitalizeFirstLetter(name)}CreateInput, ${capitalizeFirstLetter(name)}CreateOutput } from '@/core/${name}/use-cases/${name}-create';
+import { ${capitalizeFirstLetter(name)}DeleteInput, ${capitalizeFirstLetter(name)}DeleteOutput } from '@/core/${name}/use-cases/${name}-delete';
+import { ${capitalizeFirstLetter(name)}GetByIDInput, ${capitalizeFirstLetter(name)}GetByIDOutput } from '@/core/${name}/use-cases/${name}-getByID';
+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 { UserRole } from '@/core/user/entity/user';
 import { Roles } from '@/utils/decorators/role.decorator';
+import { ApiRequest } from '@/utils/request';
 import { SearchHttpSchema } from '@/utils/search';
 import { SortHttpSchema } from '@/utils/sort';
 
@@ -20,18 +26,6 @@ import {
   I${capitalizeFirstLetter(name)}UpdateAdapter
 } from './adapter';
 import { SwagggerRequest, SwagggerResponse } from './swagger';
-import {
-  ${capitalizeFirstLetter(name)}CreateInput,
-  ${capitalizeFirstLetter(name)}CreateOutput,
-  ${capitalizeFirstLetter(name)}DeleteInput,
-  ${capitalizeFirstLetter(name)}DeleteOutput,
-  ${capitalizeFirstLetter(name)}GetByIDInput,
-  ${capitalizeFirstLetter(name)}GetByIDOutput,
-  ${capitalizeFirstLetter(name)}ListInput,
-  ${capitalizeFirstLetter(name)}ListOutput,
-  ${capitalizeFirstLetter(name)}UpdateInput,
-  ${capitalizeFirstLetter(name)}UpdateOutput
-} from './types';
 
 @Controller()
 @ApiTags('${name}')
@@ -49,16 +43,16 @@ export class ${capitalizeFirstLetter(name)}Controller {
   @Post('/${pluralize(name)}')
   @ApiResponse(SwagggerResponse.create[200])
   @ApiBody(SwagggerRequest.createBody)
-  async create(@Body() input: ${capitalizeFirstLetter(name)}CreateInput): ${capitalizeFirstLetter(name)}CreateOutput {
-    return this.${name}CreateUsecase.execute(input);
+  async create(@Req() { body }: ApiRequest): ${capitalizeFirstLetter(name)}CreateOutput {
+    return this.${name}CreateUsecase.execute(body as ${capitalizeFirstLetter(name)}CreateInput);
   }
 
   @Put('/${pluralize(name)}')
   @ApiResponse(SwagggerResponse.update[200])
   @ApiResponse(SwagggerResponse.update[404])
   @ApiBody(SwagggerRequest.updateBody)
-  async update(@Body() input: ${capitalizeFirstLetter(name)}UpdateInput): ${capitalizeFirstLetter(name)}UpdateOutput {
-    return this.${name}UpdateUsecase.execute(input);
+  async update(@Req() { body }: ApiRequest): ${capitalizeFirstLetter(name)}UpdateOutput {
+    return this.${name}UpdateUsecase.execute(body as ${capitalizeFirstLetter(name)}UpdateInput);
   }
 
   @Get('/${pluralize(name)}')
@@ -67,9 +61,14 @@ export class ${capitalizeFirstLetter(name)}Controller {
   @ApiQuery(SwagggerRequest.listQuery.sort)
   @ApiQuery(SwagggerRequest.listQuery.search)
   @ApiResponse(SwagggerResponse.list[200])
-  async list(@Query() input: ${capitalizeFirstLetter(name)}ListInput): ${capitalizeFirstLetter(name)}ListOutput {
-    input.sort = SortHttpSchema.parse(input.sort);
-    input.search = SearchHttpSchema.parse(input.search);
+  async list(@Req() { query }: ApiRequest): ${capitalizeFirstLetter(name)}ListOutput {
+    const input: ${capitalizeFirstLetter(name)}ListInput = {
+      sort: SortHttpSchema.parse(query.sort),
+      search: SearchHttpSchema.parse(query.search),
+      limit: Number(query.limit),
+      page: Number(query.page)
+    };
+
     return await this.${name}ListUsecase.execute(input);
   }
 
@@ -77,16 +76,16 @@ export class ${capitalizeFirstLetter(name)}Controller {
   @ApiParam({ name: 'id', required: true })
   @ApiResponse(SwagggerResponse.getByID[200])
   @ApiResponse(SwagggerResponse.getByID[404])
-  async getById(@Param() input: ${capitalizeFirstLetter(name)}GetByIDInput): ${capitalizeFirstLetter(name)}GetByIDOutput {
-    return await this.${name}GetByIDUsecase.execute(input);
+  async getById(@Req() { params }: ApiRequest): ${capitalizeFirstLetter(name)}GetByIDOutput {
+    return await this.${name}GetByIDUsecase.execute(params as ${capitalizeFirstLetter(name)}GetByIDInput);
   }
 
-  @Delete('/${name}/:id')
+  @Delete('/${pluralize(name)}/:id')
   @ApiParam({ name: 'id', required: true })
   @ApiResponse(SwagggerResponse.delete[200])
   @ApiResponse(SwagggerResponse.delete[404])
-  async delete(@Param() input: ${capitalizeFirstLetter(name)}DeleteInput): ${capitalizeFirstLetter(name)}DeleteOutput {
-    return await this.${name}DeleteUsecase.execute(input);
+  async delete(@Req() { params }: ApiRequest): ${capitalizeFirstLetter(name)}DeleteOutput {
+    return await this.${name}DeleteUsecase.execute(params as ${capitalizeFirstLetter(name)}DeleteInput);
   }
 }
 `

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

@@ -5,7 +5,7 @@ function capitalizeFirstLetter(string) {
 
 const getModule = (name) => `import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
 import { getConnectionToken } from '@nestjs/mongoose';
-import mongoose, { Connection } from 'mongoose';
+import mongoose, { Connection, PaginateModel } from 'mongoose';
 
 import { I${capitalizeFirstLetter(name)}Repository } from '@/core/${name}/repository/${name}';
 import { ${capitalizeFirstLetter(name)}CreateUsecase } from '@/core/${name}/use-cases/${name}-create';
@@ -15,9 +15,11 @@ import { ${capitalizeFirstLetter(name)}ListUsecase } from '@/core/${name}/use-ca
 import { ${capitalizeFirstLetter(name)}UpdateUsecase } from '@/core/${name}/use-cases/${name}-update';
 import { RedisCacheModule } from '@/infra/cache/redis';
 import { ConnectionName } from '@/infra/database/enum';
+import { ${capitalizeFirstLetter(name)}, ${capitalizeFirstLetter(name)}Document, ${capitalizeFirstLetter(name)}Schema } from '@/infra/database/mongo/schemas/${name}';
 import { ILoggerAdapter, LoggerModule } from '@/infra/logger';
 import { SecretsModule } from '@/infra/secrets';
 import { TokenModule } from '@/libs/auth';
+import { MongoRepositoryModelSessionType } from '@/utils/database/mongoose';
 import { IsLoggedMiddleware } from '@/utils/middlewares/is-logged.middleware';
 
 import {
@@ -29,7 +31,6 @@ import {
 } from './adapter';
 import { ${capitalizeFirstLetter(name)}Controller } from './controller';
 import { ${capitalizeFirstLetter(name)}Repository } from './repository';
-import { ${capitalizeFirstLetter(name)}, ${capitalizeFirstLetter(name)}Document, ${capitalizeFirstLetter(name)}Schema } from './schema';
 
 @Module({
   imports: [TokenModule, SecretsModule, LoggerModule, RedisCacheModule],
@@ -37,17 +38,28 @@ import { ${capitalizeFirstLetter(name)}, ${capitalizeFirstLetter(name)}Document,
   providers: [
     {
       provide: I${capitalizeFirstLetter(name)}Repository,
-      useFactory: (connection: Connection) => {
-        return new ${capitalizeFirstLetter(name)}Repository(
-          connection.model<${capitalizeFirstLetter(name)}Document, mongoose.PaginateModel<${capitalizeFirstLetter(name)}Document>>(${capitalizeFirstLetter(name)}.name, ${capitalizeFirstLetter(name)}Schema)
-        );
+      useFactory: async (connection: Connection) => {
+        type Model = mongoose.PaginateModel<${capitalizeFirstLetter(name)}Document>;
+
+        // use if you want transaction
+        const repository: MongoRepositoryModelSessionType<PaginateModel<${capitalizeFirstLetter(name)}Document>> = connection.model<
+          ${capitalizeFirstLetter(name)}Document,
+          Model
+        >(${capitalizeFirstLetter(name)}.name, ${capitalizeFirstLetter(name)}Schema);
+
+        repository.connection = connection;
+
+        // use if you not want transaction
+        // const repository: PaginateModel<${capitalizeFirstLetter(name)}Document> = connection.model<${capitalizeFirstLetter(name)}Document, Model>(${capitalizeFirstLetter(name)}.name, ${capitalizeFirstLetter(name)}Schema);
+
+        return new ${capitalizeFirstLetter(name)}Repository(repository);
       },
       inject: [getConnectionToken(ConnectionName.USER)]
     },
     {
       provide: I${capitalizeFirstLetter(name)}CreateAdapter,
-      useFactory: (${name}Repository: I${capitalizeFirstLetter(name)}Repository) => {
-        return new ${capitalizeFirstLetter(name)}CreateUsecase(${name}Repository);
+      useFactory: (${name}Repository: I${capitalizeFirstLetter(name)}Repository, loggerService: ILoggerAdapter) => {
+        return new ${capitalizeFirstLetter(name)}CreateUsecase(${name}Repository, loggerService);
       },
       inject: [I${capitalizeFirstLetter(name)}Repository, ILoggerAdapter]
     },

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

@@ -1,3 +1,4 @@
+const pluralize = require('pluralize')
 
 function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
@@ -8,26 +9,35 @@ import { InjectModel } from '@nestjs/mongoose';
 import { PaginateModel } from 'mongoose';
 
 import { I${capitalizeFirstLetter(name)}Repository } from '@/core/${name}/repository/${name}';
+import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from '@/core/${name}/use-cases/${name}-list';
+import { ${capitalizeFirstLetter(name)}, ${capitalizeFirstLetter(name)}Document } from '@/infra/database/mongo/schemas/${name}';
 import { MongoRepository } from '@/infra/repository';
-import { ValidateMongooseFilter } from '@/utils/decorators/database/mongo/validate-mongoose-filter.decorator';
+import { MongoRepositoryModelSessionType, MongoRepositorySession } from '@/utils/database/mongoose';
+import {
+  SearchTypeEnum,
+  ValidateMongooseFilter
+} from '@/utils/decorators/database/mongo/validate-mongoose-filter.decorator';
 import { ValidateDatabaseSortAllowed } from '@/utils/decorators/database/validate-database-sort-allowed.decorator';
-import { SearchTypeEnum } from '@/utils/decorators/types';
-
-import { ${capitalizeFirstLetter(name)}, ${capitalizeFirstLetter(name)}Document } from './schema';
-import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from './types';
 
 @Injectable()
 export class ${capitalizeFirstLetter(name)}Repository extends MongoRepository<${capitalizeFirstLetter(name)}Document> implements I${capitalizeFirstLetter(name)}Repository {
-  constructor(@InjectModel(${capitalizeFirstLetter(name)}.name) readonly entity: PaginateModel<${capitalizeFirstLetter(name)}Document>) {
+  constructor(@InjectModel(${capitalizeFirstLetter(name)}.name) readonly entity: MongoRepositoryModelSessionType<PaginateModel<${capitalizeFirstLetter(name)}Document>>) {
     super(entity);
   }
 
+  async startSession<TTransaction = MongoRepositorySession>(): Promise<TTransaction> {
+    const session = await this.entity.connection.startSession();
+    session.startTransaction();
+
+    return session as TTransaction;
+  }
+
   @ValidateMongooseFilter([{ name: 'name', type: SearchTypeEnum.like }])
   @ValidateDatabaseSortAllowed(['name', 'createdAt'])
   async paginate({ limit, page, sort, search }: ${capitalizeFirstLetter(name)}ListInput): Promise<${capitalizeFirstLetter(name)}ListOutput> {
-    const ${name}s = await this.entity.paginate(search, { page, limit, sort });
+    const ${pluralize(name)} = await this.entity.paginate(search, { page, limit, sort });
 
-    return { docs: ${name}s.docs.map((u) => u.toObject({ virtuals: true })), limit, page, total: ${name}s.totalDocs };
+    return { docs: ${pluralize(name)}.docs.map((u) => u.toObject({ virtuals: true })), limit, page, total: ${name}s.totalDocs };
   }
 }
 `

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

@@ -1,12 +1,13 @@
-const getModuleSwagger = (name) => `import { CreatedModel } from '@/infra/repository';
+const pluralize = require('pluralize')
+
+const getModuleSwagger = (name) => `import { CreatedModel } from '@/infra/repository/types';
 import { Swagger } from '@/utils/swagger';
 
 const entity = {
-  id: '<id>',
   name: '<name>'
 };
 
-const entityFull = { ...entity, deletedAt: '<deletedAt>', createdAt: '<createdAt>', updatedAt: '<updatedAt>' };
+const entityFull = { ...entity, updatedAt: '<updatedAt>', createdAt: '<createdAt>', deletedAt: '<deletedAt>' };
 
 export const SwagggerResponse = {
   create: {
@@ -24,7 +25,7 @@ export const SwagggerResponse = {
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/${name}s',
+      route: 'api/${pluralize(name)}',
       message: '${name}NotFound',
       description: '${name} not found.'
     })
@@ -37,7 +38,7 @@ export const SwagggerResponse = {
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/${name}s/:id',
+      route: 'api/${pluralize(name)}/:id',
       message: '${name}NotFound',
       description: '${name} not found.'
     })
@@ -50,7 +51,7 @@ export const SwagggerResponse = {
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/${name}s/:id',
+      route: 'api/${pluralize(name)}s/:id',
       message: '${name}NotFound',
       description: '${name} not found.'
     })
@@ -80,7 +81,7 @@ export const SwagggerRequest = {
     search: Swagger.defaultApiQueryOptions({
       name: 'search',
       required: false,
-      description: '<b>name:name'
+      description: '<b>name:miau'
     })
   }
 };

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

@@ -3,14 +3,17 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getCoreRepository = (name) => `import { IRepository } from '@/infra/repository';
-import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from '@/modules/${name}/types';
+const getCoreRepository = (name) => `import { Transaction } from 'sequelize';
+
+import { IRepository } from '@/infra/repository';
 import { DatabaseOptionsType } from '@/utils/database/sequelize';
 
 import { ${capitalizeFirstLetter(name)}Entity } from '../entity/${name}';
+import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from '../use-cases/${name}-list';
 
 export abstract class I${capitalizeFirstLetter(name)}Repository extends IRepository<${capitalizeFirstLetter(name)}Entity> {
   abstract paginate<TOptions = DatabaseOptionsType>(input: ${capitalizeFirstLetter(name)}ListInput, options?: TOptions): Promise<${capitalizeFirstLetter(name)}ListOutput>;
+  abstract startSession<TTransaction = Transaction>(): Promise<TTransaction>;
 }
 `
 

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

@@ -3,22 +3,43 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getCoreUsecaseCreate = (name) => `import { ${capitalizeFirstLetter(name)}CreateInput, ${capitalizeFirstLetter(name)}CreateOutput, ${capitalizeFirstLetter(name)}CreateSchema } from '@/modules/${name}/types';
+const getCoreUsecaseCreate = (name) => `import { z } from 'zod';
+
+import { ILoggerAdapter } from '@/infra/logger';
+import { CreatedModel } from '@/infra/repository';
+import { DatabaseOptionsType } from '@/utils/database/sequelize';
 import { ValidateSchema } from '@/utils/decorators/validate-schema.decorator';
 
 import { I${capitalizeFirstLetter(name)}Repository } from '../repository/${name}';
-import { ${capitalizeFirstLetter(name)}Entity } from './../entity/${name}';
+import { ${capitalizeFirstLetter(name)}Entity, ${capitalizeFirstLetter(name)}EntitySchema } from './../entity/${name}';
+
+export const ${capitalizeFirstLetter(name)}CreateSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
+  name: true
+});
+
+export type ${capitalizeFirstLetter(name)}CreateInput = z.infer<typeof ${capitalizeFirstLetter(name)}CreateSchema>;
+export type ${capitalizeFirstLetter(name)}CreateOutput = Promise<CreatedModel>;
 
 export class ${capitalizeFirstLetter(name)}CreateUsecase {
-  constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}
+  constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository, private readonly loggerServide: ILoggerAdapter) {}
 
   @ValidateSchema(${capitalizeFirstLetter(name)}CreateSchema)
   async execute(input: ${capitalizeFirstLetter(name)}CreateInput): Promise<${capitalizeFirstLetter(name)}CreateOutput> {
     const entity = new ${capitalizeFirstLetter(name)}Entity(input);
 
-    const created = await this.${name}Repository.create(entity);
+    const transaction = await this.${name}Repository.startSession();
+    try {
+      const ${name} = await this.${name}Repository.create<DatabaseOptionsType>(entity, { transaction });
+
+      await transaction.commit();
+
+      this.loggerServide.info({ message: '${name} created.', obj: { ${name} } });
 
-    return created;
+      return ${name};
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
   }
 }
 `

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

@@ -3,19 +3,28 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getCoreUsecaseDelete = (name) => `import { I${capitalizeFirstLetter(name)}Repository } from '@/core/${name}/repository/${name}';
-import { ${capitalizeFirstLetter(name)}DeleteInput, ${capitalizeFirstLetter(name)}DeleteOutput, ${capitalizeFirstLetter(name)}DeleteSchema } from '@/modules/${name}/types';
+const getCoreUsecaseDelete = (name) => `import { z } from 'zod';
+
+import { I${capitalizeFirstLetter(name)}Repository } from '@/core/${name}/repository/${name}';
+import { DatabaseOptionsType } from '@/utils/database/sequelize';
 import { ValidateSchema } from '@/utils/decorators/validate-schema.decorator';
 import { ApiNotFoundException } from '@/utils/exception';
 
-import { ${capitalizeFirstLetter(name)}Entity } from '../entity/${name}';
+import { ${capitalizeFirstLetter(name)}Entity, ${capitalizeFirstLetter(name)}EntitySchema } from '../entity/${name}';
+
+export const ${capitalizeFirstLetter(name)}DeleteSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
+  id: true
+});
+
+export type ${capitalizeFirstLetter(name)}DeleteInput = z.infer<typeof ${capitalizeFirstLetter(name)}DeleteSchema>;
+export type ${capitalizeFirstLetter(name)}DeleteOutput = Promise<${capitalizeFirstLetter(name)}Entity>;
 
 export class ${capitalizeFirstLetter(name)}DeleteUsecase {
   constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}
 
   @ValidateSchema(${capitalizeFirstLetter(name)}DeleteSchema)
   async execute({ id }: ${capitalizeFirstLetter(name)}DeleteInput): Promise<${capitalizeFirstLetter(name)}DeleteOutput> {
-    const model = await this.${name}Repository.findById(id);
+    const model = await this.${name}Repository.findById<DatabaseOptionsType>(id);
 
     if (!model) {
       throw new ApiNotFoundException('${name}NotFound');

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

@@ -3,20 +3,29 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getCoreUsecaseGetByID = (name) => `import { ${capitalizeFirstLetter(name)}GetByIDInput, ${capitalizeFirstLetter(name)}GetByIDOutput } from '@/modules/${name}/types';
-import { ${capitalizeFirstLetter(name)}GetByIdSchema } from '@/modules/${name}/types';
+const getCoreUsecaseGetByID = (name) => `import { z } from 'zod';
+
+import { ${capitalizeFirstLetter(name)}EntitySchema } from '@/core/${name}/entity/${name}';
+import { DatabaseOptionsType } from '@/utils/database/sequelize';
 import { ValidateSchema } from '@/utils/decorators/validate-schema.decorator';
 import { ApiNotFoundException } from '@/utils/exception';
 
 import { ${capitalizeFirstLetter(name)}Entity } from '../entity/${name}';
 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 = Promise<${capitalizeFirstLetter(name)}Entity>;
+
 export class ${capitalizeFirstLetter(name)}GetByIdUsecase {
   constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}
 
   @ValidateSchema(${capitalizeFirstLetter(name)}GetByIdSchema)
   async execute({ id }: ${capitalizeFirstLetter(name)}GetByIDInput): Promise<${capitalizeFirstLetter(name)}GetByIDOutput> {
-    const ${name} = await this.${name}Repository.findById(id);
+    const ${name} = await this.${name}Repository.findById<DatabaseOptionsType>(id);
 
     if (!${name}) {
       throw new ApiNotFoundException('${name}NotFound');

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

@@ -3,11 +3,21 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getCoreUsecaseList = (name) => `import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput, ${capitalizeFirstLetter(name)}ListSchema } from '@/modules/${name}/types';
+const getCoreUsecaseList = (name) => `import { z } from 'zod';
+
+import { ${capitalizeFirstLetter(name)}Entity } from '@/core/${name}/entity/${name}';
 import { ValidateSchema } from '@/utils/decorators/validate-schema.decorator';
+import { PaginationInput, PaginationOutput, PaginationSchema } from '@/utils/pagination';
+import { SearchSchema } from '@/utils/search';
+import { SortSchema } from '@/utils/sort';
 
 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 class ${capitalizeFirstLetter(name)}ListUsecase {
   constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}
 

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

@@ -3,19 +3,29 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getCoreUsecaseUpdate = (name) => `import { I${capitalizeFirstLetter(name)}Repository } from '@/core/${name}/repository/${name}';
-import { ${capitalizeFirstLetter(name)}UpdateInput, ${capitalizeFirstLetter(name)}UpdateOutput, ${capitalizeFirstLetter(name)}UpdateSchema } from '@/modules/${name}/types';
+const getCoreUsecaseUpdate = (name) => `import { z } from 'zod';
+
+import { I${capitalizeFirstLetter(name)}Repository } from '@/core/${name}/repository/${name}';
+import { ILoggerAdapter } from '@/infra/logger';
+import { DatabaseOptionsType } from '@/utils/database/sequelize';
 import { ValidateSchema } from '@/utils/decorators/validate-schema.decorator';
 import { ApiNotFoundException } from '@/utils/exception';
 
-import { ${capitalizeFirstLetter(name)}Entity } from './../entity/${name}';
+import { ${capitalizeFirstLetter(name)}Entity, ${capitalizeFirstLetter(name)}EntitySchema } from './../entity/${name}';
+
+export const ${capitalizeFirstLetter(name)}UpdateSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
+  id: true
+}).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 class ${capitalizeFirstLetter(name)}UpdateUsecase {
-  constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}
+  constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository, private readonly loggerServide: ILoggerAdapter) {}
 
   @ValidateSchema(${capitalizeFirstLetter(name)}UpdateSchema)
   async execute(input: ${capitalizeFirstLetter(name)}UpdateInput): Promise<${capitalizeFirstLetter(name)}UpdateOutput> {
-    const ${name} = await this.${name}Repository.findById(input.id);
+    const ${name} = await this.${name}Repository.findById<DatabaseOptionsType>(input.id);
 
     if (!${name}) {
       throw new ApiNotFoundException('${name}NotFound');
@@ -27,7 +37,9 @@ export class ${capitalizeFirstLetter(name)}UpdateUsecase {
 
     await this.${name}Repository.updateOne({ id: entity.id }, entity);
 
-    const updated = await this.${name}Repository.findById(entity.id);
+    this.loggerServide.info({ message: '${name} updated.', obj: { ${name}: input } });
+
+    const updated = await this.${name}Repository.findById<DatabaseOptionsType>(entity.id);
 
     return new ${capitalizeFirstLetter(name)}Entity(updated);
   }

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

@@ -3,18 +3,11 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getModuleAdapter = (name) => `import {
-  ${capitalizeFirstLetter(name)}CreateInput,
-  ${capitalizeFirstLetter(name)}CreateOutput,
-  ${capitalizeFirstLetter(name)}DeleteInput,
-  ${capitalizeFirstLetter(name)}DeleteOutput,
-  ${capitalizeFirstLetter(name)}GetByIDInput,
-  ${capitalizeFirstLetter(name)}GetByIDOutput,
-  ${capitalizeFirstLetter(name)}ListInput,
-  ${capitalizeFirstLetter(name)}ListOutput,
-  ${capitalizeFirstLetter(name)}UpdateInput,
-  ${capitalizeFirstLetter(name)}UpdateOutput
-} from './types';
+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}-getByID';
+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';
 
 export abstract class I${capitalizeFirstLetter(name)}CreateAdapter {
   abstract execute(input: ${capitalizeFirstLetter(name)}CreateInput): Promise<${capitalizeFirstLetter(name)}CreateOutput>;

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

@@ -4,11 +4,17 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getModuleController = (name) => `import { Body, Controller, Delete, Get, Param, Post, Put, Query } from '@nestjs/common';
+const getModuleController = (name) => `import { Controller, Delete, Get, Post, Put, Req } from '@nestjs/common';
 import { ApiBearerAuth, ApiBody, ApiParam, ApiQuery, ApiResponse, ApiTags } from '@nestjs/swagger';
 
+import { ${capitalizeFirstLetter(name)}CreateInput, ${capitalizeFirstLetter(name)}CreateOutput } from '@/core/${name}/use-cases/${name}-create';
+import { ${capitalizeFirstLetter(name)}DeleteInput, ${capitalizeFirstLetter(name)}DeleteOutput } from '@/core/${name}/use-cases/${name}-delete';
+import { ${capitalizeFirstLetter(name)}GetByIDInput, ${capitalizeFirstLetter(name)}GetByIDOutput } from '@/core/${name}/use-cases/${name}-getByID';
+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 { UserRole } from '@/core/user/entity/user';
 import { Roles } from '@/utils/decorators/role.decorator';
+import { ApiRequest } from '@/utils/request';
 import { SearchHttpSchema } from '@/utils/search';
 import { SortHttpSchema } from '@/utils/sort';
 
@@ -20,23 +26,11 @@ import {
   I${capitalizeFirstLetter(name)}UpdateAdapter
 } from './adapter';
 import { SwagggerRequest, SwagggerResponse } from './swagger';
-import {
-  ${capitalizeFirstLetter(name)}CreateInput,
-  ${capitalizeFirstLetter(name)}CreateOutput,
-  ${capitalizeFirstLetter(name)}DeleteInput,
-  ${capitalizeFirstLetter(name)}DeleteOutput,
-  ${capitalizeFirstLetter(name)}GetByIDInput,
-  ${capitalizeFirstLetter(name)}GetByIDOutput,
-  ${capitalizeFirstLetter(name)}ListInput,
-  ${capitalizeFirstLetter(name)}ListOutput,
-  ${capitalizeFirstLetter(name)}UpdateInput,
-  ${capitalizeFirstLetter(name)}UpdateOutput
-} from './types';
 
 @Controller()
 @ApiTags('${name}')
 @ApiBearerAuth()
-@Roles(UserRole.BACKOFFICE)
+@Roles(UserRole.USER)
 export class ${capitalizeFirstLetter(name)}Controller {
   constructor(
     private readonly ${name}Create: I${capitalizeFirstLetter(name)}CreateAdapter,
@@ -49,24 +43,24 @@ export class ${capitalizeFirstLetter(name)}Controller {
   @Post('/${pluralize(name)}')
   @ApiResponse(SwagggerResponse.create[200])
   @ApiBody(SwagggerRequest.createBody)
-  async create(@Body() input: ${capitalizeFirstLetter(name)}CreateInput): ${capitalizeFirstLetter(name)}CreateOutput {
-    return await this.${name}Create.execute(input);
+  async create(@Req() { body }: ApiRequest): ${capitalizeFirstLetter(name)}CreateOutput {
+    return await this.${name}Create.execute(body as ${capitalizeFirstLetter(name)}CreateInput);
   }
 
   @Put('/${pluralize(name)}')
   @ApiResponse(SwagggerResponse.update[200])
   @ApiResponse(SwagggerResponse.update[404])
   @ApiBody(SwagggerRequest.updateBody)
-  async update(@Body() input: ${capitalizeFirstLetter(name)}UpdateInput): ${capitalizeFirstLetter(name)}UpdateOutput {
-    return await this.${name}Update.execute(input);
+  async update(@Req() { body }: ApiRequest): ${capitalizeFirstLetter(name)}UpdateOutput {
+    return await this.${name}Update.execute(body as ${capitalizeFirstLetter(name)}UpdateInput);
   }
 
   @Get('/${pluralize(name)}/:id')
   @ApiParam({ name: 'id', required: true })
   @ApiResponse(SwagggerResponse.getByID[200])
   @ApiResponse(SwagggerResponse.getByID[404])
-  async getById(@Param() input: ${capitalizeFirstLetter(name)}GetByIDInput): ${capitalizeFirstLetter(name)}GetByIDOutput {
-    return await this.${name}GetByID.execute(input);
+  async getById(@Req() { params }: ApiRequest): ${capitalizeFirstLetter(name)}GetByIDOutput {
+    return await this.${name}GetByID.execute(params as ${capitalizeFirstLetter(name)}GetByIDInput);
   }
 
   @Get('/${pluralize(name)}')
@@ -75,9 +69,14 @@ export class ${capitalizeFirstLetter(name)}Controller {
   @ApiQuery(SwagggerRequest.listQuery.sort)
   @ApiQuery(SwagggerRequest.listQuery.search)
   @ApiResponse(SwagggerResponse.list[200])
-  async list(@Query() input: ${capitalizeFirstLetter(name)}ListInput): ${capitalizeFirstLetter(name)}ListOutput {
-    input.sort = SortHttpSchema.parse(input.sort);
-    input.search = SearchHttpSchema.parse(input.search);
+  async list(@Req() { query }: ApiRequest): ${capitalizeFirstLetter(name)}ListOutput {
+    const input: ${capitalizeFirstLetter(name)}ListInput = {
+      sort: SortHttpSchema.parse(query.sort),
+      search: SearchHttpSchema.parse(query.search),
+      limit: Number(query.limit),
+      page: Number(query.page)
+    };
+
     return await this.${name}List.execute(input);
   }
 
@@ -85,8 +84,8 @@ export class ${capitalizeFirstLetter(name)}Controller {
   @ApiParam({ name: 'id', required: true })
   @ApiResponse(SwagggerResponse.delete[200])
   @ApiResponse(SwagggerResponse.delete[404])
-  async delete(@Param() input: ${capitalizeFirstLetter(name)}DeleteInput): ${capitalizeFirstLetter(name)}DeleteOutput {
-    return await this.${name}Delete.execute(input);
+  async delete(@Req() { params }: ApiRequest): ${capitalizeFirstLetter(name)}DeleteOutput {
+    return await this.${name}Delete.execute(params as ${capitalizeFirstLetter(name)}DeleteInput);
   }
 }
 `

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

@@ -38,19 +38,19 @@ import { ${capitalizeFirstLetter(name)}Repository } from './repository';
     {
       provide: I${capitalizeFirstLetter(name)}Repository,
       useFactory: (database: IDataBaseAdapter) => {
-        const repository = database.getDatabase<Sequelize>().model(${capitalizeFirstLetter(name)}Schema);
-        return new ${capitalizeFirstLetter(name)}Repository(repository as ModelCtor<${capitalizeFirstLetter(name)}Schema> & ${capitalizeFirstLetter(name)}Entity);
+        const repossitory = database.getDatabase<Sequelize>().model(${capitalizeFirstLetter(name)}Schema);
+        return new ${capitalizeFirstLetter(name)}Repository(repossitory as ModelCtor<${capitalizeFirstLetter(name)}Schema> & ${capitalizeFirstLetter(name)}Entity);
       },
       inject: [IDataBaseAdapter]
     },
     {
       provide: I${capitalizeFirstLetter(name)}CreateAdapter,
-      useFactory: (repository: I${capitalizeFirstLetter(name)}Repository) => new ${capitalizeFirstLetter(name)}CreateUsecase(repository),
-      inject: [I${capitalizeFirstLetter(name)}Repository]
+      useFactory: (logger: ILoggerAdapter, repository: I${capitalizeFirstLetter(name)}Repository) => new ${capitalizeFirstLetter(name)}CreateUsecase(repository, logger),
+      inject: [ILoggerAdapter, I${capitalizeFirstLetter(name)}Repository]
     },
     {
       provide: I${capitalizeFirstLetter(name)}UpdateAdapter,
-      useFactory: (repository: I${capitalizeFirstLetter(name)}Repository) => new ${capitalizeFirstLetter(name)}UpdateUsecase(repository),
+      useFactory: (logger: ILoggerAdapter, repository: I${capitalizeFirstLetter(name)}Repository) => new ${capitalizeFirstLetter(name)}UpdateUsecase(repository, logger),
       inject: [ILoggerAdapter, I${capitalizeFirstLetter(name)}Repository]
     },
     {

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

@@ -4,13 +4,14 @@ function capitalizeFirstLetter(string) {
 }
 
 const getModuleRepository = (name) => `import { Injectable } from '@nestjs/common';
+import { Transaction } from 'sequelize';
 import { ModelCtor } from 'sequelize-typescript';
 
 import { ${capitalizeFirstLetter(name)}Entity } from '@/core/${name}/entity/${name}';
 import { I${capitalizeFirstLetter(name)}Repository } from '@/core/${name}/repository/${name}';
+import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from '@/core/${name}/use-cases/${name}-list';
 import { ${capitalizeFirstLetter(name)}Schema } from '@/infra/database/postgres/schemas/${name}';
 import { SequelizeRepository } from '@/infra/repository/postgres/repository';
-import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from '@/modules/${name}/types';
 import { DatabaseOptionsSchema, DatabaseOptionsType } from '@/utils/database/sequelize';
 import { ConvertPaginateInputToSequelizeFilter } from '@/utils/decorators/database/postgres/convert-paginate-input-to-sequelize-filter.decorator';
 import { ValidateDatabaseSortAllowed } from '@/utils/decorators/database/validate-database-sort-allowed.decorator';
@@ -24,18 +25,20 @@ export class ${capitalizeFirstLetter(name)}Repository extends SequelizeRepositor
     super(repository);
   }
 
-  @ValidateDatabaseSortAllowed(['createdAt', 'name', 'breed', 'age'])
-  @ConvertPaginateInputToSequelizeFilter([
-    { name: 'name', type: SearchTypeEnum.like },
-    { name: 'breed', type: SearchTypeEnum.like },
-    { name: 'age', type: SearchTypeEnum.equal }
-  ])
+  async startSession<TTransaction = Transaction>(): Promise<TTransaction> {
+    const transaction = await this.repository.sequelize.transaction();
+
+    return transaction as TTransaction;
+  }
+
+  @ValidateDatabaseSortAllowed(['createdAt', 'name'])
+  @ConvertPaginateInputToSequelizeFilter([{ name: 'name', type: SearchTypeEnum.like }])
   async paginate(input: ${capitalizeFirstLetter(name)}ListInput, options: DatabaseOptionsType): Promise<${capitalizeFirstLetter(name)}ListOutput> {
     const { schema } = DatabaseOptionsSchema.parse(options);
 
     const list = await this.repository.schema(schema).findAndCountAll(input);
 
-    return { docs: list.rows, limit: input.limit, page: input.page, total: list.count };
+    return { docs: list.rows.map((r) => new ${capitalizeFirstLetter(name)}Entity(r)), limit: input.limit, page: input.page, total: list.count };
   }
 }
 `

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

@@ -1,3 +1,5 @@
+const pluralize = require('pluralize')
+
 const getModuleSwagger = (name) => `import { CreatedModel } from '@/infra/repository/types';
 import { Swagger } from '@/utils/swagger';
 
@@ -23,7 +25,7 @@ export const SwagggerResponse = {
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/${name}',
+      route: 'api/${pluralize(name)}',
       message: '${name}NotFound',
       description: '${name} not found.'
     })
@@ -36,7 +38,7 @@ export const SwagggerResponse = {
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/${name}/:id',
+      route: 'api/${pluralize(name)}/:id',
       message: '${name}NotFound',
       description: '${name} not found.'
     })
@@ -49,7 +51,7 @@ export const SwagggerResponse = {
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/${name}/:id',
+      route: 'api/${pluralize(name)}s/:id',
       message: '${name}NotFound',
       description: '${name} not found.'
     })
@@ -79,7 +81,7 @@ export const SwagggerRequest = {
     search: Swagger.defaultApiQueryOptions({
       name: 'search',
       required: false,
-      description: '<b>name:miau,breed:siamese'
+      description: '<b>name:miau'
     })
   }
 };

package/src/scafold/mongo/schemas/bird.ts

@@ -1,35 +0,0 @@
-import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
-import { Document } from 'mongoose';
-import * as paginate from 'mongoose-paginate-v2';
-
-import { BirdEntity } from '@/core/bird/entity/bird';
-
-export type BirdDocument = Document & BirdEntity;
-
-@Schema({
-  collection: 'birds',
-  autoIndex: true,
-  timestamps: true
-})
-export class Bird {
-  @Prop({ type: String })
-  _id: string;
-
-  @Prop({ index: true, min: 1, max: 200, required: true, type: String })
-  name: string;
-
-  @Prop({ type: Date, default: null })
-  deletedAt: Date;
-}
-
-const BirdSchema = SchemaFactory.createForClass(Bird);
-
-BirdSchema.index({ name: 1 });
-
-BirdSchema.plugin(paginate);
-
-BirdSchema.virtual('id').get(function () {
-  return this._id;
-});
-
-export { BirdSchema };

package/src/scafold/postgres/schemas/dog.ts

@@ -1,13 +0,0 @@
-import { Column, DataType, Model, Table } from 'sequelize-typescript';
-
-@Table({ timestamps: true, tableName: 'dogs' })
-export class DogSchema extends Model {
-  @Column({ primaryKey: true, type: DataType.UUID })
-  id: string;
-
-  @Column(DataType.STRING)
-  name: string;
-
-  @Column({ allowNull: true, type: DataType.DATE })
-  deletedAt?: Date;
-}

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

@@ -1,49 +0,0 @@
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
-
-const getModuleType = (name) => `import { z } from 'zod';
-
-import { ${capitalizeFirstLetter(name)}EntitySchema } from '@/core/${name}/entity/${name}';
-import { CreatedModel } from '@/infra/repository';
-import { PaginationInput, PaginationOutput, PaginationSchema } from '@/utils/pagination';
-import { SearchSchema } from '@/utils/search';
-import { SortSchema } from '@/utils/sort';
-
-type Schema = z.infer<typeof ${capitalizeFirstLetter(name)}EntitySchema>;
-
-export const ${capitalizeFirstLetter(name)}CreateSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
-  name: true
-});
-
-export type ${capitalizeFirstLetter(name)}CreateInput = z.infer<typeof ${capitalizeFirstLetter(name)}CreateSchema>;
-export type ${capitalizeFirstLetter(name)}CreateOutput = Promise<CreatedModel>;
-
-export const ${capitalizeFirstLetter(name)}UpdateSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
-  id: true
-}).merge(${capitalizeFirstLetter(name)}CreateSchema.partial());
-export type ${capitalizeFirstLetter(name)}UpdateInput = z.infer<typeof ${capitalizeFirstLetter(name)}UpdateSchema>;
-export type ${capitalizeFirstLetter(name)}UpdateOutput = Promise<Schema>;
-
-export const ${capitalizeFirstLetter(name)}ListSchema = z.intersection(PaginationSchema, SortSchema.merge(SearchSchema));
-
-export type ${capitalizeFirstLetter(name)}ListInput = PaginationInput<Schema>;
-export type ${capitalizeFirstLetter(name)}ListOutput = Promise<{ docs: Schema[] } & PaginationOutput>;
-
-export const ${capitalizeFirstLetter(name)}DeleteSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
-  id: true
-});
-export type ${capitalizeFirstLetter(name)}DeleteInput = z.infer<typeof ${capitalizeFirstLetter(name)}DeleteSchema>;
-export type ${capitalizeFirstLetter(name)}DeleteOutput = Promise<Schema>;
-
-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 = Promise<Schema>;
-`
-
-module.exports = {
-  getModuleType
-}

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

@@ -1,52 +0,0 @@
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
-
-const getModuleType = (name) => `import { z } from 'zod';
-
-import { ${capitalizeFirstLetter(name)}EntitySchema } from '@/core/${name}/entity/${name}';
-import { CreatedModel } from '@/infra/repository';
-import { PaginationInput, PaginationOutput, PaginationSchema } from '@/utils/pagination';
-import { SearchSchema } from '@/utils/search';
-import { SortSchema } from '@/utils/sort';
-
-type Schema = z.infer<typeof ${capitalizeFirstLetter(name)}EntitySchema>;
-
-export const ${capitalizeFirstLetter(name)}CreateSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
-  name: true
-});
-
-export type ${capitalizeFirstLetter(name)}CreateInput = z.infer<typeof ${capitalizeFirstLetter(name)}CreateSchema>;
-export type ${capitalizeFirstLetter(name)}CreateOutput = Promise<CreatedModel>;
-
-export const ${capitalizeFirstLetter(name)}UpdateSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
-  name: true
-})
-  .partial()
-  .merge(${capitalizeFirstLetter(name)}EntitySchema.pick({ id: true }));
-
-export type ${capitalizeFirstLetter(name)}UpdateInput = z.infer<typeof ${capitalizeFirstLetter(name)}UpdateSchema>;
-export type ${capitalizeFirstLetter(name)}UpdateOutput = Promise<Schema>;
-
-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 = Promise<Schema>;
-
-export const ${capitalizeFirstLetter(name)}ListSchema = z.intersection(PaginationSchema, SortSchema.merge(SearchSchema));
-
-export type ${capitalizeFirstLetter(name)}ListInput = PaginationInput<Schema>;
-export type ${capitalizeFirstLetter(name)}ListOutput = Promise<{ docs: Schema[] } & PaginationOutput>;
-
-export const ${capitalizeFirstLetter(name)}DeleteSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
-  id: true
-});
-export type ${capitalizeFirstLetter(name)}DeleteInput = z.infer<typeof ${capitalizeFirstLetter(name)}DeleteSchema>;
-export type ${capitalizeFirstLetter(name)}DeleteOutput = Promise<Schema>;
-`
-
-module.exports = {
-  getModuleType
-}