@actual-app/core 26.3.0

package/src/platform/server/asyncStorage/index.ts

@@ -0,0 +1,126 @@
+// @ts-strict-ignore
+import type { GlobalPrefsJson } from '../../../types/prefs';
+import { getDatabase } from '../indexeddb';
+
+import type * as T from './index-types';
+
+export const init: T.Init = function () {
+  // No need to initialise in the browser
+};
+
+export const getItem: T.GetItem = async function (key) {
+  const db = await getDatabase();
+
+  const transaction = db.transaction(['asyncStorage'], 'readonly');
+  const objectStore = transaction.objectStore('asyncStorage');
+
+  return new Promise((resolve, reject) => {
+    const req = objectStore.get(key);
+    req.onerror = e => reject(e);
+    // @ts-expect-error fix me
+    req.onsuccess = e => resolve(e.target.result);
+  });
+};
+
+export const setItem: T.SetItem = async function (key, value) {
+  const db = await getDatabase();
+
+  const transaction = db.transaction(['asyncStorage'], 'readwrite');
+  const objectStore = transaction.objectStore('asyncStorage');
+
+  void new Promise((resolve, reject) => {
+    const req = objectStore.put(value, key);
+    req.onerror = e => reject(e);
+    req.onsuccess = () => resolve(undefined);
+    transaction.commit();
+  });
+};
+
+export const removeItem: T.RemoveItem = async function (key) {
+  const db = await getDatabase();
+
+  const transaction = db.transaction(['asyncStorage'], 'readwrite');
+  const objectStore = transaction.objectStore('asyncStorage');
+
+  return new Promise((resolve, reject) => {
+    const req = objectStore.delete(key);
+    req.onerror = e => reject(e);
+    req.onsuccess = () => resolve(undefined);
+    transaction.commit();
+  });
+};
+
+export async function multiGet<K extends readonly (keyof GlobalPrefsJson)[]>(
+  keys: K,
+): Promise<{ [P in K[number]]: GlobalPrefsJson[P] }> {
+  const db = await getDatabase();
+
+  const transaction = db.transaction(['asyncStorage'], 'readonly');
+  const objectStore = transaction.objectStore('asyncStorage');
+
+  const results = await Promise.all(
+    keys.map(key => {
+      return new Promise<[K[number], GlobalPrefsJson[K[number]]]>(
+        (resolve, reject) => {
+          const req = objectStore.get(key);
+          req.onerror = e => reject(e);
+          req.onsuccess = e => {
+            const target = e.target as IDBRequest<GlobalPrefsJson[K[number]]>;
+            resolve([key, target.result]);
+          };
+        },
+      );
+    }),
+  );
+
+  transaction.commit();
+
+  // Convert the array of tuples to an object with properly typed properties
+  return results.reduce(
+    (acc, [key, value]) => {
+      acc[key] = value;
+      return acc;
+    },
+    {} as { [P in K[number]]: GlobalPrefsJson[P] },
+  );
+}
+
+export const multiSet: T.MultiSet = async function (keyValues) {
+  const db = await getDatabase();
+
+  const transaction = db.transaction(['asyncStorage'], 'readwrite');
+  const objectStore = transaction.objectStore('asyncStorage');
+
+  const promise = Promise.all(
+    keyValues.map(([key, value]) => {
+      return new Promise((resolve, reject) => {
+        const req = objectStore.put(value, key);
+        req.onerror = e => reject(e);
+        req.onsuccess = () => resolve(undefined);
+      });
+    }),
+  );
+
+  transaction.commit();
+  await promise;
+};
+
+export const multiRemove: T.MultiRemove = async function (keys) {
+  const db = await getDatabase();
+
+  const transaction = db.transaction(['asyncStorage'], 'readwrite');
+  const objectStore = transaction.objectStore('asyncStorage');
+
+  const promise = Promise.all(
+    keys.map(key => {
+      return new Promise((resolve, reject) => {
+        const req = objectStore.delete(key);
+        req.onerror = e => reject(e);
+        req.onsuccess = () => resolve(undefined);
+      });
+    }),
+  );
+
+  transaction.commit();
+  await promise;
+};

