@actual-app/core 26.3.0

package/src/server/sql/init.sql

@@ -0,0 +1,88 @@
+CREATE TABLE created_budgets (month TEXT PRIMARY KEY);
+
+CREATE TABLE spreadsheet_cells
+ (name TEXT PRIMARY KEY,
+  expr TEXT,
+  cachedValue TEXT);
+
+CREATE TABLE banks
+ (id TEXT PRIMARY KEY,
+  bank_id TEXT,
+  name TEXT,
+  tombstone INTEGER DEFAULT 0);
+
+CREATE TABLE accounts
+   (id TEXT PRIMARY KEY,
+    account_id TEXT,
+    name TEXT,
+    balance_current INTEGER,
+    balance_available INTEGER,
+    balance_limit INTEGER,
+    mask TEXT,
+    official_name TEXT,
+    type TEXT,
+    subtype TEXT,
+    bank TEXT,
+    offbudget INTEGER DEFAULT 0,
+    closed INTEGER DEFAULT 0,
+    tombstone INTEGER DEFAULT 0);
+
+CREATE TABLE pending_transactions
+  (id TEXT PRIMARY KEY,
+   acct INTEGER,
+   amount INTEGER,
+   description TEXT,
+   date TEXT,
+   FOREIGN KEY(acct) REFERENCES accounts(id));
+
+CREATE TABLE transactions
+  (id TEXT PRIMARY KEY,
+   isParent INTEGER DEFAULT 0,
+   isChild INTEGER DEFAULT 0,
+   acct TEXT,
+   category TEXT,
+   amount INTEGER,
+   description TEXT,
+   notes TEXT,
+   date INTEGER,
+   financial_id TEXT,
+   type TEXT,
+   location TEXT,
+   error TEXT,
+   imported_description TEXT,
+   starting_balance_flag INTEGER DEFAULT 0,
+   transferred_id TEXT,
+   sort_order REAL,
+   tombstone INTEGER DEFAULT 0);
+
+CREATE TABLE categories
+ (id TEXT PRIMARY KEY,
+  name TEXT,
+  is_income INTEGER DEFAULT 0,
+  cat_group TEXT,
+  sort_order REAL,
+  tombstone INTEGER DEFAULT 0);
+
+CREATE TABLE category_groups
+   (id TEXT PRIMARY KEY,
+    name TEXT UNIQUE,
+    is_income INTEGER DEFAULT 0,
+    sort_order REAL,
+    tombstone INTEGER DEFAULT 0);
+
+CREATE TABLE messages_crdt
+ (id INTEGER PRIMARY KEY,
+  timestamp TEXT NOT NULL UNIQUE,
+  dataset TEXT NOT NULL,
+  row TEXT NOT NULL,
+  column TEXT NOT NULL,
+  value BLOB NOT NULL);
+
+CREATE TABLE category_mapping
+  (id TEXT PRIMARY KEY,
+   transferId TEXT);
+
+CREATE TABLE messages_clock (id INTEGER PRIMARY KEY, clock TEXT);
+
+CREATE TABLE db_version (version TEXT PRIMARY KEY);
+CREATE TABLE __migrations__ (id INT PRIMARY KEY NOT NULL);

package/src/server/sync/__snapshots__/sync.test.ts.snap

@@ -0,0 +1,31 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`Sync > should send messages to the server 1`] = `
+[
+  {
+    "column": "amount",
+    "dataset": "transactions",
+    "id": 1,
+    "row": "foo",
+    "timestamp": "1970-01-02T10:17:36.789Z-0000-0000000000000id1",
+    "value": "N:3200",
+  },
+  {
+    "column": "amount",
+    "dataset": "transactions",
+    "id": 2,
+    "row": "foo",
+    "timestamp": "1970-01-02T10:17:37.789Z-0000-0000000000000id1",
+    "value": "N:4200",
+  },
+]
+`;
+
+exports[`Sync > should send messages to the server 2`] = `
+[
+  {
+    "clock": "{"timestamp":"1970-01-02T10:17:37.789Z-0000-0000000000000id1","merkle":{"2":{"2":{"1":{"1":{"0":{"1":{"2":{"hash":-1992470180},"hash":-1992470180},"hash":-1992470180},"hash":-1992470180},"hash":-1992470180},"hash":-1992470180},"hash":-1992470180},"hash":-1992470180}}",
+    "id": 1,
+  },
+]
+`;

package/src/server/sync/app.ts

@@ -0,0 +1,29 @@
+import { createApp } from '../app';
+
+import { repairSync as _repairSync } from './repair';
+import { resetSync as _resetSync } from './reset';
+
+import { fullSync } from '.';
+
+export type SyncHandlers = {
+  sync: typeof sync;
+  'sync-reset': typeof resetSync;
+  'sync-repair': typeof repairSync;
+};
+
+export const app = createApp<SyncHandlers>();
+app.method('sync', sync);
+app.method('sync-reset', resetSync);
+app.method('sync-repair', repairSync);
+
+async function sync() {
+  return await fullSync();
+}
+
+async function resetSync() {
+  return await _resetSync();
+}
+
+async function repairSync() {
+  await _repairSync();
+}

