@mikemajesty/microservice-crud 4.5.9 → 4.5.10

package/package.json

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

package/src/templates/module/controller.js

@@ -9,7 +9,7 @@ const getModuleControllerModule = (name) => `import { Controller, Get, Req } fro
 import { ApiBearerAuth, ApiResponse, ApiTags } from '@nestjs/swagger';
 
 import { Roles } from '@/utils/decorators';
-import { UserRole } from '@/core/user/entity/user';
+import { UserRoleEnum } from '@/core/user/entity/user';
 import { ApiRequest } from '@/utils/request';
 
 import { SwagggerResponse } from './swagger';
@@ -17,7 +17,7 @@ import { SwagggerResponse } from './swagger';
 @Controller('${pluralize(name)}')
 @ApiTags('${name}')
 @ApiBearerAuth()
-@Roles(UserRole.USER)
+@Roles(UserRoleEnum.USER)
 export class ${capitalizeFirstLetter(name)}Controller {
   @Get()
   @ApiResponse(SwagggerResponse.get[200])

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

@@ -13,7 +13,7 @@ import { ${capitalizeFirstLetter(name)}DeleteInput, ${capitalizeFirstLetter(name
 import { ${capitalizeFirstLetter(name)}GetByIDInput, ${capitalizeFirstLetter(name)}GetByIDOutput } from '@/core/${name}/use-cases/${name}-get-by-id';
 import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from '@/core/${name}/use-cases/${name}-list';
 import { ${capitalizeFirstLetter(name)}UpdateInput, ${capitalizeFirstLetter(name)}UpdateOutput } from '@/core/${name}/use-cases/${name}-update';
-import { UserRole } from '@/core/user/entity/user';
+import { UserRoleEnum } from '@/core/user/entity/user';
 import { ApiRequest } from '@/utils/request';
 import { SearchHttpSchema } from '@/utils/search';
 import { SortHttpSchema } from '@/utils/sort';
@@ -30,7 +30,7 @@ import { SwaggerRequest, SwaggerResponse } from './swagger';
 @Controller('/${pluralize(name)}')
 @ApiTags('${pluralize(name)}')
 @ApiBearerAuth()
-@Roles(UserRole.USER)
+@Roles(UserRoleEnum.USER)
 export class ${capitalizeFirstLetter(name)}Controller {
   constructor(
     private readonly ${name}CreateUsecase: I${capitalizeFirstLetter(name)}CreateAdapter,
@@ -47,12 +47,13 @@ export class ${capitalizeFirstLetter(name)}Controller {
     return this.${name}CreateUsecase.execute(body as ${capitalizeFirstLetter(name)}CreateInput);
   }
 
-  @Put()
+  @Put(':id')
   @ApiResponse(SwaggerResponse.update[200])
   @ApiResponse(SwaggerResponse.update[404])
   @ApiBody(SwaggerRequest.updateBody)
-  async update(@Req() { body }: ApiRequest): Promise<${capitalizeFirstLetter(name)}UpdateOutput> {
-    return this.${name}UpdateUsecase.execute(body as ${capitalizeFirstLetter(name)}UpdateInput);
+  @ApiParam({ name: 'id', required: true })
+  async update(@Req() { body, params }: ApiRequest): Promise<${capitalizeFirstLetter(name)}UpdateOutput> {
+    return this.${name}UpdateUsecase.execute({ ...body, id: params.id } as ${capitalizeFirstLetter(name)}UpdateInput);
   }
 
   @Get()

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

@@ -35,7 +35,7 @@ export const SwaggerResponse = {
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/${pluralize(name)}',
+      route: 'api/v1/${pluralize(name)}',
       message: '${name}NotFound',
       description: '${name} not found.'
     })
@@ -48,7 +48,7 @@ export const SwaggerResponse = {
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/${pluralize(name)}/:id',
+      route: 'api/v1/${pluralize(name)}/:id',
       message: '${name}NotFound',
       description: '${name} not found.'
     })
@@ -61,7 +61,7 @@ export const SwaggerResponse = {
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/${pluralize(name)}/:id',
+      route: 'api/v1/${pluralize(name)}/:id',
       message: '${name}NotFound',
       description: '${name} not found.'
     })

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

@@ -3,17 +3,13 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getCoreRepository = (name) => `import { Transaction } from 'sequelize';
-
-import { IRepository } from '@/infra/repository';
-import { DatabaseOptionsType } from '@/utils/database/sequelize';
+const getCoreRepository = (name) => `import { IRepository } from '@/infra/repository';
 
 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>;
+  abstract paginate(input: ${capitalizeFirstLetter(name)}ListInput): Promise<${capitalizeFirstLetter(name)}ListOutput>;
 }
 `
 

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

