feat(nestjs): migrate to NestJS

packages/server/src/modules/Accounts/Account.transformer.ts

@@ -0,0 +1,130 @@
+import { Transformer } from '../Transformer/Transformer';
+import { Account } from './models/Account.model';
+import { flatToNestedArray } from '@/utils/flat-to-nested-array';
+import { assocDepthLevelToObjectTree } from '@/utils/assoc-depth-level-to-object-tree';
+import { nestedArrayToFlatten } from '@/utils/nested-array-to-flatten';
+import { IAccountsStructureType } from './Accounts.types';
+
+export class AccountTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'accountTypeLabel',
+      'accountNormalFormatted',
+      'formattedAmount',
+      'flattenName',
+      'bankBalanceFormatted',
+      'lastFeedsUpdatedAtFormatted',
+      'isFeedsPaused',
+    ];
+  };
+
+  /**
+   * Exclude attributes.
+   * @returns {string[]}
+   */
+  public excludeAttributes = (): string[] => {
+    return ['plaidItem'];
+  };
+
+  /**
+   * Retrieves the flatten name with all dependants accounts names.
+   * @param {IAccount} account -
+   * @returns {string}
+   */
+  public flattenName = (account: Account): string => {
+    const parentDependantsIds = this.options.accountsGraph.dependantsOf(
+      account.id,
+    );
+    const prefixAccounts = parentDependantsIds.map((dependId) => {
+      const node = this.options.accountsGraph.getNodeData(dependId);
+      return `${node.name}: `;
+    });
+    return `${prefixAccounts}${account.name}`;
+  };
+
+  /**
+   * Retrieve formatted account amount.
+   * @param {IAccount} invoice
+   * @returns {string}
+   */
+  protected formattedAmount = (account: Account): string => {
+    return this.formatNumber(account.amount, {
+      currencyCode: account.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieves the formatted bank balance.
+   * @param {Account} account
+   * @returns {string}
+   */
+  protected bankBalanceFormatted = (account: Account): string => {
+    return this.formatNumber(account.bankBalance, {
+      currencyCode: account.currencyCode,
+    });
+  };
+
+  /**
+   * Retrieves the formatted last feeds update at.
+   * @param {IAccount} account
+   * @returns {string}
+   */
+  protected lastFeedsUpdatedAtFormatted = (account: Account): string => {
+    return account.lastFeedsUpdatedAt
+      ? this.formatDate(account.lastFeedsUpdatedAt)
+      : '';
+  };
+
+  /**
+   * Detarmines whether the bank account connection is paused.
+   * @param account
+   * @returns {boolean}
+   */
+  protected isFeedsPaused = (account: Account): boolean => {
+    // return account.plaidItem?.isPaused || false;
+
+    return false;
+  };
+
+  /**
+   * Retrieves formatted account type label.
+   * @returns {string}
+   */
+  protected accountTypeLabel = (account: Account): string => {
+    return this.context.i18n.t(account.accountTypeLabel);
+  };
+
+  /**
+   * Retrieves formatted account normal.
+   * @returns {string}
+   */
+  protected accountNormalFormatted = (account: Account): string => {
+    return this.context.i18n.t(account.accountNormalFormatted);
+  };
+
+  /**
+   * Transformes the accounts collection to flat or nested array.
+   * @param {IAccount[]}
+   * @returns {IAccount[]}
+   */
+  protected postCollectionTransform = (accounts: Account[]) => {
+    // Transfom the flatten to accounts tree.
+    const transformed = flatToNestedArray(accounts, {
+      id: 'id',
+      parentId: 'parentAccountId',
+    });
+    // Associate `accountLevel` attr to indicate object depth.
+    const transformed2 = assocDepthLevelToObjectTree(
+      transformed,
+      1,
+      'accountLevel',
+    );
+    return this.options.structure === IAccountsStructureType.Flat
+      ? nestedArrayToFlatten(transformed2)
+      : transformed2;
+  };
+}

packages/server/src/modules/Accounts/AccountTransaction.transformer.ts

@@ -0,0 +1,124 @@
+import { Transformer } from '../Transformer/Transformer';
+import { AccountTransaction } from './models/AccountTransaction.model';
+
+export class AccountTransactionTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {Array}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'date',
+      'formattedDate',
+      'transactionType',
+      'transactionId',
+      'transactionTypeFormatted',
+      'credit',
+      'debit',
+      'formattedCredit',
+      'formattedDebit',
+      'fcCredit',
+      'fcDebit',
+      'formattedFcCredit',
+      'formattedFcDebit',
+    ];
+  };
+
+  /**
+   * Exclude all attributes of the model.
+   * @returns {Array<string>}
+   */
+  public excludeAttributes = (): string[] => {
+    return ['*'];
+  };
+
+  /**
+   * Retrieves the formatted date.
+   * @returns {string}
+   */
+  public formattedDate(transaction: AccountTransaction) {
+    return this.formatDate(transaction.date);
+  }
+
+  /**
+   * Retrieves the formatted transaction type.
+   * @returns {string}
+   */
+  public transactionTypeFormatted(transaction: AccountTransaction) {
+    return this.context.i18n.t(transaction.referenceTypeFormatted);
+  }
+
+  /**
+   * Retrieves the tranasction type.
+   * @returns {string}
+   */
+  public transactionType(transaction: AccountTransaction) {
+    return transaction.referenceType;
+  }
+
+  /**
+   * Retrieves the transaction id.
+   * @returns {number}
+   */
+  public transactionId(transaction: AccountTransaction) {
+    return transaction.referenceId;
+  }
+
+  /**
+   * Retrieves the credit amount.
+   * @returns {string}
+   */
+  protected formattedCredit(transaction: AccountTransaction) {
+    return this.formatMoney(transaction.credit, {
+      excerptZero: true,
+    });
+  }
+
+  /**
+   * Retrieves the credit amount.
+   * @returns {string}
+   */
+  protected formattedDebit(transaction: AccountTransaction) {
+    return this.formatMoney(transaction.debit, {
+      excerptZero: true,
+    });
+  }
+
+  /**
+   * Retrieves the foreign credit amount.
+   * @returns {number}
+   */
+  protected fcCredit(transaction: AccountTransaction) {
+    return transaction.credit * transaction.exchangeRate;
+  }
+
+  /**
+   * Retrieves the foreign debit amount.
+   * @returns {number}
+   */
+  protected fcDebit(transaction: AccountTransaction) {
+    return transaction.debit * transaction.exchangeRate;
+  }
+
+  /**
+   * Retrieves the formatted foreign credit amount.
+   * @returns {string}
+   */
+  protected formattedFcCredit(transaction: AccountTransaction) {
+    return this.formatMoney(this.fcCredit(transaction), {
+      currencyCode: transaction.currencyCode,
+      excerptZero: true,
+    });
+  }
+
+  /**
+   * Retrieves the formatted foreign debit amount.
+   * @returns {string}
+   */
+  protected formattedFcDebit(transaction: AccountTransaction) {
+    return this.formatMoney(this.fcDebit(transaction), {
+      currencyCode: transaction.currencyCode,
+      excerptZero: true,
+    });
+  }
+}

packages/server/src/modules/Accounts/Accounts.constants.ts

