@actual-app/core 26.3.0

package/src/server/transactions/transfer.test.ts

@@ -0,0 +1,221 @@
+// @ts-strict-ignore
+import { expectSnapshotWithDiffer } from '../../mocks/util';
+import * as db from '../db';
+
+import * as transfer from './transfer';
+
+beforeEach(global.emptyDatabase());
+
+function getAllTransactions() {
+  return db.all<db.DbViewTransaction & { payee_name: db.DbPayee['name'] }>(
+    `SELECT t.*, p.name as payee_name
+       FROM v_transactions t
+       LEFT JOIN payees p ON p.id = t.payee
+       ORDER BY date DESC, amount DESC, id
+     `,
+  );
+}
+
+async function prepareDatabase() {
+  await db.insertCategoryGroup({ id: 'group1', name: 'group1', is_income: 0 });
+  await db.insertCategory({
+    id: '1',
+    name: 'cat1',
+    cat_group: 'group1',
+    is_income: 0,
+  });
+  await db.insertAccount({ id: 'one', name: 'one' });
+  await db.insertAccount({ id: 'two', name: 'two' });
+  await db.insertAccount({ id: 'three', name: 'three', offbudget: 1 });
+  await db.insertPayee({ name: '', transfer_acct: 'one' });
+  await db.insertPayee({ name: '', transfer_acct: 'two' });
+  await db.insertPayee({
+    name: '',
+    transfer_acct: 'three',
+  });
+}
+
+type Transaction = {
+  account: string;
+  amount: number;
+  category?: string;
+  date: string;
+  id?: string;
+  notes?: string;
+  payee: string;
+  transfer_id?: string;
+  is_parent?: boolean;
+  is_child?: boolean;
+  parent_id?: string;
+};
+
+describe('Transfer', () => {
+  test('transfers are properly inserted/updated/deleted', async () => {
+    await prepareDatabase();
+
+    let transaction: Transaction = {
+      account: 'one',
+      amount: 5000,
+      payee: await db.insertPayee({ name: 'Non-transfer' }),
+      date: '2017-01-01',
+    };
+    await db.insertTransaction(transaction);
+    await transfer.onInsert(transaction);
+
+    const differ = expectSnapshotWithDiffer(await getAllTransactions());
+
+    const transferTwo = await db.first<db.DbPayee>(
+      "SELECT * FROM payees WHERE transfer_acct = 'two'",
+    );
+    const transferThree = await db.first<db.DbPayee>(
+      "SELECT * FROM payees WHERE transfer_acct = 'three'",
+    );
+
+    transaction = {
+      account: 'one',
+      amount: 5000,
+      payee: transferTwo.id,
+      date: '2017-01-01',
+    };
+    transaction.id = await db.insertTransaction(transaction);
+    await transfer.onInsert(transaction);
+    differ.expectToMatchDiff(await getAllTransactions());
+
+    // Fill the transaction out
+    transaction = await db.getTransaction(transaction.id);
+    expect(transaction.transfer_id).toBeDefined();
+
+    transaction = {
+      ...transaction,
+      date: '2017-01-05',
+      notes: 'This is a note',
+    };
+    await db.updateTransaction(transaction);
+    await transfer.onUpdate(transaction);
+    differ.expectToMatchDiff(await getAllTransactions());
+
+    transaction = {
+      ...transaction,
+      payee: transferThree.id,
+    };
+    await db.updateTransaction(transaction);
+    await transfer.onUpdate(transaction);
+    differ.expectToMatchDiff(await getAllTransactions());
+
+    transaction = {
+      ...transaction,
+      payee: await db.insertPayee({ name: 'Not transferred anymore' }),
+    };
+    await db.updateTransaction(transaction);
+    await transfer.onUpdate(transaction);
+    differ.expectToMatchDiff(await getAllTransactions());
+
+    // Make sure it's not a linked transaction anymore
+    transaction = await db.getTransaction(transaction.id);
+    expect(transaction.transfer_id).toBeNull();
+
+    // Re-transfer it
+    transaction = {
+      ...transaction,
+      payee: transferTwo.id,
+    };
+    await db.updateTransaction(transaction);
+    await transfer.onUpdate(transaction);
+    differ.expectToMatchDiff(await getAllTransactions());
+
+    transaction = await db.getTransaction(transaction.id);
+    expect(transaction.transfer_id).toBeDefined();
+
+    await db.deleteTransaction(transaction);
+    await transfer.onDelete(transaction);
+    differ.expectToMatchDiff(await getAllTransactions());
+  });
+
+  test('transfers are properly de-categorized', async () => {
+    await prepareDatabase();
+
+    const transferTwo = await db.first<db.DbPayee>(
+      "SELECT * FROM payees WHERE transfer_acct = 'two'",
+    );
+    const transferThree = await db.first<db.DbPayee>(
+      "SELECT * FROM payees WHERE transfer_acct = 'three'",
+    );
+
+    let transaction: Transaction = {
+      account: 'one',
+      amount: 5000,
+      payee: await db.insertPayee({ name: 'Non-transfer' }),
+      date: '2017-01-01',
+      category: '1',
+    };
+    transaction.id = await db.insertTransaction(transaction);
+    await transfer.onInsert(transaction);
+
+    const differ = expectSnapshotWithDiffer(await getAllTransactions());
+
+    transaction = {
+      ...(await db.getTransaction(transaction.id)),
+      payee: transferThree.id,
+      notes: 'hi',
+    };
+    await db.updateTransaction(transaction);
+    await transfer.onUpdate(transaction);
+    differ.expectToMatchDiff(await getAllTransactions());
+
+    transaction = {
+      ...(await db.getTransaction(transaction.id)),
+      payee: transferTwo.id,
+    };
+    await db.updateTransaction(transaction);
+    await transfer.onUpdate(transaction);
+    differ.expectToMatchDiff(await getAllTransactions());
+  });
+
+  test('split transfers are retained on child transactions', async () => {
+    // test: first add a txn having a transfer acct payee
+    // then mark it as `is_parent` and add a child txn
+    // the child txn should have a different transfer acct payee
+    // and `is_child` set to true
+    await prepareDatabase();
+
+    const [transferOne, transferTwo] = await Promise.all([
+      db.first<db.DbPayee>("SELECT * FROM payees WHERE transfer_acct = 'one'"),
+      db.first<db.DbPayee>("SELECT * FROM payees WHERE transfer_acct = 'two'"),
+    ]);
+
+    let parent: Transaction = {
+      account: 'one',
+      amount: 5000,
+      payee: transferTwo.id,
+      date: '2017-01-01',
+    };
+    parent.id = await db.insertTransaction(parent);
+    await transfer.onInsert(parent);
+    parent = await db.getTransaction(parent.id);
+
+    const differ = expectSnapshotWithDiffer(await getAllTransactions());
+
+    // mark the txn as parent
+    await db.updateTransaction({ id: parent.id, is_parent: true });
+    await transfer.onUpdate(parent);
+    differ.expectToMatchDiff(await getAllTransactions());
+
+    // add a child txn
+    let child: Transaction = {
+      account: 'one',
+      amount: 2000,
+      payee: transferOne.id,
+      date: '2017-01-01',
+      is_child: true,
+      parent_id: parent.id,
+    };
+    child.id = await db.insertTransaction(child);
+    await transfer.onInsert(child);
+    differ.expectToMatchDiff(await getAllTransactions());
+
+    // ensure that the child txn has the correct transfer acct payee
+    child = await db.getTransaction(child.id);
+    expect(child.transfer_id).not.toBe(parent.transfer_id);
+    expect(child.payee).toBe(transferOne.id);
+  });
+});