@@ -64,22 +64,9 @@ describe('${capitalizeFirstLetter(name)}CreateUsecase', () => {
     const createOutput: ${capitalizeFirstLetter(name)}CreateOutput = { created: true, id: getMockUUID() };
 
     repository.create = jest.fn().mockResolvedValue(createOutput);
-    repository.startSession = jest.fn().mockResolvedValue({
-      commit: jest.fn()
-    });
-
+   
     await expect(usecase.execute(successInput)).resolves.toEqual(createOutput);
   });
-
-  test('when transaction throw an error, should expect an error', async () => {
-    repository.startSession = jest.fn().mockResolvedValue({
-      commit: jest.fn(),
-      rollback: jest.fn()
-    });
-    repository.create = jest.fn().mockRejectedValue(new ApiInternalServerException());
-
-    await expect(usecase.execute(successInput)).rejects.toThrow(ApiInternalServerException);
-  });
 });
 `
 

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

@@ -8,7 +8,7 @@ const getCoreUsecaseCreate = (name) => `import { z } from 'zod';
 import { ValidateSchema } from '@/utils/decorators';
 import { ILoggerAdapter } from '@/infra/logger';
 import { CreatedModel } from '@/infra/repository';
-import { DatabaseOptionsType } from '@/utils/database/sequelize';
+;
 import { IUsecase } from '@/utils/usecase';
 
 import { I${capitalizeFirstLetter(name)}Repository } from '../repository/${name}';
@@ -28,19 +28,11 @@ export class ${capitalizeFirstLetter(name)}CreateUsecase implements IUsecase {
   async execute(input: ${capitalizeFirstLetter(name)}CreateInput): Promise<${capitalizeFirstLetter(name)}CreateOutput> {
     const entity = new ${capitalizeFirstLetter(name)}Entity(input);
 
-    const transaction = await this.${name}Repository.startSession();
-    try {
-      const ${name} = await this.${name}Repository.create<DatabaseOptionsType>(entity, { transaction });
+    const ${name} = await this.${name}Repository.create(entity);
 
-      await transaction.commit();
+    this.loggerService.info({ message: '${name} created.', obj: { ${name} } });
 
-      this.loggerService.info({ message: '${name} created.', obj: { ${name} } });
-
-      return ${name};
-    } catch (error) {
-      await transaction.rollback();
-      throw error;
-    }
+    return ${name};
   }
 }
 `

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

@@ -7,7 +7,7 @@ const getCoreUsecaseDelete = (name) => `import { z } from 'zod';
 
 import { ValidateSchema } from '@/utils/decorators';
 import { I${capitalizeFirstLetter(name)}Repository } from '@/core/${name}/repository/${name}';
-import { DatabaseOptionsType } from '@/utils/database/sequelize';
+;
 import { ApiNotFoundException } from '@/utils/exception';
 import { IUsecase } from '@/utils/usecase';
 