@@ -0,0 +1,637 @@
+export const OtherExpensesAccount = {
+  name: 'Other Expenses',
+  slug: 'other-expenses',
+  accountType: 'other-expense',
+  code: '40011',
+  description: '',
+  active: true,
+  index: 1,
+  predefined: true,
+};
+
+export const TaxPayableAccount = {
+  name: 'Tax Payable',
+  slug: 'tax-payable',
+  accountType: 'tax-payable',
+  code: '20006',
+  description: '',
+  active: true,
+  index: 1,
+  predefined: true,
+};
+
+export const UnearnedRevenueAccount = {
+  name: 'Unearned Revenue',
+  slug: 'unearned-revenue',
+  accountType: 'other-current-liability',
+  parentAccountId: null,
+  code: '50005',
+  active: true,
+  index: 1,
+  predefined: true,
+};
+
+export const PrepardExpenses = {
+  name: 'Prepaid Expenses',
+  slug: 'prepaid-expenses',
+  accountType: 'other-current-asset',
+  parentAccountId: null,
+  code: '100010',
+  active: true,
+  index: 1,
+  predefined: true,
+};
+
+export const StripeClearingAccount = {
+  name: 'Stripe Clearing',
+  slug: 'stripe-clearing',
+  accountType: 'other-current-asset',
+  parentAccountId: null,
+  code: '100020',
+  active: true,
+  index: 1,
+  predefined: true,
+};
+
+export const DiscountExpenseAccount = {
+  name: 'Discount',
+  slug: 'discount',
+  accountType: 'other-income',
+  code: '40008',
+  active: true,
+  index: 1,
+  predefined: true,
+};
+
+export const PurchaseDiscountAccount = {
+  name: 'Purchase Discount',
+  slug: 'purchase-discount',
+  accountType: 'other-expense',
+  code: '40009',
+  active: true,
+  index: 1,
+  predefined: true,
+};
+
+export const OtherChargesAccount = {
+  name: 'Other Charges',
+  slug: 'other-charges',
+  accountType: 'other-income',
+  code: '40010',
+  active: true,
+  index: 1,
+  predefined: true,
+};
+
+export const SeedAccounts = [
+  {
+    name: 'Bank Account',
+    slug: 'bank-account',
+    accountType: 'bank',
+    code: '10001',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name: 'Saving Bank Account',
+    slug: 'saving-bank-account',
+    account_type: 'bank',
+    code: '10002',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+  {
+    name: 'Undeposited Funds',
+    slug: 'undeposited-funds',
+    account_type: 'cash',
+    code: '10003',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name: 'Petty Cash',
+    slug: 'petty-cash',
+    account_type: 'cash',
+    code: '10004',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name: 'Computer Equipment',
+    slug: 'computer-equipment',
+    code: '10005',
+    account_type: 'fixed-asset',
+    predefined: 0,
+    parent_account_id: null,
+    index: 1,
+    active: 1,
+    description: '',
+  },
+  {
+    name: 'Office Equipment',
+    slug: 'office-equipment',
+    code: '10006',
+    account_type: 'fixed-asset',
+    predefined: 0,
+    parent_account_id: null,
+    index: 1,
+    active: 1,
+    description: '',
+  },
+  {
+    name: 'Accounts Receivable (A/R)',
+    slug: 'accounts-receivable',
+    account_type: 'accounts-receivable',
+    code: '10007',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name: 'Inventory Asset',
+    slug: 'inventory-asset',
+    code: '10008',
+    account_type: 'inventory',
+    predefined: 1,
+    parent_account_id: null,
+    index: 1,
+    active: 1,
+    description:
+      'An account that holds valuation of products or goods that available for sale.',
+  },
+
+  // Libilities
+  {
+    name: 'Accounts Payable (A/P)',
+    slug: 'accounts-payable',
+    account_type: 'accounts-payable',
+    parent_account_id: null,
+    code: '20001',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name: 'Owner A Drawings',
+    slug: 'owner-drawings',
+    account_type: 'other-current-liability',
+    parent_account_id: null,
+    code: '20002',
+    description: 'Withdrawals by the owners.',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+  {
+    name: 'Loan',
+    slug: 'owner-drawings',
+    account_type: 'other-current-liability',
+    code: '20003',
+    description: 'Money that has been borrowed from a creditor.',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+  {
+    name: 'Opening Balance Liabilities',
+    slug: 'opening-balance-liabilities',
+    account_type: 'other-current-liability',
+    code: '20004',
+    description:
+      'This account will hold the difference in the debits and credits entered during the opening balance..',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+  {
+    name: 'Revenue Received in Advance',
+    slug: 'revenue-received-in-advance',
+    account_type: 'other-current-liability',
+    parent_account_id: null,
+    code: '20005',
+    description: 'When customers pay in advance for products/services.',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+  TaxPayableAccount,
+
+  // Equity
+  {
+    name: 'Retained Earnings',
+    slug: 'retained-earnings',
+    account_type: 'equity',
+    code: '30001',
+    description:
+      'Retained earnings tracks net income from previous fiscal years.',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name: 'Opening Balance Equity',
+    slug: 'opening-balance-equity',
+    account_type: 'equity',
+    code: '30002',
+    description:
+      'When you enter opening balances to the accounts, the amounts enter in Opening balance equity. This ensures that you have a correct trial balance sheet for your company, without even specific the second credit or debit entry.',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name: "Owner's Equity",
+    slug: 'owner-equity',
+    account_type: 'equity',
+    code: '30003',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name: `Drawings`,
+    slug: 'drawings',
+    account_type: 'equity',
+    code: '30003',
+    description:
+      'Goods purchased with the intention of selling these to customers',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+
+  // Expenses
+  OtherExpensesAccount,
+  {
+    name: 'Other Expenses',
+    slug: 'other-expenses',
+    account_type: 'other-expense',
+    parent_account_id: null,
+    code: '40001',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name: 'Cost of Goods Sold',
+    slug: 'cost-of-goods-sold',
+    account_type: 'cost-of-goods-sold',
+    parent_account_id: null,
+    code: '40002',
+    description: 'Tracks the direct cost of the goods sold.',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name: 'Office expenses',
+    slug: 'office-expenses',
+    account_type: 'expense',
+    parent_account_id: null,
+    code: '40003',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+  {
+    name: 'Rent',
+    slug: 'rent',
+    account_type: 'expense',
+    parent_account_id: null,
+    code: '40004',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+  {
+    name: 'Exchange Gain or Loss',
+    slug: 'exchange-grain-loss',
+    account_type: 'other-expense',
+    parent_account_id: null,
+    code: '40005',
+    description: 'Tracks the gain and losses of the exchange differences.',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name: 'Bank Fees and Charges',
+    slug: 'bank-fees-and-charges',
+    account_type: 'expense',
+    parent_account_id: null,
+    code: '40006',
+    description:
+      'Any bank fees levied is recorded into the bank fees and charges account. A bank account maintenance fee, transaction charges, a late payment fee are some examples.',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+  {
+    name: 'Depreciation Expense',
+    slug: 'depreciation-expense',
+    account_type: 'expense',
+    parent_account_id: null,
+    code: '40007',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+
+  // Income
+  {
+    name: 'Sales of Product Income',
+    slug: 'sales-of-product-income',
+    account_type: 'income',
+    predefined: 1,
+    parent_account_id: null,
+    code: '50001',
+    index: 1,
+    active: 1,
+    description: '',
+  },
+  {
+    name: 'Sales of Service Income',
+    slug: 'sales-of-service-income',
+    account_type: 'income',
+    predefined: 0,
+    parent_account_id: null,
+    code: '50002',
+    index: 1,
+    active: 1,
+    description: '',
+  },
+  {
+    name: 'Uncategorized Income',
+    slug: 'uncategorized-income',
+    account_type: 'income',
+    parent_account_id: null,
+    code: '50003',
+    description: '',
+    active: 1,
+    index: 1,
+    predefined: 1,
+  },
+  {
+    name: 'Other Income',
+    slug: 'other-income',
+    account_type: 'other-income',
+    parent_account_id: null,
+    code: '50004',
+    description:
+      'The income activities are not associated to the core business.',
+    active: 1,
+    index: 1,
+    predefined: 0,
+  },
+  UnearnedRevenueAccount,
+  PrepardExpenses,
+  DiscountExpenseAccount,
+  PurchaseDiscountAccount,
+  OtherChargesAccount,
+];
+
+export const ACCOUNT_TYPE = {
+  CASH: 'cash',
+  BANK: 'bank',
+  ACCOUNTS_RECEIVABLE: 'accounts-receivable',
+  INVENTORY: 'inventory',
+  OTHER_CURRENT_ASSET: 'other-current-asset',
+  FIXED_ASSET: 'fixed-asset',
+  NON_CURRENT_ASSET: 'none-current-asset',
+
+  ACCOUNTS_PAYABLE: 'accounts-payable',
+  CREDIT_CARD: 'credit-card',
+  TAX_PAYABLE: 'tax-payable',
+  OTHER_CURRENT_LIABILITY: 'other-current-liability',
+  LOGN_TERM_LIABILITY: 'long-term-liability',
+  NON_CURRENT_LIABILITY: 'non-current-liability',
+
+  EQUITY: 'equity',
+  INCOME: 'income',
+  OTHER_INCOME: 'other-income',
+  COST_OF_GOODS_SOLD: 'cost-of-goods-sold',
+  EXPENSE: 'expense',
+  OTHER_EXPENSE: 'other-expense',
+};
+
+export const ACCOUNT_PARENT_TYPE = {
+  CURRENT_ASSET: 'current-asset',
+  FIXED_ASSET: 'fixed-asset',
+  NON_CURRENT_ASSET: 'non-current-asset',
+
+  CURRENT_LIABILITY: 'current-liability',
+  LOGN_TERM_LIABILITY: 'long-term-liability',
+  NON_CURRENT_LIABILITY: 'non-current-liability',
+
+  EQUITY: 'equity',
+  EXPENSE: 'expense',
+  INCOME: 'income',
+};
+
+export const ACCOUNT_ROOT_TYPE = {
+  ASSET: 'asset',
+  LIABILITY: 'liability',
+  EQUITY: 'equity',
+  EXPENSE: 'expense',
+  INCOME: 'income',
+};
+
+export const ACCOUNT_NORMAL = {
+  CREDIT: 'credit',
+  DEBIT: 'debit',
+};
+export const ACCOUNT_TYPES = [
+  {
+    label: 'Cash',
+    key: ACCOUNT_TYPE.CASH,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_ASSET,
+    rootType: ACCOUNT_ROOT_TYPE.ASSET,
+    multiCurrency: true,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Bank',
+    key: ACCOUNT_TYPE.BANK,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_ASSET,
+    rootType: ACCOUNT_ROOT_TYPE.ASSET,
+    multiCurrency: true,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Accounts Receivable',
+    key: ACCOUNT_TYPE.ACCOUNTS_RECEIVABLE,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    rootType: ACCOUNT_ROOT_TYPE.ASSET,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_ASSET,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Inventory',
+    key: ACCOUNT_TYPE.INVENTORY,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    rootType: ACCOUNT_ROOT_TYPE.ASSET,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_ASSET,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Other Current Asset',
+    key: ACCOUNT_TYPE.OTHER_CURRENT_ASSET,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    rootType: ACCOUNT_ROOT_TYPE.ASSET,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_ASSET,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Fixed Asset',
+    key: ACCOUNT_TYPE.FIXED_ASSET,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    rootType: ACCOUNT_ROOT_TYPE.ASSET,
+    parentType: ACCOUNT_PARENT_TYPE.FIXED_ASSET,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Non-Current Asset',
+    key: ACCOUNT_TYPE.NON_CURRENT_ASSET,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    rootType: ACCOUNT_ROOT_TYPE.ASSET,
+    parentType: ACCOUNT_PARENT_TYPE.FIXED_ASSET,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Accounts Payable',
+    key: ACCOUNT_TYPE.ACCOUNTS_PAYABLE,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.LIABILITY,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_LIABILITY,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Credit Card',
+    key: ACCOUNT_TYPE.CREDIT_CARD,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.LIABILITY,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_LIABILITY,
+    multiCurrency: true,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Tax Payable',
+    key: ACCOUNT_TYPE.TAX_PAYABLE,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.LIABILITY,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_LIABILITY,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Other Current Liability',
+    key: ACCOUNT_TYPE.OTHER_CURRENT_LIABILITY,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.LIABILITY,
+    parentType: ACCOUNT_PARENT_TYPE.CURRENT_LIABILITY,
+    balanceSheet: false,
+    incomeSheet: true,
+  },
+  {
+    label: 'Long Term Liability',
+    key: ACCOUNT_TYPE.LOGN_TERM_LIABILITY,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.LIABILITY,
+    parentType: ACCOUNT_PARENT_TYPE.LOGN_TERM_LIABILITY,
+    balanceSheet: false,
+    incomeSheet: true,
+  },
+  {
+    label: 'Non-Current Liability',
+    key: ACCOUNT_TYPE.NON_CURRENT_LIABILITY,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.LIABILITY,
+    parentType: ACCOUNT_PARENT_TYPE.NON_CURRENT_LIABILITY,
+    balanceSheet: false,
+    incomeSheet: true,
+  },
+  {
+    label: 'Equity',
+    key: ACCOUNT_TYPE.EQUITY,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.EQUITY,
+    parentType: ACCOUNT_PARENT_TYPE.EQUITY,
+    balanceSheet: true,
+    incomeSheet: false,
+  },
+  {
+    label: 'Income',
+    key: ACCOUNT_TYPE.INCOME,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.INCOME,
+    parentType: ACCOUNT_PARENT_TYPE.INCOME,
+    balanceSheet: false,
+    incomeSheet: true,
+  },
+  {
+    label: 'Other Income',
+    key: ACCOUNT_TYPE.OTHER_INCOME,
+    normal: ACCOUNT_NORMAL.CREDIT,
+    rootType: ACCOUNT_ROOT_TYPE.INCOME,
+    parentType: ACCOUNT_PARENT_TYPE.INCOME,
+    balanceSheet: false,
+    incomeSheet: true,
+  },
+  {
+    label: 'Cost of Goods Sold',
+    key: ACCOUNT_TYPE.COST_OF_GOODS_SOLD,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    rootType: ACCOUNT_ROOT_TYPE.EXPENSE,
+    parentType: ACCOUNT_PARENT_TYPE.EXPENSE,
+    balanceSheet: false,
+    incomeSheet: true,
+  },
+  {
+    label: 'Expense',
+    key: ACCOUNT_TYPE.EXPENSE,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    rootType: ACCOUNT_ROOT_TYPE.EXPENSE,
+    parentType: ACCOUNT_PARENT_TYPE.EXPENSE,
+    balanceSheet: false,
+    incomeSheet: true,
+  },
+  {
+    label: 'Other Expense',
+    key: ACCOUNT_TYPE.OTHER_EXPENSE,
+    normal: ACCOUNT_NORMAL.DEBIT,
+    rootType: ACCOUNT_ROOT_TYPE.EXPENSE,
+    parentType: ACCOUNT_PARENT_TYPE.EXPENSE,
+    balanceSheet: false,
+    incomeSheet: true,
+  },
+];
+
+export const getAccountsSupportsMultiCurrency = () => {
+  return ACCOUNT_TYPES.filter((account) => account.multiCurrency);
+};

packages/server/src/modules/Accounts/Accounts.controller.ts

@@ -0,0 +1,149 @@
+import {
+  Controller,
+  Post,
+  Body,
+  Param,
+  Delete,
+  Get,
+  Query,
+  ParseIntPipe,
+} from '@nestjs/common';
+import { AccountsApplication } from './AccountsApplication.service';
+import { CreateAccountDTO } from './CreateAccount.dto';
+import { EditAccountDTO } from './EditAccount.dto';
+import { IAccountsFilter, IAccountsTransactionsFilter } from './Accounts.types';
+import { ApiOperation, ApiParam, ApiResponse, ApiTags } from '@nestjs/swagger';
+
+@Controller('accounts')
+@ApiTags('accounts')
+export class AccountsController {
+  constructor(private readonly accountsApplication: AccountsApplication) {}
+
+  @Post()
+  @ApiOperation({ summary: 'Create an account' })
+  @ApiResponse({
+    status: 200,
+    description: 'The account has been successfully created.',
+  })
+  async createAccount(@Body() accountDTO: CreateAccountDTO) {
+    return this.accountsApplication.createAccount(accountDTO);
+  }
+
+  @Post(':id')
+  @ApiOperation({ summary: 'Edit the given account.' })
+  @ApiResponse({
+    status: 200,
+    description: 'The account has been successfully updated.',
+  })
+  @ApiResponse({ status: 404, description: 'The account not found.' })
+  @ApiParam({
+    name: 'id',
+    required: true,
+    type: Number,
+    description: 'The account id',
+  })
+  async editAccount(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() accountDTO: EditAccountDTO,
+  ) {
+    return this.accountsApplication.editAccount(id, accountDTO);
+  }
+
+  @Delete(':id')
+  @ApiOperation({ summary: 'Delete the given account.' })
+  @ApiResponse({
+    status: 200,
+    description: 'The account has been successfully deleted.',
+  })
+  @ApiResponse({ status: 404, description: 'The account not found.' })
+  @ApiParam({
+    name: 'id',
+    required: true,
+    type: Number,
+    description: 'The account id',
+  })
+  async deleteAccount(@Param('id', ParseIntPipe) id: number) {
+    return this.accountsApplication.deleteAccount(id);
+  }
+
+  @Post(':id/activate')
+  @ApiOperation({ summary: 'Activate the given account.' })
+  @ApiResponse({
+    status: 200,
+    description: 'The account has been successfully activated.',
+  })
+  @ApiResponse({ status: 404, description: 'The account not found.' })
+  @ApiParam({
+    name: 'id',
+    required: true,
+    type: Number,
+    description: 'The account id',
+  })
+  async activateAccount(@Param('id', ParseIntPipe) id: number) {
+    return this.accountsApplication.activateAccount(id);
+  }
+
+  @Post(':id/inactivate')
+  @ApiOperation({ summary: 'Inactivate the given account.' })
+  @ApiResponse({
+    status: 200,
+    description: 'The account has been successfully inactivated.',
+  })
+  @ApiResponse({ status: 404, description: 'The account not found.' })
+  @ApiParam({
+    name: 'id',
+    required: true,
+    type: Number,
+    description: 'The account id',
+  })
+  async inactivateAccount(@Param('id', ParseIntPipe) id: number) {
+    return this.accountsApplication.inactivateAccount(id);
+  }
+
+  @Get('types')
+  @ApiOperation({ summary: 'Retrieves the account types.' })
+  @ApiResponse({
+    status: 200,
+    description: 'The account types have been successfully retrieved.',
+  })
+  async getAccountTypes() {
+    return this.accountsApplication.getAccountTypes();
+  }
+
+  @Get('transactions')
+  @ApiOperation({ summary: 'Retrieves the account transactions.' })
+  @ApiResponse({
+    status: 200,
+    description: 'The account transactions have been successfully retrieved.',
+  })
+  async getAccountTransactions(@Query() filter: IAccountsTransactionsFilter) {
+    return this.accountsApplication.getAccountsTransactions(filter);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Retrieves the account details.' })
+  @ApiResponse({
+    status: 200,
+    description: 'The account details have been successfully retrieved.',
+  })
+  @ApiResponse({ status: 404, description: 'The account not found.' })
+  @ApiParam({
+    name: 'id',
+    required: true,
+    type: Number,
+    description: 'The account id',
+  })
+  async getAccount(@Param('id', ParseIntPipe) id: number) {
+    return this.accountsApplication.getAccount(id);
+  }
+
+  @Get()
+  @ApiOperation({ summary: 'Retrieves the accounts.' })
+  @ApiResponse({
+    status: 200,
+    description: 'The accounts have been successfully retrieved.',
+  })
+  async getAccounts(@Query() filter: IAccountsFilter) {
+    return this.accountsApplication.getAccounts(filter);
+  }
+}

packages/server/src/modules/Accounts/Accounts.module.ts

@@ -0,0 +1,44 @@
+import { Module } from '@nestjs/common';
+import { TenancyDatabaseModule } from '../Tenancy/TenancyDB/TenancyDB.module';
+import { AccountsController } from './Accounts.controller';
+import { AccountsApplication } from './AccountsApplication.service';
+import { CreateAccountService } from './CreateAccount.service';
+import { TenancyContext } from '../Tenancy/TenancyContext.service';
+import { CommandAccountValidators } from './CommandAccountValidators.service';
+import { AccountRepository } from './repositories/Account.repository';
+import { EditAccount } from './EditAccount.service';
+import { DeleteAccount } from './DeleteAccount.service';
+import { GetAccount } from './GetAccount.service';
+import { TransformerInjectable } from '../Transformer/TransformerInjectable.service';
+import { ActivateAccount } from './ActivateAccount.service';
+import { GetAccountTypesService } from './GetAccountTypes.service';
+import { GetAccountTransactionsService } from './GetAccountTransactions.service';
+import { RegisterTenancyModel } from '../Tenancy/TenancyModels/Tenancy.module';
+import { BankAccount } from '../BankingTransactions/models/BankAccount';
+import { GetAccountsService } from './GetAccounts.service';
+import { DynamicListModule } from '../DynamicListing/DynamicList.module';
+// import { GetAccountsService } from './GetAccounts.service';
+
+const models = [RegisterTenancyModel(BankAccount)];
+
+@Module({
+  imports: [TenancyDatabaseModule, DynamicListModule, ...models],
+  controllers: [AccountsController],
+  providers: [
+    AccountsApplication,
+    CreateAccountService,
+    TenancyContext,
+    CommandAccountValidators,
+    AccountRepository,
+    EditAccount,
+    DeleteAccount,
+    GetAccount,
+    TransformerInjectable,
+    ActivateAccount,
+    GetAccountTypesService,
+    GetAccountTransactionsService,
+    GetAccountsService,
+  ],
+  exports: [AccountRepository, CreateAccountService, ...models],
+})
+export class AccountsModule {}

packages/server/src/modules/Accounts/Accounts.types.ts

@@ -0,0 +1,92 @@
+import { Knex } from 'knex';
+import { Account } from './models/Account.model';
+// import { IDynamicListFilterDTO } from '@/interfaces/DynamicFilter';
+
+export enum AccountNormal {
+  DEBIT = 'debit',
+  CREDIT = 'credit',
+}
+
+export interface IAccountsTransactionsFilter {
+  accountId?: number;
+  limit?: number;
+}
+
+export enum IAccountsStructureType {
+  Tree = 'tree',
+  Flat = 'flat',
+}
+
+// export interface IAccountsFilter extends IDynamicListFilterDTO {
+// }
+export interface IAccountsFilter {
+  onlyInactive: boolean;
+  structure?: IAccountsStructureType;
+}
+export interface IAccountType {
+  label: string;
+  key: string;
+  normal: string;
+  rootType: string;
+  childType: string;
+  balanceSheet: boolean;
+  incomeSheet: boolean;
+}
+
+export interface IAccountsTypesService {
+  getAccountsTypes(): Promise<IAccountType>;
+}
+
+export interface IAccountEventCreatingPayload {
+  accountDTO: any;
+  trx: Knex.Transaction;
+}
+
+export interface IAccountEventCreatedPayload {
+  account: Account;
+  accountId: number;
+  trx: Knex.Transaction;
+}
+
+export interface IAccountEventEditedPayload {
+  account: Account;
+  oldAccount: Account;
+  trx: Knex.Transaction;
+}
+
+export interface IAccountEventDeletedPayload {
+  accountId: number;
+  oldAccount: Account;
+  trx: Knex.Transaction;
+}
+
+export interface IAccountEventDeletePayload {
+  trx: Knex.Transaction;
+  oldAccount: Account;
+}
+
+export interface IAccountEventActivatedPayload {
+  accountId: number;
+  trx: Knex.Transaction;
+}
+
+export enum AccountAction {
+  CREATE = 'Create',
+  EDIT = 'Edit',
+  DELETE = 'Delete',
+  VIEW = 'View',
+  TransactionsLocking = 'TransactionsLocking',
+}
+
+export enum TaxRateAction {
+  CREATE = 'Create',
+  EDIT = 'Edit',
+  DELETE = 'Delete',
+  VIEW = 'View',
+}
+
+export interface CreateAccountParams {
+  ignoreUniqueName: boolean;
+}
+
+export interface IGetAccountTransactionPOJO {}

packages/server/src/modules/Accounts/AccountsApplication.service.ts

@@ -0,0 +1,133 @@
+import { Knex } from 'knex';
+import { Injectable } from '@nestjs/common';
+import { CreateAccountService } from './CreateAccount.service';
+import { DeleteAccount } from './DeleteAccount.service';
+import { EditAccount } from './EditAccount.service';
+import { CreateAccountDTO } from './CreateAccount.dto';
+import { Account } from './models/Account.model';
+import { EditAccountDTO } from './EditAccount.dto';
+import { GetAccount } from './GetAccount.service';
+import { ActivateAccount } from './ActivateAccount.service';
+import { GetAccountTypesService } from './GetAccountTypes.service';
+import { GetAccountTransactionsService } from './GetAccountTransactions.service';
+import {
+  IAccountsFilter,
+  IAccountsTransactionsFilter,
+  IGetAccountTransactionPOJO,
+} from './Accounts.types';
+import { GetAccountsService } from './GetAccounts.service';
+import { IFilterMeta } from '@/interfaces/Model';
+
+@Injectable()
+export class AccountsApplication {
+  /**
+   * @param {CreateAccountService} createAccountService - The create account service.
+   * @param {EditAccount} editAccountService - The edit account service.
+   * @param {DeleteAccount} deleteAccountService - The delete account service.
+   * @param {ActivateAccount} activateAccountService - The activate account service.
+   * @param {GetAccountTypesService} getAccountTypesService - The get account types service.
+   * @param {GetAccount} getAccountService - The get account service.
+   * @param {GetAccountTransactionsService} getAccountTransactionsService - The get account transactions service.
+   * @param {GetAccountsService} getAccountsService - The get accounts service.
+   */
+  constructor(
+    private readonly createAccountService: CreateAccountService,
+    private readonly editAccountService: EditAccount,
+    private readonly deleteAccountService: DeleteAccount,
+    private readonly activateAccountService: ActivateAccount,
+    private readonly getAccountTypesService: GetAccountTypesService,
+    private readonly getAccountService: GetAccount,
+    private readonly getAccountTransactionsService: GetAccountTransactionsService,
+    private readonly getAccountsService: GetAccountsService,
+  ) {}
+
+  /**
+   * Creates a new account.
+   * @param {number} tenantId
+   * @param {IAccountCreateDTO} accountDTO
+   * @returns {Promise<IAccount>}
+   */
+  public createAccount = (
+    accountDTO: CreateAccountDTO,
+    trx?: Knex.Transaction,
+  ): Promise<Account> => {
+    return this.createAccountService.createAccount(accountDTO, trx);
+  };
+
+  /**
+   * Deletes the given account.
+   * @param {number} tenantId
+   * @param {number} accountId
+   * @returns {Promise<void>}
+   */
+  public deleteAccount = (accountId: number) => {
+    return this.deleteAccountService.deleteAccount(accountId);
+  };
+
+  /**
+   * Edits the given account.
+   * @param {number} tenantId
+   * @param {number} accountId
+   * @param {IAccountEditDTO} accountDTO
+   * @returns
+   */
+  public editAccount = (accountId: number, accountDTO: EditAccountDTO) => {
+    return this.editAccountService.editAccount(accountId, accountDTO);
+  };
+
+  /**
+   * Activate the given account.
+   * @param {number} accountId - Account id.
+   */
+  public activateAccount = (accountId: number) => {
+    return this.activateAccountService.activateAccount(accountId, true);
+  };
+
+  /**
+   * Inactivate the given account.
+   * @param {number} accountId - Account id.
+   */
+  public inactivateAccount = (accountId: number) => {
+    return this.activateAccountService.activateAccount(accountId, false);
+  };
+
+  /**
+   * Retrieves the account details.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} accountId - Account id.
+   * @returns {Promise<IAccount>}
+   */
+  public getAccount = (accountId: number) => {
+    return this.getAccountService.getAccount(accountId);
+  };
+
+  /**
+   * Retrieves all account types.
+   * @returns {Promise<IAccountType[]>}
+   */
+  public getAccountTypes = () => {
+    return this.getAccountTypesService.getAccountsTypes();
+  };
+
+  /**
+   * Retrieves the accounts list.
+   * @param {IAccountsFilter} filterDTO - Filter DTO.
+   * @returns {Promise<{ accounts: IAccountResponse[]; filterMeta: IFilterMeta }>}
+   */
+  public getAccounts = (
+    filterDTO: IAccountsFilter,
+  ): Promise<{ accounts: Account[]; filterMeta: IFilterMeta }> => {
+    return this.getAccountsService.getAccountsList(filterDTO);
+  };
+
+  /**
+   * Retrieves the given account transactions.
+   * @param {IAccountsTransactionsFilter} filter
+   * @returns {Promise<IGetAccountTransactionPOJO[]>}
+   */
+  public getAccountsTransactions = (
+    filter: IAccountsTransactionsFilter,
+  ): Promise<IGetAccountTransactionPOJO[]> => {
+    return this.getAccountTransactionsService.getAccountsTransactions(filter);
+  };
+}

packages/server/src/modules/Accounts/AccountsExportable.service.ts

@@ -0,0 +1,29 @@
+import { AccountsApplication } from './AccountsApplication.service';
+import { Exportable } from '../Export/Exportable';
+import { EXPORT_SIZE_LIMIT } from '../Export/constants';
+import { IAccountsFilter, IAccountsStructureType } from './Accounts.types';
+
+export class AccountsExportable extends Exportable {
+  constructor(private readonly accountsApplication: AccountsApplication) {
+    super();
+  }
+
+  /**
+   * Retrieves the accounts data to exportable sheet.
+   */
+  public exportable(query: IAccountsFilter) {
+    const parsedQuery = {
+      sortOrder: 'desc',
+      columnSortBy: 'created_at',
+      inactiveMode: false,
+      ...query,
+      structure: IAccountsStructureType.Flat,
+      pageSize: EXPORT_SIZE_LIMIT,
+      page: 1,
+    } as IAccountsFilter;
+
+    return this.accountsApplication
+      .getAccounts(parsedQuery)
+      .then((output) => output.accounts);
+  }
+}

packages/server/src/modules/Accounts/AccountsImportable.SampleData.ts

@@ -0,0 +1,50 @@
+export const AccountsSampleData = [
+  {
+    'Account Name': 'Utilities Expense',
+    'Account Code': 9000,
+    Type: 'Expense',
+    Description: 'Omnis voluptatum consequatur.',
+    Active: 'T',
+    'Currency Code': '',
+  },
+  {
+    'Account Name': 'Unearned Revenue',
+    'Account Code': 9010,
+    Type: 'Long Term Liability',
+    Description: 'Autem odit voluptas nihil unde.',
+    Active: 'T',
+    'Currency Code': '',
+  },
+  {
+    'Account Name': 'Long-Term Debt',
+    'Account Code': 9020,
+    Type: 'Long Term Liability',
+    Description: 'In voluptas cumque exercitationem.',
+    Active: 'T',
+    'Currency Code': '',
+  },
+  {
+    'Account Name': 'Salaries and Wages Expense',
+    'Account Code': 9030,
+    Type: 'Expense',
+    Description: 'Assumenda aspernatur soluta aliquid perspiciatis quasi.',
+    Active: 'T',
+    'Currency Code': '',
+  },
+  {
+    'Account Name': 'Rental Income',
+    'Account Code': 9040,
+    Type: 'Income',
+    Description: 'Omnis possimus amet occaecati inventore.',
+    Active: 'T',
+    'Currency Code': '',
+  },
+  {
+    'Account Name': 'Paypal',
+    'Account Code': 9050,
+    Type: 'Bank',
+    Description: 'In voluptas cumque exercitationem.',
+    Active: 'T',
+    'Currency Code': '',
+  },
+];

packages/server/src/modules/Accounts/AccountsImportable.service.ts

@@ -0,0 +1,45 @@
+// import { Inject, Service } from 'typedi';
+// import { Knex } from 'knex';
+// import { IAccountCreateDTO } from '@/interfaces';
+// import { CreateAccount } from './CreateAccount.service';
+// import { Importable } from '../Import/Importable';
+// import { AccountsSampleData } from './AccountsImportable.SampleData';
+
+// @Service()
+// export class AccountsImportable extends Importable {
+//   @Inject()
+//   private createAccountService: CreateAccount;
+
+//   /**
+//    * Importing to account service.
+//    * @param {number} tenantId
+//    * @param {IAccountCreateDTO} createAccountDTO
+//    * @returns
+//    */
+//   public importable(
+//     tenantId: number,
+//     createAccountDTO: IAccountCreateDTO,
+//     trx?: Knex.Transaction
+//   ) {
+//     return this.createAccountService.createAccount(
+//       tenantId,
+//       createAccountDTO,
+//       trx
+//     );
+//   }
+
+//   /**
+//    * Concurrrency controlling of the importing process.
+//    * @returns {number}
+//    */
+//   public get concurrency() {
+//     return 1;
+//   }
+
+//   /**
+//    * Retrieves the sample data that used to download accounts sample sheet. 
+//    */
+//   public sampleData(): any[] {
+//     return AccountsSampleData;
+//   }
+// }

packages/server/src/modules/Accounts/ActivateAccount.service.ts

@@ -0,0 +1,60 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { Knex } from 'knex';
+import { IAccountEventActivatedPayload } from './Accounts.types';
+import { Account } from './models/Account.model';
+import { AccountRepository } from './repositories/Account.repository';
+import { UnitOfWork } from '../Tenancy/TenancyDB/UnitOfWork.service';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { events } from '@/common/events/events';
+import { TenantModelProxy } from '../System/models/TenantBaseModel';
+
+@Injectable()
+export class ActivateAccount {
+  /**
+   * @param {EventEmitter2} eventEmitter - The event emitter.
+   * @param {UnitOfWork} uow - The unit of work.
+   * @param {AccountRepository} accountRepository - The account repository.
+   * @param {TenantModelProxy<typeof Account>} accountModel - The account model.
+   */
+  constructor(
+    private readonly eventEmitter: EventEmitter2,
+    private readonly uow: UnitOfWork,
+    private readonly accountRepository: AccountRepository,
+
+    @Inject(Account.name)
+    private readonly accountModel: TenantModelProxy<typeof Account>,
+  ) {}
+
+  /**
+   * Activates/Inactivates the given account.
+   * @param {number} accountId - The account id.
+   * @param {boolean} activate - Activate or inactivate the account.
+   */
+  public activateAccount = async (accountId: number, activate?: boolean) => {
+    // Retrieve the given account or throw not found error.
+    const oldAccount = await this.accountModel()
+      .query()
+      .findById(accountId)
+      .throwIfNotFound();
+
+    // Get all children accounts.
+    const accountsGraph = await this.accountRepository.getDependencyGraph();
+    const dependenciesAccounts = accountsGraph.dependenciesOf(accountId);
+
+    const patchAccountsIds = [...dependenciesAccounts, accountId];
+
+    // Activate account and associated transactions under unit-of-work environment.
+    return this.uow.withTransaction(async (trx: Knex.Transaction) => {
+      // Activate and inactivate the given accounts ids.
+      activate
+        ? await this.accountRepository.activateByIds(patchAccountsIds, trx)
+        : await this.accountRepository.inactivateByIds(patchAccountsIds, trx);
+
+      // Triggers `onAccountActivated` event.
+      this.eventEmitter.emitAsync(events.accounts.onActivated, {
+        accountId,
+        trx,
+      } as IAccountEventActivatedPayload);
+    });
+  };
+}

packages/server/src/modules/Accounts/CommandAccountValidators.service.ts

@@ -0,0 +1,224 @@
+// @ts-nocheck
+import { Inject, Injectable, Scope } from '@nestjs/common';
+// import { IAccountDTO, IAccount, IAccountCreateDTO } from './Accounts.types';
+// import AccountTypesUtils from '@/lib/AccountTypes';
+import { ServiceError } from '../Items/ServiceError';
+import { ERRORS, MAX_ACCOUNTS_CHART_DEPTH } from './constants';
+import { Account } from './models/Account.model';
+import { AccountRepository } from './repositories/Account.repository';
+import { AccountTypesUtils } from './utils/AccountType.utils';
+import { CreateAccountDTO } from './CreateAccount.dto';
+import { EditAccountDTO } from './EditAccount.dto';
+import { TenantModelProxy } from '../System/models/TenantBaseModel';
+
+@Injectable({ scope: Scope.REQUEST })
+export class CommandAccountValidators {
+  constructor(
+    @Inject(Account.name)
+    private readonly accountModel: TenantModelProxy<typeof Account>,
+    private readonly accountRepository: AccountRepository,
+  ) {}
+
+  /**
+   * Throws error if the account was prefined.
+   * @param {Account} account
+   */
+  public throwErrorIfAccountPredefined(account: Account) {
+    if (account.predefined) {
+      throw new ServiceError(ERRORS.ACCOUNT_PREDEFINED);
+    }
+  }
+
+  /**
+   * Diff account type between new and old account, throw service error
+   * if they have different account type.
+   * @param {Account|CreateAccountDTO|EditAccountDTO} oldAccount
+   * @param {Account|CreateAccountDTO|EditAccountDTO} newAccount
+   */
+  public async isAccountTypeChangedOrThrowError(
+    oldAccount: Account | CreateAccountDTO | EditAccountDTO,
+    newAccount: Account | CreateAccountDTO | EditAccountDTO,
+  ) {
+    if (oldAccount.accountType !== newAccount.accountType) {
+      throw new ServiceError(ERRORS.ACCOUNT_TYPE_NOT_ALLOWED_TO_CHANGE);
+    }
+  }
+
+  /**
+   * Retrieve account type or throws service error.
+   * @param {string} accountTypeKey -
+   * @return {IAccountType}
+   */
+  public getAccountTypeOrThrowError(accountTypeKey: string) {
+    const accountType = AccountTypesUtils.getType(accountTypeKey);
+
+    if (!accountType) {
+      throw new ServiceError(ERRORS.ACCOUNT_TYPE_NOT_FOUND);
+    }
+    return accountType;
+  }
+
+  /**
+   * Retrieve parent account or throw service error.
+   * @param {number} accountId - Account id.
+   * @param {number} notAccountId - Ignore the account id.
+   */
+  public async getParentAccountOrThrowError(
+    accountId: number,
+    notAccountId?: number,
+  ) {
+    const parentAccount = await this.accountModel()
+      .query()
+      .findById(accountId)
+      .onBuild((query) => {
+        if (notAccountId) {
+          query.whereNot('id', notAccountId);
+        }
+      });
+    if (!parentAccount) {
+      throw new ServiceError(ERRORS.PARENT_ACCOUNT_NOT_FOUND);
+    }
+    return parentAccount;
+  }
+
+  /**
+   * Throws error if the account type was not unique on the storage.
+   * @param {string} accountCode - Account code.
+   * @param {number} notAccountId - Ignore the account id.
+   */
+  public async isAccountCodeUniqueOrThrowError(
+    accountCode: string,
+    notAccountId?: number,
+  ) {
+    const account = await this.accountModel()
+      .query()
+      .where('code', accountCode)
+      .onBuild((query) => {
+        if (notAccountId) {
+          query.whereNot('id', notAccountId);
+        }
+      });
+    if (account.length > 0) {
+      throw new ServiceError(
+        ERRORS.ACCOUNT_CODE_NOT_UNIQUE,
+        'Account code is not unique.',
+      );
+    }
+  }
+
+  /**
+   * Validates the account name uniquiness.
+   * @param {string} accountName - Account name.
+   * @param {number} notAccountId - Ignore the account id.
+   */
+  public async validateAccountNameUniquiness(
+    accountName: string,
+    notAccountId?: number,
+  ) {
+    const foundAccount = await this.accountModel
+      .query()
+      .findOne('name', accountName)
+      .onBuild((query) => {
+        if (notAccountId) {
+          query.whereNot('id', notAccountId);
+        }
+      });
+    if (foundAccount) {
+      throw new ServiceError(
+        ERRORS.ACCOUNT_NAME_NOT_UNIQUE,
+        'Account name is not unique.',
+      );
+    }
+  }
+
+  /**
+   * Validates the given account type supports multi-currency.
+   * @param {CreateAccountDTO | EditAccountDTO} accountDTO -
+   */
+  public validateAccountTypeSupportCurrency = (
+    accountDTO: CreateAccountDTO | EditAccountDTO,
+    baseCurrency: string,
+  ) => {
+    // Can't continue to validate the type has multi-currency feature
+    // if the given currency equals the base currency or not assigned.
+    if (accountDTO.currencyCode === baseCurrency || !accountDTO.currencyCode) {
+      return;
+    }
+    const meta = AccountTypesUtils.getType(accountDTO.accountType);
+
+    // Throw error if the account type does not support multi-currency.
+    if (!meta?.multiCurrency) {
+      throw new ServiceError(ERRORS.ACCOUNT_TYPE_NOT_SUPPORTS_MULTI_CURRENCY);
+    }
+  };
+
+  /**
+   * Validates the account DTO currency code whether equals the currency code of
+   * parent account.
+   * @param {CreateAccountDTO | EditAccountDTO} accountDTO
+   * @param {Account} parentAccount
+   * @param {string} baseCurrency -
+   * @throws {ServiceError(ERRORS.ACCOUNT_CURRENCY_NOT_SAME_PARENT_ACCOUNT)}
+   */
+  public validateCurrentSameParentAccount = (
+    accountDTO: CreateAccountDTO | EditAccountDTO,
+    parentAccount: Account,
+    baseCurrency: string,
+  ) => {
+    // If the account DTO currency not assigned and the parent account has no base currency.
+    if (
+      !accountDTO.currencyCode &&
+      parentAccount.currencyCode !== baseCurrency
+    ) {
+      throw new ServiceError(ERRORS.ACCOUNT_CURRENCY_NOT_SAME_PARENT_ACCOUNT);
+    }
+    // If the account DTO is assigned and not equals the currency code of parent account.
+    if (
+      accountDTO.currencyCode &&
+      parentAccount.currencyCode !== accountDTO.currencyCode
+    ) {
+      throw new ServiceError(ERRORS.ACCOUNT_CURRENCY_NOT_SAME_PARENT_ACCOUNT);
+    }
+  };
+
+  /**
+   * Throws service error if parent account has different type.
+   * @param {IAccountDTO} accountDTO
+   * @param {IAccount} parentAccount
+   */
+  public throwErrorIfParentHasDiffType(
+    accountDTO: CreateAccountDTO | EditAccountDTO,
+    parentAccount: Account,
+  ) {
+    if (accountDTO.accountType !== parentAccount.accountType) {
+      throw new ServiceError(ERRORS.PARENT_ACCOUNT_HAS_DIFFERENT_TYPE);
+    }
+  }
+
+  /**
+   * Retrieve account of throw service error in case account not found.
+   * @param {number} accountId
+   * @return {IAccount}
+   */
+  public async getAccountOrThrowError(accountId: number) {
+    const account = await this.accountRepository.findOneById(accountId);
+
+    if (!account) {
+      throw new ServiceError(ERRORS.ACCOUNT_NOT_FOUND);
+    }
+    return account;
+  }
+
+  /**
+   * Validates the max depth level of accounts chart.
+   * @param {number} parentAccountId - Parent account id.
+   */
+  public async validateMaxParentAccountDepthLevels(parentAccountId: number) {
+    const accountsGraph = await this.accountRepository.getDependencyGraph();
+    const parentDependantsIds = accountsGraph.dependantsOf(parentAccountId);
+
+    if (parentDependantsIds.length >= MAX_ACCOUNTS_CHART_DEPTH) {
+      throw new ServiceError(ERRORS.PARENT_ACCOUNT_EXCEEDED_THE_DEPTH_LEVEL);
+    }
+  }
+}

packages/server/src/modules/Accounts/CreateAccount.dto.ts

@@ -0,0 +1,103 @@
+import { ApiProperty } from '@nestjs/swagger';
+import {
+  IsString,
+  IsOptional,
+  IsInt,
+  MinLength,
+  MaxLength,
+  IsBoolean,
+} from 'class-validator';
+
+export class CreateAccountDTO {
+  @IsString()
+  @MinLength(3)
+  @MaxLength(255) // Assuming DATATYPES_LENGTH.STRING is 255
+  @ApiProperty({
+    description: 'Account name',
+    example: 'Cash Account',
+    minLength: 3,
+    maxLength: 255,
+  })
+  name: string;
+
+  @IsOptional()
+  @IsString()
+  @MinLength(3)
+  @MaxLength(6)
+  @ApiProperty({
+    description: 'Account code',
+    example: 'CA001',
+    required: false,
+    minLength: 3,
+    maxLength: 6,
+  })
+  code?: string;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty({
+    description: 'Currency code for the account',
+    example: 'USD',
+    required: false,
+  })
+  currencyCode?: string;
+
+  @IsString()
+  @MinLength(3)
+  @MaxLength(255)
+  @ApiProperty({
+    description: 'Type of account',
+    example: 'asset',
+    minLength: 3,
+    maxLength: 255,
+  })
+  accountType: string;
+
+  @IsOptional()
+  @IsString()
+  @MaxLength(65535)
+  @ApiProperty({
+    description: 'Account description',
+    example: 'Main cash account for daily operations',
+    required: false,
+    maxLength: 65535,
+  })
+  description?: string;
+
+  @IsOptional()
+  @IsInt()
+  @ApiProperty({
+    description: 'ID of the parent account',
+    example: 1,
+    required: false,
+  })
+  parentAccountId?: number;
+
+  @IsOptional()
+  @IsBoolean()
+  @ApiProperty({
+    description: 'Whether the account is active',
+    example: true,
+    required: false,
+    default: true,
+  })
+  active?: boolean;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty({
+    description: 'Plaid account ID for syncing',
+    example: 'plaid_account_123456',
+    required: false,
+  })
+  plaidAccountId?: string;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty({
+    description: 'Plaid item ID for syncing',
+    example: 'plaid_item_123456',
+    required: false,
+  })
+  plaidItemId?: string;
+}

packages/server/src/modules/Accounts/CreateAccount.service.ts

@@ -0,0 +1,147 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { kebabCase } from 'lodash';
+import { Knex } from 'knex';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import {
+  IAccountEventCreatingPayload,
+  CreateAccountParams,
+  IAccountEventCreatedPayload,
+} from './Accounts.types';
+import { CommandAccountValidators } from './CommandAccountValidators.service';
+import { Account } from './models/Account.model';
+import { UnitOfWork } from '../Tenancy/TenancyDB/UnitOfWork.service';
+import { TenancyContext } from '../Tenancy/TenancyContext.service';
+import { events } from '@/common/events/events';
+import { CreateAccountDTO } from './CreateAccount.dto';
+import { PartialModelObject } from 'objection';
+import { TenantModelProxy } from '../System/models/TenantBaseModel';
+
+@Injectable()
+export class CreateAccountService {
+  /**
+   * @param {TenantModelProxy<typeof Account>} accountModel - The account model proxy.
+   * @param {EventEmitter2} eventEmitter - The event emitter.
+   * @param {UnitOfWork} uow - The unit of work.
+   * @param {CommandAccountValidators} validator - The command account validators.
+   * @param {TenancyContext} tenancyContext - The tenancy context.
+   */
+  constructor(
+    @Inject(Account.name)
+    private readonly accountModel: TenantModelProxy<typeof Account>,
+    private readonly eventEmitter: EventEmitter2,
+    private readonly uow: UnitOfWork,
+    private readonly validator: CommandAccountValidators,
+    private readonly tenancyContext: TenancyContext,
+  ) {}
+
+  /**
+   * Authorize the account creation.
+   * @param {CreateAccountDTO} accountDTO
+   */
+  private authorize = async (
+    accountDTO: CreateAccountDTO,
+    baseCurrency: string,
+    params?: CreateAccountParams,
+  ) => {
+    // Validate account name uniquiness.
+    if (!params.ignoreUniqueName) {
+      await this.validator.validateAccountNameUniquiness(accountDTO.name);
+    }
+    // Validate the account code uniquiness.
+    if (accountDTO.code) {
+      await this.validator.isAccountCodeUniqueOrThrowError(accountDTO.code);
+    }
+    // Retrieve the account type meta or throw service error if not found.
+    this.validator.getAccountTypeOrThrowError(accountDTO.accountType);
+
+    // Ingore the parent account validation if not presented.
+    if (accountDTO.parentAccountId) {
+      const parentAccount = await this.validator.getParentAccountOrThrowError(
+        accountDTO.parentAccountId,
+      );
+      this.validator.throwErrorIfParentHasDiffType(accountDTO, parentAccount);
+
+      // Inherit active status from parent account.
+      accountDTO.active = parentAccount.active;
+
+      // Validate should currency code be the same currency of parent account.
+      this.validator.validateCurrentSameParentAccount(
+        accountDTO,
+        parentAccount,
+        baseCurrency,
+      );
+      // Validates the max depth level of accounts chart.
+      await this.validator.validateMaxParentAccountDepthLevels(
+        accountDTO.parentAccountId,
+      );
+    }
+    // Validates the given account type supports the multi-currency.
+    this.validator.validateAccountTypeSupportCurrency(accountDTO, baseCurrency);
+  };
+
+  /**
+   * Transformes the create account DTO to input model.
+   * @param {IAccountCreateDTO} createAccountDTO
+   */
+  private transformDTOToModel = (
+    createAccountDTO: CreateAccountDTO,
+    baseCurrency: string,
+  ): PartialModelObject<Account> => {
+    return {
+      ...createAccountDTO,
+      slug: kebabCase(createAccountDTO.name),
+      currencyCode: createAccountDTO.currencyCode || baseCurrency,
+
+      // Mark the account is Plaid owner since Plaid item/account is defined on creating.
+      isSyncingOwner: Boolean(
+        createAccountDTO.plaidAccountId || createAccountDTO.plaidItemId,
+      ),
+    };
+  };
+
+  /**
+   * Creates a new account on the storage.
+   * @param {IAccountCreateDTO} accountDTO
+   * @returns {Promise<IAccount>}
+   */
+  public createAccount = async (
+    accountDTO: CreateAccountDTO,
+    trx?: Knex.Transaction,
+    params: CreateAccountParams = { ignoreUniqueName: false },
+  ): Promise<Account> => {
+    // Retrieves the given tenant metadata.
+    const tenant = await this.tenancyContext.getTenant(true);
+
+    // Authorize the account creation.
+    await this.authorize(accountDTO, tenant.metadata.baseCurrency, params);
+
+    // Transformes the DTO to model.
+    const accountInputModel = this.transformDTOToModel(
+      accountDTO,
+      tenant.metadata.baseCurrency,
+    );
+    // Creates a new account with associated transactions under unit-of-work envirement.
+    return this.uow.withTransaction(async (trx: Knex.Transaction) => {
+      // Triggers `onAccountCreating` event.
+      await this.eventEmitter.emitAsync(events.accounts.onCreating, {
+        accountDTO,
+        trx,
+      } as IAccountEventCreatingPayload);
+
+      // Inserts account to the storage.
+      const account = await this.accountModel()
+        .query()
+        .insert({
+          ...accountInputModel,
+        });
+      // Triggers `onAccountCreated` event.
+      await this.eventEmitter.emitAsync(events.accounts.onCreated, {
+        account,
+        accountId: account.id,
+        trx,
+      } as IAccountEventCreatedPayload);
+
+      return account;
+    }, trx);
+  };
+}

packages/server/src/modules/Accounts/DeleteAccount.service.ts

@@ -0,0 +1,83 @@
+import { Knex } from 'knex';
+import { Inject, Injectable } from '@nestjs/common';
+// import { IAccountEventDeletedPayload } from '@/interfaces';
+import { CommandAccountValidators } from './CommandAccountValidators.service';
+import { Account } from './models/Account.model';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { UnitOfWork } from '../Tenancy/TenancyDB/UnitOfWork.service';
+import { events } from '@/common/events/events';
+import { IAccountEventDeletedPayload } from './Accounts.types';
+import { TenantModelProxy } from '../System/models/TenantBaseModel';
+
+@Injectable()
+export class DeleteAccount {
+  constructor(
+    @Inject(Account.name)
+    private accountModel: TenantModelProxy<typeof Account>,
+
+    private eventEmitter: EventEmitter2,
+    private uow: UnitOfWork,
+    private validator: CommandAccountValidators,
+  ) {}
+
+  /**
+   * Authorize account delete.
+   * @param {number} accountId - Account id.
+   */
+  private authorize = async (accountId: number, oldAccount: Account) => {
+    // Throw error if the account was predefined.
+    this.validator.throwErrorIfAccountPredefined(oldAccount);
+  };
+
+  /**
+   * Unlink the given parent account with children accounts.
+   * @param {number|number[]} parentAccountId -
+   */
+  private async unassociateChildrenAccountsFromParent(
+    parentAccountId: number | number[],
+    trx?: Knex.Transaction,
+  ) {
+    const accountsIds = Array.isArray(parentAccountId)
+      ? parentAccountId
+      : [parentAccountId];
+
+    await this.accountModel()
+      .query(trx)
+      .whereIn('parent_account_id', accountsIds)
+      .patch({ parentAccountId: null });
+  }
+
+  /**
+   * Deletes the account from the storage.
+   * @param {number} accountId
+   */
+  public deleteAccount = async (accountId: number): Promise<void> => {
+    // Retrieve account or not found service error.
+    const oldAccount = await this.accountModel().query().findById(accountId);
+
+    // Authorize before delete account.
+    await this.authorize(accountId, oldAccount);
+
+    // Deletes the account and associated transactions under UOW environment.
+    return this.uow.withTransaction(async (trx: Knex.Transaction) => {
+      // Triggers `onAccountDelete` event.
+      await this.eventEmitter.emitAsync(events.accounts.onDelete, {
+        trx,
+        oldAccount,
+      } as IAccountEventDeletedPayload);
+
+      // Unlink the parent account from children accounts.
+      await this.unassociateChildrenAccountsFromParent(accountId, trx);
+
+      // Deletes account by the given id.
+      await this.accountModel().query(trx).deleteById(accountId);
+
+      // Triggers `onAccountDeleted` event.
+      await this.eventEmitter.emitAsync(events.accounts.onDeleted, {
+        accountId,
+        oldAccount,
+        trx,
+      } as IAccountEventDeletedPayload);
+    });
+  };
+}

packages/server/src/modules/Accounts/EditAccount.dto.ts

@@ -0,0 +1,54 @@
+import { ApiProperty } from '@nestjs/swagger';
+import {
+  IsString,
+  IsOptional,
+  IsInt,
+  MinLength,
+  MaxLength,
+} from 'class-validator';
+
+export class EditAccountDTO {
+  @IsString()
+  @MinLength(3)
+  @MaxLength(255)
+  @ApiProperty({
+    description: 'The name of the account',
+    example: 'Bank Account',
+  })
+  name: string;
+
+  @IsOptional()
+  @IsString()
+  @MinLength(3)
+  @MaxLength(6)
+  @ApiProperty({
+    description: 'The code of the account',
+    example: '123456',
+  })
+  code?: string;
+
+  @IsString()
+  @MinLength(3)
+  @MaxLength(255)
+  @ApiProperty({
+    description: 'The type of the account',
+    example: 'Bank Account',
+  })
+  accountType: string;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty({
+    description: 'The description of the account',
+    example: 'This is a description',
+  })
+  description?: string;
+
+  @IsOptional()
+  @IsInt()
+  @ApiProperty({
+    description: 'The parent account ID of the account',
+    example: 1,
+  })
+  parentAccountId?: number;
+}

packages/server/src/modules/Accounts/EditAccount.service.ts

@@ -0,0 +1,101 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { Knex } from 'knex';
+import { CommandAccountValidators } from './CommandAccountValidators.service';
+import { Account } from './models/Account.model';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { UnitOfWork } from '../Tenancy/TenancyDB/UnitOfWork.service';
+import { events } from '@/common/events/events';
+import { EditAccountDTO } from './EditAccount.dto';
+import { TenantModelProxy } from '../System/models/TenantBaseModel';
+
+@Injectable()
+export class EditAccount {
+  constructor(
+    private readonly eventEmitter: EventEmitter2,
+    private readonly uow: UnitOfWork,
+    private readonly validator: CommandAccountValidators,
+
+    @Inject(Account.name)
+    private readonly accountModel: TenantModelProxy<typeof Account>,
+  ) {}
+
+  /**
+   * Authorize the account editing.
+   * @param {number} accountId
+   * @param {IAccountEditDTO} accountDTO
+   * @param {IAccount} oldAccount -
+   */
+  private authorize = async (
+    accountId: number,
+    accountDTO: EditAccountDTO,
+    oldAccount: Account,
+  ) => {
+    // Validate account name uniquiness.
+    await this.validator.validateAccountNameUniquiness(
+      accountDTO.name,
+      accountId,
+    );
+    // Validate the account type should be not mutated.
+    await this.validator.isAccountTypeChangedOrThrowError(
+      oldAccount,
+      accountDTO,
+    );
+    // Validate the account code not exists on the storage.
+    if (accountDTO.code && accountDTO.code !== oldAccount.code) {
+      await this.validator.isAccountCodeUniqueOrThrowError(
+        accountDTO.code,
+        oldAccount.id,
+      );
+    }
+    // Retrieve the parent account of throw not found service error.
+    if (accountDTO.parentAccountId) {
+      const parentAccount = await this.validator.getParentAccountOrThrowError(
+        accountDTO.parentAccountId,
+        oldAccount.id,
+      );
+      this.validator.throwErrorIfParentHasDiffType(accountDTO, parentAccount);
+    }
+  };
+
+  /**
+   * Edits details of the given account.
+   * @param {number} accountId
+   * @param {IAccountDTO} accountDTO
+   */
+  public async editAccount(
+    accountId: number,
+    accountDTO: EditAccountDTO,
+  ): Promise<Account> {
+    // Retrieve the old account or throw not found service error.
+    const oldAccount = await this.accountModel()
+      .query()
+      .findById(accountId)
+      .throwIfNotFound();
+
+    // Authorize the account editing.
+    await this.authorize(accountId, accountDTO, oldAccount);
+
+    // Edits account and associated transactions under unit-of-work environment.
+    return this.uow.withTransaction(async (trx: Knex.Transaction) => {
+      // Triggers `onAccountEditing` event.
+      await this.eventEmitter.emitAsync(events.accounts.onEditing, {
+        oldAccount,
+        accountDTO,
+      });
+      // Update the account on the storage.
+      const account = await this.accountModel()
+        .query(trx)
+        .findById(accountId)
+        .updateAndFetch({ ...accountDTO });
+
+      // Triggers `onAccountEdited` event.
+      // await this.eventEmitter.emitAsync(events.accounts.onEdited, {
+      //   account,
+      //   oldAccount,
+      //   trx,
+      // } as IAccountEventEditedPayload);
+
+      return account;
+    });
+  }
+}

packages/server/src/modules/Accounts/GetAccount.service.ts

@@ -0,0 +1,47 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { AccountTransformer } from './Account.transformer';
+import { Account } from './models/Account.model';
+import { AccountRepository } from './repositories/Account.repository';
+import { TransformerInjectable } from '../Transformer/TransformerInjectable.service';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { events } from '@/common/events/events';
+import { TenantModelProxy } from '../System/models/TenantBaseModel';
+
+@Injectable()
+export class GetAccount {
+  constructor(
+    @Inject(Account.name)
+    private readonly accountModel: TenantModelProxy<typeof Account>,
+    private readonly accountRepository: AccountRepository,
+    private readonly transformer: TransformerInjectable,
+    private readonly eventEmitter: EventEmitter2,
+  ) {}
+
+  /**
+   * Retrieve the given account details.
+   * @param {number} accountId
+   */
+  public getAccount = async (accountId: number) => {
+    // Find the given account or throw not found error.
+    const account = await this.accountModel()
+      .query()
+      .findById(accountId)
+      .withGraphFetched('plaidItem')
+      .throwIfNotFound();
+
+    const accountsGraph = await this.accountRepository.getDependencyGraph();
+
+    // Transforms the account model to POJO.
+    const transformed = await this.transformer.transform(
+      account,
+      new AccountTransformer(),
+      { accountsGraph },
+    );
+    const eventPayload = { accountId };
+
+    // Triggers `onAccountViewed` event.
+    await this.eventEmitter.emitAsync(events.accounts.onViewed, eventPayload);
+
+    return transformed;
+  };
+}

packages/server/src/modules/Accounts/GetAccountTransactions.service.ts

@@ -0,0 +1,55 @@
+import {
+  IAccountsTransactionsFilter,
+  IGetAccountTransactionPOJO,
+} from './Accounts.types';
+import { AccountTransactionTransformer } from './AccountTransaction.transformer';
+import { AccountTransaction } from './models/AccountTransaction.model';
+import { Account } from './models/Account.model';
+import { Inject, Injectable } from '@nestjs/common';
+import { TransformerInjectable } from '../Transformer/TransformerInjectable.service';
+import { TenantModelProxy } from '../System/models/TenantBaseModel';
+
+@Injectable()
+export class GetAccountTransactionsService {
+  constructor(
+    private readonly transformer: TransformerInjectable,
+
+    @Inject(AccountTransaction.name)
+    private readonly accountTransaction: TenantModelProxy<
+      typeof AccountTransaction
+    >,
+
+    @Inject(Account.name)
+    private readonly account: TenantModelProxy<typeof Account>,
+  ) {}
+
+  /**
+   * Retrieve the accounts transactions.
+   * @param {IAccountsTransactionsFilter} filter -
+   */
+  public getAccountsTransactions = async (
+    filter: IAccountsTransactionsFilter,
+  ): Promise<IGetAccountTransactionPOJO[]> => {
+    // Retrieve the given account or throw not found error.
+    if (filter.accountId) {
+      await this.account().query().findById(filter.accountId).throwIfNotFound();
+    }
+    const transactions = await this.accountTransaction()
+      .query()
+      .onBuild((query) => {
+        query.orderBy('date', 'DESC');
+
+        if (filter.accountId) {
+          query.where('account_id', filter.accountId);
+        }
+        query.withGraphFetched('account');
+        query.withGraphFetched('contact');
+        query.limit(filter.limit || 50);
+      });
+    // Transform the account transaction.
+    return this.transformer.transform(
+      transactions,
+      new AccountTransactionTransformer(),
+    );
+  };
+}

packages/server/src/modules/Accounts/GetAccountTypes.service.ts

@@ -0,0 +1,17 @@
+// import { IAccountType } from './Accounts.types';
+import { Injectable } from '@nestjs/common';
+import { AccountTypesUtils } from './utils/AccountType.utils';
+
+@Injectable()
+export class GetAccountTypesService {
+  /**
+   * Retrieve all accounts types.
+   * @param {number} tenantId - 
+   * @return {IAccountType}
+   */
+  public getAccountsTypes() {
+    const accountTypes = AccountTypesUtils.getList();
+
+    return accountTypes;
+  }
+}

packages/server/src/modules/Accounts/GetAccounts.service.ts

@@ -0,0 +1,69 @@
+import { Inject, Injectable } from '@nestjs/common';
+import * as R from 'ramda';
+import { IAccountsFilter } from './Accounts.types';
+import { DynamicListService } from '../DynamicListing/DynamicList.service';
+import { AccountTransformer } from './Account.transformer';
+import { TransformerInjectable } from '../Transformer/TransformerInjectable.service';
+import { Account } from './models/Account.model';
+import { AccountRepository } from './repositories/Account.repository';
+import { IFilterMeta } from '@/interfaces/Model';
+import { TenantModelProxy } from '../System/models/TenantBaseModel';
+
+@Injectable()
+export class GetAccountsService {
+  constructor(
+    private readonly dynamicListService: DynamicListService,
+    private readonly transformerService: TransformerInjectable,
+    private readonly accountRepository: AccountRepository,
+
+    @Inject(Account.name)
+    private readonly accountModel: TenantModelProxy<typeof Account>,
+  ) {}
+
+  /**
+   * Retrieve accounts datatable list.
+   * @param {IAccountsFilter} accountsFilter
+   * @returns {Promise<{ accounts: IAccountResponse[]; filterMeta: IFilterMeta }>}
+   */
+  public async getAccountsList(
+    filterDTO: IAccountsFilter,
+  ): Promise<{ accounts: Account[]; filterMeta: IFilterMeta }> {
+    // Parses the stringified filter roles.
+    const filter = this.parseListFilterDTO(filterDTO);
+
+    // Dynamic list service.
+    const dynamicList = await this.dynamicListService.dynamicList(
+      this.accountModel(),
+      filter,
+    );
+    // Retrieve accounts model based on the given query.
+    const accounts = await this.accountModel()
+      .query()
+      .onBuild((builder) => {
+        dynamicList.buildQuery()(builder);
+        builder.modify('inactiveMode', filter.inactiveMode);
+      });
+    const accountsGraph = await this.accountRepository.getDependencyGraph();
+
+    // Retrieves the transformed accounts collection.
+    const transformedAccounts = await this.transformerService.transform(
+      accounts,
+      new AccountTransformer(),
+      { accountsGraph, structure: filterDTO.structure },
+    );
+
+    return {
+      accounts: transformedAccounts,
+      filterMeta: dynamicList.getResponseMeta(),
+    };
+  }
+
+  /**
+   * Parsees accounts list filter DTO.
+   * @param filterDTO
+   * @returns
+   */
+  private parseListFilterDTO(filterDTO) {
+    return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
+  }
+}

packages/server/src/modules/Accounts/MutateBaseCurrencyAccounts.ts

@@ -0,0 +1,22 @@
+// import { Inject, Service } from 'typedi';
+// import HasTenancyService from '@/services/Tenancy/TenancyService';
+
+// @Service()
+// export class MutateBaseCurrencyAccounts {
+//   @Inject()
+//   tenancy: HasTenancyService;
+
+//   /**
+//    * Mutates the all accounts or the organziation.
+//    * @param {number} tenantId
+//    * @param {string} currencyCode
+//    */
+//   public mutateAllAccountsCurrency = async (
+//     tenantId: number,
+//     currencyCode: string
+//   ) => {
+//     const { Account } = this.tenancy.models(tenantId);
+
+//     await Account.query().update({ currencyCode });
+//   };
+// }

packages/server/src/modules/Accounts/constants.ts

@@ -0,0 +1,103 @@
+export const ERRORS = {
+  ACCOUNT_NOT_FOUND: 'account_not_found',
+  ACCOUNT_TYPE_NOT_FOUND: 'account_type_not_found',
+  PARENT_ACCOUNT_NOT_FOUND: 'parent_account_not_found',
+  ACCOUNT_CODE_NOT_UNIQUE: 'account_code_not_unique',
+  ACCOUNT_NAME_NOT_UNIQUE: 'account_name_not_unqiue',
+  PARENT_ACCOUNT_HAS_DIFFERENT_TYPE: 'parent_has_different_type',
+  ACCOUNT_TYPE_NOT_ALLOWED_TO_CHANGE: 'account_type_not_allowed_to_changed',
+  ACCOUNT_PREDEFINED: 'account_predefined',
+  ACCOUNT_HAS_ASSOCIATED_TRANSACTIONS: 'account_has_associated_transactions',
+  PREDEFINED_ACCOUNTS: 'predefined_accounts',
+  ACCOUNTS_HAVE_TRANSACTIONS: 'accounts_have_transactions',
+  CLOSE_ACCOUNT_AND_TO_ACCOUNT_NOT_SAME_TYPE:
+    'close_account_and_to_account_not_same_type',
+  ACCOUNTS_NOT_FOUND: 'accounts_not_found',
+  ACCOUNT_TYPE_NOT_SUPPORTS_MULTI_CURRENCY:
+    'ACCOUNT_TYPE_NOT_SUPPORTS_MULTI_CURRENCY',
+  ACCOUNT_CURRENCY_NOT_SAME_PARENT_ACCOUNT:
+    'ACCOUNT_CURRENCY_NOT_SAME_PARENT_ACCOUNT',
+  PARENT_ACCOUNT_EXCEEDED_THE_DEPTH_LEVEL:
+    'PARENT_ACCOUNT_EXCEEDED_THE_DEPTH_LEVEL',
+};
+
+// Default views columns.
+export const DEFAULT_VIEW_COLUMNS = [
+  { key: 'name', label: 'Account name' },
+  { key: 'code', label: 'Account code' },
+  { key: 'account_type_label', label: 'Account type' },
+  { key: 'account_normal', label: 'Account normal' },
+  { key: 'amount', label: 'Balance' },
+  { key: 'currencyCode', label: 'Currency' },
+];
+
+export const MAX_ACCOUNTS_CHART_DEPTH = 5;
+
+// Accounts default views.
+export const DEFAULT_VIEWS = [
+  {
+    name: 'Assets',
+    slug: 'assets',
+    rolesLogicExpression: '1',
+    roles: [
+      { index: 1, fieldKey: 'root_type', comparator: 'equals', value: 'asset' },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Liabilities',
+    slug: 'liabilities',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        fieldKey: 'root_type',
+        index: 1,
+        comparator: 'equals',
+        value: 'liability',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Equity',
+    slug: 'equity',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        fieldKey: 'root_type',
+        index: 1,
+        comparator: 'equals',
+        value: 'equity',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Income',
+    slug: 'income',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        fieldKey: 'root_type',
+        index: 1,
+        comparator: 'equals',
+        value: 'income',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+  {
+    name: 'Expenses',
+    slug: 'expenses',
+    rolesLogicExpression: '1',
+    roles: [
+      {
+        fieldKey: 'root_type',
+        index: 1,
+        comparator: 'equals',
+        value: 'expense',
+      },
+    ],
+    columns: DEFAULT_VIEW_COLUMNS,
+  },
+];

packages/server/src/modules/Accounts/models/Account.model.ts

@@ -0,0 +1,458 @@
+/* eslint-disable global-require */
+// import { mixin, Model } from 'objection';
+import { castArray } from 'lodash';
+import DependencyGraph from '@/libs/dependency-graph';
+import {
+  ACCOUNT_TYPES,
+  getAccountsSupportsMultiCurrency,
+} from '@/constants/accounts';
+import { TenantModel } from '@/modules/System/models/TenantModel';
+// import { SearchableModel } from '@/modules/Search/SearchableMdel';
+// import { CustomViewBaseModel } from '@/modules/CustomViews/CustomViewBaseModel';
+// import { ModelSettings } from '@/modules/Settings/ModelSettings';
+import { AccountTypesUtils } from '@/libs/accounts-utils/AccountTypesUtils';
+import { Model } from 'objection';
+import { PlaidItem } from '@/modules/BankingPlaid/models/PlaidItem';
+import { TenantBaseModel } from '@/modules/System/models/TenantBaseModel';
+import { flatToNestedArray } from '@/utils/flat-to-nested-array';
+// import AccountSettings from './Account.Settings';
+// import { DEFAULT_VIEWS } from '@/modules/Accounts/constants';
+// import { buildFilterQuery, buildSortColumnQuery } from '@/lib/ViewRolesBuilder';
+// import { flatToNestedArray } from 'utils';
+
+
+export class Account extends TenantBaseModel {
+  public name!: string;
+  public slug!: string;
+  public code!: string;
+  public index!: number;
+  public accountType!: string;
+  public parentAccountId!: number | null;
+  public predefined!: boolean;
+  public currencyCode!: string;
+  public active!: boolean;
+  public bankBalance!: number;
+  public lastFeedsUpdatedAt!: string | Date | null;
+  public amount!: number;
+  public plaidItemId!: string;
+  public plaidAccountId!: string | null;
+  public isFeedsActive!: boolean;
+  public isSyncingOwner!: boolean;
+  public plaidItem!: PlaidItem;
+
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'accounts';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  static get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return [
+      'accountTypeLabel',
+      'accountParentType',
+      'accountRootType',
+      'accountNormal',
+      'accountNormalFormatted',
+      'isBalanceSheetAccount',
+      'isPLSheet',
+    ];
+  }
+
+  /**
+   * Account normal.
+   */
+  get accountNormal(): string {
+    return AccountTypesUtils.getType(this.accountType, 'normal');
+  }
+
+  get accountNormalFormatted(): string {
+    const paris = {
+      credit: 'Credit',
+      debit: 'Debit',
+    };
+    return paris[this.accountNormal] || '';
+  }
+
+  /**
+   * Retrieve account type label.
+   */
+  get accountTypeLabel(): string {
+    return AccountTypesUtils.getType(this.accountType, 'label');
+  }
+
+  /**
+   * Retrieve account parent type.
+   */
+  get accountParentType(): string {
+    return AccountTypesUtils.getType(this.accountType, 'parentType');
+  }
+
+  /**
+   * Retrieve account root type.
+   */
+  get accountRootType(): string {
+    return AccountTypesUtils.getType(this.accountType, 'rootType');
+  }
+
+  /**
+   * Retrieve whether the account is balance sheet account.
+   */
+  get isBalanceSheetAccount(): boolean {
+    return this.isBalanceSheet();
+  }
+
+  /**
+   * Retrieve whether the account is profit/loss sheet account.
+   */
+  get isPLSheet(): boolean {
+    return this.isProfitLossSheet();
+  }
+  /**
+   * Allows to mark model as resourceable to viewable and filterable.
+   */
+  static get resourceable() {
+    return true;
+  }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    const TABLE_NAME = Account.tableName;
+
+    return {
+      /**
+       * Inactive/Active mode.
+       */
+      inactiveMode(query, active = false) {
+        query.where('accounts.active', !active);
+      },
+
+      filterAccounts(query, accountIds) {
+        if (accountIds.length > 0) {
+          query.whereIn(`${TABLE_NAME}.id`, accountIds);
+        }
+      },
+      filterAccountTypes(query, typesIds) {
+        if (typesIds.length > 0) {
+          query.whereIn('account_types.account_type_id', typesIds);
+        }
+      },
+      viewRolesBuilder(query, conditionals, expression) {
+        // buildFilterQuery(Account.tableName, conditionals, expression)(query);
+      },
+      sortColumnBuilder(query, columnKey, direction) {
+        // buildSortColumnQuery(Account.tableName, columnKey, direction)(query);
+      },
+
+      /**
+       * Filter by root type.
+       */
+      filterByRootType(query, rootType) {
+        const filterTypes = ACCOUNT_TYPES.filter(
+          (accountType) => accountType.rootType === rootType,
+        ).map((accountType) => accountType.key);
+
+        query.whereIn('account_type', filterTypes);
+      },
+
+      /**
+       * Filter by account normal
+       */
+      filterByAccountNormal(query, accountNormal) {
+        const filterTypes = ACCOUNT_TYPES.filter(
+          (accountType) => accountType.normal === accountNormal,
+        ).map((accountType) => accountType.key);
+
+        query.whereIn('account_type', filterTypes);
+      },
+
+      /**
+       * Finds account by the given slug.
+       * @param {*} query
+       * @param {*} slug
+       */
+      findBySlug(query, slug) {
+        query.where('slug', slug).first();
+      },
+
+      /**
+       *
+       * @param {*} query
+       * @param {*} baseCyrrency
+       */
+      preventMutateBaseCurrency(query) {
+        const accountsTypes = getAccountsSupportsMultiCurrency();
+        const accountsTypesKeys = accountsTypes.map((type) => type.key);
+
+        query
+          .whereIn('accountType', accountsTypesKeys)
+          .where('seededAt', null)
+          .first();
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const { AccountTransaction } = require('./AccountTransaction.model');
+    const { Item } = require('../../Items/models/Item');
+    // const InventoryAdjustment = require('models/InventoryAdjustment');
+    // const ManualJournalEntry = require('models/ManualJournalEntry');
+    // const Expense = require('models/Expense');
+    // const ExpenseEntry = require('models/ExpenseCategory');
+    // const ItemEntry = require('models/ItemEntry');
+    // const UncategorizedTransaction = require('models/UncategorizedCashflowTransaction');
+    const { PlaidItem } = require('../../BankingPlaid/models/PlaidItem');
+
+    return {
+      /**
+       * Account model may has many transactions.
+       */
+      transactions: {
+        relation: Model.HasManyRelation,
+        modelClass: AccountTransaction,
+        join: {
+          from: 'accounts.id',
+          to: 'accounts_transactions.accountId',
+        },
+      },
+     
+      /**
+       * Account may has many items as cost account.
+       */
+      itemsCostAccount: {
+        relation: Model.HasManyRelation,
+        modelClass: Item,
+        join: {
+          from: 'accounts.id',
+          to: 'items.costAccountId',
+        },
+      },
+      /**
+       * Account may has many items as sell account.
+       */
+      itemsSellAccount: {
+        relation: Model.HasManyRelation,
+        modelClass: Item,
+        join: {
+          from: 'accounts.id',
+          to: 'items.sellAccountId',
+        },
+      },
+      //   /**
+      //    *
+      //    */
+      //   inventoryAdjustments: {
+      //     relation: Model.HasManyRelation,
+      //     modelClass: InventoryAdjustment.default,
+      //     join: {
+      //       from: 'accounts.id',
+      //       to: 'inventory_adjustments.adjustmentAccountId',
+      //     },
+      //   },
+      //   /**
+      //    *
+      //    */
+      //   manualJournalEntries: {
+      //     relation: Model.HasManyRelation,
+      //     modelClass: ManualJournalEntry.default,
+      //     join: {
+      //       from: 'accounts.id',
+      //       to: 'manual_journals_entries.accountId',
+      //     },
+      //   },
+      //   /**
+      //    *
+      //    */
+      //   expensePayments: {
+      //     relation: Model.HasManyRelation,
+      //     modelClass: Expense.default,
+      //     join: {
+      //       from: 'accounts.id',
+      //       to: 'expenses_transactions.paymentAccountId',
+      //     },
+      //   },
+      //   /**
+      //    *
+      //    */
+      //   expenseEntries: {
+      //     relation: Model.HasManyRelation,
+      //     modelClass: ExpenseEntry.default,
+      //     join: {
+      //       from: 'accounts.id',
+      //       to: 'expense_transaction_categories.expenseAccountId',
+      //     },
+      //   },
+      //   /**
+      //    *
+      //    */
+      //   entriesCostAccount: {
+      //     relation: Model.HasManyRelation,
+      //     modelClass: ItemEntry.default,
+      //     join: {
+      //       from: 'accounts.id',
+      //       to: 'items_entries.costAccountId',
+      //     },
+      //   },
+      //   /**
+      //    *
+      //    */
+      //   entriesSellAccount: {
+      //     relation: Model.HasManyRelation,
+      //     modelClass: ItemEntry.default,
+      //     join: {
+      //       from: 'accounts.id',
+      //       to: 'items_entries.sellAccountId',
+      //     },
+      //   },
+      //   /**
+      //    * Associated uncategorized transactions.
+      //    */
+      //   uncategorizedTransactions: {
+      //     relation: Model.HasManyRelation,
+      //     modelClass: UncategorizedTransaction.default,
+      //     join: {
+      //       from: 'accounts.id',
+      //       to: 'uncategorized_cashflow_transactions.accountId',
+      //     },
+      //     filter: (query) => {
+      //       query.where('categorized', false);
+      //     },
+      //   },
+      /**
+       * Account model may belongs to a Plaid item.
+       */
+      plaidItem: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: PlaidItem,
+        join: {
+          from: 'accounts.plaidItemId',
+          to: 'plaid_items.plaidItemId',
+        },
+      },
+    };
+  }
+
+  /**
+   * Detarmines whether the given type equals the account type.
+   * @param {string} accountType
+   * @return {boolean}
+   */
+  isAccountType(accountType) {
+    const types = castArray(accountType);
+    return types.indexOf(this.accountType) !== -1;
+  }
+
+  /**
+   * Detarmines whether the given root type equals the account type.
+   * @param {string} rootType
+   * @return {boolean}
+   */
+  isRootType(rootType) {
+    return AccountTypesUtils.isRootTypeEqualsKey(this.accountType, rootType);
+  }
+
+  /**
+   * Detarmine whether the given parent type equals the account type.
+   * @param {string} parentType
+   * @return {boolean}
+   */
+  isParentType(parentType) {
+    return AccountTypesUtils.isParentTypeEqualsKey(
+      this.accountType,
+      parentType,
+    );
+  }
+
+  /**
+   * Detarmines whether the account is balance sheet account.
+   * @return {boolean}
+   */
+  isBalanceSheet() {
+    return AccountTypesUtils.isTypeBalanceSheet(this.accountType);
+  }
+
+  /**
+   * Detarmines whether the account is profit/loss account.
+   * @return {boolean}
+   */
+  isProfitLossSheet() {
+    return AccountTypesUtils.isTypePLSheet(this.accountType);
+  }
+
+  /**
+   * Detarmines whether the account is income statement account
+   * @return {boolean}
+   */
+  isIncomeSheet() {
+    return this.isProfitLossSheet();
+  }
+
+  /**
+   * Converts flatten accounts list to nested array.
+   * @param {Array} accounts
+   * @param {Object} options
+   */
+  static toNestedArray(accounts, options = { children: 'children' }) {
+    return flatToNestedArray(accounts, {
+      id: 'id',
+      parentId: 'parentAccountId',
+    });
+  }
+
+  /**
+   * Transformes the accounts list to depenedency graph structure.
+   * @param {IAccount[]} accounts
+   */
+  static toDependencyGraph(accounts) {
+    return DependencyGraph.fromArray(accounts, {
+      itemId: 'id',
+      parentItemId: 'parentAccountId',
+    });
+  }
+
+  /**
+   * Model settings.
+   */
+  // static get meta() {
+  // return AccountSettings;
+  // }
+
+  /**
+   * Retrieve the default custom views, roles and columns.
+   */
+  // static get defaultViews() {
+  //   return DEFAULT_VIEWS;
+  // }
+
+  /**
+   * Model search roles.
+   */
+  static get searchRoles() {
+    return [
+      { condition: 'or', fieldKey: 'name', comparator: 'contains' },
+      { condition: 'or', fieldKey: 'code', comparator: 'like' },
+    ];
+  }
+
+  /**
+   * Prevents mutate base currency since the model is not empty.
+   */
+  static get preventMutateBaseCurrency() {
+    return true;
+  }
+}

packages/server/src/modules/Accounts/models/AccountTransaction.model.ts

@@ -0,0 +1,268 @@
+import { Model, raw } from 'objection';
+import * as moment from 'moment';
+import { unitOfTime } from 'moment';
+import { isEmpty, castArray } from 'lodash';
+import { BaseModel } from '@/models/Model';
+import { Account } from './Account.model';
+// import { getTransactionTypeLabel } from '@/utils/transactions-types';
+
+export class AccountTransaction extends BaseModel {
+  public readonly referenceType: string;
+  public readonly referenceId: number;
+  public readonly accountId: number;
+  public readonly contactId: number;
+  public readonly contactType: string;
+  public readonly credit: number;
+  public readonly debit: number;
+  public readonly exchangeRate: number;
+  public readonly taxRate: number;
+  public readonly date: Date | string;
+  public readonly transactionType: string;
+  public readonly currencyCode: string;
+  public readonly referenceTypeFormatted: string;
+  public readonly transactionNumber!: string;
+  public readonly referenceNumber!: string;
+  public readonly note!: string;
+
+  public readonly index!: number;
+  public readonly indexGroup!: number;
+
+  public readonly taxRateId!: number;
+
+  public readonly branchId!: number;
+  public readonly userId!: number;
+  public readonly itemId!: number;
+  public readonly projectId!: number;
+  public readonly account: Account;
+
+  /**
+   * Table name
+   */
+  static get tableName() {
+    return 'accounts_transactions';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['createdAt'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return ['referenceTypeFormatted', 'creditLocal', 'debitLocal'];
+  }
+
+  /**
+   * Retrieves the credit amount in base currency.
+   * @return {number}
+   */
+  get creditLocal() {
+    return this.credit * this.exchangeRate;
+  }
+
+  /**
+   * Retrieves the debit amount in base currency.
+   * @return {number}
+   */
+  get debitLocal() {
+    return this.debit * this.exchangeRate;
+  }
+
+  // /**
+  //  * Retrieve formatted reference type.
+  //  * @return {string}
+  //  */
+  // get referenceTypeFormatted() {
+  //   return getTransactionTypeLabel(this.referenceType, this.transactionType);
+  // }
+
+  /**
+   * Model modifiers.
+   */
+  static get modifiers() {
+    return {
+      /**
+       * Filters accounts by the given ids.
+       * @param {Query} query
+       * @param {number[]} accountsIds
+       */
+      filterAccounts(query, accountsIds) {
+        if (Array.isArray(accountsIds) && accountsIds.length > 0) {
+          query.whereIn('account_id', accountsIds);
+        }
+      },
+
+      /**
+       * Filters the transaction types.
+       * @param {Query} query
+       * @param {string[]} types
+       */
+      filterTransactionTypes(query, types) {
+        if (Array.isArray(types) && types.length > 0) {
+          query.whereIn('reference_type', types);
+        } else if (typeof types === 'string') {
+          query.where('reference_type', types);
+        }
+      },
+
+      /**
+       * Filters the date range.
+       * @param {Query} query
+       * @param {moment.MomentInput} startDate
+       * @param {moment.MomentInput} endDate
+       * @param {unitOfTime.StartOf} type
+       */
+      filterDateRange(
+        query,
+        startDate: moment.MomentInput,
+        endDate: moment.MomentInput,
+        type: unitOfTime.StartOf = 'day',
+      ) {
+        const dateFormat = 'YYYY-MM-DD';
+        const fromDate = moment(startDate).startOf(type).format(dateFormat);
+        const toDate = moment(endDate).endOf(type).format(dateFormat);
+
+        if (startDate) {
+          query.where('date', '>=', fromDate);
+        }
+        if (endDate) {
+          query.where('date', '<=', toDate);
+        }
+      },
+
+      /**
+       * Filters the amount range.
+       * @param {Query} query
+       * @param {number} fromAmount
+       * @param {number} toAmount
+       */
+      filterAmountRange(query, fromAmount, toAmount) {
+        if (fromAmount) {
+          query.andWhere((q) => {
+            q.where('credit', '>=', fromAmount);
+            q.orWhere('debit', '>=', fromAmount);
+          });
+        }
+        if (toAmount) {
+          query.andWhere((q) => {
+            q.where('credit', '<=', toAmount);
+            q.orWhere('debit', '<=', toAmount);
+          });
+        }
+      },
+      sumationCreditDebit(query) {
+        query.select(['accountId']);
+
+        query.sum('credit as credit');
+        query.sum('debit as debit');
+        query.groupBy('account_id');
+      },
+      filterContactType(query, contactType) {
+        query.where('contact_type', contactType);
+      },
+      filterContactIds(query, contactIds) {
+        query.whereIn('contact_id', contactIds);
+      },
+      openingBalance(query, fromDate) {
+        query.modify('filterDateRange', null, fromDate);
+        query.modify('sumationCreditDebit');
+      },
+      closingBalance(query, toDate) {
+        query.modify('filterDateRange', null, toDate);
+        query.modify('sumationCreditDebit');
+      },
+      contactsOpeningBalance(
+        query,
+        openingDate,
+        receivableAccounts,
+        customersIds,
+      ) {
+        // Filter by date.
+        query.modify('filterDateRange', null, openingDate);
+
+        // Filter by customers.
+        query.whereNot('contactId', null);
+        query.whereIn('accountId', castArray(receivableAccounts));
+
+        if (!isEmpty(customersIds)) {
+          query.whereIn('contactId', castArray(customersIds));
+        }
+        // Group by the contact transactions.
+        query.groupBy('contactId');
+        query.sum('credit as credit');
+        query.sum('debit as debit');
+        query.select('contactId');
+      },
+      creditDebitSummation(query) {
+        query.sum('credit as credit');
+        query.sum('debit as debit');
+      },
+      groupByDateFormat(query, groupType = 'month') {
+        const groupBy = {
+          day: '%Y-%m-%d',
+          month: '%Y-%m',
+          year: '%Y',
+        };
+        const dateFormat = groupBy[groupType];
+
+        query.select(raw(`DATE_FORMAT(DATE, '${dateFormat}')`).as('date'));
+        query.groupByRaw(`DATE_FORMAT(DATE, '${dateFormat}')`);
+      },
+
+      filterByBranches(query, branchesIds) {
+        const formattedBranchesIds = castArray(branchesIds);
+
+        query.whereIn('branchId', formattedBranchesIds);
+      },
+
+      filterByProjects(query, projectsIds) {
+        const formattedProjectsIds = castArray(projectsIds);
+
+        query.whereIn('projectId', formattedProjectsIds);
+      },
+
+      filterByReference(query, referenceId: number, referenceType: string) {
+        query.where('reference_id', referenceId);
+        query.where('reference_type', referenceType);
+      },
+    };
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const { Account } = require('./Account.model');
+    const { Contact } = require('../../Contacts/models/Contact');
+
+    return {
+      account: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account,
+        join: {
+          from: 'accounts_transactions.accountId',
+          to: 'accounts.id',
+        },
+      },
+      contact: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Contact,
+        join: {
+          from: 'accounts_transactions.contactId',
+          to: 'contacts.id',
+        },
+      },
+    };
+  }
+
+  /**
+   * Prevents mutate base currency since the model is not empty.
+   */
+  static get preventMutateBaseCurrency() {
+    return true;
+  }
+}

packages/server/src/modules/Accounts/repositories/Account.repository.ts

@@ -0,0 +1,390 @@
+import { Knex } from 'knex';
+import { Inject, Injectable, Scope } from '@nestjs/common';
+import { TenantRepository } from '@/common/repository/TenantRepository';
+import { TENANCY_DB_CONNECTION } from '@/modules/Tenancy/TenancyDB/TenancyDB.constants';
+import { Account } from '../models/Account.model';
+import { I18nService } from 'nestjs-i18n';
+import { TenancyContext } from '@/modules/Tenancy/TenancyContext.service';
+import {
+  DiscountExpenseAccount,
+  OtherChargesAccount,
+  OtherExpensesAccount,
+  PrepardExpenses,
+  PurchaseDiscountAccount,
+  StripeClearingAccount,
+  TaxPayableAccount,
+  UnearnedRevenueAccount,
+} from '../Accounts.constants';
+
+@Injectable({ scope: Scope.REQUEST })
+export class AccountRepository extends TenantRepository {
+  constructor(
+    private readonly i18n: I18nService,
+    private readonly tenancyContext: TenancyContext,
+
+    @Inject(TENANCY_DB_CONNECTION)
+    private readonly tenantDBKnex: () => Knex,
+  ) {
+    super();
+  }
+
+  /**
+   * Gets the repository's model.
+   */
+  get model(): typeof Account {
+    return Account.bindKnex(this.tenantDBKnex());
+  }
+
+  /**
+   * Retrieve accounts dependency graph.
+   * @param {string} withRelation
+   * @param {Knex.Transaction} trx
+   * @returns {}
+   */
+  public async getDependencyGraph(
+    withRelation?: string,
+    trx?: Knex.Transaction,
+  ) {
+    const accounts = await this.all(withRelation, trx);
+
+    return this.model.toDependencyGraph(accounts);
+  }
+
+  /**
+   * Retrieve account by slug.
+   * @param {string} slug
+   * @return {Promise<IAccount>}
+   */
+  public findBySlug(slug: string) {
+    return this.findOne({ slug });
+  }
+
+  // /**
+  //  * Changes account balance.
+  //  * @param {number} accountId
+  //  * @param {number} amount
+  //  * @return {Promise<void>}
+  //  */
+  // async balanceChange(accountId: number, amount: number): Promise<void> {
+  //   const method: string = amount < 0 ? 'decrement' : 'increment';
+
+  //   await this.model.query().where('id', accountId)[method]('amount', amount);
+  //   this.flushCache();
+  // }
+
+  /**
+   * Activate user by the given id.
+   * @param  {number} userId - User id.
+   * @return {Promise<void>}
+   */
+  activateById(userId: number): Promise<number> {
+    return super.update({ active: 1 }, { id: userId });
+  }
+
+  /**
+   * Inactivate user by the given id.
+   * @param  {number} userId - User id.
+   * @return {Promise<void>}
+   */
+  inactivateById(userId: number): Promise<number> {
+    return super.update({ active: 0 }, { id: userId });
+  }
+
+  /**
+   * Activate user by the given id.
+   * @param  {number} userId - User id.
+   * @return {Promise<void>}
+   */
+  async activateByIds(userIds: number[], trx): Promise<number> {
+    const results = await this.model
+      .query(trx)
+      .whereIn('id', userIds)
+      .patch({ active: true });
+
+    return results;
+  }
+
+  /**
+   * Inactivate user by the given id.
+   * @param  {number} userId - User id.
+   * @return {Promise<void>}
+   */
+  async inactivateByIds(userIds: number[], trx): Promise<number> {
+    const results = await this.model
+      .query(trx)
+      .whereIn('id', userIds)
+      .patch({ active: false });
+
+    return results;
+  }
+
+  /**
+   *
+   * @param {string} currencyCode
+   * @param extraAttrs
+   * @param trx
+   * @returns
+   */
+  findOrCreateAccountReceivable = async (
+    currencyCode: string = '',
+    extraAttrs = {},
+    trx?: Knex.Transaction,
+  ) => {
+    let result = await this.model
+      .query(trx)
+      .onBuild((query) => {
+        if (currencyCode) {
+          query.where('currencyCode', currencyCode);
+        }
+        query.where('accountType', 'accounts-receivable');
+      })
+      .first();
+
+    if (!result) {
+      result = await this.model.query(trx).insertAndFetch({
+        name: this.i18n.t('account.accounts_receivable.currency', {
+          args: { currency: currencyCode },
+        }),
+        accountType: 'accounts-receivable',
+        currencyCode,
+        active: true,
+        ...extraAttrs,
+      });
+    }
+    return result;
+  };
+
+  /**
+   * Find or create tax payable account.
+   * @param {Record<string, string>}extraAttrs
+   * @param {Knex.Transaction} trx
+   * @returns
+   */
+  async findOrCreateTaxPayable(
+    extraAttrs: Record<string, string> = {},
+    trx?: Knex.Transaction,
+  ) {
+    let result = await this.model
+      .query(trx)
+      .findOne({ slug: TaxPayableAccount.slug, ...extraAttrs });
+
+    if (!result) {
+      result = await this.model.query(trx).insertAndFetch({
+        ...TaxPayableAccount,
+        ...extraAttrs,
+      });
+    }
+    return result;
+  }
+
+  findOrCreateAccountsPayable = async (
+    currencyCode: string = '',
+    extraAttrs = {},
+    trx?: Knex.Transaction,
+  ) => {
+    let result = await this.model
+      .query(trx)
+      .onBuild((query) => {
+        if (currencyCode) {
+          query.where('currencyCode', currencyCode);
+        }
+        query.where('accountType', 'accounts-payable');
+      })
+      .first();
+
+    if (!result) {
+      result = await this.model.query(trx).insertAndFetch({
+        name: this.i18n.t('account.accounts_payable.currency', {
+          args: { currency: currencyCode },
+        }),
+        accountType: 'accounts-payable',
+        currencyCode,
+        active: true,
+        ...extraAttrs,
+      });
+    }
+    return result;
+  };
+
+  /**
+   * Finds or creates the unearned revenue.
+   * @param {Record<string, string>} extraAttrs
+   * @param {Knex.Transaction} trx
+   * @returns
+   */
+  public async findOrCreateUnearnedRevenue(
+    extraAttrs: Record<string, string> = {},
+    trx?: Knex.Transaction,
+  ) {
+    const tenantMeta = await this.tenancyContext.getTenantMetadata();
+    const _extraAttrs = {
+      currencyCode: tenantMeta.baseCurrency,
+      ...extraAttrs,
+    };
+    let result = await this.model
+      .query(trx)
+      .findOne({ slug: UnearnedRevenueAccount.slug, ..._extraAttrs });
+
+    if (!result) {
+      result = await this.model.query(trx).insertAndFetch({
+        ...UnearnedRevenueAccount,
+        ..._extraAttrs,
+      });
+    }
+    return result;
+  }
+
+  /**
+   * Finds or creates the prepard expenses account.
+   * @param {Record<string, string>} extraAttrs
+   * @param {Knex.Transaction} trx
+   * @returns
+   */
+  public async findOrCreatePrepardExpenses(
+    extraAttrs: Record<string, string> = {},
+    trx?: Knex.Transaction,
+  ) {
+    const tenantMeta = await this.tenancyContext.getTenantMetadata();
+    const _extraAttrs = {
+      currencyCode: tenantMeta.baseCurrency,
+      ...extraAttrs,
+    };
+
+    let result = await this.model
+      .query(trx)
+      .findOne({ slug: PrepardExpenses.slug, ..._extraAttrs });
+
+    if (!result) {
+      result = await this.model.query(trx).insertAndFetch({
+        ...PrepardExpenses,
+        ..._extraAttrs,
+      });
+    }
+    return result;
+  }
+
+  /**
+   * Finds or creates the stripe clearing account.
+   * @param {Record<string, string>} extraAttrs
+   * @param {Knex.Transaction} trx
+   * @returns
+   */
+  public async findOrCreateStripeClearing(
+    extraAttrs: Record<string, string> = {},
+    trx?: Knex.Transaction,
+  ) {
+    const tenantMeta = await this.tenancyContext.getTenantMetadata();
+    const _extraAttrs = {
+      currencyCode: tenantMeta.baseCurrency,
+      ...extraAttrs,
+    };
+    let result = await this.model
+      .query(trx)
+      .findOne({ slug: StripeClearingAccount.slug, ..._extraAttrs });
+
+    if (!result) {
+      result = await this.model.query(trx).insertAndFetch({
+        ...StripeClearingAccount,
+        ..._extraAttrs,
+      });
+    }
+    return result;
+  }
+
+  /**
+   * Finds or creates the discount expense account.
+   * @param {Record<string, string>} extraAttrs
+   * @param {Knex.Transaction} trx
+   * @returns
+   */
+  public async findOrCreateDiscountAccount(
+    extraAttrs: Record<string, string> = {},
+    trx?: Knex.Transaction,
+  ) {
+    const tenantMeta = await this.tenancyContext.getTenantMetadata();
+    const _extraAttrs = {
+      currencyCode: tenantMeta.baseCurrency,
+      ...extraAttrs,
+    };
+
+    let result = await this.model
+      .query(trx)
+      .findOne({ slug: DiscountExpenseAccount.slug, ..._extraAttrs });
+
+    if (!result) {
+      result = await this.model.query(trx).insertAndFetch({
+        ...DiscountExpenseAccount,
+        ..._extraAttrs,
+      });
+    }
+    return result;
+  }
+
+  public async findOrCreatePurchaseDiscountAccount(
+    extraAttrs: Record<string, string> = {},
+    trx?: Knex.Transaction,
+  ) {
+    const tenantMeta = await this.tenancyContext.getTenantMetadata();
+    const _extraAttrs = {
+      currencyCode: tenantMeta.baseCurrency,
+      ...extraAttrs,
+    };
+
+    let result = await this.model
+      .query(trx)
+      .findOne({ slug: PurchaseDiscountAccount.slug, ..._extraAttrs });
+
+    if (!result) {
+      result = await this.model.query(trx).insertAndFetch({
+        ...PurchaseDiscountAccount,
+        ..._extraAttrs,
+      });
+    }
+    return result;
+  }
+
+  public async findOrCreateOtherChargesAccount(
+    extraAttrs: Record<string, string> = {},
+    trx?: Knex.Transaction,
+  ) {
+    const tenantMeta = await this.tenancyContext.getTenantMetadata();
+    const _extraAttrs = {
+      currencyCode: tenantMeta.baseCurrency,
+      ...extraAttrs,
+    };
+
+    let result = await this.model
+      .query(trx)
+      .findOne({ slug: OtherChargesAccount.slug, ..._extraAttrs });
+
+    if (!result) {
+      result = await this.model.query(trx).insertAndFetch({
+        ...OtherChargesAccount,
+        ..._extraAttrs,
+      });
+    }
+    return result;
+  }
+
+  public async findOrCreateOtherExpensesAccount(
+    extraAttrs: Record<string, string> = {},
+    trx?: Knex.Transaction,
+  ) {
+    const tenantMeta = await this.tenancyContext.getTenantMetadata();
+    const _extraAttrs = {
+      currencyCode: tenantMeta.baseCurrency,
+      ...extraAttrs,
+    };
+    let result = await this.model
+      .query(trx)
+      .findOne({ slug: OtherExpensesAccount.slug, ..._extraAttrs });
+
+    if (!result) {
+      result = await this.model.query(trx).insertAndFetch({
+        ...OtherExpensesAccount,
+        ..._extraAttrs,
+      });
+    }
+    return result;
+  }
+}

packages/server/src/modules/Accounts/susbcribers/MutateBaseCurrencyAccounts.ts

@@ -0,0 +1,34 @@
+// import { Service, Inject } from 'typedi';
+// import events from '@/subscribers/events';
+// import { MutateBaseCurrencyAccounts } from '../MutateBaseCurrencyAccounts';
+
+// @Service()
+// export class MutateBaseCurrencyAccountsSubscriber {
+//   @Inject()
+//   public mutateBaseCurrencyAccounts: MutateBaseCurrencyAccounts;
+
+//   /**
+//    * Attaches the events with handles.
+//    * @param bus
+//    */
+//   attach(bus) {
+//     bus.subscribe(
+//       events.organization.baseCurrencyUpdated,
+//       this.updateAccountsCurrencyOnBaseCurrencyMutated
+//     );
+//   }
+
+//   /**
+//    * Updates the all accounts currency once the base currency
+//    * of the organization is mutated.
+//    */
+//   private updateAccountsCurrencyOnBaseCurrencyMutated = async ({
+//     tenantId,
+//     organizationDTO,
+//   }) => {
+//     await this.mutateBaseCurrencyAccounts.mutateAllAccountsCurrency(
+//       tenantId,
+//       organizationDTO.baseCurrency
+//     );
+//   };
+// }

packages/server/src/modules/Accounts/utils/AccountType.utils.ts

@@ -0,0 +1,101 @@
+import { get } from 'lodash';
+import { ACCOUNT_TYPES } from '../Accounts.constants';
+
+export class AccountTypesUtils {
+  /**
+   * Retrieve account types list.
+   */
+  static getList() {
+    return ACCOUNT_TYPES;
+  }
+
+  /**
+   * Retrieve accounts types by the given root type.
+   * @param {string} rootType -
+   * @return {string}
+   */
+  static getTypesByRootType(rootType: string) {
+    return ACCOUNT_TYPES.filter((type) => type.rootType === rootType);
+  }
+
+  /**
+   * Retrieve account type by the given account type key.
+   * @param {string} key
+   * @param {string} accessor
+   */
+  static getType(key: string, accessor?: string) {
+    const type = ACCOUNT_TYPES.find((type) => type.key === key);
+
+    if (accessor) {
+      return get(type, accessor);
+    }
+    return type;
+  }
+
+  /**
+   * Retrieve accounts types by the parent account type.
+   * @param {string} parentType
+   */
+  static getTypesByParentType(parentType: string) {
+    return ACCOUNT_TYPES.filter((type) => type.parentType === parentType);
+  }
+
+  /**
+   * Retrieve accounts types by the given account normal.
+   * @param {string} normal
+   */
+  static getTypesByNormal(normal: string) {
+    return ACCOUNT_TYPES.filter((type) => type.normal === normal);
+  }
+
+  /**
+   * Detarmines whether the root type equals the account type.
+   * @param {string} key
+   * @param {string} rootType
+   */
+  static isRootTypeEqualsKey(key: string, rootType: string): boolean {
+    return ACCOUNT_TYPES.some((type) => {
+      const isType = type.key === key;
+      const isRootType = type.rootType === rootType;
+
+      return isType && isRootType;
+    });
+  }
+
+  /**
+   * Detarmines whether the parent account type equals the account type key.
+   * @param {string} key - Account type key.
+   * @param {string} parentType - Account parent type.
+   */
+  static isParentTypeEqualsKey(key: string, parentType: string): boolean {
+    return ACCOUNT_TYPES.some((type) => {
+      const isType = type.key === key;
+      const isParentType = type.parentType === parentType;
+
+      return isType && isParentType;
+    });
+  }
+
+  /**
+   * Detarmines whether account type has balance sheet.
+   * @param {string} key - Account type key.
+   *
+   */
+  static isTypeBalanceSheet(key: string): boolean {
+    return ACCOUNT_TYPES.some((type) => {
+      const isType = type.key === key;
+      return isType && type.balanceSheet;
+    });
+  }
+
+  /**
+   * Detarmines whether account type has profit/loss sheet.
+   * @param {string} key - Account type key.
+   */
+  static isTypePLSheet(key: string): boolean {
+    return ACCOUNT_TYPES.some((type) => {
+      const isType = type.key === key;
+      return isType && type.incomeSheet;
+    });
+  }
+}