@actual-app/core 26.3.0

package/src/server/migrate/migrations.ts

@@ -0,0 +1,192 @@
+// @ts-strict-ignore
+// We have to bundle in JS migrations manually to avoid having to `eval`
+// them which doesn't play well with CSP. There isn't great, and eventually
+// we can remove this migration.
+import type { Database } from '@jlongster/sql.js';
+
+import m1632571489012 from '../../../migrations/1632571489012_remove_cache';
+import m1722717601000 from '../../../migrations/1722717601000_reports_move_selected_categories';
+import m1722804019000 from '../../../migrations/1722804019000_create_dashboard_table';
+import m1723665565000 from '../../../migrations/1723665565000_prefs';
+import m1765518577215 from '../../../migrations/1765518577215_multiple_dashboards';
+import * as fs from '../../platform/server/fs';
+import { logger } from '../../platform/server/log';
+import * as sqlite from '../../platform/server/sqlite';
+import * as prefs from '../prefs';
+
+let MIGRATIONS_DIR = fs.migrationsPath;
+
+const javascriptMigrations = {
+  1632571489012: m1632571489012,
+  1722717601000: m1722717601000,
+  1722804019000: m1722804019000,
+  1723665565000: m1723665565000,
+  1765518577215: m1765518577215,
+};
+
+export async function withMigrationsDir(
+  dir: string,
+  func: () => Promise<void>,
+): Promise<void> {
+  const oldDir = MIGRATIONS_DIR;
+  MIGRATIONS_DIR = dir;
+  await func();
+  MIGRATIONS_DIR = oldDir;
+}
+
+export function getMigrationsDir(): string {
+  return MIGRATIONS_DIR;
+}
+
+function getMigrationId(name: string): number {
+  return parseInt(name.match(/^(\d)+/)[0]);
+}
+
+export function getUpMigration(id, names) {
+  for (const m of names) {
+    if (getMigrationId(m) === id) {
+      return m;
+    }
+  }
+}
+
+async function patchBadMigrations(db: Database) {
+  const badFiltersMigration = 1685375406832;
+  const newFiltersMigration = 1688749527273;
+  const appliedIds = await getAppliedMigrations(db);
+  if (appliedIds.includes(badFiltersMigration)) {
+    sqlite.runQuery(db, 'DELETE FROM __migrations__ WHERE id = ?', [
+      badFiltersMigration,
+    ]);
+    sqlite.runQuery(db, 'INSERT INTO __migrations__ (id) VALUES (?)', [
+      newFiltersMigration,
+    ]);
+  }
+}
+
+export async function getAppliedMigrations(db: Database): Promise<number[]> {
+  const rows = sqlite.runQuery<{ id: number }>(
+    db,
+    'SELECT * FROM __migrations__ ORDER BY id ASC',
+    [],
+    true,
+  );
+  return rows.map(row => row.id);
+}
+
+export async function getMigrationList(
+  migrationsDir: string,
+): Promise<string[]> {
+  const files = await fs.listDir(migrationsDir);
+  return files
+    .filter(name => name.match(/(\.sql|\.js)$/))
+    .sort((m1, m2) => {
+      const id1 = getMigrationId(m1);
+      const id2 = getMigrationId(m2);
+      if (id1 < id2) {
+        return -1;
+      } else if (id1 > id2) {
+        return 1;
+      }
+      return 0;
+    });
+}
+
+export function getPending(appliedIds: number[], all: string[]): string[] {
+  return all.filter(name => {
+    const id = getMigrationId(name);
+    return appliedIds.indexOf(id) === -1;
+  });
+}
+
+async function applyJavaScript(db, id) {
+  const dbInterface = {
+    runQuery: (query, params, fetchAll) =>
+      sqlite.runQuery(db, query, params, fetchAll),
+    execQuery: query => sqlite.execQuery(db, query),
+    transaction: func => sqlite.transaction(db, func),
+  };
+
+  if (javascriptMigrations[id] == null) {
+    throw new Error('Could not find JS migration code to run for ' + id);
+  }
+
+  const run = javascriptMigrations[id];
+  return run(dbInterface, {
+    fs,
+    fileId: prefs.getPrefs()?.id,
+  });
+}
+
+async function applySql(db, sql) {
+  try {
+    sqlite.execQuery(db, sql);
+  } catch (e) {
+    logger.log('Error applying sql:', sql);
+    throw e;
+  }
+}
+
+export async function applyMigration(
+  db: Database,
+  name: string,
+  migrationsDir: string,
+): Promise<void> {
+  const code = await fs.readFile(fs.join(migrationsDir, name));
+  if (name.match(/\.js$/)) {
+    await applyJavaScript(db, getMigrationId(name));
+  } else {
+    await applySql(db, code);
+  }
+  sqlite.runQuery(db, 'INSERT INTO __migrations__ (id) VALUES (?)', [
+    getMigrationId(name),
+  ]);
+}
+
+function checkDatabaseValidity(
+  appliedIds: number[],
+  available: string[],
+): void {
+  if (appliedIds.length > available.length) {
+    logger.error(
+      'Database is out of sync with migrations (index past available):',
+      {
+        appliedIds,
+        available,
+      },
+    );
+    throw new Error('out-of-sync-migrations');
+  }
+
+  for (let i = 0; i < appliedIds.length; i++) {
+    if (appliedIds[i] !== getMigrationId(available[i])) {
+      logger.error(
+        'Database is out of sync with migrations (migration id mismatch):',
+        {
+          appliedIds,
+          available,
+          missing: available.filter(
+            m => !appliedIds.includes(getMigrationId(m)),
+          ),
+        },
+      );
+      throw new Error('out-of-sync-migrations');
+    }
+  }
+}
+
+export async function migrate(db: Database): Promise<string[]> {
+  await patchBadMigrations(db);
+  const appliedIds = await getAppliedMigrations(db);
+  const available = await getMigrationList(MIGRATIONS_DIR);
+
+  checkDatabaseValidity(appliedIds, available);
+
+  const pending = getPending(appliedIds, available);
+
+  for (const migration of pending) {
+    await applyMigration(db, migration, MIGRATIONS_DIR);
+  }
+
+  return pending;
+}

