@actual-app/sync-server 25.5.0 → 25.6.0

package/{app.js → build/app.js}

@@ -1,11 +1,10 @@
 import { run as runMigrations } from './src/migrations.js';
-
 runMigrations()
-  .then(() => {
+    .then(() => {
     //import the app here becasue initial migrations need to be run first - they are dependencies of the app.js
     import('./src/app.js').then(app => app.run()); // run the app
-  })
-  .catch(err => {
+})
+    .catch(err => {
     console.log('Error starting app:', err);
     process.exit(1);
-  });
+});

package/build/bin/actual-server.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseArgs } from 'node:util';
+const args = process.argv;
+const options = {
+    help: {
+        type: 'boolean',
+        short: 'h',
+    },
+    version: {
+        type: 'boolean',
+        short: 'v',
+    },
+    config: {
+        type: 'string',
+    },
+};
+const { values } = parseArgs({
+    args,
+    options,
+    allowPositionals: true,
+});
+if (values.help) {
+    console.log([
+        'usage: actual-server [options]',
+        '',
+        'options:',
+        '  --config           Path to config file',
+        '',
+        '  -h --help          Print this list and exit.',
+        '  -v --version       Print the version and exit.',
+        '',
+        'Examples:',
+        '',
+        'Runs actual-server with default configuration',
+        '  actual-server',
+        '',
+        'Runs actual-server with custom configuration',
+        '  actual-server --config ./config.json',
+    ].join('\n'));
+    process.exit();
+}
+if (values.version) {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const packageJsonPath = resolve(__dirname, '../../package.json');
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    console.log('v' + packageJson.version);
+    process.exit();
+}
+const setupDataDir = (dataDir = undefined) => {
+    if (process.env.ACTUAL_DATA_DIR) {
+        return; // Env variables must not be overwritten
+    }
+    if (dataDir) {
+        process.env.ACTUAL_DATA_DIR = dataDir; // Use the dir specified
+    }
+    else {
+        // Setup defaults
+        if (existsSync('./data')) {
+            // The default data directory exists - use it
+            console.info('Found existing data directory');
+            process.env.ACTUAL_DATA_DIR = resolve('./data');
+        }
+        else {
+            console.info('Using default data directory. You can specify a custom config with --config');
+            process.env.ACTUAL_DATA_DIR = resolve('./');
+        }
+        console.info(`Data directory: ${process.env.ACTUAL_DATA_DIR}`);
+    }
+};
+if (values.config) {
+    const configExists = existsSync(values.config);
+    if (!configExists) {
+        console.log(`Please specify a valid config path. The path ${values.config} does not exist.`);
+        process.exit();
+    }
+    else {
+        console.log(`Loading config from ${values.config}`);
+        const configJson = JSON.parse(readFileSync(values.config, 'utf-8'));
+        process.env.ACTUAL_CONFIG_PATH = values.config;
+        setupDataDir(configJson.dataDir);
+    }
+}
+else {
+    // If no config is specified, check for a default config in the current directory
+    const defaultConfigJsonFile = './config.json';
+    const configExists = existsSync(defaultConfigJsonFile);
+    if (configExists) {
+        console.info('Found config.json in the current directory');
+        const configJson = JSON.parse(readFileSync(defaultConfigJsonFile, 'utf-8'));
+        process.env.ACTUAL_CONFIG_PATH = defaultConfigJsonFile;
+        setupDataDir(configJson.dataDir);
+    }
+    else {
+        setupDataDir(); // No default config exists - setup data dir with defaults
+    }
+}
+// start the sync server
+import('../app.js');

package/build/migrations/1694360000000-create-folders.js

@@ -0,0 +1,21 @@
+import fs from 'node:fs/promises';
+import { config } from '../src/load-config.js';
+async function ensureExists(path) {
+    try {
+        await fs.mkdir(path);
+    }
+    catch (err) {
+        if (err.code === 'EEXIST') {
+            return null;
+        }
+        throw err;
+    }
+}
+export const up = async function () {
+    await ensureExists(config.get('serverFiles'));
+    await ensureExists(config.get('userFiles'));
+};
+export const down = async function () {
+    await fs.rm(config.get('serverFiles'), { recursive: true, force: true });
+    await fs.rm(config.get('userFiles'), { recursive: true, force: true });
+};