package/src/server/sync/encoder.ts

@@ -0,0 +1,129 @@
+// @ts-strict-ignore
+import { SyncProtoBuf, Timestamp } from '@actual-app/crdt';
+
+import { logger } from '../../platform/server/log';
+import * as encryption from '../encryption';
+import { SyncError } from '../errors';
+import * as prefs from '../prefs';
+
+import type { Message } from './index';
+
+function coerceBuffer(value) {
+  // The web encryption APIs give us back raw Uint8Array... but our
+  // encryption code assumes we can work with it as a buffer. This is
+  // a leaky abstraction and ideally the our abstraction over the web
+  // encryption APIs should do this.
+  if (!Buffer.isBuffer(value)) {
+    return Buffer.from(value);
+  }
+  return value;
+}
+
+export async function encode(
+  groupId: string,
+  fileId: string,
+  since: Timestamp | string,
+  messages: Message[],
+): Promise<Uint8Array> {
+  const { encryptKeyId } = prefs.getPrefs();
+  const requestPb = new SyncProtoBuf.SyncRequest();
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    const envelopePb = new SyncProtoBuf.MessageEnvelope();
+    envelopePb.setTimestamp(msg.timestamp.toString());
+
+    const messagePb = new SyncProtoBuf.Message();
+    messagePb.setDataset(msg.dataset);
+    messagePb.setRow(msg.row);
+    messagePb.setColumn(msg.column);
+    messagePb.setValue(msg.value as string);
+    const binaryMsg = messagePb.serializeBinary();
+
+    if (encryptKeyId) {
+      const encrypted = new SyncProtoBuf.EncryptedData();
+
+      let result;
+      try {
+        result = await encryption.encrypt(binaryMsg, encryptKeyId);
+      } catch (e) {
+        throw new SyncError('encrypt-failure', {
+          isMissingKey: e.message === 'missing-key',
+        });
+      }
+
+      encrypted.setData(result.value);
+      encrypted.setIv(Buffer.from(result.meta.iv, 'base64'));
+      encrypted.setAuthtag(Buffer.from(result.meta.authTag, 'base64'));
+
+      envelopePb.setContent(encrypted.serializeBinary());
+      envelopePb.setIsencrypted(true);
+    } else {
+      envelopePb.setContent(binaryMsg);
+    }
+
+    requestPb.addMessages(envelopePb);
+  }
+
+  requestPb.setGroupid(groupId);
+  requestPb.setFileid(fileId);
+  requestPb.setKeyid(encryptKeyId);
+  requestPb.setSince(since.toString());
+
+  return requestPb.serializeBinary();
+}
+
+export async function decode(
+  data: Uint8Array,
+): Promise<{ messages: Message[]; merkle: { hash: number } }> {
+  const { encryptKeyId } = prefs.getPrefs();
+
+  const responsePb = SyncProtoBuf.SyncResponse.deserializeBinary(data);
+  const merkle = JSON.parse(responsePb.getMerkle());
+  const list = responsePb.getMessagesList();
+  const messages = [];
+
+  for (let i = 0; i < list.length; i++) {
+    const envelopePb = list[i];
+    const timestamp = Timestamp.parse(envelopePb.getTimestamp());
+    const encrypted = envelopePb.getIsencrypted();
+    let msg;
+
+    if (encrypted) {
+      const binary = SyncProtoBuf.EncryptedData.deserializeBinary(
+        envelopePb.getContent() as Uint8Array,
+      );
+
+      let decrypted;
+      try {
+        decrypted = await encryption.decrypt(coerceBuffer(binary.getData()), {
+          keyId: encryptKeyId,
+          algorithm: 'aes-256-gcm',
+          iv: coerceBuffer(binary.getIv()),
+          authTag: coerceBuffer(binary.getAuthtag()),
+        });
+      } catch (e) {
+        logger.log(e);
+        throw new SyncError('decrypt-failure', {
+          isMissingKey: e.message === 'missing-key',
+        });
+      }
+
+      msg = SyncProtoBuf.Message.deserializeBinary(decrypted);
+    } else {
+      msg = SyncProtoBuf.Message.deserializeBinary(
+        envelopePb.getContent() as Uint8Array,
+      );
+    }
+
+    messages.push({
+      timestamp,
+      dataset: msg.getDataset(),
+      row: msg.getRow(),
+      column: msg.getColumn(),
+      value: msg.getValue(),
+    });
+  }
+
+  return { messages, merkle };
+}