package/src/server/models.ts

@@ -0,0 +1,184 @@
+import type {
+  CategoryEntity,
+  CategoryGroupEntity,
+  PayeeEntity,
+} from '../types/models';
+
+import {
+  convertForInsert,
+  convertForUpdate,
+  convertFromSelect,
+  schema,
+  schemaConfig,
+} from './aql';
+import type { DbAccount, DbCategory, DbCategoryGroup, DbPayee } from './db';
+import { ValidationError } from './errors';
+
+export function requiredFields<T extends object, K extends keyof T>(
+  name: string,
+  row: T,
+  fields: K[],
+  update?: boolean,
+) {
+  fields.forEach(field => {
+    if (update) {
+      if (row.hasOwnProperty(field) && row[field] == null) {
+        throw new ValidationError(`${name} is missing field ${String(field)}`);
+      }
+    } else {
+      if (!row.hasOwnProperty(field) || row[field] == null) {
+        throw new ValidationError(`${name} is missing field ${String(field)}`);
+      }
+    }
+  });
+}
+
+export function toDateRepr(str: string) {
+  if (typeof str !== 'string') {
+    throw new Error('toDateRepr not passed a string: ' + str);
+  }
+
+  return parseInt(str.replace(/-/g, ''));
+}
+
+export function fromDateRepr(number: number) {
+  if (typeof number !== 'number') {
+    throw new Error('fromDateRepr not passed a number: ' + number);
+  }
+
+  const dateString = number.toString();
+  return (
+    dateString.slice(0, 4) +
+    '-' +
+    dateString.slice(4, 6) +
+    '-' +
+    dateString.slice(6)
+  );
+}
+
+export const accountModel = {
+  validate(account: Partial<DbAccount>, { update }: { update?: boolean } = {}) {
+    requiredFields(
+      'account',
+      account,
+      update ? ['name', 'offbudget', 'closed'] : ['name'],
+      update,
+    );
+
+    return account as DbAccount;
+  },
+};
+
+export const categoryModel = {
+  validate(
+    category: Partial<DbCategory>,
+    { update }: { update?: boolean } = {},
+  ): DbCategory {
+    requiredFields(
+      'category',
+      category,
+      update ? ['name', 'is_income', 'cat_group'] : ['name', 'cat_group'],
+      update,
+    );
+
+    const { sort_order: _sort_order, ...rest } = category;
+    return { ...rest } as DbCategory;
+  },
+  toDb(
+    category: CategoryEntity,
+    { update }: { update?: boolean } = {},
+  ): DbCategory {
+    return (
+      update
+        ? convertForUpdate(schema, schemaConfig, 'categories', category)
+        : convertForInsert(schema, schemaConfig, 'categories', category)
+    ) as DbCategory;
+  },
+  fromDb(category: DbCategory): CategoryEntity {
+    return convertFromSelect(
+      schema,
+      schemaConfig,
+      'categories',
+      category,
+    ) as CategoryEntity;
+  },
+};
+
+export const categoryGroupModel = {
+  validate(
+    categoryGroup: Partial<DbCategoryGroup>,
+    { update }: { update?: boolean } = {},
+  ): DbCategoryGroup {
+    requiredFields(
+      'categoryGroup',
+      categoryGroup,
+      update ? ['name', 'is_income'] : ['name'],
+      update,
+    );
+
+    const { sort_order: _sort_order, ...rest } = categoryGroup;
+    return { ...rest } as DbCategoryGroup;
+  },
+  toDb(
+    categoryGroup: CategoryGroupEntity,
+    { update }: { update?: boolean } = {},
+  ): DbCategoryGroup {
+    return (
+      update
+        ? convertForUpdate(
+            schema,
+            schemaConfig,
+            'category_groups',
+            categoryGroup,
+          )
+        : convertForInsert(
+            schema,
+            schemaConfig,
+            'category_groups',
+            categoryGroup,
+          )
+    ) as DbCategoryGroup;
+  },
+  fromDb(
+    categoryGroup: DbCategoryGroup & {
+      categories: DbCategory[];
+    },
+  ): CategoryGroupEntity {
+    const { categories, ...rest } = categoryGroup;
+    const categoryGroupEntity = convertFromSelect(
+      schema,
+      schemaConfig,
+      'category_groups',
+      rest,
+    ) as CategoryGroupEntity;
+
+    return {
+      ...categoryGroupEntity,
+      categories: categories
+        .filter(category => category.cat_group === categoryGroup.id)
+        .map(c => categoryModel.fromDb(c)),
+    };
+  },
+};
+
+export const payeeModel = {
+  validate(payee: Partial<DbPayee>, { update }: { update?: boolean } = {}) {
+    requiredFields('payee', payee, update ? [] : ['name'], update);
+    return payee as DbPayee;
+  },
+  toDb(payee: PayeeEntity, { update }: { update?: boolean } = {}): DbPayee {
+    return (
+      update
+        ? convertForUpdate(schema, schemaConfig, 'payees', payee)
+        : convertForInsert(schema, schemaConfig, 'payees', payee)
+    ) as DbPayee;
+  },
+  fromDb(payee: DbPayee): PayeeEntity {
+    return convertFromSelect(
+      schema,
+      schemaConfig,
+      'payees',
+      payee,
+    ) as PayeeEntity;
+  },
+};

