@actual-app/sync-server 25.4.0-alpha.0

package/src/app-gocardless/banks/integration-bank.js

@@ -0,0 +1,115 @@
+import * as d from 'date-fns';
+
+import { formatPayeeName } from '../../util/payee-name.js';
+import {
+  amountToInteger,
+  printIban,
+  sortByBookingDateOrValueDate,
+} from '../utils.js';
+
+const SORTED_BALANCE_TYPE_LIST = [
+  'closingBooked',
+  'expected',
+  'forwardAvailable',
+  'interimAvailable',
+  'interimBooked',
+  'nonInvoiced',
+  'openingBooked',
+];
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  institutionIds: ['IntegrationBank'],
+
+  normalizeAccount(account) {
+    console.debug(
+      'Available account properties for new institution integration',
+      { account: JSON.stringify(account) },
+    );
+
+    return {
+      account_id: account.id,
+      institution: account.institution,
+      mask: (account?.iban || '0000').slice(-4),
+      iban: account?.iban || null,
+      name: [
+        account.name ?? account.displayName ?? account.product,
+        printIban(account),
+        account.currency,
+      ]
+        .filter(Boolean)
+        .join(' '),
+      official_name: account.product ?? `integration-${account.institution_id}`,
+      type: 'checking',
+    };
+  },
+
+  normalizeTransaction(transaction, _booked, editedTransaction = null) {
+    const trans = editedTransaction ?? transaction;
+
+    const date =
+      trans.date ||
+      transaction.bookingDate ||
+      transaction.bookingDateTime ||
+      transaction.valueDate ||
+      transaction.valueDateTime;
+
+    // If we couldn't find a valid date field we filter out this transaction
+    // and hope that we will import it again once the bank has processed the
+    // transaction further.
+    if (!date) {
+      return null;
+    }
+
+    const notes =
+      trans.notes ??
+      trans.remittanceInformationUnstructured ??
+      trans.remittanceInformationUnstructuredArray?.join(' ');
+
+    transaction.remittanceInformationUnstructuredArrayString =
+      transaction.remittanceInformationUnstructuredArray?.join(',');
+    transaction.remittanceInformationStructuredArrayString =
+      transaction.remittanceInformationStructuredArray?.join(',');
+
+    return {
+      ...transaction,
+      payeeName: trans.payeeName ?? formatPayeeName(trans),
+      date: d.format(d.parseISO(date), 'yyyy-MM-dd'),
+      notes,
+    };
+  },
+
+  sortTransactions(transactions = []) {
+    console.debug(
+      'Available (first 10) transactions properties for new integration of institution in sortTransactions function',
+      { top10Transactions: JSON.stringify(transactions.slice(0, 10)) },
+    );
+    return sortByBookingDateOrValueDate(transactions);
+  },
+
+  calculateStartingBalance(sortedTransactions = [], balances = []) {
+    console.debug(
+      'Available (first 10) transactions properties for new integration of institution in calculateStartingBalance function',
+      {
+        balances: JSON.stringify(balances),
+        top10SortedTransactions: JSON.stringify(
+          sortedTransactions.slice(0, 10),
+        ),
+      },
+    );
+
+    const currentBalance = balances
+      .filter(item => SORTED_BALANCE_TYPE_LIST.includes(item.balanceType))
+      .sort(
+        (a, b) =>
+          SORTED_BALANCE_TYPE_LIST.indexOf(a.balanceType) -
+          SORTED_BALANCE_TYPE_LIST.indexOf(b.balanceType),
+      )[0];
+    return sortedTransactions.reduce(
+      (total, trans) => {
+        return total - amountToInteger(trans.transactionAmount.amount);
+      },
+      amountToInteger(currentBalance?.balanceAmount?.amount || 0),
+    );
+  },
+};

package/src/app-gocardless/banks/isybank_itbbitmm.js

@@ -0,0 +1,18 @@
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['ISYBANK_ITBBITMM'],
+
+  // It has been reported that valueDate is more accurate than booking date
+  // when it is provided
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    editedTrans.date = transaction.valueDate ?? transaction.bookingDate;
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+};

