admin
e7f0070e84
Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma strängvärde byggs med konkatenering i stället för att matcha mönstret.
204 lines
8.1 KiB
TypeScript
204 lines
8.1 KiB
TypeScript
#!/usr/bin/env npx tsx
|
|
/**
|
|
* CI gate for the konteringspaket catalogue.
|
|
*
|
|
* Schema validation alone is not enough. The failure this whole format exists
|
|
* to prevent (PR #1321: seeded reference data that contradicted what the engine
|
|
* actually books) passes any structural check: the JSON was well-formed, the
|
|
* account numbers were four digits, and the values were still wrong. So the
|
|
* gate also asserts the things that make a pack *correct*:
|
|
*
|
|
* 1. Schema (lib/packs/schema.ts), including the vat_rate / ratio split.
|
|
* 2. Filename equals meta.slug: the slug is the public lookup key.
|
|
* 3. Slugs and meta.order are unique. Order is the single source of truth for
|
|
* display order in both the gallery and the docs, so a duplicate makes the
|
|
* two surfaces disagree non-deterministically.
|
|
* 4. Every account exists in the BAS 2026 reference chart. This is the #1321
|
|
* check.
|
|
* 5. The pack BALANCES when applied, using the real applyTemplate() rather
|
|
* than a reimplementation, so the validator tests what the product does.
|
|
* 6. Debit and credit are both present: a template posting only one side can
|
|
* never produce a legal verifikat.
|
|
*
|
|
* Usage:
|
|
* npx tsx scripts/validate-packs.ts # validate (CI)
|
|
* npx tsx scripts/validate-packs.ts --json # machine-readable summary
|
|
*/
|
|
import path from 'node:path'
|
|
import { fileURLToPath } from 'node:url'
|
|
import { loadPacks, sortPacks, type LoadedPack } from '../lib/packs/load'
|
|
import { applyTemplate } from '../lib/bookkeeping/template-library'
|
|
import { getBASReference } from '../lib/bookkeeping/bas-reference'
|
|
import type { BookingTemplateLibraryLine } from '../types'
|
|
|
|
const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
|
|
|
|
/** Amounts a pack is test-applied at. Deliberately awkward so rounding shows up. */
|
|
const PROBE_AMOUNTS = [100, 1000, 1234.56, 99.99, 3333.33]
|
|
|
|
/**
|
|
* Pre-existing breakage in the 26 templates ported out of migration
|
|
* 20260413160000, quarantined so the format port stays lossless.
|
|
*
|
|
* These are NOT accepted as correct. They are recorded, visible, and bounded:
|
|
* a quarantined pack's findings are reported as warnings instead of failures,
|
|
* a NEW finding on any pack still fails the build, and fixing one requires
|
|
* deleting its entry here (the validator fails if a quarantined pack turns out
|
|
* to be clean, so the list can only shrink).
|
|
*
|
|
* They are not fixed in this PR on purpose. Each is a Swedish accounting
|
|
* content change to a user-facing template, which is a domain decision that
|
|
* deserves its own review rather than riding along inside a file-format change.
|
|
*/
|
|
const KNOWN_BROKEN: Record<string, string> = {
|
|
// Empty, and that is the point: the four templates ported out of migration
|
|
// 20260413160000 with real defects (an unbalanced salary template, and
|
|
// accounts that could not resolve) were fixed rather than accepted. The list
|
|
// may only shrink; the validator fails if an entry here validates cleanly, so
|
|
// a stale quarantine cannot linger.
|
|
}
|
|
|
|
interface Failure {
|
|
file: string
|
|
message: string
|
|
}
|
|
|
|
function checkAccountsExist(p: LoadedPack, fail: (m: string) => void): void {
|
|
for (const line of p.pack.lines) {
|
|
if (!getBASReference(line.account)) {
|
|
fail(
|
|
`account ${line.account} ("${line.label}") is not in the BAS 2026 reference chart. ` +
|
|
`A pack may only reference standard accounts.`,
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
function checkBothSidesPresent(p: LoadedPack, fail: (m: string) => void): void {
|
|
const sides = new Set(p.pack.lines.map((l) => l.side))
|
|
if (!sides.has('debit') || !sides.has('credit')) {
|
|
fail(`has only ${[...sides].join('/')} lines: a verifikat needs both a debit and a credit side`)
|
|
}
|
|
}
|
|
|
|
function checkBalances(p: LoadedPack, fail: (m: string) => void): void {
|
|
for (const amount of PROBE_AMOUNTS) {
|
|
const lines = applyTemplate(p.pack.lines as unknown as BookingTemplateLibraryLine[], amount)
|
|
let debit = 0
|
|
let credit = 0
|
|
for (const l of lines) {
|
|
debit += l.debit_amount ? Number(l.debit_amount) : 0
|
|
credit += l.credit_amount ? Number(l.credit_amount) : 0
|
|
}
|
|
// Compare in öre to avoid float noise on the sum itself.
|
|
const debitOre = Math.round(debit * 100)
|
|
const creditOre = Math.round(credit * 100)
|
|
if (debitOre !== creditOre) {
|
|
fail(
|
|
`does not balance at ${amount} kr: debit ${(debitOre / 100).toFixed(2)} vs credit ` +
|
|
`${(creditOre / 100).toFixed(2)} (difference ${((debitOre - creditOre) / 100).toFixed(2)})`,
|
|
)
|
|
return
|
|
}
|
|
if (debitOre === 0) {
|
|
fail(`applies to zero at ${amount} kr: every ratio is 0, so the template posts nothing`)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
function main(): void {
|
|
const asJson = process.argv.includes('--json')
|
|
const { packs, errors } = loadPacks(ROOT)
|
|
const failures: Failure[] = errors.map((e) => ({ file: e.file, message: e.message }))
|
|
const quarantined: Failure[] = []
|
|
/** Quarantined slugs that produced no finding: their entry is now stale. */
|
|
const cleanButQuarantined = new Set(Object.keys(KNOWN_BROKEN))
|
|
|
|
// Cross-file uniqueness.
|
|
const bySlug = new Map<string, string[]>()
|
|
const byOrder = new Map<number, string[]>()
|
|
|
|
for (const p of packs) {
|
|
const isQuarantined = p.pack.meta.slug in KNOWN_BROKEN
|
|
// Structural problems always fail, even for a quarantined pack: the
|
|
// quarantine covers accounting content, not a malformed file.
|
|
const fail = (m: string) => failures.push({ file: p.file, message: m })
|
|
// Semantic problems (BAS membership, balance) are downgraded for a
|
|
// quarantined pack and recorded instead.
|
|
const semanticFail = (m: string) => {
|
|
if (isQuarantined) {
|
|
cleanButQuarantined.delete(p.pack.meta.slug)
|
|
quarantined.push({ file: p.file, message: m })
|
|
} else {
|
|
failures.push({ file: p.file, message: m })
|
|
}
|
|
}
|
|
|
|
if (p.fileSlug !== p.pack.meta.slug) {
|
|
fail(`filename is "${p.fileSlug}.yaml" but meta.slug is "${p.pack.meta.slug}": they must match`)
|
|
}
|
|
bySlug.set(p.pack.meta.slug, [...(bySlug.get(p.pack.meta.slug) ?? []), p.file])
|
|
byOrder.set(p.pack.meta.order, [...(byOrder.get(p.pack.meta.order) ?? []), p.file])
|
|
|
|
checkAccountsExist(p, semanticFail)
|
|
checkBothSidesPresent(p, semanticFail)
|
|
checkBalances(p, semanticFail)
|
|
}
|
|
|
|
for (const [slug, files] of bySlug) {
|
|
if (files.length > 1) {
|
|
failures.push({ file: files.join(', '), message: `duplicate meta.slug "${slug}"` })
|
|
}
|
|
}
|
|
for (const [order, files] of byOrder) {
|
|
if (files.length > 1) {
|
|
failures.push({
|
|
file: files.join(', '),
|
|
message:
|
|
`duplicate meta.order ${order}. Order is the single source of truth for display order ` +
|
|
`in both the gallery and the docs; a duplicate makes them disagree.`,
|
|
})
|
|
}
|
|
}
|
|
|
|
// A quarantined pack that no longer produces a finding must be released, or
|
|
// the list silently grows stale and stops meaning anything.
|
|
for (const slug of cleanButQuarantined) {
|
|
if (packs.some((p) => p.pack.meta.slug === slug)) {
|
|
failures.push({
|
|
file: `packs/${slug}.yaml`,
|
|
message:
|
|
`is in KNOWN_BROKEN but now validates cleanly. Delete its entry from ` +
|
|
`scripts/validate-packs.ts: the quarantine list may only shrink.`,
|
|
})
|
|
}
|
|
}
|
|
|
|
if (asJson) {
|
|
console.log(JSON.stringify({ packs: packs.length, failures, quarantined }, null, 2))
|
|
process.exit(failures.length ? 1 : 0)
|
|
}
|
|
|
|
if (quarantined.length) {
|
|
console.warn(`\n! ${quarantined.length} known pre-existing problem(s), quarantined (see KNOWN_BROKEN):`)
|
|
for (const q of quarantined) console.warn(` ${q.file}\n ${q.message}`)
|
|
}
|
|
|
|
if (failures.length) {
|
|
console.error(`\n✗ Pack validation failed: ${failures.length} problem(s)\n`)
|
|
for (const f of failures) console.error(` ${f.file}\n ${f.message}`)
|
|
console.error('\n → schema and rationale: lib/packs/schema.ts')
|
|
process.exit(1)
|
|
}
|
|
|
|
const ordered = sortPacks(packs)
|
|
console.log(
|
|
`\n✓ Packs valid: ${packs.length} pack(s), orders ${ordered[0]?.pack.meta.order}-${
|
|
ordered[ordered.length - 1]?.pack.meta.order
|
|
}, all balance at ${PROBE_AMOUNTS.length} probe amounts (${quarantined.length} quarantined).`,
|
|
)
|
|
}
|
|
|
|
main()
|