package/{migrations → build/migrations}/1694360479680-create-account-db.js

@@ -1,7 +1,6 @@
 import { getAccountDb } from '../src/account-db.js';
-
 export const up = async function () {
-  await getAccountDb().exec(`
+    await getAccountDb().exec(`
     CREATE TABLE IF NOT EXISTS auth
       (password TEXT PRIMARY KEY);
 
@@ -20,9 +19,8 @@ export const up = async function () {
        name TEXT);
   `);
 };
-
 export const down = async function () {
-  await getAccountDb().exec(`
+    await getAccountDb().exec(`
     DROP TABLE auth;
     DROP TABLE sessions;
     DROP TABLE files;

package/{migrations → build/migrations}/1694362247011-create-secret-table.js

@@ -1,16 +1,14 @@
 import { getAccountDb } from '../src/account-db.js';
-
 export const up = async function () {
-  await getAccountDb().exec(`
+    await getAccountDb().exec(`
     CREATE TABLE IF NOT EXISTS secrets (
       name TEXT PRIMARY KEY,
       value BLOB
     );
   `);
 };
-
 export const down = async function () {
-  await getAccountDb().exec(`
+    await getAccountDb().exec(`
     DROP TABLE secrets;
   `);
 };

package/build/migrations/1702667624000-rename-nordigen-secrets.js

@@ -0,0 +1,9 @@
+import { getAccountDb } from '../src/account-db.js';
+export const up = async function () {
+    await getAccountDb().exec(`UPDATE secrets SET name = 'gocardless_secretId' WHERE name = 'nordigen_secretId'`);
+    await getAccountDb().exec(`UPDATE secrets SET name = 'gocardless_secretKey' WHERE name = 'nordigen_secretKey'`);
+};
+export const down = async function () {
+    await getAccountDb().exec(`UPDATE secrets SET name = 'nordigen_secretId' WHERE name = 'gocardless_secretId'`);
+    await getAccountDb().exec(`UPDATE secrets SET name = 'nordigen_secretKey' WHERE name = 'gocardless_secretKey'`);
+};

package/{migrations → build/migrations}/1718889148000-openid.js

@@ -1,8 +1,6 @@
 import { getAccountDb } from '../src/account-db.js';
-
 export const up = async function () {
-  await getAccountDb().exec(
-    `
+    await getAccountDb().exec(`
     BEGIN TRANSACTION;
      CREATE TABLE auth_new
         (method TEXT PRIMARY KEY,
@@ -19,13 +17,10 @@ export const up = async function () {
       code_verifier TEXT,
       return_url TEXT,
       expiry_time INTEGER);
-    COMMIT;`,
-  );
+    COMMIT;`);
 };
-
 export const down = async function () {
-  await getAccountDb().exec(
-    `
+    await getAccountDb().exec(`
     BEGIN TRANSACTION;
     ALTER TABLE auth RENAME TO auth_temp;
     CREATE TABLE auth
@@ -36,6 +31,5 @@ export const down = async function () {
 
     DROP TABLE pending_openid_requests;
     COMMIT;
-      `,
-  );
+      `);
 };

package/{migrations → build/migrations}/1719409568000-multiuser.js

@@ -1,13 +1,9 @@
 import { v4 as uuidv4 } from 'uuid';
-
 import { getAccountDb } from '../src/account-db.js';
-
 export const up = async function () {
-  const accountDb = getAccountDb();
-
-  accountDb.transaction(() => {
-    accountDb.exec(
-      `
+    const accountDb = getAccountDb();
+    accountDb.transaction(() => {
+        accountDb.exec(`
     CREATE TABLE users
         (id TEXT PRIMARY KEY,
         user_name TEXT,
@@ -35,25 +31,14 @@ export const up = async function () {
 
     ALTER TABLE sessions
         ADD COLUMN auth_method TEXT;
-        `,
-    );
-
-    const userId = uuidv4();
-    accountDb.mutate(
-      'INSERT INTO users (id, user_name, display_name, enabled, owner, role) VALUES (?, ?, ?, 1, 1, ?)',
-      [userId, '', '', 'ADMIN'],
-    );
-
-    accountDb.mutate(
-      'UPDATE sessions SET user_id = ?, expires_at = ?, auth_method = ? WHERE auth_method IS NULL',
-      [userId, -1, 'password'],
-    );
-  });
+        `);
+        const userId = uuidv4();
+        accountDb.mutate('INSERT INTO users (id, user_name, display_name, enabled, owner, role) VALUES (?, ?, ?, 1, 1, ?)', [userId, '', '', 'ADMIN']);
+        accountDb.mutate('UPDATE sessions SET user_id = ?, expires_at = ?, auth_method = ? WHERE auth_method IS NULL', [userId, -1, 'password']);
+    });
 };
-
 export const down = async function () {
-  await getAccountDb().exec(
-    `
+    await getAccountDb().exec(`
       BEGIN TRANSACTION;
 
       DROP TABLE IF EXISTS user_access;
@@ -111,6 +96,5 @@ export const down = async function () {
       DROP TABLE IF EXISTS users;
 
       COMMIT;
-      `,
-  );
+      `);
 };

package/build/src/account-db.js

@@ -0,0 +1,182 @@
+import { join, resolve } from 'node:path';
+import * as bcrypt from 'bcrypt';
+import { bootstrapOpenId } from './accounts/openid.js';
+import { bootstrapPassword, loginWithPassword } from './accounts/password.js';
+import { openDatabase } from './db.js';
+import { config } from './load-config.js';
+let _accountDb;
+export function getAccountDb() {
+    if (_accountDb === undefined) {
+        const dbPath = join(resolve(config.get('serverFiles')), 'account.sqlite');
+        _accountDb = openDatabase(dbPath);
+    }
+    return _accountDb;
+}
+export function needsBootstrap() {
+    const accountDb = getAccountDb();
+    const rows = accountDb.all('SELECT * FROM auth');
+    return rows.length === 0;
+}
+export function listLoginMethods() {
+    const accountDb = getAccountDb();
+    const rows = accountDb.all('SELECT method, display_name, active FROM auth');
+    return rows
+        .filter(f => rows.length > 1 && config.get('enforceOpenId')
+        ? f.method === 'openid'
+        : true)
+        .map(r => ({
+        method: r.method,
+        active: r.active,
+        displayName: r.display_name,
+    }));
+}
+export function getActiveLoginMethod() {
+    const accountDb = getAccountDb();
+    const { method } = accountDb.first('SELECT method FROM auth WHERE active = 1') || {};
+    return method;
+}
+/*
+ * Get the Login Method in the following order
+ * req (the frontend can say which method in the case it wants to resort to forcing password auth)
+ * config options
+ * fall back to using password
+ */
+export function getLoginMethod(req) {
+    if (typeof req !== 'undefined' &&
+        (req.body || { loginMethod: null }).loginMethod &&
+        config.get('allowedLoginMethods').includes(req.body.loginMethod)) {
+        return req.body.loginMethod;
+    }
+    //BY-PASS ANY OTHER CONFIGURATION TO ENSURE HEADER AUTH
+    if (config.get('loginMethod') === 'header' &&
+        config.get('allowedLoginMethods').includes('header')) {
+        return config.get('loginMethod');
+    }
+    const activeMethod = getActiveLoginMethod();
+    return activeMethod || config.get('loginMethod');
+}
+export async function bootstrap(loginSettings, forced = false) {
+    if (!loginSettings) {
+        return { error: 'invalid-login-settings' };
+    }
+    const passEnabled = 'password' in loginSettings;
+    const openIdEnabled = 'openId' in loginSettings;
+    const accountDb = getAccountDb();
+    accountDb.mutate('BEGIN TRANSACTION');
+    try {
+        const { countOfOwner } = accountDb.first(`SELECT count(*) as countOfOwner
+   FROM users
+   WHERE users.user_name <> '' and users.owner = 1`) || {};
+        if (!forced && (!openIdEnabled || countOfOwner > 0)) {
+            if (!needsBootstrap()) {
+                accountDb.mutate('ROLLBACK');
+                return { error: 'already-bootstrapped' };
+            }
+        }
+        if (!passEnabled && !openIdEnabled) {
+            accountDb.mutate('ROLLBACK');
+            return { error: 'no-auth-method-selected' };
+        }
+        if (passEnabled && openIdEnabled && !forced) {
+            accountDb.mutate('ROLLBACK');
+            return { error: 'max-one-method-allowed' };
+        }
+        if (passEnabled) {
+            const { error } = bootstrapPassword(loginSettings.password);
+            if (error) {
+                accountDb.mutate('ROLLBACK');
+                return { error };
+            }
+        }
+        if (openIdEnabled && forced) {
+            const { error } = await bootstrapOpenId(loginSettings.openId);
+            if (error) {
+                accountDb.mutate('ROLLBACK');
+                return { error };
+            }
+        }
+        accountDb.mutate('COMMIT');
+        return passEnabled ? loginWithPassword(loginSettings.password) : {};
+    }
+    catch (error) {
+        accountDb.mutate('ROLLBACK');
+        throw error;
+    }
+}
+export function isAdmin(userId) {
+    return hasPermission(userId, 'ADMIN');
+}
+export function hasPermission(userId, permission) {
+    return getUserPermission(userId) === permission;
+}
+export async function enableOpenID(loginSettings) {
+    if (!loginSettings || !loginSettings.openId) {
+        return { error: 'invalid-login-settings' };
+    }
+    const { error } = (await bootstrapOpenId(loginSettings.openId)) || {};
+    if (error) {
+        return { error };
+    }
+    getAccountDb().mutate('DELETE FROM sessions');
+}
+export async function disableOpenID(loginSettings) {
+    if (!loginSettings || !loginSettings.password) {
+        return { error: 'invalid-login-settings' };
+    }
+    const accountDb = getAccountDb();
+    const { extra_data: passwordHash } = accountDb.first('SELECT extra_data FROM auth WHERE method = ?', [
+        'password',
+    ]) || {};
+    if (!passwordHash) {
+        return { error: 'invalid-password' };
+    }
+    if (!loginSettings?.password) {
+        return { error: 'invalid-password' };
+    }
+    if (passwordHash) {
+        const confirmed = bcrypt.compareSync(loginSettings.password, passwordHash);
+        if (!confirmed) {
+            return { error: 'invalid-password' };
+        }
+    }
+    const { error } = (await bootstrapPassword(loginSettings.password)) || {};
+    if (error) {
+        return { error };
+    }
+    try {
+        accountDb.transaction(() => {
+            accountDb.mutate('DELETE FROM sessions');
+            accountDb.mutate(`DELETE FROM user_access
+                              WHERE user_access.user_id IN (
+                                  SELECT users.id
+                                  FROM users
+                                  WHERE users.user_name <> ?
+                              );`, ['']);
+            accountDb.mutate('DELETE FROM users WHERE user_name <> ?', ['']);
+            accountDb.mutate('DELETE FROM auth WHERE method = ?', ['openid']);
+        });
+    }
+    catch (err) {
+        console.error('Error cleaning up openid information:', err);
+        return { error: 'database-error' };
+    }
+}
+export function getSession(token) {
+    const accountDb = getAccountDb();
+    return accountDb.first('SELECT * FROM sessions WHERE token = ?', [token]);
+}
+export function getUserInfo(userId) {
+    const accountDb = getAccountDb();
+    return accountDb.first('SELECT * FROM users WHERE id = ?', [userId]);
+}
+export function getUserPermission(userId) {
+    const accountDb = getAccountDb();
+    const { role } = accountDb.first(`SELECT role FROM users
+          WHERE users.id = ?`, [userId]) || { role: '' };
+    return role;
+}
+export function clearExpiredSessions() {
+    const clearThreshold = Math.floor(Date.now() / 1000) - 3600;
+    const deletedSessions = getAccountDb().mutate('DELETE FROM sessions WHERE expires_at <> -1 and expires_at < ?', [clearThreshold]).changes;
+    console.log(`Deleted ${deletedSessions} old sessions`);
+}