A local-first personal finance app
Backend integration with Nordigen - account sync (#74)
Filip Stybel19cd163b30f2
diff --git a/.gitignore b/.gitignoreindex b76a64a964..b1d1b52a59 100644--- a/.gitignore+++ b/.gitignore@@ -23,3 +23,8 @@ build/!.yarn/releases!.yarn/sdks!.yarn/versions++dist+.idea+/coverage+/coverage-e2ediff --git a/babel.config.json b/babel.config.jsonnew file mode 100644index 0000000000..64363362bf--- /dev/null+++ b/babel.config.json@@ -0,0 +1,3 @@+{+ "presets": ["@babel/preset-flow"]+}diff --git a/jest.config.json b/jest.config.jsonindex b1ea03d77e..396e05b0d9 100644--- a/jest.config.json+++ b/jest.config.json@@ -1,4 +1,14 @@{- "setupFiles": ["./jest.setup.js"],- "testPathIgnorePatterns": ["/node_modules/", "/build/"]+ "setupFiles": ["./jest.setup.js"],+ "testPathIgnorePatterns": ["dist", "/node_modules/", "/build/"],+ "roots": ["<rootDir>"],+ "testMatch": ["<rootDir>/**/*.spec.js"],+ "moduleFileExtensions": ["ts", "js", "json"],+ "testEnvironment": "node",+ "collectCoverage": true,+ "collectCoverageFrom": ["**/*.{js,ts,tsx}"],+ "coveragePathIgnorePatterns": ["dist", "/node_modules/", "/build/"],+ "coverageReporters": ["html", "lcov", "text", "text-summary"],+ "resetMocks": true,+ "restoreMocks": true}diff --git a/package.json b/package.jsonindex 6d84cb6439..1bbd64e871 100644--- a/package.json+++ b/package.json@@ -8,7 +8,7 @@"start": "node app","lint": "eslint .","build": "tsc",- "test": "NODE_OPTIONS='--experimental-vm-modules --trace-warnings' jest",+ "test": "NODE_ENV=test NODE_OPTIONS='--experimental-vm-modules --trace-warnings' jest --coverage","types": "tsc --noEmit --incremental","verify": "yarn -s lint && yarn types"},@@ -22,9 +22,11 @@"express": "4.18.2","express-actuator": "1.8.4","express-response-size": "^0.0.3",+ "nordigen-node": "^1.2.3","uuid": "^9.0.0"},"devDependencies": {+ "@babel/preset-flow": "^7.18.6","@types/bcrypt": "^5.0.0","@types/better-sqlite3": "^7.5.0","@types/cors": "^2.8.13",diff --git a/src/app-nordigen/README.md b/src/app-nordigen/README.mdnew file mode 100644index 0000000000..74f11c3bd4--- /dev/null+++ b/src/app-nordigen/README.md@@ -0,0 +1,61 @@+# Integration new bank++Find in [doc](https://docs.google.com/spreadsheets/d/1ogpzydzotOltbssrc3IQ8rhBLlIZbQgm5QCiiNJrkyA/edit#gid=489769432) what is id of bank which you want to integrate++Add the `institution_id` and your name to list of possible options in the frontend+project `actual/packages/loot-design/src/components/modals/NordigenExternalMsg.js`++```jsx+<Strong>Choose your banks:</Strong>+<CustomSelect+ options={[+ ['default', 'Choose your bank'],+ ['ING_PL_INGBPLPW', 'ING PL'],+ ['MBANK_RETAIL_BREXPLPW', 'MBANK'],+ ['SANDBOXFINANCE_SFIN0000', 'DEMO - TEST']+ ]}+```++Launch frontend and backend server++Create new linked account selecting the institution which you added recently.++In the server logs you can find all required information to create class for+your bank.++Create new a bank class based on `app-nordigen/banks/sandboxfinance-sfin0000.js`. Name of the file and class should be+created based on the ID of the integrated institution.++Fill the logic of `normalizeAccount`, `sortTransactions`, and `calculateStartingBalance` functions.+You should do it based on the data which you found in the logs.++Example logs which help you to fill:++- `normalizeAccount` function:++```log+Available account properties for new institution integration {+ account: '{"iban":"PL00000000000000000987654321","currency":"PLN","ownerName":"John Example","displayName":"Product name","product":"Daily account","usage":"PRIV","ownerAddressUnstructured":["POL","UL. Example 1","00-000 Warsaw"],"id":"XXXXXXXX-XXXX-XXXXX-XXXXXX-XXXXXXXXX","created":"2023-01-18T12:15:16.502446Z","last_accessed":null,"institution_id":"MBANK_RETAIL_BREXPLPW","status":"READY","owner_name":"","institution":{"id":"MBANK_RETAIL_BREXPLPW","name":"mBank Retail","bic":"BREXPLPW","transaction_total_days":"90","countries":["PL"],"logo":"https://cdn.nordigen.com/ais/MBANK_RETAIL_BREXCZPP.png","supported_payments":{},"supported_features":["access_scopes","business_accounts","card_accounts","corporate_accounts","pending_transactions","private_accounts"]}}'+}+```++- `sortTransactions` function:++```log+Available (first 10) transactions properties for new integration of institution in sortTransactions function {+ top10SortedTransactions: '[{"transactionId":"20220101001","bookingDate":"2022-01-01","valueDate":"2022-01-01","transactionAmount":{"amount":"5.01","currency":"EUR"},"creditorName":"JOHN EXAMPLE","creditorAccount":{"iban":"PL00000000000000000987654321"},"debtorName":"CHRIS EXAMPLE","debtorAccount":{"iban":"PL12345000000000000987654321"},"remittanceInformationUnstructured":"TEST BANK TRANSFER","remittanceInformationUnstructuredArray":["TEST BANK TRANSFER"],"balanceAfterTransaction":{"balanceAmount":{"amount":"448.52","currency":"EUR"},"balanceType":"interimBooked"},"internalTransactionId":"casfib7720c2a02c0331cw2"}]'+}+```++- `calculateStartingBalance` function:++```log+Available (first 10) transactions properties for new integration of institution in calculateStartingBalance function {+ balances: '[{"balanceAmount":{"amount":"448.52","currency":"EUR"},"balanceType":"forwardAvailable"},{"balanceAmount":{"amount":"448.52","currency":"EUR"},"balanceType":"interimBooked"}]',+ top10SortedTransactions: '[{"transactionId":"20220101001","bookingDate":"2022-01-01","valueDate":"2022-01-01","transactionAmount":{"amount":"5.01","currency":"EUR"},"creditorName":"JOHN EXAMPLE","creditorAccount":{"iban":"PL00000000000000000987654321"},"debtorName":"CHRIS EXAMPLE","debtorAccount":{"iban":"PL12345000000000000987654321"},"remittanceInformationUnstructured":"TEST BANK TRANSFER","remittanceInformationUnstructuredArray":["TEST BANK TRANSFER"],"balanceAfterTransaction":{"balanceAmount":{"amount":"448.52","currency":"EUR"},"balanceType":"interimBooked"},"internalTransactionId":"casfib7720c2a02c0331cw2"}]'+}+```++Add new bank integration to `BankFactory` class in file `actual-server/app-nordigen/bank-factory.js`++Remember to add tests for new bank integration indiff --git a/src/app-nordigen/app-nordigen.js b/src/app-nordigen/app-nordigen.jsnew file mode 100644index 0000000000..999638b213--- /dev/null+++ b/src/app-nordigen/app-nordigen.js@@ -0,0 +1,166 @@+import express from 'express';++import { nordigenService } from './services/nordigen-service.js';+import {+ RequisitionNotLinked,+ AccountNotLinedToRequisition,+ GenericNordigenError+} from './errors.js';+import { handleError } from './util/handle-error.js';+import validateUser from '../util/validate-user.js';++const app = express();+export { app as handlers };+app.use(express.json());+app.use(async (req, res, next) => {+ let user = await validateUser(req, res);+ if (!user) {+ return;+ }+ next();+});++app.post(+ '/create-web-token',+ handleError(async (req, res) => {+ const { accessValidForDays, institutionId } = req.body;+ const { origin } = req.headers;++ const { link, requisitionId } = await nordigenService.createRequisition({+ accessValidForDays,+ institutionId,+ host: origin+ });++ res.send({+ status: 'ok',+ data: {+ link,+ requisitionId+ }+ });+ })+);++app.post(+ '/get-accounts',+ handleError(async (req, res) => {+ const { requisitionId } = req.body;++ try {+ const { requisition, accounts } =+ await nordigenService.getRequisitionWithAccounts(requisitionId);++ res.send({+ status: 'ok',+ data: {+ ...requisition,+ accounts+ }+ });+ } catch (error) {+ if (error instanceof RequisitionNotLinked) {+ res.send({+ status: 'ok',+ requisitionStatus: error.details.requisitionStatus+ });+ } else {+ throw error;+ }+ }+ })+);++app.post(+ '/remove-account',+ handleError(async (req, res) => {+ let { requisitionId } = req.body;++ const data = await nordigenService.deleteRequisition(requisitionId);+ if (data.summary === 'Requisition deleted') {+ res.send({+ status: 'ok',+ data+ });+ } else {+ res.send({+ status: 'error',+ data: {+ data,+ reason: 'Can not delete requisition'+ }+ });+ }+ })+);++app.post(+ '/transactions',+ handleError(async (req, res) => {+ const { requisitionId, startDate, endDate, accountId } = req.body;++ try {+ const {+ balances,+ institutionId,+ startingBalance,+ transactions: { booked, pending }+ } = await nordigenService.getTransactionsWithBalance(+ requisitionId,+ accountId,+ startDate,+ endDate+ );++ res.send({+ status: 'ok',+ data: {+ balances,+ institutionId,+ startingBalance,+ transactions: {+ booked,+ pending+ }+ }+ });+ } catch (error) {+ const sendErrorResponse = (data) =>+ res.send({ status: 'ok', data: { ...data, details: error.details } });++ switch (true) {+ case error instanceof RequisitionNotLinked:+ sendErrorResponse({+ error_type: 'ITEM_ERROR',+ error_code: 'ITEM_LOGIN_REQUIRED',+ status: 'expired',+ reason: 'Access to account has expired as set in End User Agreement'+ });+ break;+ case error instanceof AccountNotLinedToRequisition:+ sendErrorResponse({+ error_type: 'INVALID_INPUT',+ error_code: 'INVALID_ACCESS_TOKEN',+ status: 'rejected',+ reason: 'Account not linked with this requisition'+ });+ break;+ case error instanceof GenericNordigenError:+ console.log({ message: 'Something went wrong', error });+ sendErrorResponse({+ error_type: 'SYNC_ERROR',+ error_code: 'NORDIGEN_ERROR'+ });+ break;+ default:+ console.log({ message: 'Something went wrong', error });+ sendErrorResponse({+ error_type: 'UNKNOWN',+ error_code: 'UNKNOWN',+ reason: 'Something went wrong'+ });+ break;+ }+ }+ })+);diff --git a/src/app-nordigen/bank-factory.js b/src/app-nordigen/bank-factory.jsnew file mode 100644index 0000000000..fb902d9d75--- /dev/null+++ b/src/app-nordigen/bank-factory.js@@ -0,0 +1,9 @@+import IngPlIngbplpw from './banks/ing-pl-ingbplpw.js';+import IntegrationBank from './banks/integration-bank.js';+import MbankRetailBrexplpw from './banks/mbank-retail-brexplpw.js';+import SandboxfinanceSfin0000 from './banks/sandboxfinance-sfin0000.js';++const banks = [MbankRetailBrexplpw, SandboxfinanceSfin0000, IngPlIngbplpw];++export default (institutionId) =>+ banks.find((b) => b.institutionId === institutionId) || IntegrationBank;diff --git a/src/app-nordigen/banks/bank.interface.ts b/src/app-nordigen/banks/bank.interface.tsnew file mode 100644index 0000000000..788709e43e--- /dev/null+++ b/src/app-nordigen/banks/bank.interface.ts@@ -0,0 +1,28 @@+import {+ DetailedAccountWithInstitution,+ NormalizedAccountDetails+} from '../nordigen.types.js';+import { Transaction, Balance } from '../nordigen-node.types.js';++export interface IBank {+ institutionId: string;+ /**+ * Returns normalized object with required data for the frontend+ */+ normalizeAccount: (+ account: DetailedAccountWithInstitution+ ) => NormalizedAccountDetails;++ /**+ * Function sorts an array of transactions from newest to oldest+ */+ sortTransactions: (transactions: Transaction[]) => Transaction[];++ /**+ * Calculates account balance before which was before transactions provided in sortedTransactions param+ */+ calculateStartingBalance: (+ sortedTransactions: Transaction[],+ balances: Balance[]+ ) => number;+}diff --git a/src/app-nordigen/banks/ing-pl-ingbplpw.js b/src/app-nordigen/banks/ing-pl-ingbplpw.jsnew file mode 100644index 0000000000..1a90ae4faa--- /dev/null+++ b/src/app-nordigen/banks/ing-pl-ingbplpw.js@@ -0,0 +1,45 @@+import { printIban, amountToInteger } from '../utils.js';++/** @type {import('./bank.interface.js').IBank} */+export default {+ institutionId: 'ING_PL_INGBPLPW',++ normalizeAccount(account) {+ return {+ account_id: account.id,+ institution: account.institution,+ mask: account.iban.slice(-4),+ name: [account.product, printIban(account)].join(' ').trim(),+ official_name: account.product,+ type: 'checking'+ };+ },++ 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+ );+ }+ }+};diff --git a/src/app-nordigen/banks/integration-bank.js b/src/app-nordigen/banks/integration-bank.jsnew file mode 100644index 0000000000..c421082427--- /dev/null+++ b/src/app-nordigen/banks/integration-bank.js@@ -0,0 +1,38 @@+import { sortByBookingDate } from '../utils.js';++/** @type {import('./bank.interface.js').IBank} */+export default {+ institutionId: 'IntegrationBank',+ normalizeAccount(account) {+ console.log(+ '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),+ name: `integration-${account.institution_id}`,+ official_name: `integration-${account.institution_id}`,+ type: 'checking'+ };+ },+ sortTransactions(transactions = []) {+ console.log(+ 'Available (first 10) transactions properties for new integration of institution in sortTransactions function',+ { top10Transactions: JSON.stringify(transactions.slice(0, 10)) }+ );+ return sortByBookingDate(transactions);+ },+ calculateStartingBalance(sortedTransactions = [], balances = []) {+ console.log(+ 'Available (first 10) transactions properties for new integration of institution in calculateStartingBalance function',+ {+ balances: JSON.stringify(balances),+ top10SortedTransactions: JSON.stringify(sortedTransactions.slice(0, 10))+ }+ );+ return 0;+ }+};diff --git a/src/app-nordigen/banks/mbank-retail-brexplpw.js b/src/app-nordigen/banks/mbank-retail-brexplpw.jsnew file mode 100644index 0000000000..af54f3d65c--- /dev/null+++ b/src/app-nordigen/banks/mbank-retail-brexplpw.js@@ -0,0 +1,41 @@+import { printIban, amountToInteger } from '../utils.js';++/** @type {import('./bank.interface.js').IBank} */+export default {+ institutionId: 'MBANK_RETAIL_BREXPLPW',++ normalizeAccount(account) {+ return {+ account_id: account.id,+ institution: account.institution,+ mask: account.iban.slice(-4),+ name: [account.displayName, printIban(account)].join(' '),+ official_name: account.product,+ type: 'checking'+ };+ },++ 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));+ }+};diff --git a/src/app-nordigen/banks/sandboxfinance-sfin0000.js b/src/app-nordigen/banks/sandboxfinance-sfin0000.jsnew file mode 100644index 0000000000..253e6de715--- /dev/null+++ b/src/app-nordigen/banks/sandboxfinance-sfin0000.js@@ -0,0 +1,44 @@+import { printIban, amountToInteger } from '../utils.js';++/** @type {import('./bank.interface.js').IBank} */+export default {+ institutionId: 'SANDBOXFINANCE_SFIN0000',++ normalizeAccount(account) {+ return {+ account_id: account.id,+ institution: account.institution,+ mask: account.iban.slice(-4),+ name: [account.name, printIban(account)].join(' '),+ official_name: account.product,+ type: 'checking'+ };+ },++ sortTransactions(transactions = []) {+ return transactions.sort((a, b) => {+ const [aTime, aSeq] = a.transactionId.split('-');+ const [bTime, bSeq] = b.transactionId.split('-');++ return Number(bTime) - Number(aTime) || Number(bSeq) - Number(aSeq);+ });+ },++ /**+ * 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));+ }+};diff --git a/src/app-nordigen/banks/tests/ing-pl-ingbplpw.spec.js b/src/app-nordigen/banks/tests/ing-pl-ingbplpw.spec.jsnew file mode 100644index 0000000000..9a724582fe--- /dev/null+++ b/src/app-nordigen/banks/tests/ing-pl-ingbplpw.spec.js@@ -0,0 +1,199 @@+import IngPlIngbplpw from '../ing-pl-ingbplpw.js';+import { mockTransactionAmount } from '../../services/tests/fixtures.js';++describe('IngPlIngbplpw', () => {+ describe('#normalizeAccount', () => {+ /** @type {import('../../nordigen.types.js').DetailedAccountWithInstitution} */+ const accountRaw = {+ resourceId: 'PL00000000000000000987654321',+ iban: 'PL00000000000000000987654321',+ currency: 'PLN',+ ownerName: 'John Example',+ product: 'Current Account for Individuals (Retail)',+ bic: 'INGBPLPW',+ ownerAddressUnstructured: [+ 'UL. EXAMPLE STREET 10 M.1',+ '00-000 WARSZAWA'+ ],+ id: 'd3eccc94-9536-48d3-98be-813f79199ee3',+ created: '2022-07-24T20:45:47.929582Z',+ last_accessed: '2023-01-24T22:12:00.193558Z',+ institution_id: 'ING_PL_INGBPLPW',+ status: 'READY',+ owner_name: '',+ institution: {+ id: 'ING_PL_INGBPLPW',+ name: 'ING',+ bic: 'INGBPLPW',+ transaction_total_days: '365',+ countries: ['PL'],+ logo: 'https://cdn.nordigen.com/ais/ING_PL_INGBPLPW.png',+ supported_payments: {},+ supported_features: [+ 'access_scopes',+ 'business_accounts',+ 'card_accounts',+ 'corporate_accounts',+ 'pending_transactions',+ 'private_accounts'+ ]+ }+ };++ it('returns normalized account data returned to Frontend', () => {+ const normalizedAccount = IngPlIngbplpw.normalizeAccount(accountRaw);+ expect(normalizedAccount).toMatchInlineSnapshot(`+ {+ "account_id": "d3eccc94-9536-48d3-98be-813f79199ee3",+ "institution": {+ "bic": "INGBPLPW",+ "countries": [+ "PL",+ ],+ "id": "ING_PL_INGBPLPW",+ "logo": "https://cdn.nordigen.com/ais/ING_PL_INGBPLPW.png",+ "name": "ING",+ "supported_features": [+ "access_scopes",+ "business_accounts",+ "card_accounts",+ "corporate_accounts",+ "pending_transactions",+ "private_accounts",+ ],+ "supported_payments": {},+ "transaction_total_days": "365",+ },+ "mask": "4321",+ "name": "Current Account for Individuals (Retail) (XXX 4321)",+ "official_name": "Current Account for Individuals (Retail)",+ "type": "checking",+ }+ `);+ });+ });++ describe('#sortTransactions', () => {+ it('sorts transactions by time and sequence from newest to oldest', () => {+ const transactions = [+ {+ transactionId: 'D202301180000003',+ transactionAmount: mockTransactionAmount+ },+ {+ transactionId: 'D202301180000004',+ transactionAmount: mockTransactionAmount+ },+ {+ transactionId: 'D202301230000001',+ transactionAmount: mockTransactionAmount+ },+ {+ transactionId: 'D202301180000002',+ transactionAmount: mockTransactionAmount+ },+ {+ transactionId: 'D202301200000001',+ transactionAmount: mockTransactionAmount+ }+ ];+ const sortedTransactions = IngPlIngbplpw.sortTransactions(transactions);+ expect(sortedTransactions).toEqual([+ {+ transactionId: 'D202301230000001',+ transactionAmount: mockTransactionAmount+ },+ {+ transactionId: 'D202301200000001',+ transactionAmount: mockTransactionAmount+ },+ {+ transactionId: 'D202301180000004',+ transactionAmount: mockTransactionAmount+ },+ {+ transactionId: 'D202301180000003',+ transactionAmount: mockTransactionAmount+ },+ {+ transactionId: 'D202301180000002',+ transactionAmount: mockTransactionAmount+ }+ ]);+ });++ it('handles empty arrays', () => {+ const transactions = [];+ const sortedTransactions = IngPlIngbplpw.sortTransactions(transactions);+ expect(sortedTransactions).toEqual([]);+ });++ it('returns empty array for undefined input', () => {+ const sortedTransactions = IngPlIngbplpw.sortTransactions(undefined);+ expect(sortedTransactions).toEqual([]);+ });+ });++ describe('#countStartingBalance', () => {+ it('should calculate the starting balance correctly', () => {+ /** @type {import('../../nordigen-node.types.js').Transaction[]} */+ const sortedTransactions = [+ {+ transactionAmount: { amount: '-100.00', currency: 'USD' },+ balanceAfterTransaction: {+ balanceAmount: { amount: '400.00', currency: 'USD' },+ balanceType: 'interimBooked'+ }+ },+ {+ transactionAmount: { amount: '50.00', currency: 'USD' },+ balanceAfterTransaction: {+ balanceAmount: { amount: '450.00', currency: 'USD' },+ balanceType: 'interimBooked'+ }+ },+ {+ transactionAmount: { amount: '-25.00', currency: 'USD' },+ balanceAfterTransaction: {+ balanceAmount: { amount: '475.00', currency: 'USD' },+ balanceType: 'interimBooked'+ }+ }+ ];++ /** @type {import('../../nordigen-node.types.js').Balance[]} */+ const balances = [+ {+ balanceType: 'interimBooked',+ balanceAmount: { amount: '500.00', currency: 'USD' }+ },+ {+ balanceType: 'closingBooked',+ balanceAmount: { amount: '600.00', currency: 'USD' }+ }+ ];++ const startingBalance = IngPlIngbplpw.calculateStartingBalance(+ sortedTransactions,+ balances+ );++ expect(startingBalance).toEqual(50000);+ });++ it('returns the same balance amount when no transactions', () => {+ const transactions = [];++ /** @type {import('../../nordigen-node.types.js').Balance[]} */+ const balances = [+ {+ balanceType: 'interimBooked',+ balanceAmount: { amount: '500.00', currency: 'USD' }+ }+ ];+ expect(+ IngPlIngbplpw.calculateStartingBalance(transactions, balances)+ ).toEqual(50000);+ });+ });+});diff --git a/src/app-nordigen/banks/tests/integration-bank.spec.js b/src/app-nordigen/banks/tests/integration-bank.spec.jsnew file mode 100644index 0000000000..6506217d0f--- /dev/null+++ b/src/app-nordigen/banks/tests/integration-bank.spec.js@@ -0,0 +1,155 @@+import { jest } from '@jest/globals';+import IntegrationBank from '../integration-bank.js';+import {+ mockExtendAccountsAboutInstitutions,+ mockInstitution+} from '../../services/tests/fixtures.js';++describe('IntegrationBank', () => {+ let consoleSpy;++ beforeEach(() => {+ consoleSpy = jest.spyOn(console, 'log');+ });++ describe('normalizeAccount', () => {+ const account = mockExtendAccountsAboutInstitutions[0];++ it('should return a normalized account object', () => {+ const normalizedAccount = IntegrationBank.normalizeAccount(account);+ expect(normalizedAccount).toEqual({+ account_id: account.id,+ institution: mockInstitution,+ mask: '4321',+ name: 'integration-SANDBOXFINANCE_SFIN0000',+ official_name: 'integration-SANDBOXFINANCE_SFIN0000',+ type: 'checking'+ });+ });++ it('should return a normalized account object with masked value "0000" when no iban property is provided', () => {+ const normalizedAccount = IntegrationBank.normalizeAccount({+ ...account,+ iban: undefined+ });+ expect(normalizedAccount).toEqual({+ account_id: account.id,+ institution: mockInstitution,+ mask: '0000',+ name: 'integration-SANDBOXFINANCE_SFIN0000',+ official_name: 'integration-SANDBOXFINANCE_SFIN0000',+ type: 'checking'+ });+ });++ it('normalizeAccount logs available account properties', () => {+ IntegrationBank.normalizeAccount(account);+ expect(consoleSpy).toHaveBeenCalledWith(+ 'Available account properties for new institution integration',+ {+ account: JSON.stringify(account)+ }+ );+ });+ });++ describe('sortTransactions', () => {+ const transactions = [+ {+ date: '2022-01-01',+ bookingDate: '2022-01-01',+ transactionAmount: { amount: '100', currency: 'EUR' }+ },+ {+ date: '2022-01-03',+ bookingDate: '2022-01-03',+ transactionAmount: { amount: '100', currency: 'EUR' }+ },+ {+ date: '2022-01-02',+ bookingDate: '2022-01-02',+ transactionAmount: { amount: '100', currency: 'EUR' }+ }+ ];+ const sortedTransactions = [+ {+ date: '2022-01-03',+ bookingDate: '2022-01-03',+ transactionAmount: { amount: '100', currency: 'EUR' }+ },+ {+ date: '2022-01-02',+ bookingDate: '2022-01-02',+ transactionAmount: { amount: '100', currency: 'EUR' }+ },+ {+ date: '2022-01-01',+ bookingDate: '2022-01-01',+ transactionAmount: { amount: '100', currency: 'EUR' }+ }+ ];++ it('should return transactions sorted by bookingDate', () => {+ const sortedTransactions = IntegrationBank.sortTransactions(transactions);+ expect(sortedTransactions).toEqual(sortedTransactions);+ });++ it('sortTransactions logs available transactions properties', () => {+ IntegrationBank.sortTransactions(transactions);+ expect(consoleSpy).toHaveBeenCalledWith(+ 'Available (first 10) transactions properties for new integration of institution in sortTransactions function',+ { top10Transactions: JSON.stringify(sortedTransactions.slice(0, 10)) }+ );+ });+ });++ describe('calculateStartingBalance', () => {+ /** @type {import('../../nordigen-node.types.js').Transaction[]} */+ const transactions = [+ {+ bookingDate: '2022-01-01',+ transactionAmount: { amount: '100', currency: 'EUR' }+ },+ {+ bookingDate: '2022-02-01',+ transactionAmount: { amount: '100', currency: 'EUR' }+ },+ {+ bookingDate: '2022-03-01',+ transactionAmount: { amount: '100', currency: 'EUR' }+ }+ ];++ /** @type {import('../../nordigen-node.types.js').Balance[]} */+ const balances = [+ {+ balanceAmount: { amount: '1000.00', currency: 'EUR' },+ balanceType: 'interimBooked'+ }+ ];++ it('should return 0 when no transactions or balances are provided', () => {+ const startingBalance = IntegrationBank.calculateStartingBalance([], []);+ expect(startingBalance).toEqual(0);+ });++ it('should return 0 when transactions and balances are provided', () => {+ const startingBalance = IntegrationBank.calculateStartingBalance(+ transactions,+ balances+ );+ expect(startingBalance).toEqual(0);+ });++ it('logs available transactions and balances properties', () => {+ IntegrationBank.calculateStartingBalance(transactions, balances);+ expect(consoleSpy).toHaveBeenCalledWith(+ 'Available (first 10) transactions properties for new integration of institution in calculateStartingBalance function',+ {+ balances: JSON.stringify(balances),+ top10SortedTransactions: JSON.stringify(transactions.slice(0, 10))+ }+ );+ });+ });+});diff --git a/src/app-nordigen/banks/tests/mbank-retail-brexplpw.spec.js b/src/app-nordigen/banks/tests/mbank-retail-brexplpw.spec.jsnew file mode 100644index 0000000000..54229745b8--- /dev/null+++ b/src/app-nordigen/banks/tests/mbank-retail-brexplpw.spec.js@@ -0,0 +1,168 @@+import MbankRetailBrexplpw from '../mbank-retail-brexplpw.js';++describe('MbankRetailBrexplpw', () => {+ describe('#normalizeAccount', () => {+ /** @type {import('../../nordigen.types.js').DetailedAccountWithInstitution} */+ const accountRaw = {+ iban: 'PL00000000000000000987654321',+ currency: 'PLN',+ ownerName: 'John Example',+ displayName: 'EKONTO',+ product: 'RACHUNEK BIEŻĄCY',+ usage: 'PRIV',+ ownerAddressUnstructured: [+ 'POL',+ 'UL. EXAMPLE STREET 10 M.1',+ '00-000 WARSZAWA'+ ],+ id: 'd3eccc94-9536-48d3-98be-813f79199ee3',+ created: '2023-01-18T13:24:55.879512Z',+ last_accessed: null,+ institution_id: 'MBANK_RETAIL_BREXPLPW',+ status: 'READY',+ owner_name: '',+ institution: {+ id: 'MBANK_RETAIL_BREXPLPW',+ name: 'mBank Retail',+ bic: 'BREXPLPW',+ transaction_total_days: '90',+ countries: ['PL'],+ logo: 'https://cdn.nordigen.com/ais/MBANK_RETAIL_BREXCZPP.png',+ supported_payments: {},+ supported_features: [+ 'access_scopes',+ 'business_accounts',+ 'card_accounts',+ 'corporate_accounts',+ 'pending_transactions',+ 'private_accounts'+ ]+ }+ };+ it('returns normalized account data returned to Frontend', () => {+ expect(MbankRetailBrexplpw.normalizeAccount(accountRaw))+ .toMatchInlineSnapshot(`+ {+ "account_id": "d3eccc94-9536-48d3-98be-813f79199ee3",+ "institution": {+ "bic": "BREXPLPW",+ "countries": [+ "PL",+ ],+ "id": "MBANK_RETAIL_BREXPLPW",+ "logo": "https://cdn.nordigen.com/ais/MBANK_RETAIL_BREXCZPP.png",+ "name": "mBank Retail",+ "supported_features": [+ "access_scopes",+ "business_accounts",+ "card_accounts",+ "corporate_accounts",+ "pending_transactions",+ "private_accounts",+ ],+ "supported_payments": {},+ "transaction_total_days": "90",+ },+ "mask": "4321",+ "name": "EKONTO (XXX 4321)",+ "official_name": "RACHUNEK BIEŻĄCY",+ "type": "checking",+ }+ `);+ });+ });++ describe('#sortTransactions', () => {+ it('returns transactions from newest to oldest', () => {+ const sortedTransactions = MbankRetailBrexplpw.sortTransactions([+ {+ transactionId: '202212300001',+ transactionAmount: { amount: '100', currency: 'EUR' }+ },+ {+ transactionId: '202212300003',+ transactionAmount: { amount: '100', currency: 'EUR' }+ },+ {+ transactionId: '202212300002',+ transactionAmount: { amount: '100', currency: 'EUR' }+ },+ {+ transactionId: '202212300000',+ transactionAmount: { amount: '100', currency: 'EUR' }+ },+ {+ transactionId: '202112300001',+ transactionAmount: { amount: '100', currency: 'EUR' }+ }+ ]);++ expect(sortedTransactions).toEqual([+ {+ transactionId: '202212300003',+ transactionAmount: { amount: '100', currency: 'EUR' }+ },+ {+ transactionId: '202212300002',+ transactionAmount: { amount: '100', currency: 'EUR' }+ },+ {+ transactionId: '202212300001',+ transactionAmount: { amount: '100', currency: 'EUR' }+ },+ {+ transactionId: '202212300000',+ transactionAmount: { amount: '100', currency: 'EUR' }+ },+ {+ transactionId: '202112300001',+ transactionAmount: { amount: '100', currency: 'EUR' }+ }+ ]);+ });++ it('returns empty array for empty input', () => {+ const sortedTransactions = MbankRetailBrexplpw.sortTransactions([]);+ expect(sortedTransactions).toEqual([]);+ });++ it('returns empty array for undefined input', () => {+ const sortedTransactions =+ MbankRetailBrexplpw.sortTransactions(undefined);+ expect(sortedTransactions).toEqual([]);+ });+ });++ describe('#countStartingBalance', () => {+ /** @type {import('../../nordigen-node.types.js').Balance[]} */+ const balances = [+ {+ balanceAmount: { amount: '1000.00', currency: 'PLN' },+ balanceType: 'interimBooked'+ }+ ];++ it('returns the same balance amount when no transactions', () => {+ const transactions = [];++ expect(+ MbankRetailBrexplpw.calculateStartingBalance(transactions, balances)+ ).toEqual(100000);+ });++ it('returns the balance minus the available transactions', () => {+ const transactions = [+ {+ transactionAmount: { amount: '200.00', currency: 'PLN' }+ },+ {+ transactionAmount: { amount: '300.50', currency: 'PLN' }+ }+ ];++ expect(+ MbankRetailBrexplpw.calculateStartingBalance(transactions, balances)+ ).toEqual(49950);+ });+ });+});diff --git a/src/app-nordigen/banks/tests/sandboxfinance-sfin0000.spec.js b/src/app-nordigen/banks/tests/sandboxfinance-sfin0000.spec.jsnew file mode 100644index 0000000000..c1626a56cb--- /dev/null+++ b/src/app-nordigen/banks/tests/sandboxfinance-sfin0000.spec.js@@ -0,0 +1,180 @@+import SandboxfinanceSfin0000 from '../sandboxfinance-sfin0000.js';+import { mockTransactionAmount } from '../../services/tests/fixtures.js';++describe('SandboxfinanceSfin0000', () => {+ describe('#normalizeAccount', () => {+ /** @type {import('../../nordigen.types.js').DetailedAccountWithInstitution} */+ const accountRaw = {+ resourceId: '01F3NS5ASCNMVCTEJDT0G215YE',+ iban: 'GL0865354374424724',+ currency: 'EUR',+ ownerName: 'Jane Doe',+ name: 'Main Account',+ product: 'Checkings',+ cashAccountType: 'CACC',+ id: '99a0bfe2-0bef-46df-bff2-e9ae0c6c5838',+ created: '2022-02-21T13:43:55.608911Z',+ last_accessed: '2023-01-25T16:50:15.078264Z',+ institution_id: 'SANDBOXFINANCE_SFIN0000',+ status: 'READY',+ owner_name: 'Jane Doe',+ institution: {+ id: 'SANDBOXFINANCE_SFIN0000',+ name: 'Sandbox Finance',+ bic: 'SFIN0000',+ transaction_total_days: '90',+ countries: ['XX'],+ logo: 'https://cdn.nordigen.com/ais/SANDBOXFINANCE_SFIN0000.png',+ supported_payments: {},+ supported_features: []+ }+ };++ it('returns normalized account data returned to Frontend', () => {+ expect(SandboxfinanceSfin0000.normalizeAccount(accountRaw))+ .toMatchInlineSnapshot(`+ {+ "account_id": "99a0bfe2-0bef-46df-bff2-e9ae0c6c5838",+ "institution": {+ "bic": "SFIN0000",+ "countries": [+ "XX",+ ],+ "id": "SANDBOXFINANCE_SFIN0000",+ "logo": "https://cdn.nordigen.com/ais/SANDBOXFINANCE_SFIN0000.png",+ "name": "Sandbox Finance",+ "supported_features": [],+ "supported_payments": {},+ "transaction_total_days": "90",+ },+ "mask": "4724",+ "name": "Main Account (XXX 4724)",+ "official_name": "Checkings",+ "type": "checking",+ }+ `);+ });+ });++ describe('#sortTransactions', () => {+ it('sorts transactions by time and sequence from newest to oldest', () => {+ const transactions = [+ {+ transactionId: '2023012301927902-2',+ transactionAmount: mockTransactionAmount+ },+ {+ transactionId: '2023012301927902-1',+ transactionAmount: mockTransactionAmount+ },+ {+ transactionId: '2023012301927900-2',+ transactionAmount: mockTransactionAmount+ },+ {+ transactionId: '2023012301927900-1',+ transactionAmount: mockTransactionAmount+ },+ {+ transactionId: '2023012301927900-3',+ transactionAmount: mockTransactionAmount+ }+ ];+ const sortedTransactions =+ SandboxfinanceSfin0000.sortTransactions(transactions);+ expect(sortedTransactions).toEqual([+ {+ transactionId: '2023012301927902-2',+ transactionAmount: mockTransactionAmount+ },+ {+ transactionId: '2023012301927902-1',+ transactionAmount: mockTransactionAmount+ },+ {+ transactionId: '2023012301927900-3',+ transactionAmount: mockTransactionAmount+ },+ {+ transactionId: '2023012301927900-2',+ transactionAmount: mockTransactionAmount+ },+ {+ transactionId: '2023012301927900-1',+ transactionAmount: mockTransactionAmount+ }+ ]);+ });++ it('handles empty arrays', () => {+ const transactions = [];+ const sortedTransactions =+ SandboxfinanceSfin0000.sortTransactions(transactions);+ expect(sortedTransactions).toEqual([]);+ });++ it('returns empty array for undefined input', () => {+ const sortedTransactions =+ SandboxfinanceSfin0000.sortTransactions(undefined);+ expect(sortedTransactions).toEqual([]);+ });+ });++ describe('#countStartingBalance', () => {+ /** @type {import('../../nordigen-node.types.js').Balance[]} */+ const balances = [+ {+ balanceAmount: { amount: '1000.00', currency: 'PLN' },+ balanceType: 'interimAvailable'+ }+ ];++ it('should calculate the starting balance correctly', () => {+ const sortedTransactions = [+ {+ transactionId: '2022-01-01-1',+ transactionAmount: { amount: '-100.00', currency: 'USD' }+ },+ {+ transactionId: '2022-01-01-2',+ transactionAmount: { amount: '50.00', currency: 'USD' }+ },+ {+ transactionId: '2022-01-01-3',+ transactionAmount: { amount: '-25.00', currency: 'USD' }+ }+ ];++ const startingBalance = SandboxfinanceSfin0000.calculateStartingBalance(+ sortedTransactions,+ balances+ );++ expect(startingBalance).toEqual(107500);+ });++ it('returns the same balance amount when no transactions', () => {+ const transactions = [];++ expect(+ SandboxfinanceSfin0000.calculateStartingBalance(transactions, balances)+ ).toEqual(100000);+ });++ it('returns the balance minus the available transactions', () => {+ /** @type {import('../../nordigen-node.types.js').Transaction[]} */+ const transactions = [+ {+ transactionAmount: { amount: '200.00', currency: 'PLN' }+ },+ {+ transactionAmount: { amount: '300.50', currency: 'PLN' }+ }+ ];++ expect(+ SandboxfinanceSfin0000.calculateStartingBalance(transactions, balances)+ ).toEqual(49950);+ });+ });+});diff --git a/src/app-nordigen/errors.js b/src/app-nordigen/errors.jsnew file mode 100644index 0000000000..d3f9cc4ab4--- /dev/null+++ b/src/app-nordigen/errors.js@@ -0,0 +1,84 @@+export class RequisitionNotLinked extends Error {+ constructor(params = {}) {+ super('Requisition not linked yet');+ this.details = params;+ }+}++export class AccountNotLinedToRequisition extends Error {+ constructor(accountId, requisitionId) {+ super('Provided account id is not linked to given requisition');+ this.details = {+ accountId,+ requisitionId+ };+ }+}++export class GenericNordigenError extends Error {+ constructor(data = {}) {+ super('Nordigen returned error');+ this.details = data;+ }+}++export class NordigenClientError extends Error {+ constructor(message, details) {+ super(message);+ this.details = details;+ }+}++export class InvalidInputDataError extends NordigenClientError {+ constructor(response) {+ super('Invalid provided parameters', response);+ }+}++export class InvalidNordigenTokenError extends NordigenClientError {+ constructor(response) {+ super('Token is invalid or expired', response);+ }+}++export class AccessDeniedError extends NordigenClientError {+ constructor(response) {+ super('IP address access denied', response);+ }+}++export class NotFoundError extends NordigenClientError {+ constructor(response) {+ super('Resource not found', response);+ }+}++export class ResourceSuspended extends NordigenClientError {+ constructor(response) {+ super(+ 'Resource was suspended due to numerous errors that occurred while accessing it',+ response+ );+ }+}++export class RateLimitError extends NordigenClientError {+ constructor(response) {+ super(+ 'Daily request limit set by the Institution has been exceeded',+ response+ );+ }+}++export class UnknownError extends NordigenClientError {+ constructor(response) {+ super('Request to Institution returned an error', response);+ }+}++export class ServiceError extends NordigenClientError {+ constructor(response) {+ super('Institution service unavailable', response);+ }+}diff --git a/src/app-nordigen/nordigen-node.types.ts b/src/app-nordigen/nordigen-node.types.tsnew file mode 100644index 0000000000..518748428e--- /dev/null+++ b/src/app-nordigen/nordigen-node.types.ts@@ -0,0 +1,472 @@+type RequisitionStatus =+ | 'CR'+ | 'ID'+ | 'LN'+ | 'RJ'+ | 'ER'+ | 'SU'+ | 'EX'+ | 'GC'+ | 'UA'+ | 'GA'+ | 'SA';++export type Requisition = {+ /**+ * option to enable account selection view for the end user+ */+ account_selection: boolean;++ /**+ * array of account IDs retrieved within a scope of this requisition+ */+ accounts: string[];++ /**+ * EUA associated with this requisition+ */+ agreement: string;++ /**+ * The date & time at which the requisition was created.+ */+ created: string;++ /**+ * The unique ID of the requisition+ */+ id: string;++ /**+ * an Institution ID for this Requisition+ */+ institution_id: string;++ /**+ * link to initiate authorization with Institution+ */+ link: string;++ /**+ * redirect URL to your application after end-user authorization with ASPSP+ */+ redirect: string;++ /**+ * enable redirect back to the client after account list received+ */+ redirect_immediate: boolean;++ /**+ * additional ID to identify the end user+ */+ reference: string;++ /**+ * optional SSN field to verify ownership of the account+ */+ ssn: string;++ /**+ * status of this requisition+ */+ status: RequisitionStatus;++ /**+ * A two-letter country code (ISO 639-1)+ */+ user_language: string;+};++/**+ * Object representing Nordigen account details+ * Account details will be returned in Berlin Group PSD2 format.+ */+export type NordigenAccountDetails = {+ /**+ * Resource id of the account+ */+ resourceId?: string;++ /**+ * BBAN of the account. This data element is used for payment accounts which have no IBAN+ */+ bban?: string;++ /**+ * BIC associated to the account+ */+ bic?: string;++ /**+ * External Cash Account Type 1 Code from ISO 20022+ */+ cashAccountType?: string;++ /**+ * Currency of the account+ */+ currency: string;++ /**+ * Specifications that might be provided by the financial institution, including+ * - Characteristics of the account+ * - Characteristics of the relevant card+ */+ details?: string;++ /**+ * Name of the account as defined by the end user within online channels+ */+ displayName?: string;++ /**+ * IBAN of the account+ */+ iban?: string;++ /**+ * This data attribute is a field where a financial institution can name a cash account associated with pending card transactions+ */+ linkedAccounts?: string;++ /**+ * Alias to a payment account via a registered mobile phone number+ */+ msisdn?: string;++ /**+ * Name of the account, as assigned by the financial institution+ */+ name?: string;++ /**+ * Address of the legal account owner+ */+ ownerAddressUnstructured?: string[];++ /**+ * Name of the legal account owner. If there is more than one owner, then two names might be noted here. For a corporate account, the corporate name is used for this attribute.+ */+ ownerName?: string;++ /**+ * Product Name of the Bank for this account, proprietary definition+ */+ product?: string;++ /**+ * Account status. The value is one of the following:+ * - "enabled": account is available+ * - "deleted": account is terminated+ * - "blocked": account is blocked, e.g. for legal reasons+ *+ * If this field is not used, then the account is considered available according to the specification.+ */+ status?: 'enabled' | 'deleted' | 'blocked';++ /**+ * Specifies the usage of the account:+ * - PRIV: private personal account+ * - ORGA: professional account+ */+ usage?: 'PRIV' | 'ORGA';+};++/**+ * Representation of the Nordigen account metadata+ */+export type NordigenAccountMetadata = {+ /**+ * ID of the Nordigen account metadata+ */+ id: string;+ /**+ * Date when the Nordigen account metadata was created+ */+ created: string;+ /**+ * Date of the last access to the Nordigen account metadata+ */+ last_accessed: string;+ /**+ * IBAN of the Nordigen account metadata+ */+ iban: string;+ /**+ * ID of the institution associated with the Nordigen account metadata+ */+ institution_id: string;+ /**+ * Status of the Nordigen account+ * DISCOVERED: User has successfully authenticated and account is discovered+ * PROCESSING: Account is being processed by the Institution+ * ERROR: An error was encountered when processing account+ * EXPIRED: Access to account has expired as set in End User Agreement+ * READY: Account has been successfully processed+ * SUSPENDED: Account has been suspended (more than 10 consecutive failed attempts to access the account)+ */+ status:+ | 'DISCOVERED'+ | 'PROCESSING'+ | 'ERROR'+ | 'EXPIRED'+ | 'READY'+ | 'SUSPENDED';+ /**+ * Name of the owner of the Nordigen account metadata+ */+ owner_name: string;+};++/**+ * Information about the Institution+ */+export type Institution = {+ /**+ * The id of the institution, for example "N26_NTSBDEB1"+ */+ id: string;++ /**+ * The name of the institution, for example "N26 Bank"+ */+ name: string;++ /**+ * The BIC of the institution, for example "NTSBDEB1"+ */+ bic: string;++ /**+ * The total number of days of transactions available, for example "90"+ */+ transaction_total_days: string;++ /**+ * The countries where the institution operates, for example `["PL"]`+ */+ countries: string[];++ /**+ * The logo URL of the institution, for example "https://cdn.nordigen.com/ais/N26_SANDBOX_NTSBDEB1.png"+ */+ logo: string;++ supported_payments?: object;+ supported_features?: string[];+};++/**+ * An object containing information about a balance+ */+export type Balance = {+ /**+ * An object containing the balance amount and currency+ */+ balanceAmount: Amount;+ /**+ * The type of balance+ */+ balanceType:+ | 'closingBooked'+ | 'expected'+ | 'forwardAvailable'+ | 'interimAvailable'+ | 'interimBooked'+ | 'nonInvoiced'+ | 'openingBooked';+ /**+ * A flag indicating if the credit limit of the corresponding account is included in the calculation of the balance (if applicable)+ */+ creditLimitIncluded?: boolean;+ /**+ * The date and time of the last change to the balance+ */+ lastChangeDateTime?: string;+ /**+ * The reference of the last committed transaction to support the TPP in identifying whether all end users transactions are already known+ */+ lastCommittedTransaction?: string;+ /**+ * The date of the balance+ */+ referenceDate?: string;+};++/**+ * An object representing the amount of a transaction+ */+export type Amount = {+ /**+ * The amount of the transaction+ */+ amount: string;++ /**+ * The currency of the transaction+ */+ currency: string;+};++/**+ * An object representing a financial transaction+ */+export type Transaction = {+ /**+ * Might be used by the financial institution to transport additional transaction-related information.+ */+ additionalInformation?: string;++ /**+ * Is used if and only if the bookingStatus entry equals "information".+ */+ bookingStatus?: string;++ /**+ * The balance after this transaction. Recommended balance type is interimBooked.+ */+ balanceAfterTransaction?: Pick<Balance, 'balanceType' | 'balanceAmount'>;++ /**+ * Bank transaction code as used by the financial institution and using the sub elements of this structured code defined by ISO20022. For standing order reports the following codes are applicable:+ * "PMNT-ICDT-STDO" for credit transfers,+ * "PMNT-IRCT-STDO" for instant credit transfers,+ * "PMNT-ICDT-XBST" for cross-border credit transfers,+ * "PMNT-IRCT-XBST" for cross-border real-time credit transfers,+ * "PMNT-MCOP-OTHR" for specific standing orders which have a dynamic amount to move left funds e.g. on month end to a saving account+ */+ bankTransactionCode?: string;++ /**+ * The date when an entry is posted to an account on the financial institution's books.+ */+ bookingDate?: string;++ /**+ * The date and time when an entry is posted to an account on the financial institution's books.+ */+ bookingDateTime?: string;++ /**+ * Identification of a cheque+ */+ checkId?: string;++ /**+ * Account reference, conditional+ */+ creditorAccount?: string;++ /**+ * BICFI+ */+ creditorAgent?: string;++ /**+ * Identification of creditors, e.g. a SEPA Creditor ID+ */+ creditorId?: string;++ /**+ * Name of the creditor if a "debited" transaction+ */+ creditorName?: string;++ /**+ * Array of report exchange rates+ */+ currencyExchange?: string[];++ /**+ * Account reference, conditional+ */+ debtorAccount?: {+ iban: string;+ };++ /**+ * BICFI+ */+ debtorAgent?: string;++ /**+ * Name of the debtor if a "credited" transaction+ */+ debtorName?: string;++ /**+ * Unique end-to-end ID+ */+ endToEndId?: string;++ /**+ * The identification of the transaction as used for reference given by the financial institution.+ */+ entryReference?: string;++ /**+ * Transaction identifier given by Nordigen+ */+ internalTransactionId?: string;++ /**+ * Identification of Mandates, e.g. a SEPA Mandate ID+ */+ mandateId?: string;++ /**+ * Merchant category code as defined by card issuer+ */+ merchantCategoryCode?: string;++ /**+ * Proprietary bank transaction code as used within a community or within an financial institution+ */+ proprietaryBank?: string;++ /**+ * Conditional+ */+ purposeCode?: string;++ /**+ * Reference as contained in the structured remittance reference structure+ */+ remittanceInformation?: string;++ /**+ * The amount of the transaction as billed to the account+ */+ transactionAmount: Amount;++ /**+ * Unique transaction identifier given by financial institution+ */+ transactionId?: string;++ /**+ *+ */+ ultimateCreditor?: string;++ /**+ *+ */+ ultimateDebtor?: string;++ /**+ * The Date at which assets become available to the account owner in case of a credit+ */+ valueDate?: string;++ /**+ * The date and time at which assets become available to the account owner in case of a credit+ */+ valueDateTime?: string;+};++export type Transactions = {+ booked: Transaction[];+ pending: Transaction[];+};diff --git a/src/app-nordigen/nordigen.types.ts b/src/app-nordigen/nordigen.types.tsnew file mode 100644index 0000000000..70b07e6324--- /dev/null+++ b/src/app-nordigen/nordigen.types.ts@@ -0,0 +1,82 @@+import {+ NordigenAccountMetadata,+ NordigenAccountDetails,+ Institution,+ Transactions,+ Balance+} from './nordigen-node.types.js';++export type DetailedAccount = Omit<NordigenAccountDetails, 'status'> &+ NordigenAccountMetadata;+export type DetailedAccountWithInstitution = DetailedAccount & {+ institution: Institution;+};++export type NormalizedAccountDetails = {+ /**+ * Id of the account+ */+ account_id: string;++ /**+ * Institution of account+ */+ institution: Institution;++ /**+ * last 4 digits from the account iban+ */+ mask: string;++ /**+ * Name displayed on the UI of Actual app+ */+ name: string;++ /**+ * name of the product in the institution+ */+ official_name: string;++ /**+ * type of account+ */+ type: string;+};++export type GetTransactionsParams = {+ /**+ * Id of account from the nordigen app+ */+ accountId: string;++ /**+ * Begin date of the period from which we want to download transactions+ */+ startDate: string;++ /**+ * End date of the period from which we want to download transactions+ */+ endDate: string;+};++export type GetTransactionsResponse = {+ status_code?: number;+ detail?: string;+ transactions: Transactions;+};++export type CreateRequisitionParams = {+ institutionId: string;+ accessValidForDays: number;++ /**+ * Host of your frontend app - on this host you will be redirected after linking with bank+ */+ host: string;+};++export type GetBalances = {+ balances: Balance[];+};diff --git a/src/app-nordigen/services/nordigen-service.js b/src/app-nordigen/services/nordigen-service.jsnew file mode 100644index 0000000000..b81b9097c1--- /dev/null+++ b/src/app-nordigen/services/nordigen-service.js@@ -0,0 +1,440 @@+import BankFactory from '../bank-factory.js';+import {+ RequisitionNotLinked,+ AccountNotLinedToRequisition,+ InvalidInputDataError,+ InvalidNordigenTokenError,+ AccessDeniedError,+ NotFoundError,+ ResourceSuspended,+ RateLimitError,+ UnknownError,+ ServiceError+} from '../errors.js';+import * as nordigenNode from 'nordigen-node';+import * as uuid from 'uuid';+import config from '../../load-config.js';+import { sortByBookingDate } from '../utils.js';++const NordigenClient = nordigenNode.default;+const nordigenClient = new NordigenClient({+ secretId: config.nordigen_secret_id,+ secretKey: config.nordigen_secret_key+});++export const handleNordigenError = (response) => {+ switch (response.status_code) {+ case 400:+ throw new InvalidInputDataError(response);+ case 401:+ throw new InvalidNordigenTokenError(response);+ case 403:+ throw new AccessDeniedError(response);+ case 404:+ throw new NotFoundError(response);+ case 409:+ throw new ResourceSuspended(response);+ case 429:+ throw new RateLimitError(response);+ case 500:+ throw new UnknownError(response);+ case 503:+ throw new ServiceError(response);+ default:+ return;+ }+};++export const nordigenService = {+ /**+ *+ * @returns {Promise<void>}+ */+ setToken: async () => {+ if (!nordigenClient.token) {+ const tokenData = await client.generateToken();+ handleNordigenError(tokenData);+ nordigenClient.token = tokenData.access;+ }+ },++ /**+ *+ * @param requisitionId+ * @throws {RequisitionNotLinked} Will throw an error if requisition is not in Linked+ * @throws {InvalidInputDataError}+ * @throws {InvalidNordigenTokenError}+ * @throws {AccessDeniedError}+ * @throws {NotFoundError}+ * @throws {ResourceSuspended}+ * @throws {RateLimitError}+ * @throws {UnknownError}+ * @throws {ServiceError}+ * @returns {Promise<import('../nordigen-node.types.js').Requisition>}+ */+ getLinkedRequisition: async (requisitionId) => {+ const requisition = await nordigenService.getRequisition(requisitionId);++ const { status } = requisition;++ // Continue only if status of requisition is "LN" what does+ // mean that account has been successfully linked to requisition+ if (status !== 'LN') {+ throw new RequisitionNotLinked({ requisitionStatus: status });+ }++ return requisition;+ },++ /**+ * Returns requisition and all linked accounts in their Bank format.+ * Each account object is extended about details of the institution+ * @param requisitionId+ * @throws {RequisitionNotLinked} Will throw an error if requisition is not in Linked+ * @throws {InvalidInputDataError}+ * @throws {InvalidNordigenTokenError}+ * @throws {AccessDeniedError}+ * @throws {NotFoundError}+ * @throws {ResourceSuspended}+ * @throws {RateLimitError}+ * @throws {UnknownError}+ * @throws {ServiceError}+ * @returns {Promise<{requisition: import('../nordigen-node.types.js').Requisition, accounts: Array<import('../nordigen.types.js').NormalizedAccountDetails>}>}+ */+ getRequisitionWithAccounts: async (requisitionId) => {+ const requisition = await nordigenService.getLinkedRequisition(+ requisitionId+ );++ let institutionIdSet = new Set();+ const detailedAccounts = await Promise.all(+ requisition.accounts.map(async (accountId) => {+ const account = await nordigenService.getDetailedAccount(accountId);+ institutionIdSet.add(account.institution_id);+ return account;+ })+ );++ const institutions = await Promise.all(+ Array.from(institutionIdSet).map(async (institutionId) => {+ return await nordigenService.getInstitution(institutionId);+ })+ );++ const extendedAccounts =+ await nordigenService.extendAccountsAboutInstitutions({+ accounts: detailedAccounts,+ institutions+ });++ const normalizedAccounts = extendedAccounts.map((account) => {+ const bankAccount = BankFactory(account.institution_id);+ return bankAccount.normalizeAccount(account);+ });++ return { requisition, accounts: normalizedAccounts };+ },++ /**+ *+ * @param requisitionId+ * @param accountId+ * @param startDate+ * @param endDate+ * @throws {AccountNotLinedToRequisition} Will throw an error if requisition not includes provided account id+ * @throws {RequisitionNotLinked} Will throw an error if requisition is not in Linked+ * @throws {InvalidInputDataError}+ * @throws {InvalidNordigenTokenError}+ * @throws {AccessDeniedError}+ * @throws {NotFoundError}+ * @throws {ResourceSuspended}+ * @throws {RateLimitError}+ * @throws {UnknownError}+ * @throws {ServiceError}+ * @returns {Promise<{balances: Array<import('../nordigen-node.types.js').Balance>, institutionId: string, transactions: {booked: Array<import('../nordigen-node.types.js').Transaction>, pending: Array<import('../nordigen-node.types.js').Transaction>}, startingBalance: number}>}+ */+ getTransactionsWithBalance: async (+ requisitionId,+ accountId,+ startDate,+ endDate+ ) => {+ const { institution_id, accounts: accountIds } =+ await nordigenService.getLinkedRequisition(requisitionId);++ if (!accountIds.includes(accountId)) {+ throw new AccountNotLinedToRequisition(accountId, requisitionId);+ }++ const [transactions, accountBalance] = await Promise.all([+ nordigenService.getTransactions({+ accountId,+ startDate,+ endDate+ }),+ nordigenService.getBalances(accountId)+ ]);++ const bank = BankFactory(institution_id);+ const sortedBookedTransactions = bank.sortTransactions(+ transactions.transactions?.booked+ );+ const sortedPendingTransactions = bank.sortTransactions(+ transactions.transactions?.pending+ );++ const startingBalance = bank.calculateStartingBalance(+ sortedBookedTransactions,+ accountBalance.balances+ );++ return {+ balances: accountBalance.balances,+ institutionId: institution_id,+ startingBalance,+ transactions: {+ booked: sortedBookedTransactions,+ pending: sortedPendingTransactions+ }+ };+ },++ /**+ *+ * @param {import('../nordigen.types.js').CreateRequisitionParams} params+ * @throws {InvalidInputDataError}+ * @throws {InvalidNordigenTokenError}+ * @throws {AccessDeniedError}+ * @throws {NotFoundError}+ * @throws {ResourceSuspended}+ * @throws {RateLimitError}+ * @throws {UnknownError}+ * @throws {ServiceError}+ * @returns {Promise<{requisitionId, link}>}+ */+ createRequisition: async ({ institutionId, accessValidForDays, host }) => {+ await nordigenService.setToken();++ const response = await client.initSession({+ redirectUrl: host + '/nordigen/link',+ institutionId,+ referenceId: uuid.v4(),+ accessValidForDays,+ maxHistoricalDays: 90,+ userLanguage: 'en',+ ssn: null,+ redirectImmediate: false,+ accountSelection: false+ });++ handleNordigenError(response);++ const { link, id: requisitionId } = response;++ return {+ link,+ requisitionId+ };+ },++ /**+ * Deletes requisition by provided ID+ * @param requisitionId+ * @throws {InvalidInputDataError}+ * @throws {InvalidNordigenTokenError}+ * @throws {AccessDeniedError}+ * @throws {NotFoundError}+ * @throws {ResourceSuspended}+ * @throws {RateLimitError}+ * @throws {UnknownError}+ * @throws {ServiceError}+ * @returns {Promise<{summary: string, detail: string}>}+ */+ deleteRequisition: async (requisitionId) => {+ await nordigenService.getRequisition(requisitionId);+ const response = client.deleteRequisition(requisitionId);++ handleNordigenError(response);+ return response;+ },++ /**+ * Retrieve a requisition by ID+ * https://nordigen.com/en/docs/account-information/integration/parameters-and-responses/#/requisitions/requisition%20by%20id+ * @param { string } requisitionId+ * @throws {InvalidInputDataError}+ * @throws {InvalidNordigenTokenError}+ * @throws {AccessDeniedError}+ * @throws {NotFoundError}+ * @throws {ResourceSuspended}+ * @throws {RateLimitError}+ * @throws {UnknownError}+ * @throws {ServiceError}+ * @returns { Promise<import('../nordigen-node.types.js').Requisition> }+ */+ getRequisition: async (requisitionId) => {+ await nordigenService.setToken();++ const response = client.getRequisitionById(requisitionId);++ handleNordigenError(response);++ return response;+ },++ /**+ * Retrieve an detailed account by account id+ * @param accountId+ * @returns {Promise<import('../nordigen.types.js').DetailedAccount>}+ */+ getDetailedAccount: async (accountId) => {+ const [detailedAccount, metadataAccount] = await Promise.all([+ client.getDetails(accountId),+ client.getMetadata(accountId)+ ]);++ handleNordigenError(detailedAccount);+ handleNordigenError(metadataAccount);++ return {+ ...detailedAccount.account,+ ...metadataAccount+ };+ },++ /**+ * Retrieve details about a specific Institution+ * @param institutionId+ * @throws {InvalidInputDataError}+ * @throws {InvalidNordigenTokenError}+ * @throws {AccessDeniedError}+ * @throws {NotFoundError}+ * @throws {ResourceSuspended}+ * @throws {RateLimitError}+ * @throws {UnknownError}+ * @throws {ServiceError}+ * @returns {Promise<import('../nordigen-node.types.js').Institution>}+ */+ getInstitution: async (institutionId) => {+ const response = await client.getInstitutionById(institutionId);++ handleNordigenError(response);++ return response;+ },++ /**+ * Extends provided accounts about details of their institution+ * @param {{accounts: Array<import('../nordigen.types.js').DetailedAccount>, institutions: Array<import('../nordigen-node.types.js').Institution>}} params+ * @returns {Promise<Array<import('../nordigen.types.js').DetailedAccount&{institution: import('../nordigen-node.types.js').Institution}>>}+ */+ extendAccountsAboutInstitutions: async ({ accounts, institutions }) => {+ const institutionsById = institutions.reduce((acc, institution) => {+ acc[institution.id] = institution;+ return acc;+ }, {});++ return accounts.map((account) => {+ const institution = institutionsById[account.institution_id] || null;+ return {+ ...account,+ institution+ };+ });+ },++ /**+ * Returns account transaction in provided dates+ * @param {import('../nordigen.types.js').GetTransactionsParams} params+ * @throws {InvalidInputDataError}+ * @throws {InvalidNordigenTokenError}+ * @throws {AccessDeniedError}+ * @throws {NotFoundError}+ * @throws {ResourceSuspended}+ * @throws {RateLimitError}+ * @throws {UnknownError}+ * @throws {ServiceError}+ * @returns {Promise<import('../nordigen.types.js').GetTransactionsResponse>}+ */+ getTransactions: async ({ accountId, startDate, endDate }) => {+ const response = await client.getTransactions({+ accountId,+ dateFrom: startDate,+ dateTo: endDate+ });++ handleNordigenError(response);++ return response;+ },++ /**+ * Returns account available balances+ * @param accountId+ * @throws {InvalidInputDataError}+ * @throws {InvalidNordigenTokenError}+ * @throws {AccessDeniedError}+ * @throws {NotFoundError}+ * @throws {ResourceSuspended}+ * @throws {RateLimitError}+ * @throws {UnknownError}+ * @throws {ServiceError}+ * @returns {Promise<import('../nordigen.types.js').GetBalances>}+ */+ getBalances: async (accountId) => {+ const response = await client.getBalances(accountId);++ handleNordigenError(response);++ return response;+ }+};++/**+ * All executions of nordigenClient should be here for testing purposes,+ * as the nordigen-node library is not written in a way that is conducive to testing.+ * In that way we can mock the `client` const instead of nordigen library+ */+export const client = {+ getBalances: async (accountId) =>+ await nordigenClient.account(accountId).getBalances(),+ getTransactions: async ({ accountId, dateFrom, dateTo }) =>+ await nordigenClient.account(accountId).getTransactions({+ dateFrom,+ dateTo,+ country: undefined+ }),+ getInstitutionById: async (institutionId) =>+ await nordigenClient.institution.getInstitutionById(institutionId),+ getDetails: async (accountId) =>+ await nordigenClient.account(accountId).getDetails(),+ getMetadata: async (accountId) =>+ await nordigenClient.account(accountId).getMetadata(),+ getRequisitionById: async (requisitionId) =>+ await nordigenClient.requisition.getRequisitionById(requisitionId),+ deleteRequisition: async (requisitionId) =>+ await nordigenClient.requisition.deleteRequisition(requisitionId),+ initSession: async ({+ redirectUrl,+ institutionId,+ referenceId,+ accessValidForDays,+ maxHistoricalDays,+ userLanguage,+ ssn,+ redirectImmediate,+ accountSelection+ }) =>+ await nordigenClient.initSession({+ redirectUrl,+ institutionId,+ referenceId,+ accessValidForDays,+ maxHistoricalDays,+ userLanguage,+ ssn,+ redirectImmediate,+ accountSelection+ }),+ generateToken: async () => await nordigenClient.generateToken()+};diff --git a/src/app-nordigen/services/tests/fixtures.js b/src/app-nordigen/services/tests/fixtures.jsnew file mode 100644index 0000000000..e876039f65--- /dev/null+++ b/src/app-nordigen/services/tests/fixtures.js@@ -0,0 +1,180 @@+/** @type {{balances: import('../../nordigen-node.types.js').Balance[]}} */+export const mockedBalances = {+ balances: [+ {+ balanceAmount: {+ amount: '657.49',+ currency: 'string'+ },+ balanceType: 'interimAvailable',+ referenceDate: '2021-11-22'+ },+ {+ balanceAmount: {+ amount: '185.67',+ currency: 'string'+ },+ balanceType: 'interimAvailable',+ referenceDate: '2021-11-19'+ }+ ]+};++/** @type {{transactions: import('../../nordigen-node.types.js').Transactions}} */+export const mockTransactions = {+ transactions: {+ booked: [+ {+ transactionId: 'string',+ debtorName: 'string',+ debtorAccount: {+ iban: 'string'+ },+ transactionAmount: {+ currency: 'EUR',+ amount: '328.18'+ },+ bankTransactionCode: 'string',+ bookingDate: 'date',+ valueDate: 'date'+ },+ {+ transactionId: 'string',+ transactionAmount: {+ currency: 'EUR',+ amount: '947.26'+ },+ bankTransactionCode: 'string',+ bookingDate: 'date',+ valueDate: 'date'+ }+ ],+ pending: [+ {+ transactionAmount: {+ currency: 'EUR',+ amount: '947.26'+ },+ valueDate: 'date'+ }+ ]+ }+};++export const mockUnknownError = {+ summary: "Couldn't update account balances",+ detail: 'Request to Institution returned an error',+ type: 'UnknownRequestError',+ status_code: 500+};++/** @type {{account: import('../../nordigen-node.types.js').NordigenAccountDetails}} */+export const mockAccountDetails = {+ account: {+ resourceId: 'PL00000000000000000987654321',+ iban: 'PL00000000000000000987654321',+ currency: 'PLN',+ ownerName: 'JOHN EXAMPLE',+ product: 'Savings Account for Individuals (Retail)',+ bic: 'INGBPLPW',+ ownerAddressUnstructured: ['EXAMPLE STREET 100/001', '00-000 EXAMPLE CITY']+ }+};++/** @type {import('../../nordigen-node.types.js').NordigenAccountMetadata} */+export const mockAccountMetaData = {+ id: 'f0e49aa6-f6db-48fc-94ca-4a62372fadf4',+ created: '2022-07-24T20:45:47.847062Z',+ last_accessed: '2023-01-25T22:12:27.814618Z',+ iban: 'PL00000000000000000987654321',+ institution_id: 'SANDBOXFINANCE_SFIN0000',+ status: 'READY',+ owner_name: 'JOHN EXAMPLE'+};++/** @type {import('../../nordigen.types.js').DetailedAccount} */+export const mockDetailedAccount = {+ ...mockAccountDetails.account,+ ...mockAccountMetaData+};++/** @type {import('../../nordigen-node.types.js').Institution} */+export const mockInstitution = {+ id: 'N26_NTSBDEB1',+ name: 'N26 Bank',+ bic: 'NTSBDEB1',+ transaction_total_days: '90',+ countries: ['GB', 'NO', 'SE'],+ logo: 'https://cdn.nordigen.com/ais/N26_SANDBOX_NTSBDEB1.png'+};++/** @type {import('../../nordigen-node.types.js').Requisition} */+export const mockRequisition = {+ id: '3fa85f64-5717-4562-b3fc-2c963f66afa6',+ created: '2023-01-31T18:15:50.172Z',+ redirect: 'string',+ status: 'LN',+ institution_id: 'string',+ agreement: '3fa85f64-5717-4562-b3fc-2c963f66afa6',+ reference: 'string',+ accounts: ['f0e49aa6-f6db-48fc-94ca-4a62372fadf4'],+ user_language: 'string',+ link: 'https://ob.nordigen.com/psd2/start/3fa85f64-5717-4562-b3fc-2c963f66afa6/{$INSTITUTION_ID}',+ ssn: 'string',+ account_selection: false,+ redirect_immediate: false+};++export const mockDeleteRequisition = {+ summary: 'Requisition deleted',+ detail:+ "Requisition '$REQUISITION_ID' deleted with all its End User Agreements"+};++export const mockCreateRequisition = {+ id: '3fa85f64-5717-4562-b3fc-2c963f66afa6',+ created: '2023-02-01T15:53:29.481Z',+ redirect: 'string',+ status: 'CR',+ institution_id: 'string',+ agreement: '3fa85f64-5717-4562-b3fc-2c963f66afa6',+ reference: 'string',+ accounts: [],+ user_language: 'string',+ link: 'https://ob.nordigen.com/psd2/start/3fa85f64-5717-4562-b3fc-2c963f66afa6/{$INSTITUTION_ID}',+ ssn: 'string',+ account_selection: false,+ redirect_immediate: false+};++/** @type {import('../../nordigen.types.js').DetailedAccount} */+export const mockDetailedAccountExample1 = {+ ...mockDetailedAccount,+ name: 'account-example-one'+};++/** @type {import('../../nordigen.types.js').DetailedAccount} */+export const mockDetailedAccountExample2 = {+ ...mockDetailedAccount,+ name: 'account-example-two'+};++/** @type {import('../../nordigen.types.js').DetailedAccountWithInstitution[]} */+export const mockExtendAccountsAboutInstitutions = [+ {+ ...mockDetailedAccountExample1,+ institution: mockInstitution+ },+ {+ ...mockDetailedAccountExample2,+ institution: mockInstitution+ }+];++export const mockRequisitionWithExampleAccounts = {+ ...mockRequisition,++ accounts: [mockDetailedAccountExample1.id, mockDetailedAccountExample2.id]+};++export const mockTransactionAmount = { amount: '100', currency: 'EUR' };diff --git a/src/app-nordigen/services/tests/nordigen-service.spec.js b/src/app-nordigen/services/tests/nordigen-service.spec.jsnew file mode 100644index 0000000000..fa098d4527--- /dev/null+++ b/src/app-nordigen/services/tests/nordigen-service.spec.js@@ -0,0 +1,569 @@+import { jest } from '@jest/globals';+import {+ InvalidInputDataError,+ InvalidNordigenTokenError,+ AccessDeniedError,+ NotFoundError,+ ResourceSuspended,+ RateLimitError,+ UnknownError,+ ServiceError,+ RequisitionNotLinked,+ AccountNotLinedToRequisition+} from '../../errors.js';++import {+ mockedBalances,+ mockUnknownError,+ mockTransactions,+ mockDetailedAccount,+ mockInstitution,+ mockAccountMetaData,+ mockAccountDetails,+ mockRequisition,+ mockDeleteRequisition,+ mockCreateRequisition,+ mockRequisitionWithExampleAccounts,+ mockDetailedAccountExample1,+ mockDetailedAccountExample2,+ mockExtendAccountsAboutInstitutions+} from './fixtures.js';++import {+ nordigenService,+ handleNordigenError,+ client+} from '../nordigen-service.js';++describe('nordigenService', () => {+ const accountId = mockAccountMetaData.id;+ const requisitionId = mockRequisition.id;++ let getBalancesSpy;+ let getTransactionsSpy;+ let getDetailsSpy;+ let getMetadataSpy;+ let getInstitutionSpy;+ let getRequisitionsSpy;+ let deleteRequisitionsSpy;+ let createRequisitionSpy;+ let setTokenSpy;++ beforeEach(() => {+ getInstitutionSpy = jest.spyOn(client, 'getInstitutionById');+ getRequisitionsSpy = jest.spyOn(client, 'getRequisitionById');+ deleteRequisitionsSpy = jest.spyOn(client, 'deleteRequisition');+ createRequisitionSpy = jest.spyOn(client, 'initSession');+ getBalancesSpy = jest.spyOn(client, 'getBalances');+ getTransactionsSpy = jest.spyOn(client, 'getTransactions');+ getDetailsSpy = jest.spyOn(client, 'getDetails');+ getMetadataSpy = jest.spyOn(client, 'getMetadata');+ setTokenSpy = jest.spyOn(nordigenService, 'setToken');+ });++ afterEach(() => {+ jest.resetAllMocks();+ });++ describe('#getLinkedRequisition', () => {+ it('returns requisition', async () => {+ setTokenSpy.mockResolvedValue();++ jest+ .spyOn(nordigenService, 'getRequisition')+ .mockResolvedValue(mockRequisition);++ expect(await nordigenService.getLinkedRequisition(requisitionId)).toEqual(+ mockRequisition+ );+ });++ it('throws RequisitionNotLinked error if requisition status is different than LN', async () => {+ setTokenSpy.mockResolvedValue();++ jest+ .spyOn(nordigenService, 'getRequisition')+ .mockResolvedValue({ ...mockRequisition, status: 'ER' });++ await expect(() =>+ nordigenService.getLinkedRequisition(requisitionId)+ ).rejects.toThrow(RequisitionNotLinked);+ });+ });++ describe('#getRequisitionWithAccounts', () => {+ it('returns combined data', async () => {+ jest+ .spyOn(nordigenService, 'getRequisition')+ .mockResolvedValue(mockRequisitionWithExampleAccounts);+ jest+ .spyOn(nordigenService, 'getDetailedAccount')+ .mockResolvedValueOnce(mockDetailedAccountExample1);+ jest+ .spyOn(nordigenService, 'getDetailedAccount')+ .mockResolvedValueOnce(mockDetailedAccountExample2);+ jest+ .spyOn(nordigenService, 'getInstitution')+ .mockResolvedValue(mockInstitution);+ jest+ .spyOn(nordigenService, 'extendAccountsAboutInstitutions')+ .mockResolvedValue([+ {+ ...mockExtendAccountsAboutInstitutions[0],+ institution_id: 'NEWONE'+ },+ {+ ...mockExtendAccountsAboutInstitutions[1],+ institution_id: 'NEWONE'+ }+ ]);++ const response = await nordigenService.getRequisitionWithAccounts(+ mockRequisitionWithExampleAccounts.id+ );++ expect(response.accounts.length).toEqual(2);+ expect(response.accounts).toMatchObject(+ expect.arrayContaining([+ expect.objectContaining({+ account_id: mockDetailedAccountExample1.id,+ institution: mockInstitution,+ official_name: expect.stringContaining('integration-') // It comes from IntegrationBank+ }),+ expect.objectContaining({+ account_id: mockDetailedAccountExample2.id,+ institution: mockInstitution,+ official_name: expect.stringContaining('integration-') // It comes from IntegrationBank+ })+ ])+ );+ expect(response.requisition).toEqual(mockRequisitionWithExampleAccounts);+ });+ });++ describe('#getTransactionsWithBalance', () => {+ const requisitionId = mockRequisition.id;+ it('returns transaction with starting balance', async () => {+ jest+ .spyOn(nordigenService, 'getLinkedRequisition')+ .mockResolvedValue(mockRequisition);+ jest+ .spyOn(nordigenService, 'getTransactions')+ .mockResolvedValue(mockTransactions);+ jest+ .spyOn(nordigenService, 'getBalances')+ .mockResolvedValue(mockedBalances);++ expect(+ await nordigenService.getTransactionsWithBalance(+ requisitionId,+ accountId,+ undefined,+ undefined+ )+ ).toEqual(+ expect.objectContaining({+ balances: mockedBalances.balances,+ institutionId: mockRequisition.institution_id,+ startingBalance: 0,+ transactions: {+ booked: expect.arrayContaining([+ expect.objectContaining({+ bookingDate: expect.any(String),+ transactionAmount: {+ amount: expect.any(String),+ currency: 'EUR'+ },+ transactionId: expect.any(String),+ valueDate: expect.any(String)+ })+ ]),+ pending: expect.arrayContaining([+ expect.objectContaining({+ transactionAmount: {+ amount: expect.any(String),+ currency: 'EUR'+ },+ valueDate: expect.any(String)+ })+ ])+ }+ })+ );+ });++ it('throws AccountNotLinedToRequisition error if requisition accounts not includes requested account', async () => {+ jest+ .spyOn(nordigenService, 'getLinkedRequisition')+ .mockResolvedValue(mockRequisition);++ await expect(() =>+ nordigenService.getTransactionsWithBalance({+ requisitionId,+ accountId: 'some-unknown-account-id',+ startDate: undefined,+ endDate: undefined+ })+ ).rejects.toThrow(AccountNotLinedToRequisition);+ });+ });++ describe('#createRequisition', () => {+ const institutionId = 'some-institution-id';+ const params = {+ host: 'https://exemple.com',+ institutionId,+ accessValidForDays: 90+ };++ it('calls nordigenClient and delete requisition', async () => {+ setTokenSpy.mockResolvedValue();++ createRequisitionSpy.mockResolvedValue(mockCreateRequisition);++ expect(await nordigenService.createRequisition(params)).toEqual({+ link: expect.any(String),+ requisitionId: expect.any(String)+ });++ expect(createRequisitionSpy).toBeCalledTimes(1);+ });++ it('handle error if status_code present in the response', async () => {+ setTokenSpy.mockResolvedValue();++ createRequisitionSpy.mockResolvedValue(mockUnknownError);++ await expect(() =>+ nordigenService.createRequisition(params)+ ).rejects.toThrow(UnknownError);+ });+ });++ describe('#deleteRequisition', () => {+ const requisitionId = 'some-requisition-id';++ it('calls nordigenClient and delete requisition', async () => {+ setTokenSpy.mockResolvedValue();++ getRequisitionsSpy.mockResolvedValue(mockRequisition);+ deleteRequisitionsSpy.mockResolvedValue(mockDeleteRequisition);++ expect(await nordigenService.deleteRequisition(requisitionId)).toEqual(+ mockDeleteRequisition+ );++ expect(getRequisitionsSpy).toBeCalledTimes(1);+ expect(deleteRequisitionsSpy).toBeCalledTimes(1);+ });++ it('handle error if status_code present in the response', async () => {+ setTokenSpy.mockResolvedValue();++ getRequisitionsSpy.mockResolvedValue(mockRequisition);+ deleteRequisitionsSpy.mockReturnValue(mockUnknownError);++ await expect(() =>+ nordigenService.deleteRequisition(requisitionId)+ ).rejects.toThrow(UnknownError);+ });+ });++ describe('#getRequisition', () => {+ const requisitionId = 'some-requisition-id';++ it('calls nordigenClient and fetch requisition', async () => {+ setTokenSpy.mockResolvedValue();+ getRequisitionsSpy.mockResolvedValue(mockRequisition);++ expect(await nordigenService.getRequisition(requisitionId)).toEqual(+ mockRequisition+ );++ expect(setTokenSpy).toBeCalledTimes(1);+ expect(getRequisitionsSpy).toBeCalledTimes(1);+ });++ it('handle error if status_code present in the response', async () => {+ setTokenSpy.mockResolvedValue();++ getRequisitionsSpy.mockReturnValue(mockUnknownError);++ await expect(() =>+ nordigenService.getRequisition(requisitionId)+ ).rejects.toThrow(UnknownError);+ });+ });++ describe('#getDetailedAccount', () => {+ it('returns merged object', async () => {+ getDetailsSpy.mockResolvedValue(mockAccountDetails);+ getMetadataSpy.mockResolvedValue(mockAccountMetaData);++ expect(await nordigenService.getDetailedAccount(accountId)).toEqual({+ ...mockAccountMetaData,+ ...mockAccountDetails.account+ });+ expect(getDetailsSpy).toBeCalledTimes(1);+ expect(getMetadataSpy).toBeCalledTimes(1);+ });++ it('handle error if status_code present in the detailedAccount response', async () => {+ getDetailsSpy.mockResolvedValue(mockUnknownError);+ getMetadataSpy.mockResolvedValue(mockAccountMetaData);++ await expect(() =>+ nordigenService.getDetailedAccount(accountId)+ ).rejects.toThrow(UnknownError);++ expect(getDetailsSpy).toBeCalledTimes(1);+ expect(getMetadataSpy).toBeCalledTimes(1);+ });++ it('handle error if status_code present in the metadataAccount response', async () => {+ getDetailsSpy.mockResolvedValue(mockAccountDetails);+ getMetadataSpy.mockResolvedValue(mockUnknownError);++ await expect(() =>+ nordigenService.getDetailedAccount(accountId)+ ).rejects.toThrow(UnknownError);++ expect(getDetailsSpy).toBeCalledTimes(1);+ expect(getMetadataSpy).toBeCalledTimes(1);+ });+ });++ describe('#getInstitution', () => {+ const institutionId = 'fake-institution-id';+ it('calls nordigenClient and fetch institution details', async () => {+ getInstitutionSpy.mockResolvedValue(mockInstitution);++ expect(await nordigenService.getInstitution(institutionId)).toEqual(+ mockInstitution+ );+ expect(getInstitutionSpy).toBeCalledTimes(1);+ });++ it('handle error if status_code present in the response', async () => {+ getInstitutionSpy.mockResolvedValue(mockUnknownError);++ await expect(() =>+ nordigenService.getInstitution(institutionId)+ ).rejects.toThrow(UnknownError);+ });+ });++ describe('#extendAccountsAboutInstitutions', () => {+ it('extends accounts with the corresponding institution', async () => {+ const institutionA = { ...mockInstitution, id: 'INSTITUTION_A' };+ const institutionB = { ...mockInstitution, id: 'INSTITUTION_B' };+ const accountAA = {+ ...mockDetailedAccount,+ id: 'AA',+ institution_id: 'INSTITUTION_A'+ };+ const accountBB = {+ ...mockDetailedAccount,+ id: 'BB',+ institution_id: 'INSTITUTION_B'+ };++ const accounts = [accountAA, accountBB];+ const institutions = [institutionA, institutionB];++ const expected = [+ {+ ...accountAA,+ institution: institutionA+ },+ {+ ...accountBB,+ institution: institutionB+ }+ ];++ const result = await nordigenService.extendAccountsAboutInstitutions({+ accounts,+ institutions+ });++ expect(result).toEqual(expected);+ });++ it('returns accounts with missing institutions as null', async () => {+ const accountAA = {+ ...mockDetailedAccount,+ id: 'AA',+ institution_id: 'INSTITUTION_A'+ };+ const accountBB = {+ ...mockDetailedAccount,+ id: 'BB',+ institution_id: 'INSTITUTION_B'+ };++ const accounts = [accountAA, accountBB];++ const institutionA = { ...mockInstitution, id: 'INSTITUTION_A' };+ const institutions = [institutionA];++ const expected = [+ {+ ...accountAA,+ institution: institutionA+ },+ {+ ...accountBB,+ institution: null+ }+ ];++ const result = await nordigenService.extendAccountsAboutInstitutions({+ accounts,+ institutions+ });++ expect(result).toEqual(expected);+ });+ });++ describe('#getTransactions', () => {+ it('calls nordigenClient and fetch transactions for provided accountId', async () => {+ getTransactionsSpy.mockResolvedValue(mockTransactions);++ expect(+ await nordigenService.getTransactions({+ accountId,+ startDate: '',+ endDate: ''+ })+ ).toMatchInlineSnapshot(`+ {+ "transactions": {+ "booked": [+ {+ "bankTransactionCode": "string",+ "bookingDate": "date",+ "debtorAccount": {+ "iban": "string",+ },+ "debtorName": "string",+ "transactionAmount": {+ "amount": "328.18",+ "currency": "EUR",+ },+ "transactionId": "string",+ "valueDate": "date",+ },+ {+ "bankTransactionCode": "string",+ "bookingDate": "date",+ "transactionAmount": {+ "amount": "947.26",+ "currency": "EUR",+ },+ "transactionId": "string",+ "valueDate": "date",+ },+ ],+ "pending": [+ {+ "transactionAmount": {+ "amount": "947.26",+ "currency": "EUR",+ },+ "valueDate": "date",+ },+ ],+ },+ }+ `);+ expect(getTransactionsSpy).toBeCalledTimes(1);+ });++ it('handle error if status_code present in the response', async () => {+ getTransactionsSpy.mockResolvedValue(mockUnknownError);++ await expect(() =>+ nordigenService.getTransactions({+ accountId,+ startDate: '',+ endDate: ''+ })+ ).rejects.toThrow(UnknownError);+ });+ });++ describe('#getBalances', () => {+ it('calls nordigenClient and fetch balances for provided accountId', async () => {+ getBalancesSpy.mockResolvedValue(mockedBalances);++ expect(await nordigenService.getBalances(accountId)).toEqual(+ mockedBalances+ );+ expect(getBalancesSpy).toBeCalledTimes(1);+ });++ it('handle error if status_code present in the response', async () => {+ getBalancesSpy.mockResolvedValue(mockUnknownError);++ await expect(() =>+ nordigenService.getBalances(accountId)+ ).rejects.toThrow(UnknownError);+ });+ });+});++describe('#handleNordigenError', () => {+ it('throws InvalidInputDataError for status code 400', () => {+ const response = { status_code: 400 };+ expect(() => handleNordigenError(response)).toThrow(InvalidInputDataError);+ });++ it('throws InvalidNordigenTokenError for status code 401', () => {+ const response = { status_code: 401 };+ expect(() => handleNordigenError(response)).toThrow(+ InvalidNordigenTokenError+ );+ });++ it('throws AccessDeniedError for status code 403', () => {+ const response = { status_code: 403 };+ expect(() => handleNordigenError(response)).toThrow(AccessDeniedError);+ });++ it('throws NotFoundError for status code 404', () => {+ const response = { status_code: 404 };+ expect(() => handleNordigenError(response)).toThrow(NotFoundError);+ });++ it('throws ResourceSuspended for status code 409', () => {+ const response = { status_code: 409 };+ expect(() => handleNordigenError(response)).toThrow(ResourceSuspended);+ });++ it('throws RateLimitError for status code 429', () => {+ const response = { status_code: 429 };+ expect(() => handleNordigenError(response)).toThrow(RateLimitError);+ });++ it('throws UnknownError for status code 500', () => {+ const response = { status_code: 500 };+ expect(() => handleNordigenError(response)).toThrow(UnknownError);+ });++ it('throws ServiceError for status code 503', () => {+ const response = { status_code: 503 };+ expect(() => handleNordigenError(response)).toThrow(ServiceError);+ });++ it('does not throw an error for status code 200', () => {+ const response = { status_code: 200 };+ expect(() => handleNordigenError(response)).not.toThrow();+ });++ it('does not throw an error when status code is not present', () => {+ const response = { foo: 'bar' };+ expect(() => handleNordigenError(response)).not.toThrow();+ });+});diff --git a/src/app-nordigen/tests/bank-factory.spec.js b/src/app-nordigen/tests/bank-factory.spec.jsnew file mode 100644index 0000000000..3205eb192c--- /dev/null+++ b/src/app-nordigen/tests/bank-factory.spec.js@@ -0,0 +1,35 @@+import BankFactory from '../bank-factory.js';+import MbankRetailBrexplpw from '../banks/mbank-retail-brexplpw.js';+import SandboxfinanceSfin0000 from '../banks/sandboxfinance-sfin0000.js';+import IngPlIngbplpw from '../banks/ing-pl-ingbplpw.js';+import IntegrationBank from '../banks/integration-bank.js';++describe('BankFactory', () => {+ it('should return MbankRetailBrexplpw when institutionId is mbank-retail-brexplpw', () => {+ const institutionId = MbankRetailBrexplpw.institutionId;+ const result = BankFactory(institutionId);++ expect(result.institutionId).toBe(institutionId);+ });++ it('should return SandboxfinanceSfin0000 when institutionId is sandboxfinance-sfin0000', () => {+ const institutionId = SandboxfinanceSfin0000.institutionId;+ const result = BankFactory(institutionId);++ expect(result.institutionId).toBe(institutionId);+ });++ it('should return IngPlIngbplpw when institutionId is ing-pl-ingbplpw', () => {+ const institutionId = IngPlIngbplpw.institutionId;+ const result = BankFactory(institutionId);++ expect(result.institutionId).toBe(institutionId);+ });++ it('should return IntegrationBank when institutionId is not found', () => {+ const institutionId = IntegrationBank.institutionId;+ const result = BankFactory(institutionId);++ expect(result.institutionId).toBe(institutionId);+ });+});diff --git a/src/app-nordigen/tests/utils.spec.js b/src/app-nordigen/tests/utils.spec.jsnew file mode 100644index 0000000000..439b8610ad--- /dev/null+++ b/src/app-nordigen/tests/utils.spec.js@@ -0,0 +1,37 @@+import { mockTransactionAmount } from '../services/tests/fixtures.js';+import { sortByBookingDate } from '../utils.js';++describe('utils', () => {+ describe('#sortByBookingDate', () => {+ it('sorts transactions by bookingDate field from newest to oldest', () => {+ const transactions = [+ {+ bookingDate: '2023-01-01',+ transactionAmount: mockTransactionAmount+ },+ {+ bookingDate: '2023-01-20',+ transactionAmount: mockTransactionAmount+ },+ {+ bookingDate: '2023-01-10',+ transactionAmount: mockTransactionAmount+ }+ ];+ expect(sortByBookingDate(transactions)).toEqual([+ {+ bookingDate: '2023-01-20',+ transactionAmount: mockTransactionAmount+ },+ {+ bookingDate: '2023-01-10',+ transactionAmount: mockTransactionAmount+ },+ {+ bookingDate: '2023-01-01',+ transactionAmount: mockTransactionAmount+ }+ ]);+ });+ });+});diff --git a/src/app-nordigen/util/handle-error.js b/src/app-nordigen/util/handle-error.jsnew file mode 100644index 0000000000..0c91914a09--- /dev/null+++ b/src/app-nordigen/util/handle-error.js@@ -0,0 +1,9 @@+export function handleError(func) {+ return (req, res) => {+ func(req, res).catch((err) => {+ console.log('Error', req.originalUrl, err);+ res.status(500);+ res.send({ status: 'error', reason: 'internal-error' });+ });+ };+}diff --git a/src/app-nordigen/utils.js b/src/app-nordigen/utils.jsnew file mode 100644index 0000000000..541482eaaa--- /dev/null+++ b/src/app-nordigen/utils.js@@ -0,0 +1,14 @@+export const printIban = (account) => {+ if (account.iban) {+ return '(XXX ' + account.iban.slice(-4) + ')';+ } else {+ return '';+ }+};++export const sortByBookingDate = (transactions = []) =>+ transactions.sort(+ (a, b) => +new Date(b.bookingDate) - +new Date(a.bookingDate)+ );++export const amountToInteger = (n) => Math.round(n * 100);diff --git a/src/app.js b/src/app.jsindex a354895a1e..b07036527b 100644--- a/src/app.js+++ b/src/app.js@@ -7,6 +7,7 @@ import config from './load-config.js';import * as accountApp from './app-account.js';import * as syncApp from './app-sync.js';+import * as nordigenApp from './app-nordigen/app-nordigen.js';const app = express();@@ -21,6 +22,7 @@ app.use(bodyParser.raw({ type: 'application/encrypted-file', limit: '50mb' }));app.use('/sync', syncApp.handlers);app.use('/account', accountApp.handlers);+app.use('/nordigen', nordigenApp.handlers);app.get('/mode', (req, res) => {res.send(config.mode);diff --git a/src/config-types.ts b/src/config-types.tsindex 41eb188659..2a8fd6664f 100644--- a/src/config-types.ts+++ b/src/config-types.ts@@ -1,3 +1,5 @@+import { ServerOptions } from 'https';+export interface Config {mode: 'test' | 'development';port: number;@@ -8,5 +10,7 @@ export interface Config {https?: {key: string;cert: string;- } & Parameters<typeof import('node:https')['createServer']>[0];+ } & ServerOptions;+ nordigen_secret_id?: string;+ nordigen_secret_key?: string;}diff --git a/tsconfig.json b/tsconfig.jsonindex 804772f204..2a35116984 100644--- a/tsconfig.json+++ b/tsconfig.json@@ -8,6 +8,7 @@"experimentalDecorators": true,"resolveJsonModule": true,"downlevelIteration": true,+ "skipLibCheck": true,"jsx": "preserve",// Check JS files too"allowJs": true,@@ -16,5 +17,5 @@"module": "node16","outDir": "build"},- "exclude": ["node_modules", "build", "./app-plaid.js"]+ "exclude": ["node_modules", "build", "./app-plaid.js", "coverage"],}diff --git a/yarn.lock b/yarn.lockindex 0f6f948361..9c658e52e2 100644--- a/yarn.lock+++ b/yarn.lock@@ -259,6 +259,17 @@ __metadata:languageName: nodelinkType: hard+"@babel/plugin-syntax-flow@npm:^7.18.6":+ version: 7.18.6+ resolution: "@babel/plugin-syntax-flow@npm:7.18.6"+ dependencies:+ "@babel/helper-plugin-utils": ^7.18.6+ peerDependencies:+ "@babel/core": ^7.0.0-0+ checksum: abe82062b3eef14de7d2b3c0e4fecf80a3e796ca497e9df616d12dd250968abf71495ee85a955b43a6c827137203f0c409450cf792732ed0d6907c806580ea71+ languageName: node+ linkType: hard+"@babel/plugin-syntax-import-meta@npm:^7.8.3":version: 7.10.4resolution: "@babel/plugin-syntax-import-meta@npm:7.10.4"@@ -380,6 +391,31 @@ __metadata:languageName: nodelinkType: hard+"@babel/plugin-transform-flow-strip-types@npm:^7.18.6":+ version: 7.19.0+ resolution: "@babel/plugin-transform-flow-strip-types@npm:7.19.0"+ dependencies:+ "@babel/helper-plugin-utils": ^7.19.0+ "@babel/plugin-syntax-flow": ^7.18.6+ peerDependencies:+ "@babel/core": ^7.0.0-0+ checksum: c35339bf80c2a2b9abb9e2ce0382e1d9cc3ef7db2af127f4ec3d184bad2aec3269f3fcac5fdcd565439732803acad72eb9e7d5a18e439221526fdc041c9e8e1e+ languageName: node+ linkType: hard++"@babel/preset-flow@npm:^7.18.6":+ version: 7.18.6+ resolution: "@babel/preset-flow@npm:7.18.6"+ dependencies:+ "@babel/helper-plugin-utils": ^7.18.6+ "@babel/helper-validator-option": ^7.18.6+ "@babel/plugin-transform-flow-strip-types": ^7.18.6+ peerDependencies:+ "@babel/core": ^7.0.0-0+ checksum: 9100d4eab3402e6601e361a5b235e46d90cfd389c12db19e2a071e1082ca2a00c04bd47eb185ce68d8979e7c8f3e548cd5d61b86dcd701135468fb929c3aecb6+ languageName: node+ linkType: hard+"@babel/template@npm:^7.18.10, @babel/template@npm:^7.20.7, @babel/template@npm:^7.3.3":version: 7.20.7resolution: "@babel/template@npm:7.20.7"@@ -1323,6 +1359,7 @@ __metadata:dependencies:"@actual-app/api": 4.1.6"@actual-app/web": 23.2.9+ "@babel/preset-flow": ^7.18.6"@types/bcrypt": ^5.0.0"@types/better-sqlite3": ^7.5.0"@types/cors": ^2.8.13@@ -1344,6 +1381,7 @@ __metadata:express-actuator: 1.8.4express-response-size: ^0.0.3jest: ^29.3.1+ nordigen-node: ^1.2.3prettier: ^2.8.3supertest: ^6.3.1typescript: ^4.9.5@@ -1546,6 +1584,17 @@ __metadata:languageName: nodelinkType: hard+"axios@npm:^1.2.1":+ version: 1.3.2+ resolution: "axios@npm:1.3.2"+ dependencies:+ follow-redirects: ^1.15.0+ form-data: ^4.0.0+ proxy-from-env: ^1.1.0+ checksum: 9791af75a6df137b15ef45d13ad11eb357b3860d2496347ee18778db9d0abc2320362a4452f1e070e3160f1dbcc518fcefdc9e005be097e7db39acb22cf608e5+ languageName: node+ linkType: hard+"babel-jest@npm:^29.4.1":version: 29.4.1resolution: "babel-jest@npm:29.4.1"@@ -2242,6 +2291,13 @@ __metadata:languageName: nodelinkType: hard+"dotenv@npm:^10.0.0":+ version: 10.0.0+ resolution: "dotenv@npm:10.0.0"+ checksum: f412c5fe8c24fbe313d302d2500e247ba8a1946492db405a4de4d30dd0eb186a88a43f13c958c5a7de303938949c4231c56994f97d05c4bc1f22478d631b4005+ languageName: node+ linkType: hard+"ee-first@npm:1.1.1":version: 1.1.1resolution: "ee-first@npm:1.1.1"@@ -2781,6 +2837,16 @@ __metadata:languageName: nodelinkType: hard+"follow-redirects@npm:^1.15.0":+ version: 1.15.2+ resolution: "follow-redirects@npm:1.15.2"+ peerDependenciesMeta:+ debug:+ optional: true+ checksum: faa66059b66358ba65c234c2f2a37fcec029dc22775f35d9ad6abac56003268baf41e55f9ee645957b32c7d9f62baf1f0b906e68267276f54ec4b4c597c2b190+ languageName: node+ linkType: hard+"form-data@npm:^4.0.0":version: 4.0.0resolution: "form-data@npm:4.0.0"@@ -4460,6 +4526,16 @@ __metadata:languageName: nodelinkType: hard+"nordigen-node@npm:^1.2.3":+ version: 1.2.3+ resolution: "nordigen-node@npm:1.2.3"+ dependencies:+ axios: ^1.2.1+ dotenv: ^10.0.0+ checksum: 721b1b87e750ddde72e97de6b77791da71b0f7206397b485ceb8c271121d26d0e76613b95896b762f9b88eb32fd9cf83202c638a3aeade956910c6971639146b+ languageName: node+ linkType: hard+"normalize-path@npm:^3.0.0":version: 3.0.0resolution: "normalize-path@npm:3.0.0"@@ -4845,6 +4921,13 @@ __metadata:languageName: nodelinkType: hard+"proxy-from-env@npm:^1.1.0":+ version: 1.1.0+ resolution: "proxy-from-env@npm:1.1.0"+ checksum: ed7fcc2ba0a33404958e34d95d18638249a68c430e30fcb6c478497d72739ba64ce9810a24f53a7d921d0c065e5b78e3822759800698167256b04659366ca4d4+ languageName: node+ linkType: hard+"pump@npm:^3.0.0":version: 3.0.0resolution: "pump@npm:3.0.0"