@actual-app/sync-server 25.5.0 → 25.6.0

package/build/src/app-gocardless/banks/commerzbank_cobadeff.js

@@ -0,0 +1,43 @@
+import Fallback from './integration-bank.js';
+import { escapeRegExp } from './util/escape-regexp.js';
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+    ...Fallback,
+    institutionIds: ['COMMERZBANK_COBADEFF'],
+    normalizeTransaction(transaction, booked) {
+        const editedTrans = { ...transaction };
+        // remittanceInformationUnstructured is limited to 140 chars thus ...
+        // ... missing information form remittanceInformationUnstructuredArray ...
+        // ... so we recreate it.
+        editedTrans.remittanceInformationUnstructured =
+            transaction.remittanceInformationUnstructuredArray.join(' ');
+        // The limitations of remittanceInformationUnstructuredArray ...
+        // ... can result in split keywords. We fix these. Other ...
+        // ... splits will need to be fixed by user with rules.
+        const keywords = [
+            'End-to-End-Ref.:',
+            'Mandatsref:',
+            'Gläubiger-ID:',
+            'SEPA-BASISLASTSCHRIFT',
+            'Kartenzahlung',
+            'Dauerauftrag',
+        ];
+        keywords.forEach(keyword => {
+            editedTrans.remittanceInformationUnstructured =
+                editedTrans.remittanceInformationUnstructured.replace(
+                // There can be spaces in keywords
+                RegExp(keyword.split('').join('\\s*'), 'gi'), ', ' + keyword + ' ');
+        });
+        // Clean up remittanceInformation, deduplicate payee (removing slashes ...
+        // ... that are added to the remittanceInformation field), and ...
+        // ... remove clutter like "End-to-End-Ref.: NOTPROVIDED"
+        const payee = escapeRegExp(transaction.creditorName || transaction.debtorName || '');
+        editedTrans.remittanceInformationUnstructured =
+            editedTrans.remittanceInformationUnstructured
+                .replace(/\s*(,)?\s+/g, '$1 ')
+                .replace(RegExp(payee.split(' ').join('(/*| )'), 'gi'), ' ')
+                .replace(', End-to-End-Ref.: NOTPROVIDED', '')
+                .trim();
+        return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+    },
+};

package/build/src/app-gocardless/banks/danskebank_dabno22.js

@@ -0,0 +1,26 @@
+import { amountToInteger } from '../utils.js';
+import Fallback from './integration-bank.js';
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+    ...Fallback,
+    institutionIds: ['DANSKEBANK_DABANO22'],
+    normalizeTransaction(transaction, booked) {
+        const editedTrans = { ...transaction };
+        /**
+         * Danske Bank appends the EndToEndID: NOTPROVIDED to
+         * remittanceInformationUnstructured, cluttering the data.
+         *
+         * We clean thais up by removing any instances of this string from all transactions.
+         *
+         */
+        editedTrans.remittanceInformationUnstructured =
+            transaction.remittanceInformationUnstructured.replace('\nEndToEndID: NOTPROVIDED', '');
+        return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+    },
+    calculateStartingBalance(sortedTransactions = [], balances = []) {
+        const currentBalance = balances.find(balance => balance.balanceType === 'interimAvailable');
+        return sortedTransactions.reduce((total, trans) => {
+            return total - amountToInteger(trans.transactionAmount.amount);
+        }, amountToInteger(currentBalance.balanceAmount.amount));
+    },
+};

package/build/src/app-gocardless/banks/direkt_heladef1822.js

@@ -0,0 +1,13 @@
+import Fallback from './integration-bank.js';
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+    ...Fallback,
+    institutionIds: ['DIREKT_HELADEF1822'],
+    normalizeTransaction(transaction, booked) {
+        const editedTrans = { ...transaction };
+        editedTrans.remittanceInformationUnstructured =
+            transaction.remittanceInformationUnstructured ??
+                transaction.remittanceInformationStructured;
+        return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+    },
+};

package/build/src/app-gocardless/banks/easybank_bawaatww.js

