fix(reports): periodisk sammanställning nets a stornoed or corrected EU invoice voucher (#2354)
* fix(reports): periodisk sammanställning nets a stornoed or corrected EU invoice voucher (#2351) The PS reads entries with status posted or reversed, so a stornoed EU invoice voucher kept its 3308/3108 credit while the storno that nets it was dropped: its source_type is 'storno' and no register row points at it. A makulerad EU sale was over-reported while the account-based ruta 39 was zero. Which invoice explains an entry is now resolved by one composed helper, getInvoicesExplainingJournalEntries (lib/core/bookkeeping/ journal-entry-references.ts): the engine's own source_id, the invoice-side rows, and the rättelse chain through correction_of_id / reverses_id, walked upwards under the MAX_CHAIN_WALK cap correction-chain.ts already uses. Parents outside the batch are fetched by id, company-scoped. The link columns are followed rather than the storno's copied source_id because correctEntry() copies none onto its storno or correction, and a storno's copied source_id is polymorphic (a bank row on a bank booking). getInvoiceReferencesForJournalEntries (the RPC mirror behind the underlag surfaces) is unchanged: storno and correction are not doc-requiring source types, so those surfaces have no such hole. - INVOICE_SOURCED_ENTRY_TYPES / LINK_LOOKUP_CHUNK move to the helper module (the set now names every engine type whose source_id is an invoice). - PS: one resolver call; reverses_id, correction_of_id in the select; the ZERO_NET_EXCLUDED text names makulering beside kreditfaktura. - Tests: resolver cases (chain inheritance, out-of-batch fetch, own link wins, mirror, cycle, cap) and PS cases (the issue's storno nets to ZERO_NET_EXCLUDED, rättelse chain, later-period storno, mirror, linked import, gone invoice). Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LvMaHcTnwAfxzgYD1fGYX1 * fix(bookkeeping): PR #2354 review: bound in-batch chain propagation at MAX_CHAIN_WALK getInvoicesExplainingJournalEntries attributed an in-batch chain of stornos/corrections all the way down through a recursive assign over waitingOn, while parents fetched from outside the batch stopped at MAX_CHAIN_WALK. The two paths now agree: every attribution carries its depth from the root (0 for an entry resolved by its own source_id or invoice-side link), propagation is an explicit queue instead of recursion, and a descendant more than MAX_CHAIN_WALK links below the root resolves to no invoice, both when it inherits from an already attributed parent and when it is reached by propagation. Test: an in-batch chain of MAX_CHAIN_WALK + 1 links, in both batch orders, attributes the links within the cap and not the one beyond it, with no parent fetch. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> --------- Co-authored-by: Jakob Wennberg <311770904+jakobwennberg-oss@users.noreply.github.com> Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
Jakob Wennberg
co-authored by
Claude Fable 5.1
Jakob Wennberg
Claude Fable 5.1
Jakob Wennberg
parent
6a5fd6cd00
commit
4bc007cdeb
@@ -2,9 +2,13 @@ import { describe, it, expect } from 'vitest'
|
||||
import type { SupabaseClient } from '@supabase/supabase-js'
|
||||
import { createQueuedMockSupabase } from '@/tests/helpers'
|
||||
import {
|
||||
INVOICE_SOURCED_ENTRY_TYPES,
|
||||
getInvoiceReferencesForJournalEntries,
|
||||
getInvoicesExplainingJournalEntries,
|
||||
getJournalEntryUnderlagReferences,
|
||||
type ExplainableJournalEntry,
|
||||
} from '../journal-entry-references'
|
||||
import { MAX_CHAIN_WALK } from '../correction-chain'
|
||||
|
||||
/**
|
||||
* The resolver issues its queries in a fixed `.from()` order, and the queued
|
||||
@@ -268,3 +272,198 @@ describe('getInvoiceReferencesForJournalEntries', () => {
|
||||
])
|
||||
})
|
||||
})
|
||||
|
||||
/**
|
||||
* Every link through which a register invoice explains an entry (#2351).
|
||||
* Fixed `.from()` order per hop: invoices (by journal_entry_id) and
|
||||
* invoice_payments for the entries the engine's own source_id did not settle,
|
||||
* then journal_entries (by id) for the parents of unresolved stornos and
|
||||
* corrections that are not in the batch.
|
||||
*/
|
||||
describe('getInvoicesExplainingJournalEntries', () => {
|
||||
const setup = (results: { data: unknown }[]) => {
|
||||
const mock = createQueuedMockSupabase()
|
||||
mock.enqueueMany(results)
|
||||
return mock
|
||||
}
|
||||
const run = (mock: ReturnType<typeof setup>, entries: ExplainableJournalEntry[]) =>
|
||||
getInvoicesExplainingJournalEntries(
|
||||
mock.supabase as unknown as SupabaseClient,
|
||||
'company-1',
|
||||
entries,
|
||||
)
|
||||
const engine = (id: string, sourceId: string): ExplainableJournalEntry =>
|
||||
({ id, source_type: 'invoice_created', source_id: sourceId })
|
||||
const storno = (id: string, reversesId: string, sourceId: string | null = null): ExplainableJournalEntry =>
|
||||
({ id, source_type: 'storno', source_id: sourceId, reverses_id: reversesId })
|
||||
const correction = (id: string, correctionOfId: string): ExplainableJournalEntry =>
|
||||
({ id, source_type: 'correction', source_id: null, correction_of_id: correctionOfId })
|
||||
const other = (id: string, sourceType = 'import', sourceId: string | null = null): ExplainableJournalEntry =>
|
||||
({ id, source_type: sourceType, source_id: sourceId })
|
||||
const parentFetches = (mock: ReturnType<typeof setup>) => mock.findCalls('journal_entries', 'in')
|
||||
|
||||
it('pins the engine source types whose source_id is a register invoice', () => {
|
||||
// rot_rut_payout carries the ROT/RUT request id, never an invoice.
|
||||
expect([...INVOICE_SOURCED_ENTRY_TYPES].sort()).toEqual([
|
||||
'credit_note',
|
||||
'invoice_cash_payment',
|
||||
'invoice_created',
|
||||
'invoice_paid',
|
||||
'reminder_fee',
|
||||
])
|
||||
})
|
||||
|
||||
it('returns nothing, without a round trip, for an empty list', async () => {
|
||||
const mock = setup([])
|
||||
expect((await run(mock, [])).size).toBe(0)
|
||||
expect(mock.supabase.from).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('attributes an engine entry by its source_id with no round trip, even when that invoice is gone', async () => {
|
||||
// A missing invoice is a data defect for the caller to report
|
||||
// (CUSTOMER_NOT_FOUND in the PS), never a reason to fall silent.
|
||||
const mock = setup([])
|
||||
const refs = await run(mock, [engine('je-1', 'inv-gone')])
|
||||
expect(Array.from(refs.entries())).toEqual([['je-1', ['inv-gone']]])
|
||||
expect(mock.supabase.from).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('resolves a non-engine entry through the invoice-side links', async () => {
|
||||
const mock = setup([
|
||||
{ data: [] },
|
||||
{ data: [{ id: 'pay-1', invoice_id: 'inv-x', journal_entry_id: 'je-imp' }] },
|
||||
])
|
||||
const refs = await run(mock, [other('je-imp')])
|
||||
expect(Array.from(refs.entries())).toEqual([['je-imp', ['inv-x']]])
|
||||
expect(mock.supabase.from).toHaveBeenCalledTimes(2)
|
||||
})
|
||||
|
||||
it('a storno in the same batch as its engine original inherits the invoice without a fetch (#2351)', async () => {
|
||||
const mock = setup([{ data: [] }, { data: [] }])
|
||||
const refs = await run(mock, [engine('je-o', 'inv-1'), storno('je-s', 'je-o')])
|
||||
expect(refs.get('je-o')).toEqual(['inv-1'])
|
||||
expect(refs.get('je-s')).toEqual(['inv-1'])
|
||||
expect(parentFetches(mock)).toEqual([])
|
||||
expect(mock.supabase.from).toHaveBeenCalledTimes(2)
|
||||
})
|
||||
|
||||
it('follows reverses_id, never the copied source_id: a storno of a bank booking resolves to nothing', async () => {
|
||||
// reverseEntry() copies the original's source_id verbatim; on a bank
|
||||
// booking that is a transaction id, which no reader may take for an
|
||||
// invoice. The link column says what the storno cancels.
|
||||
const mock = setup([{ data: [] }, { data: [] }])
|
||||
const refs = await run(mock, [
|
||||
other('je-b', 'bank_transaction', 'tx-1'),
|
||||
storno('je-s', 'je-b', 'tx-1'),
|
||||
])
|
||||
expect(refs.size).toBe(0)
|
||||
expect(parentFetches(mock)).toEqual([])
|
||||
})
|
||||
|
||||
it('fetches an original outside the batch by id, company scoped, and both its storno and its correction inherit', async () => {
|
||||
// The storno of a May invoice booked in June: the PS for June only holds
|
||||
// the storno and the correction, so the original is loaded by id, once.
|
||||
const mock = setup([
|
||||
{ data: [] },
|
||||
{ data: [] },
|
||||
{ data: [engine('je-o', 'inv-1')] },
|
||||
])
|
||||
const refs = await run(mock, [storno('je-s', 'je-o'), correction('je-c', 'je-o')])
|
||||
expect(refs.get('je-s')).toEqual(['inv-1'])
|
||||
expect(refs.get('je-c')).toEqual(['inv-1'])
|
||||
expect(parentFetches(mock)).toEqual([['id', ['je-o']]])
|
||||
expect(mock.findCalls('journal_entries', 'eq')).toContainEqual(['company_id', 'company-1'])
|
||||
expect(mock.findCall('journal_entries', 'select')).toEqual([
|
||||
'id, source_type, source_id, reverses_id, correction_of_id',
|
||||
])
|
||||
})
|
||||
|
||||
it('a storno of a linked import inherits every invoice the payment rows name', async () => {
|
||||
// The link lives on the original (invoice_payments.journal_entry_id);
|
||||
// the storno gets the whole list, so a mixed-customer settlement stays
|
||||
// mixed when it is reversed.
|
||||
const mock = setup([
|
||||
{ data: [] },
|
||||
{ data: [
|
||||
{ id: 'pay-1', invoice_id: 'inv-a', journal_entry_id: 'je-imp' },
|
||||
{ id: 'pay-2', invoice_id: 'inv-b', journal_entry_id: 'je-imp' },
|
||||
] },
|
||||
])
|
||||
const refs = await run(mock, [other('je-imp'), storno('je-s', 'je-imp')])
|
||||
expect(refs.get('je-s')).toEqual(['inv-a', 'inv-b'])
|
||||
expect(parentFetches(mock)).toEqual([])
|
||||
})
|
||||
|
||||
it('an explicit link on the correction itself wins over the inherited one', async () => {
|
||||
const mock = setup([
|
||||
{ data: [{ id: 'inv-new', journal_entry_id: 'je-c' }] },
|
||||
{ data: [] },
|
||||
])
|
||||
const refs = await run(mock, [correction('je-c', 'je-o')])
|
||||
expect(Array.from(refs.entries())).toEqual([['je-c', ['inv-new']]])
|
||||
expect(parentFetches(mock)).toEqual([])
|
||||
})
|
||||
|
||||
it('walks a chain of corrections up to its root, one fetch per generation', async () => {
|
||||
const mock = setup([
|
||||
{ data: [] },
|
||||
{ data: [] },
|
||||
{ data: [correction('je-c1', 'je-o')] },
|
||||
{ data: [] },
|
||||
{ data: [] },
|
||||
{ data: [engine('je-o', 'inv-1')] },
|
||||
])
|
||||
const refs = await run(mock, [correction('je-c2', 'je-c1')])
|
||||
expect(refs.get('je-c2')).toEqual(['inv-1'])
|
||||
expect(parentFetches(mock)).toEqual([
|
||||
['id', ['je-c1']],
|
||||
['id', ['je-o']],
|
||||
])
|
||||
})
|
||||
|
||||
it('mirror: a storno whose original no invoice explains resolves to nothing, without a fetch', async () => {
|
||||
const mock = setup([{ data: [] }, { data: [] }])
|
||||
const refs = await run(mock, [other('je-m', 'manual'), storno('je-s', 'je-m')])
|
||||
expect(refs.size).toBe(0)
|
||||
expect(parentFetches(mock)).toEqual([])
|
||||
expect(mock.supabase.from).toHaveBeenCalledTimes(2)
|
||||
})
|
||||
|
||||
it('a cycle terminates without a fetch', async () => {
|
||||
const mock = setup([{ data: [] }, { data: [] }])
|
||||
const refs = await run(mock, [storno('a', 'b'), storno('b', 'a')])
|
||||
expect(refs.size).toBe(0)
|
||||
expect(parentFetches(mock)).toEqual([])
|
||||
})
|
||||
|
||||
it('bounds an in-batch chain at MAX_CHAIN_WALK links, in either batch order (PR #2354 review)', async () => {
|
||||
// je-0 is the engine root and je-k the storno of je-(k-1): eleven links
|
||||
// in one batch. The ten within the cap inherit, the eleventh does not,
|
||||
// the same answer the fetched walk gives a chain of that length. Both
|
||||
// orders: ascending resolves each child off an already attributed
|
||||
// parent, descending queues them all and propagates from the root.
|
||||
const chain = [engine('je-0', 'inv-1')]
|
||||
for (let k = 1; k <= MAX_CHAIN_WALK + 1; k++) chain.push(storno(`je-${k}`, `je-${k - 1}`))
|
||||
for (const batch of [chain, [...chain].reverse()]) {
|
||||
const mock = setup([{ data: [] }, { data: [] }])
|
||||
const refs = await run(mock, batch)
|
||||
for (let k = 0; k <= MAX_CHAIN_WALK; k++) expect(refs.get(`je-${k}`), `je-${k}`).toEqual(['inv-1'])
|
||||
expect(refs.has(`je-${MAX_CHAIN_WALK + 1}`)).toBe(false)
|
||||
expect(parentFetches(mock)).toEqual([])
|
||||
}
|
||||
})
|
||||
|
||||
it('stops a chain that never reaches a root at MAX_CHAIN_WALK generations', async () => {
|
||||
const mock = createQueuedMockSupabase()
|
||||
for (let k = 0; k <= MAX_CHAIN_WALK; k++) {
|
||||
mock.enqueueMany([
|
||||
{ data: [] },
|
||||
{ data: [] },
|
||||
{ data: [storno(`p${k + 1}`, `p${k + 2}`)] },
|
||||
])
|
||||
}
|
||||
const refs = await run(mock, [storno('je-s', 'p1')])
|
||||
expect(refs.size).toBe(0)
|
||||
expect(parentFetches(mock)).toHaveLength(MAX_CHAIN_WALK)
|
||||
})
|
||||
})
|
||||
|
||||
@@ -1,6 +1,8 @@
|
||||
import type { SupabaseClient } from '@supabase/supabase-js'
|
||||
import { fetchAllRows } from '@/lib/supabase/fetch-all'
|
||||
import { chunk } from '@/lib/utils'
|
||||
import { NON_ISSUED_INVOICE_STATUSES_FILTER } from '@/lib/invoices/matchable-statuses'
|
||||
import { MAX_CHAIN_WALK } from './correction-chain'
|
||||
|
||||
/**
|
||||
* A followable reference from a verifikation back to its underlag: the customer
|
||||
@@ -270,3 +272,152 @@ export async function getInvoiceReferencesForJournalEntries(
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
/**
|
||||
* Source types the invoice engine writes with `source_id` = the id of the
|
||||
* register invoice (an `invoices` row; credit notes are rows there too) that
|
||||
* the entry books: issuance and payment under faktureringsmetoden, the
|
||||
* kontantmetod inbetalning, a credit note, and a reminder fee. For these the
|
||||
* entry's own source columns are the link; no invoice-side row is needed.
|
||||
* `rot_rut_payout` is deliberately absent: its source_id is the ROT/RUT
|
||||
* request, not an invoice.
|
||||
*/
|
||||
export const INVOICE_SOURCED_ENTRY_TYPES: ReadonlySet<string> = new Set([
|
||||
'invoice_created',
|
||||
'invoice_paid',
|
||||
'invoice_cash_payment',
|
||||
'credit_note',
|
||||
'reminder_fee',
|
||||
])
|
||||
|
||||
/** Ids per PostgREST `.in()` filter (URL-length convention, lib/worklist/categories.ts). */
|
||||
export const LINK_LOOKUP_CHUNK = 100
|
||||
|
||||
/** The columns {@link getInvoicesExplainingJournalEntries} reads off an entry. */
|
||||
export interface ExplainableJournalEntry {
|
||||
id: string
|
||||
source_type: string | null
|
||||
source_id: string | null
|
||||
/** Storno: the entry this one cancels (reverseEntry / correctEntry). */
|
||||
reverses_id?: string | null
|
||||
/** Rättelse: the entry this one replaces (correctEntry). */
|
||||
correction_of_id?: string | null
|
||||
}
|
||||
|
||||
/** Literal select for the parent rows the chain walk fetches. */
|
||||
const CHAIN_COLUMNS = 'id, source_type, source_id, reverses_id, correction_of_id'
|
||||
|
||||
/**
|
||||
* Which register invoices explain each of the given journal entries, through
|
||||
* every link the register keeps:
|
||||
*
|
||||
* 1. the engine's own entries: source_id IS the invoice id
|
||||
* (INVOICE_SOURCED_ENTRY_TYPES);
|
||||
* 2. the invoice side: invoices.journal_entry_id and
|
||||
* invoice_payments.journal_entry_id (getInvoiceReferencesForJournalEntries);
|
||||
* 3. the rättelse chain: a storno or correction carries reverses_id /
|
||||
* correction_of_id and is explained by whatever explains the entry it
|
||||
* cancels or replaces. Neither writer leaves a usable link of its own on
|
||||
* the new entry (reverseEntry copies the original's polymorphic
|
||||
* source_id, correctEntry copies nothing, and the register never points
|
||||
* at a storno), so the chain is walked upwards until an attribution is
|
||||
* found: the same links correctionChainDepth trusts, under the same
|
||||
* MAX_CHAIN_WALK cap.
|
||||
*
|
||||
* A reader that followed only 1 and 2 kept a reversed original in its totals
|
||||
* and dropped the storno that nets it (#2351): a makulerad EU sale stayed in
|
||||
* the periodisk sammanställning while the account-based ruta 39 was zero.
|
||||
*
|
||||
* Values are invoice ids per entry id; an entry is present only when at least
|
||||
* one invoice explains it. An engine entry is attributed by its source_id
|
||||
* whether or not that invoice still exists (a missing one is a data defect
|
||||
* for the caller to report, not a reason for silence), and a chain entry
|
||||
* inherits its root's attribution the same way. An explicit link on the entry
|
||||
* itself wins over an inherited one. Parents are fetched by id, company
|
||||
* scoped and chunked, so the storno of a May invoice booked in June is
|
||||
* resolved from June's entries alone.
|
||||
*/
|
||||
export async function getInvoicesExplainingJournalEntries(
|
||||
supabase: SupabaseClient,
|
||||
companyId: string,
|
||||
entries: readonly ExplainableJournalEntry[],
|
||||
): Promise<Map<string, string[]>> {
|
||||
const result = new Map<string, string[]>()
|
||||
if (entries.length === 0) return result
|
||||
|
||||
// Chain entries waiting for their parent's attribution, by parent id.
|
||||
const waitingOn = new Map<string, string[]>()
|
||||
// Links between an attributed entry and the root that explains it: 0 for
|
||||
// an entry attributed by its own source_id or invoice-side link.
|
||||
const depthOf = new Map<string, number>()
|
||||
// Every id considered so far (the batch plus fetched parents): a cycle, or
|
||||
// a parent shared by several children, is never fetched twice.
|
||||
const seen = new Set<string>(entries.map((e) => e.id))
|
||||
|
||||
// Attribute an entry and every descendant waiting on it. Iterative, so a
|
||||
// pathological in-batch chain cannot exhaust the stack, and with the depth
|
||||
// carried along: a descendant more than MAX_CHAIN_WALK links below the root
|
||||
// resolves to "no invoice", the cap the fetched walk below applies, so an
|
||||
// in-batch chain and an out-of-batch chain of the same length agree.
|
||||
const assign = (entryId: string, invoiceIds: string[], depth: number): void => {
|
||||
const queue: [string, number][] = [[entryId, depth]]
|
||||
for (let i = 0; i < queue.length; i++) {
|
||||
const [id, d] = queue[i]
|
||||
if (result.has(id)) continue
|
||||
result.set(id, i === 0 ? invoiceIds : [...invoiceIds])
|
||||
depthOf.set(id, d)
|
||||
if (d >= MAX_CHAIN_WALK) continue
|
||||
for (const child of waitingOn.get(id) ?? []) queue.push([child, d + 1])
|
||||
}
|
||||
}
|
||||
|
||||
let frontier: ExplainableJournalEntry[] = [...entries]
|
||||
for (let hop = 0; frontier.length > 0; hop++) {
|
||||
const unresolved: ExplainableJournalEntry[] = []
|
||||
for (const entry of frontier) {
|
||||
if (entry.source_id && INVOICE_SOURCED_ENTRY_TYPES.has(entry.source_type ?? '')) {
|
||||
assign(entry.id, [entry.source_id], 0)
|
||||
} else {
|
||||
unresolved.push(entry)
|
||||
}
|
||||
}
|
||||
|
||||
for (const ids of chunk(unresolved.map((e) => e.id), LINK_LOOKUP_CHUNK)) {
|
||||
const refs = await getInvoiceReferencesForJournalEntries(supabase, companyId, ids)
|
||||
for (const [entryId, invoiceIds] of refs) assign(entryId, invoiceIds, 0)
|
||||
}
|
||||
|
||||
const parentIds: string[] = []
|
||||
for (const entry of unresolved) {
|
||||
if (result.has(entry.id)) continue
|
||||
const parentId = entry.correction_of_id ?? entry.reverses_id ?? null
|
||||
if (!parentId) continue
|
||||
const inherited = result.get(parentId)
|
||||
if (inherited) {
|
||||
const depth = (depthOf.get(parentId) ?? 0) + 1
|
||||
if (depth <= MAX_CHAIN_WALK) assign(entry.id, [...inherited], depth)
|
||||
continue
|
||||
}
|
||||
const waiting = waitingOn.get(parentId)
|
||||
if (waiting) waiting.push(entry.id)
|
||||
else waitingOn.set(parentId, [entry.id])
|
||||
if (!seen.has(parentId)) {
|
||||
seen.add(parentId)
|
||||
parentIds.push(parentId)
|
||||
}
|
||||
}
|
||||
if (parentIds.length === 0 || hop >= MAX_CHAIN_WALK) break
|
||||
|
||||
frontier = []
|
||||
for (const ids of chunk(parentIds, LINK_LOOKUP_CHUNK)) {
|
||||
const parents = await fetchAllRows<ExplainableJournalEntry>(({ from, to }) =>
|
||||
supabase.from('journal_entries').select(CHAIN_COLUMNS)
|
||||
.eq('company_id', companyId).in('id', ids)
|
||||
.order('id', { ascending: true }).range(from, to),
|
||||
)
|
||||
frontier.push(...parents)
|
||||
}
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user