package/src/platform/server/connection/README.md

@@ -0,0 +1,3 @@
+# Server-side connection package
+
+This is the server counterpart of the `connection` client-side package (packages/loot-core/src/platform/client/connection). This contains methods to receive, reply, and push messages from/to the client web application.

package/src/platform/server/connection/__mocks__/index.ts

@@ -0,0 +1,15 @@
+import type * as T from '../index-types';
+
+let events = [];
+
+export const init: T.Init = function () {
+  // No need to initialise in tests
+};
+
+export const send: T.Send = function (type, args) {
+  events.push([type, args]);
+};
+
+export const resetEvents: T.ResetEvents = function () {
+  events = [];
+};

package/src/platform/server/connection/index-types.ts

@@ -0,0 +1,20 @@
+import type { Handlers } from '../../../types/handlers';
+import type { ServerEvents } from '../../../types/server-events';
+
+export declare function init(
+  channel: Window | number, // in electron the port number, in web the worker
+  handlers: Handlers,
+): void;
+export type Init = typeof init;
+
+export declare function send<K extends keyof ServerEvents>(
+  type: K,
+  args?: ServerEvents[K],
+): void;
+export type Send = typeof send;
+
+export declare function getNumClients(): number;
+export type GetNumClients = typeof getNumClients;
+
+export declare function resetEvents(): void;
+export type ResetEvents = typeof resetEvents;

package/src/platform/server/connection/index.api.ts

@@ -0,0 +1,13 @@
+import type * as T from './index-types';
+
+export const init: T.Init = function () {
+  // Nothing
+};
+
+export const send: T.Send = function () {
+  // Nothing
+};
+
+export const getNumClients: T.GetNumClients = function () {
+  return 1;
+};

package/src/platform/server/connection/index.electron.ts

@@ -0,0 +1,102 @@
+// @ts-strict-ignore
+import { APIError } from '../../../server/errors';
+import { isMutating, runHandler } from '../../../server/mutators';
+import { captureException } from '../../exceptions';
+import { logger } from '../log';
+
+import type * as T from './index-types';
+
+function coerceError(error) {
+  if (error.type && error.type === 'APIError') {
+    return error;
+  }
+
+  return { type: 'ServerError', message: error.message, cause: error };
+}
+
+export const init: T.Init = function (_socketName, handlers) {
+  process.parentPort.on('message', ({ data }) => {
+    const { id, name, args, undoTag, catchErrors } = data;
+
+    if (handlers[name]) {
+      runHandler(handlers[name], args, { undoTag, name }).then(
+        result => {
+          if (catchErrors) {
+            result = { data: result, error: null };
+          }
+
+          process.parentPort.postMessage({
+            type: 'reply',
+            id,
+            result,
+            mutated:
+              isMutating(handlers[name]) && name !== 'undo' && name !== 'redo',
+            undoTag,
+          });
+        },
+        nativeError => {
+          const error = coerceError(nativeError);
+
+          if (name.startsWith('api/')) {
+            // The API is newer and does automatically forward
+            // errors
+            process.parentPort.postMessage({
+              type: 'reply',
+              id,
+              error,
+            });
+          } else if (catchErrors) {
+            process.parentPort.postMessage({
+              type: 'reply',
+              id,
+              result: { error, data: null },
+            });
+          } else {
+            process.parentPort.postMessage({ type: 'error', id, error });
+          }
+
+          if (error.type === 'ServerError' && name !== 'api/load-budget') {
+            captureException(nativeError);
+          }
+
+          if (!catchErrors) {
+            // Notify the frontend that something bad happend
+            send('server-error');
+          }
+        },
+      );
+    } else {
+      logger.error('Unknown server method: ' + name);
+      captureException(new Error('Unknown server method: ' + name));
+      const unknownMethodError = APIError('Unknown server method: ' + name);
+
+      if (catchErrors) {
+        process.parentPort.postMessage({
+          type: 'reply',
+          id,
+          result: catchErrors
+            ? { error: unknownMethodError, data: null }
+            : null,
+        });
+      } else {
+        process.parentPort.postMessage({
+          type: 'error',
+          id,
+          error: unknownMethodError,
+        });
+      }
+    }
+  });
+};
+
+export const getNumClients: T.GetNumClients = function () {
+  return 0;
+};
+
+export const send: T.Send = function (name, args) {
+  process.parentPort.postMessage({ type: 'push', name, args });
+};
+
+export const resetEvents: T.ResetEvents = function () {
+  // resetEvents is used in tests to mock the server
+};

