@actual-app/core 26.3.0

package/src/platform/client/connection/index.browser.ts

@@ -0,0 +1,213 @@
+// @ts-strict-ignore
+import { t } from 'i18next';
+import { v4 as uuidv4 } from 'uuid';
+
+import { captureBreadcrumb, captureException } from '../../exceptions';
+import * as undo from '../undo';
+
+import type * as T from './index-types';
+
+const replyHandlers = new Map();
+const listeners = new Map();
+let messageQueue = [];
+
+let globalWorker = null;
+
+class ReconstructedError extends Error {
+  url: string;
+  line: string;
+  column: string;
+
+  constructor(message, stack, url, line, column) {
+    super(message);
+    this.name = this.constructor.name;
+    this.message = message;
+
+    Object.defineProperty(this, 'stack', {
+      get: function () {
+        return 'extended ' + this._stack;
+      },
+      set: function (value) {
+        this._stack = value;
+      },
+    });
+
+    this.stack = stack;
+    this.url = url;
+    this.line = line;
+    this.column = column;
+  }
+}
+
+function handleMessage(msg) {
+  if (msg.type === 'error') {
+    // An error happened while handling a message so cleanup the
+    // current reply handler and reject the promise. The error will
+    // be propagated to the caller through this promise rejection.
+    const { id, error } = msg;
+    const handler = replyHandlers.get(id);
+    if (handler) {
+      replyHandlers.delete(id);
+      handler.reject(error);
+    }
+  } else if (msg.type === 'reply') {
+    const { id, result, mutated, undoTag } = msg;
+
+    const handler = replyHandlers.get(id);
+    if (handler) {
+      replyHandlers.delete(id);
+
+      if (!mutated) {
+        undo.gc(undoTag);
+      }
+
+      handler.resolve(result);
+    }
+  } else if (msg.type === 'push') {
+    const { name, args } = msg;
+
+    const listens = listeners.get(name);
+    if (listens) {
+      for (let i = 0; i < listens.length; i++) {
+        const stop = listens[i](args);
+        if (stop === true) {
+          break;
+        }
+      }
+    }
+  } else {
+    // Ignore internal messages that start with __
+    if (!msg.type.startsWith('__')) {
+      throw new Error('Unknown message type: ' + JSON.stringify(msg));
+    }
+  }
+}
+
+// Note that this does not support retry. If the worker
+// dies, it will permanently be disconnected. That should be OK since
+// I don't think a worker should ever die due to a system error.
+function connectWorker(worker, onOpen, onError) {
+  globalWorker = worker;
+
+  worker.onmessage = event => {
+    const msg = event.data;
+
+    // The worker implementation implements its own concept of a
+    // 'connect' event because the worker is immediately
+    // available, but we don't know when the backend is actually
+    // ready to handle messages.
+    if (msg.type === 'connect') {
+      // Send any messages that were queued while closed
+      if (messageQueue?.length > 0) {
+        messageQueue.forEach(msg => worker.postMessage(msg));
+        messageQueue = null;
+      }
+
+      // signal to the backend that we're connected to it
+      globalWorker.postMessage({
+        name: 'client-connected-to-backend',
+      });
+      onOpen();
+    } else if (msg.type === 'app-init-failure') {
+      globalWorker.postMessage({
+        name: '__app-init-failure-acknowledged',
+      });
+      onError(msg);
+    } else if (msg.type === 'capture-exception') {
+      captureException(
+        msg.stack
+          ? new ReconstructedError(
+              msg.message,
+              msg.stack,
+              msg.url,
+              msg.line,
+              msg.column,
+            )
+          : msg.exc,
+      );
+
+      if (msg.message && msg.message.includes('indexeddb-quota-error')) {
+        alert(
+          t(
+            'We hit a limit on the local storage available. Edits may not be saved. Please get in touch https://actualbudget.org/contact/ so we can help debug this.',
+          ),
+        );
+      }
+    } else if (msg.type === 'capture-breadcrumb') {
+      captureBreadcrumb(msg.data);
+    } else {
+      handleMessage(msg);
+    }
+  };
+
+  // In browsers that don't support wasm in workers well (Safari),
+  // we run the server on the main process for now. This might not
+  // actually be a worker, but instead a message port which we
+  // need to start.
+  if (worker instanceof MessagePort) {
+    worker.start();
+  }
+}
+
+export const init: T.Init = async function () {
+  const worker = await global.Actual.getServerSocket();
+  return new Promise((resolve, reject) =>
+    connectWorker(worker, resolve, reject),
+  );
+};
+
+export const send: T.Send = function (
+  ...params: Parameters<T.Send>
+): ReturnType<T.Send> {
+  const [name, args, { catchErrors = false } = {}] = params;
+  return new Promise((resolve, reject) => {
+    const id = uuidv4();
+
+    replyHandlers.set(id, { resolve, reject });
+    const message = {
+      id,
+      name,
+      args,
+      undoTag: undo.snapshot(),
+      catchErrors,
+    };
+    if (messageQueue) {
+      messageQueue.push(message);
+    } else {
+      globalWorker.postMessage(message);
+    }
+  });
+};
+
+export const sendCatch: T.SendCatch = function (name, args) {
+  return send(name, args, { catchErrors: true });
+};
+
+export const listen: T.Listen = function (name, cb) {
+  if (!listeners.get(name)) {
+    listeners.set(name, []);
+  }
+  listeners.get(name).push(cb);
+
+  return () => {
+    const arr = listeners.get(name);
+    listeners.set(
+      name,
+      arr.filter(cb_ => cb_ !== cb),
+    );
+  };
+};
+
+export const unlisten: T.Unlisten = function (name) {
+  listeners.set(name, []);
+};
+
+export const initServer: T.InitServer = async function () {
+  // initServer is used in tests to mock the server
+};
+export const serverPush: T.ServerPush = async function () {
+  // serverPush is used in tests to mock the server
+};
+export const clearServer: T.ClearServer = async function () {
+  // clearServer is used in tests to mock the server
+};

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

