babelfhir-ts 1.5.19 → 1.5.21

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

@@ -123,32 +123,96 @@ export function isArrayPath(relPath, fieldPathMap, arrayFieldPaths) {
     return false;
 }
 /**
- * Collect direct children of a slice that have finite max cardinality constraints.
+ * Resolve a slice that pins a *coded child* rather than itself.
+ *
+ * patternIdentifier of `{type: {coding: [...]}}` discriminates on
+ * identifier.type, not on the Identifier. That matches neither the
+ * patternCodeableConcept shape (`coding` at the top level) nor patternCoding
+ * (`system`/`code` at the top level), so such a slice fell through to the child's
+ * *binding* instead: cdex pins tracking-id, and we compared against the whole
+ * v2-0203 identifier-type ValueSet, so a conformant identifier never matched and
+ * the required slice was reported missing.
+ *
+ * Returns a synthetic child field carrying the nested pattern, so the existing
+ * child-pattern machinery discriminates on the pinned coding.
+ */
+export function resolveNestedPatternChild(slice) {
+    const pattern = slice.patternConstraint;
+    if (!pattern || typeof pattern !== 'object')
+        return undefined;
+    const top = pattern;
+    // Already handled by the patternCodeableConcept / patternCoding branches.
+    if ('coding' in top || 'system' in top || 'code' in top)
+        return undefined;
+    for (const [childProp, value] of Object.entries(top)) {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            continue;
+        const coding = value.coding;
+        if (!Array.isArray(coding) || coding.length === 0)
+            continue;
+        return {
+            ...slice,
+            name: `${slice.name}.${childProp}`,
+            elementId: `${slice.elementId || slice.name}.${childProp}`,
+            type: 'CodeableConcept',
+            baseTypeCode: 'CodeableConcept',
+            patternConstraint: value,
+            // The pinned coding is the discriminator; the child's own binding is a
+            // wider allowed set and must not stand in for it.
+            binding: undefined,
+            sliceName: undefined,
+            isArray: false,
+        };
+    }
+    return undefined;
+}
+/**
+ * Collect descendants of a slice that have finite max cardinality constraints.
  * Used by slice validators to emit within-slice max checks (e.g., max=0 forbidden fields).
+ *
+ * Nested paths (e.g. entity:patient.what.reference) are included only when every
+ * intermediate segment is a single-valued, non-choice element. Traversing an array or
+ * choice-typed intermediate would require per-item descent that `at()` does not do, so
+ * those are skipped rather than risk a false positive.
  */
 export function collectWithinSliceMaxChildren(slice, fields) {
     const sliceElemId = (slice.elementId || slice.name).replace(/^[^.]+\./, '');
     const sliceFullId = slice.sliceName && !sliceElemId.includes(':')
         ? `${sliceElemId}:${slice.sliceName}`
         : sliceElemId;
+    /** True when the element at `relPath` inside the slice is safe to descend through. */
+    const isTraversableIntermediate = (relPath) => {
+        if (relPath.endsWith('[x]'))
+            return false;
+        const target = `${sliceFullId}.${relPath}`;
+        const match = fields.find(f => (f.elementId || f.name).replace(/^[^.]+\./, '') === target);
+        if (!match)
+            return false;
+        if (match.isArray)
+            return false;
+        return typeof match.max !== 'number' || match.max <= 1;
+    };
     const result = [];
     for (const f of fields) {
         const fId = (f.elementId || f.name).replace(/^[^.]+\./, '');
         if (!fId.startsWith(sliceFullId + '.'))
             continue;
         const relChild = fId.substring(sliceFullId.length + 1);
-        if (relChild.includes('.'))
-            continue; // only direct children
         if (relChild.includes(':'))
             continue; // skip sub-slices (e.g., part:MemberPatient) — handled by dedicated slice validators
         if (typeof f.max !== 'number' || f.max >= Infinity)
             continue;
-        // Strip FHIR slice discriminator (e.g. "extension:time" → "extension") for JS property access
-        let jsProp = relChild.includes(':') ? relChild.split(':')[0] : relChild;
-        const isChoiceType = jsProp.endsWith('[x]');
-        if (isChoiceType)
-            jsProp = jsProp.replace(/\[x\]$/, '');
-        result.push({ childProp: jsProp, fhirPath: relChild, maxVal: f.max, isArray: !!f.isArray, isChoiceType });
+        const segments = relChild.split('.');
+        // Every segment above the leaf must be safely traversable.
+        const intermediatesOk = segments
+            .slice(0, -1)
+            .every((_, i) => isTraversableIntermediate(segments.slice(0, i + 1).join('.')));
+        if (!intermediatesOk)
+            continue;
+        const leaf = segments[segments.length - 1];
+        const isChoiceType = leaf.endsWith('[x]');
+        const propPath = [...segments.slice(0, -1), isChoiceType ? leaf.replace(/\[x\]$/, '') : leaf];
+        result.push({ propPath, fhirPath: relChild, maxVal: f.max, isArray: !!f.isArray, isChoiceType });
     }
     return result;
 }
