babelfhir-ts 1.5.20 → 1.5.21

package/out/src/generator/sdProcessor.js

@@ -11,6 +11,7 @@ import { generateClass } from './emitters/class/classGenerator.js';
 import { generateInterfaces } from './emitters/interface/interfaceGenerator.js';
 import { fetchStructureDefinition, parseStructureDefinition } from './parser/sdParser.js';
 import { writeInterfaceAndValidatorToFile, mergeFields, alignFields, writeToFile, getBaseResource, sanitizeIdentifier, toPascalCase, stripVersionFromCanonicalUrl } from './core/utils.js';
+import { extensionElements, collectSubExtensionSlices, readSubExtensionMin, readBinding } from './core/extensionSdReader.js';
 import { generateValidateProfileFunction } from './emitters/validator/validatorGenerator.js';
 import { generateZodSchema } from './emitters/zod/zodSchemaGenerator.js';
 import { extractFieldPatternsAndMetadata } from './emitters/class/fieldPatternExtractor.js';
@@ -22,10 +23,172 @@ import { extractAndDeduplicateRequiredFields, resolveChoiceSegments } from './sd
 // Re-export public API consumed by index.ts / generationHelpers.ts
 export { resetFetchFailureTracking, getFetchFailureCount, getFetchFailureWarning };
 const log = logger.withTag('generator');