package/src/app-gocardless/banks/kbc_kredbebb.js

@@ -0,0 +1,33 @@
+import Fallback from './integration-bank.js';
+import { extractPayeeNameFromRemittanceInfo } from './util/extract-payeeName-from-remittanceInfo.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['KBC_KREDBEBB'],
+
+  /**
+   * For negative amounts, the only payee information we have is returned in
+   * remittanceInformationUnstructured.
+   */
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    if (Number(transaction.transactionAmount.amount) > 0) {
+      editedTrans.payeeName =
+        transaction.debtorName ||
+        transaction.remittanceInformationUnstructured ||
+        'undefined';
+    } else {
+      editedTrans.payeeName =
+        transaction.creditorName ||
+        extractPayeeNameFromRemittanceInfo(
+          transaction.remittanceInformationUnstructured,
+          ['Betaling met', 'Domiciliëring', 'Overschrijving'],
+        );
+    }
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+};

package/src/app-gocardless/banks/lhv-lhvbee22.js

@@ -0,0 +1,36 @@
+import d from 'date-fns';
+
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['LHV_LHVBEE22'],
+
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    // extract bookingDate and creditorName for card transactions, e.g.
+    // (..1234) 2025-01-02 09:32 CrustumOU\Poordi 3\Tallinn\10156     ESTEST
+    // bookingDate: 2025-01-02
+    // creditorName: CrustumOU
+    const cardTxRegex =
+      /^\(\.\.(\d{4})\) (\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}) (.+)$/g;
+    const cardTxMatch = cardTxRegex.exec(
+      transaction?.remittanceInformationUnstructured,
+    );
+
+    if (cardTxMatch) {
+      const extractedDate = d.parse(cardTxMatch[2], 'yyyy-MM-dd', new Date());
+
+      editedTrans.payeeName = cardTxMatch[4].split('\\')[0].trim();
+
+      if (booked && d.isValid(extractedDate)) {
+        editedTrans.date = d.format(extractedDate, 'yyyy-MM-dd');
+      }
+    }
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+};

package/src/app-gocardless/banks/mbank_retail_brexplpw.js

@@ -0,0 +1,56 @@
+import { amountToInteger } from '../utils.js';
+
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['MBANK_RETAIL_BREXPLPW'],
+
+  /**
+   * When requesting transaction details for MBANK_RETAIL_BREXPLPW
+   * using gocardless API, it seems that bookingDate and valueDate are swapped.
+   * valueDate will always come before bookingDate, so as a simple fix,
+   * I have overwritten integration-bank.normalizeTransaction() here,
+   * swapped dates back (by giving valueDate higher priority) and
+   * called parent method with edited transaction as argument
+   */
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    const date =
+      transaction.valueDate ||
+      transaction.valueDateTime ||
+      transaction.bookingDate ||
+      transaction.bookingDateTime;
+
+    editedTrans.date = date;
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+
+  sortTransactions(transactions = []) {
+    return transactions.sort(
+      (a, b) => Number(b.transactionId) - Number(a.transactionId),
+    );
+  },
+
+  /**
+   *  For MBANK_RETAIL_BREXPLPW we don't know what balance was
+   *  after each transaction so we have to calculate it by getting
+   *  current balance from the account and subtract all the transactions
+   *
+   *  As a current balance we use `interimBooked` balance type because
+   *  it includes transaction placed during current day
+   */
+  calculateStartingBalance(sortedTransactions = [], balances = []) {
+    const currentBalance = balances.find(
+      balance => 'interimBooked' === balance.balanceType,
+    );
+
+    return sortedTransactions.reduce((total, trans) => {
+      return total - amountToInteger(trans.transactionAmount.amount);
+    }, amountToInteger(currentBalance.balanceAmount.amount));
+  },
+};

package/src/app-gocardless/banks/nationwide_naiagb21.js

