@actual-app/core 26.3.0

package/src/server/budget/base.test.ts

@@ -0,0 +1,340 @@
+// @ts-strict-ignore
+import * as monthUtils from '../../shared/months';
+import * as db from '../db';
+import * as sheet from '../sheet';
+
+import { createAllBudgets } from './base';
+
+beforeEach(() => {
+  return global.emptyDatabase()();
+});
+
+describe('Base budget', () => {
+  it('Recomputes budget cells when account fields change', async () => {
+    await sheet.loadSpreadsheet(db);
+
+    await db.insertCategoryGroup({ id: 'group1', name: 'group1' });
+    await db.insertCategoryGroup({
+      id: 'group2',
+      name: 'income',
+      is_income: 1,
+    });
+    const catId = await db.insertCategory({
+      name: 'foo',
+      cat_group: 'group1',
+    });
+
+    await createAllBudgets();
+
+    // Insert a transaction referencing an account that doesn't exist
+    // yet
+    await db.insertTransaction({
+      date: '2016-12-15',
+      amount: -5000,
+      account: '29eef937-9933-49ef-80d9-71627074cf31',
+      category: catId,
+    });
+
+    // Make sure that the spreadsheet finishes processing to make sure
+    // the next change doesn't get batched in with it
+    await sheet.waitOnSpreadsheet();
+
+    // The category should have nothing spent on it yet
+    expect(
+      sheet.getCellValue(
+        monthUtils.sheetForMonth('2016-12'),
+        `sum-amount-${catId}`,
+      ),
+    ).toBe(0);
+
+    // Create the referenced account
+    await db.insertAccount({
+      id: '29eef937-9933-49ef-80d9-71627074cf31',
+      name: 'foo',
+    });
+
+    // Make sure the spreadsheet finishes processing
+    await sheet.waitOnSpreadsheet();
+
+    // The category should see the transaction
+    expect(
+      sheet.getCellValue(
+        monthUtils.sheetForMonth('2016-12'),
+        `sum-amount-${catId}`,
+      ),
+    ).toBe(-5000);
+  });
+
+  it('Excludes hidden categories from group totals in Report Budget', async () => {
+    await sheet.loadSpreadsheet(db);
+    sheet.get().meta().budgetType = 'tracking';
+
+    // Create a group with multiple categories
+    await db.insertCategoryGroup({ id: 'group1', name: 'Test Group' });
+    await db.insertCategoryGroup({
+      id: 'group2',
+      name: 'Income',
+      is_income: 1,
+    });
+
+    const visibleCatId = await db.insertCategory({
+      name: 'Visible Category',
+      cat_group: 'group1',
+    });
+
+    const hiddenCatId = await db.insertCategory({
+      name: 'Hidden Category',
+      cat_group: 'group1',
+      hidden: 1,
+    });
+
+    await createAllBudgets();
+    const month = '2017-01';
+    const sheetName = monthUtils.sheetForMonth(month);
+
+    await db.insertAccount({ id: 'account1', name: 'Account 1' });
+
+    await db.insertTransaction({
+      date: '2017-01-15',
+      amount: -1000,
+      account: 'account1',
+      category: visibleCatId,
+    });
+
+    await db.insertTransaction({
+      date: '2017-01-15',
+      amount: -2000,
+      account: 'account1',
+      category: hiddenCatId,
+    });
+
+    await sheet.waitOnSpreadsheet();
+
+    // Verify individual category amounts
+    expect(sheet.getCellValue(sheetName, `sum-amount-${visibleCatId}`)).toBe(
+      -1000,
+    );
+
+    expect(sheet.getCellValue(sheetName, `sum-amount-${hiddenCatId}`)).toBe(
+      -2000,
+    );
+
+    // Verify group total only includes visible category
+    expect(sheet.getCellValue(sheetName, `group-sum-amount-group1`)).toBe(
+      -1000,
+    );
+
+    // Now toggle hidden status of the hidden category to make it visible
+    await db.updateCategory({
+      id: hiddenCatId,
+      name: 'Hidden Category',
+      cat_group: 'group1',
+      is_income: 0,
+      hidden: 0,
+    });
+
+    await sheet.waitOnSpreadsheet();
+
+    // After making hidden category visible, group total should include both
+    expect(sheet.getCellValue(sheetName, `group-sum-amount-group1`)).toBe(
+      -3000,
+    );
+  });
+
+  it('Excludes hidden category groups from budget totals in Report Budget', async () => {
+    await sheet.loadSpreadsheet(db);
+    sheet.get().meta().budgetType = 'tracking';
+
+    // Create two expense groups - one visible, one hidden
+    await db.insertCategoryGroup({
+      id: 'visible-group',
+      name: 'Visible Group',
+    });
+    await db.insertCategoryGroup({
+      id: 'hidden-group',
+      name: 'Hidden Group',
+      hidden: 1,
+    });
+
+    await db.insertCategoryGroup({
+      id: 'income-group',
+      name: 'Income',
+      is_income: 1,
+    });
+
+    const visibleGroupCatId = await db.insertCategory({
+      name: 'Visible Group Category',
+      cat_group: 'visible-group',
+    });
+
+    const hiddenGroupCatId = await db.insertCategory({
+      name: 'Hidden Group Category',
+      cat_group: 'hidden-group',
+    });
+
+    await createAllBudgets();
+    const month = '2017-01';
+    const sheetName = monthUtils.sheetForMonth(month);
+
+    await db.insertAccount({ id: 'account1', name: 'Account 1' });
+
+    await db.insertTransaction({
+      date: '2017-01-15',
+      amount: -1000,
+      account: 'account1',
+      category: visibleGroupCatId,
+    });
+
+    await db.insertTransaction({
+      date: '2017-01-15',
+      amount: -2000,
+      account: 'account1',
+      category: hiddenGroupCatId,
+    });
+
+    await sheet.waitOnSpreadsheet();
+
+    // Verify individual amounts
+    expect(
+      sheet.getCellValue(sheetName, `sum-amount-${visibleGroupCatId}`),
+    ).toBe(-1000);
+
+    expect(
+      sheet.getCellValue(sheetName, `sum-amount-${hiddenGroupCatId}`),
+    ).toBe(-2000);
+
+    expect(
+      sheet.getCellValue(sheetName, `group-sum-amount-visible-group`),
+    ).toBe(-1000);
+
+    expect(sheet.getCellValue(sheetName, `group-sum-amount-hidden-group`)).toBe(
+      -2000,
+    );
+
+    // Verify total spent only includes visible group
+    expect(sheet.getCellValue(sheetName, 'total-spent')).toBe(-1000);
+
+    // Now toggle hidden status of the hidden group to make it visible
+    await db.updateCategoryGroup({
+      id: 'hidden-group',
+      name: 'Hidden Group',
+      is_income: 0,
+      hidden: 0,
+    });
+
+    await sheet.waitOnSpreadsheet();
+
+    // After making hidden group visible, total should include both
+    expect(sheet.getCellValue(sheetName, 'total-spent')).toBe(-3000);
+  });
+
+  it('Includes hidden categories in group totals for Rollover Budget', async () => {
+    await sheet.loadSpreadsheet(db);
+    // Rollover is the default, but explicit for clarity
+    sheet.get().meta().budgetType = 'envelope';
+
+    // Create a group with multiple categories
+    await db.insertCategoryGroup({ id: 'group1', name: 'Test Group' });
+    await db.insertCategoryGroup({
+      id: 'group2',
+      name: 'Income',
+      is_income: 1,
+    });
+
+    const visibleCatId = await db.insertCategory({
+      name: 'Visible Category',
+      cat_group: 'group1',
+    });
+
+    const hiddenCatId = await db.insertCategory({
+      name: 'Hidden Category',
+      cat_group: 'group1',
+      hidden: 1,
+    });
+
+    await createAllBudgets();
+    const month = '2017-01';
+    const sheetName = monthUtils.sheetForMonth(month);
+
+    await db.insertAccount({ id: 'account1', name: 'Account 1' });
+
+    await db.insertTransaction({
+      date: '2017-01-15',
+      amount: -1000,
+      account: 'account1',
+      category: visibleCatId,
+    });
+
+    await db.insertTransaction({
+      date: '2017-01-15',
+      amount: -2000,
+      account: 'account1',
+      category: hiddenCatId,
+    });
+
+    await sheet.waitOnSpreadsheet();
+
+    // Verify group total includes both visible and hidden category amounts
+    expect(sheet.getCellValue(sheetName, `group-sum-amount-group1`)).toBe(
+      -3000,
+    );
+  });
+
+  it('Includes hidden category groups in budget totals for Rollover Budget', async () => {
+    await sheet.loadSpreadsheet(db);
+    // Rollover is the default, but explicit for clarity
+    sheet.get().meta().budgetType = 'envelope';
+
+    // Create two expense groups - one visible, one hidden
+    await db.insertCategoryGroup({
+      id: 'visible-group',
+      name: 'Visible Group',
+    });
+    await db.insertCategoryGroup({
+      id: 'hidden-group',
+      name: 'Hidden Group',
+      hidden: 1,
+    });
+
+    await db.insertCategoryGroup({
+      id: 'income-group',
+      name: 'Income',
+      is_income: 1,
+    });
+
+    const visibleGroupCatId = await db.insertCategory({
+      name: 'Visible Group Category',
+      cat_group: 'visible-group',
+    });
+
+    const hiddenGroupCatId = await db.insertCategory({
+      name: 'Hidden Group Category',
+      cat_group: 'hidden-group',
+    });
+
+    await createAllBudgets();
+    const month = '2017-01';
+    const sheetName = monthUtils.sheetForMonth(month);
+
+    await db.insertAccount({ id: 'account1', name: 'Account 1' });
+
+    await db.insertTransaction({
+      date: '2017-01-15',
+      amount: -1000,
+      account: 'account1',
+      category: visibleGroupCatId,
+    });
+
+    await db.insertTransaction({
+      date: '2017-01-15',
+      amount: -2000,
+      account: 'account1',
+      category: hiddenGroupCatId,
+    });
+
+    await sheet.waitOnSpreadsheet();
+
+    // Verify total spent includes both visible and hidden group amounts
+    expect(sheet.getCellValue(sheetName, 'total-spent')).toBe(-3000);
+  });
+});

