Files
accounted/lib/invariants/org-number.ts
T
admin e7f0070e84
masterplan-lock / check (push) Successful in 19s
ci / sonar (push) Failing after 21s
security / scan (push) Failing after 1m37s
fix(restore): återställ default branch-filer som raderades av docs-publiceringen (7e33543)
Å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.
2026-11-10 09:37:22 +01:00

183 lines
7.6 KiB
TypeScript

import { luhnValidate } from '@/lib/bankgiro/luhn'
import { usesPersonnummerAsOrgNumber } from '@/lib/company/entity-type'
import type { EntityType } from '@/types'
/**
* Swedish organisationsnummer / personnummer: the one place that decides what
* "a valid org number" means.
*
* ## The rule
*
* - **Canonical storage form is 10 digits, no separators** (`5560125790`).
* - Input may arrive as 10 or 12 digits, with spaces or hyphens, because that
* is what users type and what provider APIs return. Both forms normalize to
* the same 10 digits; the century prefix is dropped.
* - The last digit is a Luhn (mod-10) check digit, the structural rule
* Bolagsverket and personnummer share.
*
* ## Why this module exists
*
* Before it, seven call sites each had their own idea of the rule, and four of
* them fed Skatteverket-bound output that must agree:
*
* | Site | Old rule | Failure |
* |---|---|---|
* | `lib/skatteverket/format.ts` | strip `-` only | threw on any input containing a space |
* | `lib/salary/ku/ku10-generator.ts` | `replace('-', '')` | first hyphen only, no space handling |
* | `lib/salary/agi/xml-generator.ts` | strip non-digits | no check-digit validation |
* | `lib/bokslut/ixbrl/validate/rules.ts` | `/^\d{6}-?\d{4}$/` | rejected the 12-digit form outright |
*
* A company stored with a space or in 12-digit form could file AGI all year and
* then fail on the årsredovisning, with no way for the user to tell why. The
* rules only stay in agreement if there is exactly one of them.
*
* ## Deliberate asymmetry: normalize everywhere, Luhn only at the boundary
*
* `normalizeOrgNumber` (Luhn-checked) guards data coming *in*. The export-time
* converter `toRedovisare12` is structural only: it must not start rejecting
* numbers that are already stored and have been filing successfully, because a
* failed export at a deadline is worse than a number Skatteverket will reject
* with its own message. Tighten the intake, not the outflow.
*/
/**
* Strip the separators Swedish users and provider APIs put in org numbers.
* Does not validate: use {@link isOrgNumberShaped} or {@link normalizeOrgNumber}.
*/
export function stripOrgNumberFormatting(raw: string): string {
return raw.replace(/[\s-]/g, '')
}
/**
* True when the input is structurally an org number (10 or 12 digits after
* separators are stripped), regardless of check digit.
*/
export function isOrgNumberShaped(raw: string | null | undefined): boolean {
if (!raw) return false
const cleaned = stripOrgNumberFormatting(raw)
return /^\d{10}$/.test(cleaned) || /^\d{12}$/.test(cleaned)
}
/**
* Lenient identity key for a Swedish org number: the 10 significant digits,
* or null when the input is not org-number shaped.
*
* Strips separators (hyphens, spaces), keeps 10 digits as they are and takes
* the last 10 of a 12-digit century-prefixed form: "16" for organisations,
* "18"/"19"/"20" for the personnummer an enskild firma uses. Only those
* prefixes: a 12-digit value that starts with anything else is a Swedish VAT
* number typed into the wrong field (556012579001 = orgnr + "01"), and its
* last 10 digits are somebody else's identity. Letters are not stripped for
* the same reason: BE0123456789 is a Belgian enterprise number, not the
* Swedish 0123456789. Anything not shaped like a Swedish org number keys to
* null and is stored and compared exactly as typed.
*
* No Luhn check on purpose: this key answers "do these two strings denote
* the same counterparty", and two rows holding the same mistyped number are
* still one supplier. Use {@link normalizeOrgNumber} where a number is
* accepted into the system as valid; use this where existing values are
* compared or canonicalised.
*
* `suppliers.org_number` is stored in this form: the supplier matcher, the
* write schemas (web, v1, MCP, CSV import, provider migration) and the
* extractor's self-invoice guard all go through it, so a hyphenated register
* entry and a bare extracted number meet (#2391).
*/
export function orgNumberKey(raw: string | null | undefined): string | null {
if (!raw) return null
const cleaned = stripOrgNumberFormatting(raw)
if (/^\d{10}$/.test(cleaned)) return cleaned
if (/^(16|18|19|20)\d{10}$/.test(cleaned)) return cleaned.slice(2)
return null
}
/**
* Normalize an org number to Accounted's canonical 10-digit storage form.
*
* Accepts hyphen/space-formatted input in either of the two shapes Swedish
* users commonly type:
* - 10 digits (5560125790 or 8001011231): stored as-is
* - 12 digits (198001011231): century prefix stripped
*
* Returns null for any other length, non-digit content, or invalid Luhn check
* digit. Storing a structurally invalid org number would later be caught by
* Skatteverket SRU and any receiving SIE4 system: refusing at the boundary
* keeps Accounted's bookkeeping from accumulating under an unusable identifier.
*/
export function normalizeOrgNumber(raw: string | null | undefined): string | null {
if (!raw) return null
const cleaned = stripOrgNumberFormatting(raw)
let canonical: string
if (/^\d{10}$/.test(cleaned)) {
canonical = cleaned
} else if (/^\d{12}$/.test(cleaned)) {
canonical = cleaned.substring(2)
} else {
return null
}
return luhnValidate(canonical) ? canonical : null
}
/** True when {@link normalizeOrgNumber} accepts the input. */
export function isValidOrgNumber(raw: string | null | undefined): boolean {
return normalizeOrgNumber(raw) !== null
}
/**
* True when the input is shaped like an org number but its check digit is
* wrong. Lets a validator tell the user *which* problem they have instead of
* one undifferentiated "ogiltigt organisationsnummer".
*/
export function hasInvalidOrgNumberCheckDigit(raw: string | null | undefined): boolean {
return isOrgNumberShaped(raw) && !isValidOrgNumber(raw)
}
/**
* Format a canonical org number for display: `NNNNNN-NNNN`.
* Returns the input unchanged when it is not org-number shaped.
*/
export function formatOrgNumberDisplay(raw: string | null | undefined): string {
if (!raw) return ''
const cleaned = stripOrgNumberFormatting(raw)
const ten = /^\d{12}$/.test(cleaned) ? cleaned.substring(2) : cleaned
if (!/^\d{10}$/.test(ten)) return raw
return `${ten.substring(0, 6)}-${ten.substring(6)}`
}
/**
* Convert an org number to Skatteverket's 12-digit "redovisare" format.
*
* - Organisationsnummer (aktiebolag): prefix `16` (5020000013 -> 165020000013)
* - Personnummer (enskild firma): prefix `19` or `20` by century
* - Input already in 12-digit form passes through untouched
*
* Structural only, no check-digit validation: see the module docblock for why
* the export path stays permissive.
*
* @throws when the input is not 10 or 12 digits after separators are stripped.
*/
export function toRedovisare12(
orgNumber: string,
entityType: EntityType,
): string {
const clean = stripOrgNumberFormatting(orgNumber)
if (/^\d{12}$/.test(clean)) return clean
if (!/^\d{10}$/.test(clean)) {
throw new Error(`Ogiltigt organisationsnummer: ${orgNumber} (förväntar 10 eller 12 siffror)`)
}
// Juridiska personer (AB, förening) carry the fixed 16 prefix; only an
// enskild firma identifies by the owner's personnummer.
if (!usesPersonnummerAsOrgNumber(entityType)) return `16${clean}`
// Enskild firma: personnummer. A two-digit year above the current one must
// belong to the previous century (someone born in 98 is 1998, not 2098).
const yearDigits = parseInt(clean.substring(0, 2), 10)
const currentTwoDigitYear = new Date().getFullYear() % 100
const prefix = yearDigits > currentTwoDigitYear ? '19' : '20'
return `${prefix}${clean}`
}