@@ -25,7 +25,7 @@ export class ${capitalizeFirstLetter(name)}DeleteUsecase implements IUsecase {
 
   @ValidateSchema(${capitalizeFirstLetter(name)}DeleteSchema)
   async execute({ id }: ${capitalizeFirstLetter(name)}DeleteInput): Promise<${capitalizeFirstLetter(name)}DeleteOutput> {
-    const model = await this.${name}Repository.findById<DatabaseOptionsType>(id);
+    const model = await this.${name}Repository.findById(id);
 
     if (!model) {
       throw new ApiNotFoundException();

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

@@ -7,7 +7,7 @@ const getCoreUsecaseGetByID = (name) => `import { z } from 'zod';
 
 import { ValidateSchema } from '@/utils/decorators';
 import { ${capitalizeFirstLetter(name)}EntitySchema } from '@/core/${name}/entity/${name}';
-import { DatabaseOptionsType } from '@/utils/database/sequelize';
+;
 import { ApiNotFoundException } from '@/utils/exception';
 import { IUsecase } from '@/utils/usecase';
 
@@ -26,7 +26,7 @@ export class ${capitalizeFirstLetter(name)}GetByIdUsecase implements IUsecase {
 
   @ValidateSchema(${capitalizeFirstLetter(name)}GetByIdSchema)
   async execute({ id }: ${capitalizeFirstLetter(name)}GetByIDInput): Promise<${capitalizeFirstLetter(name)}GetByIDOutput> {
-    const ${name} = await this.${name}Repository.findById<DatabaseOptionsType>(id);
+    const ${name} = await this.${name}Repository.findById(id);
 
     if (!${name}) {
       throw new ApiNotFoundException();

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

@@ -8,7 +8,7 @@ const getCoreUsecaseUpdate = (name) => `import { z } from 'zod';
 import { ValidateSchema } from '@/utils/decorators';
 import { I${capitalizeFirstLetter(name)}Repository } from '@/core/${name}/repository/${name}';
 import { ILoggerAdapter } from '@/infra/logger';
-import { DatabaseOptionsType } from '@/utils/database/sequelize';
+;
 import { ApiNotFoundException } from '@/utils/exception';
 import { IUsecase } from '@/utils/usecase';
 
@@ -26,7 +26,7 @@ export class ${capitalizeFirstLetter(name)}UpdateUsecase implements IUsecase {
 
   @ValidateSchema(${capitalizeFirstLetter(name)}UpdateSchema)
   async execute(input: ${capitalizeFirstLetter(name)}UpdateInput): Promise<${capitalizeFirstLetter(name)}UpdateOutput> {
-    const ${name} = await this.${name}Repository.findById<DatabaseOptionsType>(input.id);
+    const ${name} = await this.${name}Repository.findById(input.id);
 
     if (!${name}) {
       throw new ApiNotFoundException();
@@ -40,7 +40,7 @@ export class ${capitalizeFirstLetter(name)}UpdateUsecase implements IUsecase {
 
     this.loggerService.info({ message: '${name} updated.', obj: { ${name}: input } });
 
-    const updated = await this.${name}Repository.findById<DatabaseOptionsType>(entity.id);
+    const updated = await this.${name}Repository.findById(entity.id);
 
     return new ${capitalizeFirstLetter(name)}Entity(updated);
   }

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

@@ -13,7 +13,7 @@ import { ${capitalizeFirstLetter(name)}DeleteInput, ${capitalizeFirstLetter(name
 import { ${capitalizeFirstLetter(name)}GetByIDInput, ${capitalizeFirstLetter(name)}GetByIDOutput } from '@/core/${name}/use-cases/${name}-get-by-id';
 import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from '@/core/${name}/use-cases/${name}-list';
 import { ${capitalizeFirstLetter(name)}UpdateInput, ${capitalizeFirstLetter(name)}UpdateOutput } from '@/core/${name}/use-cases/${name}-update';
-import { UserRole } from '@/core/user/entity/user';
+import { UserRoleEnum } from '@/core/user/entity/user';
 import { ApiRequest } from '@/utils/request';
 import { SearchHttpSchema } from '@/utils/search';
 import { SortHttpSchema } from '@/utils/sort';
@@ -30,7 +30,7 @@ import { SwaggerRequest, SwaggerResponse } from './swagger';
 @Controller('${pluralize(name)}')
 @ApiTags('${pluralize(name)}')
 @ApiBearerAuth()
-@Roles(UserRole.USER)
+@Roles(UserRoleEnum.USER)
 export class ${capitalizeFirstLetter(name)}Controller {
   constructor(
     private readonly ${name}Create: I${capitalizeFirstLetter(name)}CreateAdapter,
@@ -47,12 +47,13 @@ export class ${capitalizeFirstLetter(name)}Controller {
     return await this.${name}Create.execute(body as ${capitalizeFirstLetter(name)}CreateInput);
   }
 
-  @Put()
+  @Put(':id')
   @ApiResponse(SwaggerResponse.update[200])
   @ApiResponse(SwaggerResponse.update[404])
   @ApiBody(SwaggerRequest.updateBody)
-  async update(@Req() { body }: ApiRequest): Promise<${capitalizeFirstLetter(name)}UpdateOutput> {
-    return await this.${name}Update.execute(body as ${capitalizeFirstLetter(name)}UpdateInput);
+  @ApiParam({ name: 'id', required: true })
+  async update(@Req() { body, params }: ApiRequest): Promise<${capitalizeFirstLetter(name)}UpdateOutput> {
+    return await this.${name}Update.execute({ ...body, id: params.id } as ${capitalizeFirstLetter(name)}UpdateInput);
   }
 
   @Get('/:id')

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

@@ -4,7 +4,8 @@ function capitalizeFirstLetter(string) {
 }
 
 const getModule = (name) => `import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
-import { ModelCtor, Sequelize } from 'sequelize-typescript';
+import { getRepositoryToken, TypeOrmModule } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
 
 import { IsLoggedMiddleware } from '@/observables/middlewares';
 import { ${capitalizeFirstLetter(name)}Entity } from '@/core/${name}/entity/${name}';
@@ -15,8 +16,6 @@ import { ${capitalizeFirstLetter(name)}GetByIdUsecase } from '@/core/${name}/use
 import { ${capitalizeFirstLetter(name)}ListUsecase } from '@/core/${name}/use-cases/${name}-list';
 import { ${capitalizeFirstLetter(name)}UpdateUsecase } from '@/core/${name}/use-cases/${name}-update';
 import { RedisCacheModule } from '@/infra/cache/redis';
-import { IDataBaseAdapter } from '@/infra/database';
-import { PostgresDatabaseModule } from '@/infra/database/postgres/module';
 import { ${capitalizeFirstLetter(name)}Schema } from '@/infra/database/postgres/schemas/${name}';
 import { ILoggerAdapter, LoggerModule } from '@/infra/logger';
 import { TokenLibModule } from '@/libs/token';
@@ -32,16 +31,15 @@ import { ${capitalizeFirstLetter(name)}Controller } from './controller';
 import { ${capitalizeFirstLetter(name)}Repository } from './repository';
 
 @Module({
-  imports: [TokenLibModule, LoggerModule, RedisCacheModule, PostgresDatabaseModule],
+  imports: [TokenLibModule, LoggerModule, RedisCacheModule, TypeOrmModule.forFeature([${capitalizeFirstLetter(name)}Schema])],
   controllers: [${capitalizeFirstLetter(name)}Controller],
   providers: [
     {
       provide: I${capitalizeFirstLetter(name)}Repository,
-      useFactory: (database: IDataBaseAdapter) => {
-        const repossitory = database.getDatabase<Sequelize>().model(${capitalizeFirstLetter(name)}Schema);
-        return new ${capitalizeFirstLetter(name)}Repository(repossitory as ModelCtor<${capitalizeFirstLetter(name)}Schema> & ${capitalizeFirstLetter(name)}Entity);
+      useFactory: (repository: Repository<${capitalizeFirstLetter(name)}Schema & ${capitalizeFirstLetter(name)}Entity>) => {
+        return new ${capitalizeFirstLetter(name)}Repository(repository);
       },
-      inject: [IDataBaseAdapter]
+      inject: [getRepositoryToken(${capitalizeFirstLetter(name)}Schema)]
     },
     {
       provide: I${capitalizeFirstLetter(name)}CreateAdapter,

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

@@ -4,43 +4,39 @@ function capitalizeFirstLetter(string) {
 }
 
 const getModuleRepository = (name) => `import { Injectable } from '@nestjs/common';
-import { Transaction } from 'sequelize';
-import { ModelCtor } from 'sequelize-typescript';
-
-import {
-  ConvertPaginateInputToSequelizeFilter,
-  SearchTypeEnum,
-  ValidateDatabaseSortAllowed
-} from '@/utils/decorators';
+import { FindOptionsWhere, Repository } from 'typeorm';
+
 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 { DatabaseOptionsSchema, DatabaseOptionsType } from '@/utils/database/sequelize';
+import { TypeORMRepository } from '@/infra/repository/postgres/repository';
+import { SearchTypeEnum, ValidateDatabaseSortAllowed, ValidateMongooseFilter } from '@/utils/decorators';
+import { calculateSkip } from '@/utils/pagination';
 
-type Model = ModelCtor<${capitalizeFirstLetter(name)}Schema> & ${capitalizeFirstLetter(name)}Entity;
+type Model = ${capitalizeFirstLetter(name)}Schema & ${capitalizeFirstLetter(name)}Entity;
 
 @Injectable()
-export class ${capitalizeFirstLetter(name)}Repository extends SequelizeRepository<Model> implements I${capitalizeFirstLetter(name)}Repository {
-  constructor(readonly repository: Model) {
+export class ${capitalizeFirstLetter(name)}Repository extends TypeORMRepository<Model> implements I${capitalizeFirstLetter(name)}Repository {
+  constructor(readonly repository: Repository<Model>) {
     super(repository);
   }
 
-  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.map((r) => new ${capitalizeFirstLetter(name)}Entity(r)), limit: input.limit, page: input.page, total: list.count };
+  @ValidateMongooseFilter<${capitalizeFirstLetter(name)}Entity>([
+    { name: 'name', type: SearchTypeEnum.like },
+  ])
+  @ValidateDatabaseSortAllowed<${capitalizeFirstLetter(name)}Entity>('name', 'createdAt')
+  async paginate(input: ${capitalizeFirstLetter(name)}ListInput): Promise<${capitalizeFirstLetter(name)}ListOutput> {
+    const skip = calculateSkip(input);
+
+    const [docs, total] = await this.repository.findAndCount({
+      take: input.limit,
+      skip,
+      order: input.sort,
+      where: input.search as FindOptionsWhere<unknown>
+    });
+
+    return { docs, total, page: input.page, limit: input.limit };
   }
 }
 `

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

@@ -35,7 +35,7 @@ export const SwaggerResponse = {
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/${pluralize(name)}',
+      route: 'api/v1/${pluralize(name)}',
       message: '${name}NotFound',
       description: '${name} not found.'
     })
@@ -48,7 +48,7 @@ export const SwaggerResponse = {
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/${pluralize(name)}/:id',
+      route: 'api/v1/${pluralize(name)}/:id',
       message: '${name}NotFound',
       description: '${name} not found.'
     })
@@ -61,7 +61,7 @@ export const SwaggerResponse = {
     }),
     404: Swagger.defaultResponseError({
       status: 404,
-      route: 'api/${pluralize(name)}/:id',
+      route: 'api/v1/${pluralize(name)}/:id',
       message: '${name}NotFound',
       description: '${name} not found.'
     })

package/src/templates/postgres/schemas/schema.js

@@ -5,18 +5,32 @@ function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-const getModuleSchema = (name) => `import { Column, DataType, Model, Table } from 'sequelize-typescript';
+const getModuleSchema = (name) => `import {
+  BaseEntity,
+  Column,
+  CreateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  UpdateDateColumn
+} from 'typeorm';
 
-@Table({ timestamps: true, tableName: '${pluralize(name)}', underscored: true })
-export class ${capitalizeFirstLetter(name)}Schema extends Model {
-  @Column({ primaryKey: true, type: DataType.UUID })
+
+@Entity({ name: '${pluralize(name)}' })
+export class ${capitalizeFirstLetter(name)}Schema extends BaseEntity {
+  @Column({ type: 'uuid', primary: true })
   id: string;
 
-  @Column(DataType.STRING)
+  @Column('text')
   name: string;
 
-  @Column({ allowNull: true, type: DataType.DATE })
-  deletedAt?: Date;
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+
+  @DeleteDateColumn({ nullable: true })
+  deletedAt: Date;
 }
 `