feat(import): attach underlag to SIE-migrated verifikat by filename (#1627)
* refactor(documents): lift the SIE voucher-ref resolver into core
The provider migration sweep resolved a source voucher reference to the
verifikat it became with an in-memory (period, series, number) index built
inside extensions/general/arcim-migration. The underlag filename import needs
the identical resolution, and core must never import from @/extensions, so the
index, its ambiguity handling and the two paged reads move to
lib/documents/voucher-ref-resolver.ts.
Behaviour-preserving for the extension: same index construction, same "drop
both when one key repeats inside a fiscal year" rule, same dateTo-window
resolution. The arcim tests pass unchanged.
Two deliberate additions on top of the lift:
- series comparison is now case-insensitive on both sides. SIE writes series
uppercase in practice but the spec does not require it, and a filename is
whatever the exporting tool produced.
- byNumber and fetchVouchersForNumbers serve the filename flow, which
resolves a handful of refs per request and must not pull every migrated
entry into memory to do it.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
* feat(import): attach underlag to SIE-migrated verifikat by filename
A SIE file carries the ledger but not the underlag, so a migrating customer
brings the receipts over separately and today has to open every verifikat and
attach them by hand. Systems that export both name each receipt after its
verifikat (A31_<internal-id>.pdf), and the SIE import already preserves that
identity on every entry (source_voucher_series / source_voucher_number), so
the pairing is a lookup, not an interpretation: no AI, no amount matching, no
date windows.
Separate optional import mode (/import?mode=underlag), NOT a step inside the
SIE wizard: the receipts normally arrive later and from a different export, so
a migration must never be blocked on having them ready.
lib/documents/filename-voucher-ref.ts reads the ref out of a filename
lib/documents/underlag-import.ts builds the plan (reads only)
POST /api/import/documents/preview filenames in, match plan out
POST /api/import/documents/attach one file, archived and linked
components/import/UnderlagImportWizard review, adjust, run
Guards, because a document linked to a posted verifikat is
räkenskapsinformation and can never be re-pointed (BFL 7 kap):
- Matching keys on the SOURCE voucher number, never our own. The importer
renumbers per target series, so a file named after our number would land
on the wrong verifikat exactly when the import skipped a voucher.
- Nothing is uploaded until the whole plan has been shown: the preview
sends filenames only, the bytes stay in the browser.
- A ref that hits several migrated years is surfaced as a choice, never
resolved by guessing. So is a filename with a number but no series, which
is resolved but never pre-selected.
- A date-named file (20240131.pdf) is refused outright rather than read as
voucher 20240131.
- A target in a closed or locked period is shown but not selectable:
enforce_period_lock_documents would refuse the write anyway.
- The attach route re-resolves the filename server-side and 409s when it
does not name the target the client sent, so a stale plan cannot scatter
underlag permanently. An explicit manual assignment opts out of that check
and is flagged as such; company ownership of the entry is always verified.
- Idempotent per (verifikat, content): a re-run converges on the same
document row instead of archiving duplicates.
tests/pg/underlag-attach-period-lock.pg.test.ts pins the period-lock contract
the plan surface promises, including that the lock guards the LINK and still
lets an unlinked document be archived.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
* fix(import): scope underlag matching to a declared fiscal year
Adversarial review of #1627 refuted the resolver: it looked a ref up
company-wide and treated "exactly one candidate exists" as proof of identity.
Source systems restart voucher numbering every year and a filename carries no
year, so with a partial migration, or with that year's A31 among the vouchers
the importer routinely skips (empty, single-line, unbalanced), a 2023 receipt
was silently attached to a 2025 verifikat. Permanent under BFL 7 kap, and
invisible afterwards. Cardinality is not identity.
Every batch now declares its fiscal year and candidates outside it are dropped
before the index is built, so no downstream branch can see, count or propose
one. The attach route takes the year for its re-resolution from the TARGET
entry, never from the client, so the check cannot be widened by naming a
different year. Scoping cannot make the year inferable; it makes it asserted,
and the confirm dialog reads it back because it is the one input the files
cannot corroborate.
Four further defects from the same review:
- npm test went red: hoisting the column list into a VOUCHER_SELECT constant
hid it from the no-phantom-columns AST scan (ceiling 377 -> 379) and
dropped all eight journal_entries columns out of the guard on the one path
that writes irreversible links. Both selects are inline again, and split:
the provider sweep no longer fetches three display columns it never reads.
- The date guard only caught zero-padded hyphenated dates, so
`2024-1-31 kvitto.pdf`, `2024 01 31 ...`, `2024.1.31` and `24-01-31` all
parsed as voucher 2024 or 24. Widened to unpadded components, two-digit
years and space/slash separators; a bare year-shaped number is refused.
- `Verifikation 31.pdf` parsed as series ION: the alternation matched
`ifikat` and left `ion` for the series group. Reordering alone was not
enough (the engine backtracks into it), so the prefix now requires the
word to end.
- The manual-reference box was an unguarded write path: typing a date got
path-split down to a voucher number, marked the row selected, and posted
with override, which skips both server checks, while the row still showed
"Kan inte tolkas". Directory splitting is gone from the parser, the row
status is updated on resolve, and picking a server-proposed candidate no
longer counts as an override, which had disabled the filename check on
exactly the ambiguous rows it exists to protect.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
* fix(import): enforce the declared fiscal year on the server
The second adversarial pass refuted the previous fix. The attach route took
the year for its re-resolution from the TARGET entry, which is tautological:
an entry is by construction inside its own fiscal_period_id, so the filter
could never drop it and the year axis was unfalsifiable. Server-side year
enforcement was zero; the declared year existed only as React state and was
never sent. The regression test that "proved" otherwise passed only because
the mock let one journal_entries row report two different fiscal_period_id
values to two different reads, a state Postgres cannot produce. A test that
could not fail.
The attach request now carries the year the user actually reviewed, echoed
back from the plan, and the route asserts it equals the target's own period
BEFORE any other check and including overrides: an override is a statement
about which verifikat, never about which year. Its test asserts that directly
instead of a mock artifact.
Also from the same pass, a UI race that made the confirm dialog lie: FyPicker
stayed interactive while a preview of up to 2000 filenames was in flight, so
the summary and the confirm text could read back a year the plan was not built
from, and a manually resolved row could join the batch from another year
entirely. The wizard snapshots the plan's year, every downstream read uses the
snapshot, manual re-resolution goes through the server's own echoed
plan.fiscal_period_id, and the picker is frozen while a preview runs.
Parser, from the corpus pass (~360 realistic filenames plus 200k random uuids,
no ReDoS found: 2000 hostile inputs in 26ms):
- Day-first and US dates parsed as voucher numbers: `31.01.2024` became
voucher 31, a number that always exists in the year. The guard now covers
both orders.
- `ver 31.pdf` parsed as series VER and came back auto-selectable, while
every spelled-out `Verifikat 31.pdf` correctly yielded a series-less
reference needing confirmation. Same filename, two trust levels, decided
by an abbreviation. `ver` is no longer a series.
Known residual, stated rather than papered over: a scanner's `A4.pdf` or a
`K10.pdf` blankett in the receipts folder still matches verifikat A4 or K10
when that year has them. No parser can separate those from a genuine
reference; they appear in the review table with the target's date and
description.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
* fix(import): make the user actually declare the fiscal year
The third adversarial pass found that the central guarantee of the previous
two commits was fiction. FyPicker auto-selects the newest fiscal period when
nothing is stored, and the wizard passes a page-specific storage key, so that
branch fired on every first use. A user migrating 2023 receipts who never
opened the picker resolved them against the newest year; A31 exists in
essentially every year, so those rows came back `matched`, pre-selected, with
only the confirm dialog between them and permanent links. Every commit message
and code comment claiming "the year the user named" described behaviour the UI
did not have.
FyPicker gains an opt-in `requireExplicitChoice` prop, default off so no other
caller changes, and the wizard uses it. The picker starts empty and the batch
cannot proceed until someone picks. A previously stored explicit choice for
this surface is still restored, which is what makes a multi-batch migration
bearable.
Also: a company with zero fiscal periods hit a disabled picker and a disabled
button with no explanation. There is now a line saying why.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
* fix(import): close the restore-branch hole and demote collision-prone refs
Round four of adversarial review, two findings, both fixed.
1. `requireExplicitChoice` gated only the newest-period fallback, not the
localStorage restore branch above it, so the "user declares the year"
guarantee held only for a user's first-ever batch. From the second on, the
year was silently pre-filled from an earlier unrelated batch, and in a
multi-year migration last-used is the worst possible default: the user is
by definition moving to a different year each round. The prop now gates
FyPicker's ENTIRE auto-selection block with one outer condition (restore,
the ALL_YEARS-stored fallback, newest-period, preferLatestEnded), because a
per-branch gate already missed one branch once. It also suppresses the
localStorage write, which fired BEFORE onChange and so recorded picks the
wizard had rejected mid-preview. The wizard drops its storage prefix
entirely: within one sitting reset() carries the year in state, and
nothing survives the session.
2. The filename parser pre-ticked `A4 scan.pdf` and `K10.pdf` while requiring
a click for `31.pdf`, which carries MORE voucher evidence in a
single-series company. Two independent review passes flagged the same
inconsistency. Collision-famous refs (A0-A6 paper sizes, K2-K13/N1-N9/
T1-T2 blanketter, Q1-Q4 quarters) and three-letter series (IMG/DSC/DOC/
SCN are cameras; real SIE series are 1-2 chars) still parse and resolve
but are never auto-selected. Demoted, not refused: verifikat A4 genuinely
exists in every migrated ledger, and its real receipt costs one click.
Residual documented: an existing short series plus a small number in an
ad-hoc name (`B2 hyra.pdf`) is indistinguishable from a real ref by
filename alone.
Also: the attach route's multipart doc now names the required
fiscal_period_id field, and the stale reset() comment describes the actual
persistence model.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
* fix(import): honor override only for unresolvable filenames + review round
Resolution pass for the PR #1627 review reports (CodeRabbit, Swedish
accounting review, compliance swarm).
The one substantive finding (CodeRabbit, major): `override: true` skipped the
filename consistency check entirely, so a crafted client could attach a
cleanly-named file to any same-year verifikat. The resolver now runs on every
request; an override is honored only when the filename is unresolvable in the
declared year (no parse, or no candidate) or already resolves to the requested
target. The shipped UI only overrides unresolvable rows, so nothing
user-facing changes. planAcceptsTarget is renamed planPermitsAttach and
carries the semantics in one place, with tests for both directions.
The Swedish review finding (BFNAR 2013:2 systemdokumentation): the
planPermitsAttach JSDoc still described the superseded derive-the-year-from-
the-target design. It now states the actual control: the route asserts the
caller-declared year equals the target's own period before this function runs.
CodeRabbit minors and nitpicks:
- underlag_confirm_body / underlag_run / underlag_locked_warning use ICU
plural forms in both locales; "1 filer arkiveras" was wrong Swedish.
- The attach and preview route tests mock @/lib/supabase/server per the
repo test guideline.
- fetchVouchersForNumbers narrows to the declared fiscal year at the DB;
the in-memory filter in buildUnderlagPlan remains the enforced truth.
- buildVoucherIndex appends into existing arrays instead of copying per
row: the provider sweep indexes every migrated entry in the company and
per-row copies made that O(n^2).
- The pg test reuses its insertDocument helper instead of a duplicated
INSERT; runAttach clears isLoading in a finally.
Declined, with reasons in DECISIONS.md: message-regex classification of
validateDocumentFile failures (established sibling pattern; validator
contract change is out of scope).
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
* fix(import): attach only to posted or reversed verifikat
Second review cycle on PR #1627: the Swedish accounting review's re-run found
that nothing in the attach route verified the target entry's status. The SIE
import RPC posts every entry inside its own transaction, so a draft carrying a
source ref should be unobservable, but the link this route writes is
irreversible räkenskapsinformation, and an invariant enforced in another file
is not one this surface may lean on. Underlag references a verifikation
(BFL 5 kap 6-7 §), so the target must BE one.
Enforced twice: the route rejects non-posted targets with
UNDERLAG_ENTRY_NOT_POSTED (overrides included), and the resolver reads filter
to posted/reversed so a draft can never even become a candidate. Reversed
stays attachable: a storno'd original remains räkenskapsinformation and its
underlag belongs on it.
Also recorded as confirmed-intentional (review note, no code change): with
override and an unresolvable filename the endpoint links to any same-company,
same-declared-year, posted verifikat, migrated or not, which mirrors the
existing /api/documents/[id]/link capability. The period-lock error-string
regex note restates a disposition already recorded in DECISIONS.md.
The arcim test's Supabase double learns .in(), which the shared resolver read
now uses for the status filter.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Mattsson
co-authored by
Claude Opus 5
Claude Opus 5
parent
4362bffc0c
commit
2deea05d42
@@ -0,0 +1,179 @@
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import { parseVoucherRefFromFileName } from '@/lib/documents/filename-voucher-ref'
|
||||
|
||||
describe('parseVoucherRefFromFileName', () => {
|
||||
it('parses the SpeedLedger prefix form (series + number + internal id)', () => {
|
||||
expect(parseVoucherRefFromFileName('A31_8c2db060-79ba-4b6e-9f3d-4b0042aa5c52.pdf')).toEqual({
|
||||
series: 'A',
|
||||
number: 31,
|
||||
pattern: 'series_number',
|
||||
autoSelectable: true,
|
||||
})
|
||||
})
|
||||
|
||||
it('parses a bare series + number filename', () => {
|
||||
expect(parseVoucherRefFromFileName('V123.pdf')).toMatchObject({ series: 'V', number: 123 })
|
||||
})
|
||||
|
||||
it.each([
|
||||
['A-31 kvitto.pdf', 'A', 31],
|
||||
['A_31.jpg', 'A', 31],
|
||||
['A 31 leverantorsfaktura.png', 'A', 31],
|
||||
['2024-A-31.pdf', 'A', 31],
|
||||
['2024_A31_underlag.pdf', 'A', 31],
|
||||
['ver_A31.pdf', 'A', 31],
|
||||
['Verifikat A31.pdf', 'A', 31],
|
||||
['BC7.pdf', 'BC', 7],
|
||||
])('parses %s', (fileName, series, number) => {
|
||||
expect(parseVoucherRefFromFileName(fileName)).toMatchObject({ series, number })
|
||||
})
|
||||
|
||||
it('uppercases the series so a lowercase export still joins', () => {
|
||||
expect(parseVoucherRefFromFileName('a31_x.pdf')).toMatchObject({ series: 'A' })
|
||||
})
|
||||
|
||||
it.each([
|
||||
// Paper sizes: every scanner emits an A4.pdf.
|
||||
'A4.pdf',
|
||||
'A4 scan.pdf',
|
||||
'a4.pdf',
|
||||
'A3 ritning.pdf',
|
||||
// A batch scanner's zero-padded counter normalizes onto the same refs.
|
||||
'A0004.pdf',
|
||||
'A001.pdf',
|
||||
// Skatteverket blanketter and quarters.
|
||||
'K10.pdf',
|
||||
'K10 blankett 2024.pdf',
|
||||
'K4.pdf',
|
||||
'N9.pdf',
|
||||
'Q1 2024.pdf',
|
||||
])('parses %s but never pre-selects it: more often a document name than a ref', (fileName) => {
|
||||
const parsed = parseVoucherRefFromFileName(fileName)
|
||||
expect(parsed).not.toBeNull()
|
||||
expect(parsed?.autoSelectable).toBe(false)
|
||||
})
|
||||
|
||||
it.each(['IMG_0031.jpg', 'DSC00123.JPG', 'DOC001.pdf', 'SCN0007.pdf', 'Del 1 av 3.pdf'])(
|
||||
'parses %s but never pre-selects a three-letter series: cameras, not ledgers',
|
||||
(fileName) => {
|
||||
const parsed = parseVoucherRefFromFileName(fileName)
|
||||
expect(parsed).not.toBeNull()
|
||||
expect(parsed?.autoSelectable).toBe(false)
|
||||
},
|
||||
)
|
||||
|
||||
it.each([
|
||||
['A7.pdf', 'A', 7],
|
||||
['A31.pdf', 'A', 31],
|
||||
['K1.pdf', 'K', 1],
|
||||
['K14.pdf', 'K', 14],
|
||||
['LB2.pdf', 'LB', 2],
|
||||
])('keeps %s auto-selectable: just outside the collision list', (fileName, series, number) => {
|
||||
expect(parseVoucherRefFromFileName(fileName)).toEqual({
|
||||
series,
|
||||
number,
|
||||
pattern: 'series_number',
|
||||
autoSelectable: true,
|
||||
})
|
||||
})
|
||||
|
||||
it.each([
|
||||
'underlag/2024/A31_kvitto.pdf',
|
||||
'underlag\\A31.pdf',
|
||||
// The manual-reference box feeds arbitrary typed text through this same
|
||||
// parser. Splitting on the separator would turn a typed date into a
|
||||
// voucher number and hand the user an irreversible link to approve.
|
||||
'2024/01/31 kvitto.pdf',
|
||||
'2024/01/31',
|
||||
])('does not strip a path component out of %s', (input) => {
|
||||
expect(parseVoucherRefFromFileName(input)).toBeNull()
|
||||
})
|
||||
|
||||
it.each([
|
||||
['Verifikation 31.pdf', 31],
|
||||
['verifikation31.pdf', 31],
|
||||
['Verifikat 31.pdf', 31],
|
||||
// `ver` is a prefix word, not a series: without that rule this one form
|
||||
// came back auto-selectable while every spelled-out variant did not.
|
||||
['ver 31.pdf', 31],
|
||||
['ver31.pdf', 31],
|
||||
['VER-31.pdf', 31],
|
||||
['ver.31.pdf', 31],
|
||||
])('reads %s as a series-less reference, not a bogus series', (fileName, number) => {
|
||||
expect(parseVoucherRefFromFileName(fileName)).toEqual({
|
||||
series: null,
|
||||
number,
|
||||
pattern: 'number_only',
|
||||
autoSelectable: false,
|
||||
})
|
||||
})
|
||||
|
||||
it('returns a series-less parse for a number-only name, never auto-selectable', () => {
|
||||
expect(parseVoucherRefFromFileName('31.pdf')).toEqual({
|
||||
series: null,
|
||||
number: 31,
|
||||
pattern: 'number_only',
|
||||
autoSelectable: false,
|
||||
})
|
||||
expect(parseVoucherRefFromFileName('31_kvitto.pdf')).toMatchObject({ series: null, number: 31 })
|
||||
})
|
||||
|
||||
it.each([
|
||||
'20240131.pdf',
|
||||
'20240131_kvitto.pdf',
|
||||
'2024-01-31 kvitto.pdf',
|
||||
'2024_01_31.pdf',
|
||||
// Unpadded components, two-digit years and space separators are just as
|
||||
// common in receipt exports and used to slip through as voucher 2024 / 24.
|
||||
'2024-1-31 kvitto.pdf',
|
||||
'2024_1_31.pdf',
|
||||
'2024.1.31.pdf',
|
||||
'2024 01 31 kvitto.pdf',
|
||||
'24-01-31 kvitto.pdf',
|
||||
'2024/01/31.pdf',
|
||||
// Day-first and US order: the day would otherwise become a voucher number
|
||||
// that always exists in the year.
|
||||
'31.01.2024.pdf',
|
||||
'31-01-2024.pdf',
|
||||
'31_01_2024.pdf',
|
||||
'31.1.2024.pdf',
|
||||
'24.12.2024 julbord.pdf',
|
||||
'03.04.2025 ICA.pdf',
|
||||
'12.24.2024.pdf',
|
||||
'01-31-2024.pdf',
|
||||
'1-31-2024 receipt.pdf',
|
||||
'31/1/2024.pdf',
|
||||
])('refuses the date-named file %s rather than reading it as a number', (fileName) => {
|
||||
expect(parseVoucherRefFromFileName(fileName)).toBeNull()
|
||||
})
|
||||
|
||||
it.each(['2024.pdf', '2024_kvitto.pdf', '1999.pdf'])(
|
||||
'refuses the year-shaped series-less name %s',
|
||||
(fileName) => {
|
||||
expect(parseVoucherRefFromFileName(fileName)).toBeNull()
|
||||
},
|
||||
)
|
||||
|
||||
it.each([
|
||||
'kvitto.pdf',
|
||||
'Faktura2024.pdf',
|
||||
'A31kvitto.pdf',
|
||||
'Version2_kvitto.pdf',
|
||||
'',
|
||||
'.pdf',
|
||||
])('returns null for %s instead of guessing', (fileName) => {
|
||||
expect(parseVoucherRefFromFileName(fileName)).toBeNull()
|
||||
})
|
||||
|
||||
it('rejects a zero voucher number', () => {
|
||||
expect(parseVoucherRefFromFileName('A0.pdf')).toBeNull()
|
||||
expect(parseVoucherRefFromFileName('0.pdf')).toBeNull()
|
||||
})
|
||||
|
||||
it('handles a filename with no extension at all', () => {
|
||||
expect(parseVoucherRefFromFileName('A31_8c2db060-79ba-4b6e-9f3d-4b0042aa5c52')).toMatchObject({
|
||||
series: 'A',
|
||||
number: 31,
|
||||
})
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,354 @@
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import type { SupabaseClient } from '@supabase/supabase-js'
|
||||
import { buildUnderlagPlan, planPermitsAttach } from '@/lib/documents/underlag-import'
|
||||
import type { FiscalPeriodRow, VoucherRow } from '@/lib/documents/voucher-ref-resolver'
|
||||
|
||||
const PERIOD_OPEN = 'period-open'
|
||||
const PERIOD_LOCKED = 'period-locked'
|
||||
|
||||
const PERIODS: FiscalPeriodRow[] = [
|
||||
{
|
||||
id: PERIOD_OPEN,
|
||||
period_start: '2024-01-01',
|
||||
period_end: '2024-12-31',
|
||||
is_closed: false,
|
||||
locked_at: null,
|
||||
},
|
||||
{
|
||||
id: PERIOD_LOCKED,
|
||||
period_start: '2023-01-01',
|
||||
period_end: '2023-12-31',
|
||||
is_closed: true,
|
||||
locked_at: null,
|
||||
},
|
||||
]
|
||||
|
||||
function makeVoucher(overrides: Partial<VoucherRow> & Pick<VoucherRow, 'id'>): VoucherRow {
|
||||
return {
|
||||
fiscal_period_id: PERIOD_OPEN,
|
||||
entry_date: '2024-03-14',
|
||||
description: 'Inköp kontorsmaterial',
|
||||
voucher_series: 'A',
|
||||
voucher_number: 47,
|
||||
source_voucher_series: 'A',
|
||||
source_voucher_number: 31,
|
||||
...overrides,
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Minimal Supabase double keyed on the query SHAPE rather than call order:
|
||||
* buildUnderlagPlan fires the voucher and period reads concurrently, so an
|
||||
* order-sensitive queue would make these tests flaky for no benefit.
|
||||
*/
|
||||
function makeSupabase(opts: {
|
||||
vouchers: VoucherRow[]
|
||||
periods?: FiscalPeriodRow[]
|
||||
/** Total migrated entries in the company, regardless of the number filter. */
|
||||
sourceRefCount?: number
|
||||
}): SupabaseClient {
|
||||
const periods = opts.periods ?? PERIODS
|
||||
|
||||
const from = (table: string) => {
|
||||
let filteredByNumber = false
|
||||
|
||||
const result = () => {
|
||||
if (table === 'fiscal_periods') return { data: periods, error: null, count: periods.length }
|
||||
// Only the number-filtered read returns the voucher rows; the bare
|
||||
// count read answers "does this ledger have ANY source refs at all".
|
||||
return {
|
||||
data: filteredByNumber ? opts.vouchers : [],
|
||||
error: null,
|
||||
count: opts.sourceRefCount ?? opts.vouchers.length,
|
||||
}
|
||||
}
|
||||
|
||||
const chain: Record<string, unknown> = {}
|
||||
for (const method of ['select', 'eq', 'not', 'order', 'limit', 'maybeSingle', 'single']) {
|
||||
chain[method] = () => chain
|
||||
}
|
||||
chain.in = () => {
|
||||
filteredByNumber = true
|
||||
return chain
|
||||
}
|
||||
chain.range = () => Promise.resolve(result())
|
||||
chain.then = (onFulfilled: (value: unknown) => unknown) =>
|
||||
Promise.resolve(result()).then(onFulfilled)
|
||||
return chain
|
||||
}
|
||||
|
||||
return { from } as unknown as SupabaseClient
|
||||
}
|
||||
|
||||
describe('buildUnderlagPlan', () => {
|
||||
it('matches a filename prefix to the migrated verifikat it names', async () => {
|
||||
const supabase = makeSupabase({ vouchers: [makeVoucher({ id: 'je-1' })] })
|
||||
|
||||
const plan = await buildUnderlagPlan(supabase, 'company-1', [
|
||||
'A31_8c2db060-79ba-4b6e-9f3d-4b0042aa5c52.pdf',
|
||||
], PERIOD_OPEN)
|
||||
|
||||
expect(plan.rows[0]).toMatchObject({
|
||||
file_name: 'A31_8c2db060-79ba-4b6e-9f3d-4b0042aa5c52.pdf',
|
||||
status: 'matched',
|
||||
parsed_ref: { series: 'A', number: 31 },
|
||||
journal_entry_id: 'je-1',
|
||||
})
|
||||
expect(plan.rows[0].candidates[0]).toMatchObject({
|
||||
voucher_label: 'A47',
|
||||
source_voucher_label: 'A31',
|
||||
period_locked: false,
|
||||
})
|
||||
expect(plan.summary).toMatchObject({ total: 1, matched: 1 })
|
||||
})
|
||||
|
||||
it('matches on the SOURCE number, not our renumbered one', async () => {
|
||||
// The import renumbered source A31 to A47. A file named after our own
|
||||
// number must NOT match: A47 does not exist in the source system.
|
||||
const supabase = makeSupabase({ vouchers: [makeVoucher({ id: 'je-1' })] })
|
||||
|
||||
const plan = await buildUnderlagPlan(supabase, 'company-1', ['A47_kvitto.pdf'], PERIOD_OPEN)
|
||||
|
||||
expect(plan.rows[0].status).toBe('no_match')
|
||||
})
|
||||
|
||||
it('reports a locked period instead of proposing a link the DB will refuse', async () => {
|
||||
const supabase = makeSupabase({
|
||||
vouchers: [makeVoucher({ id: 'je-1', fiscal_period_id: PERIOD_LOCKED })],
|
||||
})
|
||||
|
||||
const plan = await buildUnderlagPlan(supabase, 'company-1', ['A31.pdf'], PERIOD_LOCKED)
|
||||
|
||||
expect(plan.rows[0]).toMatchObject({ status: 'period_locked', journal_entry_id: 'je-1' })
|
||||
expect(plan.rows[0].candidates[0].period_locked).toBe(true)
|
||||
expect(plan.summary.period_locked).toBe(1)
|
||||
})
|
||||
|
||||
it('treats a period with locked_at set as locked even when not closed', async () => {
|
||||
const supabase = makeSupabase({
|
||||
vouchers: [makeVoucher({ id: 'je-1' })],
|
||||
periods: [{ ...PERIODS[0], locked_at: '2025-01-31T00:00:00Z' }],
|
||||
})
|
||||
|
||||
const plan = await buildUnderlagPlan(supabase, 'company-1', ['A31.pdf'], PERIOD_OPEN)
|
||||
|
||||
expect(plan.rows[0].status).toBe('period_locked')
|
||||
})
|
||||
|
||||
it('resolves ONLY inside the declared year when a ref exists in several', async () => {
|
||||
const supabase = makeSupabase({
|
||||
vouchers: [
|
||||
makeVoucher({ id: 'je-2023', fiscal_period_id: PERIOD_LOCKED, entry_date: '2023-03-14' }),
|
||||
makeVoucher({ id: 'je-2024' }),
|
||||
],
|
||||
})
|
||||
|
||||
const plan = await buildUnderlagPlan(supabase, 'company-1', ['A31.pdf'], PERIOD_OPEN)
|
||||
|
||||
expect(plan.rows[0].status).toBe('matched')
|
||||
expect(plan.rows[0].journal_entry_id).toBe('je-2024')
|
||||
// The other year's A31 is not even offered as a candidate.
|
||||
expect(plan.rows[0].candidates.map((c) => c.journal_entry_id)).toEqual(['je-2024'])
|
||||
})
|
||||
|
||||
it('NEVER proposes a verifikat outside the declared year, even as the only one', async () => {
|
||||
// The defect this scoping exists for: a partial migration, or a year whose
|
||||
// A31 the importer skipped, leaves exactly one A31 in the whole ledger.
|
||||
// Treating that single hit as identity attached a 2023 receipt to a 2025
|
||||
// verifikat, permanently and undetectably.
|
||||
const supabase = makeSupabase({
|
||||
vouchers: [makeVoucher({ id: 'je-other-year', fiscal_period_id: PERIOD_LOCKED })],
|
||||
})
|
||||
|
||||
const plan = await buildUnderlagPlan(supabase, 'company-1', ['A31.pdf'], PERIOD_OPEN)
|
||||
|
||||
expect(plan.rows[0].status).toBe('no_match')
|
||||
expect(plan.rows[0].journal_entry_id).toBeNull()
|
||||
expect(plan.rows[0].candidates).toEqual([])
|
||||
})
|
||||
|
||||
it('still hands back a choice when one ref repeats INSIDE the declared year', async () => {
|
||||
const supabase = makeSupabase({
|
||||
vouchers: [
|
||||
makeVoucher({ id: 'je-a' }),
|
||||
makeVoucher({ id: 'je-b', entry_date: '2024-09-02' }),
|
||||
],
|
||||
})
|
||||
|
||||
const plan = await buildUnderlagPlan(supabase, 'company-1', ['A31.pdf'], PERIOD_OPEN)
|
||||
|
||||
expect(plan.rows[0].status).toBe('ambiguous')
|
||||
expect(plan.rows[0].journal_entry_id).toBeNull()
|
||||
expect(plan.rows[0].candidates.map((c) => c.journal_entry_id)).toEqual(['je-a', 'je-b'])
|
||||
expect(plan.summary.ambiguous).toBe(1)
|
||||
})
|
||||
|
||||
it('reports which year the plan was resolved against', async () => {
|
||||
const supabase = makeSupabase({ vouchers: [makeVoucher({ id: 'je-1' })] })
|
||||
|
||||
const plan = await buildUnderlagPlan(supabase, 'company-1', ['A31.pdf'], PERIOD_OPEN)
|
||||
|
||||
expect(plan.fiscal_period_id).toBe(PERIOD_OPEN)
|
||||
})
|
||||
|
||||
it('never auto-selects a collision-list ref, even on a clean single hit', async () => {
|
||||
// "A4.pdf" is a scanner's paper size far more often than verifikat A4,
|
||||
// and verifikat A4 exists in every migrated ledger, so the collision is
|
||||
// guaranteed. The parse survives, the pre-tick does not.
|
||||
const supabase = makeSupabase({
|
||||
vouchers: [makeVoucher({ id: 'je-a4', source_voucher_number: 4, voucher_number: 4 })],
|
||||
})
|
||||
|
||||
const plan = await buildUnderlagPlan(supabase, 'company-1', ['A4 scan.pdf'], PERIOD_OPEN)
|
||||
|
||||
expect(plan.rows[0]).toMatchObject({
|
||||
status: 'needs_confirmation',
|
||||
parsed_ref: { series: 'A', number: 4 },
|
||||
journal_entry_id: 'je-a4',
|
||||
})
|
||||
})
|
||||
|
||||
it('never auto-selects a series-less filename, even on a single hit', async () => {
|
||||
const supabase = makeSupabase({ vouchers: [makeVoucher({ id: 'je-1' })] })
|
||||
|
||||
const plan = await buildUnderlagPlan(supabase, 'company-1', ['31.pdf'], PERIOD_OPEN)
|
||||
|
||||
expect(plan.rows[0]).toMatchObject({
|
||||
status: 'needs_confirmation',
|
||||
parsed_ref: { series: null, number: 31 },
|
||||
journal_entry_id: 'je-1',
|
||||
})
|
||||
expect(plan.summary.needs_confirmation).toBe(1)
|
||||
})
|
||||
|
||||
it('reports an unreadable filename as unparsed without touching the ledger', async () => {
|
||||
const supabase = makeSupabase({ vouchers: [makeVoucher({ id: 'je-1' })] })
|
||||
|
||||
const plan = await buildUnderlagPlan(supabase, 'company-1', ['kvitto ica.pdf'], PERIOD_OPEN)
|
||||
|
||||
expect(plan.rows[0]).toMatchObject({
|
||||
status: 'unparsed',
|
||||
parsed_ref: null,
|
||||
journal_entry_id: null,
|
||||
candidates: [],
|
||||
})
|
||||
expect(plan.summary.unparsed).toBe(1)
|
||||
})
|
||||
|
||||
it('flags a ledger with no source refs at all, so the miss is explained', async () => {
|
||||
const supabase = makeSupabase({ vouchers: [], sourceRefCount: 0 })
|
||||
|
||||
const plan = await buildUnderlagPlan(supabase, 'company-1', ['A31.pdf'], PERIOD_OPEN)
|
||||
|
||||
expect(plan.rows[0].status).toBe('no_match')
|
||||
expect(plan.no_source_refs).toBe(true)
|
||||
})
|
||||
|
||||
it('does not blame missing source refs when the ledger has them', async () => {
|
||||
const supabase = makeSupabase({ vouchers: [], sourceRefCount: 120 })
|
||||
|
||||
const plan = await buildUnderlagPlan(supabase, 'company-1', ['A31.pdf'], PERIOD_OPEN)
|
||||
|
||||
expect(plan.rows[0].status).toBe('no_match')
|
||||
expect(plan.no_source_refs).toBe(false)
|
||||
})
|
||||
|
||||
it('skips the diagnostic round-trip once anything matched', async () => {
|
||||
const supabase = makeSupabase({ vouchers: [makeVoucher({ id: 'je-1' })], sourceRefCount: 0 })
|
||||
|
||||
const plan = await buildUnderlagPlan(supabase, 'company-1', ['A31.pdf', 'kvitto.pdf'], PERIOD_OPEN)
|
||||
|
||||
expect(plan.no_source_refs).toBe(false)
|
||||
})
|
||||
|
||||
it('counts a mixed batch correctly', async () => {
|
||||
const supabase = makeSupabase({ vouchers: [makeVoucher({ id: 'je-1' })] })
|
||||
|
||||
const plan = await buildUnderlagPlan(supabase, 'company-1', [
|
||||
'A31_a.pdf',
|
||||
'A31_b.pdf',
|
||||
'A99.pdf',
|
||||
'kvitto.pdf',
|
||||
], PERIOD_OPEN)
|
||||
|
||||
expect(plan.summary).toEqual({
|
||||
total: 4,
|
||||
matched: 2,
|
||||
needs_confirmation: 0,
|
||||
ambiguous: 0,
|
||||
period_locked: 0,
|
||||
no_match: 1,
|
||||
unparsed: 1,
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
describe('planPermitsAttach', () => {
|
||||
it('override permits an unresolvable filename onto any same-year target', async () => {
|
||||
const supabase = makeSupabase({ vouchers: [] })
|
||||
|
||||
await expect(
|
||||
planPermitsAttach(supabase, 'company-1', 'kvitto ica.pdf', 'je-1', PERIOD_OPEN, true),
|
||||
).resolves.toBe(true)
|
||||
// A parsed ref with no candidate in the year is unresolvable too.
|
||||
await expect(
|
||||
planPermitsAttach(supabase, 'company-1', 'A99.pdf', 'je-1', PERIOD_OPEN, true),
|
||||
).resolves.toBe(true)
|
||||
})
|
||||
|
||||
it('override does NOT permit a resolvable filename onto a different target', async () => {
|
||||
// The hole this closes: a lying client could set override=true and scatter
|
||||
// cleanly-named underlag across arbitrary same-year verifikat.
|
||||
const supabase = makeSupabase({ vouchers: [makeVoucher({ id: 'je-1' })] })
|
||||
|
||||
await expect(
|
||||
planPermitsAttach(supabase, 'company-1', 'A31.pdf', 'je-other', PERIOD_OPEN, true),
|
||||
).resolves.toBe(false)
|
||||
// The target the filename actually points at stays permitted, of course.
|
||||
await expect(
|
||||
planPermitsAttach(supabase, 'company-1', 'A31.pdf', 'je-1', PERIOD_OPEN, true),
|
||||
).resolves.toBe(true)
|
||||
})
|
||||
|
||||
it('accepts the entry the filename resolves to', async () => {
|
||||
const supabase = makeSupabase({ vouchers: [makeVoucher({ id: 'je-1' })] })
|
||||
|
||||
await expect(planPermitsAttach(supabase, 'company-1', 'A31.pdf', 'je-1', PERIOD_OPEN, false)).resolves.toBe(true)
|
||||
})
|
||||
|
||||
it('accepts any candidate of an ambiguous filename: the user picked one', async () => {
|
||||
const supabase = makeSupabase({
|
||||
vouchers: [makeVoucher({ id: 'je-a' }), makeVoucher({ id: 'je-b' })],
|
||||
})
|
||||
|
||||
await expect(
|
||||
planPermitsAttach(supabase, 'company-1', 'A31.pdf', 'je-b', PERIOD_OPEN, false),
|
||||
).resolves.toBe(true)
|
||||
})
|
||||
|
||||
it('refuses a target in another fiscal year even when the ref matches', async () => {
|
||||
const supabase = makeSupabase({
|
||||
vouchers: [makeVoucher({ id: 'je-other-year', fiscal_period_id: PERIOD_LOCKED })],
|
||||
})
|
||||
|
||||
await expect(
|
||||
planPermitsAttach(supabase, 'company-1', 'A31.pdf', 'je-other-year', PERIOD_OPEN, false),
|
||||
).resolves.toBe(false)
|
||||
})
|
||||
|
||||
it('refuses an entry the filename does not point at', async () => {
|
||||
const supabase = makeSupabase({ vouchers: [makeVoucher({ id: 'je-1' })] })
|
||||
|
||||
await expect(planPermitsAttach(supabase, 'company-1', 'A31.pdf', 'je-other', PERIOD_OPEN, false)).resolves.toBe(
|
||||
false,
|
||||
)
|
||||
})
|
||||
|
||||
it('refuses an unreadable filename outright', async () => {
|
||||
const supabase = makeSupabase({ vouchers: [makeVoucher({ id: 'je-1' })] })
|
||||
|
||||
await expect(planPermitsAttach(supabase, 'company-1', 'kvitto.pdf', 'je-1', PERIOD_OPEN, false)).resolves.toBe(
|
||||
false,
|
||||
)
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,193 @@
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import {
|
||||
buildVoucherIndex,
|
||||
candidatesForNumber,
|
||||
candidatesForRef,
|
||||
periodIdForDate,
|
||||
resolveDatedRef,
|
||||
sourceVoucherLabel,
|
||||
voucherLabel,
|
||||
type FiscalPeriodRow,
|
||||
type VoucherRow,
|
||||
} from '@/lib/documents/voucher-ref-resolver'
|
||||
|
||||
const PERIOD_2024 = 'period-2024'
|
||||
const PERIOD_2025 = 'period-2025'
|
||||
|
||||
const periods: FiscalPeriodRow[] = [
|
||||
{
|
||||
id: PERIOD_2024,
|
||||
period_start: '2024-01-01',
|
||||
period_end: '2024-12-31',
|
||||
is_closed: false,
|
||||
locked_at: null,
|
||||
},
|
||||
{
|
||||
id: PERIOD_2025,
|
||||
period_start: '2025-01-01',
|
||||
period_end: '2025-12-31',
|
||||
is_closed: false,
|
||||
locked_at: null,
|
||||
},
|
||||
]
|
||||
|
||||
function makeVoucher(overrides: Partial<VoucherRow> & Pick<VoucherRow, 'id'>): VoucherRow {
|
||||
return {
|
||||
fiscal_period_id: PERIOD_2024,
|
||||
entry_date: '2024-03-14',
|
||||
description: 'Import: A31',
|
||||
voucher_series: 'A',
|
||||
voucher_number: 47,
|
||||
source_voucher_series: 'A',
|
||||
source_voucher_number: 31,
|
||||
...overrides,
|
||||
}
|
||||
}
|
||||
|
||||
describe('buildVoucherIndex', () => {
|
||||
it('indexes an entry by both its period key and its source ref', () => {
|
||||
const index = buildVoucherIndex([makeVoucher({ id: 'je-1' })])
|
||||
|
||||
expect(index.byPeriodKey.get(`${PERIOD_2024}|A|31`)).toBe('je-1')
|
||||
expect(candidatesForRef(index, { series: 'A', number: 31 })).toHaveLength(1)
|
||||
expect(index.ambiguousPeriodKeys.size).toBe(0)
|
||||
})
|
||||
|
||||
it('skips entries with no source ref (non-SIE and pre-2026-04 imports)', () => {
|
||||
const index = buildVoucherIndex([
|
||||
makeVoucher({ id: 'je-1', source_voucher_series: null, source_voucher_number: null }),
|
||||
])
|
||||
|
||||
expect(index.byPeriodKey.size).toBe(0)
|
||||
expect(index.bySourceRef.size).toBe(0)
|
||||
expect(index.byNumber.size).toBe(0)
|
||||
})
|
||||
|
||||
it('drops BOTH entries when one source ref repeats inside a fiscal year', () => {
|
||||
const index = buildVoucherIndex([
|
||||
makeVoucher({ id: 'je-1' }),
|
||||
makeVoucher({ id: 'je-2' }),
|
||||
])
|
||||
|
||||
expect(index.byPeriodKey.has(`${PERIOD_2024}|A|31`)).toBe(false)
|
||||
expect(index.ambiguousPeriodKeys.has(`${PERIOD_2024}|A|31`)).toBe(true)
|
||||
// Both stay discoverable so a caller can present the choice.
|
||||
expect(candidatesForRef(index, { series: 'A', number: 31 })).toHaveLength(2)
|
||||
})
|
||||
|
||||
it('keeps a third repeat out of byPeriodKey once the key is ambiguous', () => {
|
||||
const index = buildVoucherIndex([
|
||||
makeVoucher({ id: 'je-1' }),
|
||||
makeVoucher({ id: 'je-2' }),
|
||||
makeVoucher({ id: 'je-3' }),
|
||||
])
|
||||
|
||||
expect(index.byPeriodKey.has(`${PERIOD_2024}|A|31`)).toBe(false)
|
||||
expect(candidatesForRef(index, { series: 'A', number: 31 })).toHaveLength(3)
|
||||
})
|
||||
|
||||
it('keeps the same source ref in different fiscal years apart', () => {
|
||||
const index = buildVoucherIndex([
|
||||
makeVoucher({ id: 'je-2024' }),
|
||||
makeVoucher({ id: 'je-2025', fiscal_period_id: PERIOD_2025, entry_date: '2025-03-14' }),
|
||||
])
|
||||
|
||||
expect(index.byPeriodKey.get(`${PERIOD_2024}|A|31`)).toBe('je-2024')
|
||||
expect(index.byPeriodKey.get(`${PERIOD_2025}|A|31`)).toBe('je-2025')
|
||||
expect(candidatesForRef(index, { series: 'A', number: 31 })).toHaveLength(2)
|
||||
})
|
||||
|
||||
it('matches series case-insensitively on both sides', () => {
|
||||
const index = buildVoucherIndex([makeVoucher({ id: 'je-1', source_voucher_series: 'a' })])
|
||||
|
||||
expect(candidatesForRef(index, { series: 'A', number: 31 })).toHaveLength(1)
|
||||
expect(index.byPeriodKey.get(`${PERIOD_2024}|A|31`)).toBe('je-1')
|
||||
})
|
||||
})
|
||||
|
||||
describe('candidatesForNumber', () => {
|
||||
it('finds a number across every series', () => {
|
||||
const index = buildVoucherIndex([
|
||||
makeVoucher({ id: 'je-a', source_voucher_series: 'A' }),
|
||||
makeVoucher({ id: 'je-b', source_voucher_series: 'B' }),
|
||||
])
|
||||
|
||||
expect(candidatesForNumber(index, 31).map((v) => v.id)).toEqual(['je-a', 'je-b'])
|
||||
expect(candidatesForNumber(index, 999)).toEqual([])
|
||||
})
|
||||
})
|
||||
|
||||
describe('periodIdForDate', () => {
|
||||
it('finds the period containing the date, inclusive of both bounds', () => {
|
||||
expect(periodIdForDate(periods, '2024-01-01')).toBe(PERIOD_2024)
|
||||
expect(periodIdForDate(periods, '2024-12-31')).toBe(PERIOD_2024)
|
||||
expect(periodIdForDate(periods, '2025-06-01')).toBe(PERIOD_2025)
|
||||
expect(periodIdForDate(periods, '2023-06-01')).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
describe('resolveDatedRef', () => {
|
||||
const index = buildVoucherIndex([
|
||||
makeVoucher({ id: 'je-2024' }),
|
||||
makeVoucher({ id: 'je-2025', fiscal_period_id: PERIOD_2025, entry_date: '2025-03-14' }),
|
||||
])
|
||||
|
||||
it('resolves via the fiscal period the attachment date falls in', () => {
|
||||
expect(resolveDatedRef(index, periods, { series: 'A', number: 31, date: '2024-05-02' })).toBe(
|
||||
'je-2024',
|
||||
)
|
||||
expect(resolveDatedRef(index, periods, { series: 'A', number: 31, date: '2025-05-02' })).toBe(
|
||||
'je-2025',
|
||||
)
|
||||
})
|
||||
|
||||
it('returns undefined when the date falls outside every known period', () => {
|
||||
expect(
|
||||
resolveDatedRef(index, periods, { series: 'A', number: 31, date: '2023-05-02' }),
|
||||
).toBeUndefined()
|
||||
})
|
||||
|
||||
it('resolves a financial-year window when exactly one entry falls inside it', () => {
|
||||
expect(
|
||||
resolveDatedRef(index, periods, {
|
||||
series: 'A',
|
||||
number: 31,
|
||||
date: '2024-01-01',
|
||||
dateTo: '2024-12-31',
|
||||
}),
|
||||
).toBe('je-2024')
|
||||
})
|
||||
|
||||
it('refuses a financial-year window that spans two candidates', () => {
|
||||
expect(
|
||||
resolveDatedRef(index, periods, {
|
||||
series: 'A',
|
||||
number: 31,
|
||||
date: '2024-01-01',
|
||||
dateTo: '2025-12-31',
|
||||
}),
|
||||
).toBeUndefined()
|
||||
})
|
||||
|
||||
it('returns undefined for an ambiguous key rather than picking one', () => {
|
||||
const ambiguous = buildVoucherIndex([makeVoucher({ id: 'je-1' }), makeVoucher({ id: 'je-2' })])
|
||||
|
||||
expect(
|
||||
resolveDatedRef(ambiguous, periods, { series: 'A', number: 31, date: '2024-05-02' }),
|
||||
).toBeUndefined()
|
||||
})
|
||||
})
|
||||
|
||||
describe('labels', () => {
|
||||
it('separates our voucher label from the source label', () => {
|
||||
const entry = makeVoucher({ id: 'je-1' })
|
||||
|
||||
expect(voucherLabel(entry)).toBe('A47')
|
||||
expect(sourceVoucherLabel(entry)).toBe('A31')
|
||||
})
|
||||
|
||||
it('returns null when a label is not fully populated', () => {
|
||||
expect(voucherLabel({ voucher_series: 'A', voucher_number: null })).toBeNull()
|
||||
expect(sourceVoucherLabel({ source_voucher_series: null, source_voucher_number: 31 })).toBeNull()
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,174 @@
|
||||
/**
|
||||
* Read a source-system voucher reference out of an underlag filename.
|
||||
*
|
||||
* Systems that export receipts alongside a SIE file name each file after the
|
||||
* verifikat it belongs to: SpeedLedger writes `A31_<internal-uuid>.pdf`, Fortnox
|
||||
* `V123.pdf`, others `2024-A-31 kvitto.pdf`. That prefix is a deterministic
|
||||
* pointer into the ledger, which is why underlag import does not need to read
|
||||
* the document at all: no AI, no amount matching, no date windows.
|
||||
*
|
||||
* Design rule: an unrecognised name returns null. A wrong parse attaches
|
||||
* räkenskapsinformation to the wrong verifikat, and that cannot be undone
|
||||
* (BFL 7 kap), so the cost of guessing is far higher than the cost of asking.
|
||||
*/
|
||||
|
||||
export type VoucherRefPattern =
|
||||
/** `A31`, `A31_uuid`, `A-31 kvitto`, `2024_A31`, `ver A31` */
|
||||
| 'series_number'
|
||||
/** `31`, `31_kvitto`: a number with no series at all. */
|
||||
| 'number_only'
|
||||
|
||||
export interface ParsedFileNameRef {
|
||||
/** Null when the filename carried a number but no series. */
|
||||
series: string | null
|
||||
number: number
|
||||
pattern: VoucherRefPattern
|
||||
/**
|
||||
* Whether this parse may be pre-selected in a bulk plan. Three classes are
|
||||
* never auto-selectable, even on a single-candidate hit:
|
||||
* - series-less parses (`31.pdf` can point at any series);
|
||||
* - refs on the collision list (`A4.pdf` is far more often a scanner's
|
||||
* paper size than verifikat A4, `K10.pdf` a blankett);
|
||||
* - three-letter series (`IMG_0031.jpg`: real SIE series are 1-2 chars,
|
||||
* three letters is a camera or scanner prefix).
|
||||
* They all still parse and resolve; a human confirms with one click.
|
||||
*/
|
||||
autoSelectable: boolean
|
||||
}
|
||||
|
||||
/**
|
||||
* Optional noise ahead of the reference: a year folder prefix and the words
|
||||
* some exporters prepend. Kept tight on purpose, `(?:19|20)\d{2}` rather than
|
||||
* any 4 digits, so a voucher number is never eaten as a year.
|
||||
*
|
||||
* `ifikation` must precede `ifikat` in the alternation: regex alternation is
|
||||
* first-match, so the short branch would otherwise consume `Verifikat` out of
|
||||
* `Verifikation 31` and leave `ion` for the series group to swallow.
|
||||
*/
|
||||
const YEAR_NOISE = '(?:(?:19|20)\\d{2}[-_. ]+)?'
|
||||
/**
|
||||
* The lookahead is load-bearing, not decoration. Without it the engine
|
||||
* backtracks into the shorter alternatives and `Verifikation 31` matches `ver`
|
||||
* + `ifikat`, leaving `ion` for the series group to swallow as series `ION`.
|
||||
* Requiring the word to end here means the prefix is either the whole word or
|
||||
* not consumed at all.
|
||||
*/
|
||||
const VER_NOISE = '(?:ver(?:ifikation|ifikat)?(?![A-Za-zÅÄÖåäö])[-_. ]*)?'
|
||||
|
||||
/** `A31`, `A-31`, `A_31`, `A 31`, optionally followed by `_`/`-`/space + anything. */
|
||||
const SERIES_NUMBER_RE = new RegExp(
|
||||
`^${YEAR_NOISE}${VER_NOISE}([A-Za-zÅÄÖåäö]{1,3})[-_. ]?(\\d{1,7})(?:[-_. ].*)?$`,
|
||||
'i',
|
||||
)
|
||||
|
||||
/**
|
||||
* `31`, `31_kvitto`, `Verifikat 31`. The `ver` prefix is allowed here but the
|
||||
* year prefix is NOT: `2024 31` is far more likely a date fragment than
|
||||
* voucher 31 of 2024, and this branch has no series to corroborate it with.
|
||||
*/
|
||||
const NUMBER_ONLY_RE = new RegExp(`^${VER_NOISE}(\\d{1,6})(?:[-_. ].*)?$`, 'i')
|
||||
|
||||
/**
|
||||
* A date-named file, never a voucher number. Deliberately loose where the
|
||||
* parser is strict: unpadded components (`2024-1-31`), two-digit years
|
||||
* (`24-01-31`), any of `-_. /` as separator, and the compact `20240131`.
|
||||
* A false positive here costs one manual assignment; a false negative attaches
|
||||
* a receipt to a verifikat whose number happens to equal a year fragment.
|
||||
*/
|
||||
const DATE_PREFIX_RE = new RegExp(
|
||||
'^(?:' +
|
||||
// 20240131
|
||||
'(?:19|20)\\d{6}' +
|
||||
// 2024-01-31, 2024-1-31, 24-01-31, 2024 01 31, 2024/01/31
|
||||
'|(?:19|20)?\\d{2}[-_. /]\\d{1,2}[-_. /]\\d{1,2}' +
|
||||
// 31.01.2024, 31/1/2024, 12-24-2024: day-first and US order. Without this
|
||||
// the day becomes a voucher number that always exists in the year.
|
||||
'|\\d{1,2}[-_. /]\\d{1,2}[-_. /](?:19|20)\\d{2}' +
|
||||
')(?!\\d)',
|
||||
)
|
||||
|
||||
/**
|
||||
* `ver` is a prefix word, never a series. Without this `ver 31.pdf` parses as
|
||||
* series VER and comes back auto-selectable, while the spelled-out
|
||||
* `Verifikat 31.pdf` correctly yields a series-less reference that requires
|
||||
* confirmation. Same filename, two trust levels, decided by an abbreviation.
|
||||
*/
|
||||
const NOT_A_SERIES = new Set(['VER'])
|
||||
|
||||
/**
|
||||
* Refs that are, in the wild, far more often document names than voucher
|
||||
* references: A0-A6 are paper sizes (every scanner emits an `A4.pdf`),
|
||||
* K2-K13 / N1-N9 / T1-T2 are Skatteverket blanketter, Q1-Q4 are quarters.
|
||||
* Verifikat A4 genuinely exists in every migrated ledger, which is exactly
|
||||
* why these must not be pre-selected: the review table cannot tell a scanned
|
||||
* "A4.pdf" from the real receipt for voucher A4, and a wrong link is
|
||||
* permanent. Demoted, not refused: a genuine A4 costs one click.
|
||||
*
|
||||
* The inconsistency this fixes: `31.pdf` already required confirmation while
|
||||
* `A4 scan.pdf`, which carries LESS voucher evidence in a single-series
|
||||
* company, was pre-ticked.
|
||||
*/
|
||||
const COLLISION_REFS = new Set([
|
||||
'A0', 'A1', 'A2', 'A3', 'A4', 'A5', 'A6',
|
||||
'K2', 'K3', 'K4', 'K5', 'K6', 'K7', 'K8', 'K9', 'K10', 'K11', 'K12', 'K13',
|
||||
'N1', 'N2', 'N3', 'N4', 'N5', 'N6', 'N7', 'N8', 'N9',
|
||||
'T1', 'T2',
|
||||
'Q1', 'Q2', 'Q3', 'Q4',
|
||||
])
|
||||
|
||||
/** Real SIE series are 1-2 characters; three letters is IMG/DSC/DOC/SCN. */
|
||||
const MAX_AUTO_SERIES_LENGTH = 2
|
||||
|
||||
/**
|
||||
* Any four-digit run that reads as a calendar year. Used to refuse a
|
||||
* SERIES-LESS parse: `2024` alone is overwhelmingly a year, not verifikat 2024.
|
||||
*/
|
||||
const YEAR_LIKE_RE = /^(?:19|20)\d{2}$/
|
||||
|
||||
/**
|
||||
* Trim only. Directory components are NOT stripped: `file.name` from an
|
||||
* `<input type=file>` never carries a path, while the manual-reference box
|
||||
* feeds arbitrary user text through this same parser, where splitting on `/`
|
||||
* would quietly turn the typed date `2024/01/31` into voucher 31.
|
||||
*/
|
||||
function baseName(fileName: string): string {
|
||||
return fileName.trim()
|
||||
}
|
||||
|
||||
/** Drop the extension, but only a real-looking one (`.pdf`, `.jpeg`). */
|
||||
function stripExtension(name: string): string {
|
||||
return name.replace(/\.[A-Za-z0-9]{1,5}$/, '')
|
||||
}
|
||||
|
||||
export function parseVoucherRefFromFileName(fileName: string): ParsedFileNameRef | null {
|
||||
const stem = stripExtension(baseName(fileName))
|
||||
if (!stem) return null
|
||||
|
||||
// A file named after its date is the single most common false positive: the
|
||||
// digits parse cleanly and point at a verifikat number that has nothing to do
|
||||
// with the receipt. Refuse the whole name rather than try to be clever.
|
||||
if (DATE_PREFIX_RE.test(stem)) return null
|
||||
|
||||
const seriesMatch = SERIES_NUMBER_RE.exec(stem)
|
||||
if (seriesMatch) {
|
||||
const series = seriesMatch[1].toUpperCase()
|
||||
const number = Number(seriesMatch[2])
|
||||
if (!NOT_A_SERIES.has(series) && Number.isInteger(number) && number > 0) {
|
||||
// The check runs on the NORMALIZED ref: a scanner's `A0004.pdf` parses
|
||||
// to number 4 and must be caught by the same A4 entry.
|
||||
const autoSelectable =
|
||||
series.length <= MAX_AUTO_SERIES_LENGTH && !COLLISION_REFS.has(`${series}${number}`)
|
||||
return { series, number, pattern: 'series_number', autoSelectable }
|
||||
}
|
||||
}
|
||||
|
||||
const numberMatch = NUMBER_ONLY_RE.exec(stem)
|
||||
if (numberMatch && !YEAR_LIKE_RE.test(numberMatch[1])) {
|
||||
const number = Number(numberMatch[1])
|
||||
if (Number.isInteger(number) && number > 0) {
|
||||
return { series: null, number, pattern: 'number_only', autoSelectable: false }
|
||||
}
|
||||
}
|
||||
|
||||
return null
|
||||
}
|
||||
@@ -0,0 +1,286 @@
|
||||
/**
|
||||
* Underlag import: attach a folder of receipt files to already-migrated
|
||||
* verifikat, using nothing but the voucher reference in each filename.
|
||||
*
|
||||
* A SIE file carries the ledger but not the underlag, so a migrating customer
|
||||
* has to bring the receipts over separately. Systems that export both name each
|
||||
* receipt after its verifikat (`A31_<id>.pdf`), and the SIE import preserved
|
||||
* that same identity on every entry, so the pairing is a lookup rather than an
|
||||
* interpretation. No AI, no amount matching, no date windows.
|
||||
*
|
||||
* This module only PLANS. Nothing here writes: the plan goes back to the user,
|
||||
* who approves it, and each approved row is then attached one file at a time.
|
||||
* That split is deliberate: linking a document to a posted verifikat makes it
|
||||
* räkenskapsinformation, which can never be re-pointed (BFL 7 kap), so a bulk
|
||||
* write with no preview would be an unrecoverable mistake by design.
|
||||
*
|
||||
* EVERY plan is scoped to one fiscal year, which the user declares. That is not
|
||||
* ceremony. Source systems restart voucher numbering every year and a filename
|
||||
* carries no year, so `A31` alone does not identify a verifikat. An earlier
|
||||
* version resolved company-wide and treated "only one candidate exists" as
|
||||
* proof of identity: with a partial migration, or with the year's A31 among the
|
||||
* vouchers the importer skipped (empty, single-line, unbalanced), that silently
|
||||
* attached a 2023 receipt to a 2025 verifikat, permanently. Cardinality is not
|
||||
* identity. Scoping cannot make the year inferable, so it makes it asserted:
|
||||
* a file can only ever land in the year the user named.
|
||||
*/
|
||||
|
||||
import type { SupabaseClient } from '@supabase/supabase-js'
|
||||
import { parseVoucherRefFromFileName } from '@/lib/documents/filename-voucher-ref'
|
||||
import {
|
||||
buildVoucherIndex,
|
||||
candidatesForNumber,
|
||||
candidatesForRef,
|
||||
fetchFiscalPeriods,
|
||||
fetchVouchersForNumbers,
|
||||
hasSourceRefVouchers,
|
||||
sourceVoucherLabel,
|
||||
voucherLabel,
|
||||
type FiscalPeriodRow,
|
||||
type VoucherRow,
|
||||
} from '@/lib/documents/voucher-ref-resolver'
|
||||
|
||||
export type UnderlagPlanStatus =
|
||||
/** Exactly one open verifikat: safe to pre-select. */
|
||||
| 'matched'
|
||||
/** Resolved, but the filename gave no series: a human confirms the pick. */
|
||||
| 'needs_confirmation'
|
||||
/** The ref exists in several fiscal years: the user picks which one. */
|
||||
| 'ambiguous'
|
||||
/** The only candidate sits in a closed or locked period: the DB will refuse. */
|
||||
| 'period_locked'
|
||||
/** Parsed a ref, but no migrated verifikat carries it. */
|
||||
| 'no_match'
|
||||
/** The filename carries no readable voucher reference. */
|
||||
| 'unparsed'
|
||||
|
||||
export interface UnderlagPlanCandidate {
|
||||
journal_entry_id: string
|
||||
/** Our own label after renumbering, e.g. `A47`. */
|
||||
voucher_label: string | null
|
||||
/** The label the source system used, i.e. what the filename says, e.g. `A31`. */
|
||||
source_voucher_label: string | null
|
||||
entry_date: string
|
||||
description: string | null
|
||||
period_locked: boolean
|
||||
}
|
||||
|
||||
export interface UnderlagPlanRow {
|
||||
file_name: string
|
||||
status: UnderlagPlanStatus
|
||||
parsed_ref: { series: string | null; number: number } | null
|
||||
/** The single resolved target, when there is exactly one. */
|
||||
journal_entry_id: string | null
|
||||
/** Every candidate, so an ambiguous row can be resolved by hand. */
|
||||
candidates: UnderlagPlanCandidate[]
|
||||
}
|
||||
|
||||
export interface UnderlagPlanSummary {
|
||||
total: number
|
||||
matched: number
|
||||
needs_confirmation: number
|
||||
ambiguous: number
|
||||
period_locked: number
|
||||
no_match: number
|
||||
unparsed: number
|
||||
}
|
||||
|
||||
export interface UnderlagPlan {
|
||||
rows: UnderlagPlanRow[]
|
||||
summary: UnderlagPlanSummary
|
||||
/** The fiscal year every row in this plan was resolved against. */
|
||||
fiscal_period_id: string
|
||||
/**
|
||||
* True when the SELECTED fiscal year holds no migrated entry carrying a
|
||||
* source voucher ref. Either that year was never imported from SIE, or the
|
||||
* import predates the columns (added 2026-04-21 and never backfilled), in
|
||||
* which case filename matching cannot work for it at all and the UI must say
|
||||
* so instead of showing 400 misses. Often it just means the wrong year is
|
||||
* selected, which is the first thing worth telling the user.
|
||||
*/
|
||||
no_source_refs: boolean
|
||||
}
|
||||
|
||||
function isPeriodLocked(period: FiscalPeriodRow | undefined): boolean {
|
||||
return period ? period.is_closed || period.locked_at !== null : false
|
||||
}
|
||||
|
||||
function toCandidate(entry: VoucherRow, periods: Map<string, FiscalPeriodRow>): UnderlagPlanCandidate {
|
||||
return {
|
||||
journal_entry_id: entry.id,
|
||||
voucher_label: voucherLabel(entry),
|
||||
source_voucher_label: sourceVoucherLabel(entry),
|
||||
entry_date: entry.entry_date,
|
||||
description: entry.description ?? null,
|
||||
period_locked: isPeriodLocked(periods.get(entry.fiscal_period_id)),
|
||||
}
|
||||
}
|
||||
|
||||
function emptySummary(): UnderlagPlanSummary {
|
||||
return {
|
||||
total: 0,
|
||||
matched: 0,
|
||||
needs_confirmation: 0,
|
||||
ambiguous: 0,
|
||||
period_locked: 0,
|
||||
no_match: 0,
|
||||
unparsed: 0,
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the match plan for a set of filenames, inside one declared fiscal year.
|
||||
* Reads only: no upload, no link.
|
||||
*
|
||||
* The same function backs the preview and the per-file attach check, so the
|
||||
* server can never link a file to a verifikat the preview would not have
|
||||
* proposed.
|
||||
*/
|
||||
export async function buildUnderlagPlan(
|
||||
supabase: SupabaseClient,
|
||||
companyId: string,
|
||||
fileNames: string[],
|
||||
fiscalPeriodId: string,
|
||||
): Promise<UnderlagPlan> {
|
||||
const parsed = fileNames.map((fileName) => ({
|
||||
fileName,
|
||||
ref: parseVoucherRefFromFileName(fileName),
|
||||
}))
|
||||
|
||||
const numbers = parsed.map((p) => p.ref?.number).filter((n): n is number => n != null)
|
||||
|
||||
const [vouchers, periodRows] = await Promise.all([
|
||||
fetchVouchersForNumbers(supabase, companyId, numbers, fiscalPeriodId),
|
||||
fetchFiscalPeriods(supabase, companyId),
|
||||
])
|
||||
|
||||
// The single most important line in this module: candidates outside the
|
||||
// declared year are dropped BEFORE the index is built, so no downstream
|
||||
// branch can ever see, count or propose one.
|
||||
const index = buildVoucherIndex(
|
||||
vouchers.filter((entry) => entry.fiscal_period_id === fiscalPeriodId),
|
||||
)
|
||||
const periods = new Map(periodRows.map((p) => [p.id, p]))
|
||||
|
||||
const summary = emptySummary()
|
||||
summary.total = parsed.length
|
||||
|
||||
const rows: UnderlagPlanRow[] = parsed.map(({ fileName, ref }) => {
|
||||
if (!ref) {
|
||||
summary.unparsed++
|
||||
return {
|
||||
file_name: fileName,
|
||||
status: 'unparsed',
|
||||
parsed_ref: null,
|
||||
journal_entry_id: null,
|
||||
candidates: [],
|
||||
}
|
||||
}
|
||||
|
||||
const parsedRef = { series: ref.series, number: ref.number }
|
||||
const entries = ref.series
|
||||
? candidatesForRef(index, { series: ref.series, number: ref.number })
|
||||
: candidatesForNumber(index, ref.number)
|
||||
const candidates = entries.map((entry) => toCandidate(entry, periods))
|
||||
|
||||
if (candidates.length === 0) {
|
||||
summary.no_match++
|
||||
return {
|
||||
file_name: fileName,
|
||||
status: 'no_match',
|
||||
parsed_ref: parsedRef,
|
||||
journal_entry_id: null,
|
||||
candidates: [],
|
||||
}
|
||||
}
|
||||
|
||||
if (candidates.length > 1) {
|
||||
// Inside one fiscal year a source ref should be unique, so this is either
|
||||
// a re-imported year or a series-less filename hitting several series.
|
||||
// Hand the choice back rather than pick.
|
||||
summary.ambiguous++
|
||||
return {
|
||||
file_name: fileName,
|
||||
status: 'ambiguous',
|
||||
parsed_ref: parsedRef,
|
||||
journal_entry_id: null,
|
||||
candidates,
|
||||
}
|
||||
}
|
||||
|
||||
const only = candidates[0]
|
||||
if (only.period_locked) {
|
||||
summary.period_locked++
|
||||
return {
|
||||
file_name: fileName,
|
||||
status: 'period_locked',
|
||||
parsed_ref: parsedRef,
|
||||
journal_entry_id: only.journal_entry_id,
|
||||
candidates,
|
||||
}
|
||||
}
|
||||
|
||||
if (!ref.autoSelectable) {
|
||||
summary.needs_confirmation++
|
||||
return {
|
||||
file_name: fileName,
|
||||
status: 'needs_confirmation',
|
||||
parsed_ref: parsedRef,
|
||||
journal_entry_id: only.journal_entry_id,
|
||||
candidates,
|
||||
}
|
||||
}
|
||||
|
||||
summary.matched++
|
||||
return {
|
||||
file_name: fileName,
|
||||
status: 'matched',
|
||||
parsed_ref: parsedRef,
|
||||
journal_entry_id: only.journal_entry_id,
|
||||
candidates,
|
||||
}
|
||||
})
|
||||
|
||||
// Only worth a round-trip when nothing landed: the answer distinguishes
|
||||
// "wrong filenames" from "this year holds no source refs to match against",
|
||||
// which most often means the wrong year is selected.
|
||||
const no_source_refs =
|
||||
summary.matched + summary.needs_confirmation + summary.ambiguous + summary.period_locked === 0
|
||||
? !(await hasSourceRefVouchers(supabase, companyId, fiscalPeriodId))
|
||||
: false
|
||||
|
||||
return { rows, summary, fiscal_period_id: fiscalPeriodId, no_source_refs }
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether attaching `fileName` to `journalEntryId` is permitted by the plan.
|
||||
*
|
||||
* Guards the attach route against a stale or wrong client: the file the browser
|
||||
* uploads must land on a verifikat the preview would propose for that name.
|
||||
* `fiscalPeriodId` is the caller-supplied declared year, which the route has
|
||||
* ALREADY asserted equal to the target entry's own period before calling this;
|
||||
* this function only decides the filename-to-target question inside that year.
|
||||
*
|
||||
* `override` marks a deliberate manual assignment. It is honored ONLY when the
|
||||
* filename is unresolvable in the declared year (no parse, or no candidate):
|
||||
* a filename the resolver CAN place must land where it points, override or
|
||||
* not, otherwise a lying client could scatter cleanly-named underlag across
|
||||
* arbitrary same-year verifikat. The shipped UI only ever overrides rows whose
|
||||
* filenames resolved to nothing, so this costs it no capability.
|
||||
*/
|
||||
export async function planPermitsAttach(
|
||||
supabase: SupabaseClient,
|
||||
companyId: string,
|
||||
fileName: string,
|
||||
journalEntryId: string,
|
||||
fiscalPeriodId: string,
|
||||
override: boolean,
|
||||
): Promise<boolean> {
|
||||
const plan = await buildUnderlagPlan(supabase, companyId, [fileName], fiscalPeriodId)
|
||||
const row = plan.rows[0]
|
||||
if (!row) return false
|
||||
if (row.candidates.some((candidate) => candidate.journal_entry_id === journalEntryId)) {
|
||||
return true
|
||||
}
|
||||
return override && row.candidates.length === 0
|
||||
}
|
||||
@@ -0,0 +1,314 @@
|
||||
/**
|
||||
* Resolve a SOURCE-system voucher reference to the gnubok verifikat it became.
|
||||
*
|
||||
* The SIE importer renumbers vouchers per target series (so source `A31` may
|
||||
* land as `A47` here), but it preserves the source identity on every entry:
|
||||
* `journal_entries.source_voucher_series` + `source_voucher_number`, written by
|
||||
* the `import_sie_journal_entries` RPC straight from #VER. That pair is the only
|
||||
* safe join key back to the old system. Matching on our own `voucher_number`
|
||||
* instead silently attaches underlag to the wrong verifikat as soon as the
|
||||
* import skipped an empty or unbalanced voucher, which it routinely does.
|
||||
*
|
||||
* Two consumers, one resolution truth:
|
||||
* - the provider migration sweep (Bokio/Fortnox), which knows each attachment's
|
||||
* voucher ref AND its date/financial year, and
|
||||
* - the underlag file import, which only knows what the filename says.
|
||||
*
|
||||
* Hence two entry points: `resolveDatedRef` when a date narrows the candidates,
|
||||
* and `candidatesForRef` when it does not and the caller must handle ambiguity
|
||||
* itself (surface the choice rather than guess: an underlag on the wrong
|
||||
* verifikat is räkenskapsinformation and cannot be re-pointed afterwards).
|
||||
*/
|
||||
|
||||
import type { SupabaseClient } from '@supabase/supabase-js'
|
||||
import { fetchAllRows } from '@/lib/supabase/fetch-all'
|
||||
|
||||
/** A voucher as written in the source system. */
|
||||
export interface SourceVoucherRef {
|
||||
series: string
|
||||
number: number
|
||||
}
|
||||
|
||||
/** A source ref plus the date window that narrows it to one fiscal year. */
|
||||
export interface DatedSourceVoucherRef extends SourceVoucherRef {
|
||||
/** Attachment date, or the financial year start when only that is known. */
|
||||
date: string
|
||||
/** Financial year end, when the source only pins the attachment to a year. */
|
||||
dateTo?: string
|
||||
}
|
||||
|
||||
export interface VoucherRow {
|
||||
id: string
|
||||
fiscal_period_id: string
|
||||
entry_date: string
|
||||
source_voucher_series: string | null
|
||||
source_voucher_number: number | null
|
||||
// Display-only, and fetched only by the reads that need them: the provider
|
||||
// sweep resolves thousands of entries and never renders any of this.
|
||||
description?: string | null
|
||||
voucher_series?: string | null
|
||||
voucher_number?: number | null
|
||||
}
|
||||
|
||||
export interface FiscalPeriodRow {
|
||||
id: string
|
||||
period_start: string
|
||||
period_end: string
|
||||
is_closed: boolean
|
||||
locked_at: string | null
|
||||
}
|
||||
|
||||
export interface VoucherIndex {
|
||||
/**
|
||||
* (period, series, number) → entry id, for keys that resolve to exactly one
|
||||
* verifikat. Keys seen more than once are removed and recorded as ambiguous.
|
||||
*/
|
||||
byPeriodKey: Map<string, string>
|
||||
/** "series|number" → every entry carrying it, across all fiscal years. */
|
||||
bySourceRef: Map<string, VoucherRow[]>
|
||||
/** number → every entry carrying it in ANY series, for series-less filenames. */
|
||||
byNumber: Map<number, VoucherRow[]>
|
||||
ambiguousPeriodKeys: Set<string>
|
||||
}
|
||||
|
||||
/** Find the fiscal period whose date range contains a given date. */
|
||||
export function periodIdForDate(periods: FiscalPeriodRow[], date: string): string | null {
|
||||
const period = periods.find((p) => p.period_start <= date && date <= p.period_end)
|
||||
return period?.id ?? null
|
||||
}
|
||||
|
||||
/**
|
||||
* Series comparison is case-insensitive on both sides of the join. SIE writes
|
||||
* series uppercase in practice but the spec does not require it, and a filename
|
||||
* is whatever the user's export tool produced: `a31.pdf` must still find `A31`.
|
||||
*/
|
||||
function normalizeSeries(series: string): string {
|
||||
return series.trim().toUpperCase()
|
||||
}
|
||||
|
||||
/**
|
||||
* In-memory key for a verifikat: fiscal period + series + number. Scoping by
|
||||
* period is essential: source systems restart voucher numbering every year, so
|
||||
* `A31` alone is not unique once several years are migrated.
|
||||
*/
|
||||
export function voucherKey(periodId: string, series: string, number: number): string {
|
||||
return `${periodId}|${normalizeSeries(series)}|${number}`
|
||||
}
|
||||
|
||||
/** "series|number", the period-agnostic key. */
|
||||
export function sourceRefKey(series: string, number: number): string {
|
||||
return `${normalizeSeries(series)}|${number}`
|
||||
}
|
||||
|
||||
export function buildVoucherIndex(vouchers: VoucherRow[]): VoucherIndex {
|
||||
const byPeriodKey = new Map<string, string>()
|
||||
const bySourceRef = new Map<string, VoucherRow[]>()
|
||||
const byNumber = new Map<number, VoucherRow[]>()
|
||||
const ambiguousPeriodKeys = new Set<string>()
|
||||
|
||||
// Get-or-create + push, never copy: the provider sweep indexes every
|
||||
// migrated entry in the company, and per-row array copies turn that O(n²).
|
||||
const appendTo = <K,>(map: Map<K, VoucherRow[]>, key: K, row: VoucherRow) => {
|
||||
const list = map.get(key)
|
||||
if (list) list.push(row)
|
||||
else map.set(key, [row])
|
||||
}
|
||||
|
||||
for (const v of vouchers) {
|
||||
if (v.source_voucher_series == null || v.source_voucher_number == null) continue
|
||||
|
||||
appendTo(bySourceRef, sourceRefKey(v.source_voucher_series, v.source_voucher_number), v)
|
||||
appendTo(byNumber, v.source_voucher_number, v)
|
||||
|
||||
const key = voucherKey(v.fiscal_period_id, v.source_voucher_series, v.source_voucher_number)
|
||||
if (byPeriodKey.has(key)) {
|
||||
// Two entries share one source ref inside one fiscal year: neither can be
|
||||
// chosen without guessing, so drop both rather than attach blind.
|
||||
byPeriodKey.delete(key)
|
||||
ambiguousPeriodKeys.add(key)
|
||||
} else if (!ambiguousPeriodKeys.has(key)) {
|
||||
byPeriodKey.set(key, v.id)
|
||||
}
|
||||
}
|
||||
|
||||
return { byPeriodKey, bySourceRef, byNumber, ambiguousPeriodKeys }
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve a ref that carries date information. Returns undefined when the ref
|
||||
* matches nothing or is ambiguous: callers count it as unmatched, never guess.
|
||||
*/
|
||||
export function resolveDatedRef(
|
||||
index: VoucherIndex,
|
||||
periods: FiscalPeriodRow[],
|
||||
ref: DatedSourceVoucherRef,
|
||||
): string | undefined {
|
||||
if (ref.dateTo) {
|
||||
// The source pinned the attachment to a financial year, not a day: accept
|
||||
// it only when exactly one migrated verifikat in that window carries the ref.
|
||||
const candidates = (index.bySourceRef.get(sourceRefKey(ref.series, ref.number)) ?? []).filter(
|
||||
(voucher) => ref.date <= voucher.entry_date && voucher.entry_date <= ref.dateTo!,
|
||||
)
|
||||
return candidates.length === 1 ? candidates[0].id : undefined
|
||||
}
|
||||
|
||||
const periodId = periodIdForDate(periods, ref.date)
|
||||
return periodId ? index.byPeriodKey.get(voucherKey(periodId, ref.series, ref.number)) : undefined
|
||||
}
|
||||
|
||||
/**
|
||||
* Every migrated verifikat carrying a source ref, across all fiscal years.
|
||||
* A filename gives no date, so a ref that hits several years is genuinely
|
||||
* ambiguous and the caller must ask instead of picking one.
|
||||
*/
|
||||
export function candidatesForRef(index: VoucherIndex, ref: SourceVoucherRef): VoucherRow[] {
|
||||
return index.bySourceRef.get(sourceRefKey(ref.series, ref.number)) ?? []
|
||||
}
|
||||
|
||||
/**
|
||||
* Candidates for a filename that carried a number but no series (`31.pdf`).
|
||||
* Searches every series, so this is only usable when it yields exactly one hit,
|
||||
* and the caller must still make a human confirm it.
|
||||
*/
|
||||
export function candidatesForNumber(index: VoucherIndex, number: number): VoucherRow[] {
|
||||
return index.byNumber.get(number) ?? []
|
||||
}
|
||||
|
||||
// Both selects are written out inline at their call site rather than hoisted
|
||||
// into a shared constant. tests/schema/no-phantom-columns.test.ts resolves
|
||||
// column lists by scanning the AST for string literals passed to .select();
|
||||
// a constant is opaque to it, and hiding this query surface would drop all
|
||||
// eight journal_entries columns out of the phantom-column net on the one code
|
||||
// path that writes irreversible räkenskapsinformation links.
|
||||
|
||||
/**
|
||||
* Statuses a resolved verifikat may have to receive underlag. Posted is the
|
||||
* normal case; reversed stays in, because a storno'd original remains
|
||||
* räkenskapsinformation and its underlag belongs on it. Draft and cancelled
|
||||
* are excluded: the SIE import RPC posts every entry inside its own
|
||||
* transaction, so a draft with a source ref should be unobservable, but the
|
||||
* link is irreversible, and an invariant that lives in another file is not an
|
||||
* invariant this module may lean on.
|
||||
*/
|
||||
const ATTACHABLE_STATUSES = ['posted', 'reversed']
|
||||
|
||||
/**
|
||||
* All entries that carry a source voucher ref, resolution columns only.
|
||||
*
|
||||
* A stable `.order('id')` is required: fetchAllRows pages with `.range()`, and
|
||||
* PostgREST paging without a deterministic order can skip or repeat rows once
|
||||
* the table exceeds one page (journal_entries crosses 1000 after a couple of
|
||||
* migrated years), which would defeat both resolution and any dedup built on it.
|
||||
*/
|
||||
export async function fetchSourceRefVouchers(
|
||||
supabase: SupabaseClient,
|
||||
companyId: string,
|
||||
): Promise<VoucherRow[]> {
|
||||
return fetchAllRows<VoucherRow>(({ from, to }) =>
|
||||
supabase
|
||||
.from('journal_entries')
|
||||
.select('id, fiscal_period_id, entry_date, source_voucher_series, source_voucher_number')
|
||||
.eq('company_id', companyId)
|
||||
.not('source_voucher_number', 'is', null)
|
||||
.in('status', ATTACHABLE_STATUSES)
|
||||
.order('id', { ascending: true })
|
||||
.range(from, to),
|
||||
)
|
||||
}
|
||||
|
||||
/** PostgREST puts `.in()` lists in the URL, so the filter is chunked. */
|
||||
const REF_QUERY_CHUNK = 200
|
||||
|
||||
/**
|
||||
* Only the entries that could match one of `numbers`, rather than every
|
||||
* migrated entry in the company. The filename flow resolves a handful of refs
|
||||
* per request and would otherwise pull thousands of rows into memory each time.
|
||||
* Series is filtered in memory afterwards: it is case-insensitive here and a
|
||||
* series-less filename has to search across all of them anyway.
|
||||
*
|
||||
* Carries the display columns too, because this is the read behind a plan the
|
||||
* user has to be able to read before approving it.
|
||||
*
|
||||
* `fiscalPeriodId` narrows the read at the DB. It is an OPTIMIZATION, not the
|
||||
* enforcement: buildUnderlagPlan re-filters the rows in memory before indexing,
|
||||
* and that in-memory filter is the line the year guarantee rests on.
|
||||
*/
|
||||
export async function fetchVouchersForNumbers(
|
||||
supabase: SupabaseClient,
|
||||
companyId: string,
|
||||
numbers: number[],
|
||||
fiscalPeriodId?: string,
|
||||
): Promise<VoucherRow[]> {
|
||||
const unique = [...new Set(numbers)]
|
||||
if (unique.length === 0) return []
|
||||
|
||||
const rows: VoucherRow[] = []
|
||||
for (let i = 0; i < unique.length; i += REF_QUERY_CHUNK) {
|
||||
const chunk = unique.slice(i, i + REF_QUERY_CHUNK)
|
||||
const chunkRows = await fetchAllRows<VoucherRow>(({ from, to }) => {
|
||||
let query = supabase
|
||||
.from('journal_entries')
|
||||
.select(
|
||||
'id, fiscal_period_id, entry_date, description, voucher_series, voucher_number, source_voucher_series, source_voucher_number',
|
||||
)
|
||||
.eq('company_id', companyId)
|
||||
.in('source_voucher_number', chunk)
|
||||
.in('status', ATTACHABLE_STATUSES)
|
||||
if (fiscalPeriodId) query = query.eq('fiscal_period_id', fiscalPeriodId)
|
||||
return query.order('id', { ascending: true }).range(from, to)
|
||||
})
|
||||
rows.push(...chunkRows)
|
||||
}
|
||||
return rows
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether a fiscal year holds any SIE-imported entry carrying a source ref.
|
||||
* Distinguishes "the filenames are wrong" from "this year was never imported
|
||||
* from SIE", which are the same empty plan on screen but different problems.
|
||||
*/
|
||||
export async function hasSourceRefVouchers(
|
||||
supabase: SupabaseClient,
|
||||
companyId: string,
|
||||
fiscalPeriodId: string,
|
||||
): Promise<boolean> {
|
||||
const { count, error } = await supabase
|
||||
.from('journal_entries')
|
||||
.select('id', { count: 'exact', head: true })
|
||||
.eq('company_id', companyId)
|
||||
.eq('fiscal_period_id', fiscalPeriodId)
|
||||
.not('source_voucher_number', 'is', null)
|
||||
|
||||
if (error) throw new Error(`Failed to count migrated vouchers: ${error.message}`)
|
||||
return (count ?? 0) > 0
|
||||
}
|
||||
|
||||
export async function fetchFiscalPeriods(
|
||||
supabase: SupabaseClient,
|
||||
companyId: string,
|
||||
): Promise<FiscalPeriodRow[]> {
|
||||
return fetchAllRows<FiscalPeriodRow>(({ from, to }) =>
|
||||
supabase
|
||||
.from('fiscal_periods')
|
||||
.select('id, period_start, period_end, is_closed, locked_at')
|
||||
.eq('company_id', companyId)
|
||||
.order('id', { ascending: true })
|
||||
.range(from, to),
|
||||
)
|
||||
}
|
||||
|
||||
/** Our own label for a verifikat (`A47`), as opposed to the source label. */
|
||||
export function voucherLabel(entry: Pick<VoucherRow, 'voucher_series' | 'voucher_number'>): string | null {
|
||||
return entry.voucher_series && entry.voucher_number != null
|
||||
? `${entry.voucher_series}${entry.voucher_number}`
|
||||
: null
|
||||
}
|
||||
|
||||
/** The label the source system used (`A31`), which is what filenames carry. */
|
||||
export function sourceVoucherLabel(
|
||||
entry: Pick<VoucherRow, 'source_voucher_series' | 'source_voucher_number'>,
|
||||
): string | null {
|
||||
return entry.source_voucher_series && entry.source_voucher_number != null
|
||||
? `${entry.source_voucher_series}${entry.source_voucher_number}`
|
||||
: null
|
||||
}
|
||||
Reference in New Issue
Block a user