@mikemajesty/microservice-crud 3.3.10 → 3.3.11

package/package.json

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

package/potgres.README.md

@@ -1,16 +1,5 @@
 #### Postgres CRUD
 
-### Add Schema to Sequelize.
-
- - Access the config.ts file
-  ```
-    src/infra/database/postgres/config.ts
-  ```
- - Add your Postgres schema in the addModels function. 
-  ```
-    sequelizeConfig.addModels([NewSchema]);
-  ```
-
 ### Add Module to microservice.
 
  - Access the app.module.ts file

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

@@ -5,7 +5,7 @@ function capitalizeFirstLetter(string) {
 
 const getCoreEntity = (name) => `import { z } from 'zod';
 
-import { BaseEntity, withID } from '@/utils/entity';
+import { BaseEntity, IEntity } from '@/utils/entity';
 
 const ID = z.string().uuid();
 const Name = z.string().min(1).max(200).trim();
@@ -23,12 +23,12 @@ export const ${capitalizeFirstLetter(name)}EntitySchema = z.object({
 
 type ${capitalizeFirstLetter(name)} = z.infer<typeof ${capitalizeFirstLetter(name)}EntitySchema>;
 
-export class ${capitalizeFirstLetter(name)}Entity extends BaseEntity<${capitalizeFirstLetter(name)}Entity>(${capitalizeFirstLetter(name)}EntitySchema) {
+export class ${capitalizeFirstLetter(name)}Entity extends BaseEntity<${capitalizeFirstLetter(name)}Entity>(${capitalizeFirstLetter(name)}EntitySchema) implements IEntity {
   name: string;
 
   constructor(entity: ${capitalizeFirstLetter(name)}) {
     super();
-    Object.assign(this, ${capitalizeFirstLetter(name)}EntitySchema.parse(withID(entity)));
+    Object.assign(this, this.validate(entity));
   }
 }
 `

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

@@ -7,7 +7,6 @@ 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, generateUUID } from '@/utils/tests/tests';
 
 import { ${capitalizeFirstLetter(name)}Entity } from '../../entity/${name}';
@@ -64,22 +63,9 @@ describe('${capitalizeFirstLetter(name)}CreateUsecase', () => {
     const createOutput: ${capitalizeFirstLetter(name)}CreateOutput = { created: true, id: generateUUID() };
 
     repository.create = jest.fn().mockResolvedValue(createOutput);
-    repository.startSession = jest.fn().mockResolvedValue({
-      commit: jest.fn()
-    });
 
     await expect(usecase.execute(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

@@ -7,7 +7,6 @@ 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}';
@@ -27,19 +26,11 @@ export class ${capitalizeFirstLetter(name)}CreateUsecase {
   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.loggerServide.info({ message: '${name} created.', obj: { ${name} } });
 
-      this.loggerServide.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

@@ -6,7 +6,6 @@ function capitalizeFirstLetter(string) {
 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';
 
@@ -24,7 +23,7 @@ export class ${capitalizeFirstLetter(name)}DeleteUsecase {
 
   @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/getByID.js

@@ -6,7 +6,6 @@ function capitalizeFirstLetter(string) {
 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';
 
@@ -25,7 +24,7 @@ export class ${capitalizeFirstLetter(name)}GetByIdUsecase {
 
   @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

@@ -7,7 +7,6 @@ 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';
 
@@ -25,7 +24,7 @@ export class ${capitalizeFirstLetter(name)}UpdateUsecase {
 
   @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();
@@ -39,7 +38,7 @@ export class ${capitalizeFirstLetter(name)}UpdateUsecase {
 
     this.loggerServide.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/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 { ${capitalizeFirstLetter(name)}Entity } from '@/core/${name}/entity/${name}';
 import { I${capitalizeFirstLetter(name)}Repository } from '@/core/${name}/repository/${name}';
@@ -14,8 +15,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 { TokenModule } from '@/libs/auth';
@@ -32,21 +31,20 @@ import { ${capitalizeFirstLetter(name)}Controller } from './controller';
 import { ${capitalizeFirstLetter(name)}Repository } from './repository';
 
 @Module({
-  imports: [TokenModule, LoggerModule, RedisCacheModule, PostgresDatabaseModule],
+  imports: [TokenModule, LoggerModule, TypeOrmModule.forFeature([${capitalizeFirstLetter(name)}Schema]), RedisCacheModule],
   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,
-      useFactory: (logger: ILoggerAdapter, repository: I${capitalizeFirstLetter(name)}Repository) => new ${capitalizeFirstLetter(name)}CreateUsecase(repository, logger),
-      inject: [ILoggerAdapter, I${capitalizeFirstLetter(name)}Repository]
+      useFactory: (repository: I${capitalizeFirstLetter(name)}Repository, logger: ILoggerAdapter) => new ${capitalizeFirstLetter(name)}CreateUsecase(repository, logger),
+      inject: [I${capitalizeFirstLetter(name)}Repository, ILoggerAdapter]
     },
     {
       provide: I${capitalizeFirstLetter(name)}UpdateAdapter,

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

@@ -4,41 +4,39 @@ function capitalizeFirstLetter(string) {
 }
 
 const getModuleRepository = (name) => `import { Injectable } from '@nestjs/common';
-import { Transaction } from 'sequelize';
-import { ModelCtor } from 'sequelize-typescript';
+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 { ConvertPaginateInputToSequelizeFilter } from '@/utils/decorators/database/postgres/convert-paginate-input-to-sequelize-filter.decorator';
+import { PostgresRepository } from '@/infra/repository/postgres/repository';
+import { ValidatePostgresFilter } from '@/utils/decorators/database/postgres/validate-typeorm-filter.decorator';
 import { ValidateDatabaseSortAllowed } from '@/utils/decorators/database/validate-database-sort-allowed.decorator';
 import { SearchTypeEnum } from '@/utils/decorators/types';
+import { calucaleSkip } 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 PostgresRepository<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();
+  @ValidateDatabaseSortAllowed<${capitalizeFirstLetter(name)}Entity>('createdAt', 'name')
+  @ValidatePostgresFilter<${capitalizeFirstLetter(name)}Entity>([{ name: 'name', type: SearchTypeEnum.like }])
+  async paginate(input: ${capitalizeFirstLetter(name)}ListInput): Promise<${capitalizeFirstLetter(name)}ListOutput> {
+    const skip = calucaleSkip(input);
 
-    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);
+    const [docs, total] = await this.repository.findAndCount({
+      take: input.limit,
+      skip,
+      order: input.sort,
+      where: input.search as FindOptionsWhere<${capitalizeFirstLetter(name)}Entity>
+    });
 
-    return { docs: list.rows.map((r) => new ${capitalizeFirstLetter(name)}Entity(r)), limit: input.limit, page: input.page, total: list.count };
+    return { docs, total, page: input.page, limit: input.limit };
   }
 }
 `

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

@@ -5,18 +5,27 @@ 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 { Max, Min } from 'class-validator';
+import { BaseEntity, Column, CreateDateColumn, DeleteDateColumn, Entity, UpdateDateColumn } from 'typeorm';
 
-@Table({ timestamps: true, tableName: '${pluralize(name)}' })
-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)
+  @Min(1)
+  @Max(200)
+  @Column()
   name: string;
 
-  @Column({ allowNull: true, type: DataType.DATE })
-  deletedAt?: Date;
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+
+  @DeleteDateColumn({ nullable: true })
+  deletedAt: Date;
 }
 `