349 lines
11 KiB
TypeScript
349 lines
11 KiB
TypeScript
import { db } from '$lib/server/db/index.js';
|
|
import {
|
|
companyAccounts,
|
|
companyAccountTransactions,
|
|
expenses,
|
|
invoices,
|
|
externalTransactions
|
|
} from '$lib/server/db/schema.js';
|
|
import { and, eq, sql } from 'drizzle-orm';
|
|
|
|
/**
|
|
* Drizzle's tx inside db.transaction() has the same methods as db.
|
|
* Use `any` to avoid importing the internal PgTransaction generic type.
|
|
*/
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
type Dbx = typeof db | any;
|
|
|
|
export type CompanyAccountTxnType =
|
|
| 'opening_balance'
|
|
| 'expense'
|
|
| 'invoice_payment'
|
|
| 'transfer_in'
|
|
| 'transfer_out'
|
|
| 'deposit'
|
|
| 'adjustment'
|
|
| 'reconciliation';
|
|
|
|
export interface PostTxnInput {
|
|
accountId: string;
|
|
companyId: string;
|
|
type: CompanyAccountTxnType;
|
|
amount: string | number; // signed decimal; positive = credit, negative = debit
|
|
currency: string;
|
|
occurredAt: Date;
|
|
description?: string | null;
|
|
reference?: string | null;
|
|
counterpartyAccountId?: string | null;
|
|
sourceExpenseId?: string | null;
|
|
sourceInvoiceId?: string | null;
|
|
sourceExternalTransactionId?: string | null;
|
|
fxRate?: string | number | null;
|
|
fxAmount?: string | number | null;
|
|
createdBy?: string | null;
|
|
}
|
|
|
|
function toDecimalString(v: string | number | null | undefined): string | null {
|
|
if (v === null || v === undefined) return null;
|
|
return typeof v === 'number' ? v.toString() : v;
|
|
}
|
|
|
|
export async function postTransaction(dbx: Dbx, input: PostTxnInput): Promise<{ id: string }> {
|
|
const amountStr = toDecimalString(input.amount);
|
|
if (amountStr === null) throw new Error('postTransaction: amount is required');
|
|
|
|
const [row] = await dbx
|
|
.insert(companyAccountTransactions)
|
|
.values({
|
|
accountId: input.accountId,
|
|
companyId: input.companyId,
|
|
type: input.type,
|
|
amount: amountStr,
|
|
currency: input.currency,
|
|
occurredAt: input.occurredAt,
|
|
description: input.description ?? null,
|
|
reference: input.reference ?? null,
|
|
counterpartyAccountId: input.counterpartyAccountId ?? null,
|
|
sourceExpenseId: input.sourceExpenseId ?? null,
|
|
sourceInvoiceId: input.sourceInvoiceId ?? null,
|
|
sourceExternalTransactionId: input.sourceExternalTransactionId ?? null,
|
|
fxRate: toDecimalString(input.fxRate),
|
|
fxAmount: toDecimalString(input.fxAmount),
|
|
createdBy: input.createdBy ?? null
|
|
})
|
|
.returning({ id: companyAccountTransactions.id });
|
|
return row;
|
|
}
|
|
|
|
export interface PostTransferInput {
|
|
fromAccountId: string;
|
|
toAccountId: string;
|
|
companyId: string;
|
|
amount: string | number; // always positive — the sending side (debit)
|
|
occurredAt: Date;
|
|
description?: string | null;
|
|
reference?: string | null;
|
|
/** Cross-currency: set exactly one of fxRate OR destinationAmount. */
|
|
fxRate?: string | number | null;
|
|
destinationAmount?: string | number | null;
|
|
createdBy?: string | null;
|
|
}
|
|
|
|
export async function postTransfer(
|
|
input: PostTransferInput
|
|
): Promise<{ fromTxnId: string; toTxnId: string }> {
|
|
if (input.fromAccountId === input.toAccountId) {
|
|
throw new Error('postTransfer: fromAccountId and toAccountId must differ');
|
|
}
|
|
const absAmount = Number(input.amount);
|
|
if (!Number.isFinite(absAmount) || absAmount <= 0) {
|
|
throw new Error('postTransfer: amount must be a positive number');
|
|
}
|
|
|
|
return await db.transaction(async (tx: Dbx) => {
|
|
const accts = await tx
|
|
.select({
|
|
id: companyAccounts.id,
|
|
companyId: companyAccounts.companyId,
|
|
currency: companyAccounts.currency
|
|
})
|
|
.from(companyAccounts)
|
|
.where(
|
|
sql`${companyAccounts.id} IN (${input.fromAccountId}, ${input.toAccountId}) AND ${companyAccounts.companyId} = ${input.companyId} AND ${companyAccounts.deletedAt} IS NULL`
|
|
);
|
|
const fromAcct = accts.find((a: { id: string }) => a.id === input.fromAccountId);
|
|
const toAcct = accts.find((a: { id: string }) => a.id === input.toAccountId);
|
|
if (!fromAcct || !toAcct) throw new Error('postTransfer: account not found or mismatched company');
|
|
|
|
const sameCurrency = fromAcct.currency === toAcct.currency;
|
|
let fxRateStr: string | null = null;
|
|
let destAmount: number;
|
|
|
|
if (sameCurrency) {
|
|
destAmount = absAmount;
|
|
} else if (input.destinationAmount != null && input.destinationAmount !== '') {
|
|
destAmount = Number(input.destinationAmount);
|
|
if (!Number.isFinite(destAmount) || destAmount <= 0) {
|
|
throw new Error('postTransfer: destinationAmount must be positive');
|
|
}
|
|
fxRateStr = (destAmount / absAmount).toFixed(8);
|
|
} else if (input.fxRate != null && input.fxRate !== '') {
|
|
const rate = Number(input.fxRate);
|
|
if (!Number.isFinite(rate) || rate <= 0) {
|
|
throw new Error('postTransfer: fxRate must be positive');
|
|
}
|
|
fxRateStr = rate.toFixed(8);
|
|
destAmount = +(absAmount * rate).toFixed(2);
|
|
} else {
|
|
throw new Error(
|
|
'postTransfer: cross-currency transfer requires fxRate or destinationAmount'
|
|
);
|
|
}
|
|
|
|
const fxAmountStr = sameCurrency ? null : destAmount.toFixed(2);
|
|
|
|
const fromTxn = await postTransaction(tx, {
|
|
accountId: input.fromAccountId,
|
|
companyId: input.companyId,
|
|
type: 'transfer_out',
|
|
amount: (-absAmount).toFixed(2),
|
|
currency: fromAcct.currency,
|
|
occurredAt: input.occurredAt,
|
|
description: input.description ?? null,
|
|
reference: input.reference ?? null,
|
|
counterpartyAccountId: input.toAccountId,
|
|
fxRate: fxRateStr,
|
|
fxAmount: fxAmountStr,
|
|
createdBy: input.createdBy ?? null
|
|
});
|
|
|
|
const toTxn = await postTransaction(tx, {
|
|
accountId: input.toAccountId,
|
|
companyId: input.companyId,
|
|
type: 'transfer_in',
|
|
amount: destAmount.toFixed(2),
|
|
currency: toAcct.currency,
|
|
occurredAt: input.occurredAt,
|
|
description: input.description ?? null,
|
|
reference: input.reference ?? null,
|
|
counterpartyAccountId: input.fromAccountId,
|
|
fxRate: fxRateStr,
|
|
fxAmount: fxAmountStr,
|
|
createdBy: input.createdBy ?? null
|
|
});
|
|
|
|
return { fromTxnId: fromTxn.id, toTxnId: toTxn.id };
|
|
});
|
|
}
|
|
|
|
export async function getBalance(accountId: string): Promise<{ balance: string; currency: string }> {
|
|
const [acct] = await db
|
|
.select({ currency: companyAccounts.currency })
|
|
.from(companyAccounts)
|
|
.where(eq(companyAccounts.id, accountId))
|
|
.limit(1);
|
|
if (!acct) throw new Error(`getBalance: account ${accountId} not found`);
|
|
|
|
const [row] = await db
|
|
.select({
|
|
total: sql<string>`coalesce(sum(${companyAccountTransactions.amount}), '0')::text`
|
|
})
|
|
.from(companyAccountTransactions)
|
|
.where(eq(companyAccountTransactions.accountId, accountId));
|
|
|
|
return { balance: row?.total ?? '0', currency: acct.currency };
|
|
}
|
|
|
|
export async function postExpenseTransaction(
|
|
expenseId: string,
|
|
accountId: string,
|
|
userId: string,
|
|
dbx?: Dbx
|
|
): Promise<void> {
|
|
const dbOrTx = dbx ?? db;
|
|
const [exp] = await dbOrTx
|
|
.select({
|
|
id: expenses.id,
|
|
amount: expenses.amount,
|
|
currency: expenses.currency,
|
|
expenseDate: expenses.expenseDate,
|
|
title: expenses.title
|
|
})
|
|
.from(expenses)
|
|
.where(eq(expenses.id, expenseId))
|
|
.limit(1);
|
|
if (!exp) throw new Error(`postExpenseTransaction: expense ${expenseId} not found`);
|
|
|
|
const [acct] = await dbOrTx
|
|
.select({ companyId: companyAccounts.companyId, currency: companyAccounts.currency })
|
|
.from(companyAccounts)
|
|
.where(eq(companyAccounts.id, accountId))
|
|
.limit(1);
|
|
if (!acct) throw new Error(`postExpenseTransaction: account ${accountId} not found`);
|
|
|
|
// Idempotent: replace any prior post for this expense.
|
|
await dbOrTx
|
|
.delete(companyAccountTransactions)
|
|
.where(eq(companyAccountTransactions.sourceExpenseId, expenseId));
|
|
|
|
await postTransaction(dbOrTx, {
|
|
accountId,
|
|
companyId: acct.companyId,
|
|
type: 'expense',
|
|
amount: (-Number(exp.amount)).toFixed(2),
|
|
currency: exp.currency,
|
|
occurredAt: new Date(exp.expenseDate),
|
|
description: exp.title,
|
|
sourceExpenseId: expenseId,
|
|
createdBy: userId
|
|
});
|
|
}
|
|
|
|
export async function removeExpenseTransaction(expenseId: string, dbx?: Dbx): Promise<void> {
|
|
const dbOrTx = dbx ?? db;
|
|
await dbOrTx
|
|
.delete(companyAccountTransactions)
|
|
.where(eq(companyAccountTransactions.sourceExpenseId, expenseId));
|
|
}
|
|
|
|
export async function postInvoicePaymentTransaction(
|
|
invoiceId: string,
|
|
paymentAccountId: string,
|
|
userId: string,
|
|
dbx?: Dbx
|
|
): Promise<void> {
|
|
const dbOrTx = dbx ?? db;
|
|
const [inv] = await dbOrTx
|
|
.select({
|
|
id: invoices.id,
|
|
total: invoices.total,
|
|
currency: invoices.currency,
|
|
issueDate: invoices.issueDate,
|
|
invoiceNumber: invoices.invoiceNumber
|
|
})
|
|
.from(invoices)
|
|
.where(eq(invoices.id, invoiceId))
|
|
.limit(1);
|
|
if (!inv) throw new Error(`postInvoicePaymentTransaction: invoice ${invoiceId} not found`);
|
|
|
|
const [acct] = await dbOrTx
|
|
.select({ companyId: companyAccounts.companyId, currency: companyAccounts.currency })
|
|
.from(companyAccounts)
|
|
.where(eq(companyAccounts.id, paymentAccountId))
|
|
.limit(1);
|
|
if (!acct) throw new Error(`postInvoicePaymentTransaction: account ${paymentAccountId} not found`);
|
|
|
|
await dbOrTx
|
|
.delete(companyAccountTransactions)
|
|
.where(eq(companyAccountTransactions.sourceInvoiceId, invoiceId));
|
|
|
|
await postTransaction(dbOrTx, {
|
|
accountId: paymentAccountId,
|
|
companyId: acct.companyId,
|
|
type: 'invoice_payment',
|
|
amount: Number(inv.total).toFixed(2),
|
|
currency: inv.currency,
|
|
occurredAt: new Date(inv.issueDate),
|
|
description: `Invoice ${inv.invoiceNumber}`,
|
|
sourceInvoiceId: invoiceId,
|
|
createdBy: userId
|
|
});
|
|
}
|
|
|
|
export async function removeInvoicePaymentTransaction(
|
|
invoiceId: string,
|
|
dbx?: Dbx
|
|
): Promise<void> {
|
|
const dbOrTx = dbx ?? db;
|
|
await dbOrTx
|
|
.delete(companyAccountTransactions)
|
|
.where(eq(companyAccountTransactions.sourceInvoiceId, invoiceId));
|
|
}
|
|
|
|
export async function postReconciliationTransaction(
|
|
externalTransactionId: string,
|
|
accountId: string,
|
|
companyId: string,
|
|
userId: string,
|
|
dbx?: Dbx
|
|
): Promise<void> {
|
|
const dbOrTx = dbx ?? db;
|
|
const [ext] = await dbOrTx
|
|
.select({
|
|
id: externalTransactions.id,
|
|
amount: externalTransactions.amount,
|
|
currency: externalTransactions.currency,
|
|
direction: externalTransactions.direction,
|
|
occurredAt: externalTransactions.occurredAt,
|
|
description: externalTransactions.description,
|
|
counterparty: externalTransactions.counterparty
|
|
})
|
|
.from(externalTransactions)
|
|
.where(
|
|
and(
|
|
eq(externalTransactions.id, externalTransactionId),
|
|
eq(externalTransactions.companyId, companyId)
|
|
)
|
|
)
|
|
.limit(1);
|
|
if (!ext) throw new Error(`postReconciliationTransaction: external txn ${externalTransactionId} not found`);
|
|
|
|
const signedAmount = ext.direction === 'credit' ? Number(ext.amount) : -Number(ext.amount);
|
|
|
|
await dbOrTx
|
|
.delete(companyAccountTransactions)
|
|
.where(eq(companyAccountTransactions.sourceExternalTransactionId, externalTransactionId));
|
|
|
|
await postTransaction(dbOrTx, {
|
|
accountId,
|
|
companyId,
|
|
type: 'reconciliation',
|
|
amount: signedAmount.toFixed(2),
|
|
currency: ext.currency,
|
|
occurredAt: ext.occurredAt,
|
|
description: ext.description ?? ext.counterparty ?? 'Bank reconciliation',
|
|
sourceExternalTransactionId: externalTransactionId,
|
|
createdBy: userId
|
|
});
|
|
}
|