feat(reconciliation): three doors over one engine: dashboard routes, v1 API and MCP tools (#1833)
* feat(reconciliation): skattekonto bridge engine, sync-time twin proposals, account-keyed facade The engine half of the reconciliation page (design: Avstämningsmotorn). - lib/reconciliation/skattekonto-reconciliation.ts: getSkattekontoReconciliationStatus anchors at the saldo snapshot and returns the bridge (saldo hos Skatteverket, händelser som saknas, 1630-rader utan händelse, ignorerade, ingående skillnad, bokfört), the item buckets the page shows (proposed, unmatched external, unmatched ledger, matched, ignored, upcoming), opening_difference, unexplained_difference (0,00 by construction when data is consistent), dead-link handling (a link to a reversed/draft entry counts as unlinked and is flagged), awaiting_external for ledger lines within 5 days of the snapshot, staleness, and a window that scopes item lists without hiding older rows. Core reads skattekonto_transactions and the extension's snapshot row directly; no @/extensions import. - lib/reconciliation/gl-balance.ts: one ledger-balance helper with the trial-balance predicate status IN (posted, reversed). The drift check summed posted only, which misstated 1630 for any company with a storno on the account; skattekonto-drift.ts now delegates to the helper. - Proposals at sync: migration 20260823120000 adds suggested_journal_entry_id / suggested_at (ON DELETE SET NULL, partial index on open rows); the sync calls refreshSkattekontoProposals after the upsert. findMatchSuggestionsBulk now assigns one-to-one across rows (AGI period first, then nearest date) and falls back to an entry whose 1630 lines net to the amount (split lines); a proposal is never a link. - lib/reconciliation/service.ts + schemas.ts: the account-keyed facade (bank:<cash_account_id> | skattekonto | manual:NNNN) with listReconciliationAccounts (enabled cash accounts folded per IBAN, skattekonto when configured) and getAccountStatus dispatching to the bank engine or the new one; shared Zod shapes for the v1 registry, MCP schemas and the UI (PR 2). Tests: identity on a mixed fixture, storno pair, stale snapshot, awaiting window, window scoping, failed ledger read, live-linked entries never proposed; matcher one-to-one and split-line cases; proposal refresh writes/clears; service dedupe and dispatch. No UI in this PR. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(reconciliation): roundOre instead of inline öre rounding (guard ratchet) The antipattern ratchet counts Math.round(x*100)/100; the new engine used it in five places. Switch to roundOre from @/lib/money and ratchet the baseline down by the three occurrences this removes net of the matcher rewrite. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(reconciliation): three doors over one engine: dashboard routes, v1 API and MCP tools for account-keyed reconciliation PR 2 of the Avstämning build (design: Avstämning via API och MCP). Every door calls lib/reconciliation/{service,items,actions}.ts; none re-implements a link. - lib/reconciliation/items.ts: listAccountItems per account_key, the page's buckets (proposed, unmatched_external, unmatched_ledger, matched, ignored, upcoming), limit/offset; skattekonto from the engine, bank from the scoped transactions + unlinked GL lines (netted per entry). - lib/reconciliation/actions.ts: matchPairs (pairs or use_proposals, dry run, partial success with codes), unmatchLink, setItemIgnored; emits reconciliation.matched / reconciliation.unmatched. - lib/skatteverket/skattekonto-link.ts: canonical core link semantics for a skattekonto row (single line or entry net on 1630, live-link guard, race-safe update, unlink, ignore); the extension keeps its own matchSkattekontoToEntry until its tests are ported. - Dashboard routes /api/reconciliation/accounts[...]: list, status, items, links (POST), links/{linkId} (DELETE), items/{itemId}/ignore (POST); apply directly (a human clicked). - v1 routes /api/v1/companies/{id}/reconciliation/accounts[...]: same six, withApiV1, new scopes reconciliation:read / reconciliation:write (write is a staging scope for SoD), Idempotency-Key + dry_run on writes, registered for OpenAPI, load-routes, skills/accounted-api regenerated. Legacy bank routes and their transactions:* scopes unchanged. - MCP: gnubok_get_reconciliation_status takes account_key (legacy bank path untouched), new gnubok_list_reconciliation_items (default catalog), gnubok_reconcile_match (stages reconciliation_match, preflight = status) and gnubok_reconcile_unmatch (stages reconciliation_unmatch), both search-only to stay under the tools/list payload ceiling; gnubok_link_transaction_to_journal_entry moved to search. Executors in commit.ts; risk tiers medium/low; migration pair 20260823130000/130001 adds the two op types to the CHECK constraint (value list = live prod as of 2026-08-23 + the two); close_period loadout updated. Tests: service/actions/items/link unit tests, v1 route tests (401/403/400/404/ happy, idempotency, dry run), dashboard route tests, MCP tool tests + the guard suite (payload ceiling, descriptions, staging meta, qualified ids). Guards and apiskill:check green; no type errors in changed files. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(reconciliation): refresh the v1 spec snapshot and keep the ignore update readable by the phantom-column guard The six new v1 reconciliation endpoints and the two new scopes were not recorded in the spec snapshot, and setSkattekontoRowIgnored updated through one conditional payload, which the phantom-column scanner cannot read (ceiling 380 -> 381). Two literal payloads instead; snapshot updated. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> --------- Co-authored-by: Jakob Wennberg <311770904+jakobwennberg-oss@users.noreply.github.com> Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Jakob Wennberg
co-authored by
Claude Fable 5
Jakob Wennberg
Claude Fable 5
Jakob Wennberg
parent
0a8544e0cb
commit
3a62c5419e
@@ -0,0 +1,182 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest'
|
||||
import { createQueuedMockSupabase } from '@/tests/helpers'
|
||||
|
||||
const linkMock = vi.fn()
|
||||
const unlinkMock = vi.fn()
|
||||
const setIgnoredMock = vi.fn()
|
||||
const manualLinkMock = vi.fn()
|
||||
const unlinkReconciliationMock = vi.fn()
|
||||
const skvStatusMock = vi.fn()
|
||||
const emitMock = vi.fn()
|
||||
|
||||
vi.mock('@/lib/skatteverket/skattekonto-link', async (importOriginal) => {
|
||||
const actual = await importOriginal<typeof import('@/lib/skatteverket/skattekonto-link')>()
|
||||
return {
|
||||
...actual,
|
||||
linkSkattekontoRow: (...args: unknown[]) => linkMock(...args),
|
||||
unlinkSkattekontoRow: (...args: unknown[]) => unlinkMock(...args),
|
||||
setSkattekontoRowIgnored: (...args: unknown[]) => setIgnoredMock(...args),
|
||||
}
|
||||
})
|
||||
vi.mock('../bank-reconciliation', () => ({
|
||||
manualLink: (...args: unknown[]) => manualLinkMock(...args),
|
||||
unlinkReconciliation: (...args: unknown[]) => unlinkReconciliationMock(...args),
|
||||
}))
|
||||
vi.mock('../skattekonto-reconciliation', () => ({
|
||||
getSkattekontoReconciliationStatus: (...args: unknown[]) => skvStatusMock(...args),
|
||||
}))
|
||||
vi.mock('@/lib/events/bus', () => ({ eventBus: { emit: (...args: unknown[]) => emitMock(...args) } }))
|
||||
|
||||
import { SkattekontoLinkError } from '@/lib/skatteverket/skattekonto-link'
|
||||
import { matchPairs, setItemIgnored, unmatchLink } from '../actions'
|
||||
|
||||
const COMPANY = 'company-1'
|
||||
const USER = 'user-1'
|
||||
const CASH = '11111111-1111-4111-8111-111111111111'
|
||||
const R1 = '22222222-2222-4222-8222-222222222222'
|
||||
const R2 = '33333333-3333-4333-8333-333333333333'
|
||||
const E1 = '44444444-4444-4444-8444-444444444444'
|
||||
const E2 = '55555555-5555-4555-8555-555555555555'
|
||||
|
||||
describe('matchPairs', () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks()
|
||||
linkMock.mockReset()
|
||||
manualLinkMock.mockReset()
|
||||
skvStatusMock.mockReset()
|
||||
emitMock.mockResolvedValue(undefined)
|
||||
})
|
||||
|
||||
it('returns null for an unknown or manual account key', async () => {
|
||||
const { supabase } = createQueuedMockSupabase()
|
||||
expect(await matchPairs(supabase as never, COMPANY, USER, 'nope', { pairs: [] })).toBeNull()
|
||||
expect(await matchPairs(supabase as never, COMPANY, USER, 'manual:1910', { pairs: [] })).toBeNull()
|
||||
})
|
||||
|
||||
it('links skattekonto pairs one by one, reports skips with codes, and emits one event per link', async () => {
|
||||
const { supabase } = createQueuedMockSupabase()
|
||||
linkMock
|
||||
.mockResolvedValueOnce({ skattekonto_transaction_id: R1, journal_entry_id: E1, via: 'line' })
|
||||
.mockRejectedValueOnce(new SkattekontoLinkError('redan kopplat', 'ENTRY_ALREADY_LINKED'))
|
||||
|
||||
const result = await matchPairs(supabase as never, COMPANY, USER, 'skattekonto', {
|
||||
pairs: [
|
||||
{ external_ids: [R1], journal_entry_ids: [E1] },
|
||||
{ external_ids: [R2], journal_entry_ids: [E1] },
|
||||
{ external_ids: [R1, R2], journal_entry_ids: [E2] },
|
||||
],
|
||||
})
|
||||
|
||||
expect(result).toMatchObject({ dry_run: false, considered: 3 })
|
||||
expect(result?.applied).toEqual([{ external_id: R1, journal_entry_id: E1, via: 'line' }])
|
||||
expect(result?.skipped.map((s) => s.code)).toEqual(['ALREADY_LINKED', 'UNSUPPORTED_PAIR_SHAPE'])
|
||||
expect(emitMock).toHaveBeenCalledTimes(1)
|
||||
expect(emitMock.mock.calls[0][0]).toMatchObject({
|
||||
type: 'reconciliation.matched',
|
||||
payload: { accountKey: 'skattekonto', externalId: R1, journalEntryId: E1, method: 'manual' },
|
||||
})
|
||||
})
|
||||
|
||||
it('dry run resolves proposals into pairs without writing', async () => {
|
||||
const { supabase } = createQueuedMockSupabase()
|
||||
skvStatusMock.mockResolvedValue({
|
||||
items: {
|
||||
proposed: [
|
||||
{ item_id: R1, proposal: { journal_entry_id: E1, confidence: 0.95 } },
|
||||
{ item_id: R2, proposal: { journal_entry_id: E2, confidence: 0.8 } },
|
||||
],
|
||||
},
|
||||
})
|
||||
|
||||
const result = await matchPairs(
|
||||
supabase as never,
|
||||
COMPANY,
|
||||
USER,
|
||||
'skattekonto',
|
||||
{ use_proposals: true, confidence_threshold: 0.9 },
|
||||
{ dryRun: true },
|
||||
)
|
||||
|
||||
expect(result).toMatchObject({ dry_run: true, considered: 1 })
|
||||
expect(result?.applied).toEqual([{ external_id: R1, journal_entry_id: E1 }])
|
||||
expect(linkMock).not.toHaveBeenCalled()
|
||||
expect(emitMock).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('links bank pairs through manualLink with the account ledger number', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: { ledger_account: '1931' } }) // cash_accounts lookup
|
||||
manualLinkMock.mockResolvedValue({ success: true })
|
||||
|
||||
const result = await matchPairs(supabase as never, COMPANY, USER, `bank:${CASH}`, {
|
||||
pairs: [{ external_ids: [R1], journal_entry_ids: [E1] }],
|
||||
})
|
||||
|
||||
expect(manualLinkMock).toHaveBeenCalledWith(supabase, COMPANY, R1, E1, USER, '1931')
|
||||
expect(result?.applied).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('a failed bank link is a PAIR_NOT_CLOSED skip, not a throw', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: { ledger_account: '1930' } })
|
||||
manualLinkMock.mockResolvedValue({ success: false, error: 'Beloppen stämmer inte' })
|
||||
|
||||
const result = await matchPairs(supabase as never, COMPANY, USER, `bank:${CASH}`, {
|
||||
pairs: [{ external_ids: [R1], journal_entry_ids: [E1] }],
|
||||
})
|
||||
expect(result?.skipped[0]).toMatchObject({ code: 'PAIR_NOT_CLOSED', message: 'Beloppen stämmer inte' })
|
||||
})
|
||||
})
|
||||
|
||||
describe('unmatchLink / setItemIgnored', () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks()
|
||||
unlinkMock.mockReset()
|
||||
unlinkReconciliationMock.mockReset()
|
||||
setIgnoredMock.mockReset()
|
||||
emitMock.mockResolvedValue(undefined)
|
||||
})
|
||||
|
||||
it('unlinks a skattekonto row and emits reconciliation.unmatched', async () => {
|
||||
const { supabase } = createQueuedMockSupabase()
|
||||
unlinkMock.mockResolvedValue({ skattekonto_transaction_id: R1, previous_journal_entry_id: E1 })
|
||||
const result = await unmatchLink(supabase as never, COMPANY, USER, 'skattekonto', R1)
|
||||
expect(result).toEqual({ external_id: R1, previous_journal_entry_id: E1 })
|
||||
expect(emitMock.mock.calls[0][0]).toMatchObject({ type: 'reconciliation.unmatched', payload: { externalId: R1 } })
|
||||
})
|
||||
|
||||
it('unlinks a bank transaction through the bank engine', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: { journal_entry_id: E1 } })
|
||||
unlinkReconciliationMock.mockResolvedValue({ success: true })
|
||||
const result = await unmatchLink(supabase as never, COMPANY, USER, `bank:${CASH}`, R1)
|
||||
expect(unlinkReconciliationMock).toHaveBeenCalledWith(supabase, COMPANY, R1, USER)
|
||||
expect(result).toEqual({ external_id: R1, previous_journal_entry_id: E1 })
|
||||
})
|
||||
|
||||
it('ignores a skattekonto row via the core helper', async () => {
|
||||
const { supabase } = createQueuedMockSupabase()
|
||||
setIgnoredMock.mockResolvedValue({ skattekonto_transaction_id: R1, is_ignored: true })
|
||||
expect(await setItemIgnored(supabase as never, COMPANY, 'skattekonto', R1, true)).toEqual({
|
||||
external_id: R1,
|
||||
is_ignored: true,
|
||||
})
|
||||
})
|
||||
|
||||
it('refuses to ignore a booked bank transaction', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: { id: R1, journal_entry_id: E1, is_ignored: false } })
|
||||
await expect(setItemIgnored(supabase as never, COMPANY, `bank:${CASH}`, R1, true)).rejects.toMatchObject({
|
||||
code: 'ALREADY_BOOKED',
|
||||
})
|
||||
})
|
||||
|
||||
it('ignores an unbooked bank transaction', async () => {
|
||||
const { supabase, enqueue, findCalls } = createQueuedMockSupabase()
|
||||
enqueue({ data: { id: R1, journal_entry_id: null, is_ignored: false } })
|
||||
enqueue({ data: null }) // update
|
||||
const result = await setItemIgnored(supabase as never, COMPANY, `bank:${CASH}`, R1, true)
|
||||
expect(result).toEqual({ external_id: R1, is_ignored: true })
|
||||
expect(findCalls('transactions', 'update')[0][0]).toEqual({ is_ignored: true })
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,97 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest'
|
||||
import { createQueuedMockSupabase } from '@/tests/helpers'
|
||||
|
||||
const skvStatusMock = vi.fn()
|
||||
const fetchUnlinkedMock = vi.fn()
|
||||
|
||||
vi.mock('../skattekonto-reconciliation', () => ({
|
||||
getSkattekontoReconciliationStatus: (...args: unknown[]) => skvStatusMock(...args),
|
||||
}))
|
||||
vi.mock('../bank-reconciliation', () => ({
|
||||
fetchUnlinkedGLLines: (...args: unknown[]) => fetchUnlinkedMock(...args),
|
||||
scopeTransactionsToAccount: (q: unknown) => q,
|
||||
}))
|
||||
|
||||
import { listAccountItems } from '../items'
|
||||
|
||||
const COMPANY = 'company-1'
|
||||
const CASH = '11111111-1111-4111-8111-111111111111'
|
||||
|
||||
function item(id: string, bucket: string) {
|
||||
return { item_id: id, bucket, side: 'external', item_type: 'skattekonto_transaction', date: '2026-08-01', description: id, amount: 1, currency: 'SEK', actions: [] }
|
||||
}
|
||||
|
||||
describe('listAccountItems', () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks()
|
||||
skvStatusMock.mockReset()
|
||||
fetchUnlinkedMock.mockReset()
|
||||
})
|
||||
|
||||
it('returns null for an invalid key', async () => {
|
||||
const { supabase } = createQueuedMockSupabase()
|
||||
expect(await listAccountItems(supabase as never, COMPANY, 'nope')).toBeNull()
|
||||
})
|
||||
|
||||
it('pages skattekonto buckets in work order and carries the older count', async () => {
|
||||
const { supabase } = createQueuedMockSupabase()
|
||||
skvStatusMock.mockResolvedValue({
|
||||
older_unmatched_count: 2,
|
||||
items: {
|
||||
proposed: [item('p1', 'proposed')],
|
||||
unmatched_external: [item('u1', 'unmatched_external'), item('u2', 'unmatched_external')],
|
||||
unmatched_ledger: [item('l1', 'unmatched_ledger')],
|
||||
matched: [item('m1', 'matched')],
|
||||
ignored: [],
|
||||
upcoming: [],
|
||||
},
|
||||
})
|
||||
|
||||
const all = await listAccountItems(supabase as never, COMPANY, 'skattekonto', { limit: 3, offset: 0 })
|
||||
expect(all?.items.map((i) => i.item_id)).toEqual(['p1', 'u1', 'u2'])
|
||||
expect(all).toMatchObject({ count: 3, total_count: 5, has_more: true, next_offset: 3, older_unmatched_count: 2 })
|
||||
|
||||
const page2 = await listAccountItems(supabase as never, COMPANY, 'skattekonto', { limit: 3, offset: 3 })
|
||||
expect(page2?.items.map((i) => i.item_id)).toEqual(['l1', 'm1'])
|
||||
expect(page2?.has_more).toBe(false)
|
||||
|
||||
const onlyLedger = await listAccountItems(supabase as never, COMPANY, 'skattekonto', { bucket: 'unmatched_ledger' })
|
||||
expect(onlyLedger?.items.map((i) => i.item_id)).toEqual(['l1'])
|
||||
expect(skvStatusMock).toHaveBeenLastCalledWith(supabase, COMPANY, { today: undefined, windowFrom: null, windowTo: null })
|
||||
})
|
||||
|
||||
it('buckets bank transactions by ignored / linked / proposed / open and nets unlinked ledger lines per entry', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: { id: CASH, ledger_account: '1930', currency: 'SEK', is_primary: true } })
|
||||
enqueue({
|
||||
data: [
|
||||
{ id: 't-ign', date: '2026-08-04', description: 'Dubblett', merchant_name: null, amount: -10, currency: 'SEK', journal_entry_id: null, potential_journal_entry_id: null, potential_match_method: null, potential_match_confidence: null, is_ignored: true, reconciliation_method: null },
|
||||
{ id: 't-link', date: '2026-08-03', description: 'Lön', merchant_name: null, amount: -31200, currency: 'SEK', journal_entry_id: 'e-1', potential_journal_entry_id: null, potential_match_method: 'manual', potential_match_confidence: null, is_ignored: false, reconciliation_method: 'manual' },
|
||||
{ id: 't-prop', date: '2026-08-02', description: 'Swish', merchant_name: 'Swish 123', amount: 2400, currency: 'SEK', journal_entry_id: null, potential_journal_entry_id: 'e-2', potential_match_method: 'auto_fuzzy', potential_match_confidence: '0.82', is_ignored: false, reconciliation_method: null },
|
||||
{ id: 't-open', date: '2026-08-01', description: 'Elgiganten', merchant_name: null, amount: -1046, currency: 'SEK', journal_entry_id: null, potential_journal_entry_id: null, potential_match_method: null, potential_match_confidence: null, is_ignored: false, reconciliation_method: null },
|
||||
],
|
||||
})
|
||||
fetchUnlinkedMock.mockResolvedValue([
|
||||
{ line_id: 'l1', journal_entry_id: 'e-3', debit_amount: 0, credit_amount: 600, line_description: null, entry_date: '2026-08-18', voucher_number: 231, voucher_series: 'A', entry_description: 'Elgiganten', source_type: 'manual' },
|
||||
{ line_id: 'l2', journal_entry_id: 'e-3', debit_amount: 0, credit_amount: 400, line_description: null, entry_date: '2026-08-18', voucher_number: 231, voucher_series: 'A', entry_description: 'Elgiganten', source_type: 'manual' },
|
||||
])
|
||||
|
||||
const result = await listAccountItems(supabase as never, COMPANY, `bank:${CASH}`, { limit: 50 })
|
||||
const byId = Object.fromEntries((result?.items ?? []).map((i) => [i.item_id, i]))
|
||||
|
||||
expect(byId['t-prop']).toMatchObject({ bucket: 'proposed', description: 'Swish 123', proposal: { journal_entry_id: 'e-2', confidence: 0.82 } })
|
||||
expect(byId['t-open']).toMatchObject({ bucket: 'unmatched_external', actions: ['book', 'match', 'ignore'] })
|
||||
expect(byId['t-link']).toMatchObject({ bucket: 'matched', linked_journal_entry_id: 'e-1', actions: ['unmatch'] })
|
||||
expect(byId['t-ign']).toMatchObject({ bucket: 'ignored', actions: ['unignore'] })
|
||||
expect(byId['e-3']).toMatchObject({ bucket: 'unmatched_ledger', side: 'ledger', amount: -1000, voucher_number: 231 })
|
||||
// Work order: proposed, unmatched external, unmatched ledger, ignored, upcoming, matched
|
||||
expect(result?.items.map((i) => i.bucket)).toEqual(['proposed', 'unmatched_external', 'unmatched_ledger', 'ignored', 'matched'])
|
||||
expect(result?.total_count).toBe(5)
|
||||
})
|
||||
|
||||
it('returns null for an unknown cash account', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: null })
|
||||
expect(await listAccountItems(supabase as never, COMPANY, `bank:${CASH}`)).toBeNull()
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,291 @@
|
||||
import type { SupabaseClient } from '@supabase/supabase-js'
|
||||
import { eventBus } from '@/lib/events/bus'
|
||||
import { createLogger } from '@/lib/logger'
|
||||
import {
|
||||
linkSkattekontoRow,
|
||||
setSkattekontoRowIgnored,
|
||||
SkattekontoLinkError,
|
||||
unlinkSkattekontoRow,
|
||||
} from '@/lib/skatteverket/skattekonto-link'
|
||||
import { manualLink, unlinkReconciliation } from './bank-reconciliation'
|
||||
import { getSkattekontoReconciliationStatus } from './skattekonto-reconciliation'
|
||||
import { parseAccountKey } from './schemas'
|
||||
|
||||
const log = createLogger('reconciliation/actions')
|
||||
|
||||
/**
|
||||
* Write actions of the account-keyed reconciliation surface. Every door (page
|
||||
* route, v1, MCP commit executor) calls these; none of them links on its own.
|
||||
*
|
||||
* Links never touch the ledger: they pair an outside row with an existing
|
||||
* verifikat, so they are allowed in locked periods and reversible by
|
||||
* unmatch. Bookings (residual postings) are a separate, later action.
|
||||
*/
|
||||
|
||||
export interface ReconciliationPair {
|
||||
/** Outside rows: transaction ids (bank) or skattekonto_transaction ids. */
|
||||
external_ids: string[]
|
||||
journal_entry_ids: string[]
|
||||
}
|
||||
|
||||
export type PairSkipCode =
|
||||
| 'UNSUPPORTED_PAIR_SHAPE'
|
||||
| 'ALREADY_LINKED'
|
||||
| 'ENTRY_NOT_FOUND'
|
||||
| 'ENTRY_REVERSED'
|
||||
| 'PAIR_NOT_CLOSED'
|
||||
| 'ROW_IGNORED'
|
||||
| 'NOT_FOUND'
|
||||
| 'LINK_RACE'
|
||||
| 'UNKNOWN'
|
||||
|
||||
export interface AppliedLink {
|
||||
external_id: string
|
||||
journal_entry_id: string
|
||||
via?: 'line' | 'entry_total'
|
||||
}
|
||||
|
||||
export interface SkippedPair {
|
||||
pair: ReconciliationPair
|
||||
code: PairSkipCode
|
||||
message: string
|
||||
}
|
||||
|
||||
export interface MatchPairsInput {
|
||||
pairs?: ReconciliationPair[]
|
||||
/** Use the persisted proposals (skattekonto) or potential matches (bank) as pairs. */
|
||||
use_proposals?: boolean
|
||||
/** Only with use_proposals: skip proposals below this confidence. */
|
||||
confidence_threshold?: number
|
||||
}
|
||||
|
||||
export interface MatchPairsResult {
|
||||
dry_run: boolean
|
||||
applied: AppliedLink[]
|
||||
skipped: SkippedPair[]
|
||||
considered: number
|
||||
}
|
||||
|
||||
function skipCodeFor(err: unknown): { code: PairSkipCode; message: string } {
|
||||
if (err instanceof SkattekontoLinkError) {
|
||||
const map: Record<string, PairSkipCode> = {
|
||||
TRANSACTION_NOT_FOUND: 'NOT_FOUND',
|
||||
ALREADY_BOOKED: 'ALREADY_LINKED',
|
||||
ROW_IGNORED: 'ROW_IGNORED',
|
||||
ENTRY_NOT_FOUND: 'ENTRY_NOT_FOUND',
|
||||
ENTRY_ALREADY_LINKED: 'ALREADY_LINKED',
|
||||
INVALID_CANDIDATE: 'PAIR_NOT_CLOSED',
|
||||
NOT_LINKED: 'UNKNOWN',
|
||||
LINK_RACE: 'LINK_RACE',
|
||||
}
|
||||
return { code: map[err.code] ?? 'UNKNOWN', message: err.message }
|
||||
}
|
||||
return { code: 'UNKNOWN', message: err instanceof Error ? err.message : String(err) }
|
||||
}
|
||||
|
||||
async function proposalsAsPairs(
|
||||
supabase: SupabaseClient,
|
||||
companyId: string,
|
||||
accountKey: string,
|
||||
threshold: number,
|
||||
): Promise<ReconciliationPair[]> {
|
||||
const parsed = parseAccountKey(accountKey)
|
||||
if (!parsed) return []
|
||||
if (parsed.kind === 'skattekonto') {
|
||||
const status = await getSkattekontoReconciliationStatus(supabase, companyId)
|
||||
if (!status) return []
|
||||
return status.items.proposed
|
||||
.filter((i) => i.proposal && i.proposal.confidence >= threshold)
|
||||
.map((i) => ({ external_ids: [i.item_id], journal_entry_ids: [i.proposal!.journal_entry_id] }))
|
||||
}
|
||||
if (parsed.kind === 'bank') {
|
||||
const { data } = await supabase
|
||||
.from('transactions')
|
||||
.select('id, potential_journal_entry_id, potential_match_confidence')
|
||||
.eq('company_id', companyId)
|
||||
.eq('cash_account_id', parsed.cashAccountId)
|
||||
.is('journal_entry_id', null)
|
||||
.eq('is_ignored', false)
|
||||
.not('potential_journal_entry_id', 'is', null)
|
||||
return ((data ?? []) as Array<{ id: string; potential_journal_entry_id: string; potential_match_confidence: number | string | null }>)
|
||||
.filter((r) => Number(r.potential_match_confidence ?? 0) >= threshold)
|
||||
.map((r) => ({ external_ids: [r.id], journal_entry_ids: [r.potential_journal_entry_id] }))
|
||||
}
|
||||
return []
|
||||
}
|
||||
|
||||
/**
|
||||
* Link pairs on one account. Today each pair is one outside row and one
|
||||
* verifikat (the N:M worksheet selection arrives with the manual-match mode);
|
||||
* other shapes are reported as UNSUPPORTED_PAIR_SHAPE, never silently
|
||||
* reduced. Dry run validates shapes and resolves proposals without writing.
|
||||
* Partial success is first-class: `applied` and `skipped` together cover
|
||||
* every considered pair.
|
||||
*/
|
||||
export async function matchPairs(
|
||||
supabase: SupabaseClient,
|
||||
companyId: string,
|
||||
userId: string,
|
||||
accountKey: string,
|
||||
input: MatchPairsInput,
|
||||
options: { dryRun?: boolean } = {},
|
||||
): Promise<MatchPairsResult | null> {
|
||||
const parsed = parseAccountKey(accountKey)
|
||||
if (!parsed || parsed.kind === 'manual') return null
|
||||
const dryRun = options.dryRun ?? false
|
||||
|
||||
const pairs: ReconciliationPair[] = [...(input.pairs ?? [])]
|
||||
if (input.use_proposals) {
|
||||
pairs.push(
|
||||
...(await proposalsAsPairs(supabase, companyId, accountKey, input.confidence_threshold ?? 0)),
|
||||
)
|
||||
}
|
||||
|
||||
const applied: AppliedLink[] = []
|
||||
const skipped: SkippedPair[] = []
|
||||
|
||||
for (const pair of pairs) {
|
||||
if (pair.external_ids.length !== 1 || pair.journal_entry_ids.length !== 1) {
|
||||
skipped.push({
|
||||
pair,
|
||||
code: 'UNSUPPORTED_PAIR_SHAPE',
|
||||
message: 'Ett par är en händelse och ett verifikat i den här versionen.',
|
||||
})
|
||||
continue
|
||||
}
|
||||
const [externalId] = pair.external_ids
|
||||
const [journalEntryId] = pair.journal_entry_ids
|
||||
|
||||
if (dryRun) {
|
||||
applied.push({ external_id: externalId, journal_entry_id: journalEntryId })
|
||||
continue
|
||||
}
|
||||
|
||||
try {
|
||||
if (parsed.kind === 'skattekonto') {
|
||||
const r = await linkSkattekontoRow(supabase, companyId, externalId, journalEntryId)
|
||||
applied.push({ external_id: externalId, journal_entry_id: journalEntryId, via: r.via })
|
||||
} else {
|
||||
const { data: account } = await supabase
|
||||
.from('cash_accounts')
|
||||
.select('ledger_account')
|
||||
.eq('company_id', companyId)
|
||||
.eq('id', parsed.cashAccountId)
|
||||
.maybeSingle<{ ledger_account: string }>()
|
||||
const r = await manualLink(
|
||||
supabase,
|
||||
companyId,
|
||||
externalId,
|
||||
journalEntryId,
|
||||
userId,
|
||||
account?.ledger_account ?? '1930',
|
||||
)
|
||||
if (!r.success) {
|
||||
skipped.push({ pair, code: 'PAIR_NOT_CLOSED', message: r.error ?? 'Kunde inte koppla' })
|
||||
continue
|
||||
}
|
||||
applied.push({ external_id: externalId, journal_entry_id: journalEntryId })
|
||||
}
|
||||
await eventBus.emit({
|
||||
type: 'reconciliation.matched',
|
||||
payload: {
|
||||
accountKey,
|
||||
externalId,
|
||||
journalEntryId,
|
||||
method: input.use_proposals ? 'proposal' : 'manual',
|
||||
userId,
|
||||
companyId,
|
||||
},
|
||||
})
|
||||
} catch (err) {
|
||||
const { code, message } = skipCodeFor(err)
|
||||
skipped.push({ pair, code, message })
|
||||
}
|
||||
}
|
||||
|
||||
if (!dryRun && applied.length > 0) {
|
||||
log.info('reconciliation pairs linked', { companyId, accountKey, applied: applied.length, skipped: skipped.length })
|
||||
}
|
||||
|
||||
return { dry_run: dryRun, applied, skipped, considered: pairs.length }
|
||||
}
|
||||
|
||||
export interface UnmatchResult {
|
||||
external_id: string
|
||||
previous_journal_entry_id: string | null
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove one link. link id = the outside row's id (transaction or
|
||||
* skattekonto row), which is the one-link-per-row identity both kinds share.
|
||||
*/
|
||||
export async function unmatchLink(
|
||||
supabase: SupabaseClient,
|
||||
companyId: string,
|
||||
userId: string,
|
||||
accountKey: string,
|
||||
linkId: string,
|
||||
): Promise<UnmatchResult | null> {
|
||||
const parsed = parseAccountKey(accountKey)
|
||||
if (!parsed || parsed.kind === 'manual') return null
|
||||
|
||||
let previous: string | null = null
|
||||
if (parsed.kind === 'skattekonto') {
|
||||
const r = await unlinkSkattekontoRow(supabase, companyId, linkId)
|
||||
previous = r.previous_journal_entry_id
|
||||
} else {
|
||||
const { data: tx } = await supabase
|
||||
.from('transactions')
|
||||
.select('journal_entry_id')
|
||||
.eq('company_id', companyId)
|
||||
.eq('id', linkId)
|
||||
.maybeSingle<{ journal_entry_id: string | null }>()
|
||||
previous = tx?.journal_entry_id ?? null
|
||||
const r = await unlinkReconciliation(supabase, companyId, linkId, userId)
|
||||
if (!r.success) throw new Error(r.error ?? 'Kunde inte koppla bort')
|
||||
}
|
||||
await eventBus.emit({
|
||||
type: 'reconciliation.unmatched',
|
||||
payload: { accountKey, externalId: linkId, previousJournalEntryId: previous, userId, companyId },
|
||||
})
|
||||
return { external_id: linkId, previous_journal_entry_id: previous }
|
||||
}
|
||||
|
||||
/**
|
||||
* Ignore / restore one outside row. Ignored rows leave the unmatched totals
|
||||
* and surface on the bridge's exclusion line (bank #1705 precedent).
|
||||
*/
|
||||
export async function setItemIgnored(
|
||||
supabase: SupabaseClient,
|
||||
companyId: string,
|
||||
accountKey: string,
|
||||
itemId: string,
|
||||
ignored: boolean,
|
||||
): Promise<{ external_id: string; is_ignored: boolean } | null> {
|
||||
const parsed = parseAccountKey(accountKey)
|
||||
if (!parsed || parsed.kind === 'manual') return null
|
||||
if (parsed.kind === 'skattekonto') {
|
||||
const r = await setSkattekontoRowIgnored(supabase, companyId, itemId, ignored)
|
||||
return { external_id: r.skattekonto_transaction_id, is_ignored: r.is_ignored }
|
||||
}
|
||||
const { data: tx, error } = await supabase
|
||||
.from('transactions')
|
||||
.select('id, journal_entry_id, is_ignored')
|
||||
.eq('company_id', companyId)
|
||||
.eq('id', itemId)
|
||||
.maybeSingle<{ id: string; journal_entry_id: string | null; is_ignored: boolean | null }>()
|
||||
if (error) throw new Error(`Kunde inte hämta transaktionen: ${error.message}`)
|
||||
if (!tx) throw new SkattekontoLinkError('Transaktionen hittades inte.', 'TRANSACTION_NOT_FOUND')
|
||||
if (ignored && tx.journal_entry_id) {
|
||||
throw new SkattekontoLinkError('En bokförd transaktion kan inte ignoreras.', 'ALREADY_BOOKED')
|
||||
}
|
||||
if (Boolean(tx.is_ignored) !== ignored) {
|
||||
const { error: updateError } = await supabase
|
||||
.from('transactions')
|
||||
.update({ is_ignored: ignored })
|
||||
.eq('company_id', companyId)
|
||||
.eq('id', itemId)
|
||||
if (updateError) throw new Error(`Kunde inte uppdatera: ${updateError.message}`)
|
||||
}
|
||||
return { external_id: itemId, is_ignored: ignored }
|
||||
}
|
||||
@@ -0,0 +1,235 @@
|
||||
import type { SupabaseClient } from '@supabase/supabase-js'
|
||||
import { roundOre } from '@/lib/money'
|
||||
import { fetchUnlinkedGLLines, scopeTransactionsToAccount } from './bank-reconciliation'
|
||||
import { getSkattekontoReconciliationStatus } from './skattekonto-reconciliation'
|
||||
import {
|
||||
parseAccountKey,
|
||||
type ReconciliationItem,
|
||||
type ReconciliationItemBucket,
|
||||
} from './schemas'
|
||||
|
||||
/**
|
||||
* Item listing for one account, in the page's buckets, paginated with
|
||||
* limit/offset (the MCP convention; the v1 door wraps this in its cursor).
|
||||
*
|
||||
* Skattekonto items come straight from the engine (which already buckets
|
||||
* and windows them). Bank items are built from the same sources the bank
|
||||
* page uses: the account-scoped transactions for the external side and the
|
||||
* unlinked-GL-lines RPC for the ledger side; the bank matcher's proposals are
|
||||
* the rows carrying potential_journal_entry_id.
|
||||
*/
|
||||
|
||||
export const DEFAULT_ITEMS_LIMIT = 50
|
||||
export const MAX_ITEMS_LIMIT = 200
|
||||
|
||||
/** Bucket order when no bucket is requested: what to do first, first. */
|
||||
export const BUCKET_ORDER: readonly ReconciliationItemBucket[] = [
|
||||
'proposed',
|
||||
'unmatched_external',
|
||||
'unmatched_ledger',
|
||||
'ignored',
|
||||
'upcoming',
|
||||
'matched',
|
||||
]
|
||||
|
||||
export interface ListItemsOptions {
|
||||
bucket?: ReconciliationItemBucket
|
||||
windowFrom?: string | null
|
||||
windowTo?: string | null
|
||||
limit?: number
|
||||
offset?: number
|
||||
today?: string
|
||||
}
|
||||
|
||||
export interface ListItemsResult {
|
||||
items: ReconciliationItem[]
|
||||
count: number
|
||||
total_count: number
|
||||
has_more: boolean
|
||||
next_offset?: number
|
||||
/** Unmatched rows dated before windowFrom (never hidden, only counted). */
|
||||
older_unmatched_count: number
|
||||
}
|
||||
|
||||
interface CashAccountRow {
|
||||
id: string
|
||||
ledger_account: string
|
||||
currency: string | null
|
||||
is_primary: boolean | null
|
||||
}
|
||||
|
||||
interface BankTxRow {
|
||||
id: string
|
||||
date: string
|
||||
description: string | null
|
||||
merchant_name: string | null
|
||||
amount: number | string
|
||||
currency: string
|
||||
journal_entry_id: string | null
|
||||
potential_journal_entry_id: string | null
|
||||
potential_match_method: string | null
|
||||
potential_match_confidence: number | string | null
|
||||
is_ignored: boolean | null
|
||||
reconciliation_method: string | null
|
||||
}
|
||||
|
||||
function clampLimit(limit?: number): number {
|
||||
if (!limit || !Number.isFinite(limit) || limit < 1) return DEFAULT_ITEMS_LIMIT
|
||||
return Math.min(Math.floor(limit), MAX_ITEMS_LIMIT)
|
||||
}
|
||||
|
||||
function page<T>(all: T[], limit: number, offset: number): ListItemsResult & { items: T[] } {
|
||||
const items = all.slice(offset, offset + limit)
|
||||
const hasMore = offset + limit < all.length
|
||||
return {
|
||||
items,
|
||||
count: items.length,
|
||||
total_count: all.length,
|
||||
has_more: hasMore,
|
||||
...(hasMore ? { next_offset: offset + limit } : {}),
|
||||
older_unmatched_count: 0,
|
||||
} as ListItemsResult & { items: T[] }
|
||||
}
|
||||
|
||||
export async function listAccountItems(
|
||||
supabase: SupabaseClient,
|
||||
companyId: string,
|
||||
accountKey: string,
|
||||
options: ListItemsOptions = {},
|
||||
): Promise<ListItemsResult | null> {
|
||||
const parsed = parseAccountKey(accountKey)
|
||||
if (!parsed) return null
|
||||
const limit = clampLimit(options.limit)
|
||||
const offset = Math.max(0, Math.floor(options.offset ?? 0))
|
||||
|
||||
if (parsed.kind === 'skattekonto') {
|
||||
const status = await getSkattekontoReconciliationStatus(supabase, companyId, {
|
||||
today: options.today,
|
||||
windowFrom: options.windowFrom ?? null,
|
||||
windowTo: options.windowTo ?? null,
|
||||
})
|
||||
if (!status) return null
|
||||
const all = options.bucket
|
||||
? status.items[options.bucket]
|
||||
: BUCKET_ORDER.flatMap((b) => status.items[b])
|
||||
return { ...page(all, limit, offset), older_unmatched_count: status.older_unmatched_count }
|
||||
}
|
||||
|
||||
if (parsed.kind === 'bank') {
|
||||
const { data: account, error } = await supabase
|
||||
.from('cash_accounts')
|
||||
.select('id, ledger_account, currency, is_primary')
|
||||
.eq('company_id', companyId)
|
||||
.eq('id', parsed.cashAccountId)
|
||||
.maybeSingle<CashAccountRow>()
|
||||
if (error) throw new Error(`Kunde inte hämta kassakonto: ${error.message}`)
|
||||
if (!account) return null
|
||||
const currency = account.currency ?? 'SEK'
|
||||
const buckets = options.bucket ? [options.bucket] : [...BUCKET_ORDER]
|
||||
const byBucket = new Map<ReconciliationItemBucket, ReconciliationItem[]>()
|
||||
const push = (item: ReconciliationItem) => {
|
||||
byBucket.set(item.bucket, [...(byBucket.get(item.bucket) ?? []), item])
|
||||
}
|
||||
|
||||
const wantsExternal = buckets.some((b) =>
|
||||
['proposed', 'unmatched_external', 'matched', 'ignored'].includes(b),
|
||||
)
|
||||
if (wantsExternal) {
|
||||
let query = supabase
|
||||
.from('transactions')
|
||||
.select(
|
||||
'id, date, description, merchant_name, amount, currency, journal_entry_id, potential_journal_entry_id, potential_match_method, potential_match_confidence, is_ignored, reconciliation_method',
|
||||
)
|
||||
.eq('company_id', companyId)
|
||||
query = scopeTransactionsToAccount(query, account.id, currency, Boolean(account.is_primary))
|
||||
if (options.windowFrom) query = query.gte('date', options.windowFrom)
|
||||
if (options.windowTo) query = query.lte('date', options.windowTo)
|
||||
const { data, error: txError } = await query.order('date', { ascending: false }).order('id', { ascending: true })
|
||||
if (txError) throw new Error(`Kunde inte hämta transaktioner: ${txError.message}`)
|
||||
const rows = (data ?? []) as BankTxRow[]
|
||||
{
|
||||
for (const tx of rows) {
|
||||
const bucket: ReconciliationItemBucket = tx.is_ignored
|
||||
? 'ignored'
|
||||
: tx.journal_entry_id
|
||||
? 'matched'
|
||||
: tx.potential_journal_entry_id
|
||||
? 'proposed'
|
||||
: 'unmatched_external'
|
||||
if (!buckets.includes(bucket)) continue
|
||||
push({
|
||||
item_id: tx.id,
|
||||
item_type: 'transaction',
|
||||
side: 'external',
|
||||
bucket,
|
||||
date: tx.date,
|
||||
description: tx.merchant_name || tx.description || '',
|
||||
amount: roundOre(Number(tx.amount)),
|
||||
currency: tx.currency,
|
||||
linked_journal_entry_id: tx.journal_entry_id,
|
||||
proposal: tx.potential_journal_entry_id
|
||||
? {
|
||||
journal_entry_id: tx.potential_journal_entry_id,
|
||||
voucher_number: null,
|
||||
voucher_series: null,
|
||||
entry_date: tx.date,
|
||||
description: '',
|
||||
entry_status: 'posted',
|
||||
confidence: Number(tx.potential_match_confidence ?? 0.75),
|
||||
reasons: [tx.potential_match_method ?? 'föreslagen av matcharen'],
|
||||
}
|
||||
: null,
|
||||
actions:
|
||||
bucket === 'matched'
|
||||
? ['unmatch']
|
||||
: bucket === 'ignored'
|
||||
? ['unignore']
|
||||
: bucket === 'proposed'
|
||||
? ['match', 'book', 'ignore']
|
||||
: ['book', 'match', 'ignore'],
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (buckets.includes('unmatched_ledger')) {
|
||||
const lines = await fetchUnlinkedGLLines(
|
||||
supabase,
|
||||
companyId,
|
||||
account.ledger_account,
|
||||
options.windowFrom ?? undefined,
|
||||
options.windowTo ?? undefined,
|
||||
)
|
||||
// One item per entry: several 1930 lines of one voucher net, as a link settles the voucher.
|
||||
const byEntry = new Map<string, ReconciliationItem>()
|
||||
for (const l of lines) {
|
||||
const amount = roundOre(Number(l.debit_amount || 0) - Number(l.credit_amount || 0))
|
||||
const existing = byEntry.get(l.journal_entry_id)
|
||||
if (existing) {
|
||||
existing.amount = roundOre(existing.amount + amount)
|
||||
continue
|
||||
}
|
||||
byEntry.set(l.journal_entry_id, {
|
||||
item_id: l.journal_entry_id,
|
||||
item_type: 'journal_entry',
|
||||
side: 'ledger',
|
||||
bucket: 'unmatched_ledger',
|
||||
date: l.entry_date,
|
||||
description: l.entry_description || l.line_description || '',
|
||||
amount,
|
||||
currency,
|
||||
voucher_number: l.voucher_number,
|
||||
voucher_series: l.voucher_series,
|
||||
entry_status: 'posted',
|
||||
actions: ['match', 'review'],
|
||||
})
|
||||
}
|
||||
for (const it of byEntry.values()) push(it)
|
||||
}
|
||||
|
||||
const all = buckets.flatMap((b) => byBucket.get(b) ?? [])
|
||||
return page(all, limit, offset)
|
||||
}
|
||||
|
||||
return null
|
||||
}
|
||||
Reference in New Issue
Block a user