babelfhir-ts 1.5.20 → 1.5.21

package/out/src/cli/updateCommand.js

@@ -114,21 +114,28 @@ async function promptInstallRedirect(packageFilter, confirm) {
         return { redirectInstall: packageFilter };
     return {};
 }
-/** Default Y/N prompt reading from stdin. */
-function defaultConfirm(question) {
-    return new Promise((resolve) => {
-        process.stdout.write(question);
-        const rl = (async () => {
-            const { createInterface } = await import('readline');
-            return createInterface({ input: process.stdin, output: process.stdout });
-        })();
-        rl.then(r => {
-            r.question('', (answer) => {
-                r.close();
+/**
+ * Default Y/N prompt reading from stdin.
+ *
+ * The readline import is awaited rather than `.then`-ed inside a `new Promise`:
+ * that form dropped a rejection on the floor, and since nothing ever called
+ * `resolve`, a failed import left the caller awaiting a promise that could not
+ * settle. Declining is the safe answer when the prompt cannot be shown.
+ */
+async function defaultConfirm(question) {
+    process.stdout.write(question);
+    const { createInterface } = await import('readline');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return await new Promise((resolve) => {
+            rl.question('', (answer) => {
                 resolve(!answer || answer.toLowerCase().startsWith('y'));
             });
         });
-    });
+    }
+    finally {
+        rl.close();
+    }
 }
 // ── Discovery ───────────────────────────────────────────────────────────────
 /** Find all lib/ directories starting from startDir. Non-recursive returns only startDir/lib. */

package/out/src/generator/core/extensionSdReader.js

@@ -0,0 +1,99 @@
+/**
+ * Reading what an Extension StructureDefinition declares about its own contents.
+ *
+ * A complex extension carries its requirements in its own SD. A profile that
+ * references one re-declares the sub-extension paths as mustSupport markers but
+ * copies none of the constraints, so anything read only from the profile's field
+ * model misses them entirely — KBV_PR_ERP_PracticeSupply's
+ * `extension:Kostentraeger.extension:Kostentraegertyp.value[x]:valueCoding` has no
+ * binding, while KBV_EX_ERP_PracticeSupply_Payor binds it required to
+ * KBV_VS_FOR_Payor_type.
+ */
+/** `Extension.extension:<name>` with no further path below it. */
+const SUB_SLICE_ID = /^Extension\.extension:([^.:]+)$/;
+/**
+ * The elements to read constraints from.
+ *
+ * Prefer the snapshot, but fall back to the differential: several published
+ * extension SDs ship without one (KBV_EX_ERP_PracticeSupply_Payor among them), and
+ * requiring a snapshot meant they resolved to no metadata at all.
+ */
+export function extensionElements(sd) {
+    const els = sd?.snapshot?.element ?? sd?.differential?.element;
+    return els?.length ? els : undefined;
+}
+/** Read a binding off an element, normalising the ValueSet reference to a bare uri. */
+export function readBinding(el) {
+    const binding = el?.binding;
+    if (!binding?.strength || !binding.valueSet)
+        return undefined;
+    const raw = typeof binding.valueSet === 'string'
+        ? binding.valueSet
+        : binding.valueSet?.reference;
+    if (!raw)
+        return undefined;
+    return { strength: binding.strength, uri: raw.split('|')[0] };
+}
+/** Type codes declared on an element. */
+function typeCodes(el) {
+    return (el?.type ?? []).map(t => t.code).filter((c) => !!c);
+}
+/**
+ * `min` on the unsliced `Extension.extension` element.
+ *
+ * This is what HL7 reports as "Extension.extension: minimum required = N", and it is
+ * not the sum of the slice minimums — the SD states it directly.
+ */
+export function readSubExtensionMin(els) {
+    const el = els.find(e => (e.id ?? e.path) === 'Extension.extension' && !e.sliceName);
+    return typeof el?.min === 'number' ? el.min : undefined;
+}
+/**
+ * Collect the sub-extension slices a complex extension declares.
+ *
+ * A slice with no resolvable `url` is dropped rather than reported under its slice
+ * name: the url is how a member is recognised at runtime, and without it any check
+ * would be guessing which member to apply itself to.
+ */
+export function collectSubExtensionSlices(els) {
+    const byId = new Map();
+    for (const el of els) {
+        const id = el.id ?? el.path;
+        if (id)
+            byId.set(id, el);
+    }
+    const out = [];
+    for (const el of els) {
+        const id = el.id ?? el.path;
+        const match = id ? SUB_SLICE_ID.exec(id) : null;
+        if (!match)
+            continue;
+        const sliceName = el.sliceName ?? match[1];
+        const urlEl = byId.get(`Extension.extension:${sliceName}.url`);
+        const url = typeof urlEl?.fixedUri === 'string' ? urlEl.fixedUri : undefined;
+        if (!url)
+            continue;
+        const valueEl = byId.get(`Extension.extension:${sliceName}.value[x]`);
+        let valueTypes = typeCodes(valueEl);
+        let binding = readBinding(valueEl);
+        // The binding usually sits on the typed slice (…value[x]:valueCoding) rather than
+        // on value[x] itself, which is where the Payor extension puts it.
+        for (const code of valueTypes.length ? valueTypes : ['']) {
+            const suffix = code ? code.charAt(0).toUpperCase() + code.slice(1) : '';
+            const typedEl = suffix ? byId.get(`Extension.extension:${sliceName}.value[x]:value${suffix}`) : undefined;
+            if (!typedEl)
+                continue;
+            binding = binding ?? readBinding(typedEl);
+            if (valueTypes.length === 0)
+                valueTypes = typeCodes(typedEl);
+        }
+        out.push({
+            sliceName,
+            url,
+            min: typeof el.min === 'number' ? el.min : 0,
+            valueTypes,
+            binding,
+        });
+    }
+    return out;
+}

package/out/src/generator/core/utils.js

@@ -181,6 +181,48 @@ export function alignFields(newFields, oldFields) {
     // Return the original oldFields and the aligned newFields
     return { alignedNewFields, oldFields };
 }
+/** A type the parser could not pin down from the element itself. */
+function isUnstatedType(type) {
+    return !type || type === 'any';
+}
+/**
+ * Carry forward what a differential element left unstated.
+ *
+ * A differential says only what it changes, so an element that constrains
+ * cardinality alone carries no `type` and an element that constrains `min` alone
+ * carries no `max`. Both are inherited rather than defaulted away.
+ */
+function inheritUnstatedFromBase(field, base) {
+    if (!base)
+        return field;
+    const merged = { ...field };
+    if (isUnstatedType(merged.type) && !isUnstatedType(base.type)) {
+        merged.type = base.type;
+    }
+    if (!merged.baseTypeCode && base.baseTypeCode) {
+        merged.baseTypeCode = base.baseTypeCode;
+    }
+    // `max` absent means the differential did not narrow the upper bound, so the
+    // base's bound — and with it whether the element repeats — still holds.
+    if (merged.max === undefined && base.max !== undefined) {
+        merged.max = base.max;
+        merged.isArray = base.isArray;
+    }
+    if (!merged.typeOptions?.length && base.typeOptions?.length) {
+        merged.typeOptions = base.typeOptions;
+    }
+    // An extension slice is recognised at runtime by the canonical its profile
+    // names. A derived profile that only tightens cardinality does not restate it —
+    // KBV_PR_ERP_Medication_PZN redeclares extension:Kategorie and extension:Normgroesse
+    // with no type.profile, while KBV_PR_Base_Medication gives them
+    // KBV_EX_Base_Medication_Type and .../normgroesse. Dropping the base's left two
+    // of four slices unidentifiable, so the closed-slicing check on
+    // Medication.extension could not build its allowed set and stayed silent.
+    if (!merged.profileUrls?.length && base.profileUrls?.length) {
+        merged.profileUrls = base.profileUrls;
+    }
+    return merged;
+}
 export function mergeFields(newFields, oldFields) {
     const fieldMap = new Map();
     // Create unique key for field - use elementId if available (includes slice names for child elements)
@@ -208,9 +250,22 @@ export function mergeFields(newFields, oldFields) {
         }
         fieldMap.set(key, field);
     }
-    // Overwrite or add newFields to the map
+    // Overwrite or add newFields to the map.
+    //
+    // A differential element states only what it *changes*. Replacing the base
+    // field wholesale therefore threw away everything it stayed silent about:
+    // 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 said nothing. The same silence on `max` left Medication.ingredient
+    // with isArray=false despite being 0..* in the base, so paths beneath it were
+    // never walked.
+    //
+    // Only genuinely absent properties are filled in; anything the differential
+    // states still wins.
     for (const field of newFields) {
-        fieldMap.set(getFieldKey(field), field);
+        const key = getFieldKey(field);
+        fieldMap.set(key, inheritUnstatedFromBase(field, fieldMap.get(key)));
     }
     // Return the merged fields as an array
     return Array.from(fieldMap.values());

package/out/src/generator/emitters/class/classTemplate.js

@@ -26,7 +26,7 @@ export function renderClassTemplate(params) {
     const helperImportList = Array.from(helperImports).join(', ');
     const hasVsBindings = Object.keys(valueSetBindings).length > 0;
     return `
-import { validate${interfaceName}, ${interfaceName} } from "./${interfaceName}.js";
+import { validate${interfaceName}, type ${interfaceName} } from "./${interfaceName}.js";
 import type { ValidatorOptions } from "./ValidatorOptions.js";
 // Only import helpers actually referenced below (dynamic based on required fields)
 import { ${helperImportList} } from "./random/index.js";
@@ -55,7 +55,13 @@ function safeClone<T>(value: T): T {
 
 export class ${className} {
 ${generatePatternMetadata(fieldPatterns, forbiddenFields, valueSetBindings, fieldOrder, codeableConceptBindings)}
-  constructor(private resource: ${interfaceName}) {
+  private resource: ${interfaceName};
+
+  // Declared and assigned rather than written as a parameter property, which
+  // erasableSyntaxOnly bans: it emits real assignment code from what reads as a
+  // type annotation. Generated output is held to the same strictness as src/.
+  constructor(resource: ${interfaceName}) {
+    this.resource = resource;
     ${constructorMetaProfile}
   }
   /** Validate current resource instance. */

package/out/src/generator/emitters/client/clientGenerator.js

@@ -176,11 +176,16 @@ export type FetchFn = typeof globalThis.fetch;
 export class FhirResourceReader<T, S extends SearchParams = SearchParams> implements FhirResourceSearcher<T, S> {
   private readonly fetchFn: FetchFn;
 
+  public readonly baseUrl: string;
+  public readonly resourceType: string;
+
   constructor(
-    public readonly baseUrl: string,
-    public readonly resourceType: string,
+    baseUrl: string,
+    resourceType: string,
     fetchFn?: FetchFn,
   ) {
+    this.baseUrl = baseUrl;
+    this.resourceType = resourceType;
     this.fetchFn = fetchFn ?? globalThis.fetch.bind(globalThis);
   }
 
@@ -321,11 +326,16 @@ import type { FetchFn } from "./resource-reader.js";
 export class FhirResourceWriterImpl<T> implements FhirResourceWriter<T> {
   private readonly fetchFn: FetchFn;
 
+  public readonly baseUrl: string;
+  public readonly resourceType: string;
+
   constructor(
-    public readonly baseUrl: string,
-    public readonly resourceType: string,
+    baseUrl: string,
+    resourceType: string,
     fetchFn?: FetchFn,
   ) {
+    this.baseUrl = baseUrl;
+    this.resourceType = resourceType;
     this.fetchFn = fetchFn ?? globalThis.fetch.bind(globalThis);
   }
 
@@ -451,7 +461,11 @@ export type BundleEntry<T extends FhirResource = FhirResource> = {
  * FHIR Bundle Parser - provides type-safe parsing and filtering of FHIR Bundles
  */
 export class BundleParser {
-  constructor(private readonly bundle: Bundle<FhirResource>) {}
+  private readonly bundle: Bundle<FhirResource>;
+
+  constructor(bundle: Bundle<FhirResource>) {
+    this.bundle = bundle;
+  }
 
   /**
    * Get all resources from the bundle
@@ -659,11 +673,13 @@ ${writerMethods}
 export class FhirClient {
   private readonly readClient: FhirReadClient;
   private readonly writeClient: FhirWriteClient;
+  public readonly baseUrl: string;
 
   constructor(
-    public readonly baseUrl: string,
+    baseUrl: string,
     fetchFn?: FetchFn,
   ) {
+    this.baseUrl = baseUrl;
     this.readClient = new FhirReadClient(baseUrl, fetchFn);
     this.writeClient = new FhirWriteClient(baseUrl, fetchFn);
   }

package/out/src/generator/emitters/client/smartAuthGenerator.js

@@ -167,7 +167,10 @@ export class SmartAuth {
   private readonly storage: Storage;
   private readonly keys: ReturnType<typeof storageKeys>;
 
-  constructor(public readonly config: SmartConfig) {
+  public readonly config: SmartConfig;
+
+  constructor(config: SmartConfig) {
+    this.config = config;
     this.storage = config.storage ?? sessionStorage;
     this.keys = storageKeys(config.storagePrefix ?? "smart_");
   }

package/out/src/generator/emitters/interface/backboneSliceTyping.js

@@ -135,7 +135,7 @@ function collectSliceGroups(fields, baseFields, baseResource) {
         if (!isEligibleBackbonePath(field.baseTypeCode || field.type || '', path, baseResource))
             continue;
         const childFields = gatherChildFields(fields, path);
-        const slicingRules = field.slicingRules || 'open';
+        const slicingRules = field.slicingRules ?? 'open';
         seenPaths.add(path);
         groups.push({ parentField: field, sliceFields, childFields, slicingRules });
     }
@@ -160,7 +160,7 @@ function collectSliceGroups(fields, baseFields, baseResource) {
         if (sliceFields.length === 0)
             continue;
         const childFields = gatherChildFields(fields, path);
-        const slicingRules = parentField.slicingRules || 'open';
+        const slicingRules = parentField.slicingRules ?? 'open';
         seenPaths.add(path);
         groups.push({ parentField, sliceFields, childFields, slicingRules });
     }

package/out/src/generator/emitters/interface/postProcessExtensions.js

@@ -4,6 +4,7 @@
  */
 import { capitalize, sanitizeIdentifier, toPascalCase, stripVersionFromCanonicalUrl } from '../../core/utils.js';
 import { logger } from '../../../logger.js';
+import {} from './importManager.js';
 import { getRules } from '../../fhir/versionContext.js';
 export function postProcessExtensions(params) {
     const { interfaces, interfaceName, baseResource, newFields, baseFieldByLastSegment, importManager, existingProfiles, profileUrlToName, generatedAliasTypes, findInterfaceIndex, inferBackboneType, addTypeImport } = params;

package/out/src/generator/emitters/validator/closedSlicingValidation.js

@@ -0,0 +1,146 @@
+/**
+ * Closed slicing enforcement.
+ *
+ * `slicing.rules = 'closed'` means an instance element matching none of the declared
+ * slices is an error. Nothing enforced it: `slicingRules` was read in the interface
+ * emitter through an `as unknown as` cast and never written by any parser, so every
+ * slicing looked open. HL7 reports these as
+ *   "This element does not match any known slice defined in the profile <url>
+ *    and slicing is CLOSED: <path>"
+ * and they were the whole `entry` category of the remaining random-parity failures
+ * (davinci-dtr, kbv-erp — issue #138).
+ *
+ * Two discriminator shapes are enforced:
+ *   - `{value, url}` on an extension slot — the member's url must be declared
+ *   - `{type, $this}` on a choice element — the chosen type must be declared
+ *
+ * Deliberately limited to slicings introduced at an unsliced path. A slicing declared
+ * *inside* another slice (`Medication.extension:Kategorie.value[x]`) shares its
+ * unsliced name with its siblings, so the field model cannot tell the sets apart:
+ * merging them applies one slice's allowed types to every member and reports a
+ * conformant resource. Enforcing those needs slice-scoped traversal and is left off
+ * rather than approximated.
+ */
+import { stripVersionFromCanonicalUrl } from '../../core/utils.js';
+const CHOICE_SUFFIX = '[x]';
+/** The url an instance of this extension slice carries (pinned `url` child, else profile). */
+function instanceUrl(slice, fields) {
+    const sliceElemId = (slice.elementId || slice.name).replace(/^[^.]+\./, '');
+    const sliceFullId = slice.sliceName && !sliceElemId.includes(':')
+        ? `${sliceElemId}:${slice.sliceName}`
+        : sliceElemId;
+    for (const f of fields) {
+        const childId = (f.elementId || f.name).replace(/^[^.]+\./, '');
+        if (childId === sliceFullId + '.url' && typeof f.fixedValue === 'string')
+            return f.fixedValue;
+    }
+    return slice.profileUrls?.length ? stripVersionFromCanonicalUrl(slice.profileUrls[0]) : undefined;
+}
+/**
+ * The property name a choice slice occupies.
+ *
+ * A choice slice is conventionally named after the property (`valueCoding`), so the
+ * slice name is used when it already starts with the base property; the declared
+ * type is the fallback (`value[x]` + type `Coding` → `valueCoding`).
+ */
+function choiceProperty(baseProp, slice) {
+    if (slice.sliceName?.startsWith(baseProp))
+        return slice.sliceName;
+    const code = slice.typeOptions?.[0]?.code ?? slice.baseTypeCode ?? slice.type;
+    if (!code)
+        return undefined;
+    return `${baseProp}${code.charAt(0).toUpperCase()}${code.slice(1)}`;
+}
+/** Classify a closed slicing, or undefined when it is not one this module enforces. */
+function classify(leaf) {
+    if (leaf === 'extension' || leaf === 'modifierExtension')
+        return 'extension-url';
+    if (leaf.endsWith(CHOICE_SUFFIX))
+        return 'choice-type';
+    return undefined;
+}
+/**
+ * Bind `_csElem` to every element at `segments`, flattening array hops.
+ *
+ * Always the flattening walk, never a plain `at()`: the field model's array flags do
+ * not always agree with the instance (Medication.ingredient is 0..* yet was read as a
+ * single element), and `elementsAt` is correct for both shapes.
+ */
+function walk(segments, body) {
+    const pathArgs = segments.map(s => `'${s}'`).join(', ');
+    return `\n  for (const _csElem of elementsAt(resource, [${pathArgs}])) {${body}\n  }`;
+}
+/**
+ * Emit closed-slicing checks for every element that introduces a closed slicing.
+ */
+export function generateClosedSlicingValidations(fields, profileUrl, baseResourceType) {
+    const out = [];
+    const seen = new Set();
+    for (const field of fields) {
+        if (field.slicingRules !== 'closed' || field.sliceName)
+            continue;
+        // Address the slicing by its element id so slice qualifiers stay visible.
+        const elemId = (field.elementId || field.name).replace(/^[^.]+\./, '');
+        if (!elemId || seen.has(elemId))
+            continue;
+        // A slicing nested inside another slice cannot be addressed from the root.
+        if (elemId.includes(':'))
+            continue;
+        const segments = elemId.split('.');
+        const leaf = segments[segments.length - 1];
+        const kind = classify(leaf);
+        if (!kind)
+            continue;
+        // A choice segment above the leaf is not a JSON property name, so the walk
+        // cannot reach past it.
+        if (segments.slice(0, -1).some(s => s.endsWith(CHOICE_SUFFIX)))
+            continue;
+        const slices = fields.filter(f => f.sliceName && f.name === field.name);
+        if (slices.length === 0)
+            continue;
+        const fhirPath = `${baseResourceType ?? 'Resource'}.${elemId}`;
+        const profileRef = profileUrl ?? (baseResourceType ?? '');
+        const message = `This element does not match any known slice defined in the profile ${profileRef} and slicing is CLOSED: ${fhirPath}`;
+        if (kind === 'extension-url') {
+            const urls = slices.map(s => instanceUrl(s, fields)).filter((u) => !!u);
+            // Every slice must be identifiable, or a conformant member gets reported.
+            if (urls.length !== slices.length)
+                continue;
+            const allowed = `[${[...new Set(urls)].map(u => `"${u}"`).join(', ')}]`;
+            // A member with no url matches no slice either, and HL7 reports it: every
+            // discriminator here is `<canonical> in url`, so an absent url satisfies none
+            // of them. Firing only on a *present* url meant the member KBV's random
+            // Medication carries — `{extension:[…]}` with no url at all — went unreported
+            // while HL7 named all four slices it failed to match. The missing url itself
+            // is a separate finding (Extension.url: minimum required = 1) that both
+            // validators already agree on; this is the slicing violation on top of it.
+            out.push(`
+  // Closed slicing on ${fhirPath}: only the declared extension urls are allowed${walk(segments, `
+    const _csUrl = at(_csElem, 'url');
+    if (typeof _csUrl !== 'string' || !${allowed}.includes(_csUrl)) {
+      errors.push("${message}" + (typeof _csUrl === 'string' ? " (url = " + _csUrl + ")" : " (no url)"));
+    }`)}`);
+            seen.add(elemId);
+            continue;
+        }
+        // choice-type: the slot is `foo[x]`, so an instance writes `fooCoding` etc.
+        const baseProp = leaf.slice(0, -CHOICE_SUFFIX.length);
+        const props = slices.map(s => choiceProperty(baseProp, s)).filter((p) => !!p);
+        if (props.length !== slices.length)
+            continue;
+        const allowedProps = `[${[...new Set(props)].map(p => `"${p}"`).join(', ')}]`;
+        // The choice lives on the parent element — `foo[x]` is not a property name.
+        const body = `
+    const _csKey = Object.keys(node(_csElem)).find((k) => k.startsWith("${baseProp}") && k !== "${baseProp}");
+    if (_csKey !== undefined && !${allowedProps}.includes(_csKey)) {
+      errors.push("${message}.ofType(" + _csKey.slice(${baseProp.length}).toLowerCase() + ")");
+    }`;
+        const parentSegments = segments.slice(0, -1);
+        out.push(`
+  // Closed slicing on ${fhirPath}: only the declared types are allowed${parentSegments.length === 0
+            ? `\n  {\n    const _csElem = resource;${body}\n  }`
+            : walk(parentSegments, body)}`);
+        seen.add(elemId);
+    }
+    return out;
+}