@@ -158,13 +222,22 @@ export function collectWithinSliceMaxChildren(slice, fields) {
  */
 export function generateWithinSliceMaxChecks(children, elementsVarName, resType, relPath, sliceLabel) {
     let code = '';
-    for (const { childProp, fhirPath, maxVal, isArray, isChoiceType } of children) {
+    for (const { propPath, fhirPath, maxVal, isArray, isChoiceType } of children) {
+        const errorPath = `${resType}.${relPath}:${sliceLabel}.${fhirPath}`;
+        // Address the leaf via at()'s variadic path so nested elements
+        // (e.g. entity:patient.what.reference) resolve from the slice element.
+        const accessArgs = propPath.map(p => `'${p}'`).join(', ');
         if (maxVal === 0 && isChoiceType) {
             // max=0 on choice type (e.g., value[x]): check no key starting with prefix exists
+            const parentPath = propPath.slice(0, -1);
+            const parentExpr = parentPath.length
+                ? `at(_wsElem, ${parentPath.map(p => `'${p}'`).join(', ')})`
+                : '_wsElem';
+            const prefix = propPath[propPath.length - 1];
             code += `
     for (const _wsElem of ${elementsVarName}) {
-      if (Object.keys(node(_wsElem)).some(k => k.startsWith("${childProp}"))) {
-        errors.push("${resType}.${relPath}:${sliceLabel}.${fhirPath}: max allowed = 0, but found 1");
+      if (Object.keys(node(${parentExpr})).some(k => k.startsWith("${prefix}"))) {
+        errors.push("${errorPath}: max allowed = 0, but found 1");
       }
     }`;
         }
@@ -172,9 +245,9 @@ export function generateWithinSliceMaxChecks(children, elementsVarName, resType,
             // max=0: field must not exist at all — handles both scalar and array
             code += `
     for (const _wsElem of ${elementsVarName}) {
-      const _wsVal = at(_wsElem, '${childProp}');
+      const _wsVal = at(_wsElem, ${accessArgs});
       if (_wsVal !== undefined && _wsVal !== null) {
-        errors.push("${resType}.${relPath}:${sliceLabel}.${fhirPath}: max allowed = 0, but found " + (Array.isArray(_wsVal) ? _wsVal.length : 1));
+        errors.push("${errorPath}: max allowed = 0, but found " + (Array.isArray(_wsVal) ? _wsVal.length : 1));
       }
     }`;
         }
@@ -182,9 +255,9 @@ export function generateWithinSliceMaxChecks(children, elementsVarName, resType,
             // array field: check count doesn't exceed max
             code += `
     for (const _wsElem of ${elementsVarName}) {
-      const _wsArr = at(_wsElem, '${childProp}');
+      const _wsArr = at(_wsElem, ${accessArgs});
       if (Array.isArray(_wsArr) && _wsArr.length > ${maxVal}) {
-        errors.push("${resType}.${relPath}:${sliceLabel}.${fhirPath}: max allowed = ${maxVal}, but found " + _wsArr.length);
+        errors.push("${errorPath}: max allowed = ${maxVal}, but found " + _wsArr.length);
       }
     }`;
         }

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

@@ -0,0 +1,100 @@
+/**
+ * Addressing a sub-extension slice — an extension slice nested inside another.
+ *
+ * Split out of sliceExtensionValidation.ts to keep it under the 650 LOC gate, and
+ * because this is a self-contained concern: turning a slice's element id into the
+ * runtime walk that reaches the elements *containing* it.
+ */
+import { stripVersionFromCanonicalUrl } from '../../core/utils.js';
+/**
+ * The url an *instance* of this extension slice carries.
+ *
+ * `detectExtensionUrlSlice` answers a different question — which canonical names the
+ * slice — and prefers `type.profile`, which may be version-pinned (`…|4.0.0`). An
+ * instance never writes the version, so matching on that form finds nothing. The
+ * pinned `url` child is what the instance actually carries; fall back to the profile
+ * canonical with the version stripped.
+ */
+export function instanceUrlForSlice(slice, fields) {
+    const sliceElementId = (slice.elementId || slice.name).replace(/^[^.]+\./, '');
+    const sliceFullId = slice.sliceName && !sliceElementId.includes(':')
+        ? `${sliceElementId}:${slice.sliceName}`
+        : sliceElementId;
+    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;
+}
+/**
+ * Build the walk down to the elements that *contain* a sub-extension slice.
+ *
+ * Only for a slice nested inside another extension slice
+ * (`item.extension:contextExpression.extension:label`). The generic path builds one
+ * `at(_el, 'extension', 'extension')` hop, which returns undefined the moment it
+ * meets the `extension` array — so the check read nothing and its `length < min`
+ * assertion fired on every parent element instead. It also ignored the parent slice
+ * entirely, applying contextExpression's requirements to every extension on the item.
+ *
+ * Returns null when the slice is not of that shape, leaving the existing paths alone.
+ */
+export function buildSubExtensionScope(slice, fields) {
+    const elemId = (slice.elementId || '').replace(/^[^.]+\./, '');
+    if (!elemId)
+        return null;
+    const segments = elemId.split('.');
+    // The slice itself is the last segment; everything before it is the container walk.
+    const containerSegments = segments.slice(0, -1);
+    const slicedAncestors = containerSegments.filter(s => {
+        const [prop, sliceName] = s.split(':');
+        return sliceName && (prop === 'extension' || prop === 'modifierExtension');
+    });
+    if (slicedAncestors.length === 0)
+        return null;
+    const hops = [];
+    for (let i = 0; i < containerSegments.length; i++) {
+        const [prop, sliceName] = containerSegments[i].split(':');
+        let url;
+        if (sliceName) {
+            const ancestorId = containerSegments.slice(0, i + 1).join('.');
+            const ancestor = fields.find(f => (f.elementId || '').replace(/^[^.]+\./, '') === ancestorId);
+            // Without a resolvable url the hop cannot be scoped, and an unscoped walk is
+            // what this function exists to avoid — bail rather than guess.
+            if (!ancestor)
+                return null;
+            url = instanceUrlForSlice(ancestor, fields);
+            if (!url)
+                return null;
+        }
+        hops.push({ prop, url });
+    }
+    return hops;
+}
+/**
+ * Render a scope walk as nested for-loops, innermost body supplied by the caller.
+ *
+ * Unfiltered hops go through `elementsAt`, which drops absent and null intermediates
+ * and flattens arrays. Reading a single element into a one-item list instead would
+ * carry `undefined` into the body, where a `length < min` assertion fires on it.
+ */
+export function renderScopeHops(hops, body) {
+    let code = '';
+    let indent = '  ';
+    let current = 'resource';
+    hops.forEach((hop, i) => {
+        const next = `_scope${i}`;
+        const list = hop.url
+            ? `elements(at(${current}, '${hop.prop}')).filter((e) => e.url === "${hop.url}")`
+            : `elementsAt(${current}, ['${hop.prop}'])`;
+        code += `\n${indent}for (const ${next} of ${list}) {`;
+        indent += '  ';
+        current = next;
+    });
+    code += body(current, indent);
+    for (let i = hops.length - 1; i >= 0; i--) {
+        indent = indent.slice(2);
+        code += `\n${indent}}`;
+    }
+    return code;
+}