package/src/platform/server/connection/index.ts

@@ -0,0 +1,154 @@
+// @ts-strict-ignore
+import { APIError } from '../../../server/errors';
+import { isMutating, runHandler } from '../../../server/mutators';
+import { captureException } from '../../exceptions';
+import { logger } from '../log';
+
+import type * as T from './index-types';
+
+function getGlobalObject() {
+  const obj =
+    typeof window !== 'undefined'
+      ? window
+      : typeof self !== 'undefined'
+        ? self
+        : null;
+  if (!obj) {
+    throw new Error('Cannot get global object');
+  }
+  return obj as unknown as typeof globalThis & {
+    __globalServerChannel: Window | null;
+  };
+}
+
+getGlobalObject().__globalServerChannel = null;
+
+function coerceError(error) {
+  if (error.type && error.type === 'APIError') {
+    return error;
+  }
+
+  return { type: 'ServerError', message: error.message, cause: error };
+}
+
+export const init: T.Init = function (serverChn, handlers) {
+  const serverChannel = serverChn as Window;
+  getGlobalObject().__globalServerChannel = serverChannel;
+
+  serverChannel.addEventListener(
+    'message',
+    e => {
+      const data = e.data;
+      const msg = typeof data === 'string' ? JSON.parse(data) : data;
+
+      if (msg.type && (msg.type === 'init' || msg.type.startsWith('__'))) {
+        return;
+      }
+
+      if (msg.name === 'client-connected-to-backend') {
+        // the client is indicating that it is connected to this backend. Stop attempting to connect
+        logger.info('Backend: Client connected');
+        clearInterval(reconnectToClientInterval);
+        return;
+      }
+
+      const { id, name, args, undoTag, catchErrors } = msg;
+
+      if (handlers[name]) {
+        runHandler(handlers[name], args, { undoTag, name }).then(
+          result => {
+            serverChannel.postMessage({
+              type: 'reply',
+              id,
+              result: catchErrors ? { data: result, error: null } : result,
+              mutated: isMutating(handlers[name]),
+              undoTag,
+            });
+          },
+          nativeError => {
+            const error = coerceError(nativeError);
+
+            if (name.startsWith('api/')) {
+              // The API is newer and does automatically forward
+              // errors
+              serverChannel.postMessage({ type: 'reply', id, error });
+            } else if (catchErrors) {
+              serverChannel.postMessage({
+                type: 'reply',
+                id,
+                result: { error, data: null },
+              });
+            } else {
+              serverChannel.postMessage({ type: 'error', id, error });
+            }
+
+            // Only report internal errors
+            if (error.type === 'ServerError') {
+              captureException(nativeError);
+            }
+
+            if (!catchErrors) {
+              // Notify the frontend that something bad happend
+              send('server-error');
+            }
+          },
+        );
+      } else {
+        logger.error('Unknown server method: ' + name);
+        captureException(new Error('Unknown server method: ' + name));
+        const unknownMethodError = APIError('Unknown server method: ' + name);
+
+        if (catchErrors) {
+          serverChannel.postMessage({
+            type: 'reply',
+            id,
+            result: catchErrors
+              ? { error: unknownMethodError, data: null }
+              : null,
+          });
+        } else {
+          serverChannel.postMessage({
+            type: 'error',
+            id,
+            error: unknownMethodError,
+          });
+        }
+      }
+    },
+    false,
+  );
+
+  const RECONNECT_INTERVAL_MS = 200;
+  const MAX_RECONNECT_ATTEMPTS = 500;
+  let reconnectAttempts = 0;
+
+  const reconnectToClientInterval = setInterval(() => {
+    logger.info('Backend: Trying to connect to client');
+    serverChannel.postMessage({ type: 'connect' });
+    reconnectAttempts++;
+    if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+      // Failed to connect to client - signal server error
+      send('server-error');
+      clearInterval(reconnectToClientInterval);
+    }
+  }, RECONNECT_INTERVAL_MS);
+};
+
+export const send: T.Send = function (name, args) {
+  const { __globalServerChannel } = getGlobalObject();
+  if (__globalServerChannel) {
+    __globalServerChannel.postMessage({
+      type: 'push',
+      name,
+      args,
+    });
+  }
+};
+
+export const getNumClients = function () {
+  return 1;
+};
+
+export const resetEvents: T.ResetEvents = function () {
+  // resetEvents is used in tests to mock the server
+};

