@actual-app/core 26.3.0

package/src/server/db/mappings.ts

@@ -0,0 +1,59 @@
+// @ts-strict-ignore
+import { addSyncListener } from '../sync/index';
+
+import * as db from './index';
+
+// This file keeps all the mappings in memory so we can access it
+// synchronously. This is primarily used in the rules system, but
+// there may be other uses in the future. You don't need to worry
+// about this generally; if you are querying transactions, ids are
+// transparently mapped for you. But if you are building something
+// that stores ids and later uses them, you need to remember to map
+// the ids.
+//
+// IMPORTANT: `loadMappings` must be called first before other modules
+// that listen for sync changes. This must be the first sync listener
+// to run in case other listeners use this mapping table; otherwise
+// they might see stale mappings.
+
+let allMappings;
+let unlistenSync;
+
+export async function loadMappings() {
+  // The mappings are separated into tables specific to the type of
+  // data. But you know, we really could keep a global mapping table.
+  const categories = (
+    await db.all<db.DbCategoryMapping>('SELECT * FROM category_mapping')
+  ).map(r => [r.id, r.transferId] as const);
+  const payees = (
+    await db.all<db.DbPayeeMapping>('SELECT * FROM payee_mapping')
+  ).map(r => [r.id, r.targetId] as const);
+
+  // All ids are unique, so we can just keep a global table of mappings
+  allMappings = new Map(categories.concat(payees));
+
+  if (unlistenSync) {
+    unlistenSync();
+  }
+  unlistenSync = addSyncListener(onApplySync);
+}
+
+function onApplySync(oldValues, newValues) {
+  newValues.forEach((items, table) => {
+    if (table.indexOf('mapping') !== -1) {
+      const field = table === 'category_mapping' ? 'transferId' : 'targetId';
+
+      items.forEach(newValue => {
+        allMappings.set(newValue.id, newValue[field]);
+      });
+    }
+  });
+}
+
+export function getMappings() {
+  return allMappings;
+}
+
+export function getMapping(id) {
+  return allMappings.get(id) || null;
+}

package/src/server/db/sort.ts

@@ -0,0 +1,58 @@
+export const SORT_INCREMENT = 16384;
+
+function midpoint<T extends { sort_order: number }>(items: T[], to: number) {
+  const below = items[to - 1];
+  const above = items[to];
+
+  if (!below) {
+    return above.sort_order / 2;
+  } else if (!above) {
+    return below.sort_order + SORT_INCREMENT;
+  } else {
+    return (below.sort_order + above.sort_order) / 2;
+  }
+}
+
+export function shoveSortOrders<T extends { id: string; sort_order: number }>(
+  items: T[],
+  targetId: string | null = null,
+) {
+  const to = items.findIndex(item => item.id === targetId);
+  const target = items[to];
+  const before = items[to - 1];
+  const updates: Array<{ id: string; sort_order: number }> = [];
+
+  // If no target is specified, append at the end
+  if (!targetId || to === -1) {
+    let order;
+    if (items.length > 0) {
+      // Add a new increment to whatever is the latest sort order
+      order = items[items.length - 1].sort_order + SORT_INCREMENT;
+    } else {
+      // If no items exist, the default is to use the first increment
+      order = SORT_INCREMENT;
+    }
+
+    return { updates, sort_order: order };
+  } else {
+    if (target.sort_order - (before ? before.sort_order : 0) <= 2) {
+      let next = to;
+      let order = Math.floor(items[next].sort_order) + SORT_INCREMENT;
+      while (next < items.length) {
+        // No need to update it if it's already greater than the current
+        // order. This can happen because there may already be large
+        // gaps
+        if (order <= items[next].sort_order) {
+          break;
+        }
+
+        updates.push({ id: items[next].id, sort_order: order });
+
+        next++;
+        order += SORT_INCREMENT;
+      }
+    }
+
+    return { updates, sort_order: midpoint(items, to) };
+  }
+}

package/src/server/db/types/index.ts