package/src/server/mutators.ts

@@ -0,0 +1,139 @@
+// @ts-strict-ignore
+import { captureBreadcrumb, captureException } from '../platform/exceptions';
+import { sequential } from '../shared/async';
+import type { HandlerFunctions, Handlers } from '../types/handlers';
+
+const runningMethods = new Set();
+
+let currentContext = null;
+const mutatingMethods = new WeakMap();
+let globalMutationsEnabled = false;
+
+let _latestHandlerNames = [];
+
+export function mutator<T extends HandlerFunctions>(handler: T): T {
+  mutatingMethods.set(handler, true);
+  return handler;
+}
+
+export function isMutating(handler) {
+  return mutatingMethods.has(handler);
+}
+
+async function flushRunningMethods() {
+  // Give the client some time to invoke new requests
+  await wait(200);
+
+  while (runningMethods.size > 0) {
+    // Wait for all of them
+    await Promise.all([...runningMethods.values()]);
+
+    // We give clients more time to make other requests. This lets them continue
+    // to do an async workflow
+    await wait(100);
+  }
+}
+
+function wait(time) {
+  return new Promise(resolve => setTimeout(resolve, time));
+}
+
+export async function runHandler<T extends Handlers[keyof Handlers]>(
+  handler: T,
+  args?: Parameters<T>[0],
+  { undoTag, name }: { undoTag?; name? } = {},
+): Promise<ReturnType<T>> {
+  // For debug reasons, track the latest handlers that have been
+  // called
+  _latestHandlerNames.push(name);
+  if (_latestHandlerNames.length > 5) {
+    _latestHandlerNames = _latestHandlerNames.slice(-5);
+  }
+
+  if (mutatingMethods.has(handler)) {
+    return runMutator(() => handler(args), { undoTag }) as Promise<
+      ReturnType<T>
+    >;
+  }
+
+  // When closing a file, it clears out all global state for the file. That
+  // means any async workflows currently executed would be cut off. We handle
+  // this by letting all async workflows finish executing before closing the
+  // file
+  if (name === 'close-budget') {
+    await flushRunningMethods();
+  }
+
+  const promise = handler(args);
+  runningMethods.add(promise);
+  void promise.then(() => {
+    runningMethods.delete(promise);
+  });
+  return promise as Promise<ReturnType<T>>;
+}
+
+// These are useful for tests. Only use them in tests.
+export function enableGlobalMutations() {
+  if (process.env.NODE_ENV === 'test') {
+    globalMutationsEnabled = true;
+  }
+}
+
+export function disableGlobalMutations() {
+  if (process.env.NODE_ENV === 'test') {
+    globalMutationsEnabled = false;
+  }
+}
+
+function _runMutator<T extends () => Promise<unknown>>(
+  func: T,
+  initialContext = {},
+): Promise<Awaited<ReturnType<T>>> {
+  currentContext = initialContext;
+  return func().finally(() => {
+    currentContext = null;
+  }) as Promise<Awaited<ReturnType<T>>>;
+}
+// Type cast needed as TS looses types over nested generic returns
+export const runMutator = sequential(_runMutator) as typeof _runMutator;
+
+export function withMutatorContext<T>(
+  context: { undoListening: boolean; undoTag?: unknown },
+  func: () => Promise<T>,
+): Promise<T> {
+  if (currentContext == null && !globalMutationsEnabled) {
+    captureBreadcrumb('Recent methods: ' + _latestHandlerNames.join(', '));
+    captureException(new Error('withMutatorContext: mutator not running'));
+
+    // See comment below. This is not an error right now, but it will
+    // be in the future.
+    return func();
+  }
+
+  const prevContext = currentContext;
+  currentContext = { ...currentContext, ...context };
+  return func().finally(() => {
+    currentContext = prevContext;
+  });
+}
+
+export function getMutatorContext() {
+  if (currentContext == null) {
+    captureBreadcrumb({
+      category: 'server',
+      message: 'Recent methods: ' + _latestHandlerNames.join(', '),
+    });
+    // captureException(new Error('getMutatorContext: mutator not running'));
+
+    // For now, this is a non-fatal error. It will be in the future,
+    // but this is relatively non-critical (undo just won't work) so
+    // return an empty context. When we have more confidence that
+    // everything is running inside a mutator, throw an error.
+    return {};
+  }
+
+  if (currentContext == null && globalMutationsEnabled) {
+    return {};
+  }
+  return currentContext;
+}

package/src/server/notes/app.ts

@@ -0,0 +1,18 @@
+import type { NoteEntity } from '../../types/models';
+import { createApp } from '../app';
+import * as db from '../db';
+import { mutator } from '../mutators';
+import { undoable } from '../undo';
+
+export type NotesHandlers = {
+  'notes-save': typeof updateNotes;
+  'notes-save-undoable': typeof updateNotes;
+};
+
+export const app = createApp<NotesHandlers>();
+app.method('notes-save', updateNotes);
+app.method('notes-save-undoable', mutator(undoable(updateNotes)));
+
+async function updateNotes({ id, note }: NoteEntity) {
+  await db.update('notes', { id, note });
+}