@@ -0,0 +1,42 @@
+import * as d from 'date-fns';
+import { formatPayeeName } from '../../util/payee-name.js';
+import { title } from '../../util/title/index.js';
+import Fallback from './integration-bank.js';
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+    ...Fallback,
+    institutionIds: ['EASYBANK_BAWAATWW'],
+    // If date is same, sort by transactionId
+    sortTransactions: (transactions = []) => transactions.sort((a, b) => {
+        const diff = +new Date(b.valueDate || b.bookingDate) -
+            +new Date(a.valueDate || a.bookingDate);
+        if (diff !== 0)
+            return diff;
+        return parseInt(b.transactionId) - parseInt(a.transactionId);
+    }),
+    normalizeTransaction(transaction, booked) {
+        const editedTrans = { ...transaction };
+        let payeeName = formatPayeeName(transaction);
+        if (!payeeName)
+            payeeName = extractPayeeName(transaction);
+        editedTrans.payeeName = payeeName;
+        return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+    },
+};
+/**
+ * Extracts the payee name from the remittanceInformationStructured
+ * @param {import('../gocardless-node.types.js').Transaction} transaction
+ */
+function extractPayeeName(transaction) {
+    const structured = transaction.remittanceInformationStructured;
+    // The payee name is betweeen the transaction timestamp (11.07. 11:36) and the location, that starts with \\
+    const regex = /\d{2}\.\d{2}\. \d{2}:\d{2}(.*)\\\\/;
+    const matches = structured.match(regex);
+    if (matches && matches.length > 1 && matches[1]) {
+        return title(matches[1]);
+    }
+    else {
+        // As a fallback if still no payee is found, the whole information is used
+        return structured;
+    }
+}

package/build/src/app-gocardless/banks/entercard_swednokk.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: ['ENTERCARD_SWEDNOKK'],
+    normalizeTransaction(transaction, booked) {
+        const editedTrans = { ...transaction };
+        // GoCardless's Entercard integration returns forex transactions with the
+        // foreign amount in `transactionAmount`, but at least the amount actually
+        // billed to the account is now available in
+        // `remittanceInformationUnstructured`.
+        const remittanceInformationUnstructured = transaction.remittanceInformationUnstructured;
+        if (remittanceInformationUnstructured.startsWith('billingAmount: ')) {
+            transaction.transactionAmount = {
+                amount: remittanceInformationUnstructured.substring(15),
+                currency: 'SEK',
+            };
+        }
+        editedTrans.date = transaction.valueDate;
+        return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+    },
+    calculateStartingBalance(sortedTransactions = [], balances = []) {
+        return sortedTransactions.reduce((total, trans) => {
+            return total - amountToInteger(trans.transactionAmount.amount);
+        }, amountToInteger(balances[0]?.balanceAmount?.amount || 0));
+    },
+};

package/build/src/app-gocardless/banks/fortuneo_ftnofrp1xxx.js

@@ -0,0 +1,34 @@
+import { formatPayeeName } from '../../util/payee-name.js';
+import Fallback from './integration-bank.js';
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+    ...Fallback,
+    institutionIds: ['FORTUNEO_FTNOFRP1XXX'],
+    normalizeTransaction(transaction, booked) {
+        const editedTrans = { ...transaction };
+        // Most of the information from the transaction is in the remittanceInformationUnstructuredArray field.
+        // We extract the creditor and debtor names from this field.
+        // The remittanceInformationUnstructuredArray field usually contain keywords like "Vir" for
+        // bank transfers or "Carte 03/06" for card payments, as well as the date.
+        // We remove these keywords to get a cleaner payee name.
+        const keywordsToRemove = [
+            'VIR INST',
+            'VIR',
+            'PRLV',
+            'ANN CARTE',
+            'CARTE \\d{2}\\/\\d{2}',
+        ];
+        const details = transaction.remittanceInformationUnstructuredArray.join(' ');
+        const amount = transaction.transactionAmount.amount;
+        const regex = new RegExp(keywordsToRemove.join('|'), 'g');
+        const payeeName = details.replace(regex, '').trim();
+        // The amount is negative for outgoing transactions, positive for incoming transactions.
+        const isCreditorPayee = parseFloat(amount) < 0;
+        // The payee name is the creditor name for outgoing transactions and the debtor name for incoming transactions.
+        const creditorName = isCreditorPayee ? payeeName : null;
+        const debtorName = isCreditorPayee ? null : payeeName;
+        editedTrans.creditorName = creditorName;
+        editedTrans.debtorName = debtorName;
+        return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+    },
+};

package/build/src/app-gocardless/banks/hype_hyeeit22.js

