@actual-app/core 26.3.0

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

@@ -0,0 +1,370 @@
+// @ts-strict-ignore
+import type { TransactionEntity } from '../../types/models';
+import * as db from '../db';
+
+import { mergeTransactions } from './merge';
+
+describe('Merging fails for invalid quantity', () => {
+  beforeEach(global.emptyDatabase());
+  afterEach(global.emptyDatabase());
+
+  const tests: [TransactionEntity[], string][] = [
+    [[{} as TransactionEntity], 'one transaction'],
+    [[], 'no transactions'],
+    [undefined as unknown as TransactionEntity[], 'undefined'],
+    [[{}, {}, {}] as TransactionEntity[], 'three transactions'],
+    [
+      [{}, undefined] as TransactionEntity[],
+      'two transactions but one is undefined',
+    ],
+  ];
+  tests.forEach(([arr, message]) =>
+    it(message, () => expect(() => mergeTransactions(arr)).rejects.toThrow()),
+  );
+
+  it("fails when amounts don't match", async () => {
+    await prepareDatabase();
+    const t1 = await db.insertTransaction({
+      account: 'one',
+      date: '2025-01-01',
+      amount: 10,
+    });
+    const t2 = await db.insertTransaction({
+      account: 'one',
+      date: '2025-01-01',
+      amount: 12,
+    });
+    await expect(() =>
+      mergeTransactions([{ id: t1 }, { id: t2 }]),
+    ).rejects.toThrow('Transaction amounts must match for merge');
+  });
+
+  it("fails when transaction id doesn't exist", async () => {
+    await prepareDatabase();
+    const t1 = await db.insertTransaction({
+      account: 'one',
+      date: '2025-01-01',
+      amount: 10,
+    });
+    await expect(() =>
+      mergeTransactions([{ id: t1 }, { id: 'missing' }]),
+    ).rejects.toThrow('One of the provided transactions does not exist');
+  });
+});
+
+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.insertCategory({
+    id: '2',
+    name: 'cat2',
+    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({ id: 'payee1', name: 'one' });
+  await db.insertPayee({ id: 'payee2', name: 'two' });
+  await db.insertPayee({ id: 'payee3', name: 'three' });
+}
+
+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
+     `,
+  );
+}
+
+describe('Merging success', () => {
+  beforeEach(global.emptyDatabase());
+  beforeEach(prepareDatabase);
+  afterEach(global.emptyDatabase());
+  const transaction1 = {
+    account: 'one',
+    date: '2025-01-01',
+    payee: 'payee1',
+    notes: 'notes1',
+    category: '1',
+    amount: 5,
+    cleared: false,
+    reconciled: false,
+  } as TransactionEntity;
+
+  const dbTransaction1 = {
+    account: 'one',
+    date: 20250101,
+    payee: 'payee1',
+    notes: 'notes1',
+    category: '1',
+    amount: 5,
+    cleared: 1,
+    reconciled: 1,
+  } as db.DbViewTransaction;
+
+  const transaction2 = {
+    account: 'two',
+    date: '2025-02-02',
+    payee: 'payee2',
+    notes: 'notes2',
+    category: '2',
+    amount: 5,
+    cleared: true,
+    reconciled: true,
+  } as TransactionEntity;
+
+  const dbTransaction2 = {
+    account: 'two',
+    date: 20250202,
+    payee: 'payee2',
+    notes: 'notes2',
+    category: '2',
+    amount: 5,
+    cleared: 1,
+    reconciled: 1,
+  } as db.DbViewTransaction;
+
+  it('two banksynced transactions keeps older transaction', async () => {
+    const t1 = await db.insertTransaction({
+      ...transaction1,
+      imported_id: 'imported_1',
+    });
+    const t2 = await db.insertTransaction({
+      ...transaction2,
+      imported_id: 'imported_2',
+    });
+
+    expect(await mergeTransactions([{ id: t1 }, { id: t2 }])).toBe(t1);
+
+    const transactions = await getAllTransactions();
+    expect(transactions.length).toBe(1);
+    expect(transactions[0]).toMatchObject({
+      ...dbTransaction1,
+      imported_id: 'imported_1',
+    });
+  });
+
+  it('first banksynced, second manual keeps banksynced values', async () => {
+    const t1 = await db.insertTransaction({
+      ...transaction1,
+      imported_id: 'imported_1',
+    });
+    const t2 = await db.insertTransaction(transaction2);
+
+    expect(await mergeTransactions([{ id: t1 }, { id: t2 }])).toBe(t1);
+
+    const transactions = await getAllTransactions();
+    expect(transactions.length).toBe(1);
+    expect(transactions[0]).toMatchObject({
+      ...dbTransaction1,
+      imported_id: 'imported_1',
+    });
+  });
+
+  it('first file imported, second banksycned keeps banksynced values', async () => {
+    const t1 = await db.insertTransaction({
+      ...transaction1,
+      imported_payee: 'payee',
+    });
+    const t2 = await db.insertTransaction({
+      ...transaction2,
+      imported_id: 'imported_2',
+    });
+
+    expect(await mergeTransactions([{ id: t1 }, { id: t2 }])).toBe(t2);
+
+    const transactions = await getAllTransactions();
+    expect(transactions.length).toBe(1);
+    expect(transactions[0]).toMatchObject({
+      ...dbTransaction2,
+      imported_id: 'imported_2',
+    });
+  });
+
+  it('second file imported, first banksycned keeps banksynced values', async () => {
+    const t1 = await db.insertTransaction({
+      ...transaction1,
+      imported_id: 'imported_1',
+    });
+    const t2 = await db.insertTransaction({
+      ...transaction2,
+      imported_payee: 'payee',
+    });
+
+    expect(await mergeTransactions([{ id: t1 }, { id: t2 }])).toBe(t1);
+
+    const transactions = await getAllTransactions();
+    expect(transactions.length).toBe(1);
+    expect(transactions[0]).toMatchObject({
+      ...dbTransaction1,
+      imported_id: 'imported_1',
+    });
+  });
+
+  it('second file imported, first manual keeps file imported values', async () => {
+    const t1 = await db.insertTransaction(transaction1);
+    const t2 = await db.insertTransaction({
+      ...transaction2,
+      imported_payee: 'payee',
+    });
+
+    expect(await mergeTransactions([{ id: t1 }, { id: t2 }])).toBe(t2);
+
+    const transactions = await getAllTransactions();
+    expect(transactions.length).toBe(1);
+    expect(transactions[0]).toMatchObject({
+      ...dbTransaction2,
+      imported_payee: 'payee',
+    });
+  });
+
+  it('first file imported, second manual keeps file imported values', async () => {
+    const t1 = await db.insertTransaction({
+      ...transaction1,
+      imported_payee: 'payee',
+    });
+    const t2 = await db.insertTransaction(transaction2);
+
+    expect(await mergeTransactions([{ id: t1 }, { id: t2 }])).toBe(t1);
+
+    const transactions = await getAllTransactions();
+    expect(transactions.length).toBe(1);
+    expect(transactions[0]).toMatchObject({
+      ...dbTransaction1,
+      imported_payee: 'payee',
+    });
+  });
+
+  it('second banksynced, first manual keeps banksynced values', async () => {
+    const t1 = await db.insertTransaction(transaction1);
+    const t2 = await db.insertTransaction({
+      ...transaction2,
+      imported_id: 'imported_2',
+    });
+
+    expect(await mergeTransactions([{ id: t1 }, { id: t2 }])).toBe(t2);
+
+    const transactions = await getAllTransactions();
+    expect(transactions.length).toBe(1);
+    expect(transactions[0]).toMatchObject({
+      ...dbTransaction2,
+      imported_id: 'imported_2',
+    });
+  });
+
+  it('missing values in keep are filled in with drop values', async () => {
+    // only insert required fields, imported to be kept
+    const t1 = await db.insertTransaction({
+      account: 'one',
+      amount: 5,
+      date: '2025-01-01',
+      imported_id: 'imported_1',
+    });
+    const t2 = await db.insertTransaction(transaction2);
+
+    expect(await mergeTransactions([{ id: t1 }, { id: t2 }])).toBe(t1);
+    const transactions = await getAllTransactions();
+    expect(transactions.length).toBe(1);
+    expect(transactions[0]).toMatchObject({
+      ...dbTransaction2,
+      // values that should be kept from t1
+      id: t1,
+      account: 'one',
+      amount: 5,
+      date: 20250101,
+      imported_id: 'imported_1',
+    });
+  });
+
+  it('preserves split categories when merging split transaction with uncategorized imported transaction', async () => {
+    // Create a manual transaction with splits
+    const manualParent = await db.insertTransaction({
+      account: 'one',
+      amount: 100,
+      date: '2025-01-01',
+      is_parent: true,
+      category: null,
+    });
+
+    const _sub1 = await db.insertTransaction({
+      account: 'one',
+      amount: 60,
+      date: '2025-01-01',
+      category: '1',
+      notes: 'Food',
+      is_child: true,
+      parent_id: manualParent,
+    });
+
+    const _sub2 = await db.insertTransaction({
+      account: 'one',
+      amount: 40,
+      date: '2025-01-01',
+      category: '2',
+      notes: 'Transport',
+      is_child: true,
+      parent_id: manualParent,
+    });
+
+    // Create an uncategorized imported transaction
+    const imported = await db.insertTransaction({
+      account: 'one',
+      amount: 100,
+      date: '2025-01-02',
+      imported_id: 'imported_1',
+      category: null,
+    });
+
+    // Merge: imported transaction should be kept (because it has imported_id)
+    const keptId = await mergeTransactions([
+      { id: manualParent },
+      { id: imported },
+    ]);
+    expect(keptId).toBe(imported);
+
+    // Check that the kept transaction is now a parent
+    const keptTransaction = await db.getTransaction(imported);
+    expect(keptTransaction?.is_parent).toBe(true);
+    expect(keptTransaction?.category).toBeNull();
+    expect(keptTransaction?.imported_id).toBe('imported_1');
+
+    // Check that subtransactions were transferred and still exist
+    const allTransactions = await getAllTransactions();
+    const childTransactions = allTransactions.filter(
+      t => t.parent_id === imported,
+    );
+    expect(childTransactions.length).toBe(2);
+
+    // Verify the subtransactions have the correct parent_id and preserved their categories
+    const child1 = childTransactions.find(t => t.amount === 60);
+    const child2 = childTransactions.find(t => t.amount === 40);
+
+    expect(child1).toMatchObject({
+      parent_id: imported,
+      category: '1',
+      notes: 'Food',
+      is_child: 1, // From getAllTransactions (db.all), not converted
+    });
+
+    expect(child2).toMatchObject({
+      parent_id: imported,
+      category: '2',
+      notes: 'Transport',
+      is_child: 1, // From getAllTransactions (db.all), not converted
+    });
+
+    // Verify no orphaned subtransactions remain
+    const orphanedChildren = allTransactions.filter(
+      t => t.parent_id === manualParent,
+    );
+    expect(orphanedChildren.length).toBe(0);
+  });
+});

package/src/server/transactions/merge.ts

@@ -0,0 +1,139 @@
+import { q } from '../../shared/query';
+import {
+  deleteTransaction as sharedDeleteTransaction,
+  ungroupTransactions,
+} from '../../shared/transactions';
+import type { TransactionEntity } from '../../types/models';
+import { aqlQuery } from '../aql';
+import * as db from '../db';
+
+import { batchUpdateTransactions } from '.';
+
+export async function mergeTransactions(
+  transactions: Pick<TransactionEntity, 'id'>[],
+): Promise<TransactionEntity['id']> {
+  // make sure all values have ids
+  const txIds = transactions?.map(x => x?.id).filter(Boolean) || [];
+  if (txIds.length !== 2) {
+    throw new Error(
+      'Merging is only possible with 2 transactions, but found ' +
+        JSON.stringify(transactions),
+    );
+  }
+
+  // get most recent transactions
+  const [a, b]: TransactionEntity[] = await Promise.all(
+    txIds.map(db.getTransaction),
+  );
+  if (!a || !b) {
+    throw new Error('One of the provided transactions does not exist');
+  } else if (a.amount !== b.amount) {
+    throw new Error('Transaction amounts must match for merge');
+  }
+  const { keep, drop } = determineKeepDrop(a, b);
+
+  // Load subtransactions with a single query, then split by parent_id in memory
+  const keepSubtransactions: TransactionEntity[] = [];
+  const dropSubtransactions: TransactionEntity[] = [];
+  const parents: string[] = [];
+  if (keep.is_parent) parents.push(keep.id);
+  if (drop.is_parent) parents.push(drop.id);
+
+  let rows: TransactionEntity[] = [];
+  if (parents.length === 2) {
+    rows = await db.all<TransactionEntity>(
+      'SELECT * FROM v_transactions WHERE parent_id IN (?, ?)',
+      parents,
+    );
+  } else if (parents.length === 1) {
+    rows = await db.all<TransactionEntity>(
+      'SELECT * FROM v_transactions WHERE parent_id = ?',
+      parents,
+    );
+  } // else: both are non-parents → rows stays []
+
+  for (const row of rows) {
+    if (row.parent_id === keep.id) keepSubtransactions.push(row);
+    else if (row.parent_id === drop.id) dropSubtransactions.push(row);
+  }
+
+  // Determine which transaction has subtransactions (split categories)
+  const keepHasSubtransactions = keepSubtransactions.length > 0;
+  const dropHasSubtransactions = dropSubtransactions.length > 0;
+
+  // If keep doesn't have subtransactions but drop does, transfer them
+  if (!keepHasSubtransactions && dropHasSubtransactions) {
+    // Update each subtransaction to point to the kept parent
+    await Promise.all(
+      dropSubtransactions.map(sub =>
+        db.updateTransaction({
+          id: sub.id,
+          parent_id: keep.id,
+        } as TransactionEntity),
+      ),
+    );
+    // Mark keep as a parent transaction
+    await db.updateTransaction({
+      id: keep.id,
+      is_parent: true,
+      category: null, // Parent transactions with splits shouldn't have a category
+      payee: keep.payee || drop.payee,
+      notes: keep.notes || drop.notes,
+      cleared: keep.cleared || drop.cleared,
+      reconciled: keep.reconciled || drop.reconciled,
+    } as unknown as TransactionEntity);
+  } else {
+    // Normal merge without subtransactions
+    await db.updateTransaction({
+      id: keep.id,
+      payee: keep.payee || drop.payee,
+      category: keep.category || drop.category,
+      notes: keep.notes || drop.notes,
+      cleared: keep.cleared || drop.cleared,
+      reconciled: keep.reconciled || drop.reconciled,
+    } as TransactionEntity);
+  }
+
+  // Delete the dropped transaction using shared deleteTransaction to
+  // intelligently handle possible parent/child cascading logic
+  const { data: transactionsToDelete } = await aqlQuery(
+    q('transactions')
+      .filter({ id: drop.id })
+      .select('*')
+      .options({ splits: 'grouped' }),
+  );
+  const ungroupedTransactions = ungroupTransactions(transactionsToDelete);
+  if (ungroupedTransactions.length > 0) {
+    const { diff } = sharedDeleteTransaction(ungroupedTransactions, drop.id);
+    await batchUpdateTransactions(diff);
+  }
+
+  return keep.id;
+}
+
+function determineKeepDrop(
+  a: TransactionEntity,
+  b: TransactionEntity,
+): { keep: TransactionEntity; drop: TransactionEntity } {
+  // if one is imported through bank sync and the other is manual,
+  // keep the imported transaction
+  if (b.imported_id && !a.imported_id) {
+    return { keep: b, drop: a };
+  } else if (a.imported_id && !b.imported_id) {
+    return { keep: a, drop: b };
+  }
+
+  // same logic but for imported transactions
+  if (b.imported_payee && !a.imported_payee) {
+    return { keep: b, drop: a };
+  } else if (a.imported_payee && !b.imported_payee) {
+    return { keep: a, drop: b };
+  }
+
+  // keep the earlier transaction
+  if (a.date.localeCompare(b.date) < 0) {
+    return { keep: a, drop: b };
+  } else {
+    return { keep: b, drop: a };
+  }
+}