package/src/server/budget/base.ts

@@ -0,0 +1,339 @@
+// @ts-strict-ignore
+import * as monthUtils from '../../shared/months';
+import { q } from '../../shared/query';
+import { getChangedValues } from '../../shared/util';
+import type { CategoryGroupEntity } from '../../types/models';
+import { aqlQuery } from '../aql';
+import * as db from '../db';
+import * as sheet from '../sheet';
+import { resolveName } from '../spreadsheet/util';
+
+import * as budgetActions from './actions';
+import * as envelopeBudget from './envelope';
+import * as report from './report';
+
+export function getBudgetType() {
+  const meta = sheet.get().meta();
+  return meta.budgetType || 'envelope';
+}
+
+export function getBudgetRange(start: string, end: string) {
+  start = monthUtils.getMonth(start);
+  end = monthUtils.getMonth(end);
+
+  // The start date should never be after the end date. If that
+  // happened, the month range might be a valid range and weird
+  // things happen
+  if (start > end) {
+    start = end;
+  }
+
+  // Budgets should exist 3 months before the earliest needed date
+  // (either the oldest transaction or the current month if no
+  // transactions yet), and a year from the current date. There's no
+  // need to ever have budgets outside that range.
+  start = monthUtils.subMonths(start, 3);
+  end = monthUtils.addMonths(end, 12);
+
+  return { start, end, range: monthUtils.rangeInclusive(start, end) };
+}
+
+export function createCategory(cat, sheetName, prevSheetName, start, end) {
+  sheet.get().createDynamic(sheetName, 'sum-amount-' + cat.id, {
+    initialValue: 0,
+    run: () => {
+      // Making this sync is faster!
+      const rows = db.runQuery<{ amount: number }>(
+        `SELECT SUM(amount) as amount FROM v_transactions_internal_alive t
+           LEFT JOIN accounts a ON a.id = t.account
+         WHERE t.date >= ${start} AND t.date <= ${end}
+           AND category = '${cat.id}' AND a.offbudget = 0`,
+        [],
+        true,
+      );
+      const row = rows[0];
+      const amount = row ? row.amount : 0;
+      return amount || 0;
+    },
+  });
+
+  if (getBudgetType() === 'envelope') {
+    envelopeBudget.createCategory(cat, sheetName, prevSheetName);
+  } else {
+    void report.createCategory(cat, sheetName, prevSheetName);
+  }
+}
+
+function handleAccountChange(months, oldValue, newValue) {
+  if (!oldValue || oldValue.offbudget !== newValue.offbudget) {
+    const rows = db.runQuery<Pick<db.DbTransaction, 'category'>>(
+      `
+        SELECT DISTINCT(category) as category FROM transactions
+        WHERE acct = ?
+      `,
+      [newValue.id],
+      true,
+    );
+
+    months.forEach(month => {
+      const sheetName = monthUtils.sheetForMonth(month);
+
+      rows.forEach(row => {
+        sheet
+          .get()
+          .recompute(resolveName(sheetName, 'sum-amount-' + row.category));
+      });
+    });
+  }
+}
+
+function handleTransactionChange(transaction, changedFields) {
+  if (
+    (changedFields.has('date') ||
+      changedFields.has('acct') ||
+      changedFields.has('amount') ||
+      changedFields.has('category') ||
+      changedFields.has('tombstone') ||
+      changedFields.has('isParent')) &&
+    transaction.date &&
+    transaction.category
+  ) {
+    const month = monthUtils.monthFromDate(db.fromDateRepr(transaction.date));
+    const sheetName = monthUtils.sheetForMonth(month);
+
+    sheet
+      .get()
+      .recompute(resolveName(sheetName, 'sum-amount-' + transaction.category));
+  }
+}
+
+function handleCategoryMappingChange(months, oldValue, newValue) {
+  months.forEach(month => {
+    const sheetName = monthUtils.sheetForMonth(month);
+    if (oldValue) {
+      sheet
+        .get()
+        .recompute(resolveName(sheetName, 'sum-amount-' + oldValue.transferId));
+    }
+    sheet
+      .get()
+      .recompute(resolveName(sheetName, 'sum-amount-' + newValue.transferId));
+  });
+}
+
+function handleBudgetMonthChange(budget) {
+  const sheetName = monthUtils.sheetForMonth(budget.id);
+  sheet.get().set(`${sheetName}!buffered`, budget.buffered);
+}
+
+function handleBudgetChange(budget) {
+  if (budget.category) {
+    const sheetName = monthUtils.sheetForMonth(budget.month.toString());
+    sheet
+      .get()
+      .set(`${sheetName}!budget-${budget.category}`, budget.amount || 0);
+    sheet
+      .get()
+      .set(
+        `${sheetName}!carryover-${budget.category}`,
+        budget.carryover === 1 ? true : false,
+      );
+    sheet.get().set(`${sheetName}!goal-${budget.category}`, budget.goal);
+    sheet
+      .get()
+      .set(`${sheetName}!long-goal-${budget.category}`, budget.long_goal);
+  }
+}
+
+export function triggerBudgetChanges(oldValues, newValues) {
+  const { createdMonths = new Set() } = sheet.get().meta();
+  const budgetType = getBudgetType();
+  sheet.startTransaction();
+
+  try {
+    newValues.forEach((items, table) => {
+      const old = oldValues.get(table);
+
+      items.forEach(newValue => {
+        const oldValue = old && old.get(newValue.id);
+
+        if (table === 'zero_budget_months') {
+          handleBudgetMonthChange(newValue);
+        } else if (table === 'zero_budgets' || table === 'reflect_budgets') {
+          handleBudgetChange(newValue);
+        } else if (table === 'transactions') {
+          const changed = new Set(
+            Object.keys(getChangedValues(oldValue || {}, newValue) || {}),
+          );
+
+          if (oldValue) {
+            handleTransactionChange(oldValue, changed);
+          }
+          handleTransactionChange(newValue, changed);
+        } else if (table === 'category_mapping') {
+          handleCategoryMappingChange(createdMonths, oldValue, newValue);
+        } else if (table === 'categories') {
+          if (budgetType === 'envelope') {
+            envelopeBudget.handleCategoryChange(
+              createdMonths,
+              oldValue,
+              newValue,
+            );
+          } else {
+            report.handleCategoryChange(createdMonths, oldValue, newValue);
+          }
+        } else if (table === 'category_groups') {
+          if (budgetType === 'envelope') {
+            envelopeBudget.handleCategoryGroupChange(
+              createdMonths,
+              oldValue,
+              newValue,
+            );
+          } else {
+            report.handleCategoryGroupChange(createdMonths, oldValue, newValue);
+          }
+        } else if (table === 'accounts') {
+          handleAccountChange(createdMonths, oldValue, newValue);
+        }
+      });
+    });
+  } finally {
+    sheet.endTransaction();
+  }
+}
+
+export async function doTransfer(categoryIds, transferId) {
+  const { createdMonths: months } = sheet.get().meta();
+
+  [...months].forEach(month => {
+    const totalValue = categoryIds
+      .map(id => {
+        return budgetActions.getBudget({ month, category: id });
+      })
+      .reduce((total, value) => total + value, 0);
+
+    const transferValue = budgetActions.getBudget({
+      month,
+      category: transferId,
+    });
+
+    void budgetActions.setBudget({
+      month,
+      category: transferId,
+      amount: totalValue + transferValue,
+    });
+  });
+}
+
+export async function createBudget(months) {
+  const { data: groups }: { data: CategoryGroupEntity[] } = await aqlQuery(
+    q('category_groups').select('*'),
+  );
+  const categories = groups.flatMap(group => group.categories);
+
+  sheet.startTransaction();
+  const meta = sheet.get().meta();
+  meta.createdMonths = meta.createdMonths || new Set();
+
+  const budgetType = getBudgetType();
+
+  if (budgetType === 'envelope') {
+    envelopeBudget.createBudget(meta, categories, months);
+  }
+
+  months.forEach(month => {
+    if (!meta.createdMonths.has(month)) {
+      const prevMonth = monthUtils.prevMonth(month);
+      const { start, end } = monthUtils.bounds(month);
+      const sheetName = monthUtils.sheetForMonth(month);
+      const prevSheetName = monthUtils.sheetForMonth(prevMonth);
+
+      categories.forEach(cat => {
+        createCategory(cat, sheetName, prevSheetName, start, end);
+      });
+      groups.forEach(group => {
+        if (budgetType === 'envelope') {
+          envelopeBudget.createCategoryGroup(group, sheetName);
+        } else {
+          report.createCategoryGroup(group, sheetName);
+        }
+      });
+
+      if (budgetType === 'envelope') {
+        envelopeBudget.createSummary(
+          groups,
+          categories,
+          prevSheetName,
+          sheetName,
+        );
+      } else {
+        report.createSummary(groups, sheetName);
+      }
+
+      meta.createdMonths.add(month);
+    }
+  });
+
+  sheet.get().setMeta(meta);
+  sheet.endTransaction();
+
+  // Wait for the spreadsheet to finish computing. Normally this won't
+  // do anything (as values are cached) but on first run this need to
+  // show the loading screen while it initially sets up.
+  await sheet.waitOnSpreadsheet();
+}
+
+export async function createAllBudgets() {
+  const earliestTransaction = await db.first<db.DbTransaction>(
+    'SELECT * FROM transactions WHERE isChild=0 AND date IS NOT NULL ORDER BY date ASC LIMIT 1',
+  );
+  const earliestDate =
+    earliestTransaction && db.fromDateRepr(earliestTransaction.date);
+  const currentMonth = monthUtils.currentMonth();
+
+  // Get the range based off of the earliest transaction and the
+  // current month. If no transactions currently exist the current
+  // month is also used as the starting month
+  const { start, end, range } = getBudgetRange(
+    earliestDate || currentMonth,
+    currentMonth,
+  );
+
+  const meta = sheet.get().meta();
+  const createdMonths = meta.createdMonths || new Set();
+  const newMonths = range.filter(m => !createdMonths.has(m));
+
+  if (newMonths.length > 0) {
+    await createBudget(range);
+  }
+
+  return { start, end };
+}
+
+export async function setType(type) {
+  const meta = sheet.get().meta();
+  if (type === meta.budgetType) {
+    return;
+  }
+
+  meta.budgetType = type;
+  meta.createdMonths = new Set();
+
+  // Go through and force all the cells to be recomputed
+  const nodes = sheet.get().getNodes();
+  db.transaction(() => {
+    for (const name of nodes.keys()) {
+      const [sheetName, cellName] = name.split('!');
+      if (sheetName.match(/^budget\d+/)) {
+        sheet.get().deleteCell(sheetName, cellName);
+      }
+    }
+  });
+
+  sheet.get().startCacheBarrier();
+  void sheet.loadUserBudgets(db);
+  const bounds = await createAllBudgets();
+  sheet.get().endCacheBarrier();
+
+  return bounds;
+}