@@ -0,0 +1,155 @@
+// @ts-strict-ignore
+import { v4 as uuidv4 } from 'uuid';
+
+import * as undo from '../undo';
+
+import type * as T from './index-types';
+
+const replyHandlers = new Map();
+const listeners = new Map();
+let messageQueue = [];
+let socketClient = null;
+
+function connectSocket(onOpen) {
+  global.Actual.ipcConnect(function (client) {
+    client.on('message', data => {
+      const msg = data;
+
+      if (msg.type === 'error') {
+        // An error happened while handling a message so cleanup the
+        // current reply handler and reject the promise. The error will
+        // be propagated to the caller through this promise rejection.
+        const { id, error } = msg;
+        const handler = replyHandlers.get(id);
+        if (handler) {
+          replyHandlers.delete(id);
+          handler.reject(error);
+        }
+      } else if (msg.type === 'reply') {
+        let { result } = msg;
+        const { id, mutated, undoTag } = msg;
+
+        // Check if the result is a serialized buffer, and if so
+        // convert it to a Uint8Array. This is only needed when working
+        // with node; the web version connection layer automatically
+        // supports buffers
+        if (result && result.type === 'Buffer' && Array.isArray(result.data)) {
+          result = new Uint8Array(result.data);
+        }
+
+        const handler = replyHandlers.get(id);
+        if (handler) {
+          replyHandlers.delete(id);
+
+          if (!mutated) {
+            undo.gc(undoTag);
+          }
+
+          handler.resolve(result);
+        }
+      } else if (msg.type === 'push') {
+        const { name, args } = msg;
+
+        const listens = listeners.get(name);
+        if (listens) {
+          for (let i = 0; i < listens.length; i++) {
+            const stop = listens[i](args);
+            if (stop === true) {
+              break;
+            }
+          }
+        }
+      } else {
+        throw new Error('Unknown message type: ' + JSON.stringify(msg));
+      }
+    });
+
+    socketClient = client;
+
+    // Send any messages that were queued while closed
+    if (messageQueue.length > 0) {
+      messageQueue.forEach(msg => client.emit('message', msg));
+      messageQueue = [];
+    }
+
+    onOpen();
+  });
+}
+
+export const init: T.Init = async function () {
+  return new Promise(connectSocket);
+};
+
+export const send: T.Send = function (
+  ...params: Parameters<T.Send>
+): ReturnType<T.Send> {
+  const [name, args, { catchErrors = false } = {}] = params;
+  return new Promise((resolve, reject) => {
+    const id = uuidv4();
+    replyHandlers.set(id, { resolve, reject });
+
+    if (socketClient) {
+      socketClient.emit('message', {
+        id,
+        name,
+        args,
+        undoTag: undo.snapshot(),
+        catchErrors: !!catchErrors,
+      });
+    } else {
+      messageQueue.push({
+        id,
+        name,
+        args,
+        undoTag: undo.snapshot(),
+        catchErrors,
+      });
+    }
+  });
+};
+
+export const sendCatch: T.SendCatch = function (name, args) {
+  return send(name, args, { catchErrors: true });
+};
+
+export const listen: T.Listen = function (name, cb) {
+  if (!listeners.get(name)) {
+    listeners.set(name, []);
+  }
+  listeners.get(name).push(cb);
+
+  return () => {
+    const arr = listeners.get(name);
+    if (arr) {
+      listeners.set(
+        name,
+        arr.filter(cb_ => cb_ !== cb),
+      );
+    }
+  };
+};
+
+export const unlisten: T.Unlisten = function (name) {
+  listeners.set(name, []);
+};
+
+async function closeSocket(onClose) {
+  socketClient.onclose = () => {
+    socketClient = null;
+    onClose();
+  };
+
+  await socketClient.close();
+}
+
+export const clearServer: T.ClearServer = async function () {
+  if (socketClient != null) {
+    return new Promise(closeSocket);
+  }
+};
+export const initServer: T.InitServer = async function () {
+  // initServer is used in tests to mock the server
+};
+export const serverPush: T.ServerPush = async function () {
+  // serverPush is used in tests to mock the server
+};