@@ -0,0 +1,63 @@
+import Fallback from './integration-bank.js';
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+    ...Fallback,
+    institutionIds: ['HYPE_HYEEIT22'],
+    normalizeTransaction(transaction, booked) {
+        const editedTrans = { ...transaction };
+        /** Online card payments - identified by "crd" transaction code
+         *  always start with PAGAMENTO PRESSO + <payee name>
+         */
+        if (transaction.proprietaryBankTransactionCode === 'crd') {
+            // remove PAGAMENTO PRESSO and set payee name
+            editedTrans.debtorName =
+                transaction.remittanceInformationUnstructured?.slice('PAGAMENTO PRESSO '.length);
+        }
+        /**
+         * In-app money transfers (p2p) and bank transfers (bon) have remittance info structure like
+         * DENARO (INVIATO/RICEVUTO) (A/DA) {payee_name} - {payment_info} (p2p)
+         * HAI (INVIATO/RICEVUTO) UN BONIFICO (A/DA) {payee_name} - {payment_info} (bon)
+         */
+        if (transaction.proprietaryBankTransactionCode === 'p2p' ||
+            transaction.proprietaryBankTransactionCode === 'bon') {
+            // keep only {payment_info} portion of remittance info
+            // NOTE: if {payee_name} contains dashes (unlikely / impossible?), this probably gets bugged!
+            const infoIdx = transaction.remittanceInformationUnstructured.indexOf(' - ') + 3;
+            editedTrans.remittanceInformationUnstructured =
+                infoIdx === -1
+                    ? transaction.remittanceInformationUnstructured
+                    : transaction.remittanceInformationUnstructured.slice(infoIdx).trim();
+        }
+        /**
+         * CONVERT ESCAPED UNICODE TO CODEPOINTS
+         * p2p payments allow user to write arbitrary unicode strings as messages
+         * gocardless reports unicode codepoints as \Uxxxx
+         * so it groups them in 4bytes bundles
+         * the code below assumes this is always the case
+         */
+        if (transaction.proprietaryBankTransactionCode === 'p2p') {
+            let str = transaction.remittanceInformationUnstructured;
+            let idx = str.indexOf('\\U');
+            let start_idx = idx;
+            let codepoints = [];
+            while (idx !== -1) {
+                codepoints.push(parseInt(str.slice(idx + 2, idx + 6), 16));
+                const next_idx = str.indexOf('\\U', idx + 6);
+                if (next_idx === idx + 6) {
+                    idx = next_idx;
+                    continue;
+                }
+                str =
+                    str.slice(0, start_idx) +
+                        String.fromCodePoint(...codepoints) +
+                        str.slice(idx + 6);
+                codepoints = [];
+                idx = str.indexOf('\\U'); // slight inefficiency?
+                start_idx = idx;
+            }
+            editedTrans.remittanceInformationUnstructured = str;
+        }
+        editedTrans.date = transaction.valueDate || transaction.bookingDate;
+        return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+    },
+};

package/build/src/app-gocardless/banks/ing_ingbrobu.js

@@ -0,0 +1,56 @@
+import Fallback from './integration-bank.js';
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+    ...Fallback,
+    institutionIds: ['ING_INGBROBU'],
+    normalizeTransaction(transaction, booked) {
+        const editedTrans = { ...transaction };
+        //Merchant transactions all have the same transactionId of 'NOTPROVIDED'.
+        //For booked transactions, this can be set to the internalTransactionId
+        //For pending transactions, this needs to be removed for them to show up in Actual
+        //For deduplication to work better, payeeName needs to be standardized
+        //and converted from a pending transaction form ("payeeName":"Card no: xxxxxxxxxxxx1111"') to a booked transaction form ("payeeName":"Card no: Xxxx Xxxx Xxxx 1111")
+        if (transaction.transactionId === 'NOTPROVIDED') {
+            //Some corner case transactions only have the `proprietaryBankTransactionCode` field, this need to be copied to `remittanceInformationUnstructured`
+            if (transaction.proprietaryBankTransactionCode &&
+                !transaction.remittanceInformationUnstructured) {
+                editedTrans.remittanceInformationUnstructured =
+                    transaction.proprietaryBankTransactionCode;
+            }
+            if (booked) {
+                transaction.transactionId = transaction.internalTransactionId;
+                if (transaction.remittanceInformationUnstructured &&
+                    transaction.remittanceInformationUnstructured
+                        .toLowerCase()
+                        .includes('card no:')) {
+                    editedTrans.creditorName =
+                        transaction.remittanceInformationUnstructured.split(',')[0];
+                    //Catch all case for other types of payees
+                }
+                else {
+                    editedTrans.creditorName =
+                        transaction.remittanceInformationUnstructured;
+                }
+            }
+            else {
+                transaction.transactionId = null;
+                if (transaction.remittanceInformationUnstructured &&
+                    transaction.remittanceInformationUnstructured
+                        .toLowerCase()
+                        .includes('card no:')) {
+                    editedTrans.creditorName =
+                        transaction.remittanceInformationUnstructured.replace(/x{4}/g, 'Xxxx ');
+                    //Catch all case for other types of payees
+                }
+                else {
+                    editedTrans.creditorName =
+                        transaction.remittanceInformationUnstructured;
+                }
+                //Remove remittanceInformationUnstructured from pending transactions, so the `notes` field remains empty (there is no merchant information)
+                //Once booked, the right `notes` (containing the merchant) will be populated
+                editedTrans.remittanceInformationUnstructured = null;
+            }
+        }
+        return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+    },
+};