package/src/platform/server/fetch/__mocks__/index.ts

@@ -0,0 +1,3 @@
+export const fetch = function () {
+  throw new Error('fetch not implemented');
+};

package/src/platform/server/fetch/index.api.ts

@@ -0,0 +1 @@
+export const fetch = globalThis.fetch;

package/src/platform/server/fetch/index.electron.ts

@@ -0,0 +1,18 @@
+import { logger } from '../log';
+
+import type * as T from './index';
+
+export const fetch: typeof T.fetch = async (input, options) => {
+  try {
+    return await globalThis.fetch(input, {
+      ...options,
+      headers: {
+        ...options?.headers,
+        origin: 'app://actual',
+      },
+    });
+  } catch (error) {
+    logger.error(error); // log error
+    throw error;
+  }
+};

package/src/platform/server/fetch/index.ts

@@ -0,0 +1,20 @@
+import * as connection from '../connection';
+
+export const fetch = async (
+  input: RequestInfo | URL,
+  options: RequestInit = {},
+): Promise<Response> => {
+  // Set redirect to manual so that we can detect and respond to redirects.
+  if (!options.redirect) options.redirect = 'manual';
+
+  const response = await globalThis.fetch(input, options);
+
+  // Authentication proxies redirect when authentication has expired. In this case,
+  // we want to fully reload and yeild control from the service worker back to the server.
+  if (response.type === 'opaqueredirect') {
+    connection.send('api-fetch-redirected');
+    throw new Error(`API request redirected`);
+  }
+
+  return response;
+};

package/src/platform/server/fs/index.api.ts