package/src/server/transactions/transfer.ts

@@ -0,0 +1,173 @@
+// @ts-strict-ignore
+import * as db from '../db';
+
+import { runRules } from './transaction-rules';
+
+async function getPayee(acct) {
+  return db.first<db.DbPayee>('SELECT * FROM payees WHERE transfer_acct = ?', [
+    acct,
+  ]);
+}
+
+async function getTransferredAccount(transaction) {
+  if (transaction.payee) {
+    const result = await db.first<Pick<db.DbViewPayee, 'transfer_acct'>>(
+      'SELECT transfer_acct FROM v_payees WHERE id = ?',
+      [transaction.payee],
+    );
+
+    return result?.transfer_acct || null;
+  }
+  return null;
+}
+
+async function clearCategory(transaction, transferAcct) {
+  const { offbudget: fromOffBudget } = await db.first<
+    Pick<db.DbAccount, 'offbudget'>
+  >('SELECT offbudget FROM accounts WHERE id = ?', [transaction.account]);
+  const { offbudget: toOffBudget } = await db.first<
+    Pick<db.DbAccount, 'offbudget'>
+  >('SELECT offbudget FROM accounts WHERE id = ?', [transferAcct]);
+
+  // If the transfer is between two on budget or two off budget accounts,
+  // we should clear the category, because the category is not relevant
+  if (fromOffBudget === toOffBudget) {
+    await db.updateTransaction({ id: transaction.id, category: null });
+    if (transaction.transfer_id) {
+      await db.updateTransaction({
+        id: transaction.transfer_id,
+        category: null,
+      });
+    }
+    return true;
+  }
+  return false;
+}
+
+export async function addTransfer(transaction, transferredAccount) {
+  if (transaction.is_parent) {
+    // For split transactions, we should create transfers using child transactions.
+    // This is to ensure that the amounts received by the transferred account
+    // reflects the amounts in the child transactions and not the parent transaction
+    // amount which is the total amount.
+    return null;
+  }
+
+  const { id: fromPayee } = await db.first<Pick<db.DbPayee, 'id'>>(
+    'SELECT id FROM payees WHERE transfer_acct = ?',
+    [transaction.account],
+  );
+
+  const transferTransaction = {
+    account: transferredAccount,
+    amount: -transaction.amount,
+    payee: fromPayee,
+    date: transaction.date,
+    transfer_id: transaction.id,
+    notes: transaction.notes || null,
+    schedule: transaction.schedule,
+    cleared: false,
+  };
+  const { notes, cleared, schedule } = await runRules(transferTransaction);
+  const matchedSchedule = schedule ?? transaction.schedule;
+
+  const id = await db.insertTransaction({
+    ...transferTransaction,
+    notes,
+    cleared,
+    schedule: matchedSchedule,
+  });
+
+  await db.updateTransaction({
+    id: transaction.id,
+    transfer_id: id,
+    ...(matchedSchedule ? { schedule: matchedSchedule } : {}),
+  });
+  const categoryCleared = await clearCategory(transaction, transferredAccount);
+
+  return {
+    id: transaction.id,
+    transfer_id: id,
+    ...(categoryCleared ? { category: null } : {}),
+  };
+}
+
+export async function removeTransfer(transaction) {
+  const transferTrans = await db.getTransaction(transaction.transfer_id);
+
+  // Perform operations on the transfer transaction only
+  // if it is found. For example: when users delete both
+  // (in & out) transfer transactions at the same time -
+  // transfer transaction will not be found.
+  if (transferTrans) {
+    if (transferTrans.is_child) {
+      // If it's a child transaction, we don't delete it because that
+      // would invalidate the whole split transaction. Instead of turn
+      // it into a normal transaction
+      await db.updateTransaction({
+        id: transaction.transfer_id,
+        transfer_id: null,
+        payee: null,
+      });
+    } else {
+      await db.deleteTransaction({ id: transaction.transfer_id });
+    }
+  }
+  await db.updateTransaction({ id: transaction.id, transfer_id: null });
+  return { id: transaction.id, transfer_id: null };
+}
+
+export async function updateTransfer(transaction, transferredAccount) {
+  const payee = await getPayee(transaction.account);
+
+  await db.updateTransaction({
+    id: transaction.transfer_id,
+    account: transferredAccount,
+    // Make sure to update the payee on the other side in case the
+    // user moved this transaction into another account
+    payee: payee.id,
+    date: transaction.date,
+    notes: transaction.notes,
+    amount: -transaction.amount,
+    schedule: transaction.schedule,
+  });
+
+  const categoryCleared = await clearCategory(transaction, transferredAccount);
+  if (categoryCleared) {
+    return { id: transaction.id, category: null };
+  }
+}
+
+export async function onInsert(transaction) {
+  const transferredAccount = await getTransferredAccount(transaction);
+
+  if (transferredAccount) {
+    return addTransfer(transaction, transferredAccount);
+  }
+}
+
+export async function onDelete(transaction) {
+  if (transaction.transfer_id) {
+    await removeTransfer(transaction);
+  }
+}
+
+export async function onUpdate(transaction) {
+  const transferredAccount = await getTransferredAccount(transaction);
+
+  if (transaction.is_parent) {
+    return removeTransfer(transaction);
+  }
+
+  if (transferredAccount && !transaction.transfer_id) {
+    return addTransfer(transaction, transferredAccount);
+  }
+
+  if (!transferredAccount && transaction.transfer_id) {
+    return removeTransfer(transaction);
+  }
+
+  if (transferredAccount && transaction.transfer_id) {
+    return updateTransfer(transaction, transferredAccount);
+  }
+}