@@ -0,0 +1,46 @@
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['NATIONWIDE_NAIAGB21'],
+
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    // Nationwide can sometimes return pending transactions with a date
+    // representing the latest a transaction could be booked. This stops
+    // actual's deduplication logic from working as it only checks 7 days
+    // ahead/behind and the transactionID from Nationwide changes when a
+    // transaction is booked
+    if (!booked) {
+      const useDate = new Date(
+        Math.min(
+          new Date(transaction.bookingDate).getTime(),
+          new Date().getTime(),
+        ),
+      );
+      editedTrans.date = useDate.toISOString().slice(0, 10);
+    }
+
+    // Nationwide also occasionally returns erroneous transaction_ids
+    // that are malformed and can even change after import. This will ignore
+    // these ids and unset them. When a correct ID is returned then it will
+    // update via the deduplication logic
+    const debitCreditRegex = /^00(DEB|CRED)IT.+$/;
+    const validLengths = [
+      40, // Nationwide credit cards
+      32, // Nationwide current accounts
+    ];
+
+    if (
+      transaction.transactionId?.match(debitCreditRegex) ||
+      !validLengths.includes(transaction.transactionId?.length)
+    ) {
+      transaction.transactionId = null;
+    }
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+};

package/src/app-gocardless/banks/nbg_ethngraaxxx.js

@@ -0,0 +1,51 @@
+import { amountToInteger } from '../utils.js';
+
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['NBG_ETHNGRAAXXX'],
+
+  /**
+   * Fixes for the pending transactions:
+   * - Corrects amount to negative (nbg erroneously omits the minus sign in pending transactions)
+   * - Removes prefix 'ΑΓΟΡΑ' from remittance information to align with the booked transaction (necessary for fuzzy matching to work)
+   */
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    if (
+      !transaction.transactionId &&
+      transaction.remittanceInformationUnstructured.startsWith('ΑΓΟΡΑ ')
+    ) {
+      transaction.transactionAmount = {
+        amount: '-' + transaction.transactionAmount.amount,
+        currency: transaction.transactionAmount.currency,
+      };
+      editedTrans.remittanceInformationUnstructured =
+        transaction.remittanceInformationUnstructured.substring(6);
+    }
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+
+  /**
+   *  For NBG_ETHNGRAAXXX we don't know what balance was
+   *  after each transaction so we have to calculate it by getting
+   *  current balance from the account and subtract all the transactions
+   *
+   *  As a current balance we use `interimBooked` balance type because
+   *  it includes transaction placed during current day
+   */
+  calculateStartingBalance(sortedTransactions = [], balances = []) {
+    const currentBalance = balances.find(
+      balance => 'interimAvailable' === balance.balanceType,
+    );
+
+    return sortedTransactions.reduce((total, trans) => {
+      return total - amountToInteger(trans.transactionAmount.amount);
+    }, amountToInteger(currentBalance.balanceAmount.amount));
+  },
+};

package/src/app-gocardless/banks/norwegian_xx_norwnok1.js

@@ -0,0 +1,74 @@
+import { amountToInteger } from '../utils.js';
+
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: [
+    'NORWEGIAN_NO_NORWNOK1',
+    'NORWEGIAN_SE_NORWNOK1',
+    'NORWEGIAN_DE_NORWNOK1',
+    'NORWEGIAN_DK_NORWNOK1',
+    'NORWEGIAN_ES_NORWNOK1',
+    'NORWEGIAN_FI_NORWNOK1',
+  ],
+
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    if (booked) {
+      editedTrans.date = transaction.bookingDate;
+      return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+    }
+
+    /**
+     * For pending transactions there are two possibilities:
+     *
+     * - Either a `valueDate` was set, in which case it corresponds to when the
+     *   transaction actually occurred, or
+     * - There is no date field, in which case we try to parse the correct date
+     *   out of the `remittanceInformationStructured` field.
+     *
+     * If neither case succeeds then we return `null` causing this transaction
+     * to be filtered out for now, and hopefully we'll be able to import it
+     * once the bank has processed it further.
+     */
+    if (transaction.valueDate !== undefined) {
+      editedTrans.date = transaction.valueDate;
+      return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+    }
+
+    if (transaction.remittanceInformationStructured) {
+      const remittanceInfoRegex = / (\d{4}-\d{2}-\d{2}) /;
+      const matches =
+        transaction.remittanceInformationStructured.match(remittanceInfoRegex);
+      if (matches) {
+        editedTrans.date = matches[1];
+        return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+      }
+    }
+
+    return null;
+  },
+
+  /**
+   *  For NORWEGIAN_XX_NORWNOK1 we don't know what balance was
+   *  after each transaction so we have to calculate it by getting
+   *  current balance from the account and subtract all the transactions
+   *
+   *  As a current balance we use `expected` balance type because it
+   *  corresponds to the current running balance, whereas `interimAvailable`
+   *  holds the remaining credit limit.
+   */
+  calculateStartingBalance(sortedTransactions = [], balances = []) {
+    const currentBalance = balances.find(
+      balance => 'expected' === balance.balanceType,
+    );
+
+    return sortedTransactions.reduce((total, trans) => {
+      return total - amountToInteger(trans.transactionAmount.amount);
+    }, amountToInteger(currentBalance.balanceAmount.amount));
+  },
+};