@@ -0,0 +1,198 @@
+// @ts-strict-ignore
+import * as fs from 'fs';
+import * as path from 'path';
+
+import promiseRetry from 'promise-retry';
+
+import { logger } from '../log';
+
+import type * as T from './index';
+
+export { getDocumentDir, getBudgetDir, _setDocumentDir } from './shared';
+
+export const init: typeof T.init = async () => {
+  // Nothing to do
+};
+
+export const getDataDir: typeof T.getDataDir = () => {
+  if (!process.env.ACTUAL_DATA_DIR) {
+    throw new Error('ACTUAL_DATA_DIR env variable is required');
+  }
+  return process.env.ACTUAL_DATA_DIR;
+};
+
+export const bundledDatabasePath: typeof T.bundledDatabasePath = path.join(
+  __dirname,
+  'default-db.sqlite',
+);
+
+export const migrationsPath: typeof T.migrationsPath = path.join(
+  __dirname,
+  'migrations',
+);
+
+export const demoBudgetPath: typeof T.demoBudgetPath = path.join(
+  __dirname,
+  'demo-budget',
+);
+
+export const join: typeof T.join = (...args: Parameters<typeof path.join>) =>
+  path.join(...args);
+
+export const basename: typeof T.basename = filepath => path.basename(filepath);
+
+export const listDir: typeof T.listDir = filepath =>
+  new Promise((resolve, reject) => {
+    fs.readdir(filepath, (err, files) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(files);
+      }
+    });
+  });
+
+export const exists: typeof T.exists = filepath =>
+  new Promise(resolve => {
+    fs.access(filepath, fs.constants.F_OK, err => {
+      return resolve(!err);
+    });
+  });
+
+export const mkdir: typeof T.mkdir = filepath =>
+  new Promise((resolve, reject) => {
+    fs.mkdir(filepath, err => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(undefined);
+      }
+    });
+  });
+
+export const size: typeof T.size = filepath =>
+  new Promise((resolve, reject) => {
+    fs.stat(filepath, (err, stats) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(stats.size);
+      }
+    });
+  });
+
+export const copyFile: typeof T.copyFile = (frompath, topath) => {
+  return new Promise<boolean>((resolve, reject) => {
+    const readStream = fs.createReadStream(frompath);
+    const writeStream = fs.createWriteStream(topath);
+
+    readStream.on('error', reject);
+    writeStream.on('error', reject);
+
+    writeStream.on('open', () => readStream.pipe(writeStream));
+    writeStream.once('close', () => resolve(true));
+  });
+};
+
+export const readFile: typeof T.readFile = (
+  filepath: string,
+  encoding: 'utf8' | 'binary' | null = 'utf8',
+) => {
+  if (encoding === 'binary') {
+    // `binary` is not actually a valid encoding, you pass `null` into node if
+    // you want a buffer
+    encoding = null;
+  }
+  // `any` as cannot refine return with two function overrides
+  // oxlint-disable-next-line typescript/no-explicit-any
+  return new Promise<any>((resolve, reject) => {
+    fs.readFile(filepath, encoding, (err, data) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(data);
+      }
+    });
+  });
+};
+
+export const writeFile: typeof T.writeFile = async (filepath, contents) => {
+  try {
+    await promiseRetry(
+      (retry, attempt) => {
+        return new Promise((resolve, reject) => {
+          fs.writeFile(filepath, contents, 'utf8', err => {
+            if (err) {
+              logger.error(
+                `Failed to write to ${filepath}. Attempted ${attempt} times. Something is locking the file - potentially a virus scanner or backup software.`,
+              );
+              reject(err);
+            } else {
+              if (attempt > 1) {
+                logger.info(
+                  `Successfully recovered from file lock. It took ${attempt} retries`,
+                );
+              }
+              resolve(undefined);
+            }
+          });
+        }).catch(retry);
+      },
+      {
+        retries: 20,
+        minTimeout: 100,
+        maxTimeout: 500,
+        factor: 1.5,
+      },
+    );
+
+    return undefined;
+  } catch (err) {
+    logger.error(`Unable to recover from file lock on file ${filepath}`);
+    throw err;
+  }
+};
+
+export const removeFile: typeof T.removeFile = filepath => {
+  return new Promise(function (resolve, reject) {
+    fs.unlink(filepath, err => {
+      return err ? reject(err) : resolve(undefined);
+    });
+  });
+};
+
+export const removeDir: typeof T.removeDir = dirpath => {
+  return new Promise(function (resolve, reject) {
+    fs.rmdir(dirpath, err => {
+      return err ? reject(err) : resolve(undefined);
+    });
+  });
+};
+
+export const removeDirRecursively: typeof T.removeDirRecursively =
+  async dirpath => {
+    if (await exists(dirpath)) {
+      for (const file of await listDir(dirpath)) {
+        const fullpath = join(dirpath, file);
+        if (fs.statSync(fullpath).isDirectory()) {
+          await removeDirRecursively(fullpath);
+        } else {
+          await removeFile(fullpath);
+        }
+      }
+
+      await removeDir(dirpath);
+    }
+  };
+
+export const getModifiedTime: typeof T.getModifiedTime = filepath => {
+  return new Promise(function (resolve, reject) {
+    fs.stat(filepath, (err, stats) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(new Date(stats.mtime));
+      }
+    });
+  });
+};