package/src/server/undo.ts

@@ -0,0 +1,271 @@
+// @ts-strict-ignore
+import { Timestamp } from '@actual-app/crdt';
+
+import * as connection from '../platform/server/connection';
+import { getIn } from '../shared/util';
+import type { HandlerFunctions } from '../types/handlers';
+
+import { getMutatorContext, withMutatorContext } from './mutators';
+import { sendMessages } from './sync';
+import type { Message } from './sync';
+
+// A marker always sits as the first entry to simplify logic
+type MarkerMessage = { type: 'marker'; meta?: unknown };
+type MessagesMessage = {
+  type: 'messages';
+  messages: Message[];
+  meta?: unknown;
+  oldData;
+  undoTag;
+};
+let MESSAGE_HISTORY: Array<MarkerMessage | MessagesMessage> = [
+  { type: 'marker' },
+];
+let CURSOR = 0;
+const HISTORY_SIZE = 20;
+
+export type UndoState = {
+  messages: Message[];
+  meta?: unknown;
+  tables: string[];
+  undoTag: string;
+};
+
+function trimHistory() {
+  MESSAGE_HISTORY = MESSAGE_HISTORY.slice(0, CURSOR + 1);
+
+  const markers = MESSAGE_HISTORY.filter(item => item.type === 'marker');
+  if (markers.length > HISTORY_SIZE) {
+    const slice = markers.slice(-HISTORY_SIZE);
+    const cutoff = MESSAGE_HISTORY.indexOf(slice[0]);
+    MESSAGE_HISTORY = MESSAGE_HISTORY.slice(cutoff);
+    CURSOR = MESSAGE_HISTORY.length - 1;
+  }
+}
+
+export function appendMessages(messages, oldData) {
+  const context = getMutatorContext();
+
+  if (context.undoListening && messages.length > 0) {
+    trimHistory();
+
+    const { undoTag } = context;
+
+    MESSAGE_HISTORY.push({
+      type: 'messages',
+      messages,
+      oldData,
+      undoTag,
+    });
+    CURSOR++;
+  }
+}
+
+export function clearUndo() {
+  MESSAGE_HISTORY = [{ type: 'marker' }];
+  CURSOR = 0;
+}
+
+export function withUndo<T>(
+  func: () => Promise<T>,
+  meta?: unknown,
+): Promise<T> {
+  const context = getMutatorContext();
+  if (context.undoDisabled || context.undoListening) {
+    return func();
+  }
+
+  MESSAGE_HISTORY = MESSAGE_HISTORY.slice(0, CURSOR + 1);
+
+  const marker: MarkerMessage = { type: 'marker', meta };
+
+  if (MESSAGE_HISTORY[MESSAGE_HISTORY.length - 1].type === 'marker') {
+    MESSAGE_HISTORY[MESSAGE_HISTORY.length - 1] = marker;
+  } else {
+    MESSAGE_HISTORY.push(marker);
+    CURSOR++;
+  }
+
+  return withMutatorContext(
+    { undoListening: true, undoTag: context.undoTag },
+    func,
+  );
+}
+
+export function undoable<T extends HandlerFunctions>(
+  func: T,
+  metaFunc?: (...metaArgs: Parameters<T>) => unknown,
+) {
+  return (...args: Parameters<T>) => {
+    return withUndo<Awaited<ReturnType<T>>>(
+      () => {
+        return func.apply(null, args);
+      },
+      metaFunc ? metaFunc(...args) : undefined,
+    );
+  };
+}
+
+async function applyUndoAction(messages, meta, undoTag) {
+  await withMutatorContext({ undoListening: false }, () => {
+    return sendMessages(
+      messages.map(msg => ({ ...msg, timestamp: Timestamp.send() })),
+    );
+  });
+
+  const tables = messages.reduce((acc, message) => {
+    if (!acc.includes(message.dataset)) {
+      acc.push(message.dataset);
+    }
+    return acc;
+  }, []);
+
+  connection.send('undo-event', {
+    messages,
+    tables,
+    meta,
+    undoTag,
+  });
+}
+
+export async function undo() {
+  const end = CURSOR;
+  CURSOR = Math.max(CURSOR - 1, 0);
+
+  // Walk back to the nearest marker
+  while (CURSOR > 0 && MESSAGE_HISTORY[CURSOR].type !== 'marker') {
+    CURSOR--;
+  }
+
+  const meta = MESSAGE_HISTORY[CURSOR].meta;
+  const start = Math.max(CURSOR, 0);
+  const entries = MESSAGE_HISTORY.slice(start, end + 1).filter(
+    (entry): entry is MessagesMessage => entry.type === 'messages',
+  );
+
+  if (entries.length > 0) {
+    const toApply = entries
+      .reduce((acc, entry) => {
+        return acc.concat(
+          entry.messages
+            .map(message => undoMessage(message, entry.oldData))
+            .filter(x => x),
+        );
+      }, [])
+      .reverse();
+
+    await applyUndoAction(toApply, meta, entries[0].undoTag);
+  }
+}
+
+function undoMessage(message, oldData) {
+  const oldItem = getIn(oldData, [message.dataset, message.row]);
+  if (oldItem) {
+    let column = message.column;
+    if (message.dataset === 'spreadsheet_cells') {
+      // The spreadsheet messages use the `expr` column, but only as a
+      // placeholder. We actually want to read the `cachedValue` prop
+      // from the old item.
+      column = 'cachedValue';
+    }
+
+    return { ...message, value: oldItem[column] };
+  } else {
+    if (message.dataset === 'spreadsheet_cells') {
+      if (message.column === 'expr') {
+        return { ...message, value: null };
+      }
+      return message;
+    } else if (
+      // The mapping fields aren't ever deleted... this should be
+      // harmless since all they are is meta information. Maybe we
+      // should fix this though.
+      message.dataset !== 'category_mapping' &&
+      message.dataset !== 'payee_mapping'
+    ) {
+      if (
+        message.dataset === 'zero_budget_months' ||
+        message.dataset === 'zero_budgets' ||
+        message.dataset === 'reflect_budgets'
+      ) {
+        // Only these fields are reversable
+        if (['buffered', 'amount', 'carryover'].includes(message.column)) {
+          return { ...message, value: 0 };
+        }
+        return null;
+      } else if (message.dataset === 'notes') {
+        return { ...message, value: null };
+      }
+
+      return { ...message, column: 'tombstone', value: 1 };
+    }
+  }
+  return null;
+}
+
+export async function redo() {
+  const meta =
+    MESSAGE_HISTORY[CURSOR].type === 'marker'
+      ? MESSAGE_HISTORY[CURSOR].meta
+      : null;
+
+  const start = CURSOR;
+  CURSOR = Math.min(CURSOR + 1, MESSAGE_HISTORY.length - 1);
+
+  // Walk forward to the nearest marker
+  while (
+    CURSOR < MESSAGE_HISTORY.length - 1 &&
+    MESSAGE_HISTORY[CURSOR].type !== 'marker'
+  ) {
+    CURSOR++;
+  }
+
+  const end = CURSOR;
+  const entries = MESSAGE_HISTORY.slice(start + 1, end + 1).filter(
+    (entry): entry is MessagesMessage => entry.type === 'messages',
+  );
+
+  if (entries.length > 0) {
+    const toApply = entries.reduce((acc, entry) => {
+      return acc
+        .concat(entry.messages)
+        .concat(redoResurrections(entry.messages, entry.oldData));
+    }, []);
+
+    await applyUndoAction(toApply, meta, entries[entries.length - 1].undoTag);
+  }
+}
+
+function redoResurrections(messages, oldData): Message[] {
+  const resurrect = new Set<string>();
+
+  messages.forEach(message => {
+    // If any of the ids didn't exist before, we need to "resurrect"
+    // them by resetting their tombstones to 0
+    const oldItem = getIn(oldData, [message.dataset, message.row]);
+    if (
+      !oldItem &&
+      ![
+        'zero_budget_months',
+        'zero_budgets',
+        'reflect_budgets',
+        'notes',
+        'category_mapping',
+        'payee_mapping',
+      ].includes(message.dataset)
+    ) {
+      resurrect.add(message.dataset + '.' + message.row);
+    }
+  });
+
+  return [...resurrect].map(desc => {
+    const [table, row] = desc.split('.');
+    return {
+      dataset: table,
+      row,
+      column: 'tombstone',
+      value: 0,
+      timestamp: Timestamp.send(),
+    };
+  });
+}

package/src/server/update.ts

@@ -0,0 +1,37 @@
+// @ts-strict-ignore
+import md5 from 'md5';
+
+import { makeViews, schema, schemaConfig } from './aql';
+import * as db from './db';
+import * as migrations from './migrate/migrations';
+
+// Managing the init/update process
+
+async function runMigrations() {
+  await migrations.migrate(db.getDatabase());
+}
+
+async function updateViews() {
+  const hashKey = 'view-hash';
+  const row = await db.first<{ value: string }>(
+    'SELECT value FROM __meta__ WHERE key = ?',
+    [hashKey],
+  );
+  const { value: hash } = row || {};
+
+  const views = makeViews(schema, schemaConfig);
+  const currentHash = md5(views);
+
+  if (hash !== currentHash) {
+    db.execQuery(views);
+    db.runQuery('INSERT OR REPLACE INTO __meta__ (key, value) VALUES (?, ?)', [
+      hashKey,
+      currentHash,
+    ]);
+  }
+}
+
+export async function updateVersion() {
+  await runMigrations();
+  await updateViews();
+}