package/src/platform/client/undo/index.ts

@@ -0,0 +1,59 @@
+import { v4 as uuidv4 } from 'uuid';
+
+import type { UndoState as ServerUndoState } from '../../../server/undo';
+
+// oxlint-disable-next-line @typescript-eslint/no-explicit-any
+type Modal = any; // TODO: fix me
+
+type UndoState = {
+  url: string | null;
+  openModal: Modal | null;
+  selectedItems: {
+    name: string;
+    items: Set<string>;
+  } | null;
+  undoEvent: ServerUndoState | null;
+};
+
+type UndoStateWithId = UndoState & {
+  id?: string;
+};
+
+// List of recently used states. We don't use a true MRU structure
+// because our needs are simple and we also do some custom reordering.
+const HISTORY_SIZE = 40;
+let UNDO_STATE_MRU: UndoStateWithId[] = [];
+
+const currentUndoState: UndoStateWithId = {
+  url: null,
+  openModal: null,
+  selectedItems: null,
+  undoEvent: null,
+};
+
+export const setUndoState = <K extends keyof Omit<UndoState, 'id'>>(
+  name: K,
+  value: UndoState[K],
+) => {
+  currentUndoState[name] = value;
+  currentUndoState.id = uuidv4();
+};
+
+export const getUndoState = <K extends keyof UndoState>(name: K) => {
+  return currentUndoState[name];
+};
+
+export const getTaggedState = (id: string) => {
+  return UNDO_STATE_MRU.find(state => state.id === id);
+};
+
+export const snapshot = () => {
+  const tagged = { ...currentUndoState, id: uuidv4() };
+  UNDO_STATE_MRU.unshift(tagged);
+  UNDO_STATE_MRU = UNDO_STATE_MRU.slice(0, HISTORY_SIZE);
+  return tagged.id;
+};
+
+export const gc = (id: string) => {
+  UNDO_STATE_MRU = UNDO_STATE_MRU.filter(state => state.id !== id);
+};

package/src/platform/exceptions/__mocks__/index.ts

@@ -0,0 +1,7 @@
+export const captureException = function () {
+  // Do not capture exceptions in tests
+};
+
+export const captureBreadcrumb = function () {
+  // Do not capture breadcrumbs in tests
+};

package/src/platform/exceptions/index.ts

@@ -0,0 +1,9 @@
+import { logger } from '../server/log';
+
+export const captureException = function (exc: Error) {
+  logger.error('[Exception]', exc);
+};
+
+export const captureBreadcrumb = function (crumb: unknown) {
+  logger.info('[Breadcrumb]', crumb);
+};

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

