Skip to content

A local-first personal finance app

Extract budget category related server handlers from main.ts to server/budget/app.ts (#4442)

Joel Jeremy Marquezc8813e995362
diff --git a/packages/loot-core/src/mocks/budget.ts b/packages/loot-core/src/mocks/budget.ts
index 112cf41cf5..70add4ff81 100644
--- a/packages/loot-core/src/mocks/budget.ts
+++ b/packages/loot-core/src/mocks/budget.ts
@@ -703,7 +703,7 @@ export async function createTestBudget(handlers: Handlers) {
for (const category of group.categories) {
const categoryId = await handlers['category-create']({
...category,
- isIncome: category.is_income ? 1 : 0,
+ isIncome: category.is_income,
groupId,
});
diff --git a/packages/loot-core/src/server/budget/app.ts b/packages/loot-core/src/server/budget/app.ts
index 345f0097f4..a6a9697e86 100644
--- a/packages/loot-core/src/server/budget/app.ts
+++ b/packages/loot-core/src/server/budget/app.ts
@@ -1,11 +1,57 @@
+import * as monthUtils from '../../shared/months';
+import { CategoryEntity, CategoryGroupEntity } from '../../types/models';
import { createApp } from '../app';
+import * as db from '../db';
+import { APIError } from '../errors';
+import { categoryGroupModel, categoryModel } from '../models';
import { mutator } from '../mutators';
+import * as sheet from '../sheet';
+import { resolveName } from '../spreadsheet/util';
+import { batchMessages } from '../sync';
import { undoable } from '../undo';
import * as actions from './actions';
+import * as budget from './base';
import * as cleanupActions from './cleanup-template';
import * as goalActions from './goaltemplates';
-import { BudgetHandlers } from './types/handlers';
+
+export interface BudgetHandlers {
+ 'budget/budget-amount': typeof actions.setBudget;
+ 'budget/copy-previous-month': typeof actions.copyPreviousMonth;
+ 'budget/copy-single-month': typeof actions.copySinglePreviousMonth;
+ 'budget/set-zero': typeof actions.setZero;
+ 'budget/set-3month-avg': typeof actions.set3MonthAvg;
+ 'budget/set-6month-avg': typeof actions.set6MonthAvg;
+ 'budget/set-12month-avg': typeof actions.set12MonthAvg;
+ 'budget/set-n-month-avg': typeof actions.setNMonthAvg;
+ 'budget/check-templates': typeof goalActions.runCheckTemplates;
+ 'budget/apply-goal-template': typeof goalActions.applyTemplate;
+ 'budget/apply-multiple-templates': typeof goalActions.applyMultipleCategoryTemplates;
+ 'budget/overwrite-goal-template': typeof goalActions.overwriteTemplate;
+ 'budget/apply-single-template': typeof goalActions.applySingleCategoryTemplate;
+ 'budget/cleanup-goal-template': typeof cleanupActions.cleanupTemplate;
+ 'budget/hold-for-next-month': typeof actions.holdForNextMonth;
+ 'budget/reset-hold': typeof actions.resetHold;
+ 'budget/cover-overspending': typeof actions.coverOverspending;
+ 'budget/transfer-available': typeof actions.transferAvailable;
+ 'budget/cover-overbudgeted': typeof actions.coverOverbudgeted;
+ 'budget/transfer-category': typeof actions.transferCategory;
+ 'budget/set-carryover': typeof actions.setCategoryCarryover;
+ 'get-categories': typeof getCategories;
+ 'get-budget-bounds': typeof getBudgetBounds;
+ 'envelope-budget-month': typeof envelopeBudgetMonth;
+ 'tracking-budget-month': typeof trackingBudgetMonth;
+ 'category-create': typeof createCategory;
+ 'category-update': typeof updateCategory;
+ 'category-move': typeof moveCategory;
+ 'category-delete': typeof deleteCategory;
+ 'get-category-groups': typeof getCategoryGroups;
+ 'category-group-create': typeof createCategoryGroup;
+ 'category-group-update': typeof updateCategoryGroup;
+ 'category-group-move': typeof moveCategoryGroup;
+ 'category-group-delete': typeof deleteCategoryGroup;
+ 'must-category-transfer': typeof isCategoryTransferRequired;
+}
export const app = createApp<BudgetHandlers>();
@@ -72,3 +118,330 @@ app.method(
'budget/set-carryover',
mutator(undoable(actions.setCategoryCarryover)),
);
+app.method('get-categories', getCategories);
+app.method('get-budget-bounds', getBudgetBounds);
+app.method('envelope-budget-month', envelopeBudgetMonth);
+app.method('tracking-budget-month', trackingBudgetMonth);
+app.method('category-create', mutator(undoable(createCategory)));
+app.method('category-update', mutator(undoable(updateCategory)));
+app.method('category-move', mutator(undoable(moveCategory)));
+app.method('category-delete', mutator(undoable(deleteCategory)));
+app.method('get-category-groups', getCategoryGroups);
+app.method('category-group-create', mutator(undoable(createCategoryGroup)));
+app.method('category-group-update', mutator(undoable(updateCategoryGroup)));
+app.method('category-group-move', mutator(undoable(moveCategoryGroup)));
+app.method('category-group-delete', mutator(undoable(deleteCategoryGroup)));
+app.method('must-category-transfer', isCategoryTransferRequired);
+
+// Server must return AQL entities not the raw DB data
+async function getCategories() {
+ const categoryGroups = await getCategoryGroups();
+ return {
+ grouped: categoryGroups,
+ list: categoryGroups.flatMap(g => g.categories ?? []),
+ };
+}
+
+async function getBudgetBounds() {
+ return await budget.createAllBudgets();
+}
+
+async function envelopeBudgetMonth({ month }: { month: string }) {
+ const groups = await db.getCategoriesGrouped();
+ const sheetName = monthUtils.sheetForMonth(month);
+
+ function value(name: string) {
+ const v = sheet.getCellValue(sheetName, name);
+ return { value: v === '' ? 0 : v, name: resolveName(sheetName, name) };
+ }
+
+ let values = [
+ value('available-funds'),
+ value('last-month-overspent'),
+ value('buffered'),
+ value('total-budgeted'),
+ value('to-budget'),
+
+ value('from-last-month'),
+ value('total-income'),
+ value('total-spent'),
+ value('total-leftover'),
+ ];
+
+ for (const group of groups) {
+ const categories = group.categories ?? [];
+
+ if (group.is_income) {
+ values.push(value('total-income'));
+
+ for (const cat of categories) {
+ values.push(value(`sum-amount-${cat.id}`));
+ }
+ } else {
+ values = values.concat([
+ value(`group-budget-${group.id}`),
+ value(`group-sum-amount-${group.id}`),
+ value(`group-leftover-${group.id}`),
+ ]);
+
+ for (const cat of categories) {
+ values = values.concat([
+ value(`budget-${cat.id}`),
+ value(`sum-amount-${cat.id}`),
+ value(`leftover-${cat.id}`),
+ value(`carryover-${cat.id}`),
+ value(`goal-${cat.id}`),
+ value(`long-goal-${cat.id}`),
+ ]);
+ }
+ }
+ }
+
+ return values;
+}
+
+async function trackingBudgetMonth({ month }: { month: string }) {
+ const groups = await db.getCategoriesGrouped();
+ const sheetName = monthUtils.sheetForMonth(month);
+
+ function value(name: string) {
+ const v = sheet.getCellValue(sheetName, name);
+ return { value: v === '' ? 0 : v, name: resolveName(sheetName, name) };
+ }
+
+ let values = [
+ value('total-budgeted'),
+ value('total-budget-income'),
+ value('total-saved'),
+ value('total-income'),
+ value('total-spent'),
+ value('real-saved'),
+ value('total-leftover'),
+ ];
+
+ for (const group of groups) {
+ values = values.concat([
+ value(`group-budget-${group.id}`),
+ value(`group-sum-amount-${group.id}`),
+ value(`group-leftover-${group.id}`),
+ ]);
+
+ const categories = group.categories ?? [];
+
+ for (const cat of categories) {
+ values = values.concat([
+ value(`budget-${cat.id}`),
+ value(`sum-amount-${cat.id}`),
+ value(`leftover-${cat.id}`),
+ value(`goal-${cat.id}`),
+ value(`long-goal-${cat.id}`),
+ ]);
+
+ if (!group.is_income) {
+ values.push(value(`carryover-${cat.id}`));
+ }
+ }
+ }
+
+ return values;
+}
+
+async function createCategory({
+ name,
+ groupId,
+ isIncome,
+ hidden,
+}: {
+ name: string;
+ groupId: CategoryGroupEntity['id'];
+ isIncome?: boolean;
+ hidden?: boolean;
+}): Promise<CategoryEntity['id']> {
+ if (!groupId) {
+ throw APIError('Creating a category: groupId is required');
+ }
+
+ return await db.insertCategory({
+ name: name.trim(),
+ cat_group: groupId,
+ is_income: isIncome ? 1 : 0,
+ hidden: hidden ? 1 : 0,
+ });
+}
+
+async function updateCategory(
+ category: CategoryEntity,
+): Promise<{ error?: { type: 'category-exists' } }> {
+ try {
+ await db.updateCategory(
+ categoryModel.toDb({
+ ...category,
+ name: category.name.trim(),
+ }),
+ );
+ } catch (e) {
+ if (
+ e instanceof Error &&
+ e.message.toLowerCase().includes('unique constraint')
+ ) {
+ return { error: { type: 'category-exists' } };
+ }
+ throw e;
+ }
+ return {};
+}
+
+async function moveCategory({
+ id,
+ groupId,
+ targetId,
+}: {
+ id: CategoryEntity['id'];
+ groupId: CategoryGroupEntity['id'];
+ targetId: CategoryEntity['id'];
+}): Promise<void> {
+ await batchMessages(async () => {
+ await db.moveCategory(id, groupId, targetId);
+ });
+}
+
+async function deleteCategory({
+ id,
+ transferId,
+}: {
+ id: CategoryEntity['id'];
+ transferId: CategoryEntity['id'];
+}): Promise<{ error?: 'no-categories' | 'category-type' }> {
+ let result = {};
+ await batchMessages(async () => {
+ const row = await db.first<Pick<db.DbCategory, 'is_income'>>(
+ 'SELECT is_income FROM categories WHERE id = ?',
+ [id],
+ );
+ if (!row) {
+ result = { error: 'no-categories' };
+ return;
+ }
+
+ const transfer =
+ transferId &&
+ (await db.first<Pick<db.DbCategory, 'is_income'>>(
+ 'SELECT is_income FROM categories WHERE id = ?',
+ [transferId],
+ ));
+
+ if (!row || (transferId && !transfer)) {
+ result = { error: 'no-categories' };
+ return;
+ } else if (
+ transferId &&
+ row &&
+ transfer &&
+ row.is_income !== transfer.is_income
+ ) {
+ result = { error: 'category-type' };
+ return;
+ }
+
+ // Update spreadsheet values if it's an expense category
+ // TODO: We should do this for income too if it's a reflect budget
+ if (row.is_income === 0) {
+ if (transferId) {
+ await budget.doTransfer([id], transferId);
+ }
+ }
+
+ await db.deleteCategory({ id }, transferId);
+ });
+
+ return result;
+}
+
+// Server must return AQL entities not the raw DB data
+async function getCategoryGroups() {
+ return (await db.getCategoriesGrouped()) as unknown as CategoryGroupEntity[];
+}
+
+async function createCategoryGroup({
+ name,
+ isIncome,
+ hidden,
+}: {
+ name: CategoryGroupEntity['name'];
+ isIncome?: CategoryGroupEntity['is_income'];
+ hidden?: CategoryGroupEntity['hidden'];
+}): Promise<CategoryGroupEntity['id']> {
+ return await db.insertCategoryGroup({
+ name,
+ is_income: isIncome ? 1 : 0,
+ hidden: hidden ? 1 : 0,
+ });
+}
+
+async function updateCategoryGroup(group: CategoryGroupEntity) {
+ await db.updateCategoryGroup(categoryGroupModel.toDb(group));
+}
+
+async function moveCategoryGroup({
+ id,
+ targetId,
+}: {
+ id: CategoryGroupEntity['id'];
+ targetId: CategoryGroupEntity['id'];
+}): Promise<void> {
+ await batchMessages(async () => {
+ await db.moveCategoryGroup(id, targetId);
+ });
+}
+
+async function deleteCategoryGroup({
+ id,
+ transferId,
+}: {
+ id: CategoryGroupEntity['id'];
+ transferId: CategoryGroupEntity['id'];
+}): Promise<void> {
+ const groupCategories = await db.all<Pick<CategoryEntity, 'id'>>(
+ 'SELECT id FROM categories WHERE cat_group = ? AND tombstone = 0',
+ [id],
+ );
+
+ await batchMessages(async () => {
+ if (transferId) {
+ await budget.doTransfer(
+ groupCategories.map(c => c.id),
+ transferId,
+ );
+ }
+ await db.deleteCategoryGroup({ id }, transferId);
+ });
+}
+
+async function isCategoryTransferRequired({
+ id,
+}: {
+ id: CategoryEntity['id'];
+}) {
+ const res = await db.runQuery<{ count: number }>(
+ `SELECT count(t.id) as count FROM transactions t
+ LEFT JOIN category_mapping cm ON cm.id = t.category
+ WHERE cm.transferId = ? AND t.tombstone = 0`,
+ [id],
+ true,
+ );
+
+ // If there are transactions with this category, return early since
+ // we already know it needs to be tranferred
+ if (res[0].count !== 0) {
+ return true;
+ }
+
+ // If there are any non-zero budget values, also force the user to
+ // transfer the category.
+ return [...(sheet.get().meta().createdMonths as Set<string>)].some(month => {
+ const sheetName = monthUtils.sheetForMonth(month);
+ const value = sheet.get().getCellValue(sheetName, 'budget-' + id);
+
+ return value != null && value !== 0;
+ });
+}
diff --git a/packages/loot-core/src/server/budget/types/handlers.d.ts b/packages/loot-core/src/server/budget/types/handlers.d.ts
deleted file mode 100644
index 28da76d152..0000000000
--- a/packages/loot-core/src/server/budget/types/handlers.d.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-import type { Notification } from '../../../client/notifications/notificationsSlice';
-
-export interface BudgetHandlers {
- 'budget/budget-amount': (arg: {
- category: string /* category id */;
- month: string;
- amount: number;
- }) => Promise<void>;
-
- 'budget/copy-previous-month': (arg: { month: string }) => Promise<void>;
-
- 'budget/set-zero': (arg: { month: string }) => Promise<void>;
-
- 'budget/set-3month-avg': (arg: { month: string }) => Promise<void>;
-
- 'budget/set-6month-avg': (arg: { month: string }) => Promise<void>;
-
- 'budget/set-12month-avg': (arg: { month: string }) => Promise<void>;
-
- 'budget/check-templates': () => Promise<Notification>;
-
- 'budget/apply-goal-template': (arg: {
- month: string;
- }) => Promise<Notification>;
-
- 'budget/overwrite-goal-template': (arg: {
- month: string;
- }) => Promise<Notification>;
-
- 'budget/cleanup-goal-template': (arg: {
- month: string;
- }) => Promise<Notification>;
-
- 'budget/hold-for-next-month': (arg: {
- month: string;
- amount: number;
- }) => Promise<boolean>;
-
- 'budget/reset-hold': (arg: { month: string }) => Promise<void>;
-
- 'budget/cover-overspending': (arg: {
- month: string;
- to: string;
- from: string;
- }) => Promise<void>;
-
- 'budget/transfer-available': (arg: {
- month: string;
- amount: number;
- category: string;
- }) => Promise<void>;
-
- 'budget/cover-overbudgeted': (arg: {
- month: string;
- category: string;
- }) => Promise<void>;
-
- 'budget/transfer-category': (arg: {
- month: string;
- amount: number;
- to: string;
- from: string;
- }) => Promise<void>;
-
- 'budget/set-carryover': (arg: {
- startMonth: string;
- category: string;
- flag: boolean;
- }) => Promise<void>;
-
- 'budget/apply-single-template': (arg: {
- month: string;
- category: string; //category id
- }) => Promise<Notification>;
-
- 'budget/set-n-month-avg': (arg: {
- month: string;
- N: number;
- category: string; //category id
- }) => Promise<void>;
-
- 'budget/copy-single-month': (arg: {
- month: string;
- category: string; //category id
- }) => Promise<void>;
-
- 'budget/apply-multiple-templates': (arg: {
- month: string;
- categoryIds: string[];
- }) => Promise<Notification>;
-}
diff --git a/packages/loot-core/src/server/db/index.ts b/packages/loot-core/src/server/db/index.ts
index 0e66abd85d..10354ca973 100644
--- a/packages/loot-core/src/server/db/index.ts
+++ b/packages/loot-core/src/server/db/index.ts
@@ -306,7 +306,9 @@ export function updateWithSchema(table, fields) {
// Data-specific functions. Ideally this would be split up into
// different files
-export async function getCategories(ids?: Array<DbCategory['id']>) {
+export async function getCategories(
+ ids?: Array<DbCategory['id']>,
+): Promise<DbCategory[]> {
const whereIn = ids ? `c.id IN (${toSqlQueryParameters(ids)}) AND` : '';
const query = `SELECT c.* FROM categories c WHERE ${whereIn} c.tombstone = 0 ORDER BY c.sort_order, c.id`;
return ids
@@ -343,7 +345,9 @@ export async function getCategoriesGrouped(
}));
}
-export async function insertCategoryGroup(group) {
+export async function insertCategoryGroup(
+ group: WithRequired<Partial<DbCategoryGroup>, 'name'>,
+): Promise<DbCategoryGroup['id']> {
// Don't allow duplicate group
const existingGroup = await first<
Pick<DbCategoryGroup, 'id' | 'name' | 'hidden'>
@@ -366,15 +370,24 @@ export async function insertCategoryGroup(group) {
...categoryGroupModel.validate(group),
sort_order,
};
- return insertWithUUID('category_groups', group);
+ const id: DbCategoryGroup['id'] = await insertWithUUID(
+ 'category_groups',
+ group,
+ );
+ return id;
}
-export function updateCategoryGroup(group) {
+export function updateCategoryGroup(
+ group: WithRequired<Partial<DbCategoryGroup>, 'name' | 'is_income'>,
+) {
group = categoryGroupModel.validate(group, { update: true });
return update('category_groups', group);
}
-export async function moveCategoryGroup(id, targetId) {
+export async function moveCategoryGroup(
+ id: DbCategoryGroup['id'],
+ targetId: DbCategoryGroup['id'],
+) {
const groups = await all<Pick<DbCategoryGroup, 'id' | 'sort_order'>>(
`SELECT id, sort_order FROM category_groups WHERE tombstone = 0 ORDER BY sort_order, id`,
);
@@ -386,7 +399,10 @@ export async function moveCategoryGroup(id, targetId) {
await update('category_groups', { id, sort_order });
}
-export async function deleteCategoryGroup(group, transferId?: string) {
+export async function deleteCategoryGroup(
+ group: Pick<DbCategoryGroup, 'id'>,
+ transferId?: string,
+) {
const categories = await all<DbCategory>(
'SELECT * FROM categories WHERE cat_group = ?',
[group.id],
@@ -398,12 +414,12 @@ export async function deleteCategoryGroup(group, transferId?: string) {
}
export async function insertCategory(
- category,
- { atEnd } = { atEnd: undefined },
-) {
+ category: WithRequired<Partial<DbCategory>, 'name' | 'cat_group'>,
+ { atEnd }: { atEnd?: boolean | undefined } = { atEnd: undefined },
+): Promise<DbCategory['id']> {
let sort_order;
- let id_;
+ let id_: DbCategory['id'];
await batchMessages(async () => {
// Dont allow duplicated names in groups
const existingCatInGroup = await first<Pick<DbCategory, 'id'>>(
@@ -452,7 +468,12 @@ export async function insertCategory(
return id_;
}
-export function updateCategory(category) {
+export function updateCategory(
+ category: WithRequired<
+ Partial<DbCategory>,
+ 'name' | 'is_income' | 'cat_group'
+ >,
+) {
category = categoryModel.validate(category, { update: true });
return update('categories', category);
}
diff --git a/packages/loot-core/src/server/main.ts b/packages/loot-core/src/server/main.ts
index 9510766824..334992a9ec 100644
--- a/packages/loot-core/src/server/main.ts
+++ b/packages/loot-core/src/server/main.ts
@@ -12,11 +12,9 @@ import * as connection from '../platform/server/connection';
import * as fs from '../platform/server/fs';
import { logger } from '../platform/server/log';
import * as sqlite from '../platform/server/sqlite';
-import * as monthUtils from '../shared/months';
import { q } from '../shared/query';
import { type Budget } from '../types/budget';
import { Handlers } from '../types/handlers';
-import { CategoryEntity, CategoryGroupEntity } from '../types/models';
import { OpenIdConfig } from '../types/models/openid';
import { app as accountsApp } from './accounts/app';
@@ -37,7 +35,6 @@ import { app as dashboardApp } from './dashboard/app';
import * as db from './db';
import * as mappings from './db/mappings';
import * as encryption from './encryption';
-import { APIError } from './errors';
import { app as filtersApp } from './filters/app';
import { handleBudgetImport } from './importers';
import { app } from './main-app';
@@ -62,13 +59,12 @@ import {
clearFullSyncTimeout,
resetSync,
repairSync,
- batchMessages,
} from './sync';
import * as syncMigrations from './sync/migrate';
import { app as toolsApp } from './tools/app';
import { app as transactionsApp } from './transactions/app';
import * as rules from './transactions/transaction-rules';
-import { clearUndo, undo, redo, withUndo } from './undo';
+import { clearUndo, undo, redo } from './undo';
import { updateVersion } from './update';
import {
uniqueBudgetName,
@@ -103,285 +99,6 @@ handlers['redo'] = mutator(function () {
return redo();
});
-handlers['get-categories'] = async function () {
- // TODO: Force cast to CategoryGroupEntity and CategoryEntity.
- // This should be updated to AQL queries. The server should not directly return DB models.
- return {
- grouped:
- (await db.getCategoriesGrouped()) as unknown as CategoryGroupEntity[],
- list: (await db.getCategories()) as unknown as CategoryEntity[],
- };
-};
-
-handlers['get-budget-bounds'] = async function () {
- return budget.createAllBudgets();
-};
-
-handlers['envelope-budget-month'] = async function ({ month }) {
- const groups = await db.getCategoriesGrouped();
- const sheetName = monthUtils.sheetForMonth(month);
-
- function value(name) {
- const v = sheet.getCellValue(sheetName, name);
- return { value: v === '' ? 0 : v, name: resolveName(sheetName, name) };
- }
-
- let values = [
- value('available-funds'),
- value('last-month-overspent'),
- value('buffered'),
- value('total-budgeted'),
- value('to-budget'),
-
- value('from-last-month'),
- value('total-income'),
- value('total-spent'),
- value('total-leftover'),
- ];
-
- for (const group of groups) {
- if (group.is_income) {
- values.push(value('total-income'));
-
- for (const cat of group.categories) {
- values.push(value(`sum-amount-${cat.id}`));
- }
- } else {
- values = values.concat([
- value(`group-budget-${group.id}`),
- value(`group-sum-amount-${group.id}`),
- value(`group-leftover-${group.id}`),
- ]);
-
- for (const cat of group.categories) {
- values = values.concat([
- value(`budget-${cat.id}`),
- value(`sum-amount-${cat.id}`),
- value(`leftover-${cat.id}`),
- value(`carryover-${cat.id}`),
- value(`goal-${cat.id}`),
- value(`long-goal-${cat.id}`),
- ]);
- }
- }
- }
-
- return values;
-};
-
-handlers['tracking-budget-month'] = async function ({ month }) {
- const groups = await db.getCategoriesGrouped();
- const sheetName = monthUtils.sheetForMonth(month);
-
- function value(name) {
- const v = sheet.getCellValue(sheetName, name);
- return { value: v === '' ? 0 : v, name: resolveName(sheetName, name) };
- }
-
- let values = [
- value('total-budgeted'),
- value('total-budget-income'),
- value('total-saved'),
- value('total-income'),
- value('total-spent'),
- value('real-saved'),
- value('total-leftover'),
- ];
-
- for (const group of groups) {
- values = values.concat([
- value(`group-budget-${group.id}`),
- value(`group-sum-amount-${group.id}`),
- value(`group-leftover-${group.id}`),
- ]);
-
- for (const cat of group.categories) {
- values = values.concat([
- value(`budget-${cat.id}`),
- value(`sum-amount-${cat.id}`),
- value(`leftover-${cat.id}`),
- value(`goal-${cat.id}`),
- value(`long-goal-${cat.id}`),
- ]);
-
- if (!group.is_income) {
- values.push(value(`carryover-${cat.id}`));
- }
- }
- }
-
- return values;
-};
-
-handlers['category-create'] = mutator(async function ({
- name,
- groupId,
- isIncome,
- hidden,
-}) {
- return withUndo(async () => {
- if (!groupId) {
- throw APIError('Creating a category: groupId is required');
- }
-
- return db.insertCategory({
- name: name.trim(),
- cat_group: groupId,
- is_income: isIncome ? 1 : 0,
- hidden: hidden ? 1 : 0,
- });
- });
-});
-
-handlers['category-update'] = mutator(async function (category) {
- return withUndo(async () => {
- try {
- await db.updateCategory({
- ...category,
- name: category.name.trim(),
- });
- } catch (e) {
- if (e.message.toLowerCase().includes('unique constraint')) {
- return { error: { type: 'category-exists' } };
- }
- throw e;
- }
- return {};
- });
-});
-
-handlers['category-move'] = mutator(async function ({ id, groupId, targetId }) {
- return withUndo(async () => {
- await batchMessages(async () => {
- await db.moveCategory(id, groupId, targetId);
- });
- return 'ok';
- });
-});
-
-handlers['category-delete'] = mutator(async function ({ id, transferId }) {
- return withUndo(async () => {
- let result = {};
- await batchMessages(async () => {
- const row = await db.first<Pick<db.DbCategory, 'is_income'>>(
- 'SELECT is_income FROM categories WHERE id = ?',
- [id],
- );
- if (!row) {
- result = { error: 'no-categories' };
- return;
- }
-
- const transfer =
- transferId &&
- (await db.first<Pick<db.DbCategory, 'is_income'>>(
- 'SELECT is_income FROM categories WHERE id = ?',
- [transferId],
- ));
-
- if (!row || (transferId && !transfer)) {
- result = { error: 'no-categories' };
- return;
- } else if (transferId && row.is_income !== transfer.is_income) {
- result = { error: 'category-type' };
- return;
- }
-
- // Update spreadsheet values if it's an expense category
- // TODO: We should do this for income too if it's a reflect budget
- if (row.is_income === 0) {
- if (transferId) {
- await budget.doTransfer([id], transferId);
- }
- }
-
- await db.deleteCategory({ id }, transferId);
- });
-
- return result;
- });
-});
-
-handlers['get-category-groups'] = async function () {
- return await db.getCategoriesGrouped();
-};
-
-handlers['category-group-create'] = mutator(async function ({
- name,
- isIncome,
- hidden,
-}) {
- return withUndo(async () => {
- return db.insertCategoryGroup({
- name,
- is_income: isIncome ? 1 : 0,
- hidden,
- });
- });
-});
-
-handlers['category-group-update'] = mutator(async function (group) {
- return withUndo(async () => {
- return db.updateCategoryGroup(group);
- });
-});
-
-handlers['category-group-move'] = mutator(async function ({ id, targetId }) {
- return withUndo(async () => {
- await batchMessages(async () => {
- await db.moveCategoryGroup(id, targetId);
- });
- return 'ok';
- });
-});
-
-handlers['category-group-delete'] = mutator(async function ({
- id,
- transferId,
-}) {
- return withUndo(async () => {
- const groupCategories = await db.all<Pick<db.DbCategory, 'id'>>(
- 'SELECT id FROM categories WHERE cat_group = ? AND tombstone = 0',
- [id],
- );
-
- return batchMessages(async () => {
- if (transferId) {
- await budget.doTransfer(
- groupCategories.map(c => c.id),
- transferId,
- );
- }
- await db.deleteCategoryGroup({ id }, transferId);
- });
- });
-});
-
-handlers['must-category-transfer'] = async function ({ id }) {
- const res = await db.runQuery<{ count: number }>(
- `SELECT count(t.id) as count FROM transactions t
- LEFT JOIN category_mapping cm ON cm.id = t.category
- WHERE cm.transferId = ? AND t.tombstone = 0`,
- [id],
- true,
- );
-
- // If there are transactions with this category, return early since
- // we already know it needs to be tranferred
- if (res[0].count !== 0) {
- return true;
- }
-
- // If there are any non-zero budget values, also force the user to
- // transfer the category.
- return [...sheet.get().meta().createdMonths].some(month => {
- const sheetName = monthUtils.sheetForMonth(month);
- const value = sheet.get().getCellValue(sheetName, 'budget-' + id);
-
- return value != null && value !== 0;
- });
-};
-
handlers['make-filters-from-conditions'] = async function ({
conditions,
applySpecialCases,
diff --git a/packages/loot-core/src/server/models.ts b/packages/loot-core/src/server/models.ts
index dfab26b130..d4b443f259 100644
--- a/packages/loot-core/src/server/models.ts
+++ b/packages/loot-core/src/server/models.ts
@@ -1,4 +1,8 @@
-import { PayeeEntity } from '../types/models';
+import {
+ CategoryEntity,
+ CategoryGroupEntity,
+ PayeeEntity,
+} from '../types/models';
import {
convertForInsert,
@@ -69,7 +73,7 @@ export const categoryModel = {
validate(
category: Partial<DbCategory>,
{ update }: { update?: boolean } = {},
- ) {
+ ): DbCategory {
requiredFields(
'category',
category,
@@ -78,7 +82,43 @@ export const categoryModel = {
);
const { sort_order, ...rest } = category;
- return { ...rest, hidden: rest.hidden ? 1 : 0 } as DbCategory;
+ return { ...rest } as DbCategory;
+ },
+ toDb(
+ category: CategoryEntity,
+ { update }: { update?: boolean } = {},
+ ): DbCategory {
+ const { cat_group: group, ...rest } = category;
+ // TODO: This is a workaround.
+ // Entity model does not match AQL so we rename it here.
+ // It should be updated later to match AQL.
+ const catWithGroupRenamed = {
+ ...rest,
+ group,
+ };
+ return (
+ update
+ ? convertForUpdate(
+ schema,
+ schemaConfig,
+ 'categories',
+ catWithGroupRenamed,
+ )
+ : convertForInsert(
+ schema,
+ schemaConfig,
+ 'categories',
+ catWithGroupRenamed,
+ )
+ ) as DbCategory;
+ },
+ fromDb(category: DbCategory): CategoryEntity {
+ return convertFromSelect(
+ schema,
+ schemaConfig,
+ 'categories',
+ category,
+ ) as CategoryEntity;
},
};
@@ -86,7 +126,7 @@ export const categoryGroupModel = {
validate(
categoryGroup: Partial<DbCategoryGroup>,
{ update }: { update?: boolean } = {},
- ) {
+ ): DbCategoryGroup {
requiredFields(
'categoryGroup',
categoryGroup,
@@ -95,7 +135,47 @@ export const categoryGroupModel = {
);
const { sort_order, ...rest } = categoryGroup;
- return { ...rest, hidden: rest.hidden ? 1 : 0 } as DbCategoryGroup;
+ 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(categoryModel.fromDb),
+ };
},
};
diff --git a/packages/loot-core/src/types/handlers.d.ts b/packages/loot-core/src/types/handlers.d.ts
index 15f81e6e6d..c0ec2a28c2 100644
--- a/packages/loot-core/src/types/handlers.d.ts
+++ b/packages/loot-core/src/types/handlers.d.ts
@@ -1,6 +1,6 @@
import type { AccountHandlers } from '../server/accounts/app';
import type { AdminHandlers } from '../server/admin/types/handlers';
-import type { BudgetHandlers } from '../server/budget/types/handlers';
+import type { BudgetHandlers } from '../server/budget/app';
import type { DashboardHandlers } from '../server/dashboard/types/handlers';
import type { FiltersHandlers } from '../server/filters/types/handlers';
import type { NotesHandlers } from '../server/notes/types/handlers';
diff --git a/upcoming-release-notes/4442.md b/upcoming-release-notes/4442.md
new file mode 100644
index 0000000000..d015915b53
--- /dev/null
+++ b/upcoming-release-notes/4442.md
@@ -0,0 +1,6 @@
+---
+category: Maintenance
+authors: [joel-jeremy]
+---
+
+Extract budget category related server handlers from main.ts to server/budget/app.ts
\ No newline at end of file