package/src/app-gocardless/banks/revolut_revolt21.js

@@ -0,0 +1,37 @@
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['REVOLUT_REVOLT21'],
+
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    if (
+      transaction.remittanceInformationUnstructuredArray[0].startsWith(
+        'Bizum payment from: ',
+      )
+    ) {
+      editedTrans.payeeName =
+        transaction.remittanceInformationUnstructuredArray[0].replace(
+          'Bizum payment from: ',
+          '',
+        );
+      editedTrans.remittanceInformationUnstructured =
+        transaction.remittanceInformationUnstructuredArray[1];
+    }
+
+    if (
+      transaction.remittanceInformationUnstructuredArray[0].startsWith(
+        'Bizum payment to: ',
+      )
+    ) {
+      editedTrans.remittanceInformationUnstructured =
+        transaction.remittanceInformationUnstructuredArray[1];
+    }
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+};

package/src/app-gocardless/banks/sandboxfinance_sfin0000.js

@@ -0,0 +1,28 @@
+import { amountToInteger } from '../utils.js';
+
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['SANDBOXFINANCE_SFIN0000'],
+
+  /**
+   *  For SANDBOXFINANCE_SFIN0000 we don't know what balance was
+   *  after each transaction so we have to calculate it by getting
+   *  current balance from the account and subtract all the transactions
+   *
+   *  As a current balance we use `interimBooked` balance type because
+   *  it includes transaction placed during current day
+   */
+  calculateStartingBalance(sortedTransactions = [], balances = []) {
+    const currentBalance = balances.find(
+      balance => 'interimAvailable' === balance.balanceType,
+    );
+
+    return sortedTransactions.reduce((total, trans) => {
+      return total - amountToInteger(trans.transactionAmount.amount);
+    }, amountToInteger(currentBalance.balanceAmount.amount));
+  },
+};

package/src/app-gocardless/banks/seb_kort_bank_ab.js

@@ -0,0 +1,58 @@
+import { amountToInteger } from '../utils.js';
+
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: [
+    'SEB_KORT_AB_NO_SKHSFI21',
+    'SEB_KORT_AB_SE_SKHSFI21',
+    'SEB_CARD_ESSESESS',
+  ],
+
+  /**
+   * Sign of transaction amount needs to be flipped for SEB credit cards
+   */
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    // Creditor name is stored in additionInformation for SEB
+    editedTrans.creditorName = transaction.additionalInformation;
+    transaction.transactionAmount = {
+      // Flip transaction amount sign
+      amount: (-parseFloat(transaction.transactionAmount.amount)).toString(),
+      currency: transaction.transactionAmount.currency,
+    };
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+
+  /**
+   *  For SEB_KORT_AB_NO_SKHSFI21 and SEB_KORT_AB_SE_SKHSFI21 we don't know what balance was
+   *  after each transaction so we have to calculate it by getting
+   *  current balance from the account and subtract all the transactions
+   *
+   *  As a current balance we use `expected` and `nonInvoiced` balance types because it
+   *  corresponds to the current running balance, whereas `interimAvailable`
+   *  holds the remaining credit limit.
+   */
+  calculateStartingBalance(sortedTransactions = [], balances = []) {
+    const currentBalance = balances.find(
+      balance => 'expected' === balance.balanceType,
+    );
+
+    const nonInvoiced = balances.find(
+      balance => 'nonInvoiced' === balance.balanceType,
+    );
+
+    return sortedTransactions.reduce(
+      (total, trans) => {
+        return total - amountToInteger(trans.transactionAmount.amount);
+      },
+      -amountToInteger(currentBalance.balanceAmount.amount) +
+        amountToInteger(nonInvoiced.balanceAmount.amount),
+    );
+  },
+};