package/build/src/app-gocardless/banks/ing_ingddeff.js

@@ -0,0 +1,34 @@
+import { amountToInteger } from '../utils.js';
+import Fallback from './integration-bank.js';
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+    ...Fallback,
+    institutionIds: ['ING_INGDDEFF'],
+    normalizeTransaction(transaction, booked) {
+        const editedTrans = { ...transaction };
+        const remittanceInformationMatch = /remittanceinformation:(.*)$/.exec(transaction.remittanceInformationUnstructured);
+        editedTrans.remittanceInformationUnstructured = remittanceInformationMatch
+            ? remittanceInformationMatch[1]
+            : transaction.remittanceInformationUnstructured;
+        return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+    },
+    sortTransactions(transactions = []) {
+        return transactions.sort((a, b) => {
+            const diff = +new Date(b.valueDate || b.bookingDate) -
+                +new Date(a.valueDate || a.bookingDate);
+            if (diff)
+                return diff;
+            const idA = parseInt(a.transactionId);
+            const idB = parseInt(b.transactionId);
+            if (!isNaN(idA) && !isNaN(idB))
+                return idB - idA;
+            return 0;
+        });
+    },
+    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/build/src/app-gocardless/banks/ing_pl_ingbplpw.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: ['ING_PL_INGBPLPW'],
+    normalizeTransaction(transaction, booked) {
+        const editedTrans = { ...transaction };
+        editedTrans.date = transaction.valueDate;
+        return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+    },
+    sortTransactions(transactions = []) {
+        return transactions.sort((a, b) => {
+            return (Number(b.transactionId.substr(2)) - Number(a.transactionId.substr(2)));
+        });
+    },
+    calculateStartingBalance(sortedTransactions = [], balances = []) {
+        if (sortedTransactions.length) {
+            const oldestTransaction = sortedTransactions[sortedTransactions.length - 1];
+            const oldestKnownBalance = amountToInteger(oldestTransaction.balanceAfterTransaction.balanceAmount.amount);
+            const oldestTransactionAmount = amountToInteger(oldestTransaction.transactionAmount.amount);
+            return oldestKnownBalance - oldestTransactionAmount;
+        }
+        else {
+            return amountToInteger(balances.find(balance => 'interimBooked' === balance.balanceType)
+                .balanceAmount.amount);
+        }
+    },
+};

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

@@ -0,0 +1,78 @@
+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/build/src/app-gocardless/banks/isybank_itbbitmm.js

@@ -0,0 +1,13 @@
+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/build/src/app-gocardless/banks/kbc_kredbebb.js

@@ -0,0 +1,26 @@
+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/build/src/app-gocardless/banks/lhv-lhvbee22.js

@@ -0,0 +1,24 @@
+import * as 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/build/src/app-gocardless/banks/mbank_retail_brexplpw.js

@@ -0,0 +1,41 @@
+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/build/src/app-gocardless/banks/nationwide_naiagb21.js

@@ -0,0 +1,32 @@
+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/build/src/app-gocardless/banks/nbg_ethngraaxxx.js

@@ -0,0 +1,39 @@
+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));
+    },
+};