Files
accounted/lib/import/opening-balance/cascade.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

406 lines
14 KiB
TypeScript

import type { SupabaseClient } from '@supabase/supabase-js'
import type { Logger } from '@/lib/logger'
import type { CreateJournalEntryLineInput } from '@/types'
import { roundOre } from '@/lib/money'
import { replaceOpeningBalanceEntry } from '@/lib/bookkeeping/engine'
import { fetchEntryLines, type EntryLinesQuery } from '@/lib/bookkeeping/entry-lines'
import {
validateOpeningBalanceLines,
type OpeningBalanceLine,
} from './execute-helpers'
/**
* Cascade an opening-balance correction to subsequent fiscal years.
*
* Fortnox/SIE-migrated companies get one IB verifikat per imported year, each
* linked via fiscal_periods.opening_balance_entry_id. Correcting one year's IB
* therefore leaves every later year's linked IB verifikat carrying the stale
* figures. This module applies the same per-account delta (corrected minus
* original) to each subsequent period's IB the BFL-compliant way, via the
* atomic replaceOpeningBalanceEntry engine primitive (one DB transaction owns
* the storno, the corrected voucher, and the period pointer swap, with a CAS
* on the expected old entry id), so a failure leaves the period untouched.
*
* The corrected verifikat keeps the original lines verbatim (descriptions and
* dimensions included) and appends one adjustment line per changed account,
* so years the user never opened stay reviewable line by line.
*
* Periods that cannot be touched (closed, locked, behind the company lock
* date, or with a posted bokslut on top) are skipped and reported, never
* forced: the DB triggers enforcing those states are legally required.
*/
/** Net per-account change of a correction: (new debit-credit) minus (old debit-credit). */
export type AccountDeltas = Map<string, number>
/** An existing IB line with the fields the rebooked verifikat must preserve. */
export interface CascadeSourceLine extends OpeningBalanceLine {
line_description: string | null
dimensions: Record<string, string> | null
}
export interface CascadeCorrectedPeriod {
fiscal_period_id: string
period_name: string | null
journal_entry_id: string
/** Storno mode: the replaced entry. Inline mode: null (same verifikat edited in place). */
reversed_entry_id: string | null
}
export type CascadeSkipReason =
| 'closed'
| 'locked'
| 'lock_date'
| 'year_end'
| 'no_opening_balance'
| 'validation_failed'
| 'correction_failed'
export interface CascadeSkippedPeriod {
fiscal_period_id: string
period_name: string | null
reason: CascadeSkipReason
}
export interface CascadeResult {
corrected: CascadeCorrectedPeriod[]
skipped: CascadeSkippedPeriod[]
/**
* Set by the ROUTES when the cascade itself blew up before/while running
* (log fetch failed, unexpected throw): the base correction stands, no
* later year was verified, and the client must tell the user to check.
*/
failed?: boolean
}
/**
* Per-account net deltas between the original IB lines and the corrected
* lines. Accounts whose net balance did not change are omitted, so an empty
* map means "nothing to cascade".
*/
export function computeAccountDeltas(
oldLines: OpeningBalanceLine[],
newLines: OpeningBalanceLine[],
): AccountDeltas {
const nets = new Map<string, { oldNet: number; newNet: number }>()
for (const line of oldLines) {
const slot = nets.get(line.account_number) ?? { oldNet: 0, newNet: 0 }
slot.oldNet = roundOre(slot.oldNet + (line.debit_amount - line.credit_amount))
nets.set(line.account_number, slot)
}
for (const line of newLines) {
const slot = nets.get(line.account_number) ?? { oldNet: 0, newNet: 0 }
slot.newNet = roundOre(slot.newNet + (line.debit_amount - line.credit_amount))
nets.set(line.account_number, slot)
}
const deltas: AccountDeltas = new Map()
for (const [account, { oldNet, newNet }] of nets) {
const delta = roundOre(newNet - oldNet)
if (Math.abs(delta) >= 0.01) deltas.set(account, delta)
}
return deltas
}
/**
* Build the corrected line set for a subsequent period: the existing lines
* verbatim (keeping description and dimensions), plus one labelled adjustment
* line per delta account. Both the existing entry and the delta set balance
* (deltas come from two balanced entries), so the result balances too.
*/
export function buildCascadedLines(
existingLines: CascadeSourceLine[],
deltas: AccountDeltas,
): CreateJournalEntryLineInput[] {
const kept: CreateJournalEntryLineInput[] = existingLines
.filter((l) => l.debit_amount > 0 || l.credit_amount > 0)
.map((l) => ({
account_number: l.account_number,
debit_amount: l.debit_amount,
credit_amount: l.credit_amount,
line_description: l.line_description ?? undefined,
dimensions: l.dimensions ?? undefined,
}))
return [...kept, ...buildAdjustmentLines(deltas)]
}
/** One labelled adjustment line per delta account, sorted; balances to zero. */
export function buildAdjustmentLines(deltas: AccountDeltas): CreateJournalEntryLineInput[] {
return [...deltas.entries()]
.sort(([a], [b]) => a.localeCompare(b))
.map(([account_number, delta]) => ({
account_number,
debit_amount: delta > 0 ? delta : 0,
credit_amount: delta < 0 ? roundOre(-delta) : 0,
line_description: `IB-rättelse ${account_number}`,
}))
}
/** Fetch an entry's lines with the fields a cascaded rebook must preserve. */
export async function fetchEntryOpeningBalanceLines(
supabase: SupabaseClient,
companyId: string,
entryId: string,
): Promise<CascadeSourceLine[]> {
// Two-step entry-lines fetch: verifies company_id ownership on the entry
// side (defense in depth alongside RLS) and paginates. Same pattern as
// lib/reports/opening-balances.ts.
const rows = await fetchEntryLines<{
id: string
account_number: string
debit_amount: number | string
credit_amount: number | string
line_description: string | null
dimensions: Record<string, string> | null
}>({
supabase,
lineColumns: 'id, account_number, debit_amount, credit_amount, line_description, dimensions',
filterEntries: (q: EntryLinesQuery) => q.eq('id', entryId).eq('company_id', companyId),
attachEntriesAs: null,
})
return rows.map((r) => ({
account_number: r.account_number,
debit_amount: Number(r.debit_amount) || 0,
credit_amount: Number(r.credit_amount) || 0,
line_description: r.line_description ?? null,
dimensions: r.dimensions ?? null,
}))
}
interface SubsequentPeriodRow {
id: string
name: string | null
period_start: string
is_closed: boolean
locked_at: string | null
opening_balance_entry_id: string | null
opening_balance_entry: {
voucher_series: string | null
voucher_number: number | null
} | null
}
export interface CascadeOptions {
/** period_start of the period whose IB was just corrected. */
basePeriodStart: string
/** Per-account net deltas from the base correction. */
deltas: AccountDeltas
/** company_settings.bookkeeping_locked_through, already fetched by the caller. */
lockDate: string | null
/**
* How each later year's IB is corrected:
* - 'storno' (default): atomic replaceOpeningBalanceEntry (storno + rebook
* + pointer swap), used by the storno-based /correct route.
* - 'inline': append the labelled adjustment lines inside the SAME
* verifikat via correct_entry_lines_inline (BFL 5 kap 5 § track 2): no
* new verifikat at all. Used by the /correct-inline route.
*/
mode?: 'storno' | 'inline'
log: Logger
}
/**
* Replace each subsequent period's IB with the deltas applied, one atomic
* engine replacement per period. Each period is independent: a failure is
* reported as skipped (the RPC transaction leaves that period untouched) and
* the cascade continues with the next year.
*/
export async function cascadeOpeningBalanceCorrection(
supabase: SupabaseClient,
companyId: string,
userId: string,
options: CascadeOptions,
): Promise<CascadeResult> {
const { basePeriodStart, deltas, lockDate, log } = options
const mode = options.mode ?? 'storno'
const result: CascadeResult = { corrected: [], skipped: [] }
if (deltas.size === 0) return result
const { data: periods, error: periodsError } = await supabase
.from('fiscal_periods')
.select(
'id, name, period_start, is_closed, locked_at, opening_balance_entry_id, opening_balance_entry:journal_entries!opening_balance_entry_id(voucher_series, voucher_number)',
)
.eq('company_id', companyId)
.gt('period_start', basePeriodStart)
.order('period_start', { ascending: true })
if (periodsError) {
// The base correction already succeeded; surface the cascade as fully
// skipped rather than failing the request.
log.error('opening balance cascade: could not list subsequent periods', {
audit: true,
event: 'opening_balance.cascade_list_failed',
companyId,
reason: periodsError.message,
})
return result
}
for (const period of (periods ?? []) as unknown as SubsequentPeriodRow[]) {
const skip = (reason: CascadeSkipReason) => {
result.skipped.push({
fiscal_period_id: period.id,
period_name: period.name,
reason,
})
}
const auditFailure = (fields: Record<string, unknown>) => {
log.error('audit: opening balance cascade correction failed', {
audit: true,
event: 'opening_balance.cascade_period_failed',
companyId,
userId,
fiscalPeriodId: period.id,
oldEntryId: period.opening_balance_entry_id,
...fields,
})
}
if (!period.opening_balance_entry_id) {
// No linked IB verifikat: reports fall back to computing prior balances,
// which already reflect the base correction. Reported for transparency.
skip('no_opening_balance')
continue
}
if (period.is_closed) {
skip('closed')
continue
}
if (period.locked_at) {
skip('locked')
continue
}
if (lockDate && period.period_start <= lockDate) {
skip('lock_date')
continue
}
// Fail CLOSED: a failed lookup must not read as "no bokslut", or the
// cascade would rewrite the IB of a period with a posted year-end.
const { count: yearEndCount, error: yearEndError } = await supabase
.from('journal_entries')
.select('id', { count: 'exact', head: true })
.eq('company_id', companyId)
.eq('fiscal_period_id', period.id)
.eq('source_type', 'year_end')
.eq('status', 'posted')
if (yearEndError) {
auditFailure({ phase: 'year_end_check_failed', reason: yearEndError.message })
skip('correction_failed')
continue
}
if ((yearEndCount ?? 0) > 0) {
skip('year_end')
continue
}
const oldEntryId = period.opening_balance_entry_id
if (mode === 'inline') {
// Append the labelled adjustment lines inside the SAME verifikat: no
// storno, no new verifikat. The RPC transaction enforces the whole
// envelope (posted, current linked IB, no bokslut, class 1-2, balance
// to the öre, rättelse log) and rolls the period back on any failure.
const { error: inlineError } = await supabase.rpc('correct_entry_lines_inline', {
p_company_id: companyId,
p_entry_id: oldEntryId,
p_strike_line_ids: [],
p_new_lines: buildAdjustmentLines(deltas).map((l) => ({
account_number: l.account_number,
debit_amount: l.debit_amount,
credit_amount: l.credit_amount,
line_description: l.line_description ?? null,
dimensions: {},
})),
p_user_id: userId,
})
if (inlineError) {
auditFailure({ phase: 'inline_rattelse_failed', reason: inlineError.message })
skip('correction_failed')
continue
}
result.corrected.push({
fiscal_period_id: period.id,
period_name: period.name,
journal_entry_id: oldEntryId,
reversed_entry_id: null,
})
continue
}
let lines: CreateJournalEntryLineInput[]
try {
const existingLines = await fetchEntryOpeningBalanceLines(supabase, companyId, oldEntryId)
lines = buildCascadedLines(existingLines, deltas)
} catch (err) {
auditFailure({
phase: 'line_fetch_failed',
reason: err instanceof Error ? err.message : 'unknown',
})
skip('correction_failed')
continue
}
const validation = validateOpeningBalanceLines(
lines.map((l) => ({
account_number: l.account_number,
debit_amount: l.debit_amount,
credit_amount: l.credit_amount,
})),
)
if (!validation.ok) {
skip('validation_failed')
continue
}
// BFL 5 kap 5§: reference the verifikat being rättat, same convention as
// the base correction.
const voucherLabel =
period.opening_balance_entry?.voucher_series && period.opening_balance_entry?.voucher_number
? `${period.opening_balance_entry.voucher_series}${period.opening_balance_entry.voucher_number}`
: null
const description = voucherLabel
? `Ingående balanser (korrigerade, rättelse av ${voucherLabel})`
: 'Ingående balanser (korrigerade)'
// One RPC transaction: storno the old IB, commit the corrected one, swap
// fiscal_periods.opening_balance_entry_id, CAS-guarded on oldEntryId. Any
// failure (including a period locked between our pre-check and the write)
// rolls the whole period back: no compensation pass, no half states.
try {
const replacement = await replaceOpeningBalanceEntry(supabase, companyId, userId, oldEntryId, {
fiscal_period_id: period.id,
entry_date: period.period_start,
description,
source_type: 'opening_balance',
voucher_series: 'A',
lines,
})
result.corrected.push({
fiscal_period_id: period.id,
period_name: period.name,
journal_entry_id: replacement.newEntryId,
reversed_entry_id: oldEntryId,
})
} catch (err) {
auditFailure({
phase: 'replacement_failed',
reason: err instanceof Error ? err.message : 'unknown',
})
skip('correction_failed')
}
}
return result
}