babelfhir-ts 1.5.19 → 1.5.21

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

@@ -2,6 +2,20 @@
  * Extension and ValueSet slice validation strategies.
  */
 import { safeAccessor, safeList, sliceElseBranch, detectNestedArray, findArrayAncestor, isArrayPath, FHIR_PRIMITIVE_STRING_TYPES } from './sliceValidatorUtils.js';
+import { stripVersionFromCanonicalUrl } from '../../core/utils.js';
+import { buildSubExtensionScope, renderScopeHops } from './subExtensionScope.js';
+/**
+ * Read pre-resolved Extension SD metadata for a canonical.
+ *
+ * The map is keyed by the version-stripped canonical because a slice names its
+ * extension in two spellings — `type.profile` with a `|x.y.z` suffix, the pinned
+ * `url` child without one — and either may reach this lookup. Reading with the
+ * raw url missed every versioned entry, and a miss is indistinguishable from an
+ * unreadable SD, so the emitter silently skipped the slice.
+ */
+export function lookupExtensionMetadata(metadata, extensionUrl) {
+    return metadata?.get(stripVersionFromCanonicalUrl(extensionUrl));
+}
 export function generateValueSetValidation(slice, baseName, relPath, errorPath, sliceLabel, varName, min, minText, getValueSetForBinding, valueSetImports, fields, out) {
     const vsInfo = getValueSetForBinding(slice.binding.uri);
     const vsInfoFull = vsInfo && !('systemOnly' in vsInfo && vsInfo.systemOnly) ? vsInfo : undefined;
@@ -216,17 +230,12 @@ export function generateExistsExtensionValidation(slice, relPath, errorPath, sli
         const remainingAccessor = remaining.includes('.') ? remaining.split('.').join('?.') : remaining;
         out.push(`
   // Required slice validation for ${relPath}:${sliceLabel} (exists extension discriminator, nested in array)
-  if (${safeAccessor(arrayParent)} && Array.isArray(${safeAccessor(arrayParent)})) {
-    for (const _el of ${safeAccessor(arrayParent)}) {
-      const _arr = elements(at(_el, ${remainingAccessor.split('?.').map(s => `'${s}'`).join(', ')}));
-      if (Array.isArray(_arr)) {
-        const ${varName}Matched = _arr.filter((item) =>
-          elements(at(item, 'extension')).some((ext) => ext.url === "${extensionUrl}")
-        );
-        if (${varName}Matched.length < ${min}) {
-          errors.push("No elements matched required slice: '${errorPath}:${sliceLabel}'");
-        }
-      }
+  for (const _el of arr(${safeAccessor(arrayParent)})) {
+    const ${varName}Matched = elements(at(_el, ${remainingAccessor.split('?.').map(s => `'${s}'`).join(', ')})).filter((item) =>
+      elements(at(item, 'extension')).some((ext) => ext.url === "${extensionUrl}")
+    );
+    if (${varName}Matched.length < ${min}) {
+      errors.push("No elements matched required slice: '${errorPath}:${sliceLabel}'");
     }
   }`);
         return;
@@ -278,12 +287,17 @@ export function detectExtensionUrlSlice(slice, relPath, fields) {
 }
 export function generateExtensionUrlSliceValidation(slice, relPath, errorPath, sliceLabel, varName, min, extensionUrl, fieldPathMap, arrayFieldPaths, out, ctx) {
     const baseFieldIsArray = isArrayPath(relPath, fieldPathMap, arrayFieldPaths);
-    const extMeta = ctx?.extensionMetadata?.get(extensionUrl);
+    const extMeta = lookupExtensionMetadata(ctx?.extensionMetadata, extensionUrl);
     // Narrow extension metadata value types with profile-level constraints.
     // The profile differential may restrict value[x] types more strictly than
     // the extension SD (e.g., extension allows [boolean, url] but profile allows only [url]).
+    //
+    // An empty type list is not a list to narrow: it means the extension is complex and
+    // forbids a value outright. The profile still carries the inherited value[x] element
+    // with its full base type list, so narrowing would read that as "any of ~50 types
+    // allowed" and cancel the prohibition.
     let effectiveMeta = extMeta;
-    if (extMeta && ctx?.fields && slice.elementId) {
+    if (extMeta && extMeta.valueTypes.length > 0 && ctx?.fields && slice.elementId) {
         const sliceElemId = slice.elementId.replace(/^[^.]+\./, '');
         const valueChild = ctx.fields.find(f => {
             if (!f.elementId || !f.typeOptions?.length)
@@ -296,22 +310,55 @@ export function generateExtensionUrlSliceValidation(slice, relPath, errorPath, s
             effectiveMeta = { ...extMeta, valueTypes: profileTypes };
         }
     }
+    // An optional slice asserts no count, but a present instance must still conform.
+    // Omitting the assertion rather than emitting `length < 0` keeps a branch that can
+    // never fire out of the generated output.
+    const countAssertion = min > 0
+        ? `
+    if (${varName}Matches.length < ${min}) {
+      errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
+    }`
+        : '';
+    const headline = min > 0 ? 'Required' : 'Optional';
+    // With no count to assert and no resolved metadata there is nothing to check, and
+    // the block would filter a list and discard it. That happens whenever the
+    // extension SD could not be read, so emit only when the slice earns it.
+    if (min === 0 && !generateExtensionValueChecks('_probe', extensionUrl, effectiveMeta, ctx, '')) {
+        return;
+    }
+    // A sub-extension of another extension slice needs the parent walked and filtered
+    // first; the generic paths below address it from the resource root and cannot.
+    const subScope = ctx?.fields
+        ? buildSubExtensionScope(slice, ctx.fields)
+        : null;
+    if (subScope) {
+        const scopedElemId = (slice.elementId || '').replace(/^[^.]+\./, '');
+        const scopedErrorPath = scopedElemId || `${errorPath}:${sliceLabel}`;
+        // The slot the slice lives in: its own last segment, minus the slice qualifier.
+        const leafProp = scopedElemId.split('.').pop().split(':')[0];
+        const body = renderScopeHops(subScope, (container, indent) => {
+            const matches = `${varName}Matches`;
+            let inner = `\n${indent}const ${matches} = elements(at(${container}, '${leafProp}')).filter((item) => item.url === "${extensionUrl}");`;
+            if (min > 0) {
+                inner += `\n${indent}if (${matches}.length < ${min}) {`;
+                inner += `\n${indent}  errors.push("Slice '${scopedErrorPath}': a matching slice is required, but not found");`;
+                inner += `\n${indent}}`;
+            }
+            inner += generateExtensionValueChecks(matches, extensionUrl, effectiveMeta, ctx, indent);
+            return inner;
+        });
+        out.push(`
+  // ${headline} extension slice validation for ${scopedErrorPath} (sub-extension, scoped to its parent slice)${body}`);
+        return;
+    }
     const nested = findArrayAncestor(relPath, fieldPathMap, arrayFieldPaths);
     if (nested) {
         const { arrayParent, remaining } = nested;
         const remainingAccessor = remaining.includes('.') ? remaining.split('.').join('?.') : remaining;
         out.push(`
-  // Required extension slice validation for ${relPath}:${sliceLabel} (url discriminator, nested in array)
-  if (${safeAccessor(arrayParent)} && Array.isArray(${safeAccessor(arrayParent)})) {
-    for (const _el of ${safeAccessor(arrayParent)}) {
-      const _extArr = elements(at(_el, ${remainingAccessor.split('?.').map(s => `'${s}'`).join(', ')}));
-      if (Array.isArray(_extArr)) {
-        const ${varName}Matches = _extArr.filter((item) => item.url === "${extensionUrl}");
-        if (${varName}Matches.length < ${min}) {
-          errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
-        }${generateExtensionValueChecks(varName + 'Matches', extensionUrl, effectiveMeta, ctx, '        ')}
-      }
-    }
+  // ${headline} extension slice validation for ${relPath}:${sliceLabel} (url discriminator, nested in array)
+  for (const _el of arr(${safeAccessor(arrayParent)})) {
+    const ${varName}Matches = elements(at(_el, ${remainingAccessor.split('?.').map(s => `'${s}'`).join(', ')})).filter((item) => item.url === "${extensionUrl}");${countAssertion}${generateExtensionValueChecks(varName + 'Matches', extensionUrl, effectiveMeta, ctx, '    ')}
   }`);
         return;
     }
@@ -319,41 +366,159 @@ export function generateExtensionUrlSliceValidation(slice, relPath, errorPath, s
         const pathParts = relPath.split('.');
         const parentPath = pathParts.length > 1 ? pathParts.slice(0, -1).join('.') : null;
         const parentGuard = parentPath ? `${safeAccessor(parentPath)} && ` : '';
-        const elseGuard = parentPath ? `else if (${safeAccessor(parentPath)})` : 'else';
+        // The absent branch asserts the slice is missing. For min=0 that is simply false,
+        // and on an empty resource the element is never an array, so it fired every time:
+        // this is what cost empty parity 613/613 -> 599/613 across mcode, ndh, pas and
+        // physical-activity. Two earlier attempts patched only the nested path above and
+        // never reached this one.
+        const absentBranch = min > 0
+            ? ` ${parentPath ? `else if (${safeAccessor(parentPath)})` : 'else'} {
+    errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
+  }`
+            : '';
+        const arrayCountAssertion = min > 0
+            ? `
+    if (${varName}Elements.length < ${min}) {
+      errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
+    }`
+            : '';
         out.push(`
-  // Required extension slice validation for ${relPath}:${sliceLabel} (url discriminator)
+  // ${headline} extension slice validation for ${relPath}:${sliceLabel} (url discriminator)
   if (${parentGuard}Array.isArray(${safeAccessor(relPath)})) {
     const ${varName}Elements = ${safeList(relPath)}.filter((item) =>
       item.url === "${extensionUrl}"
-    );
-    if (${varName}Elements.length < ${min}) {
-      errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
-    }${generateExtensionValueChecks(varName + 'Elements', extensionUrl, effectiveMeta, ctx, '    ')}
-  } ${elseGuard} {
-    errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
-  }`);
+    );${arrayCountAssertion}${generateExtensionValueChecks(varName + 'Elements', extensionUrl, effectiveMeta, ctx, '    ')}
+  }${absentBranch}`);
     }
-    else {
+    else if (min > 0) {
         out.push(`
   // Required extension slice validation for ${relPath}:${sliceLabel} (url discriminator)
   if (!${safeAccessor(relPath)} || (${safeAccessor(relPath)} as { url?: string }).url !== "${extensionUrl}") {
     errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
   }`);
     }
+    // A non-array optional slice has nothing to assert: its only check was that the
+    // slice is present, which min=0 does not require.
 }
 // ── Extension value type + binding validation helper ─────────────────────
 /** Map FHIR type code → JSON property name suffix (e.g., 'code' → 'Code'). */
 function valuePropertySuffix(typeCode) {
     return typeCode.charAt(0).toUpperCase() + typeCode.slice(1);
 }
+/** A ValueSet resolved to an emitted validator function, or nothing to check against. */
+function resolveBindingValueSet(binding, ctx) {
+    if (!binding || !ctx)
+        return undefined;
+    if (binding.strength !== 'required' && binding.strength !== 'extensible')
+        return undefined;
+    const vsInfo = ctx.getValueSetForBinding(binding.uri);
+    // A system-only ValueSet cannot decide membership of a code, only of its system.
+    if (!vsInfo || ('systemOnly' in vsInfo && vsInfo.systemOnly))
+        return undefined;
+    const full = vsInfo;
+    ctx.valueSetImports.set(full.sanitizedName, `./valuesets/ValueSet-${full.sanitizedName}.js`);
+    return full;
+}
+/**
+ * Check a sub-extension's value against its bound ValueSet.
+ *
+ * `elemVar` is `unknown`, so the value is reached through `at()` and only the shape
+ * actually read is asserted. Codings are the case KBV needs — the Payor extension
+ * binds `Extension.extension:Kostentraegertyp.value[x]:valueCoding` required — and
+ * primitives and CodeableConcepts are handled alongside so one helper covers the
+ * shapes an extension value can take.
+ */
+function subExtensionBindingCheck(sub, vs, elemVar, indent) {
+    const lines = [];
+    const notFound = (valueExpr) => `errors.push("The value provided ('" + ${valueExpr} + "') was not found in the value set '${vs.displayName}' (${sub.binding.uri})");`;
+    if (sub.valueTypes.includes('Coding')) {
+        lines.push(`${indent}const _seCode = at(${elemVar}, 'valueCoding', 'code');`);
+        lines.push(`${indent}if (typeof _seCode === 'string' && !${vs.validatorFn}(_seCode)) {`);
+        lines.push(`${indent}  ${notFound('_seCode')}`);
+        lines.push(`${indent}}`);
+    }
+    else if (sub.valueTypes.includes('CodeableConcept')) {
+        lines.push(`${indent}const _seCodings = codings(at(${elemVar}, 'valueCodeableConcept'));`);
+        lines.push(`${indent}if (_seCodings.length > 0 && !_seCodings.some((c) => !!c.code && ${vs.validatorFn}(c.code))) {`);
+        lines.push(`${indent}  errors.push("None of the codings in the extension value are from the value set '${vs.displayName}' (${sub.binding.uri})");`);
+        lines.push(`${indent}}`);
+    }
+    else {
+        // Primitive: whichever value* property is present carries the code.
+        lines.push(`${indent}const _seEntry = Object.entries(node(${elemVar})).find(([k]) => k.startsWith("value"));`);
+        lines.push(`${indent}if (_seEntry && typeof _seEntry[1] === 'string' && !${vs.validatorFn}(_seEntry[1])) {`);
+        lines.push(`${indent}  ${notFound('_seEntry[1]')}`);
+        lines.push(`${indent}}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Checks on the sub-extensions of a matched complex extension.
+ *
+ * `_ext` is the matched member; its own `extension` array holds the sub-extensions.
+ * Emits the cardinality on `Extension.extension`, the presence of each required
+ * slice, and the bound ValueSet of each slice that declares one — all in HL7's
+ * wording so parity attributes them to the same fields.
+ */
+function generateSubExtensionChecks(extMeta, ctx, indent) {
+    const subs = extMeta.subExtensions ?? [];
+    const min = extMeta.subExtensionMin ?? 0;
+    const lines = [];
+    if (min > 0) {
+        lines.push(`${indent}const _seAll = elements(at(_ext, 'extension'));`);
+        lines.push(`${indent}if (_seAll.length < ${min}) {`);
+        lines.push(`${indent}  errors.push("Extension.extension: minimum required = ${min}, but only found " + _seAll.length);`);
+        lines.push(`${indent}}`);
+    }
+    for (const sub of subs) {
+        const needsPresence = sub.min > 0;
+        const vs = resolveBindingValueSet(sub.binding, ctx);
+        if (!needsPresence && !vs)
+            continue;
+        const varName = `_se_${sub.sliceName.replace(/[^a-zA-Z0-9_]/g, '_')}`;
+        lines.push(`${indent}const ${varName} = elements(at(_ext, 'extension')).filter((e) => e.url === "${sub.url}");`);
+        if (needsPresence) {
+            lines.push(`${indent}if (${varName}.length < ${sub.min}) {`);
+            lines.push(`${indent}  errors.push("Slice 'Extension.extension:${sub.sliceName}': a matching slice is required, but not found");`);
+            lines.push(`${indent}}`);
+        }
+        if (vs) {
+            lines.push(`${indent}for (const _seElem of ${varName}) {`);
+            lines.push(subExtensionBindingCheck(sub, vs, '_seElem', indent + '  '));
+            lines.push(`${indent}}`);
+        }
+    }
+    return lines.length ? '\n' + lines.join('\n') : '';
+}
 /**
  * Generate inline JS code that validates extension value type and binding
  * for each matched extension in the given array variable.
  * Returns an empty string when no metadata is available.
  */
 function generateExtensionValueChecks(matchedArrayVar, extensionUrl, extMeta, ctx, indent) {
-    if (!extMeta || extMeta.valueTypes.length === 0)
+    // No entry means the extension SD could not be read, so nothing can be concluded.
+    if (!extMeta)
         return '';
+    // An entry with no permitted types means the opposite of unknown: the extension
+    // is complex, pins value[x] to max=0, and carries sub-extensions instead. A value
+    // of any type is forbidden, and since no single property can be named — every
+    // `value*` variant is disallowed — the check is on the presence of any of them.
+    if (extMeta.valueTypes.length === 0) {
+        const forbidUrl = ctx?.profileUrl || extensionUrl;
+        // HL7 reports one defect under two headings — the cardinality breach and the
+        // empty allowed-type list — and parity classifies them into different fields
+        // ('value' and 'constraint'), so emitting only the first left `constraint`
+        // showing as HL7-only on a finding we had already detected.
+        return `
+${indent}// Complex extension: value[x] is max=0, so no value* property is allowed
+${indent}for (const _ext of ${matchedArrayVar}) {
+${indent}  const _forbidden = Object.keys(node(_ext)).find((k) => k.startsWith("value"));
+${indent}  if (_forbidden) {
+${indent}    errors.push("Extension.value[x]: max allowed = 0, but found 1 (${forbidUrl})");
+${indent}    errors.push("The Extension '${extensionUrl}' definition allows for the types [] but found type " + _forbidden.slice(5));
+${indent}  }${generateSubExtensionChecks(extMeta, ctx, indent + '  ')}
+${indent}}`;
+    }
     const lines = [];
     const allowedProps = extMeta.valueTypes.map(t => `"value${valuePropertySuffix(t)}"`);
     const allowedSet = `[${allowedProps.join(', ')}]`;