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

package/src/app-gocardless/tests/utils.spec.js

@@ -0,0 +1,162 @@
+import { mockTransactionAmount } from '../services/tests/fixtures.js';
+import { sortByBookingDateOrValueDate } 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(sortByBookingDateOrValueDate(transactions)).toEqual([
+        {
+          bookingDate: '2023-01-20',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          bookingDate: '2023-01-10',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          bookingDate: '2023-01-01',
+          transactionAmount: mockTransactionAmount,
+        },
+      ]);
+    });
+
+    it('should sort by valueDate if bookingDate is missing', () => {
+      const transactions = [
+        {
+          valueDate: '2023-01-01',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          valueDate: '2023-01-20',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          valueDate: '2023-01-10',
+          transactionAmount: mockTransactionAmount,
+        },
+      ];
+      expect(sortByBookingDateOrValueDate(transactions)).toEqual([
+        {
+          valueDate: '2023-01-20',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          valueDate: '2023-01-10',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          valueDate: '2023-01-01',
+          transactionAmount: mockTransactionAmount,
+        },
+      ]);
+    });
+
+    it('should use bookingDate primarily even if bookingDateTime is on an other date', () => {
+      const transactions = [
+        {
+          bookingDate: '2023-01-01',
+          bookingDateTime: '2023-01-01T00:00:00Z',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          bookingDate: '2023-01-10',
+          bookingDateTime: '2023-01-01T12:00:00Z',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          bookingDate: '2023-01-01',
+          bookingDateTime: '2023-01-01T12:00:00Z',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          bookingDate: '2023-01-10',
+          bookingDateTime: '2023-01-01T00:00:00Z',
+          transactionAmount: mockTransactionAmount,
+        },
+      ];
+      expect(sortByBookingDateOrValueDate(transactions)).toEqual([
+        {
+          bookingDate: '2023-01-10',
+          bookingDateTime: '2023-01-01T12:00:00Z',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          bookingDate: '2023-01-10',
+          bookingDateTime: '2023-01-01T00:00:00Z',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          bookingDate: '2023-01-01',
+          bookingDateTime: '2023-01-01T12:00:00Z',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          bookingDate: '2023-01-01',
+          bookingDateTime: '2023-01-01T00:00:00Z',
+          transactionAmount: mockTransactionAmount,
+        },
+      ]);
+    });
+
+    it('should sort on booking date if value date is widely off', () => {
+      const transactions = [
+        {
+          bookingDate: '2023-01-01',
+          valueDateTime: '2023-01-31T00:00:00Z',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          bookingDate: '2023-01-02',
+          valueDateTime: '2023-01-02T12:00:00Z',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          bookingDate: '2023-01-30',
+          valueDateTime: '2023-01-01T12:00:00Z',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          bookingDate: '2023-01-30',
+          valueDateTime: '2023-01-01T00:00:00Z',
+          transactionAmount: mockTransactionAmount,
+        },
+      ];
+      expect(sortByBookingDateOrValueDate(transactions)).toEqual([
+        {
+          bookingDate: '2023-01-30',
+          valueDateTime: '2023-01-01T12:00:00Z',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          bookingDate: '2023-01-30',
+          valueDateTime: '2023-01-01T00:00:00Z',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          bookingDate: '2023-01-02',
+          valueDateTime: '2023-01-02T12:00:00Z',
+          transactionAmount: mockTransactionAmount,
+        },
+        {
+          bookingDate: '2023-01-01',
+          valueDateTime: '2023-01-31T00:00:00Z',
+          transactionAmount: mockTransactionAmount,
+        },
+      ]);
+    });
+  });
+});

package/src/app-gocardless/util/handle-error.js

@@ -0,0 +1,16 @@
+import { inspect } from 'util';
+
+export function handleError(func) {
+  return (req, res) => {
+    func(req, res).catch(err => {
+      console.log('Error', req.originalUrl, inspect(err, { depth: null }));
+      res.send({
+        status: 'ok',
+        data: {
+          error_code: 'INTERNAL_ERROR',
+          error_type: err.message ? err.message : 'internal-error',
+        },
+      });
+    });
+  };
+}

package/src/app-gocardless/utils.js

