feat(nestjs): migrate to NestJS

packages/server/src/modules/BankRules/commands/CreateBankRule.service.ts

@@ -0,0 +1,67 @@
+import { ModelObject } from 'objection';
+import { Knex } from 'knex';
+import { Inject, Injectable } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import {
+  IBankRuleEventCreatedPayload,
+  IBankRuleEventCreatingPayload,
+} from '../types';
+import { UnitOfWork } from '../../Tenancy/TenancyDB/UnitOfWork.service';
+import { events } from '@/common/events/events';
+import { BankRule } from '../models/BankRule';
+import { CreateBankRuleDto } from '../dtos/BankRule.dto';
+import { TenantModelProxy } from '@/modules/System/models/TenantBaseModel';
+
+@Injectable()
+export class CreateBankRuleService {
+  constructor(
+    private readonly uow: UnitOfWork,
+    private readonly eventPublisher: EventEmitter2,
+
+    @Inject(BankRule.name)
+    private readonly bankRuleModel: TenantModelProxy<typeof BankRule>,
+  ) {}
+
+  /**
+   * Transforms the DTO to model.
+   * @param {ICreateBankRuleDTO} createDTO
+   */
+  private transformDTO(createDTO: CreateBankRuleDto): ModelObject<BankRule> {
+    return {
+      ...createDTO,
+    } as ModelObject<BankRule>;
+  }
+
+  /**
+   * Creates a new bank rule.
+   * @param {ICreateBankRuleDTO} createRuleDTO
+   * @returns {Promise<BankRule>}
+   */
+  public async createBankRule(
+    createRuleDTO: CreateBankRuleDto,
+  ): Promise<BankRule> {
+    const transformDTO = this.transformDTO(createRuleDTO);
+
+    return this.uow.withTransaction(async (trx: Knex.Transaction) => {
+      // Triggers `onBankRuleCreating` event.
+      await this.eventPublisher.emitAsync(events.bankRules.onCreating, {
+        createRuleDTO,
+        trx,
+      } as IBankRuleEventCreatingPayload);
+
+      const bankRule = await this.bankRuleModel()
+        .query(trx)
+        .upsertGraphAndFetch({
+          ...transformDTO,
+        });
+      // Triggers `onBankRuleCreated` event.
+      await this.eventPublisher.emitAsync(events.bankRules.onCreated, {
+        createRuleDTO,
+        bankRule,
+        trx,
+      } as IBankRuleEventCreatedPayload);
+
+      return bankRule;
+    });
+  }
+}

packages/server/src/modules/BankRules/commands/DeleteBankRule.service.ts

@@ -0,0 +1,63 @@
+import { Knex } from 'knex';
+import { Inject, Injectable } from '@nestjs/common';
+import {
+  IBankRuleEventDeletedPayload,
+  IBankRuleEventDeletingPayload,
+} from '../types';
+import { BankRule } from '../models/BankRule';
+import { BankRuleCondition } from '../models/BankRuleCondition';
+import { UnitOfWork } from '@/modules/Tenancy/TenancyDB/UnitOfWork.service';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { events } from '@/common/events/events';
+import { TenantModelProxy } from '@/modules/System/models/TenantBaseModel';
+
+@Injectable()
+export class DeleteBankRuleService {
+  constructor(
+    @Inject(BankRule.name)
+    private bankRuleModel: TenantModelProxy<typeof BankRule>,
+
+    @Inject(BankRuleCondition.name)
+    private bankRuleConditionModel: TenantModelProxy<typeof BankRuleCondition>,
+
+    private readonly uow: UnitOfWork,
+    private readonly eventPublisher: EventEmitter2,
+  ) {}
+
+  /**
+   * Deletes the given bank rule.
+   * @param {number} ruleId
+   * @returns {Promise<void>}
+   */
+  public async deleteBankRule(
+    ruleId: number,
+    trx?: Knex.Transaction,
+  ): Promise<void> {
+    const oldBankRule = await this.bankRuleModel()
+      .query()
+      .findById(ruleId)
+      .throwIfNotFound();
+
+    return this.uow.withTransaction(async (trx: Knex.Transaction) => {
+      // Triggers `onBankRuleDeleting` event.
+      await this.eventPublisher.emitAsync(events.bankRules.onDeleting, {
+        oldBankRule,
+        ruleId,
+        trx,
+      } as IBankRuleEventDeletingPayload);
+
+      await this.bankRuleConditionModel()
+        .query(trx)
+        .where('ruleId', ruleId)
+        .delete();
+
+      await this.bankRuleModel().query(trx).findById(ruleId).delete();
+
+      // Triggers `onBankRuleDeleted` event.
+      await this.eventPublisher.emitAsync(events.bankRules.onDeleted, {
+        ruleId,
+        trx,
+      } as IBankRuleEventDeletedPayload);
+    }, trx);
+  }
+}