+/**
+ * Fill in what a profile's differential never states, from the base resource.
+ *
+ * A differential element says only what it *changes*. KBV constrains
+ * `Medication.amount.numerator.value` to max=0 and says nothing about its type, so
+ * the merged field read `any` and every type-aware check skipped it — HL7 reported
+ * "The value 'Example value' is not a valid decimal" where we were silent. The same
+ * silence on `max` left `Medication.ingredient` non-repeating despite being 0..* in
+ * the base, so nothing beneath it was ever walked.
+ *
+ * The base resource snapshot supplies the top of each path (`Medication.amount` is a
+ * Ratio); below that it stops, because a resource never expands its datatypes'
+ * children. Those come from the datatype tables — `Ratio.numerator` is a Quantity,
+ * `Quantity.value` a decimal — walked down from the deepest ancestor whose type is
+ * already known. An unresolvable hop leaves the field alone rather than guessing.
+ *
+ * Only unstated properties are filled; anything the differential declares still wins.
+ */
+async function fillUnstatedFromBaseResource(fields, resourceType) {
+    if (!resourceType)
+        return;
+    let baseSd;
+    try {
+        baseSd = await fetchStructureDefinition(`http://hl7.org/fhir/StructureDefinition/${resourceType}`);
+    }
+    catch {
+        return;
+    }
+    const baseElements = baseSd?.snapshot?.element;
+    if (!baseElements?.length)
+        return;
+    const baseByPath = new Map();
+    for (const el of baseElements) {
+        const id = el.id ?? el.path;
+        if (!id)
+            continue;
+        const rel = id.replace(/^[^.]+\./, '');
+        if (!rel || rel === id || rel.includes(':'))
+            continue;
+        baseByPath.set(rel, { type: el.type?.[0]?.code, max: el.max });
+    }
+    // Container types name no datatype to walk into, so they seed nothing.
+    const knownType = new Map();
+    for (const [rel, meta] of baseByPath) {
+        if (meta.type && meta.type !== 'BackboneElement' && meta.type !== 'Element') {
+            knownType.set(rel, meta.type);
+        }
+    }
+    const unstated = (type) => !type || type === 'any';
+    // Shallow paths first, so a deeper one can walk down from an ancestor this pass
+    // has just resolved.
+    const ordered = [...fields].sort((a, b) => (a.name || '').split('.').length - (b.name || '').split('.').length);
+    for (const field of ordered) {
+        const rel = (field.name || '').replace(/^[^.]+\./, '');
+        if (!rel)
+            continue;
+        const base = baseByPath.get(rel);
+        if (base) {
+            if (unstated(field.type) && base.type)
+                field.type = base.type;
+            if (field.max === undefined && base.max !== undefined) {
+                const unbounded = base.max === '*';
+                const parsed = unbounded ? Infinity : Number.parseInt(base.max, 10);
+                if (unbounded || Number.isFinite(parsed)) {
+                    field.max = parsed;
+                    field.isArray = unbounded || parsed > 1;
+                }
+            }
+            if (!unstated(field.type))
+                knownType.set(rel, field.type);
+            continue;
+        }
+        if (!unstated(field.type)) {
+            knownType.set(rel, field.type);
+            continue;
+        }
+        const segments = rel.split('.');
+        let current;
+        let next = 0;
+        for (let depth = segments.length - 1; depth >= 1; depth--) {
+            const ancestorType = knownType.get(segments.slice(0, depth).join('.'));
+            if (ancestorType) {
+                current = ancestorType;
+                next = depth;
+                break;
+            }
+        }
+        if (!current)
+            continue;
+        for (let i = next; i < segments.length && current; i++) {
+            current = resolveComplexTypeChildType(current, segments[i]);
+        }
+        if (current) {
+            field.type = current;
+            knownType.set(rel, current);
+        }
+    }
+}
+/**
+ * Fill in extension-slice canonicals a derived profile does not restate.
+ *
+ * An extension slice is recognised at runtime by the canonical its `type.profile`
+ * names. A derived profile that only tightens cardinality omits it:
+ * KBV_PR_ERP_Medication_PZN redeclares `extension:Kategorie` and
+ * `extension:Normgroesse` with no profile, while its base KBV_PR_Base_Medication
+ * gives them KBV_EX_Base_Medication_Type and .../normgroesse. Two of four slices
+ * were therefore unidentifiable, and the closed-slicing check on
+ * `Medication.extension` could not build an allowed set — so it stayed silent where
+ * HL7 reports "does not match any known slice … and slicing is CLOSED".
+ *
+ * Walks the baseDefinition chain, nearest ancestor first, and stops at the first
+ * that names a canonical. Depth-bounded: a malformed chain must not loop.
+ */
+async function fillSliceProfileUrlsFromBaseProfiles(fields, baseDefinition) {
+    const needing = fields.filter(f => f.sliceName && !f.profileUrls?.length && f.elementId);
+    if (needing.length === 0)
+        return;
+    const seen = new Set();
+    let canonical = baseDefinition;
+    for (let depth = 0; depth < 5 && canonical; depth++) {
+        const key = stripVersionFromCanonicalUrl(canonical);
+        if (seen.has(key))
+            break;
+        seen.add(key);
+        let baseSd;
+        try {
+            baseSd = await fetchStructureDefinition(canonical);
+        }
+        catch {
+            return;
+        }
+        if (!baseSd)
+            return;
+        const byElementId = new Map();
+        for (const el of (baseSd.snapshot?.element ?? baseSd.differential?.element ?? [])) {
+            const id = el.id;
+            if (!id)
+                continue;
+            const profiles = (el.type ?? []).flatMap(t => t.profile ?? []);
+            if (profiles.length)
+                byElementId.set(id, profiles);
+        }
+        for (const field of needing) {
+            if (field.profileUrls?.length)
+                continue;
+            const inherited = byElementId.get(field.elementId);
+            if (inherited?.length)
+                field.profileUrls = inherited;
+        }
+        if (needing.every(f => f.profileUrls?.length))
+            return;
+        canonical = baseSd.baseDefinition;
+    }
+}
 // ── Extension metadata resolution for validator emission ──────────────────
 /**
  * Scan fields for extension slices with profile URLs, resolve their
  * StructureDefinitions, and extract value[x] type + binding metadata.
+ *
+ * Keyed by the *version-stripped* canonical. A slice names its extension twice and
+ * the two forms disagree: `type.profile` carries a version suffix
+ * (`…/sdc-questionnaire-contextExpression|4.0.0`) while the pinned `url` child
+ * carries the bare canonical. Keying on whichever arrived first left the other
+ * lookup empty, and an absent entry means "SD unreadable, conclude nothing" — so
+ * DTRStdQuestionnaire's contextExpression emitted no validation at all.
+ * Callers must strip before reading; use `lookupExtensionMetadata`.
  */
 async function resolveExtensionMetadata(fields) {
     const extUrls = new Set();
@@ -41,11 +204,35 @@ async function resolveExtensionMetadata(fields) {
         return undefined;
     const map = new Map();
     await Promise.all([...extUrls].map(async (url) => {
+        // Fetch by the url as written — the version suffix selects the right SD — but
+        // key the result by the stripped form so either spelling finds it.
+        const key = stripVersionFromCanonicalUrl(url);
         try {
             const extSd = await fetchStructureDefinition(url);
-            if (!extSd?.snapshot?.element)
+            const els = extensionElements(extSd);
+            if (!els)
                 return;
-            const valueEl = extSd.snapshot.element.find((el) => (el.path === 'Extension.value[x]' || el.id === 'Extension.value[x]'));
+            const valueEl = els.find(el => el.path === 'Extension.value[x]' || el.id === 'Extension.value[x]');
+            const subExtensions = collectSubExtensionSlices(els);
+            const subExtensionMin = readSubExtensionMin(els);
+            // A complex extension carries sub-extensions instead of a value, and forbids a
+            // value outright (ext-1: extension.exists() != value.exists()). Recorded as an
+            // empty type list — different from no entry at all, which would mean the SD
+            // could not be read and nothing can be concluded.
+            //
+            // Recognised two ways because published SDs state it two ways: value[x] pinned
+            // to max=0 (sdc-questionnaire-contextExpression), or a required
+            // Extension.extension with no value[x] element at all
+            // (KBV_EX_ERP_PracticeSupply_Payor, whose differential omits value[x] entirely —
+            // the earlier `if (!valueEl) return` dropped it before anything was read).
+            if (valueEl?.max === '0' || (subExtensionMin ?? 0) >= 1) {
+                map.set(key, {
+                    valueTypes: [],
+                    subExtensionMin,
+                    subExtensions: subExtensions.length ? subExtensions : undefined,
+                });
+                return;
+            }
             if (!valueEl)
                 return;
             const types = (valueEl.type || []).map((t) => t.code).filter(Boolean);
@@ -54,25 +241,17 @@ async function resolveExtensionMetadata(fields) {
             const entry = { valueTypes: types };
             // Check binding on value[x] first, then fall back to typed slices
             // (e.g., Extension.valueCode may carry the binding instead of Extension.value[x])
-            let binding = valueEl.binding;
-            if (!binding?.valueSet && types.length === 1) {
+            let binding = readBinding(valueEl);
+            if (!binding && types.length === 1) {
                 const suffix = types[0].charAt(0).toUpperCase() + types[0].slice(1);
-                const sliceEl = extSd.snapshot.element.find((el) => el.id === `Extension.value[x]:value${suffix}` ||
+                const sliceEl = els.find(el => el.id === `Extension.value[x]:value${suffix}` ||
                     el.path === `Extension.value${suffix}` ||
                     el.id === `Extension.value${suffix}`);
-                if (sliceEl?.binding?.valueSet) {
-                    binding = sliceEl.binding;
-                }
-            }
-            if (binding?.strength && binding?.valueSet) {
-                const vsUri = typeof binding.valueSet === 'string'
-                    ? binding.valueSet
-                    : binding.valueSet?.reference;
-                if (vsUri) {
-                    entry.binding = { strength: binding.strength, uri: vsUri.split('|')[0] };
-                }
+                binding = readBinding(sliceEl);
             }
-            map.set(url, entry);
+            if (binding)
+                entry.binding = binding;
+            map.set(key, entry);
         }
         catch {
             // Extension SD not resolvable — skip
@@ -187,7 +366,10 @@ export async function processStructureDefinition(sd, ctx) {
     // ── External profile resolution ──────────────────────────────────
     for (const [typeName, profileInfo] of interfaceResult.referencedExternalProfiles) {
         const normalizedTypeName = toPascalCase(sanitizeIdentifier(typeName));
-        const isUsedHere = interfaceContent.includes(`import { ${normalizedTypeName} } from "./${normalizedTypeName}"`) ||
+        // Tolerates the `type` modifier the interface emitter writes; the second
+        // clause already did, but leaving the first matching only the bare form
+        // makes the two disagree for no reason.
+        const isUsedHere = new RegExp(`import(?:\\s+type)?\\s+\\{\\s*${normalizedTypeName}\\s*\\}\\s+from\\s+"\\./${normalizedTypeName}"`).test(interfaceContent) ||
             (interfaceContent.includes(`from "./${normalizedTypeName}"`) && interfaceContent.includes(`{ ${normalizedTypeName} }`));
         if (!isUsedHere)
             continue;
@@ -265,9 +447,13 @@ export async function processStructureDefinition(sd, ctx) {
     let finalInterfaceContent = interfaceContent;
     for (const [originalName, actualName] of profileIdToName?.entries() || []) {
         if (originalName !== actualName) {
-            const oldImport = `import { ${originalName} } from "./${originalName}"`;
-            const newImport = `import { ${actualName} } from "./${actualName}"`;
-            finalInterfaceContent = finalInterfaceContent.replace(oldImport, newImport);
+            // Matched by pattern, not by a literal string: the emitted form carries a
+            // `type` modifier, and a literal that omitted it renamed the *usages*
+            // while leaving the import pointing at the old module — which generated
+            // `Cannot find module './BodySite'` alongside `Cannot find name
+            // 'BodyStructureReference'` in the same file.
+            const importRegex = new RegExp(`import(\\s+type)?\\s+\\{\\s*${originalName}\\s*\\}\\s+from\\s+"\\./${originalName}"`, 'g');
+            finalInterfaceContent = finalInterfaceContent.replace(importRegex, (_m, typeModifier) => `import${typeModifier ?? ''} { ${actualName} } from "./${actualName}"`);
             const typeUsageRegex = new RegExp(`(:\\s+|Array<|\\|\\s+|&\\s+|extends\\s+)${originalName}(?=\\s*[;,>\\|&\\)\\n\\[\\s{])`, 'g');
             finalInterfaceContent = finalInterfaceContent.replace(typeUsageRegex, `$1${actualName}`);
         }
@@ -287,6 +473,8 @@ export async function processStructureDefinition(sd, ctx) {
     finalInterfaceContent = dedupedLines.join('\n');
     // ── Required fields ──────────────────────────────────────────────
     const merged = mergeFields(aligned.alignedNewFields, parsed.oldFields);
+    await fillUnstatedFromBaseResource(merged, sd.type);
+    await fillSliceProfileUrlsFromBaseProfiles(merged, sd.baseDefinition);
     // ── Pre-resolve Extension SDs for validator emission ─────────────
     const extensionMetadata = await resolveExtensionMetadata(merged);
     const datatypeProfilePins = await resolveDatatypeProfilePins(merged);

package/out/src/generator/sdProcessorRequiredFields.js

@@ -173,16 +173,41 @@ function choiceSuffix(type) {
  * The trailing `[x]` is also tried stripped, because a profile that pins the
  * choice may record it under the bare name.
  */
-function narrowedSegmentType(id, candidateFields) {
-    const bare = id.replace(/\[x\]$/, '');
-    const narrowed = new Set();
+/**
+ * Narrowed types by field name, built once per field list.
+ *
+ * The scan used to run per `[x]` segment, which is O(fields × segments): us-core
+ * has thousands of both, and generation crossed the 300s subprocess timeout in CI
+ * (`spawnSync /bin/sh ETIMEDOUT`) while every package small enough to finish still
+ * passed. Keyed on the array itself so callers need not thread an index through.
+ */
+const narrowedTypeIndexes = new WeakMap();
+function narrowedTypeIndex(candidateFields) {
+    const cached = narrowedTypeIndexes.get(candidateFields);
+    if (cached)
+        return cached;
+    const index = new Map();
     for (const candidate of candidateFields) {
-        if (candidate.name !== id && candidate.name !== bare)
-            continue;
         const type = singleType(candidate);
-        if (type)
-            narrowed.add(type);
+        if (!type || !candidate.name)
+            continue;
+        let types = index.get(candidate.name);
+        if (!types)
+            index.set(candidate.name, (types = new Set()));
+        types.add(type);
     }
+    narrowedTypeIndexes.set(candidateFields, index);
+    return index;
+}
+function narrowedSegmentType(id, candidateFields) {
+    const index = narrowedTypeIndex(candidateFields);
+    const bare = id.replace(/\[x\]$/, '');
+    // Both spellings, unioned: the same element appears under `value[x]` and, once a
+    // profile pins it, under `value`. Disagreement still names nothing.
+    const narrowed = new Set([
+        ...(index.get(id) ?? []),
+        ...(bare === id ? [] : index.get(bare) ?? []),
+    ]);
     return narrowed.size === 1 ? [...narrowed][0] : undefined;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelfhir-ts",
-  "version": "1.5.20",
+  "version": "1.5.21",
   "description": "BabelFHIR-TS: generate TypeScript interfaces, validators, and helper classes from FHIR R4/R4B/R5 StructureDefinitions (profiles) directly inside package archives.",
   "type": "module",
   "main": "out/src/main.js",
@@ -86,6 +86,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@max-health/config": "github:max-health-inc/config",
     "@maxhealth.tech/prefab": "^0.3.5",
     "@types/node": "^25.9.5",
     "@types/semver": "^7.7.1",