Å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.
406 lines
14 KiB
TypeScript
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
|
|
}
|