@@ -0,0 +1,50 @@
+// @ts-strict-ignore
+import type { GlobalPrefsJson } from '../../../../types/prefs';
+import type * as T from '../index-types';
+
+const store: GlobalPrefsJson = {};
+
+export const init: T.Init = function () {
+  // No need to initialise in tests
+};
+
+export const getItem: T.GetItem = async function (key) {
+  return store[key];
+};
+
+export const setItem: T.SetItem = async function (key, value) {
+  store[key] = value;
+};
+
+export const removeItem: T.RemoveItem = async function (key) {
+  delete store[key];
+};
+
+export async function multiGet<K extends readonly (keyof GlobalPrefsJson)[]>(
+  keys: K,
+): Promise<{ [P in K[number]]: GlobalPrefsJson[P] }> {
+  const results = keys.map(key => [key, store[key]]) as {
+    [P in keyof K]: [K[P], GlobalPrefsJson[K[P]]];
+  };
+
+  // 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) {
+  keyValues.forEach(function ([key, value]) {
+    store[key] = value;
+  });
+};
+
+export const multiRemove: T.MultiRemove = async function (keys) {
+  keys.forEach(function (key) {
+    delete store[key];
+  });
+};

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

@@ -0,0 +1,35 @@
+import type { GlobalPrefsJson } from '../../../types/prefs';
+
+export declare function init(opts?: { persist?: boolean }): void;
+export type Init = typeof init;
+
+export declare function getItem<K extends keyof GlobalPrefsJson>(
+  key: K,
+): Promise<GlobalPrefsJson[K]>;
+export type GetItem = typeof getItem;
+
+export declare function setItem<K extends keyof GlobalPrefsJson>(
+  key: K,
+  value: GlobalPrefsJson[K],
+): Promise<void>;
+export type SetItem = typeof setItem;
+
+export declare function removeItem(key: keyof GlobalPrefsJson): Promise<void>;
+export type RemoveItem = typeof removeItem;
+
+export declare function multiGet<K extends readonly (keyof GlobalPrefsJson)[]>(
+  keys: K,
+): Promise<{ [P in K[number]]: GlobalPrefsJson[P] }>;
+
+export type MultiGet = typeof multiGet;
+
+export declare function multiSet<K extends keyof GlobalPrefsJson>(
+  keyValues: Array<[K, GlobalPrefsJson[K]]>,
+): Promise<void>;
+
+export type MultiSet = typeof multiSet;
+
+export declare function multiRemove(
+  keys: (keyof GlobalPrefsJson)[],
+): Promise<void>;
+export type MultiRemove = typeof multiRemove;

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

@@ -0,0 +1,2 @@
+// oxlint-disable-next-line no-restricted-imports
+export * from './index.electron';

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

@@ -0,0 +1,88 @@
+// @ts-strict-ignore
+import * as fs from 'fs';
+import { join } from 'path';
+
+import type { GlobalPrefsJson } from '../../../types/prefs';
+import * as lootFs from '../fs';
+
+import type * as T from './index-types';
+
+const getStorePath = () => join(lootFs.getDataDir(), 'global-store.json');
+let store: GlobalPrefsJson;
+let persisted = true;
+
+export const init: T.Init = function ({ persist = true } = {}) {
+  if (persist) {
+    try {
+      store = JSON.parse(fs.readFileSync(getStorePath(), 'utf8'));
+    } catch {
+      store = {};
+    }
+  } else {
+    store = {};
+  }
+
+  persisted = persist;
+};
+
+function _saveStore(): Promise<void> {
+  if (persisted) {
+    return new Promise(function (resolve, reject) {
+      fs.writeFile(
+        getStorePath(),
+        JSON.stringify(store),
+        'utf8',
+        function (err) {
+          return err ? reject(err) : resolve();
+        },
+      );
+    });
+  }
+}
+
+export const getItem: T.GetItem = function (key) {
+  return new Promise(function (resolve) {
+    return resolve(store[key]);
+  });
+};
+
+export const setItem: T.SetItem = function (key, value) {
+  store[key] = value;
+  return _saveStore();
+};
+
+export const removeItem: T.RemoveItem = function (key) {
+  delete store[key];
+  return _saveStore();
+};
+
+export async function multiGet<K extends readonly (keyof GlobalPrefsJson)[]>(
+  keys: K,
+): Promise<{ [P in K[number]]: GlobalPrefsJson[P] }> {
+  const results = keys.map(key => [key, store[key]]) as {
+    [P in keyof K]: [K[P], GlobalPrefsJson[K[P]]];
+  };
+
+  // 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 = function (keyValues) {
+  keyValues.forEach(function ([key, value]) {
+    store[key] = value;
+  });
+  return _saveStore();
+};
+
+export const multiRemove: T.MultiRemove = function (keys) {
+  keys.forEach(function (key) {
+    delete store[key];
+  });
+  return _saveStore();
+};