530 lines
19 KiB
TypeScript
530 lines
19 KiB
TypeScript
import { db } from '#lib/server/db/index.js';
|
||
import {
|
||
moneyAccounts,
|
||
moneyTransactions,
|
||
moneyRecurring,
|
||
moneyForecasts,
|
||
moneyUtilitySettings,
|
||
moneyUtilityReadings,
|
||
moneyWishlist,
|
||
moneyInsurances,
|
||
moneyProjectionSettings
|
||
} from '#lib/server/db/schema/index.js';
|
||
import { requireAdmin } from '#lib/server/authorization.js';
|
||
import {
|
||
type ImportedTransaction,
|
||
cadence,
|
||
cents,
|
||
invalid,
|
||
optionalText,
|
||
parseTransactionImport,
|
||
planImport,
|
||
positiveId,
|
||
textField,
|
||
utilityKind,
|
||
validDate
|
||
} from '#lib/server/money-tracker.js';
|
||
import { and, asc, desc, eq, gte, inArray } from 'drizzle-orm';
|
||
import { error, redirect } from '@sveltejs/kit';
|
||
import type { Actions, PageServerLoad } from './$types';
|
||
|
||
export const load: PageServerLoad = async (event) => {
|
||
if (!event.locals.user) redirect(303, '/login?returnTo=/projects/money-tracker');
|
||
const user = requireAdmin(event);
|
||
const userId = user.id;
|
||
const [
|
||
accounts,
|
||
transactions,
|
||
recurring,
|
||
forecasts,
|
||
utilitySettings,
|
||
utilityReadings,
|
||
wishlist,
|
||
insurances,
|
||
projectionSettings
|
||
] = await Promise.all([
|
||
db
|
||
.select()
|
||
.from(moneyAccounts)
|
||
.where(eq(moneyAccounts.userId, userId))
|
||
.orderBy(asc(moneyAccounts.name)),
|
||
db
|
||
.select({
|
||
id: moneyTransactions.id,
|
||
accountId: moneyTransactions.accountId,
|
||
date: moneyTransactions.date,
|
||
description: moneyTransactions.description,
|
||
amountCents: moneyTransactions.amountCents,
|
||
source: moneyTransactions.source
|
||
})
|
||
.from(moneyTransactions)
|
||
.where(eq(moneyTransactions.userId, userId))
|
||
.orderBy(asc(moneyTransactions.date), asc(moneyTransactions.id)),
|
||
db
|
||
.select()
|
||
.from(moneyRecurring)
|
||
.where(eq(moneyRecurring.userId, userId))
|
||
.orderBy(asc(moneyRecurring.name)),
|
||
db
|
||
.select()
|
||
.from(moneyForecasts)
|
||
.where(eq(moneyForecasts.userId, userId))
|
||
.orderBy(asc(moneyForecasts.date)),
|
||
db.select().from(moneyUtilitySettings).where(eq(moneyUtilitySettings.userId, userId)),
|
||
db
|
||
.select()
|
||
.from(moneyUtilityReadings)
|
||
.where(eq(moneyUtilityReadings.userId, userId))
|
||
.orderBy(asc(moneyUtilityReadings.date)),
|
||
db
|
||
.select()
|
||
.from(moneyWishlist)
|
||
.where(eq(moneyWishlist.userId, userId))
|
||
.orderBy(desc(moneyWishlist.createdAt)),
|
||
db
|
||
.select()
|
||
.from(moneyInsurances)
|
||
.where(eq(moneyInsurances.userId, userId))
|
||
.orderBy(asc(moneyInsurances.name)),
|
||
db.select().from(moneyProjectionSettings).where(eq(moneyProjectionSettings.userId, userId))
|
||
]);
|
||
return {
|
||
accounts,
|
||
transactions,
|
||
recurring,
|
||
forecasts,
|
||
utilitySettings,
|
||
utilityReadings,
|
||
wishlist,
|
||
insurances,
|
||
projectionSettings: projectionSettings[0] ?? null,
|
||
today: new Date().toISOString().slice(0, 10)
|
||
};
|
||
};
|
||
|
||
async function ownedAccount(userId: string, value: FormDataEntryValue | null, optional = false) {
|
||
if (optional && !value) return null;
|
||
const id = positiveId(value);
|
||
if (!id) error(400, 'Choose an account.');
|
||
const [account] = await db
|
||
.select({ id: moneyAccounts.id })
|
||
.from(moneyAccounts)
|
||
.where(and(eq(moneyAccounts.id, id), eq(moneyAccounts.userId, userId)));
|
||
if (!account) error(400, 'Choose an account you own.');
|
||
return account.id;
|
||
}
|
||
|
||
function recordId(form: FormData) {
|
||
return positiveId(form.get('id'));
|
||
}
|
||
|
||
export const actions: Actions = {
|
||
saveAccount: async (event) => {
|
||
const user = requireAdmin(event);
|
||
const form = await event.request.formData();
|
||
const name = textField(form, 'name', 80);
|
||
const openingBalanceCents = cents(form.get('openingBalance'));
|
||
const kind = String(form.get('kind') ?? 'spendable');
|
||
const colorRaw = String(form.get('color') ?? '').trim();
|
||
const color = colorRaw ? colorRaw.toLowerCase() : null;
|
||
if (!name || openingBalanceCents == null || !['spendable', 'investment'].includes(kind))
|
||
return invalid('Enter an account name and a valid opening balance.');
|
||
if (color && !/^#[0-9a-f]{6}$/.test(color)) return invalid('Choose a valid account color.');
|
||
const id = recordId(form);
|
||
try {
|
||
if (id) {
|
||
const [row] = await db
|
||
.update(moneyAccounts)
|
||
.set({ name, openingBalanceCents, kind, color })
|
||
.where(and(eq(moneyAccounts.id, id), eq(moneyAccounts.userId, user.id)))
|
||
.returning({ id: moneyAccounts.id });
|
||
if (!row) error(404, 'Account not found');
|
||
} else
|
||
await db
|
||
.insert(moneyAccounts)
|
||
.values({ userId: user.id, name, openingBalanceCents, kind, color });
|
||
} catch (cause) {
|
||
if (typeof cause === 'object' && cause && 'code' in cause && cause.code === '23505')
|
||
return invalid('An account with that name already exists.');
|
||
throw cause;
|
||
}
|
||
return { saved: true };
|
||
},
|
||
deleteAccount: async (event) => {
|
||
const user = requireAdmin(event);
|
||
const id = recordId(await event.request.formData());
|
||
if (!id) return invalid('Invalid account.');
|
||
try {
|
||
await db
|
||
.delete(moneyAccounts)
|
||
.where(and(eq(moneyAccounts.id, id), eq(moneyAccounts.userId, user.id)));
|
||
} catch (cause) {
|
||
if (typeof cause === 'object' && cause && 'code' in cause && cause.code === '23503')
|
||
return invalid('Remove or move this account’s transactions before deleting it.');
|
||
throw cause;
|
||
}
|
||
return { saved: true };
|
||
},
|
||
saveTransaction: async (event) => {
|
||
const user = requireAdmin(event);
|
||
const form = await event.request.formData();
|
||
const date = validDate(form.get('date'));
|
||
const description = textField(form, 'description', 500);
|
||
const amountCents = cents(form.get('amount'));
|
||
if (!date || !description || amountCents == null)
|
||
return invalid('Enter a date, description and valid signed amount.');
|
||
const accountId = await ownedAccount(user.id, form.get('accountId'));
|
||
if (!accountId) return invalid('Choose an account.');
|
||
const values = { date, description, amountCents, accountId };
|
||
const id = recordId(form);
|
||
if (id) {
|
||
const [row] = await db
|
||
.update(moneyTransactions)
|
||
.set(values)
|
||
.where(and(eq(moneyTransactions.id, id), eq(moneyTransactions.userId, user.id)))
|
||
.returning({ id: moneyTransactions.id });
|
||
if (!row) error(404, 'Transaction not found');
|
||
} else await db.insert(moneyTransactions).values({ ...values, userId: user.id });
|
||
return { saved: true };
|
||
},
|
||
deleteTransaction: async (event) => {
|
||
const user = requireAdmin(event);
|
||
const id = recordId(await event.request.formData());
|
||
if (!id) return invalid('Invalid transaction.');
|
||
await db
|
||
.delete(moneyTransactions)
|
||
.where(and(eq(moneyTransactions.id, id), eq(moneyTransactions.userId, user.id)));
|
||
return { saved: true };
|
||
},
|
||
saveRecurring: async (event) => {
|
||
const user = requireAdmin(event);
|
||
const form = await event.request.formData();
|
||
const name = textField(form, 'name', 200);
|
||
const amountCents = cents(form.get('amount'));
|
||
const period = cadence(form.get('cadence'));
|
||
const startsOnRaw = String(form.get('startsOn') ?? '').trim();
|
||
const endsOnRaw = String(form.get('endsOn') ?? '').trim();
|
||
const startsOn = startsOnRaw ? validDate(startsOnRaw) : null;
|
||
const endsOn = endsOnRaw ? validDate(endsOnRaw) : null;
|
||
if (
|
||
!name ||
|
||
amountCents == null ||
|
||
!period ||
|
||
(startsOnRaw && !startsOn) ||
|
||
(endsOnRaw && !endsOn) ||
|
||
(startsOn && endsOn && endsOn < startsOn)
|
||
)
|
||
return invalid('Enter a name, valid signed amount and frequency.');
|
||
const accountId = await ownedAccount(user.id, form.get('accountId'), true);
|
||
const values = { name, amountCents, cadence: period, accountId, startsOn, endsOn };
|
||
const id = recordId(form);
|
||
if (id) {
|
||
const [row] = await db
|
||
.update(moneyRecurring)
|
||
.set(values)
|
||
.where(and(eq(moneyRecurring.id, id), eq(moneyRecurring.userId, user.id)))
|
||
.returning({ id: moneyRecurring.id });
|
||
if (!row) error(404, 'Recurring item not found');
|
||
} else await db.insert(moneyRecurring).values({ ...values, userId: user.id });
|
||
return { saved: true };
|
||
},
|
||
deleteRecurring: async (event) => {
|
||
const user = requireAdmin(event);
|
||
const id = recordId(await event.request.formData());
|
||
if (!id) return invalid('Invalid recurring item.');
|
||
await db
|
||
.delete(moneyRecurring)
|
||
.where(and(eq(moneyRecurring.id, id), eq(moneyRecurring.userId, user.id)));
|
||
return { saved: true };
|
||
},
|
||
saveForecast: async (event) => {
|
||
const user = requireAdmin(event);
|
||
const form = await event.request.formData();
|
||
const date = validDate(form.get('date'));
|
||
const description = textField(form, 'description', 500);
|
||
const amountCents = cents(form.get('amount'));
|
||
if (!date || !description || amountCents == null)
|
||
return invalid('Enter a date, description and valid signed amount.');
|
||
const accountId = await ownedAccount(user.id, form.get('accountId'), true);
|
||
const values = { date, description, amountCents, accountId };
|
||
const id = recordId(form);
|
||
if (id) {
|
||
const [row] = await db
|
||
.update(moneyForecasts)
|
||
.set(values)
|
||
.where(and(eq(moneyForecasts.id, id), eq(moneyForecasts.userId, user.id)))
|
||
.returning({ id: moneyForecasts.id });
|
||
if (!row) error(404, 'Forecast not found');
|
||
} else await db.insert(moneyForecasts).values({ ...values, userId: user.id });
|
||
return { saved: true };
|
||
},
|
||
deleteForecast: async (event) => {
|
||
const user = requireAdmin(event);
|
||
const id = recordId(await event.request.formData());
|
||
if (!id) return invalid('Invalid forecast.');
|
||
await db
|
||
.delete(moneyForecasts)
|
||
.where(and(eq(moneyForecasts.id, id), eq(moneyForecasts.userId, user.id)));
|
||
return { saved: true };
|
||
},
|
||
saveProjectionSettings: async (event) => {
|
||
const user = requireAdmin(event);
|
||
const form = await event.request.formData();
|
||
const investmentAccountId = await ownedAccount(user.id, form.get('investmentAccountId'), true);
|
||
if (investmentAccountId !== null) {
|
||
const [account] = await db
|
||
.select({ kind: moneyAccounts.kind })
|
||
.from(moneyAccounts)
|
||
.where(and(eq(moneyAccounts.id, investmentAccountId), eq(moneyAccounts.userId, user.id)));
|
||
if (account?.kind !== 'investment') return invalid('Choose an investment account.');
|
||
}
|
||
const reserveCents = cents(form.get('reserve'));
|
||
const fixedMonthlyCents = cents(form.get('fixedMonthly'));
|
||
const annualReturnPercent = String(form.get('annualReturnPercent') ?? '')
|
||
.trim()
|
||
.replace(',', '.');
|
||
const contributionMode = String(form.get('contributionMode') ?? 'excess');
|
||
const endDateRaw = String(form.get('endDate') ?? '').trim();
|
||
const endDate = endDateRaw ? validDate(endDateRaw) : null;
|
||
const maxEndDate = new Date();
|
||
maxEndDate.setUTCFullYear(maxEndDate.getUTCFullYear() + 20);
|
||
if (
|
||
reserveCents == null ||
|
||
reserveCents < 0 ||
|
||
fixedMonthlyCents == null ||
|
||
fixedMonthlyCents < 0 ||
|
||
!/^(?:\d{1,2}|100)(?:\.\d{1,2})?$/.test(annualReturnPercent) ||
|
||
Number(annualReturnPercent) > 100 ||
|
||
!['excess', 'fixed'].includes(contributionMode) ||
|
||
(endDateRaw && !endDate) ||
|
||
(endDate &&
|
||
(endDate < new Date().toISOString().slice(0, 10) ||
|
||
endDate > maxEndDate.toISOString().slice(0, 10)))
|
||
)
|
||
return invalid('Enter valid projection settings.');
|
||
const values = {
|
||
investmentAccountId,
|
||
reserveCents,
|
||
fixedMonthlyCents,
|
||
annualReturnPercent,
|
||
contributionMode,
|
||
includeRecurring: form.get('includeRecurring') === 'on',
|
||
endDate
|
||
};
|
||
await db
|
||
.insert(moneyProjectionSettings)
|
||
.values({ userId: user.id, ...values })
|
||
.onConflictDoUpdate({
|
||
target: moneyProjectionSettings.userId,
|
||
set: values
|
||
});
|
||
return { saved: true };
|
||
},
|
||
saveUtilitySettings: async (event) => {
|
||
const user = requireAdmin(event);
|
||
const form = await event.request.formData();
|
||
const kind = utilityKind(form.get('kind'));
|
||
const rate = String(form.get('ratePerUnit') ?? '')
|
||
.trim()
|
||
.replace(',', '.');
|
||
const monthlyAdvanceCents = cents(form.get('monthlyAdvance'));
|
||
const billingStartRaw = String(form.get('billingStart') ?? '').trim();
|
||
const billingStart = billingStartRaw ? validDate(billingStartRaw) : null;
|
||
if (
|
||
!kind ||
|
||
!/^\d{1,7}(?:\.\d{1,4})?$/.test(rate) ||
|
||
monthlyAdvanceCents == null ||
|
||
monthlyAdvanceCents < 0 ||
|
||
(billingStartRaw && !billingStart)
|
||
)
|
||
return invalid('Enter a non-negative unit rate and monthly advance.');
|
||
await db
|
||
.insert(moneyUtilitySettings)
|
||
.values({ userId: user.id, kind, ratePerUnit: rate, monthlyAdvanceCents, billingStart })
|
||
.onConflictDoUpdate({
|
||
target: [moneyUtilitySettings.userId, moneyUtilitySettings.kind],
|
||
set: { ratePerUnit: rate, monthlyAdvanceCents, billingStart }
|
||
});
|
||
return { saved: true };
|
||
},
|
||
saveReading: async (event) => {
|
||
const user = requireAdmin(event);
|
||
const form = await event.request.formData();
|
||
const kind = utilityKind(form.get('kind'));
|
||
const date = validDate(form.get('date'));
|
||
const reading = String(form.get('reading') ?? '')
|
||
.trim()
|
||
.replace(',', '.');
|
||
if (!kind || !date || !/^\d{1,9}(?:\.\d{1,3})?$/.test(reading))
|
||
return invalid('Enter a valid meter reading and date.');
|
||
const id = recordId(form);
|
||
const values = { kind, date, reading };
|
||
if (id) {
|
||
const [row] = await db
|
||
.update(moneyUtilityReadings)
|
||
.set(values)
|
||
.where(and(eq(moneyUtilityReadings.id, id), eq(moneyUtilityReadings.userId, user.id)))
|
||
.returning({ id: moneyUtilityReadings.id });
|
||
if (!row) error(404, 'Reading not found');
|
||
} else await db.insert(moneyUtilityReadings).values({ ...values, userId: user.id });
|
||
return { saved: true };
|
||
},
|
||
deleteReading: async (event) => {
|
||
const user = requireAdmin(event);
|
||
const id = recordId(await event.request.formData());
|
||
if (!id) return invalid('Invalid reading.');
|
||
await db
|
||
.delete(moneyUtilityReadings)
|
||
.where(and(eq(moneyUtilityReadings.id, id), eq(moneyUtilityReadings.userId, user.id)));
|
||
return { saved: true };
|
||
},
|
||
saveWishlist: async (event) => {
|
||
const user = requireAdmin(event);
|
||
const form = await event.request.formData();
|
||
const name = textField(form, 'name', 200);
|
||
const estimatedCents = cents(form.get('estimated'), true);
|
||
const notes = optionalText(form, 'notes');
|
||
const priority = Number(form.get('priority') ?? 3);
|
||
if (
|
||
!name ||
|
||
estimatedCents === undefined ||
|
||
notes === undefined ||
|
||
(estimatedCents !== null && estimatedCents < 0) ||
|
||
!Number.isInteger(priority) ||
|
||
priority < 1 ||
|
||
priority > 5
|
||
)
|
||
return invalid('Enter a name and a valid estimated cost.');
|
||
const values = { name, estimatedCents, notes, priority };
|
||
const id = recordId(form);
|
||
if (id) {
|
||
const [row] = await db
|
||
.update(moneyWishlist)
|
||
.set(values)
|
||
.where(and(eq(moneyWishlist.id, id), eq(moneyWishlist.userId, user.id)))
|
||
.returning({ id: moneyWishlist.id });
|
||
if (!row) error(404, 'Wish list item not found');
|
||
} else await db.insert(moneyWishlist).values({ ...values, userId: user.id });
|
||
return { saved: true };
|
||
},
|
||
deleteWishlist: async (event) => {
|
||
const user = requireAdmin(event);
|
||
const id = recordId(await event.request.formData());
|
||
if (!id) return invalid('Invalid wish list item.');
|
||
await db
|
||
.delete(moneyWishlist)
|
||
.where(and(eq(moneyWishlist.id, id), eq(moneyWishlist.userId, user.id)));
|
||
return { saved: true };
|
||
},
|
||
saveInsurance: async (event) => {
|
||
const user = requireAdmin(event);
|
||
const form = await event.request.formData();
|
||
const name = textField(form, 'name', 200);
|
||
const provider = optionalText(form, 'provider', 200);
|
||
const coverage = optionalText(form, 'coverage');
|
||
const premiumCents = cents(form.get('premium'), true);
|
||
const period = cadence(form.get('cadence'));
|
||
if (
|
||
!name ||
|
||
provider === undefined ||
|
||
coverage === undefined ||
|
||
premiumCents === undefined ||
|
||
(premiumCents !== null && premiumCents < 0) ||
|
||
!period
|
||
)
|
||
return invalid('Enter an insurance name and valid premium.');
|
||
const values = { name, provider, coverage, premiumCents, cadence: period };
|
||
const id = recordId(form);
|
||
if (id) {
|
||
const [row] = await db
|
||
.update(moneyInsurances)
|
||
.set(values)
|
||
.where(and(eq(moneyInsurances.id, id), eq(moneyInsurances.userId, user.id)))
|
||
.returning({ id: moneyInsurances.id });
|
||
if (!row) error(404, 'Insurance not found');
|
||
} else await db.insert(moneyInsurances).values({ ...values, userId: user.id });
|
||
return { saved: true };
|
||
},
|
||
deleteInsurance: async (event) => {
|
||
const user = requireAdmin(event);
|
||
const id = recordId(await event.request.formData());
|
||
if (!id) return invalid('Invalid insurance.');
|
||
await db
|
||
.delete(moneyInsurances)
|
||
.where(and(eq(moneyInsurances.id, id), eq(moneyInsurances.userId, user.id)));
|
||
return { saved: true };
|
||
},
|
||
importTransactions: async (event) => {
|
||
const user = requireAdmin(event);
|
||
const form = await event.request.formData();
|
||
const file = form.get('file');
|
||
if (!(file instanceof File) || !file.size || file.size > 2_000_000)
|
||
return invalid('Choose a CSV or TSV file under 2 MB.');
|
||
const chosenId = positiveId(form.get('accountId'));
|
||
const accounts = await db.select().from(moneyAccounts).where(eq(moneyAccounts.userId, user.id));
|
||
const chosen = chosenId ? accounts.find((account) => account.id === chosenId) : undefined;
|
||
if (chosenId && !chosen) return invalid('Choose an account.');
|
||
let parsed: ImportedTransaction[];
|
||
try {
|
||
parsed = parseTransactionImport(await file.text(), chosen?.name);
|
||
} catch (cause) {
|
||
return invalid(cause instanceof Error ? cause.message : 'Invalid CSV.');
|
||
}
|
||
const result = await db.transaction(async (tx) => {
|
||
const ids = new Map(accounts.map((account) => [account.name.toLowerCase(), account.id]));
|
||
for (const name of [...new Set(parsed.map((row) => row.account))]) {
|
||
if (ids.has(name.toLowerCase())) continue;
|
||
const [account] = await tx
|
||
.insert(moneyAccounts)
|
||
.values({ userId: user.id, name })
|
||
.returning({ id: moneyAccounts.id });
|
||
ids.set(name.toLowerCase(), account.id);
|
||
}
|
||
const rows = parsed.map((row) => ({
|
||
...row,
|
||
accountId: ids.get(row.account.toLowerCase())!
|
||
}));
|
||
const accountIds = [...new Set(rows.map((row) => row.accountId))];
|
||
const existing = await tx
|
||
.select({
|
||
id: moneyTransactions.id,
|
||
accountId: moneyTransactions.accountId,
|
||
date: moneyTransactions.date,
|
||
amountCents: moneyTransactions.amountCents,
|
||
externalId: moneyTransactions.externalId
|
||
})
|
||
.from(moneyTransactions)
|
||
.where(
|
||
and(
|
||
eq(moneyTransactions.userId, user.id),
|
||
inArray(moneyTransactions.accountId, accountIds),
|
||
gte(moneyTransactions.date, addDays(rows[0].date, -1))
|
||
)
|
||
);
|
||
const { insert, duplicates } = planImport(rows, existing);
|
||
for (let i = 0; i < insert.length; i += 500) {
|
||
await tx
|
||
.insert(moneyTransactions)
|
||
.values(
|
||
insert.slice(i, i + 500).map((row) => ({
|
||
userId: user.id,
|
||
accountId: row.accountId,
|
||
date: row.date,
|
||
description: row.description,
|
||
amountCents: row.amountCents,
|
||
externalId: row.externalId,
|
||
source: 'csv'
|
||
}))
|
||
)
|
||
.onConflictDoNothing();
|
||
}
|
||
return { imported: insert.length, duplicates };
|
||
});
|
||
return result;
|
||
}
|
||
};
|
||
|
||
function addDays(date: string, days: number) {
|
||
return new Date(Date.parse(date + 'T00:00:00Z') + days * 86_400_000).toISOString().slice(0, 10);
|
||
}
|