@actual-app/sync-server 25.5.0 → 25.6.0

package/build/src/app-openid.js

@@ -0,0 +1,83 @@
+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/build/src/app-pluggyai/app-pluggyai.js

@@ -0,0 +1,164 @@
+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/build/src/app-pluggyai/pluggyai-service.js

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

package/build/src/app-secrets.js

@@ -0,0 +1,48 @@
+import express from 'express';
+import { getAccountDb, isAdmin } from './account-db.js';
+import { secretsService } from './services/secrets-service.js';
+import { requestLoggerMiddleware, validateSessionMiddleware, } from './util/middlewares.js';
+const app = express();
+export { app as handlers };
+app.use(express.json());
+app.use(requestLoggerMiddleware);
+app.use(validateSessionMiddleware);
+app.post('/', async (req, res) => {
+    let method;
+    try {
+        const result = getAccountDb().first('SELECT method FROM auth WHERE active = 1');
+        method = result?.method;
+    }
+    catch (error) {
+        console.error('Failed to fetch auth method:', error);
+        return res.status(500).send({
+            status: 'error',
+            reason: 'database-error',
+            details: 'Failed to validate authentication method',
+        });
+    }
+    const { name, value } = req.body || {};
+    if (method === 'openid') {
+        const canSaveSecrets = isAdmin(res.locals.user_id);
+        if (!canSaveSecrets) {
+            res.status(403).send({
+                status: 'error',
+                reason: 'not-admin',
+                details: 'You have to be admin to set secrets',
+            });
+            return;
+        }
+    }
+    secretsService.set(name, value);
+    res.status(200).send({ status: 'ok' });
+});
+app.get('/:name', async (req, res) => {
+    const name = req.params.name;
+    const keyExists = secretsService.exists(name);
+    if (keyExists) {
+        res.sendStatus(204);
+    }
+    else {
+        res.status(404).send('key not found');
+    }
+});