babelfhir-ts 1.5.20 → 1.5.21

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

@@ -149,6 +149,38 @@ export function buildInlineResourceTypeValidations(fields, profileUrl) {
  * Build deeply nested required field validations.
  * For fields like component.value[x].data (min=1) where the parent is an array.
  */
+/**
+ * Rewrite an element id whose only slice qualifiers name choice-type variants into
+ * the concrete JSON path, or undefined when any qualifier discriminates a subset.
+ *
+ * `ingredient.item[x]:itemCodeableConcept.text` → `ingredient.itemCodeableConcept.text`.
+ * A qualifier is only accepted when its base ends in `[x]` and the slice name starts
+ * with the base property, which is the convention that makes the slice name the
+ * property name. `identifier:NPI.value` fails both tests and is still skipped: NPI
+ * is one identifier among several, so requiring its children of every identifier
+ * would report a conformant resource.
+ */
+function leafFieldName(parts) {
+    return parts[parts.length - 1];
+}
+function resolveChoiceSliceSegments(elementIdRel) {
+    const segments = elementIdRel.split('.');
+    const out = [];
+    for (const segment of segments) {
+        if (!segment.includes(':')) {
+            out.push(segment.replace(/\[x\]$/, ''));
+            continue;
+        }
+        const [base, sliceName] = segment.split(':');
+        if (!base.endsWith('[x]') || !sliceName)
+            return undefined;
+        const baseProp = base.slice(0, -'[x]'.length);
+        if (!sliceName.startsWith(baseProp) || sliceName === baseProp)
+            return undefined;
+        out.push(sliceName);
+    }
+    return out.join('.');
+}
 export function buildNestedRequiredValidations(fields, arrayFieldPaths) {
     const result = [];
     fields
@@ -162,15 +194,34 @@ export function buildNestedRequiredValidations(fields, arrayFieldPaths) {
         let rel = relFull.replace(/^[^.]+\./, '').replace(/\[x\]/g, '');
         if (!rel)
             return;
-        // Skip slice-specific fields
+        // Skip slice-specific fields: a slice's requirements bind only its own
+        // members, and this builder emits an unconditional check.
+        //
+        // One exception, and it is not really a subset. A choice-type slice names a
+        // JSON property rather than discriminating within one: FHIR writes
+        // `item[x]:itemCodeableConcept` for the CodeableConcept variant of `item[x]`,
+        // and an instance carrying that variant writes `itemCodeableConcept`. So the
+        // slice *is* the property, and its required children apply whenever the
+        // property is present — which is what HL7 reports as
+        // "Medication.ingredient.item[x]:itemCodeableConcept.text: minimum required = 1"
+        // where we said nothing, because `field.name` flattens `item[x]` to `item`
+        // and loses which variant was meant.
         const elementId = field.elementId || relFull;
-        if (elementId.includes(':'))
-            return;
+        let choiceSliceResolved = false;
+        if (elementId.includes(':')) {
+            const resolved = resolveChoiceSliceSegments(elementId.replace(/^[^.]+\./, ''));
+            if (!resolved)
+                return;
+            rel = resolved;
+            choiceSliceResolved = true;
+        }
         const pathParts = rel.split('.');
         if (pathParts.length < 2)
             return;
-        // Resolve choice type in path
-        if (relFull.includes('[x]')) {
+        // Resolve choice type in path. Skipped when the element id already named the
+        // variant: this block reads the *leaf's* own type, which for a nested leaf
+        // (…item[x]:itemCodeableConcept.text) is the text's type, not the choice's.
+        if (relFull.includes('[x]') && !choiceSliceResolved) {
             // The JSON property name comes from the element's *own* type, not its parent's.
             // Reading the parent discarded the check whenever that parent was a container:
             // Claim.item.location[x] is typed CodeableConcept, so the property is
@@ -203,8 +254,27 @@ export function buildNestedRequiredValidations(fields, arrayFieldPaths) {
         // segment to be an array meant a path whose only array sits deeper
         // (Observation.code.coding.code — code is 0..1, coding is the array) bailed
         // out and emitted nothing, leaving HL7 to report the missing element alone.
-        if (!topIsArray && !hasIntermediateArray)
+        if (!topIsArray && !hasIntermediateArray) {
+            // A choice-slice path is emitted even when no level is a known array.
+            // `Medication.ingredient` is 0..* in the base but the KBV differential
+            // constrains only its `min`, so the merged field carries no max and
+            // `isArray` reads false — the check bailed and HL7 reported
+            // "…itemCodeableConcept.text: minimum required = 1" alone. `elementsAt`
+            // flattens an array level and passes a single object through unchanged,
+            // so it is right either way and does not depend on that flag.
+            if (!choiceSliceResolved)
+                return;
+            const walk = resolvedParts.slice(0, -1).map(p => `'${p}'`).join(', ');
+            result.push(`
+  // Nested required field: ${rel} (min=1)
+  for (const _nrEl of elementsAt(resource, [${walk}])) {
+    const _nrLeaf = at(_nrEl, '${leafFieldName(resolvedParts)}');
+    if (_nrLeaf === undefined || _nrLeaf === null) {
+      errors.push("Missing required member: '${leafFieldName(resolvedParts)}'");
+    }
+  }`);
             return;
+        }
         const leafField = resolvedParts[resolvedParts.length - 1];
         // Check if the leaf field itself is an array — if so, don't flag Array values as absent
         const fullLeafPath = resolvedParts.join('.');
@@ -450,6 +520,20 @@ export function buildProhibitedFieldValidations(fields, arrayFieldPaths, fieldPa
             // Skip if ANY segment has a slice qualifier — the constraint is
             // slice-scoped (e.g. name:Geburtsname.given) and must not be emitted
             // as a global prohibition.
+            //
+            // TODO(parity): this correctly avoids a global prohibition but emits nothing
+            // at all, so slice-scoped max=0 goes unchecked. A complex extension sets its
+            // own value[x] to max=0 — sub-extensions or a value, never both — and we miss
+            // it: on DTRStdQuestionnaire, HL7 reports "Extension.value[x]: max allowed =
+            // 0, but found 1" and "Extension.extension: minimum required = 2, but only
+            // found 0" for item.extension:contextExpression while we report neither.
+            //
+            // Fixing it needs a slice-scoped emission, not a relaxed guard: iterate the
+            // extensions matching the slice's url and assert the absence of any value*
+            // property. It cannot name one property, because a forbidden choice narrows
+            // to no type — which is why the choice resolution elsewhere in this file
+            // skips it too. Removing this guard instead would reintroduce the regression
+            // where AuditEvent.agent:user.requestor was demanded of every agent.
             const segments = field.elementId.split('.');
             if (segments.some(seg => seg.includes(':')))
                 return false;
@@ -570,6 +654,16 @@ const FHIR_PRIMITIVE_TYPES = new Set([
     'time', 'instant', 'code', 'id', 'oid', 'markdown', 'base64Binary',
     'uuid', 'positiveInt', 'unsignedInt', 'integer64', 'xhtml',
 ]);
+/**
+ * FHIR primitives that serialize as a JSON number.
+ *
+ * integer64 is deliberately absent: R5 serializes it as a *string* to survive
+ * JavaScript's 53-bit safe integer range, so requiring a number would reject
+ * conformant data.
+ */
+const NUMERIC_PRIMITIVES = new Set([
+    'decimal', 'integer', 'positiveInt', 'unsignedInt',
+]);
 /** Check whether a FHIR type serializes as a JSON primitive (string/number/bool). */
 function isFhirPrimitive(fieldType) {
     if (FHIR_PRIMITIVE_TYPES.has(fieldType))
@@ -595,9 +689,72 @@ const CONTAINER_TYPES = new Set([
  *
  * Only top-level (depth-1) non-sliced fields are checked.
  */
+/**
+ * A numeric or boolean primitive below a repeating element must still hold the right
+ * JSON kind.
+ *
+ * The flat pass deliberately skips any path with an array ancestor, because a path
+ * walk cannot descend one — so `ingredient.strength.numerator.value` went unchecked
+ * and HL7 reported "The value 'Example value' is not a valid decimal" alone. This
+ * emits the loop that pass declined to guess at.
+ *
+ * Both of HL7's headings are pushed: the value wording classifies as `unclassified`
+ * and the parse wording as `constraint`, so emitting only the first leaves
+ * `constraint` looking like an HL7-only finding.
+ */
+function buildArrayNestedPrimitiveKindValidations(fields, arrayFieldPaths, result) {
+    const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(p.split(':')[0]);
+    const seen = new Set();
+    for (const field of fields) {
+        if (field.sliceName || field.isArray)
+            continue;
+        const rel = (field.name || '').replace(/^[^.]+\./, '');
+        if (!rel || !rel.includes('.') || rel.includes('[x]') || seen.has(rel))
+            continue;
+        const fieldType = field.type || field.baseTypeCode;
+        const jsonKind = NUMERIC_PRIMITIVES.has(fieldType || '') ? 'number'
+            : fieldType === 'boolean' ? 'boolean'
+                : undefined;
+        if (!jsonKind)
+            continue;
+        const segments = rel.split('.');
+        const parents = segments.slice(0, -1);
+        const leaf = segments[segments.length - 1];
+        // The flat pass already covers a path with no array on the way down.
+        if (!parents.some((_p, i) => isArrayPath(parents.slice(0, i + 1).join('.'))))
+            continue;
+        seen.add(rel);
+        let expr = 'resource';
+        const open = [];
+        let indent = '    ';
+        parents.forEach((segment, i) => {
+            if (isArrayPath(parents.slice(0, i + 1).join('.'))) {
+                const loopVar = `_pkEl${i}`;
+                open.push(`${indent}for (const ${loopVar} of arr(at(${expr}, '${segment}'))) {`);
+                indent += '  ';
+                expr = loopVar;
+            }
+            else {
+                expr = `at(${expr}, '${segment}')`;
+            }
+        });
+        const closes = open.map((_l, i) => '  '.repeat(open.length - i + 1) + '}').join('\n');
+        const body = `${indent}const _pkValue = at(${expr}, '${leaf}');
+${indent}if (_pkValue !== undefined && _pkValue !== null && typeof _pkValue !== '${jsonKind}') {
+${indent}  errors.push("The value '" + String(_pkValue) + "' is not a valid ${fieldType}");
+${indent}  errors.push("Error parsing JSON: the primitive value must be a ${jsonKind}");
+${indent}}`;
+        result.push(`
+  // Structural type check: ${rel} must be a JSON ${jsonKind} (${fieldType})
+  {
+${[...open, body, closes].filter(Boolean).join('\n')}
+  }`);
+    }
+}
 export function buildStructuralTypeValidations(fields, arrayFieldPaths) {
     const result = [];
     buildNestedObjectTypeValidations(fields, arrayFieldPaths, result);
+    buildArrayNestedPrimitiveKindValidations(fields, arrayFieldPaths, result);
     for (const field of fields) {
         // Skip sliced fields — handled by slice validator
         if (field.sliceName)
@@ -610,13 +767,34 @@ export function buildStructuralTypeValidations(fields, arrayFieldPaths) {
         if (fullPath.includes('[x]'))
             continue;
         const rel = fullPath.replace(/^[^.]+\./, '');
-        if (!rel || rel.includes('.'))
-            continue; // only top-level fields
+        if (!rel)
+            continue;
+        // A nested primitive is still worth checking, and only the primitive kind check
+        // below handles one: HL7 reports "The value 'Example value' is not a valid
+        // decimal" on Medication.amount.numerator.value, three levels down, where we
+        // reported nothing. The array and object checks stay top-level only, since both
+        // would need iteration to descend correctly.
+        const isNested = rel.includes('.');
+        if (isNested) {
+            // Any array on the way down needs a loop, not a path walk. Skipped rather than
+            // guessed at, so a repeating ancestor never yields a check against the array
+            // object itself.
+            // arrayFieldPaths is keyed on the *relative* path. Building the key from the
+            // full path never matched, so Bundle.entry.search.score was emitted as
+            // at(resource, 'entry', 'search', 'score') — a walk into an array, which
+            // yields undefined and checks nothing.
+            const segments = rel.split('.');
+            const hasArrayAncestor = segments.some((_seg, i) => arrayFieldPaths.has(segments.slice(0, i + 1).join('.')));
+            if (hasArrayAncestor)
+                continue;
+            if (!NUMERIC_PRIMITIVES.has(field.type || '') && field.type !== 'boolean')
+                continue;
+        }
         const fieldType = field.type || field.baseTypeCode;
         if (!fieldType)
             continue;
         // ── Array structural check ─────────────────────────────────────────
-        if (field.isArray) {
+        if (field.isArray && !isNested) {
             result.push(`
   // Structural type check: ${rel} must be a JSON Array
   {
@@ -625,10 +803,40 @@ export function buildStructuralTypeValidations(fields, arrayFieldPaths) {
       const _stType = at(resource, 'resourceType');
       errors.push("The property ${rel} must be a JSON Array, not an Object (at " + (typeof _stType === 'string' ? _stType : "Resource") + ")");
     }
+  }`);
+        }
+        // ── Primitive JSON kind check ──────────────────────────────────────
+        // A numeric or boolean FHIR primitive must not arrive as a string. We checked
+        // that complex types are objects but never that a decimal holds a number, so
+        // HL7 reported "The value 'Example value' is not a valid decimal" and "the
+        // primitive value must be a number" where we said nothing.
+        //
+        // Both headings, as HL7 reports them: the value wording classifies as
+        // `unclassified` and the parse wording as `constraint`, so emitting only the
+        // first left `constraint` attributed to HL7 alone for a defect we had detected.
+        //
+        // Only the kinds JSON distinguishes are checked. Date, code and the rest all
+        // serialize as strings, and their formats already have dedicated checks
+        // elsewhere; asserting `typeof === 'string'` on them would add nothing.
+        const jsonKind = NUMERIC_PRIMITIVES.has(fieldType) ? 'number'
+            : fieldType === 'boolean' ? 'boolean'
+                : undefined;
+        if (jsonKind && !field.isArray) {
+            // Segments, not a dotted key: at() walks its varargs, so at(resource, 'a.b')
+            // would look for a property literally named "a.b" and always find nothing.
+            const accessorArgs = rel.split('.').map(seg => `'${seg}'`).join(', ');
+            result.push(`
+  // Structural type check: ${rel} must be a JSON ${jsonKind} (${fieldType})
+  {
+    const _stValue = at(resource, ${accessorArgs});
+    if (_stValue !== undefined && _stValue !== null && typeof _stValue !== '${jsonKind}') {
+      errors.push("The value '" + String(_stValue) + "' is not a valid ${fieldType}");
+      errors.push("Error parsing JSON: the primitive value must be a ${jsonKind}");
+    }
   }`);
         }
         // ── Complex type as Object check ───────────────────────────────────
-        if (!isFhirPrimitive(fieldType) && !CONTAINER_TYPES.has(fieldType)) {
+        if (!isNested && !isFhirPrimitive(fieldType) && !CONTAINER_TYPES.has(fieldType)) {
             // Complex types must be objects when present — not primitive strings/numbers
             if (!field.isArray) {
                 result.push(`

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

@@ -1,6 +1,7 @@
 import { logger } from '../../../logger.js';
 import { sanitizeValueSetName } from '../valueset/valueSetGenerator.js';
 import { generateSliceValidations } from './sliceValidatorGenerator.js';
+import { generateClosedSlicingValidations } from './closedSlicingValidation.js';
 import { fhirpathModelSlug } from '../../fhir/versionContext.js';
 import { buildRequiredConstraints, buildMaxCardinalityConstraints, buildForbiddenFieldConstraintEntries, buildPatternValidations, buildChoiceTypeNarrowingValidations, } from './validatorConstraintBuilders.js';
 import { buildNestedRequiredValidations, buildFixedValueValidations, buildProhibitedFieldValidations, buildPrimitiveFormatValidations, buildStructuralTypeValidations, buildInlineResourceTypeValidations, INLINE_RESOURCE_SLOTS, } from './validatorFieldBuilders.js';
@@ -241,6 +242,7 @@ export function generateValidateProfileFunction(interfaceName, fields, valueSets
         valueSetImports, profileUrl, profileName: interfaceName, baseResourceType,
         profileUrlToName, validatorImports, extensionMetadata, profileUrlToType, datatypeProfilePins,
     });
+    const closedSlicingValidations = generateClosedSlicingValidations(fields, profileUrl, baseResourceType);
     const primitiveFormatValidations = buildPrimitiveFormatValidations(fields);
     const structuralTypeValidations = [
         ...buildStructuralTypeValidations(fields, arrayFieldPaths),
@@ -479,7 +481,7 @@ export function generateValidateProfileFunction(interfaceName, fields, valueSets
     })
         .join("\n");
     // ── Assemble final output ───────────────────────────────────────────────
-    const hasConstraints = filteredConstraints.length > 0 || sliceValidations.length > 0
+    const hasConstraints = filteredConstraints.length > 0 || sliceValidations.length > 0 || closedSlicingValidations.length > 0
         || patternValidations.length > 0 || fixedValueValidations.length > 0
         || bindingValidations.length > 0 || prohibitedFieldValidations.length > 0
         || bundleRefValidation.length > 0 || primitiveFormatValidations.length > 0
@@ -561,7 +563,7 @@ ${body}
   const errors: string[] = [];
   const warnings: string[] = [];
   ${fhirpathOptionsBlock}
-  ${bundleEntryResolution}${referenceTargetTypeValidation}${validationLogic}${fixedPatternValidations.join('')}${nestedRequiredValidations.join('')}${fixedValueValidations.join('')}${structuralTypeValidations.join('')}${prohibitedFieldValidations.join('')}${bindingValidations.join('')}${primitiveFormatValidations.join('')}${choiceNarrowingValidations.join('')}${sliceValidations.join('')}${datatypeProfileDelegations.join('')}${nonDomainTextCheck}${extensionStructuralValidation}${containedRefValidation}${bundledAggregationValidation}${bundleRefValidation}
+  ${bundleEntryResolution}${referenceTargetTypeValidation}${validationLogic}${fixedPatternValidations.join('')}${nestedRequiredValidations.join('')}${fixedValueValidations.join('')}${structuralTypeValidations.join('')}${prohibitedFieldValidations.join('')}${bindingValidations.join('')}${primitiveFormatValidations.join('')}${choiceNarrowingValidations.join('')}${sliceValidations.join('')}${closedSlicingValidations.join('')}${datatypeProfileDelegations.join('')}${nonDomainTextCheck}${extensionStructuralValidation}${containedRefValidation}${bundledAggregationValidation}${bundleRefValidation}
   return { errors, warnings };
 }`,
         valueSetImports

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

@@ -8,7 +8,7 @@
  * Runtime helpers every generated validator may import from ValidatorOptions.
  * Single source of truth for the emitted import list.
  */
-export const HELPER_NAMES = ['at', 'arr', 'node', 'elements', 'coding', 'codings', 'asResource', 'refsAt'];
+export const HELPER_NAMES = ['at', 'arr', 'node', 'elements', 'elementsAt', 'coding', 'codings', 'asResource', 'refsAt'];
 /**
  * Returns the content of ValidatorOptions.ts — the shared runtime options type
  * plus the element-probing helpers that every generated validateX() imports.
@@ -131,13 +131,14 @@ export function elements(value: unknown): readonly ElementShape[] {
 }
 
 /**
- * Collect the literal references found at a property path.
+ * Collect every element sitting at a property path, flattening arrays at each hop.
  *
- * Every hop flattens arrays, so one path covers both single and repeating elements
- * (Composition.author is 1..*, Composition.subject 0..1). Only string \`reference\`
- * values are returned; a Reference carrying just an identifier names no target.
+ * One path therefore covers both single and repeating elements
+ * (Composition.author is 1..*, Composition.subject 0..1) and any mix of the two,
+ * which is what \`at()\` cannot do — it stops the moment the path meets an array.
+ * Absent and null intermediates simply contribute nothing.
  */
-export function refsAt(value: unknown, path: readonly string[]): string[] {
+export function elementsAt(value: unknown, path: readonly string[]): unknown[] {
   let current: unknown[] = [value];
   for (const key of path) {
     const next: unknown[] = [];
@@ -148,9 +149,18 @@ export function refsAt(value: unknown, path: readonly string[]): string[] {
     }
     current = next;
   }
+  return current;
+}
 
+/**
+ * Collect the literal references found at a property path.
+ *
+ * Only string \`reference\` values are returned; a Reference carrying just an
+ * identifier names no target.
+ */
+export function refsAt(value: unknown, path: readonly string[]): string[] {
   const found: string[] = [];
-  for (const item of current) {
+  for (const item of elementsAt(value, path)) {
     const reference = at(item, 'reference');
     if (typeof reference === 'string') found.push(reference);
   }

package/out/src/generator/index.js

@@ -223,16 +223,18 @@ async function generateIndexFile(dir) {
     const files = fs.readdirSync(dir, { withFileTypes: true });
     const exports = [];
     const exportedNames = new Set();
-    // First pass: collect all files and their exported names
+    // First pass: collect all files and their exported names, keeping the
+    // declaration kind — `verbatimModuleSyntax` needs a re-exported type to go
+    // through `export type { … }`, so the barrel has to know which is which.
     const fileExports = new Map();
     for (const file of files) {
         if (file.isFile() && file.name.endsWith('.ts') && !file.name.endsWith('.d.ts') && file.name !== 'index.ts' && file.name !== 'ValidatorOptions.ts') {
             const filePath = path.join(dir, file.name);
             const content = fs.readFileSync(filePath, 'utf-8');
-            const names = new Set();
-            const exportMatches = content.matchAll(/export\s+(?:interface|class|type|const|function)\s+(\w+)/g);
+            const names = new Map();
+            const exportMatches = content.matchAll(/export\s+(interface|class|type|const|function)\s+(\w+)/g);
             for (const match of exportMatches) {
-                names.add(match[1]);
+                names.set(match[2], match[1] === 'interface' || match[1] === 'type' ? 'type' : 'value');
             }
             fileExports.set(file.name, names);
         }
@@ -241,11 +243,11 @@ async function generateIndexFile(dir) {
     for (const file of files) {
         if (file.isFile() && file.name.endsWith('.ts') && !file.name.endsWith('.d.ts') && file.name !== 'index.ts' && file.name !== 'ValidatorOptions.ts') {
             const baseName = file.name.replace('.ts', '');
-            const fileNames = fileExports.get(file.name) || new Set();
+            const fileNames = fileExports.get(file.name) || new Map();
             // Find which names from this file conflict with already-exported names
             const conflicting = new Set();
             const unique = new Set();
-            for (const name of fileNames) {
+            for (const name of fileNames.keys()) {
                 if (exportedNames.has(name)) {
                     conflicting.add(name);
                 }
@@ -254,17 +256,25 @@ async function generateIndexFile(dir) {
                 }
             }
             if (conflicting.size === 0) {
-                // No conflicts — use simple wildcard export
+                // No conflicts — use simple wildcard export. `export *` carries types
+                // without needing the `type` modifier.
                 exports.push(`export * from './${baseName}.js';`);
             }
             else if (unique.size > 0) {
-                // Has conflicts but also has unique names — use selective named export
-                const names = [...unique].sort().join(', ');
-                exports.push(`export { ${names} } from './${baseName}.js';`);
+                // Has conflicts but also has unique names — use selective named exports,
+                // split by kind so re-exported types carry the `type` modifier.
+                const typeNames = [...unique].filter(n => fileNames.get(n) === 'type').sort();
+                const valueNames = [...unique].filter(n => fileNames.get(n) !== 'type').sort();
+                if (valueNames.length > 0) {
+                    exports.push(`export { ${valueNames.join(', ')} } from './${baseName}.js';`);
+                }
+                if (typeNames.length > 0) {
+                    exports.push(`export type { ${typeNames.join(', ')} } from './${baseName}.js';`);
+                }
             }
             // If all names conflict (unique.size === 0), skip entirely
             // Track all names from this file as exported
-            for (const name of fileNames) {
+            for (const name of fileNames.keys()) {
                 exportedNames.add(name);
             }
         }

package/out/src/generator/parser/sdParser.js

@@ -442,6 +442,7 @@ export async function parseStructureDefinition(structureDefinition, fhirServerUr
             type,
             baseTypeCode, // Raw FHIR type code (e.g., "HumanName" even when type is "humanname-de-basis")
             sliceName: element.sliceName,
+            slicingRules: element.slicing?.rules,
             profileUrls: (element.type || []).flatMap(t => t.profile || []),
             binding: bindingMeta,
             isProfiled: hasProfile,