packages/server/src/modules/BankRules/commands/DeleteBankRules.service.ts

@@ -0,0 +1,28 @@
+import { Knex } from 'knex';
+import { PromisePool } from '@supercharge/promise-pool';
+import { castArray, uniq } from 'lodash';
+import { DeleteBankRuleService } from './DeleteBankRule.service';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class DeleteBankRulesService {
+  constructor(private readonly deleteBankRuleService: DeleteBankRuleService) {}
+
+  /**
+   * Delete bank rules.
+   * @param {number | Array<number>} bankRuleId - The bank rule id or ids.
+   * @param {Knex.Transaction} trx - The transaction.
+   */
+  async deleteBankRules(
+    bankRuleId: number | Array<number>,
+    trx?: Knex.Transaction,
+  ) {
+    const bankRulesIds = uniq(castArray(bankRuleId));
+
+    const results = await PromisePool.withConcurrency(1)
+      .for(bankRulesIds)
+      .process(async (bankRuleId: number) => {
+        await this.deleteBankRuleService.deleteBankRule(bankRuleId, trx);
+      });
+  }
+}

packages/server/src/modules/BankRules/commands/EditBankRule.service.ts

@@ -0,0 +1,75 @@
+import { Inject, Injectable } from '@nestjs/common';
+import {
+  IBankRuleEventEditedPayload,
+  IBankRuleEventEditingPayload,
+  IEditBankRuleDTO,
+} from '../types';
+import { BankRule } from '../models/BankRule';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { UnitOfWork } from '@/modules/Tenancy/TenancyDB/UnitOfWork.service';
+import { events } from '@/common/events/events';
+import { TenantModelProxy } from '@/modules/System/models/TenantBaseModel';
+import { EditBankRuleDto } from '../dtos/BankRule.dto';
+import { ModelObject } from 'objection';
+
+@Injectable()
+export class EditBankRuleService {
+  constructor(
+    private readonly uow: UnitOfWork,
+    private readonly eventPublisher: EventEmitter2,
+
+    @Inject(BankRule.name)
+    private bankRuleModel: TenantModelProxy<typeof BankRule>,
+  ) {}
+
+  /**
+   *
+   * @param createDTO
+   * @returns
+   */
+  private transformDTO(createDTO: EditBankRuleDto): ModelObject<BankRule> {
+    return {
+      ...createDTO,
+    } as ModelObject<BankRule>;
+  }
+
+  /**
+   * Edits the given bank rule.
+   * @param {number} ruleId -
+   * @param {IEditBankRuleDTO} editBankDTO
+   */
+  public async editBankRule(ruleId: number, editRuleDTO: EditBankRuleDto) {
+    const oldBankRule = await this.bankRuleModel()
+      .query()
+      .findById(ruleId)
+      .withGraphFetched('conditions')
+      .throwIfNotFound();
+
+    const tranformDTO = this.transformDTO(editRuleDTO);
+
+    return this.uow.withTransaction(async (trx) => {
+      // Triggers `onBankRuleEditing` event.
+      await this.eventPublisher.emitAsync(events.bankRules.onEditing, {
+        oldBankRule,
+        ruleId,
+        editRuleDTO,
+        trx,
+      } as IBankRuleEventEditingPayload);
+
+      // Updates the given bank rule.
+      const bankRule = await this.bankRuleModel()
+        .query(trx)
+        .upsertGraphAndFetch({
+          ...tranformDTO,
+          id: ruleId,
+        });
+      // Triggers `onBankRuleEdited` event.
+      await this.eventPublisher.emitAsync(events.bankRules.onEdited, {
+        oldBankRule,
+        bankRule,
+        editRuleDTO,
+        trx,
+      } as IBankRuleEventEditedPayload);
+    });
+  }
+}