mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-17 23:52:24 +00:00
Registering `ko` in the `Locale` union left seven locale-keyed tables without an entry, so the build could not type-check and the safety screens, the citation-coverage grader and the reference-range parser read nothing at all for a Korean reader. Three failures were not missing keys but wrong assumptions: - The shared fold decomposes with NFD and strips U+0300-U+036F. Latin accents become plain letters, but Hangul decomposes into jamo, which are not in that range and survived — so folded Korean text was a jamo sequence no precomposed table entry could ever match. It recomposes to NFC now; every Latin, Polish and German fold is byte-identical. - `normaliseLabKey` kept `[a-z0-9]`, which reduced every Korean analyte name to the empty string, so the derived index held none of them and a Korean cholesterol result reached a FHIR export uncoded. - The reference-range parser had the hyphen and the dashes but not the tilde a Korean lab actually prints (`3.5~5.0`). The Korean safety banks carry no `\b` next to a Hangul token — `\b` is an ASCII `\w` boundary and Hangul is not `\w`, so `/\b증량/` matches nothing — and the clause order is the mirror of the Latin banks, since Korean closes with the verb. The dose patterns require a target-marking particle for the same reason the Latin banks require "to"/"by": without it the permitted restatement "7.5mg을 복용 중이고, 체중은 내려가고 있어요" tripped the lowering pattern. The Coach and Insights prompts route `ko` down the reviewed English body plus a Korean reply directive; there is no `safety-contracts.ko.yaml`, so the native builder has no Korean ground rules to compose from.
232 lines
9.5 KiB
TypeScript
232 lines
9.5 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
||
import { readFileSync, readdirSync } from "node:fs";
|
||
import { join } from "node:path";
|
||
|
||
import { resolveKey } from "@/lib/i18n/resolve-key";
|
||
import {
|
||
ILLNESS_SCAN_TYPES,
|
||
FUNCTIONAL_IMPACT_RETURN_KEY,
|
||
} from "@/lib/illness/correlation";
|
||
import {
|
||
illnessTypeEnum,
|
||
illnessLifecycleEnum,
|
||
} from "@/lib/validations/illness";
|
||
import {
|
||
allergyCategoryEnum,
|
||
allergyTypeEnum,
|
||
allergySeverityEnum,
|
||
allergyStatusEnum,
|
||
} from "@/lib/validations/allergy";
|
||
import { familyRelationshipEnum } from "@/lib/validations/family-history";
|
||
import { encounterKindEnum } from "@/lib/validations/encounters";
|
||
import { encounterKindLabelKey } from "@/lib/encounters/kind-label";
|
||
import { INSTRUMENTS } from "@/lib/mental-health/instruments";
|
||
|
||
/**
|
||
* Enum-driven exhaustiveness guard for DYNAMICALLY-built i18n keys.
|
||
*
|
||
* The three existing i18n guards each see one face of the problem and miss the
|
||
* fourth:
|
||
* - `i18n-call-site-coverage.test.ts` sees only literal `t("ns.key")` calls,
|
||
* so a runtime-assembled `t(\`ns.${x}\`)` key is invisible to it.
|
||
* - `i18n-reverse-coverage.test.ts` sees bundle orphans, but treats any
|
||
* `ns.${x}` template as covering its whole subtree — so a MEMBER missing
|
||
* from the subtree is invisible.
|
||
* - `i18n-locale-integrity.test.ts` sees cross-locale parity, so it only
|
||
* fires when a key is present in SOME locale but not all.
|
||
*
|
||
* None of them assert the class that actually ships broken: "for enum E, every
|
||
* member's dynamically-built key resolves, non-empty, in every locale." Because
|
||
* parity is perfect, a key missing from ONE locale is missing from ALL SIX at
|
||
* once — exactly the seam that let `measurementReminders.types.{WHO5_SCORE,
|
||
* SCI_SCORE,WAIST_CIRCUMFERENCE}` (v1.28.38) and `illness.vital.FUNCTIONAL_IMPACT`
|
||
* (v1.28.41) ship absent from every bundle.
|
||
*
|
||
* This test derives the EXPECTED key set from the SOURCE enum/const and asserts
|
||
* every `prefix + member` resolves. Adding an enum member without a bundle key
|
||
* fails CI by construction — no hand-maintained floor to drift.
|
||
*
|
||
* ── Covered key spaces (source is a clean, finite, import-safe enum/const) ──
|
||
* - illness.vital.* ILLNESS_SCAN_TYPES ∪ FUNCTIONAL_IMPACT_RETURN_KEY
|
||
* - illness.type.* illnessTypeEnum
|
||
* - illness.lifecycle.* illnessLifecycleEnum
|
||
* - records.allergies.category.* allergyCategoryEnum
|
||
* - records.allergies.type.* allergyTypeEnum
|
||
* - records.allergies.severity.* allergySeverityEnum ∪ "NONE" sentinel
|
||
* - records.allergies.status.* allergyStatusEnum
|
||
* - records.family.relationship.* familyRelationshipEnum
|
||
* - mentalHealth.instrument.* } INSTRUMENTS i18nKey slugs
|
||
* - mentalHealth.instrumentSub.* } (PHQ-9 / GAD-7 / WHO-5 / SCI —
|
||
* - mentalHealth.instrumentDescription.* } the WHO-5/SCI class that bit before)
|
||
*
|
||
* ── Deliberately EXCLUDED (would produce false positives) ──
|
||
* - `insights.workouts.sport.*` — the Strava render path stores a raw
|
||
* `sport_type` and the render site legitimately falls back to that raw
|
||
* string, so a "missing" key is a graceful degradation, not a broken token
|
||
* (audit LOW #2). Asserting it would fail on a path that is by-design lax.
|
||
* - `settings.sections.*.description`, `settings.ai.providerChain.types.admin-codex`,
|
||
* `insights.<metric>.emptyState.cta` — structurally unreachable behind a
|
||
* tsc-exhaustive map / a `!= null` guard / a server-only filter (audit LOW).
|
||
* Registering them would demand bundle keys for code paths users never hit.
|
||
* - `measurementReminders.types.*` — already exhaustively covered by
|
||
* `measurement-reminders/__tests__/type-labels-i18n.test.ts`; its source
|
||
* const lives in a client component, not a lib-level export.
|
||
* - Prisma cycle enums, medication/document/lab/nutrient catalogs — clean
|
||
* enums the audit flags as candidates; left for a follow-up extension. Add
|
||
* them here once their exact prefix→member mapping is confirmed 1:1 (the
|
||
* cycle cervix* prefixes and catalog slug maps need per-space verification
|
||
* to stay false-positive-free).
|
||
*/
|
||
|
||
const MESSAGES_DIR = join(__dirname, "../../messages");
|
||
|
||
const LOCALES = readdirSync(MESSAGES_DIR)
|
||
.filter((f) => f.endsWith(".json"))
|
||
.map((f) => ({
|
||
locale: f.replace(/\.json$/, ""),
|
||
messages: JSON.parse(readFileSync(join(MESSAGES_DIR, f), "utf8")) as Record<
|
||
string,
|
||
unknown
|
||
>,
|
||
}));
|
||
|
||
/** PHQ-9 / GAD-7 / WHO-5 / SCI lowercase i18n slugs, straight from the source. */
|
||
const INSTRUMENT_SLUGS = Object.values(INSTRUMENTS).map((i) => i.i18nKey);
|
||
|
||
interface KeySpace {
|
||
/** The dotted prefix the key is built from (`t(\`prefix.${member}\`)`). */
|
||
prefix: string;
|
||
/** The finite member set, derived from the SOURCE enum/const. */
|
||
members: readonly string[];
|
||
}
|
||
|
||
const REGISTRY: readonly KeySpace[] = [
|
||
// illness.* — the currently-broken seed (FUNCTIONAL_IMPACT wins recovery-gap ties).
|
||
{
|
||
prefix: "illness.vital",
|
||
members: [...ILLNESS_SCAN_TYPES.map(String), FUNCTIONAL_IMPACT_RETURN_KEY],
|
||
},
|
||
{ prefix: "illness.type", members: illnessTypeEnum.options },
|
||
{ prefix: "illness.lifecycle", members: illnessLifecycleEnum.options },
|
||
|
||
// records.allergies.* — Zod enums; severity carries a "NONE" (not-assessed) sentinel.
|
||
{
|
||
prefix: "records.allergies.category",
|
||
members: allergyCategoryEnum.options,
|
||
},
|
||
{ prefix: "records.allergies.type", members: allergyTypeEnum.options },
|
||
{
|
||
prefix: "records.allergies.severity",
|
||
members: [...allergySeverityEnum.options, "NONE"],
|
||
},
|
||
{ prefix: "records.allergies.status", members: allergyStatusEnum.options },
|
||
|
||
// records.family.relationship.*
|
||
{
|
||
prefix: "records.family.relationship",
|
||
members: familyRelationshipEnum.options,
|
||
},
|
||
|
||
// mentalHealth.* — the WHO-5/SCI class whose absence originally motivated this guard.
|
||
{ prefix: "mentalHealth.instrument", members: INSTRUMENT_SLUGS },
|
||
{ prefix: "mentalHealth.instrumentSub", members: INSTRUMENT_SLUGS },
|
||
{ prefix: "mentalHealth.instrumentDescription", members: INSTRUMENT_SLUGS },
|
||
];
|
||
|
||
/**
|
||
* The second arm: key spaces whose member → key mapping is NOT `prefix +
|
||
* member`, so the registry above cannot express them. The mapping function
|
||
* itself is the source, and the guard runs the enum through it.
|
||
*
|
||
* `encounters.kind` is why this arm exists. The enum member is `ROUTINE`, the
|
||
* bundle leaf is `routine`, and three surfaces — the doctor-report PDF's visit
|
||
* table, the daily digest's upcoming-visit line and the clinician share view —
|
||
* built the key by interpolation. All three printed `encounters.kind.ROUTINE`
|
||
* verbatim: into a clinical document, onto a lock screen, and onto a page a
|
||
* doctor opens. The prefix-plus-member form of this guard would have caught it
|
||
* on the day the interpolation was written, but only if the mapping had been
|
||
* expressible; it is not, so it was never registered and nothing else looked.
|
||
*/
|
||
const RESOLVED_REGISTRY: readonly {
|
||
/** What the space is, for the failure message. */
|
||
name: string;
|
||
/** Every key the resolver can return, over the whole source enum. */
|
||
keys: readonly string[];
|
||
}[] = [
|
||
{
|
||
name: "encounters.kind via encounterKindLabelKey",
|
||
keys: encounterKindEnum.options.map(encounterKindLabelKey),
|
||
},
|
||
];
|
||
|
||
describe("dynamic-key exhaustiveness (enum-derived)", () => {
|
||
// Six shipped locales. An empty read of `messages/` would register zero
|
||
// per-locale cases and the suite would report green over nothing.
|
||
it("reads every shipped locale bundle", () => {
|
||
expect(LOCALES.length).toBeGreaterThanOrEqual(6);
|
||
});
|
||
|
||
it("discovers all seven shipped locales", () => {
|
||
expect(LOCALES.map((l) => l.locale).sort()).toEqual([
|
||
"de",
|
||
"en",
|
||
"es",
|
||
"fr",
|
||
"it",
|
||
"ko",
|
||
"pl",
|
||
]);
|
||
});
|
||
|
||
it("every registered key space has a non-empty member set", () => {
|
||
for (const space of REGISTRY) {
|
||
expect(
|
||
space.members.length,
|
||
`${space.prefix} resolved to an empty member set — source import broke`,
|
||
).toBeGreaterThan(0);
|
||
}
|
||
});
|
||
|
||
it("every resolver-mapped key space returns a distinct key per member", () => {
|
||
for (const space of RESOLVED_REGISTRY) {
|
||
expect(
|
||
space.keys.length,
|
||
`${space.name} resolved to an empty key set — source import broke`,
|
||
).toBeGreaterThan(0);
|
||
// A resolver whose default arm swallowed a member would collapse two
|
||
// enum values onto one key and the per-locale checks below would still
|
||
// pass, because the surviving key resolves fine.
|
||
expect(
|
||
new Set(space.keys).size,
|
||
`${space.name} maps two enum members onto one key`,
|
||
).toBe(space.keys.length);
|
||
}
|
||
});
|
||
|
||
for (const { locale, messages } of LOCALES) {
|
||
for (const space of REGISTRY) {
|
||
for (const member of space.members) {
|
||
const key = `${space.prefix}.${member}`;
|
||
it(`resolves ${key} in ${locale}`, () => {
|
||
const value = resolveKey(messages, key);
|
||
expect(value, `${key} missing in ${locale}.json`).toBeTypeOf(
|
||
"string",
|
||
);
|
||
expect((value ?? "").trim().length).toBeGreaterThan(0);
|
||
});
|
||
}
|
||
}
|
||
for (const space of RESOLVED_REGISTRY) {
|
||
for (const key of space.keys) {
|
||
it(`resolves ${key} in ${locale} (${space.name})`, () => {
|
||
const value = resolveKey(messages, key);
|
||
expect(value, `${key} missing in ${locale}.json`).toBeTypeOf(
|
||
"string",
|
||
);
|
||
expect((value ?? "").trim().length).toBeGreaterThan(0);
|
||
});
|
||
}
|
||
}
|
||
}
|
||
});
|