@@ -0,0 +1,45 @@
+export const printIban = account => {
+  if (account.iban) {
+    return '(XXX ' + account.iban.slice(-4) + ')';
+  } else {
+    return '';
+  }
+};
+
+const compareDates = (
+  /** @type {string | number | Date | undefined} */ a,
+  /** @type {string | number | Date | undefined} */ b,
+) => {
+  if (a == null && b == null) {
+    return 0;
+  } else if (a == null) {
+    return 1;
+  } else if (b == null) {
+    return -1;
+  }
+
+  return +new Date(a) - +new Date(b);
+};
+
+/**
+ * @type {(function(*, *): number)[]}
+ */
+const compareFunctions = [
+  (a, b) => compareDates(a.bookingDate, b.bookingDate),
+  (a, b) => compareDates(a.bookingDateTime, b.bookingDateTime),
+  (a, b) => compareDates(a.valueDate, b.valueDate),
+  (a, b) => compareDates(a.valueDateTime, b.valueDateTime),
+];
+
+export const sortByBookingDateOrValueDate = (transactions = []) =>
+  transactions.sort((a, b) => {
+    for (const sortFunction of compareFunctions) {
+      const result = sortFunction(b, a);
+      if (result !== 0) {
+        return result;
+      }
+    }
+    return 0;
+  });
+
+export const amountToInteger = n => Math.round(n * 100);

package/src/app-openid.js

@@ -0,0 +1,108 @@
+import express from 'express';
+
+import { disableOpenID, enableOpenID, isAdmin } from './account-db.js';
+import {
+  isValidRedirectUrl,
+  loginWithOpenIdFinalize,
+} from './accounts/openid.js';
+import { checkPassword } from './accounts/password.js';
+import * as UserService from './services/user-service.js';
+import {
+  errorMiddleware,
+  requestLoggerMiddleware,
+  validateSessionMiddleware,
+} from './util/middlewares.js';
+
+const app = express();
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+app.use(requestLoggerMiddleware);
+export { app as handlers };
+
+app.post('/enable', validateSessionMiddleware, async (req, res) => {
+  if (!isAdmin(res.locals.user_id)) {
+    res.status(403).send({
+      status: 'error',
+      reason: 'forbidden',
+      details: 'permission-not-found',
+    });
+    return;
+  }
+
+  const { error } = (await enableOpenID(req.body)) || {};
+
+  if (error) {
+    res.status(500).send({ status: 'error', reason: error });
+    return;
+  }
+  res.send({ status: 'ok' });
+});
+
+app.post('/disable', validateSessionMiddleware, async (req, res) => {
+  if (!isAdmin(res.locals.user_id)) {
+    res.status(403).send({
+      status: 'error',
+      reason: 'forbidden',
+      details: 'permission-not-found',
+    });
+    return;
+  }
+
+  const { error } = (await disableOpenID(req.body)) || {};
+
+  if (error) {
+    res.status(401).send({ status: 'error', reason: error });
+    return;
+  }
+  res.send({ status: 'ok' });
+});
+
+app.post('/config', async (req, res) => {
+  const { cnt: ownerCount } = UserService.getOwnerCount() || {};
+
+  if (ownerCount > 0) {
+    res.status(400).send({ status: 'error', reason: 'already-bootstraped' });
+    return;
+  }
+
+  if (!checkPassword(req.body.password)) {
+    res.status(400).send({ status: 'error', reason: 'invalid-password' });
+    return;
+  }
+
+  const auth = UserService.getOpenIDConfig();
+
+  if (!auth) {
+    res
+      .status(500)
+      .send({ status: 'error', reason: 'OpenID configuration not found' });
+    return;
+  }
+
+  try {
+    const openIdConfig = JSON.parse(auth.extra_data);
+    res.send({ status: 'ok', data: { openId: openIdConfig } });
+  } catch (error) {
+    res
+      .status(500)
+      .send({ status: 'error', reason: 'Invalid OpenID configuration' });
+  }
+});
+
+app.get('/callback', async (req, res) => {
+  const { error, url } = await loginWithOpenIdFinalize(req.query);
+
+  if (error) {
+    res.status(400).send({ status: 'error', reason: error });
+    return;
+  }
+
+  if (!isValidRedirectUrl(url)) {
+    res.status(400).send({ status: 'error', reason: 'Invalid redirect URL' });
+    return;
+  }
+
+  res.redirect(url);
+});
+
+app.use(errorMiddleware);

package/src/app-pluggyai/app-pluggyai.js

