Å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.
179 lines
7.3 KiB
TypeScript
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
|
|
}
|