@@ -116,10 +123,13 @@ function DrillDownRow({
{new Date(t.transaction_date).toLocaleDateString("en-AU", { day: "2-digit", month: "short" })}
| {t.merchant_name || t.description} |
+
+ {fmtExact(grossAmt)}
+ |
{fmtTx(effectiveAmt, t.transaction_type)}
{sharePct < 100 && (
- {fmtExact(t.amount)}
+ ({sharePct}%)
)}
|
diff --git a/src/app/statements/page.tsx b/src/app/statements/page.tsx
index 414654d..73fc0bb 100644
--- a/src/app/statements/page.tsx
+++ b/src/app/statements/page.tsx
@@ -222,6 +222,19 @@ export default function StatementsPage() {
|
{s.transaction_count}
+ {/* Balance assertion: flags statements whose transactions
+ don't add up to the closing balance. */}
+ {s.balance_diff !== null && s.balance_diff !== undefined &&
+ Math.abs(Number(s.balance_diff)) >= 0.02 && (
+
+ ⚠ {formatAmount(Math.abs(Number(s.balance_diff)))} off
+
+ )}
|
{participants?.length ? (
diff --git a/src/lib/analytics-sql.ts b/src/lib/analytics-sql.ts
index fbe86e3..04348b3 100644
--- a/src/lib/analytics-sql.ts
+++ b/src/lib/analytics-sql.ts
@@ -72,8 +72,28 @@ export const mySplitOf = (base: string, participant = "$1") =>
`((${base}) * ${myShare(participant)} / 100)`;
/**
- * Predicate excluding money-movement categories.
+ * Predicate excluding categories that are not spend.
* The COALESCE matters: a bare `category NOT IN (...)` evaluates to NULL for
* uncategorised rows, which silently drops them from spend totals.
*/
-export const EXCLUDE_NON_SPEND = `${EFFECTIVE_CATEGORY} NOT IN ('transfers', 'investment')`;
+export const EXCLUDE_NON_SPEND = `${EFFECTIVE_CATEGORY} NOT IN ('transfers', 'investment', 'income')`;
+
+/**
+ * Rows that count towards NET spend — outgoings plus the refunds that cancel
+ * them. Pair with SPEND_SIGNED, which carries the direction.
+ */
+export const NET_SPEND_ROWS = `(${SPEND_ROWS} OR t.transaction_type IN ('refund', 'credit'))`;
+
+/**
+ * SPEND_BASE, signed: refunds and credits come back as negatives so they cancel
+ * the original purchase.
+ *
+ * Without this a refund is counted nowhere. It is excluded from spend by type
+ * and only counted as income if categorised 'income', which a refund is not —
+ * so it falls through both and never reduces anything. A $2,888.92 Expedia
+ * purchase refunded in full eight days later still read as $2,888.92 of spend.
+ */
+export const SPEND_SIGNED = `CASE
+ WHEN t.transaction_type IN ('refund', 'credit') THEN -(${SPEND_BASE})
+ ELSE (${SPEND_BASE})
+END`;
diff --git a/src/lib/queries.ts b/src/lib/queries.ts
index d477094..a560147 100644
--- a/src/lib/queries.ts
+++ b/src/lib/queries.ts
@@ -32,6 +32,9 @@ export interface TransactionRow {
my_share_percent: number | null;
effective_category: string;
effective_merchant: string;
+ // My share of this transaction, resolved server-side so the UI matches analytics.
+ my_share_pct: number;
+ my_amount: number;
// statement context (null for manual transactions)
bank_name: string;
// Native currency of the statement this row came from ('AUD' for manual rows).
@@ -81,6 +84,10 @@ export interface StatementRow {
owner_name: string;
created_at: string;
transaction_count: number;
+ // Balance assertion (see BALANCE_DELTA). Null when the statement has no
+ // opening/closing balance to check against.
+ expected_closing: number | null;
+ balance_diff: number | null;
}
interface TransactionFilters {
@@ -202,6 +209,24 @@ export async function getTransactions(ownerId: number, filters: TransactionFilte
COALESCE(o.merchant_normalized, t.merchant_normalized, t.merchant_name) as effective_merchant,
COALESCE(s.bank_name, 'Manual') as bank_name,
COALESCE(s.currency, 'AUD') as currency,
+ -- My share, resolved the same way analytics does it (see myShare in
+ -- analytics-sql.ts): explicit split row, then override, then whatever is
+ -- left after everyone else. Computed here so the UI cannot drift from
+ -- the totals it is drilling into.
+ COALESCE(
+ (SELECT x.share_percent FROM transaction_splits x
+ WHERE x.transaction_id = t.id AND x.participant_id = $1),
+ o.my_share_percent,
+ 100 - COALESCE((SELECT SUM(x.share_percent) FROM transaction_splits x
+ WHERE x.transaction_id = t.id AND x.participant_id <> $1), 0)
+ )::numeric(5,2) as my_share_pct,
+ (COALESCE(t.amount_aud, t.amount) * COALESCE(
+ (SELECT x.share_percent FROM transaction_splits x
+ WHERE x.transaction_id = t.id AND x.participant_id = $1),
+ o.my_share_percent,
+ 100 - COALESCE((SELECT SUM(x.share_percent) FROM transaction_splits x
+ WHERE x.transaction_id = t.id AND x.participant_id <> $1), 0)
+ ) / 100)::numeric(12,2) as my_amount,
COALESCE(t.owner_id, s.owner_id) as owner_id,
p.name as owner_name,
COALESCE(src.created_at, t.created_at) as created_at,
@@ -279,13 +304,43 @@ export async function getTransactionById(id: number) {
return rows[0] || null;
}
+/**
+ * Does opening_balance + the period's transactions equal closing_balance?
+ *
+ * The single cheapest check on extraction quality: it catches missed rows,
+ * duplicates, sign errors and transactions filed against the wrong statement,
+ * none of which are visible by eye. Borrowed from double-entry accounting,
+ * where it is called a balance assertion.
+ *
+ * Sign depends on what the balance means. On a liability (credit card, loan)
+ * the balance is what you OWE, so spending increases it and payments reduce it.
+ * On an asset (transaction, savings, offset) the balance is what you HOLD, so
+ * the signs invert.
+ */
+export const BALANCE_DELTA = `SUM(CASE
+ WHEN s.statement_type IN ('credit_card', 'loan')
+ THEN CASE WHEN t.transaction_type IN ('debit', 'fee', 'interest') THEN t.amount ELSE -t.amount END
+ ELSE CASE WHEN t.transaction_type IN ('debit', 'fee', 'interest') THEN -t.amount ELSE t.amount END
+END)`;
+
export async function getStatements(ownerId: number) {
const sql = `
SELECT s.*,
(SELECT COUNT(*)::int FROM transactions t WHERE t.statement_id = s.id) as transaction_count,
- p.name as owner_name
+ p.name as owner_name,
+ recon.expected_closing,
+ recon.balance_diff
FROM statements s
LEFT JOIN participants p ON p.id = s.owner_id
+ LEFT JOIN LATERAL (
+ SELECT
+ (s.opening_balance + ${BALANCE_DELTA})::numeric(12,2) as expected_closing,
+ (s.opening_balance + ${BALANCE_DELTA} - s.closing_balance)::numeric(12,2) as balance_diff
+ FROM transactions t
+ WHERE t.statement_id = s.id
+ AND s.opening_balance IS NOT NULL
+ AND s.closing_balance IS NOT NULL
+ ) recon ON true
WHERE s.owner_id = $1
ORDER BY s.billing_end_date DESC NULLS LAST, s.created_at DESC
`;
|