@@ -0,0 +1,342 @@
+// These are the types that exactly match the database schema.
+// The `Entity` types e.g. `TransactionEntity`, `AccountEntity`, etc
+// are specific to the AQL query framework and does not necessarily
+// match the actual database schema.
+
+type JsonString = string;
+
+export type DbAccount = {
+  id: string;
+  name: string;
+  offbudget: 1 | 0;
+  closed: 1 | 0;
+  tombstone: 1 | 0;
+  sort_order: number;
+  account_id?: string | null;
+  balance_current?: number | null;
+  balance_available?: number | null;
+  balance_limit?: number | null;
+  mask?: string | null;
+  official_name?: string | null;
+  type?: string | null;
+  subtype?: string | null;
+  bank?: string | null;
+  account_sync_source?: 'simpleFin' | 'goCardless' | null;
+  last_reconciled?: string | null;
+  last_sync?: string | null;
+};
+
+export type DbBank = {
+  id: string;
+  bank_id: string;
+  name: string;
+  tombstone: 1 | 0;
+};
+
+export type DbCategory = {
+  id: string;
+  name: string;
+  is_income: 1 | 0;
+  cat_group: DbCategoryGroup['id'];
+  sort_order: number;
+  hidden: 1 | 0;
+  goal_def?: JsonString | null;
+  template_settings?: { source: 'notes' | 'ui' };
+  tombstone: 1 | 0;
+};
+
+export type DbCategoryGroup = {
+  id: string;
+  name: string;
+  is_income: 1 | 0;
+  sort_order: number;
+  hidden: 1 | 0;
+  tombstone: 1 | 0;
+};
+
+export type DbCategoryMapping = {
+  id: DbCategory['id'];
+  transferId: DbCategory['id'];
+};
+
+export type DbKvCache = {
+  key: string;
+  value: string;
+};
+
+export type DbKvCacheKey = {
+  id: number;
+  key: number;
+};
+
+export type DbClockMessage = {
+  id: string;
+  clock: string;
+};
+
+export type DbCrdtMessage = {
+  id: string;
+  timestamp: string;
+  dataset: string;
+  row: string;
+  column: string;
+  value: Uint8Array;
+};
+
+export type DbNote = {
+  id: string;
+  note: string;
+};
+
+export type DbPayeeMapping = {
+  id: DbPayee['id'];
+  targetId: DbPayee['id'];
+};
+
+export type DbPayee = {
+  id: string;
+  name: string;
+  transfer_acct?: DbAccount['id'] | null;
+  favorite: 1 | 0;
+  learn_categories: 1 | 0;
+  tombstone: 1 | 0;
+  // Unused in the codebase
+  category?: string | null;
+};
+
+export type DbRule = {
+  id: string;
+  stage: string;
+  conditions: JsonString;
+  actions: JsonString;
+  tombstone: 1 | 0;
+  conditions_op: string;
+};
+
+export type DbSchedule = {
+  id: string;
+  name: string;
+  rule: DbRule['id'];
+  active: 1 | 0;
+  completed: 1 | 0;
+  posts_transaction: 1 | 0;
+  tombstone: 1 | 0;
+};
+
+// type DbScheduleJsonPath = {
+//   schedule_id: DbSchedule['id'];
+//   payee: string;
+//   account: string;
+//   amount: string;
+//   date: string;
+// };
+
+export type DbScheduleNextDate = {
+  id: string;
+  schedule_id: DbSchedule['id'];
+  local_next_date: number;
+  local_next_date_ts: number;
+  base_next_date: number;
+  base_next_date_ts: number;
+};
+
+// This is unused in the codebase.
+// type DbPendingTransaction = {
+//   id: string;
+//   acct: number;
+//   amount: number;
+//   description: string;
+//   date: string;
+// };
+
+export type DbTransaction = {
+  id: string;
+  isParent: 1 | 0;
+  isChild: 1 | 0;
+  date: number;
+  acct: DbAccount['id'];
+  amount: number;
+  sort_order: number;
+  parent_id?: DbTransaction['id'] | null;
+  category?: DbCategory['id'] | null;
+  description?: string | null;
+  notes?: string | null;
+  financial_id?: string | null;
+  error?: string | null;
+  imported_description?: string | null;
+  transferred_id?: DbTransaction['id'] | null;
+  schedule?: DbSchedule['id'] | null;
+  starting_balance_flag: 1 | 0;
+  tombstone: 1 | 0;
+  cleared: 1 | 0;
+  reconciled: 1 | 0;
+  // Unused in the codebase
+  pending?: 1 | 0 | null;
+  location?: string | null;
+  type?: string | null;
+};
+
+export type DbReflectBudget = {
+  id: string;
+  month: number;
+  category: string;
+  amount: number;
+  carryover: number;
+  goal: number;
+  long_goal: number;
+};
+
+export type DbZeroBudgetMonth = {
+  id: string;
+  buffered: number;
+};
+
+export type DbZeroBudget = {
+  id: string;
+  month: number;
+  category: string;
+  amount: number;
+  carryover: number;
+  goal: number;
+  long_goal: number;
+};
+
+export type DbTransactionFilter = {
+  id: string;
+  name: string;
+  conditions: JsonString;
+  conditions_op: string;
+  tombstone: 1 | 0;
+};
+
+export type DbPreference = {
+  id: string;
+  value: string;
+};
+
+export type DbCustomReport = {
+  id: string;
+  name: string;
+  start_date: string;
+  end_date: string;
+  date_static: number;
+  date_range: string;
+  mode: string;
+  group_by: string;
+  balance_type: string;
+  show_empty: 1 | 0;
+  show_offbudget: 1 | 0;
+  show_hidden: 1 | 0;
+  show_uncategorized: 1 | 0;
+  selected_categories: string;
+  graph_type: string;
+  conditions: JsonString;
+  conditions_op: string;
+  metadata: JsonString;
+  interval: string;
+  color_scheme: string;
+  include_current: 1 | 0;
+  sort_by: string;
+  tombstone: 1 | 0;
+};
+
+export type DbDashboardPage = {
+  id: string;
+  name: string;
+  tombstone: 1 | 0;
+};
+
+export type DbDashboard = {
+  id: string;
+  dashboard_page_id: string;
+  type: string;
+  width: number;
+  height: number;
+  x: number;
+  y: number;
+  meta: JsonString;
+  tombstone: 1 | 0;
+};
+
+export type DbViewTransactionInternal = {
+  id: DbTransaction['id'];
+  is_parent: DbTransaction['isParent'];
+  is_child: DbTransaction['isChild'];
+  date: DbTransaction['date'];
+  account: DbAccount['id'];
+  amount: DbTransaction['amount'];
+  parent_id: DbTransaction['parent_id'] | null;
+  category: DbCategory['id'] | null;
+  payee: DbPayee['id'] | null;
+  notes: DbTransaction['notes'] | null;
+  imported_id: DbTransaction['financial_id'] | null;
+  error: DbTransaction['error'] | null;
+  imported_payee: DbTransaction['imported_description'] | null;
+  starting_balance_flag: DbTransaction['starting_balance_flag'] | null;
+  transfer_id: DbTransaction['transferred_id'] | null;
+  schedule: DbSchedule['id'] | null;
+  sort_order: DbTransaction['sort_order'];
+  cleared: DbTransaction['cleared'];
+  tombstone: DbTransaction['tombstone'];
+  reconciled: DbTransaction['reconciled'];
+};
+
+export type DbViewTransactionInternalAlive = DbViewTransactionInternal;
+export type DbViewTransaction = DbViewTransactionInternalAlive;
+
+export type DbViewCategory = {
+  id: DbCategory['id'];
+  name: DbCategory['name'];
+  is_income: DbCategory['is_income'];
+  hidden: DbCategory['hidden'];
+  group: DbCategoryGroup['id'];
+  sort_order: DbCategory['sort_order'];
+  tombstone: DbCategory['tombstone'];
+};
+
+export type DbViewCategoryWithGroupHidden = {
+  id: DbCategory['id'];
+  name: DbCategory['name'];
+  is_income: DbCategory['is_income'];
+  hidden: DbCategory['hidden'];
+  group: DbCategoryGroup['id'];
+  group_hidden: DbCategoryGroup['hidden'];
+  sort_order: DbCategory['sort_order'];
+  tombstone: DbCategory['tombstone'];
+};
+
+export type DbViewPayee = {
+  id: DbPayee['id'];
+  name: DbAccount['name'] | DbPayee['name'];
+  transfer_acct: DbPayee['transfer_acct'];
+  tombstone: DbPayee['tombstone'];
+};
+
+export type DbViewSchedule = {
+  id: DbSchedule['id'];
+  name: DbSchedule['name'];
+  rule: DbSchedule['rule'];
+  next_date:
+    | DbScheduleNextDate['local_next_date_ts']
+    | DbScheduleNextDate['local_next_date']
+    | DbScheduleNextDate['base_next_date'];
+  active: DbSchedule['active'];
+  completed: DbSchedule['completed'];
+  posts_transaction: DbSchedule['posts_transaction'];
+  tombstone: DbSchedule['tombstone'];
+  _payee: DbPayeeMapping['targetId'];
+  _account: DbAccount['id'];
+  _amount: number;
+  _amountOp: string;
+  _date: JsonString;
+  _conditions: JsonString;
+  _actions: JsonString;
+};
+
+export type DbTag = {
+  id: string;
+  tag: string;
+  color?: string | null;
+  description?: string | null;
+  tombstone: 1 | 0;
+};

