fix: Delete bank account with uncategorized transactions

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

@@ -73,6 +73,7 @@ export class DeleteAccount {
       .throwIfNotFound()
       .queryAndThrowIfHasRelations({
         type: ERRORS.ACCOUNT_HAS_ASSOCIATED_TRANSACTIONS,
+        excludeRelations: ['uncategorizedTransactions', 'plaidItem']
       });
     // Authorize before delete account.
     await this.authorize(tenantId, accountId, oldAccount);

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

@@ -0,0 +1,68 @@
+import { Inject, Service } from 'typedi';
+import { initialize } from 'objection';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import events from '@/subscribers/events';
+import { IAccountEventDeletePayload } from '@/interfaces';
+import { DeleteBankRulesService } from '../../Rules/DeleteBankRules';
+import { RevertRecognizedTransactions } from '../../RegonizeTranasctions/RevertRecognizedTransactions';
+
+@Service()
+export class DeleteUncategorizedTransactionsOnAccountDeleting {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private deleteBankRules: DeleteBankRulesService;
+
+  @Inject()
+  private revertRecognizedTransactins: RevertRecognizedTransactions;
+
+  /**
+   * Constructor method.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.accounts.onDelete,
+      this.handleDeleteBankRulesOnAccountDeleting.bind(this),
+    )
+    bus.subscribe(
+      events.accounts.onDelete,
+      this.handleDeleteUncategorizedTransactions.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) {
+    const knex = this.tenancy.knex(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);
+
+    await initialize(knex, [
+      UncategorizedCashflowTransaction,
+      RecognizedBankTransaction,
+      MatchedBankTransaction,
+    ]);
+
+    await this.revertRecognizedTransactins.revertRecognizedTransactions(tenantId, foundAssociatedRulesIds, null, trx)
+
+    await this.deleteBankRules.deleteBankRules(tenantId, foundAssociatedRulesIds);
+  }
+}

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

@@ -3,6 +3,7 @@ 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';
 
 @Service()
 export class DisconnectPlaidItemOnAccountDeleted {
@@ -51,13 +52,17 @@ export class DisconnectPlaidItemOnAccountDeleted {
       .findOne('plaidItemId', oldAccount.plaidItemId)
       .delete();
 
-    if (oldPlaidItem) {
-      const plaidInstance = PlaidClientWrapper.getClient();
+    // Remove Plaid item once the transaction resolve.
+    runAfterTransaction(trx, async () => {
+      if (oldPlaidItem) {
+        const plaidInstance = PlaidClientWrapper.getClient();
+
+        // Remove the Plaid item.
+        await plaidInstance.itemRemove({
+          access_token: oldPlaidItem.plaidAccessToken,
+        });
+      }
+    })
 
-      // Remove the Plaid item.
-      await plaidInstance.itemRemove({
-        access_token: oldPlaidItem.plaidAccessToken,
-      });
-    }
   }
 }

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

@@ -26,7 +26,7 @@ export class DeleteBankRuleSerivce {
    * @param {number} ruleId
    * @returns {Promise<void>}
    */
-  public async deleteBankRule(tenantId: number, ruleId: number): 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()
@@ -51,6 +51,6 @@ export class DeleteBankRuleSerivce {
         ruleId,
         trx,
       } as IBankRuleEventDeletedPayload);
-    });
+    }, trx);
   }
 }

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

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