feat: delete uncategorized transactions before deleting bank account

packages/server/src/services/Accounts/AccountsApplication.ts

@@ -43,8 +43,8 @@ export class AccountsApplication {
 
   /**
    * Creates a new account.
-   * @param   {number} tenantId
-   * @param   {IAccountCreateDTO} accountDTO
+   * @param {number} tenantId
+   * @param {IAccountCreateDTO} accountDTO
    * @returns {Promise<IAccount>}
    */
   public createAccount = (
@@ -108,8 +108,8 @@ export class AccountsApplication {
 
   /**
    * Retrieves the account details.
-   * @param   {number} tenantId
-   * @param   {number} accountId
+   * @param {number} tenantId
+   * @param {number} accountId
    * @returns {Promise<IAccount>}
    */
   public getAccount = (tenantId: number, accountId: number) => {

packages/server/src/services/Banking/BankAccounts/events/DeleteUncategorizedTransactionsOnAccountDeleting.ts

@@ -23,46 +23,56 @@ export class DeleteUncategorizedTransactionsOnAccountDeleting {
   public attach(bus) {
     bus.subscribe(
       events.accounts.onDelete,
-      this.handleDeleteBankRulesOnAccountDeleting.bind(this),
-    )
-    bus.subscribe(
-      events.accounts.onDelete,
-      this.handleDeleteUncategorizedTransactions.bind(this)
+      this.handleDeleteBankRulesOnAccountDeleting.bind(this)
     );
   }
 
-  /**
-   * Handles delete the uncategorized transactions.
-   * @param {IAccountEventDeletePayload} payload -
-   */
-  private async handleDeleteUncategorizedTransactions({ tenantId, oldAccount, trx }: IAccountEventDeletePayload) {
-    const { UncategorizedCashflowTransaction } = this.tenancy.models(tenantId);
-
-    await UncategorizedCashflowTransaction.query(trx)
-      .where('accountId', oldAccount.id)
-      .delete();
-  }
-
   /**
    * Handles revert the recognized transactions and delete all the bank rules
    * associated to the deleted bank account.
    * @param {IAccountEventDeletePayload}
    */
-  private async handleDeleteBankRulesOnAccountDeleting({ tenantId, oldAccount, trx }: IAccountEventDeletePayload) {
+  private async handleDeleteBankRulesOnAccountDeleting({
+    tenantId,
+    oldAccount,
+    trx,
+  }: IAccountEventDeletePayload) {
     const knex = this.tenancy.knex(tenantId);
-    const { BankRule, UncategorizedCashflowTransaction, MatchedBankTransaction, RecognizedBankTransaction } = this.tenancy.models(tenantId);
+    const {
+      BankRule,
+      UncategorizedCashflowTransaction,
+      MatchedBankTransaction,
+      RecognizedBankTransaction,
+    } = this.tenancy.models(tenantId);
 
-    const foundAssociatedRules = await BankRule.query(trx).where('applyIfAccountId', oldAccount.id);
-    const foundAssociatedRulesIds = foundAssociatedRules.map(rule => rule.id);
+    const foundAssociatedRules = await BankRule.query(trx).where(
+      'applyIfAccountId',
+      oldAccount.id
+    );
+    const foundAssociatedRulesIds = foundAssociatedRules.map((rule) => rule.id);
 
     await initialize(knex, [
       UncategorizedCashflowTransaction,
       RecognizedBankTransaction,
       MatchedBankTransaction,
     ]);
+    // Revert the recognized transactions of the given bank rules.
+    await this.revertRecognizedTransactins.revertRecognizedTransactions(
+      tenantId,
+      foundAssociatedRulesIds,
+      null,
+      trx
+    );
+    // Delete the associated uncategorized transactions.
+    await UncategorizedCashflowTransaction.query(trx)
+      .where('accountId', oldAccount.id)
+      .delete();
 
-    await this.revertRecognizedTransactins.revertRecognizedTransactions(tenantId, foundAssociatedRulesIds, null, trx)
-
-    await this.deleteBankRules.deleteBankRules(tenantId, foundAssociatedRulesIds);
+    // Delete the given bank rules.
+    await this.deleteBankRules.deleteBankRules(
+      tenantId,
+      foundAssociatedRulesIds,
+      trx
+    );
   }
-}
+}

packages/server/src/services/Banking/BankAccounts/events/DisconnectPlaidItemOnAccountDeleted.ts

@@ -2,8 +2,8 @@ import { Inject, Service } from 'typedi';
 import { IAccountEventDeletedPayload } from '@/interfaces';
 import { PlaidClientWrapper } from '@/lib/Plaid';
 import HasTenancyService from '@/services/Tenancy/TenancyService';
-import events from '@/subscribers/events';
 import { runAfterTransaction } from '@/services/UnitOfWork/TransactionsHooks';
+import events from '@/subscribers/events';
 
 @Service()
 export class DisconnectPlaidItemOnAccountDeleted {

packages/server/src/services/Banking/Plaid/PlaidUpdateTransactions.ts

@@ -1,10 +1,10 @@
-import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Knex } from 'knex';
 import { Inject, Service } from 'typedi';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
 import { PlaidClientWrapper } from '@/lib/Plaid/Plaid';
 import { PlaidSyncDb } from './PlaidSyncDB';
 import { PlaidFetchedTransactionsUpdates } from '@/interfaces';
 import UnitOfWork from '@/services/UnitOfWork';
-import { Knex } from 'knex';
 
 @Service()
 export class PlaidUpdateTransactions {
@@ -19,9 +19,9 @@ export class PlaidUpdateTransactions {
 
   /**
    * Handles sync the Plaid item to Bigcaptial under UOW.
-   * @param {number} tenantId
-   * @param {number} plaidItemId
-   * @returns {Promise<{  addedCount: number; modifiedCount: number; removedCount: number; }>}
+   * @param {number} tenantId - Tenant id.
+   * @param {number} plaidItemId - Plaid item id.
+   * @returns {Promise<{ addedCount: number; modifiedCount: number; removedCount: number; }>}
    */
   public async updateTransactions(tenantId: number, plaidItemId: string) {
     return this.uow.withTransaction(tenantId, (trx: Knex.Transaction) => {

packages/server/src/services/Banking/Rules/DeleteBankRule.ts

@@ -26,31 +26,39 @@ export class DeleteBankRuleSerivce {
    * @param {number} ruleId
    * @returns {Promise<void>}
    */
-  public async deleteBankRule(tenantId: number, ruleId: number, trx?: Knex.Transaction): Promise<void> {
+  public async deleteBankRule(
+    tenantId: number,
+    ruleId: number,
+    trx?: Knex.Transaction
+  ): Promise<void> {
     const { BankRule, BankRuleCondition } = this.tenancy.models(tenantId);
 
     const oldBankRule = await BankRule.query()
       .findById(ruleId)
       .throwIfNotFound();
 
-    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
-      // Triggers `onBankRuleDeleting` event.
-      await this.eventPublisher.emitAsync(events.bankRules.onDeleting, {
-        tenantId,
-        oldBankRule,
-        ruleId,
-        trx,
-      } as IBankRuleEventDeletingPayload);
+    return this.uow.withTransaction(
+      tenantId,
+      async (trx: Knex.Transaction) => {
+        // Triggers `onBankRuleDeleting` event.
+        await this.eventPublisher.emitAsync(events.bankRules.onDeleting, {
+          tenantId,
+          oldBankRule,
+          ruleId,
+          trx,
+        } as IBankRuleEventDeletingPayload);
 
-      await BankRuleCondition.query(trx).where('ruleId', ruleId).delete();
-      await BankRule.query(trx).findById(ruleId).delete();
+        await BankRuleCondition.query(trx).where('ruleId', ruleId).delete()
+        await BankRule.query(trx).findById(ruleId).delete();
 
-      // Triggers `onBankRuleDeleted` event.
-      await await this.eventPublisher.emitAsync(events.bankRules.onDeleted, {
-        tenantId,
-        ruleId,
-        trx,
-      } as IBankRuleEventDeletedPayload);
-    }, trx);
+        // Triggers `onBankRuleDeleted` event.
+        await await this.eventPublisher.emitAsync(events.bankRules.onDeleted, {
+          tenantId,
+          ruleId,
+          trx,
+        } as IBankRuleEventDeletedPayload);
+      },
+      trx
+    );
   }
 }

packages/server/src/services/Banking/Rules/DeleteBankRules.ts

@@ -1,8 +1,8 @@
 import { Knex } from 'knex';
-import { Inject, Service } from "typedi";
-import PromisePool from "@supercharge/promise-pool";
-import { castArray, uniq } from "lodash";
-import { DeleteBankRuleSerivce } from "./DeleteBankRule";
+import { Inject, Service } from 'typedi';
+import PromisePool from '@supercharge/promise-pool';
+import { castArray, uniq } from 'lodash';
+import { DeleteBankRuleSerivce } from './DeleteBankRule';
 
 @Service()
 export class DeleteBankRulesService {
@@ -11,16 +11,24 @@ export class DeleteBankRulesService {
 
   /**
    * Delete bank rules.
-   * @param {number} tenantId 
-   * @param {number | Array<number>} bankRuleId 
+   * @param {number} tenantId
+   * @param {number | Array<number>} bankRuleId
    */
-  async deleteBankRules(tenantId: number, bankRuleId: number | Array<number>, trx?: Knex.Transaction) {
+  async deleteBankRules(
+    tenantId: number,
+    bankRuleId: number | Array<number>,
+    trx?: Knex.Transaction
+  ) {
     const bankRulesIds = uniq(castArray(bankRuleId));
 
-    await PromisePool.withConcurrency(1)
+    const results = await PromisePool.withConcurrency(1)
       .for(bankRulesIds)
       .process(async (bankRuleId: number) => {
-        await this.deleteBankRuleService.deleteBankRule(tenantId, bankRuleId, trx);
+        await this.deleteBankRuleService.deleteBankRule(
+          tenantId,
+          bankRuleId,
+          trx
+        );
       });
   }
-}
+}