package/src/server/db/util.ts

@@ -0,0 +1,36 @@
+// @ts-strict-ignore
+export async function incrFetch(
+  runQuery,
+  terms,
+  compare,
+  makeQuery,
+  params = [],
+) {
+  const pageCount = 500;
+  let results = [];
+
+  let fetchedIds = new Set();
+
+  for (let i = 0; i < terms.length; i += pageCount) {
+    const slice = terms
+      .slice(i, i + pageCount)
+      .filter(id => !fetchedIds.has(id));
+    if (slice.length > 0) {
+      const filter = slice.map(id => compare(id)).join(' OR ');
+      const query = makeQuery('(' + filter + ')');
+
+      const rows = await runQuery(query, params, true);
+      fetchedIds = new Set([...fetchedIds, ...slice]);
+      results = results.concat(rows);
+    }
+  }
+
+  return results;
+}
+
+export function whereIn(ids: string[], field: string) {
+  const ids2 = [...new Set(ids)];
+
+  const filter = `${field} IN (` + ids2.map(id => `'${id}'`).join(',') + ')';
+  return filter;
+}

package/src/server/encryption/app.ts

@@ -0,0 +1,133 @@
+import { v4 as uuidv4 } from 'uuid';
+
+import * as asyncStorage from '../../platform/server/asyncStorage';
+import { logger } from '../../platform/server/log';
+import type { Budget } from '../../types/budget';
+import { createApp } from '../app';
+import { post } from '../post';
+import * as prefs from '../prefs';
+import { getServer } from '../server-config';
+import { makeTestMessage, resetSync } from '../sync';
+
+import * as encryption from '.';
+
+export type EncryptionHandlers = {
+  'key-make': typeof keyMake;
+  'key-test': typeof keyTest;
+};
+
+export const app = createApp<EncryptionHandlers>();
+app.method('key-make', keyMake);
+app.method('key-test', keyTest);
+
+// A user can only enable/change their key with the file loaded. This
+// will change in the future: during onboarding the user should be
+// able to enable encryption. (Imagine if they are importing data from
+// another source, they should be able to encrypt first)
+async function keyMake({ password }: { password: string }) {
+  if (!prefs.getPrefs()) {
+    throw new Error('key-make must be called with file loaded');
+  }
+
+  const salt = encryption.randomBytes(32).toString('base64');
+  const id = uuidv4();
+  const key = await encryption.createKey({ id, password, salt });
+
+  // Load the key
+  await encryption.loadKey(key);
+
+  // Make some test data to use if the key is valid or not
+  const testContent = await makeTestMessage(key.getId());
+
+  // Changing your key necessitates a sync reset as well. This will
+  // clear all existing encrypted data from the server so you won't
+  // have a mix of data encrypted with different keys.
+  return await resetSync({
+    key,
+    salt,
+    testContent: JSON.stringify({
+      ...testContent,
+      value: testContent.value.toString('base64'),
+    }),
+  });
+}
+
+// This can be called both while a file is already loaded or not. This
+// will see if a key is valid and if so save it off.
+async function keyTest({
+  cloudFileId,
+  password,
+}: {
+  cloudFileId?: Budget['cloudFileId'];
+  password: string;
+}) {
+  const userToken = await asyncStorage.getItem('user-token');
+
+  if (cloudFileId == null) {
+    cloudFileId = prefs.getPrefs().cloudFileId;
+  }
+
+  let validCloudFileId: NonNullable<Budget['cloudFileId']>;
+  let res: {
+    id: string;
+    salt: string;
+    test: string | null;
+  };
+  try {
+    const serverConfig = getServer();
+    if (!serverConfig) {
+      throw new Error('No sync server configured.');
+    }
+    res = await post(serverConfig.SYNC_SERVER + '/user-get-key', {
+      token: userToken,
+      fileId: cloudFileId,
+    });
+    validCloudFileId = cloudFileId!;
+  } catch (e) {
+    logger.log(e);
+    return { error: { reason: 'network' } };
+  }
+
+  const { id, salt, test: originalTest } = res;
+
+  if (!originalTest) {
+    return { error: { reason: 'old-key-style' } };
+  }
+
+  const test: {
+    value: string;
+    meta: {
+      keyId: string;
+      algorithm: string;
+      iv: string;
+      authTag: string;
+    };
+  } = JSON.parse(originalTest);
+
+  const key = await encryption.createKey({ id, password, salt });
+  await encryption.loadKey(key);
+
+  try {
+    await encryption.decrypt(Buffer.from(test.value, 'base64'), test.meta);
+  } catch (e) {
+    logger.log(e);
+
+    // Unload the key, it's invalid
+    encryption.unloadKey(key);
+    return { error: { reason: 'decrypt-failure' } };
+  }
+
+  // Persist key in async storage
+  const keys = JSON.parse((await asyncStorage.getItem(`encrypt-keys`)) || '{}');
+  keys[validCloudFileId] = key.serialize();
+  await asyncStorage.setItem('encrypt-keys', JSON.stringify(keys));
+
+  // Save the key id in prefs if the are loaded. If they aren't, we
+  // are testing a key to download a file and when the file is
+  // actually downloaded it will update the prefs with the latest key id
+  if (prefs.getPrefs()) {
+    await prefs.savePrefs({ encryptKeyId: key.getId() });
+  }
+
+  return {};
+}

package/src/server/encryption/encryption-internals.api.ts

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