package/src/app-gocardless/banks/seb_privat.js

@@ -0,0 +1,29 @@
+import { amountToInteger } from '../utils.js';
+
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['SEB_ESSESESS_PRIVATE'],
+
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    // Creditor name is stored in additionInformation for SEB
+    editedTrans.creditorName = transaction.additionalInformation;
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+
+  calculateStartingBalance(sortedTransactions = [], balances = []) {
+    const currentBalance = balances.find(
+      balance => 'interimBooked' === balance.balanceType,
+    );
+
+    return sortedTransactions.reduce((total, trans) => {
+      return total - amountToInteger(trans.transactionAmount.amount);
+    }, amountToInteger(currentBalance.balanceAmount.amount));
+  },
+};

package/src/app-gocardless/banks/sparnord_spnodk22.js

@@ -0,0 +1,24 @@
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: [
+    'SPARNORD_SPNODK22',
+    'LAGERNES_BANK_LAPNDKK1',
+    'ANDELSKASSEN_FALLESKASSEN_FAELDKK1',
+  ],
+
+  /**
+   * Banks on the BEC backend only give information regarding the transaction in additionalInformation
+   */
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    editedTrans.remittanceInformationUnstructured =
+      transaction.additionalInformation;
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+};

package/src/app-gocardless/banks/spk_karlsruhe_karsde66.js

@@ -0,0 +1,61 @@
+import { amountToInteger } from '../utils.js';
+
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['SPK_KARLSRUHE_KARSDE66XXX'],
+
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    let remittanceInformationUnstructured;
+
+    if (transaction.remittanceInformationUnstructured) {
+      remittanceInformationUnstructured =
+        transaction.remittanceInformationUnstructured;
+    } else if (transaction.remittanceInformationStructured) {
+      remittanceInformationUnstructured =
+        transaction.remittanceInformationStructured;
+    } else if (transaction.remittanceInformationStructuredArray?.length > 0) {
+      remittanceInformationUnstructured =
+        transaction.remittanceInformationStructuredArray?.join(' ');
+    }
+
+    if (transaction.additionalInformation) {
+      remittanceInformationUnstructured +=
+        ' ' + transaction.additionalInformation;
+    }
+
+    const usefulCreditorName =
+      transaction.ultimateCreditor ||
+      transaction.creditorName ||
+      transaction.debtorName;
+
+    editedTrans.creditorName = usefulCreditorName;
+    editedTrans.remittanceInformationUnstructured =
+      remittanceInformationUnstructured;
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+
+  /**
+   *  For SANDBOXFINANCE_SFIN0000 we don't know what balance was
+   *  after each transaction so we have to calculate it by getting
+   *  current balance from the account and subtract all the transactions
+   *
+   *  As a current balance we use `interimBooked` balance type because
+   *  it includes transaction placed during current day
+   */
+  calculateStartingBalance(sortedTransactions = [], balances = []) {
+    const currentBalance = balances.find(
+      balance => 'interimAvailable' === balance.balanceType,
+    );
+
+    return sortedTransactions.reduce((total, trans) => {
+      return total - amountToInteger(trans.transactionAmount.amount);
+    }, amountToInteger(currentBalance.balanceAmount.amount));
+  },
+};