Files
accounted/lib/core/bookkeeping/result-appropriation-service.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

211 lines
8.5 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import type { SupabaseClient } from '@supabase/supabase-js'
import { resolveCompanyEntityType, resultClosingAccounts } from '@/lib/company/entity-type'
import { createJournalEntry } from '@/lib/bookkeeping/engine'
import { getOpeningBalances } from '@/lib/reports/opening-balances'
import { roundOre, ORE_TOLERANCE } from '@/lib/bokslut/rounding'
import { createLogger } from '@/lib/logger'
import type { JournalEntry, CreateJournalEntryLineInput } from '@/types'
const log = createLogger('result-appropriation-service')
/** Årets resultat (current-year result, aktiebolag). */
export const RESULT_ACCOUNT = '2099'
/** Vinst eller förlust från föregående år. */
export const PRIOR_RESULT_ACCOUNT = '2098'
export interface ResultAppropriationPlan {
periodId: string
periodName: string
/** entry_date for the omföring: the new period's first day. */
periodStart: string
/** The form's "årets resultat" account (AB 2099, ideell förening 2069). */
resultAccount: string
/** Where last year's result is carried (AB 2098, ideell förening 2068). */
priorResultAccount: string
/** Net result-account IB balance, credit-positive (a profit is > 0, a loss is < 0). */
net: number
/** Absolute, öre-rounded amount that moves between the two accounts. */
amount: number
direction: 'profit' | 'loss'
/** Balanced lines for the omföring verifikat. */
lines: CreateJournalEntryLineInput[]
}
/**
* Read-only computation of the year-open omföring (no writes). Returns the plan
* to move 2099 "Årets resultat" onto 2098 "Vinst eller förlust från föregående
* år", or null when there is nothing to do.
*
* Returns null when:
* - the company is not an aktiebolag (enskild firma books to 2010, no 2099),
* - the period already has a POSTED result_appropriation entry (idempotency;
* a reversed one has been stornoed, no longer moves any balance, and must
* not block re-planning: the year-end undo flow reverses the omföring and
* the subsequent re-run has to be able to post a fresh one), or
* - 2099 carries no balance (within ORE_TOLERANCE).
*
* Shared by generateResultAppropriation (which posts the plan) and the
* retroactive catch-up script (which previews it in dry-run) so the preview
* and the committed entry can never diverge.
*/
export async function planResultAppropriation(
supabase: SupabaseClient,
companyId: string,
periodId: string,
): Promise<ResultAppropriationPlan | null> {
// Aktiebolag only. Same resolution as previewYearEndClosing's closing-account
// decision, so the omföring runs exactly when the result was posted to 2099.
const { data: settings } = await supabase
.from('company_settings')
.select('entity_type')
.eq('company_id', companyId)
.maybeSingle()
const entityType = await resolveCompanyEntityType(supabase, companyId, settings?.entity_type)
// Only forms that close into a dedicated "årets resultat" account carry it
// forward: AB 2099 -> 2098, ideell förening 2069 -> 2068. An enskild firma
// closes straight into 2010 and has nothing to reclassify.
const accounts = resultClosingAccounts(entityType)
if (!accounts.priorYearCarry) return null
const resultAccount = accounts.closing
const priorResultAccount = accounts.priorYearCarry
// Idempotency: never plan a second omföring for a period that already has a
// LIVE one. Deliberately posted-only: a reversed omföring is storno-cancelled
// (net zero effect on 2099), so it must not block the re-run after an
// administrative year-end undo (scripts/undo-year-end-closing.ts).
const { data: existing } = await supabase
.from('journal_entries')
.select('id')
.eq('company_id', companyId)
.eq('fiscal_period_id', periodId)
.eq('source_type', 'result_appropriation')
.eq('status', 'posted')
.limit(1)
.maybeSingle()
if (existing) return null
const { data: period } = await supabase
.from('fiscal_periods')
.select('period_start, name, opening_balance_entry_id')
.eq('id', periodId)
.eq('company_id', companyId)
.single()
if (!period) throw new Error('Fiscal period not found')
// Read 2099 from the period's INGÅENDE BALANS only: the carried-forward
// prior result that the IB entry mirrored from last year's UB: NOT the full
// trial balance. The omföring must reclassify exactly that carried amount;
// scoping to IB makes it correct even when the period already has current-year
// 2099 activity (e.g. the retroactive catch-up script running mid-year, where
// closing = IB + activity would over/under-reclassify). getOpeningBalances
// reads the committed opening_balance entry, falling back to a server-side
// aggregate of prior posted lines when none is set. credit − debit is positive
// for a profit (2099 is credit-normal).
const { balances } = await getOpeningBalances(supabase, companyId, period)
const ibResult = balances.get(resultAccount)
const net = ibResult ? roundOre(ibResult.credit - ibResult.debit) : 0
if (Math.abs(net) < ORE_TOLERANCE) return null
const amount = roundOre(Math.abs(net))
const lines: CreateJournalEntryLineInput[] =
net > 0
? [
// Profit: move the credit balance off the result account onto the carry.
{
account_number: resultAccount,
debit_amount: amount,
credit_amount: 0,
line_description: 'Omföring av föregående års resultat',
},
{
account_number: priorResultAccount,
debit_amount: 0,
credit_amount: amount,
line_description: 'Föregående års resultat',
},
]
: [
// Loss: move the debit balance off the result account onto the carry.
{
account_number: priorResultAccount,
debit_amount: amount,
credit_amount: 0,
line_description: 'Föregående års resultat',
},
{
account_number: resultAccount,
debit_amount: 0,
credit_amount: amount,
line_description: 'Omföring av föregående års resultat',
},
]
return {
periodId,
periodName: period.name,
periodStart: period.period_start,
resultAccount,
priorResultAccount,
net,
amount,
direction: net > 0 ? 'profit' : 'loss',
lines,
}
}
/**
* Omföring av föregående års resultat: reclassify 2099 at new-year open.
*
* After a new fiscal year's opening balances are generated, account 2099
* "Årets resultat" carries the prior year's result forward (the IB entry is a
* faithful mirror of the prior period's UB). Per BAS practice the prior result
* must not remain on 2099: each year must start with 2099 = 0 so it only ever
* holds the *current* year's result. This posts the year-open reclassification
* as a SEPARATE verifikat in the new period:
*
* profit (2099 has a credit balance): Dr 2099 / Cr 2098
* loss (2099 has a debit balance): Dr 2098 / Cr 2099
*
* It is deliberately NOT folded into the opening-balance entry. The IB entry
* must stay a faithful mirror of the prior UB, or validateBalanceContinuity():
* which reads IB solely from the period's opening_balance entry, would flag
* 2099 and 2098 as discrepancies and executeYearEndClosing would self-reverse.
* A standalone entry is invisible to that check.
*
* The further disposition 2098 → 2091 (balanserat resultat) / 2898 (utdelning)
* is the bolagsstämma's decision and is intentionally left to a separate step.
*
* Idempotent / AB-only: see planResultAppropriation for the no-op conditions.
* Powers both executeYearEndClosing (steady state) and the retroactive
* catch-up script (clears any accumulated 2099 in a company's open period).
*/
export async function generateResultAppropriation(
supabase: SupabaseClient,
companyId: string,
userId: string,
periodId: string,
): Promise<JournalEntry | null> {
const plan = await planResultAppropriation(supabase, companyId, periodId)
if (!plan) return null
const entry = await createJournalEntry(supabase, companyId, userId, {
fiscal_period_id: periodId,
entry_date: plan.periodStart,
description: `Omföring av föregående års resultat (${plan.resultAccount} → ${plan.priorResultAccount})`,
source_type: 'result_appropriation',
voucher_series: 'A',
lines: plan.lines,
})
log.info('Posted result appropriation omföring', {
operation: 'result_appropriation.post',
companyId,
entityType: 'journal_entry',
entityId: entry.id,
amount: plan.amount,
direction: plan.direction,
})
return entry
}