@@ -0,0 +1,215 @@
+import express from 'express';
+
+import { handleError } from '../app-gocardless/util/handle-error.js';
+import { SecretName, secretsService } from '../services/secrets-service.js';
+import { requestLoggerMiddleware } from '../util/middlewares.js';
+
+import { pluggyaiService } from './pluggyai-service.js';
+
+const app = express();
+export { app as handlers };
+app.use(express.json());
+app.use(requestLoggerMiddleware);
+
+app.post(
+  '/status',
+  handleError(async (req, res) => {
+    const clientId = secretsService.get(SecretName.pluggyai_clientId);
+    const configured = clientId != null;
+
+    res.send({
+      status: 'ok',
+      data: {
+        configured,
+      },
+    });
+  }),
+);
+
+app.post(
+  '/accounts',
+  handleError(async (req, res) => {
+    try {
+      const itemIds = secretsService
+        .get(SecretName.pluggyai_itemIds)
+        .split(',')
+        .map(item => item.trim());
+
+      let accounts = [];
+
+      for (const item of itemIds) {
+        const partial = await pluggyaiService.getAccountsByItemId(item);
+        accounts = accounts.concat(partial.results);
+      }
+
+      res.send({
+        status: 'ok',
+        data: {
+          accounts,
+        },
+      });
+    } catch (error) {
+      res.send({
+        status: 'ok',
+        data: {
+          error: error.message,
+        },
+      });
+    }
+  }),
+);
+
+app.post(
+  '/transactions',
+  handleError(async (req, res) => {
+    const { accountId, startDate } = req.body;
+
+    try {
+      const transactions = await pluggyaiService.getTransactions(
+        accountId,
+        startDate,
+      );
+
+      const account = await pluggyaiService.getAccountById(accountId);
+
+      let startingBalance = parseInt(
+        Math.round(account.balance * 100).toString(),
+      );
+      if (account.type === 'CREDIT') {
+        startingBalance = -startingBalance;
+      }
+      const date = getDate(new Date(account.updatedAt));
+
+      const balances = [
+        {
+          balanceAmount: {
+            amount: startingBalance,
+            currency: account.currencyCode,
+          },
+          balanceType: 'expected',
+          referenceDate: date,
+        },
+      ];
+
+      const all = [];
+      const booked = [];
+      const pending = [];
+
+      for (const trans of transactions) {
+        const newTrans = {};
+
+        newTrans.booked = !(trans.status === 'PENDING');
+
+        const transactionDate = new Date(trans.date);
+
+        if (transactionDate < startDate && !trans.sandbox) {
+          continue;
+        }
+
+        newTrans.date = getDate(transactionDate);
+        newTrans.payeeName = getPayeeName(trans);
+        newTrans.notes = trans.descriptionRaw || trans.description;
+
+        if (account.type === 'CREDIT') {
+          if (trans.amountInAccountCurrency) {
+            trans.amountInAccountCurrency *= -1;
+          }
+
+          trans.amount *= -1;
+        }
+
+        let amountInCurrency = trans.amountInAccountCurrency ?? trans.amount;
+        amountInCurrency = Math.round(amountInCurrency * 100) / 100;
+
+        newTrans.transactionAmount = {
+          amount: amountInCurrency,
+          currency: trans.currencyCode,
+        };
+
+        newTrans.transactionId = trans.id;
+        newTrans.sortOrder = transactionDate.getTime();
+
+        delete trans.amount;
+
+        const finalTrans = { ...flattenObject(trans), ...newTrans };
+        if (newTrans.booked) {
+          booked.push(finalTrans);
+        } else {
+          pending.push(finalTrans);
+        }
+        all.push(finalTrans);
+      }
+
+      const sortFunction = (a, b) => b.sortOrder - a.sortOrder;
+
+      const bookedSorted = booked.sort(sortFunction);
+      const pendingSorted = pending.sort(sortFunction);
+      const allSorted = all.sort(sortFunction);
+
+      res.send({
+        status: 'ok',
+        data: {
+          balances,
+          startingBalance,
+          transactions: {
+            all: allSorted,
+            booked: bookedSorted,
+            pending: pendingSorted,
+          },
+        },
+      });
+    } catch (error) {
+      res.send({
+        status: 'ok',
+        data: {
+          error: error.message,
+        },
+      });
+    }
+    return;
+  }),
+);
+
+function getDate(date) {
+  return date.toISOString().split('T')[0];
+}
+
+function flattenObject(obj, prefix = '') {
+  const result = {};
+
+  for (const [key, value] of Object.entries(obj)) {
+    const newKey = prefix ? `${prefix}.${key}` : key;
+
+    if (value === null) {
+      continue;
+    }
+
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      Object.assign(result, flattenObject(value, newKey));
+    } else {
+      result[newKey] = value;
+    }
+  }
+
+  return result;
+}
+
+function getPayeeName(trans) {
+  if (trans.merchant && (trans.merchant.name || trans.merchant.businessName)) {
+    return trans.merchant.name || trans.merchant.businessName || '';
+  }
+
+  if (trans.paymentData) {
+    const { receiver, payer } = trans.paymentData;
+
+    if (trans.type === 'DEBIT' && receiver) {
+      return receiver.name || receiver.documentNumber?.value || '';
+    }
+
+    if (trans.type === 'CREDIT' && payer) {
+      return payer.name || payer.documentNumber?.value || '';
+    }
+  }
+
+  return '';
+}

