Files
accounted/lib/invoices/invoice-payee.ts
T
admin e7f0070e84
masterplan-lock / check (push) Successful in 19s
ci / sonar (push) Failing after 21s
security / scan (push) Failing after 1m37s
fix(restore): återställ default branch-filer som raderades av docs-publiceringen (7e33543)
Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i
server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma
strängvärde byggs med konkatenering i stället för att matcha mönstret.
2026-11-10 09:37:22 +01:00

179 lines
7.3 KiB
TypeScript

import type { SupabaseClient } from '@supabase/supabase-js'
import type { CashAccount, Currency, Invoice, InvoicePaymentAccount } from '@/types'
import { cashAccountPayee, isBankCashAccount, isUsableInvoicePayee } from '@/lib/cash-accounts/invoice-payee'
import { invoiceRequiresPaymentAccount } from '@/lib/invoices/payment-accounts'
import { ACCOUNT_NUMBER_RE } from '@/lib/invariants'
import { createLogger } from '@/lib/logger'
const log = createLogger('invoices/payee')
export type InvoicePayeeFields = {
payment_cash_account_id: string | null
payment_details: InvoicePaymentAccount | null
}
export type InvoicePayeeChoiceResult =
| { ok: true; fields: InvoicePayeeFields }
| { ok: false; code: 'INVOICE_PAYEE_ACCOUNT_INVALID'; details: Record<string, unknown> }
async function loadPayeeAccount(
supabase: SupabaseClient,
companyId: string,
cashAccountId: string,
): Promise<CashAccount | null> {
const { data, error } = await supabase
.from('cash_accounts')
.select('*')
.eq('company_id', companyId)
.eq('id', cashAccountId)
.maybeSingle()
if (error) throw new Error(`cash_accounts lookup failed: ${error.message}`)
return (data as CashAccount | null) ?? null
}
/**
* Validate a draft's choice of payee account and freeze its payee fields.
* Used by every invoice create/update path (dashboard, v1, MCP) so the rule
* cannot drift: the account must be the company's, flagged as a payee, and
* usable for the invoice currency (an IBAN for anything but SEK).
*
* null/undefined = no choice: both columns are cleared and the invoice
* resolves the company's default for its currency at render time.
*/
export async function resolveInvoicePayeeChoice(
supabase: SupabaseClient,
companyId: string,
currency: Currency,
cashAccountId: string | null | undefined,
): Promise<InvoicePayeeChoiceResult> {
if (!cashAccountId) {
return { ok: true, fields: { payment_cash_account_id: null, payment_details: null } }
}
const account = await loadPayeeAccount(supabase, companyId, cashAccountId)
if (!account || !isBankCashAccount(account) || !isUsableInvoicePayee(account, currency)) {
return {
ok: false,
code: 'INVOICE_PAYEE_ACCOUNT_INVALID',
details: {
cash_account_id: cashAccountId,
currency,
reason: !account ? 'not_found' : !isBankCashAccount(account) ? 'not_bank_account' : !account.enabled ? 'disabled' : !account.invoice_payee ? 'not_payee' : 'unusable_for_currency',
},
}
}
return {
ok: true,
fields: { payment_cash_account_id: account.id, payment_details: cashAccountPayee(account) },
}
}
export type InvoicePayeeSnapshotResult =
| { ok: true; payee: InvoicePaymentAccount | null }
| { ok: false; code: 'INVOICE_SEND_PAYMENT_ACCOUNT_INVALID' | 'INVOICE_PAYEE_SNAPSHOT_FAILED'; details: Record<string, unknown> }
export interface SnapshotInvoicePayeeOptions {
/** false = validate and return the payee without writing (dry runs). */
persist?: boolean
}
/**
* At issue (send, mark-sent, Peppol, recurring): refresh the frozen payee of
* an invoice that chose a bank account from the account as it is now, and
* persist it. From here on the invoice prints these fields whatever happens
* to the account. An account that can no longer be used blocks issue with a
* specific error instead of silently printing the company default.
*
* Invoices without a chosen account are left alone (payee null): they keep
* resolving the per-currency default exactly as before this feature.
*/
export async function snapshotInvoicePayee(
supabase: SupabaseClient,
companyId: string,
invoice: Pick<Invoice, 'id' | 'currency'>
& Partial<Pick<Invoice, 'payment_cash_account_id' | 'payment_details' | 'document_type' | 'credited_invoice_id'>>,
opts: SnapshotInvoicePayeeOptions = {},
): Promise<InvoicePayeeSnapshotResult> {
const cashAccountId = invoice.payment_cash_account_id ?? null
if (!cashAccountId) return { ok: true, payee: invoice.payment_details ?? null }
// Credit notes, proformas, delivery notes and quotes print no payee: a
// stale account on them must not block issue.
if (!invoiceRequiresPaymentAccount({
credited_invoice_id: invoice.credited_invoice_id ?? null,
document_type: invoice.document_type ?? 'invoice',
})) {
return { ok: true, payee: invoice.payment_details ?? null }
}
const account = await loadPayeeAccount(supabase, companyId, cashAccountId)
if (!account || !isBankCashAccount(account) || !isUsableInvoicePayee(account, invoice.currency)) {
return {
ok: false,
code: 'INVOICE_SEND_PAYMENT_ACCOUNT_INVALID',
details: { cash_account_id: cashAccountId, currency: invoice.currency },
}
}
const payee = cashAccountPayee(account)
const current = invoice.payment_details ?? null
if (opts.persist !== false && JSON.stringify(current) !== JSON.stringify(payee)) {
const { error } = await supabase
.from('invoices')
.update({ payment_details: payee })
.eq('id', invoice.id)
.eq('company_id', companyId)
if (error) {
// Issue must not continue: the document would print a payee the row
// does not carry, and a later re-render would disagree with it.
log.error('invoice payee snapshot write failed', { invoiceId: invoice.id, error: error.message })
return {
ok: false,
code: 'INVOICE_PAYEE_SNAPSHOT_FAILED',
details: { cash_account_id: cashAccountId, invoice_id: invoice.id, pgMessage: error.message },
}
}
}
return { ok: true, payee }
}
/**
* The BAS account a manual "mark as paid" debits: the chosen payee account's
* ledger account (1930, 1931, ...) when the invoice chose one and the row
* still exists, else the 1930 default the generators have always used.
* Bank-transaction matches never come here: they debit the account the
* money actually landed on (resolveSettlementAccount on the transaction).
*/
export async function resolveInvoiceSettlementAccount(
supabase: SupabaseClient,
companyId: string,
invoice: Partial<Pick<Invoice, 'payment_cash_account_id'>>,
): Promise<string> {
const cashAccountId = invoice.payment_cash_account_id ?? null
if (!cashAccountId) return '1930'
const { data, error } = await supabase
.from('cash_accounts')
.select('ledger_account, enabled')
.eq('company_id', companyId)
.eq('id', cashAccountId)
.maybeSingle()
if (error) {
log.warn('settlement account lookup failed; defaulting to 1930', { cashAccountId, error: error.message })
return '1930'
}
const row = data as { ledger_account?: string; enabled?: boolean } | null
const ledger = row?.ledger_account
// Only a live bank account (19xx) may take the debit: a PSP clearing
// account (1686, 1680, 1584) cleared later by a payout must never receive
// a bank transfer, and a disabled or deleted account is not where money
// lands any more. Both fall back to 1930, and say so: the printed invoice
// named another account, so the bookkeeper must know.
if (!row || !ledger || !ACCOUNT_NUMBER_RE.test(ledger) || !isBankCashAccount({ ledger_account: ledger }) || row.enabled === false) {
log.warn('chosen payee account is not a live bank account; debiting 1930 instead', {
cashAccountId,
ledger: ledger ?? null,
enabled: row?.enabled ?? null,
found: Boolean(row),
})
return '1930'
}
return ledger
}