feat(inbox): per-item underlag anchoring status and a daily reconcile cron for stranded underlag (#1548) (#2012)
* feat(invoice-inbox): per-item underlag status and daily reconcile of stranded booked items (#1548) The inbox derives "booked" from the matched transaction's verifikat, but that says nothing about whether THIS item's document reached it: a link that failed at propagation time, or a document anchored to another verifikat, read as booked while the verifikat sat without its underlag (BFL 5 kap 6-7 §). GET /items and /items/:id now also emit underlag_status (anchored | unlinked | anchored_elsewhere) from one batched document_attachments read; the workspace keeps divergent items in "Att göra", drops the booking bridge for them (the book routes 409 on a booked transaction) and shows one explanatory line with a link to the verifikat. The backfill script's loop moves into lib/transactions/ inbox-underlag-reconcile.ts and runs daily from a new extension-owned cron (vercel.json plus the generated Docker crontabs): transient link failures heal without an ad-hoc script run, permanent conflicts are counted in one summary, and each repaired transaction leaves an InboxUnderlagReconciled row in behandlingshistorik. That event type is registered by migration 20260828154800: processing_history.event_type has an FK to processing_event_types, and the script's previous InboxUnderlagBackfilled type was never registered, so its appends had always failed silently. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015nAd8XJ2RPCmG2eKoLBdna * fix(invoice-inbox): address review findings on the underlag reconcile (#1548) Findings 1, 3, 6 (scan cap starves the tail): the reconcile no longer caps the read. The matched-unconsumed candidate set holds permanent residents (samlingsverifikat siblings, anchored-elsewhere items) that never leave it, so a uuid-ordered read cap would revisit the same 1000 rows every night and never reach a stranded item sorting past the cut. The scan now pages through every candidate (four columns per row) and maxItems bounds the WORK: at most that many unlinked (or unreadable) items are propagated per run; already-anchored, anchored-elsewhere and locked items are counted from the pre-state without a propagation or budget. Items past the budget are counted as deferred and truncated is logged at warn level. Findings 2, 5 (false "linked automatically" promise for locked periods): resolveUnderlagAnchoring reads the fiscal period lock state of the verifikat for every unlinked item and reports unlinked_locked when is_closed or locked_at is set, the same pair enforce_period_lock_documents checks. The reconciler counts it separately (unlinkedLocked), never propagates it and never warns "still unlinked after re-run"; the rail shows a message that says the period must be unlocked first. Findings 4, 7 (absent anchoring read as booked): the list and detail enrichment emit underlag_status 'unknown' when the helper could not read the document row, and the workspace treats any status but 'anchored' as divergent (stays in Att göra, no booking bridge, own message). classify() counts a repair only when the pre-state was explicitly unlinked, so an unreadable before-read never earns an InboxUnderlagReconciled event. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015nAd8XJ2RPCmG2eKoLBdna * fix(invoice-inbox): address round-2 review findings (#1548) 1. [minor] Round-1 fix dropped propagation for transactions whose inbox items already read anchored, so the pinned-document leg (transactions.document_id) was never repaired and settled items never received their created_journal_entry_id stamp, staying in the scan and inflating alreadyAnchored every night. reconcileCompany now propagates every stranded transaction that has an unlinked (budgeted) item or an anchored / document-less item, outside the maxItems budget: the helper is idempotent and the stamp shrinks its own population. Locked-only and anchored-elsewhere-only transactions stay skipped. Counting and the behandlingshistorik trail are unchanged (anchored items keep their pre-state verdict, no event). Tests updated and a new case pins the anchored-item plus document-less-item transaction: propagated, no after-read, no history. DECISIONS line amended. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015nAd8XJ2RPCmG2eKoLBdna --------- 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
ad8566f1ae
commit
a4ceaafa4f
@@ -0,0 +1,441 @@
|
||||
import { describe, it, expect, beforeEach, vi } from 'vitest'
|
||||
import { createQueuedMockSupabase } from '@/tests/helpers'
|
||||
import type { SupabaseClient } from '@supabase/supabase-js'
|
||||
|
||||
// The reconciler orchestrates the shared underlag helpers; those are covered
|
||||
// in inbox-underlag.test.ts, so here they are mocked and the run's own
|
||||
// logic is what is under test: grouping, dry-run vs execute, classification,
|
||||
// the history trail, the scan cap, and never throwing.
|
||||
const resolveBooked = vi.fn()
|
||||
const resolveAnchoring = vi.fn()
|
||||
const propagate = vi.fn()
|
||||
vi.mock('@/lib/transactions/inbox-underlag', () => ({
|
||||
resolveBookedJournalEntryIds: (...a: unknown[]) => resolveBooked(...a),
|
||||
resolveUnderlagAnchoring: (...a: unknown[]) => resolveAnchoring(...a),
|
||||
propagateUnderlagForBookedTransaction: (...a: unknown[]) => propagate(...a),
|
||||
}))
|
||||
|
||||
const appendHistory = vi.fn()
|
||||
vi.mock('@/lib/processing-history/append', () => ({
|
||||
appendProcessingHistoryWithClient: (...a: unknown[]) => appendHistory(...a),
|
||||
}))
|
||||
|
||||
import {
|
||||
reconcileStrandedInboxUnderlag,
|
||||
INBOX_UNDERLAG_RECONCILED_EVENT,
|
||||
} from '../inbox-underlag-reconcile'
|
||||
|
||||
const C1 = 'company-1'
|
||||
const C2 = 'company-2'
|
||||
const TX1 = 'tx-1'
|
||||
const TX2 = 'tx-2'
|
||||
const TX3 = 'tx-3'
|
||||
const JE1 = 'je-1'
|
||||
const JE2 = 'je-2'
|
||||
|
||||
function item(id: string, company: string, tx: string, doc: string | null = `doc-${id}`) {
|
||||
return { id, company_id: company, matched_transaction_id: tx, document_id: doc }
|
||||
}
|
||||
|
||||
function anchoring(
|
||||
entries: Record<string, 'anchored' | 'unlinked' | 'unlinked_locked' | 'anchored_elsewhere'>,
|
||||
) {
|
||||
return new Map(
|
||||
Object.entries(entries).map(([id, status]) => [
|
||||
id,
|
||||
{ status, document_journal_entry_id: status === 'anchored_elsewhere' ? 'je-other' : null },
|
||||
]),
|
||||
)
|
||||
}
|
||||
|
||||
const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), child: vi.fn() }
|
||||
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks()
|
||||
propagate.mockResolvedValue(undefined)
|
||||
appendHistory.mockResolvedValue('event-1')
|
||||
})
|
||||
|
||||
describe('reconcileStrandedInboxUnderlag', () => {
|
||||
it('dry-run classifies without writing and counts stranded items', async () => {
|
||||
const { supabase, enqueue, findCalls } = createQueuedMockSupabase()
|
||||
enqueue({ data: [item('i1', C1, TX1), item('i2', C1, TX2), item('i3', C1, TX3)] })
|
||||
// TX3 is not booked: its item is scanned but not stranded.
|
||||
resolveBooked.mockResolvedValue(new Map([[TX1, JE1], [TX2, JE2]]))
|
||||
resolveAnchoring.mockResolvedValue(anchoring({ i1: 'unlinked', i2: 'anchored_elsewhere' }))
|
||||
|
||||
const summary = await reconcileStrandedInboxUnderlag(supabase as unknown as SupabaseClient, {
|
||||
execute: false,
|
||||
log: log as never,
|
||||
})
|
||||
|
||||
expect(summary).toMatchObject({
|
||||
execute: false,
|
||||
scanned: 3,
|
||||
truncated: false,
|
||||
strandedOnBooked: 2,
|
||||
repaired: 0,
|
||||
stillUnlinked: 1,
|
||||
anchoredElsewhere: 1,
|
||||
companiesTouched: 1,
|
||||
historyAppended: 0,
|
||||
failures: 0,
|
||||
})
|
||||
expect(propagate).not.toHaveBeenCalled()
|
||||
expect(appendHistory).not.toHaveBeenCalled()
|
||||
expect(resolveAnchoring).toHaveBeenCalledTimes(1)
|
||||
expect(resolveAnchoring).toHaveBeenCalledWith(expect.anything(), C1, [
|
||||
{ id: 'i1', document_id: 'doc-i1', journalEntryId: JE1 },
|
||||
{ id: 'i2', document_id: 'doc-i2', journalEntryId: JE2 },
|
||||
])
|
||||
expect(findCalls('invoice_inbox_items', 'update')).toEqual([])
|
||||
})
|
||||
|
||||
it('execute propagates unlinked and anchored transactions but logs history only for repaired ones', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
// Two items on TX1 (a samlingsverifikat) and one on TX2.
|
||||
enqueue({ data: [item('i1', C1, TX1), item('i2', C1, TX1), item('i3', C1, TX2)] })
|
||||
resolveBooked.mockResolvedValue(new Map([[TX1, JE1], [TX2, JE2]]))
|
||||
resolveAnchoring
|
||||
.mockResolvedValueOnce(anchoring({ i1: 'unlinked', i2: 'anchored', i3: 'anchored' })) // before
|
||||
.mockResolvedValueOnce(anchoring({ i1: 'anchored' })) // after, only the linked item is re-read
|
||||
|
||||
const summary = await reconcileStrandedInboxUnderlag(supabase as unknown as SupabaseClient, {
|
||||
execute: true,
|
||||
log: log as never,
|
||||
actorId: 'test-actor',
|
||||
})
|
||||
|
||||
// TX2's item was already anchored, so its link is settled, but the
|
||||
// propagation still runs for the legs only it covers (the transaction's
|
||||
// pinned document, the created_journal_entry_id stamp); only TX1's
|
||||
// unlinked item is re-read afterwards.
|
||||
expect(propagate).toHaveBeenCalledTimes(2)
|
||||
expect(propagate).toHaveBeenCalledWith(expect.anything(), C1, TX1, JE1)
|
||||
expect(propagate).toHaveBeenCalledWith(expect.anything(), C1, TX2, JE2)
|
||||
expect(resolveAnchoring).toHaveBeenCalledTimes(2)
|
||||
expect(resolveAnchoring).toHaveBeenNthCalledWith(2, expect.anything(), C1, [
|
||||
{ id: 'i1', document_id: 'doc-i1', journalEntryId: JE1 },
|
||||
])
|
||||
expect(summary).toMatchObject({
|
||||
strandedOnBooked: 3,
|
||||
repaired: 1,
|
||||
alreadyAnchored: 2,
|
||||
stillUnlinked: 0,
|
||||
anchoredElsewhere: 0,
|
||||
historyAppended: 1,
|
||||
failures: 0,
|
||||
})
|
||||
// Only TX1 changed linkage (i1); TX2's item was already anchored, so no
|
||||
// changelog row pretends a repair happened there.
|
||||
expect(appendHistory).toHaveBeenCalledTimes(1)
|
||||
expect(appendHistory).toHaveBeenCalledWith(
|
||||
expect.anything(),
|
||||
expect.objectContaining({
|
||||
companyId: C1,
|
||||
aggregateType: 'BankTransaction',
|
||||
aggregateId: TX1,
|
||||
correlationId: TX1,
|
||||
eventType: INBOX_UNDERLAG_RECONCILED_EVENT,
|
||||
payload: {
|
||||
transaction_id: TX1,
|
||||
journal_entry_id: JE1,
|
||||
inbox_item_ids: ['i1'],
|
||||
source: 'test-actor',
|
||||
},
|
||||
actor: { type: 'system', id: 'test-actor' },
|
||||
}),
|
||||
)
|
||||
})
|
||||
|
||||
it('counts a link that failed again as still unlinked and appends nothing', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: [item('i1', C1, TX1)] })
|
||||
resolveBooked.mockResolvedValue(new Map([[TX1, JE1]]))
|
||||
resolveAnchoring
|
||||
.mockResolvedValueOnce(anchoring({ i1: 'unlinked' }))
|
||||
.mockResolvedValueOnce(anchoring({ i1: 'unlinked' }))
|
||||
|
||||
const summary = await reconcileStrandedInboxUnderlag(supabase as unknown as SupabaseClient, {
|
||||
execute: true,
|
||||
log: log as never,
|
||||
})
|
||||
|
||||
expect(summary).toMatchObject({ repaired: 0, stillUnlinked: 1, historyAppended: 0 })
|
||||
expect(appendHistory).not.toHaveBeenCalled()
|
||||
expect(log.warn).toHaveBeenCalledWith(
|
||||
expect.stringContaining('still unlinked'),
|
||||
expect.objectContaining({ inbox_item_id: 'i1', transaction_id: TX1 }),
|
||||
)
|
||||
})
|
||||
|
||||
it('counts a document anchored to another verifikat as a conflict, greppable by its verifikat', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: [item('i1', C1, TX1)] })
|
||||
resolveBooked.mockResolvedValue(new Map([[TX1, JE1]]))
|
||||
// Settled from the pre-state alone: no propagation, no after-read.
|
||||
resolveAnchoring.mockResolvedValue(anchoring({ i1: 'anchored_elsewhere' }))
|
||||
|
||||
const summary = await reconcileStrandedInboxUnderlag(supabase as unknown as SupabaseClient, {
|
||||
execute: true,
|
||||
log: log as never,
|
||||
})
|
||||
|
||||
expect(summary).toMatchObject({ repaired: 0, anchoredElsewhere: 1, historyAppended: 0 })
|
||||
expect(propagate).not.toHaveBeenCalled()
|
||||
expect(resolveAnchoring).toHaveBeenCalledTimes(1)
|
||||
expect(appendHistory).not.toHaveBeenCalled()
|
||||
expect(log.warn).toHaveBeenCalledWith(
|
||||
expect.stringContaining('another verifikat'),
|
||||
expect.objectContaining({ inbox_item_id: 'i1', document_journal_entry_id: 'je-other' }),
|
||||
)
|
||||
})
|
||||
|
||||
it('treats an item the anchoring read could not classify as unlinked, never repaired', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: [item('i1', C1, TX1)] })
|
||||
resolveBooked.mockResolvedValue(new Map([[TX1, JE1]]))
|
||||
resolveAnchoring.mockResolvedValue(new Map())
|
||||
|
||||
const summary = await reconcileStrandedInboxUnderlag(supabase as unknown as SupabaseClient, {
|
||||
execute: true,
|
||||
log: log as never,
|
||||
})
|
||||
|
||||
expect(summary).toMatchObject({ repaired: 0, stillUnlinked: 1, historyAppended: 0 })
|
||||
})
|
||||
|
||||
it('groups per company and skips companies with no booked matches', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: [item('i1', C1, TX1), item('i2', C2, TX2)] })
|
||||
resolveBooked.mockImplementation(async (_s: unknown, companyId: string) =>
|
||||
companyId === C1 ? new Map([[TX1, JE1]]) : new Map(),
|
||||
)
|
||||
resolveAnchoring
|
||||
.mockResolvedValueOnce(anchoring({ i1: 'unlinked' }))
|
||||
.mockResolvedValueOnce(anchoring({ i1: 'anchored' }))
|
||||
|
||||
const summary = await reconcileStrandedInboxUnderlag(supabase as unknown as SupabaseClient, {
|
||||
execute: true,
|
||||
log: log as never,
|
||||
})
|
||||
|
||||
expect(resolveBooked).toHaveBeenCalledWith(expect.anything(), C1, [TX1])
|
||||
expect(resolveBooked).toHaveBeenCalledWith(expect.anything(), C2, [TX2])
|
||||
expect(summary).toMatchObject({ scanned: 2, strandedOnBooked: 1, companiesTouched: 1, repaired: 1 })
|
||||
expect(propagate).toHaveBeenCalledTimes(1)
|
||||
})
|
||||
|
||||
it('reads every candidate and spends maxItems on unlinked items only, deferring the rest', async () => {
|
||||
const { supabase, enqueue, findCalls } = createQueuedMockSupabase()
|
||||
// Six candidates: two already anchored, one anchored elsewhere, three
|
||||
// unlinked. A read cap would have stopped at the first rows; the link
|
||||
// budget (2) must reach past the settled ones and defer only the third
|
||||
// unlinked item.
|
||||
enqueue({
|
||||
data: [
|
||||
item('a1', C1, TX1),
|
||||
item('a2', C1, TX1),
|
||||
item('e1', C1, TX2),
|
||||
item('u1', C1, TX3),
|
||||
item('u2', C2, 'tx-4'),
|
||||
item('u3', C2, 'tx-5'),
|
||||
],
|
||||
})
|
||||
resolveBooked.mockImplementation(async (_s: unknown, companyId: string) =>
|
||||
companyId === C1
|
||||
? new Map([[TX1, JE1], [TX2, JE2], [TX3, 'je-3']])
|
||||
: new Map([['tx-4', 'je-4'], ['tx-5', 'je-5']]),
|
||||
)
|
||||
resolveAnchoring.mockImplementation(async (_s: unknown, companyId: string) =>
|
||||
companyId === C1
|
||||
? anchoring({ a1: 'anchored', a2: 'anchored', e1: 'anchored_elsewhere', u1: 'unlinked' })
|
||||
: anchoring({ u2: 'unlinked', u3: 'unlinked' }),
|
||||
)
|
||||
|
||||
const summary = await reconcileStrandedInboxUnderlag(supabase as unknown as SupabaseClient, {
|
||||
execute: true,
|
||||
maxItems: 2,
|
||||
log: log as never,
|
||||
})
|
||||
|
||||
expect(findCalls('invoice_inbox_items', 'range')).toEqual([[0, 999]])
|
||||
expect(summary).toMatchObject({
|
||||
scanned: 6,
|
||||
strandedOnBooked: 6,
|
||||
alreadyAnchored: 2,
|
||||
anchoredElsewhere: 1,
|
||||
deferred: 1,
|
||||
truncated: true,
|
||||
})
|
||||
// u1 and u2 got the budget; u3 waits for the next run, without a
|
||||
// misleading "still unlinked after re-run" line. TX1 (anchored items)
|
||||
// is propagated outside the budget for its pin and stamp legs; the
|
||||
// anchored-elsewhere conflict on TX2 is not.
|
||||
expect(propagate).toHaveBeenCalledTimes(3)
|
||||
expect(propagate).toHaveBeenCalledWith(expect.anything(), C1, TX1, JE1)
|
||||
expect(propagate).toHaveBeenCalledWith(expect.anything(), C1, TX3, 'je-3')
|
||||
expect(propagate).toHaveBeenCalledWith(expect.anything(), C2, 'tx-4', 'je-4')
|
||||
expect(propagate).not.toHaveBeenCalledWith(expect.anything(), C1, TX2, JE2)
|
||||
expect(propagate).not.toHaveBeenCalledWith(expect.anything(), C2, 'tx-5', 'je-5')
|
||||
expect(log.warn).toHaveBeenCalledWith(
|
||||
expect.stringContaining('link budget spent'),
|
||||
expect.objectContaining({ max_items: 2, deferred: 1 }),
|
||||
)
|
||||
})
|
||||
|
||||
it('pages through more than one page of candidates', async () => {
|
||||
const { supabase, enqueue, findCalls } = createQueuedMockSupabase()
|
||||
const firstPage = Array.from({ length: 1000 }, (_, i) => item(`p${i}`, C1, TX1))
|
||||
enqueue({ data: firstPage })
|
||||
enqueue({ data: [item('tail', C1, TX1)] })
|
||||
resolveBooked.mockResolvedValue(new Map())
|
||||
|
||||
const summary = await reconcileStrandedInboxUnderlag(supabase as unknown as SupabaseClient, {
|
||||
execute: false,
|
||||
log: log as never,
|
||||
})
|
||||
|
||||
expect(summary.scanned).toBe(1001)
|
||||
expect(summary.truncated).toBe(false)
|
||||
expect(findCalls('invoice_inbox_items', 'range')).toEqual([[0, 999], [1000, 1999]])
|
||||
})
|
||||
|
||||
it('still propagates a transaction whose only item is anchored so an unlinked pin is repaired', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
// i1's own document is anchored; i2 carries no document at all. Both
|
||||
// read 'anchored', but the transaction may still have a pinned document
|
||||
// (transactions.document_id) whose link failed earlier, and the items
|
||||
// still lack their stamp: only the propagation repairs those.
|
||||
enqueue({ data: [item('i1', C1, TX1), item('i2', C1, TX2, null)] })
|
||||
resolveBooked.mockResolvedValue(new Map([[TX1, JE1], [TX2, JE2]]))
|
||||
resolveAnchoring.mockResolvedValue(anchoring({ i1: 'anchored', i2: 'anchored' }))
|
||||
|
||||
const summary = await reconcileStrandedInboxUnderlag(supabase as unknown as SupabaseClient, {
|
||||
execute: true,
|
||||
maxItems: 0,
|
||||
log: log as never,
|
||||
})
|
||||
|
||||
// Outside the link budget (maxItems 0 still lets this run), no after-read
|
||||
// (the pre-state is the verdict) and no history: nothing this run can
|
||||
// vouch for changed the item's linkage.
|
||||
expect(propagate).toHaveBeenCalledTimes(2)
|
||||
expect(propagate).toHaveBeenCalledWith(expect.anything(), C1, TX1, JE1)
|
||||
expect(propagate).toHaveBeenCalledWith(expect.anything(), C1, TX2, JE2)
|
||||
expect(resolveAnchoring).toHaveBeenCalledTimes(1)
|
||||
expect(summary).toMatchObject({
|
||||
strandedOnBooked: 2,
|
||||
repaired: 0,
|
||||
alreadyAnchored: 2,
|
||||
deferred: 0,
|
||||
truncated: false,
|
||||
historyAppended: 0,
|
||||
})
|
||||
expect(appendHistory).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('counts a locked-period item separately, never propagates it, and appends nothing', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: [item('i1', C1, TX1)] })
|
||||
resolveBooked.mockResolvedValue(new Map([[TX1, JE1]]))
|
||||
resolveAnchoring.mockResolvedValue(anchoring({ i1: 'unlinked_locked' }))
|
||||
|
||||
const summary = await reconcileStrandedInboxUnderlag(supabase as unknown as SupabaseClient, {
|
||||
execute: true,
|
||||
log: log as never,
|
||||
})
|
||||
|
||||
expect(summary).toMatchObject({
|
||||
strandedOnBooked: 1,
|
||||
repaired: 0,
|
||||
stillUnlinked: 0,
|
||||
unlinkedLocked: 1,
|
||||
deferred: 0,
|
||||
truncated: false,
|
||||
historyAppended: 0,
|
||||
})
|
||||
// The link is known to fail (enforce_period_lock_documents): no
|
||||
// propagation, no budget spent, no daily "still unlinked" warning.
|
||||
expect(propagate).not.toHaveBeenCalled()
|
||||
expect(appendHistory).not.toHaveBeenCalled()
|
||||
expect(log.warn).toHaveBeenCalledWith(
|
||||
expect.stringContaining('locked period'),
|
||||
expect.objectContaining({ inbox_item_id: 'i1' }),
|
||||
)
|
||||
})
|
||||
|
||||
it('does not count an unreadable pre-state that reads anchored afterwards as repaired', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: [item('i1', C1, TX1)] })
|
||||
resolveBooked.mockResolvedValue(new Map([[TX1, JE1]]))
|
||||
resolveAnchoring
|
||||
.mockResolvedValueOnce(new Map()) // before: document row unreadable
|
||||
.mockResolvedValueOnce(anchoring({ i1: 'anchored' })) // after
|
||||
|
||||
const summary = await reconcileStrandedInboxUnderlag(supabase as unknown as SupabaseClient, {
|
||||
execute: true,
|
||||
log: log as never,
|
||||
})
|
||||
|
||||
// Unknown before is a reason to look (propagate), not evidence that this
|
||||
// run changed the linkage: no InboxUnderlagReconciled event.
|
||||
expect(propagate).toHaveBeenCalledTimes(1)
|
||||
expect(summary).toMatchObject({ repaired: 0, alreadyAnchored: 1, historyAppended: 0 })
|
||||
expect(appendHistory).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('returns a zero summary with one failure when the scan errors, without throwing', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: null, error: { message: 'connection reset' } })
|
||||
|
||||
const summary = await reconcileStrandedInboxUnderlag(supabase as unknown as SupabaseClient, {
|
||||
execute: true,
|
||||
log: log as never,
|
||||
})
|
||||
|
||||
expect(summary).toMatchObject({ scanned: 0, strandedOnBooked: 0, repaired: 0, failures: 1 })
|
||||
expect(propagate).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('counts a failing company and continues with the next one', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: [item('i1', C1, TX1), item('i2', C2, TX2)] })
|
||||
resolveBooked.mockImplementation(async (_s: unknown, companyId: string) => {
|
||||
if (companyId === C1) throw new Error('resolver blew up')
|
||||
return new Map([[TX2, JE2]])
|
||||
})
|
||||
resolveAnchoring
|
||||
.mockResolvedValueOnce(anchoring({ i2: 'unlinked' }))
|
||||
.mockResolvedValueOnce(anchoring({ i2: 'anchored' }))
|
||||
|
||||
const summary = await reconcileStrandedInboxUnderlag(supabase as unknown as SupabaseClient, {
|
||||
execute: true,
|
||||
log: log as never,
|
||||
})
|
||||
|
||||
expect(summary).toMatchObject({ failures: 1, companiesTouched: 1, repaired: 1 })
|
||||
expect(propagate).toHaveBeenCalledWith(expect.anything(), C2, TX2, JE2)
|
||||
})
|
||||
|
||||
it('keeps the repair when the history append fails', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: [item('i1', C1, TX1)] })
|
||||
resolveBooked.mockResolvedValue(new Map([[TX1, JE1]]))
|
||||
resolveAnchoring
|
||||
.mockResolvedValueOnce(anchoring({ i1: 'unlinked' }))
|
||||
.mockResolvedValueOnce(anchoring({ i1: 'anchored' }))
|
||||
appendHistory.mockRejectedValue(new Error('fk violation'))
|
||||
|
||||
const summary = await reconcileStrandedInboxUnderlag(supabase as unknown as SupabaseClient, {
|
||||
execute: true,
|
||||
log: log as never,
|
||||
})
|
||||
|
||||
expect(summary).toMatchObject({ repaired: 1, historyAppended: 0, failures: 0 })
|
||||
expect(log.error).toHaveBeenCalledWith(
|
||||
expect.stringContaining('processing_history append failed'),
|
||||
expect.objectContaining({ transaction_id: TX1 }),
|
||||
)
|
||||
})
|
||||
})
|
||||
@@ -10,6 +10,7 @@ import {
|
||||
completeInboxItemsForBookedTransaction,
|
||||
propagateUnderlagForBookedTransaction,
|
||||
resolveBookedJournalEntryIds,
|
||||
resolveUnderlagAnchoring,
|
||||
} from '../inbox-underlag'
|
||||
import { linkToJournalEntry } from '@/lib/core/documents/document-service'
|
||||
|
||||
@@ -356,3 +357,106 @@ describe('completeInboxItemsForBookedTransaction', () => {
|
||||
expect(findCalls('invoice_inbox_items', 'update')).toEqual([])
|
||||
})
|
||||
})
|
||||
|
||||
describe('resolveUnderlagAnchoring', () => {
|
||||
beforeEach(() => vi.clearAllMocks())
|
||||
|
||||
it('reads an item without a document as anchored, without querying', async () => {
|
||||
// No underlag to carry onto the verifikat: only the stamp is missing.
|
||||
const { supabase, calls } = createQueuedMockSupabase()
|
||||
const map = await resolveUnderlagAnchoring(supabase as unknown as SupabaseClient, COMPANY, [
|
||||
{ id: 'i1', document_id: null, journalEntryId: JE1 },
|
||||
])
|
||||
expect(map.get('i1')).toEqual({ status: 'anchored', document_journal_entry_id: null })
|
||||
expect(calls.length).toBe(0)
|
||||
})
|
||||
|
||||
it('classifies anchored, unlinked and anchored_elsewhere from one batched select', async () => {
|
||||
const { supabase, enqueue, findCalls } = createQueuedMockSupabase()
|
||||
enqueue({
|
||||
data: [
|
||||
{ id: 'doc-a', journal_entry_id: JE1 },
|
||||
{ id: 'doc-b', journal_entry_id: null },
|
||||
{ id: 'doc-c', journal_entry_id: JE2 },
|
||||
],
|
||||
})
|
||||
|
||||
const map = await resolveUnderlagAnchoring(supabase as unknown as SupabaseClient, COMPANY, [
|
||||
{ id: 'i-a', document_id: 'doc-a', journalEntryId: JE1 },
|
||||
{ id: 'i-b', document_id: 'doc-b', journalEntryId: JE1 },
|
||||
{ id: 'i-c', document_id: 'doc-c', journalEntryId: JE1 },
|
||||
{ id: 'i-none', document_id: null, journalEntryId: JE1 },
|
||||
])
|
||||
|
||||
expect(map.get('i-a')?.status).toBe('anchored')
|
||||
expect(map.get('i-b')?.status).toBe('unlinked')
|
||||
expect(map.get('i-c')).toEqual({ status: 'anchored_elsewhere', document_journal_entry_id: JE2 })
|
||||
expect(map.get('i-none')?.status).toBe('anchored')
|
||||
const selects = findCalls('document_attachments', 'select')
|
||||
expect(selects.length).toBe(1)
|
||||
expect(findCalls('document_attachments', 'in')).toEqual([['id', ['doc-a', 'doc-b', 'doc-c']]])
|
||||
})
|
||||
|
||||
it('reads an unlinked item whose verifikat sits in a locked or closed period as unlinked_locked', async () => {
|
||||
const { supabase, enqueue, findCalls } = createQueuedMockSupabase()
|
||||
enqueue({
|
||||
data: [
|
||||
{ id: 'doc-a', journal_entry_id: null },
|
||||
{ id: 'doc-b', journal_entry_id: null },
|
||||
{ id: 'doc-c', journal_entry_id: null },
|
||||
{ id: 'doc-d', journal_entry_id: JE1 },
|
||||
],
|
||||
})
|
||||
enqueue({
|
||||
data: [
|
||||
{ id: JE1, fiscal_period: { is_closed: false, locked_at: '2026-08-01T00:00:00Z' } },
|
||||
{ id: JE2, fiscal_period: { is_closed: true, locked_at: null } },
|
||||
{ id: 'je-open', fiscal_period: { is_closed: false, locked_at: null } },
|
||||
],
|
||||
})
|
||||
|
||||
const map = await resolveUnderlagAnchoring(supabase as unknown as SupabaseClient, COMPANY, [
|
||||
{ id: 'i-a', document_id: 'doc-a', journalEntryId: JE1 },
|
||||
{ id: 'i-b', document_id: 'doc-b', journalEntryId: JE2 },
|
||||
{ id: 'i-c', document_id: 'doc-c', journalEntryId: 'je-open' },
|
||||
{ id: 'i-d', document_id: 'doc-d', journalEntryId: JE1 },
|
||||
])
|
||||
|
||||
expect(map.get('i-a')).toEqual({ status: 'unlinked_locked', document_journal_entry_id: null })
|
||||
expect(map.get('i-b')).toEqual({ status: 'unlinked_locked', document_journal_entry_id: null })
|
||||
expect(map.get('i-c')?.status).toBe('unlinked')
|
||||
// Already anchored: the lock does not matter and it is not looked up.
|
||||
expect(map.get('i-d')?.status).toBe('anchored')
|
||||
expect(findCalls('journal_entries', 'in')).toEqual([['id', [JE1, JE2, 'je-open']]])
|
||||
})
|
||||
|
||||
it('keeps an unlinked item unlinked (retryable) when the lock-state read fails', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: [{ id: 'doc-a', journal_entry_id: null }] })
|
||||
enqueue({ data: null, error: { message: 'boom' } })
|
||||
const map = await resolveUnderlagAnchoring(supabase as unknown as SupabaseClient, COMPANY, [
|
||||
{ id: 'i-a', document_id: 'doc-a', journalEntryId: JE1 },
|
||||
])
|
||||
expect(map.get('i-a')?.status).toBe('unlinked')
|
||||
})
|
||||
|
||||
it('leaves items absent (unknown, not anchored) when the document read fails', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: null, error: { message: 'boom' } })
|
||||
const map = await resolveUnderlagAnchoring(supabase as unknown as SupabaseClient, COMPANY, [
|
||||
{ id: 'i-a', document_id: 'doc-a', journalEntryId: JE1 },
|
||||
{ id: 'i-none', document_id: null, journalEntryId: JE1 },
|
||||
])
|
||||
expect(map.has('i-a')).toBe(false)
|
||||
expect(map.get('i-none')?.status).toBe('anchored')
|
||||
})
|
||||
|
||||
it('leaves an item absent when its document row is not returned', async () => {
|
||||
const { supabase, enqueue } = createQueuedMockSupabase()
|
||||
enqueue({ data: [] })
|
||||
const map = await resolveUnderlagAnchoring(supabase as unknown as SupabaseClient, COMPANY, [
|
||||
{ id: 'i-a', document_id: 'doc-a', journalEntryId: JE1 },
|
||||
])
|
||||
expect(map.has('i-a')).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
@@ -0,0 +1,418 @@
|
||||
/**
|
||||
* Periodic reconciliation of inbox items stranded on booked transactions
|
||||
* (#1548, the follow-up to the 2026-08-12 "booked items stuck in Att göra"
|
||||
* fix).
|
||||
*
|
||||
* An item whose matched transaction is booked should have its document
|
||||
* anchored to that verifikat (BFL 5 kap 6-7 §) and, where the UNIQUE
|
||||
* created_journal_entry_id allows, carry the stamp. Two things leave an
|
||||
* item behind that only a re-run repairs or a human resolves:
|
||||
*
|
||||
* - transient: linkToJournalEntry failed at propagation time (a DB blip).
|
||||
* Re-running the same propagation links it.
|
||||
* - locked: the verifikat sits in a closed or locked period, so the link is
|
||||
* rejected by enforce_period_lock_documents every time. Counted, not
|
||||
* retried: only unlocking the period (or a human) resolves it.
|
||||
* - permanent: the item's document is already anchored to a DIFFERENT
|
||||
* verifikat. Never stolen; the run counts and logs it so it is visible
|
||||
* outside ad-hoc log greps, and the inbox keeps the item in "Att göra"
|
||||
* (underlag_status enrichment) until someone decides.
|
||||
*
|
||||
* The scan reads every matched, unconsumed item (cheap: four columns per
|
||||
* row) and bounds the WORK instead: at most `maxItems` unlinked items are
|
||||
* linked per run. Capping the read would starve the tail: healthy matched
|
||||
* items and samlingsverifikat siblings never leave the candidate set, so a
|
||||
* read cap keyed on id would revisit the same window every night.
|
||||
*
|
||||
* Transactions whose items already read anchored are still propagated,
|
||||
* outside the budget: the propagation also anchors the transaction's own
|
||||
* pinned document (transactions.document_id) and stamps
|
||||
* created_journal_entry_id on settled items so they leave the scan. That
|
||||
* leg is idempotent and shrinks its own population, so it needs no cap.
|
||||
*
|
||||
* This is the one implementation the daily cron
|
||||
* (app/api/extensions/invoice-inbox/underlag-reconcile/cron) and the manual
|
||||
* script (scripts/backfill-inbox-booked-underlag.ts) share. It never throws:
|
||||
* a failing company is counted and the rest of the run continues.
|
||||
*
|
||||
* Behandlingshistorik (BFNAR 2013:2 kap 8): a run that changed the
|
||||
* underlag-to-verifikat linkage appends one 'InboxUnderlagReconciled' event
|
||||
* per repaired transaction, distinguishing the repair from the original
|
||||
* booking. Only genuinely repaired transactions get an event: stamping an
|
||||
* already-anchored item is a display fast path, not a linkage change.
|
||||
*/
|
||||
import type { SupabaseClient } from '@supabase/supabase-js'
|
||||
import { appendProcessingHistoryWithClient } from '@/lib/processing-history/append'
|
||||
import { createLogger, type Logger } from '@/lib/logger'
|
||||
import {
|
||||
propagateUnderlagForBookedTransaction,
|
||||
resolveBookedJournalEntryIds,
|
||||
resolveUnderlagAnchoring,
|
||||
type UnderlagAnchoringResult,
|
||||
} from '@/lib/transactions/inbox-underlag'
|
||||
|
||||
/** Registered in processing_event_types by migration 20260828154800. */
|
||||
export const INBOX_UNDERLAG_RECONCILED_EVENT = 'InboxUnderlagReconciled'
|
||||
|
||||
/** Default actor id in behandlingshistorik when the caller names none. */
|
||||
export const DEFAULT_RECONCILE_ACTOR_ID = 'inbox-underlag-reconcile'
|
||||
|
||||
/** Link budget per run (unlinked items linked) so a scheduled pass stays bounded. */
|
||||
export const DEFAULT_RECONCILE_MAX_ITEMS = 1000
|
||||
|
||||
const PAGE_SIZE = 1000
|
||||
|
||||
export interface ReconcileStrandedInboxUnderlagOptions {
|
||||
/** false: classify only, no writes (the script's dry-run). */
|
||||
execute: boolean
|
||||
/** Link at most this many unlinked items per run (default 1000); the rest wait for the next run. */
|
||||
maxItems?: number
|
||||
log?: Logger
|
||||
/** Who the behandlingshistorik event is attributed to. */
|
||||
actorId?: string
|
||||
}
|
||||
|
||||
export interface ReconcileStrandedInboxUnderlagSummary {
|
||||
execute: boolean
|
||||
/** Matched, unconsumed items read (across all companies, uncapped). */
|
||||
scanned: number
|
||||
/** True when more unlinked items existed than maxItems allowed this run to link. */
|
||||
truncated: boolean
|
||||
/** Scanned items whose matched transaction resolves as booked. */
|
||||
strandedOnBooked: number
|
||||
/** execute only: items whose underlag was unlinked before and anchored after this run. */
|
||||
repaired: number
|
||||
/** Items whose underlag already referenced the verifikat (only the stamp was missing). */
|
||||
alreadyAnchored: number
|
||||
/**
|
||||
* Items whose underlag references no verifikat. execute: the link failed
|
||||
* again this run (transient, retried next run). dry-run: what a run would
|
||||
* link.
|
||||
*/
|
||||
stillUnlinked: number
|
||||
/** Unlinked items whose verifikat sits in a locked/closed period: the link cannot land until it is unlocked. */
|
||||
unlinkedLocked: number
|
||||
/** Unlinked items left for the next run because this run's link budget (maxItems) was spent. */
|
||||
deferred: number
|
||||
/** Items whose document is anchored to another verifikat: a human decision. */
|
||||
anchoredElsewhere: number
|
||||
companiesTouched: number
|
||||
/** 'InboxUnderlagReconciled' events written (one per repaired transaction). */
|
||||
historyAppended: number
|
||||
/** Companies (or the initial scan) that threw; the run continued past them. */
|
||||
failures: number
|
||||
}
|
||||
|
||||
interface StrandedItem {
|
||||
id: string
|
||||
company_id: string
|
||||
matched_transaction_id: string
|
||||
document_id: string | null
|
||||
}
|
||||
|
||||
function emptySummary(execute: boolean): ReconcileStrandedInboxUnderlagSummary {
|
||||
return {
|
||||
execute,
|
||||
scanned: 0,
|
||||
truncated: false,
|
||||
strandedOnBooked: 0,
|
||||
repaired: 0,
|
||||
alreadyAnchored: 0,
|
||||
stillUnlinked: 0,
|
||||
unlinkedLocked: 0,
|
||||
deferred: 0,
|
||||
anchoredElsewhere: 0,
|
||||
companiesTouched: 0,
|
||||
historyAppended: 0,
|
||||
failures: 0,
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The backfill script's query: matched to a transaction, consumed by neither
|
||||
* a journal entry nor a supplier invoice. Ordered by id for stable paging
|
||||
* and read in full: the per-run bound is on links, not on rows read.
|
||||
*/
|
||||
async function fetchStrandedCandidates(supabase: SupabaseClient): Promise<StrandedItem[]> {
|
||||
const rows: StrandedItem[] = []
|
||||
let from = 0
|
||||
for (;;) {
|
||||
const to = from + PAGE_SIZE - 1
|
||||
const { data, error } = await supabase
|
||||
.from('invoice_inbox_items')
|
||||
.select('id, company_id, matched_transaction_id, document_id')
|
||||
.not('matched_transaction_id', 'is', null)
|
||||
.is('created_journal_entry_id', null)
|
||||
.is('created_supplier_invoice_id', null)
|
||||
.order('id', { ascending: true })
|
||||
.range(from, to)
|
||||
if (error) throw new Error(error.message)
|
||||
const page = (data ?? []) as StrandedItem[]
|
||||
rows.push(...page)
|
||||
if (page.length < PAGE_SIZE) break
|
||||
from = to + 1
|
||||
}
|
||||
return rows
|
||||
}
|
||||
|
||||
export async function reconcileStrandedInboxUnderlag(
|
||||
supabase: SupabaseClient,
|
||||
opts: ReconcileStrandedInboxUnderlagOptions,
|
||||
): Promise<ReconcileStrandedInboxUnderlagSummary> {
|
||||
const log = opts.log ?? createLogger('transactions/inbox-underlag-reconcile')
|
||||
const maxItems = opts.maxItems ?? DEFAULT_RECONCILE_MAX_ITEMS
|
||||
const actorId = opts.actorId ?? DEFAULT_RECONCILE_ACTOR_ID
|
||||
const summary = emptySummary(opts.execute)
|
||||
|
||||
let candidates: StrandedItem[]
|
||||
try {
|
||||
candidates = await fetchStrandedCandidates(supabase)
|
||||
} catch (err) {
|
||||
log.error('inbox underlag reconcile: failed to read matched inbox items', {
|
||||
error: err instanceof Error ? err.message : String(err),
|
||||
})
|
||||
summary.failures++
|
||||
return summary
|
||||
}
|
||||
summary.scanned = candidates.length
|
||||
|
||||
// Group per company so the resolvers run one batched lookup per tenant.
|
||||
const byCompany = new Map<string, StrandedItem[]>()
|
||||
for (const item of candidates) {
|
||||
const list = byCompany.get(item.company_id) ?? []
|
||||
list.push(item)
|
||||
byCompany.set(item.company_id, list)
|
||||
}
|
||||
|
||||
const run = { execute: opts.execute, actorId, log, summary, budget: maxItems }
|
||||
for (const [companyId, companyItems] of byCompany) {
|
||||
try {
|
||||
await reconcileCompany(supabase, companyId, companyItems, run)
|
||||
} catch (err) {
|
||||
summary.failures++
|
||||
log.error('inbox underlag reconcile: company failed', {
|
||||
company_id: companyId,
|
||||
error: err instanceof Error ? err.message : String(err),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
if (summary.truncated) {
|
||||
log.warn('inbox underlag reconcile: link budget spent; unlinked items deferred to the next run', {
|
||||
max_items: maxItems,
|
||||
deferred: summary.deferred,
|
||||
})
|
||||
}
|
||||
|
||||
return summary
|
||||
}
|
||||
|
||||
/** Per-run state shared by every company: the counters and the remaining link budget. */
|
||||
interface RunState {
|
||||
execute: boolean
|
||||
actorId: string
|
||||
log: Logger
|
||||
summary: ReconcileStrandedInboxUnderlagSummary
|
||||
/** Unlinked items this run may still propagate; decremented as work is claimed. */
|
||||
budget: number
|
||||
}
|
||||
|
||||
/** Whether an item needs (and may benefit from) a propagation: unlinked, or unreadable. */
|
||||
function needsLink(before: UnderlagAnchoringResult | undefined): boolean {
|
||||
return before === undefined || before.status === 'unlinked'
|
||||
}
|
||||
|
||||
async function reconcileCompany(
|
||||
supabase: SupabaseClient,
|
||||
companyId: string,
|
||||
companyItems: StrandedItem[],
|
||||
run: RunState,
|
||||
): Promise<void> {
|
||||
const { summary, log } = run
|
||||
const txIds = Array.from(new Set(companyItems.map((i) => i.matched_transaction_id)))
|
||||
const bookedByTx = await resolveBookedJournalEntryIds(supabase, companyId, txIds)
|
||||
const stranded = companyItems.filter((i) => bookedByTx.has(i.matched_transaction_id))
|
||||
if (stranded.length === 0) return
|
||||
|
||||
summary.companiesTouched++
|
||||
summary.strandedOnBooked += stranded.length
|
||||
|
||||
const anchoringInput = stranded.map((i) => ({
|
||||
id: i.id,
|
||||
document_id: i.document_id,
|
||||
journalEntryId: bookedByTx.get(i.matched_transaction_id) as string,
|
||||
}))
|
||||
const before = await resolveUnderlagAnchoring(supabase, companyId, anchoringInput)
|
||||
|
||||
// Only unlinked (or unreadable) items claim budget. Already-anchored
|
||||
// siblings, anchored-elsewhere conflicts and locked periods are counted
|
||||
// straight from the pre-state: re-linking them would either no-op or
|
||||
// fail identically, and letting them consume the budget is what would
|
||||
// starve the real work.
|
||||
const toLink = new Set<string>()
|
||||
for (const item of stranded) {
|
||||
if (!needsLink(before.get(item.id))) continue
|
||||
if (run.budget <= 0) {
|
||||
summary.deferred++
|
||||
summary.truncated = true
|
||||
continue
|
||||
}
|
||||
run.budget--
|
||||
toLink.add(item.id)
|
||||
}
|
||||
|
||||
if (!run.execute) {
|
||||
for (const item of stranded) {
|
||||
if (summaryDeferred(item, before, toLink)) continue
|
||||
classify(item, before.get(item.id), null, run, companyId)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Propagate every transaction with link work, plus every transaction
|
||||
// whose items already read anchored (or carry no document). The helper is
|
||||
// idempotent and does two more things than the item link that only it
|
||||
// can do: anchor the transaction's own pinned document
|
||||
// (transactions.document_id, which no inbox item carries) and stamp
|
||||
// created_journal_entry_id on settled items so they leave this scan.
|
||||
// Neither claims budget: the stamp is what shrinks the candidate set, so
|
||||
// this leg is self-limiting. Transactions whose items are all locked or
|
||||
// anchored elsewhere are still skipped: the link would fail identically,
|
||||
// and the conflict is a human decision.
|
||||
const txIdsToComplete = new Set<string>()
|
||||
for (const item of stranded) {
|
||||
if (toLink.has(item.id) || before.get(item.id)?.status === 'anchored') {
|
||||
txIdsToComplete.add(item.matched_transaction_id)
|
||||
}
|
||||
}
|
||||
for (const txId of txIdsToComplete) {
|
||||
const journalEntryId = bookedByTx.get(txId)
|
||||
if (!journalEntryId) continue
|
||||
await propagateUnderlagForBookedTransaction(supabase, companyId, txId, journalEntryId)
|
||||
}
|
||||
|
||||
const after =
|
||||
toLink.size > 0
|
||||
? await resolveUnderlagAnchoring(
|
||||
supabase,
|
||||
companyId,
|
||||
anchoringInput.filter((i) => toLink.has(i.id)),
|
||||
)
|
||||
: new Map<string, UnderlagAnchoringResult>()
|
||||
const repairedByTx = new Map<string, string[]>()
|
||||
for (const item of stranded) {
|
||||
if (summaryDeferred(item, before, toLink)) continue
|
||||
// Items outside this run's link work keep their pre-state verdict.
|
||||
const verdict = toLink.has(item.id) ? after.get(item.id) : before.get(item.id)
|
||||
const repaired = classify(item, before.get(item.id), verdict, run, companyId)
|
||||
if (repaired) {
|
||||
const list = repairedByTx.get(item.matched_transaction_id) ?? []
|
||||
list.push(item.id)
|
||||
repairedByTx.set(item.matched_transaction_id, list)
|
||||
}
|
||||
}
|
||||
|
||||
for (const [txId, itemIds] of repairedByTx) {
|
||||
const journalEntryId = bookedByTx.get(txId) as string
|
||||
try {
|
||||
await appendProcessingHistoryWithClient(supabase, {
|
||||
companyId,
|
||||
correlationId: txId,
|
||||
aggregateType: 'BankTransaction',
|
||||
aggregateId: txId,
|
||||
eventType: INBOX_UNDERLAG_RECONCILED_EVENT,
|
||||
payload: {
|
||||
transaction_id: txId,
|
||||
journal_entry_id: journalEntryId,
|
||||
inbox_item_ids: itemIds,
|
||||
source: run.actorId,
|
||||
},
|
||||
actor: { type: 'system', id: run.actorId },
|
||||
occurredAt: new Date(),
|
||||
})
|
||||
summary.historyAppended++
|
||||
} catch (err) {
|
||||
// The repair itself is done; a missing changelog row is a logged gap,
|
||||
// not a reason to fail the run.
|
||||
log.error('inbox underlag reconcile: processing_history append failed', {
|
||||
company_id: companyId,
|
||||
transaction_id: txId,
|
||||
error: err instanceof Error ? err.message : String(err),
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** True for an item that needed a link but fell outside this run's budget (already counted as deferred). */
|
||||
function summaryDeferred(
|
||||
item: StrandedItem,
|
||||
before: Map<string, UnderlagAnchoringResult>,
|
||||
toLink: Set<string>,
|
||||
): boolean {
|
||||
return needsLink(before.get(item.id)) && !toLink.has(item.id)
|
||||
}
|
||||
|
||||
/**
|
||||
* Count one item into the summary. `after` is null on a dry-run (the
|
||||
* pre-state is the verdict). Returns true when this run linked the
|
||||
* underlag: explicitly unlinked before, anchored after. An unreadable
|
||||
* pre-state that reads anchored afterwards is not a repair this run can
|
||||
* vouch for, so it earns no behandlingshistorik event.
|
||||
*/
|
||||
function classify(
|
||||
item: StrandedItem,
|
||||
before: UnderlagAnchoringResult | undefined,
|
||||
after: UnderlagAnchoringResult | null | undefined,
|
||||
run: { execute: boolean; log: Logger; summary: ReconcileStrandedInboxUnderlagSummary },
|
||||
companyId: string,
|
||||
): boolean {
|
||||
const { summary, log } = run
|
||||
// An unreadable document row is unknown, never settled: it stays counted
|
||||
// as unlinked so the next run looks again.
|
||||
const verdict = (run.execute ? after : before) ?? {
|
||||
status: 'unlinked' as const,
|
||||
document_journal_entry_id: null,
|
||||
}
|
||||
const context = {
|
||||
company_id: companyId,
|
||||
inbox_item_id: item.id,
|
||||
transaction_id: item.matched_transaction_id,
|
||||
document_id: item.document_id,
|
||||
}
|
||||
switch (verdict.status) {
|
||||
case 'anchored': {
|
||||
if (
|
||||
run.execute &&
|
||||
(before?.status === 'unlinked' || before?.status === 'unlinked_locked')
|
||||
) {
|
||||
summary.repaired++
|
||||
return true
|
||||
}
|
||||
summary.alreadyAnchored++
|
||||
return false
|
||||
}
|
||||
case 'unlinked': {
|
||||
summary.stillUnlinked++
|
||||
log.warn(
|
||||
run.execute
|
||||
? 'inbox underlag reconcile: document still unlinked after re-run'
|
||||
: 'inbox underlag reconcile: document unlinked (would link)',
|
||||
context,
|
||||
)
|
||||
return false
|
||||
}
|
||||
case 'unlinked_locked': {
|
||||
summary.unlinkedLocked++
|
||||
log.warn('inbox underlag reconcile: document unlinked and its verifikat sits in a locked period; unlock to link', context)
|
||||
return false
|
||||
}
|
||||
case 'anchored_elsewhere': {
|
||||
summary.anchoredElsewhere++
|
||||
log.warn('inbox underlag reconcile: document anchored to another verifikat; needs a human', {
|
||||
...context,
|
||||
document_journal_entry_id: verdict.document_journal_entry_id,
|
||||
})
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -120,6 +120,136 @@ export async function resolveVoucherLinkedEntryIds(
|
||||
return map
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether an inbox item's underlag actually references the verifikat that
|
||||
* booked its transaction. Both readers of "this item is booked" need it:
|
||||
*
|
||||
* - the inbox list enrichment, so an item whose document never reached the
|
||||
* verifikat (a failed link, or a document anchored to a DIFFERENT
|
||||
* verifikat) keeps showing in "Att göra" instead of reading as booked on
|
||||
* the transaction's word alone (#1548)
|
||||
* - the reconciliation pass, to classify what a re-run repaired and what
|
||||
* still needs a human
|
||||
*
|
||||
* 'anchored' : document_attachments.journal_entry_id equals the
|
||||
* verifikat, or the item carries no document (there
|
||||
* is no underlag to link; the stamp is all that is
|
||||
* missing)
|
||||
* 'unlinked' : the document references no verifikat yet
|
||||
* (transient: a re-run of the propagation links it)
|
||||
* 'unlinked_locked' : unlinked, and the verifikat sits in a closed or
|
||||
* locked period, so enforce_period_lock_documents
|
||||
* rejects the link until someone unlocks the period
|
||||
* (not transient: a re-run fails the same way)
|
||||
* 'anchored_elsewhere' : the document references another verifikat
|
||||
* (permanent: never stolen, a human decides)
|
||||
*
|
||||
* One batched select for N items, plus one lock-state read for the verifikat
|
||||
* of every unlinked item. Items whose document row cannot be read (select
|
||||
* error) are absent from the map: callers treat absence as unknown, never as
|
||||
* anchored. A failed lock-state read leaves the item 'unlinked' (the
|
||||
* propagation is what fails safely, so erring towards "retry" is harmless).
|
||||
*/
|
||||
export type UnderlagAnchoring = 'anchored' | 'unlinked' | 'unlinked_locked' | 'anchored_elsewhere'
|
||||
|
||||
export interface UnderlagAnchoringResult {
|
||||
status: UnderlagAnchoring
|
||||
/** The verifikat the document currently references, if any. */
|
||||
document_journal_entry_id: string | null
|
||||
}
|
||||
|
||||
export async function resolveUnderlagAnchoring(
|
||||
supabase: SupabaseClient,
|
||||
companyId: string,
|
||||
items: Array<{ id: string; document_id: string | null; journalEntryId: string }>,
|
||||
): Promise<Map<string, UnderlagAnchoringResult>> {
|
||||
const map = new Map<string, UnderlagAnchoringResult>()
|
||||
const withDocument: typeof items = []
|
||||
for (const item of items) {
|
||||
if (item.document_id) withDocument.push(item)
|
||||
else map.set(item.id, { status: 'anchored', document_journal_entry_id: null })
|
||||
}
|
||||
if (withDocument.length === 0) return map
|
||||
|
||||
const docIds = Array.from(new Set(withDocument.map((i) => i.document_id as string)))
|
||||
const { data: docs, error } = await supabase
|
||||
.from('document_attachments')
|
||||
.select('id, journal_entry_id')
|
||||
.in('id', docIds)
|
||||
.eq('company_id', companyId)
|
||||
if (error) {
|
||||
log.error('Failed to resolve document anchoring for inbox items', {
|
||||
company_id: companyId,
|
||||
error: error.message,
|
||||
})
|
||||
return map
|
||||
}
|
||||
const entryByDoc = new Map<string, string | null>()
|
||||
for (const doc of (docs ?? []) as Array<{ id: string; journal_entry_id: string | null }>) {
|
||||
entryByDoc.set(doc.id, doc.journal_entry_id)
|
||||
}
|
||||
const unlinked: typeof items = []
|
||||
for (const item of withDocument) {
|
||||
const docId = item.document_id as string
|
||||
if (!entryByDoc.has(docId)) continue // unreadable row: unknown, not anchored
|
||||
const current = entryByDoc.get(docId) ?? null
|
||||
const status: UnderlagAnchoring =
|
||||
current === null
|
||||
? 'unlinked'
|
||||
: current === item.journalEntryId
|
||||
? 'anchored'
|
||||
: 'anchored_elsewhere'
|
||||
if (status === 'unlinked') unlinked.push(item)
|
||||
map.set(item.id, { status, document_journal_entry_id: current })
|
||||
}
|
||||
if (unlinked.length === 0) return map
|
||||
|
||||
const lockedEntryIds = await resolveLockedJournalEntryIds(
|
||||
supabase,
|
||||
companyId,
|
||||
Array.from(new Set(unlinked.map((i) => i.journalEntryId))),
|
||||
)
|
||||
for (const item of unlinked) {
|
||||
if (lockedEntryIds.has(item.journalEntryId)) {
|
||||
map.set(item.id, { status: 'unlinked_locked', document_journal_entry_id: null })
|
||||
}
|
||||
}
|
||||
return map
|
||||
}
|
||||
|
||||
/**
|
||||
* Which of the given verifikat sit in a closed or locked fiscal period: the
|
||||
* same (is_closed, locked_at) pair enforce_period_lock_documents checks, so
|
||||
* a document link to them is known to fail before it is attempted. A read
|
||||
* error yields an empty set (nothing is reported as locked on a guess).
|
||||
*/
|
||||
async function resolveLockedJournalEntryIds(
|
||||
supabase: SupabaseClient,
|
||||
companyId: string,
|
||||
entryIds: string[],
|
||||
): Promise<Set<string>> {
|
||||
const locked = new Set<string>()
|
||||
if (entryIds.length === 0) return locked
|
||||
const { data, error } = await supabase
|
||||
.from('journal_entries')
|
||||
.select('id, fiscal_period:fiscal_periods(is_closed, locked_at)')
|
||||
.in('id', entryIds)
|
||||
.eq('company_id', companyId)
|
||||
if (error) {
|
||||
log.error('Failed to resolve period lock state for inbox underlag anchoring', {
|
||||
company_id: companyId,
|
||||
error: error.message,
|
||||
})
|
||||
return locked
|
||||
}
|
||||
type PeriodLock = { is_closed?: boolean | null; locked_at?: string | null }
|
||||
for (const row of (data ?? []) as Array<{ id: string; fiscal_period: PeriodLock | PeriodLock[] | null }>) {
|
||||
const period = Array.isArray(row.fiscal_period) ? row.fiscal_period[0] : row.fiscal_period
|
||||
if (period?.is_closed || period?.locked_at) locked.add(row.id)
|
||||
}
|
||||
return locked
|
||||
}
|
||||
|
||||
/**
|
||||
* Anchor one document to the verifikat, with the guard semantics every
|
||||
* booking path shares: a document already pointing at THIS verifikat is a
|
||||
|
||||
Reference in New Issue
Block a user