package/src/app-pluggyai/pluggyai-service.js

@@ -0,0 +1,120 @@
+import { PluggyClient } from 'pluggy-sdk';
+
+import { SecretName, secretsService } from '../services/secrets-service.js';
+
+let pluggyClient = null;
+
+function getPluggyClient() {
+  if (!pluggyClient) {
+    const clientId = secretsService.get(SecretName.pluggyai_clientId);
+    const clientSecret = secretsService.get(SecretName.pluggyai_clientSecret);
+
+    pluggyClient = new PluggyClient({
+      clientId,
+      clientSecret,
+    });
+  }
+
+  return pluggyClient;
+}
+
+export const pluggyaiService = {
+  isConfigured: () => {
+    return !!(
+      secretsService.get(SecretName.pluggyai_clientId) &&
+      secretsService.get(SecretName.pluggyai_clientSecret) &&
+      secretsService.get(SecretName.pluggyai_itemIds)
+    );
+  },
+
+  getAccountsByItemId: async itemId => {
+    try {
+      const client = getPluggyClient();
+      const { results, total, ...rest } = await client.fetchAccounts(itemId);
+      return {
+        results,
+        total,
+        ...rest,
+        hasError: false,
+        errors: {},
+      };
+    } catch (error) {
+      console.error(`Error fetching accounts: ${error.message}`);
+      throw error;
+    }
+  },
+  getAccountById: async accountId => {
+    try {
+      const client = getPluggyClient();
+      const account = await client.fetchAccount(accountId);
+      return {
+        ...account,
+        hasError: false,
+        errors: {},
+      };
+    } catch (error) {
+      console.error(`Error fetching account: ${error.message}`);
+      throw error;
+    }
+  },
+
+  getTransactionsByAccountId: async (accountId, startDate, pageSize, page) => {
+    try {
+      const client = getPluggyClient();
+
+      const account = await pluggyaiService.getAccountById(accountId);
+
+      // the sandbox data doesn't move the dates automatically so the
+      // transactions are often older than 90 days. The owner on one of the
+      // sandbox accounts is set to John Doe so in these cases we'll ignore
+      // the start date.
+      const sandboxAccount = account.owner === 'John Doe';
+
+      if (sandboxAccount) startDate = '2000-01-01';
+
+      const transactions = await client.fetchTransactions(accountId, {
+        from: startDate,
+        pageSize,
+        page,
+      });
+
+      if (sandboxAccount) {
+        transactions.results = transactions.results.map(t => ({
+          ...t,
+          sandbox: true,
+        }));
+      }
+
+      return {
+        ...transactions,
+        hasError: false,
+        errors: {},
+      };
+    } catch (error) {
+      console.error(`Error fetching transactions: ${error.message}`);
+      throw error;
+    }
+  },
+  getTransactions: async (accountId, startDate) => {
+    let transactions = [];
+    let result = await pluggyaiService.getTransactionsByAccountId(
+      accountId,
+      startDate,
+      500,
+      1,
+    );
+    transactions = transactions.concat(result.results);
+    const totalPages = result.totalPages;
+    while (result.page !== totalPages) {
+      result = await pluggyaiService.getTransactionsByAccountId(
+        accountId,
+        startDate,
+        500,
+        result.page + 1,
+      );
+      transactions = transactions.concat(result.results);
+    }
+
+    return transactions;
+  },
+};