babelfhir-ts 1.5.19 → 1.5.21

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

@@ -174,7 +174,19 @@ export function buildForbiddenFieldConstraintEntries(fields) {
                 human: `${concretePath}: max allowed = 0, but found 1`,
                 severity: 'error',
             },
-            fieldPath: concreteParts[concreteParts.length - 1],
+            // The full path, not the last segment. The expression above is written
+            // relative to the resource root, and the emitter wraps an expression in
+            // `${fieldPath}.all(...)` unless the expression already navigates from
+            // fieldPath. With a bare last segment it never did, so a max=0 on
+            // Medication.amount.numerator.value became
+            //
+            //     value.all(amount.numerator.value.exists().not())
+            //
+            // and Medication has no `value` element: the collection is empty, FHIRPath
+            // all() on empty is true, and the constraint could never fire. Two of the
+            // three kbv-erp random-parity failures were this, with HL7 reporting the
+            // violation we had already written down and then scoped into oblivion.
+            fieldPath: concretePath,
             isChoiceType: false,
         });
     });
@@ -262,95 +274,123 @@ function emitNestedCodingPattern(output, fields, pathParts, parentFieldName, pat
         (f.name || '').replace(/^[^.]+\./, '').split(':')[0] === parentBasePath);
     if (parentIsSliced)
         return;
-    const system = 'system' in pattern && pattern.system ? String(pattern.system) : null;
-    const code = String(pattern.code);
-    if (system) {
-        output.push(`
-  // Pattern constraint for ${humanRel}: every ${parentPath} element must include a coding matching pattern
+    // Same split as the CodeableConcept case: identity here, pinned details below.
+    const match = codingIdentityPredicate(pattern);
+    const described = codingPatternDescription(pattern, true);
+    output.push(`
+  // Pattern constraint for ${humanRel}: every ${parentPath} element must include a coding matching ${described}
   if (resource.${parentPath} && Array.isArray(resource.${parentPath})) {
     for (const _item of resource.${parentPath}) {
-      const _hasMatch = _item?.coding?.some((coding) => (coding?.system as string) === "${system}" && (coding?.code as string) === "${code}");
+      const _hasMatch = codings(_item).some((coding) => ${match});
       if (!_hasMatch) {
-        errors.push("Pattern constraint violation: ${humanRel} requires system='${system}' and code='${code}'");
+        errors.push("Pattern constraint violation: ${humanRel} requires ${described}");
       }
     }
   }`);
-    }
-    else {
+    emitPinnedDetailChecks(output, `resource.${parentPath}`, pattern, parentPath.replace(/[^a-zA-Z0-9_]/g, '_'));
+}
+/**
+ * Coding sub-elements a pattern can pin, in the order they read best in a message.
+ *
+ * `display` is deliberately absent: HL7 does not fail a pattern on a differing
+ * display, and enforcing it would make us the stricter outlier.
+ */
+const PATTERN_CODING_PARTS = ['system', 'version', 'code'];
+/** The sub-elements this pattern actually pins, in message order. */
+function pinnedParts(coding) {
+    return PATTERN_CODING_PARTS.filter(part => coding[part] !== undefined && coding[part] !== null && coding[part] !== '');
+}
+/**
+ * Predicate matching only the parts that *identify* which coding the pattern is
+ * talking about, so a coding that is clearly the intended one but missing a pinned
+ * detail can be reported against that detail.
+ */
+function codingIdentityPredicate(coding, receiver = 'coding') {
+    const identity = pinnedParts(coding).filter(part => part === 'system' || part === 'code');
+    const comparisons = identity.map(part => `(${receiver}?.${part} as string) === "${String(coding[part])}"`);
+    return comparisons.length > 0 ? comparisons.join(' && ') : 'true';
+}
+/**
+ * Per-sub-element checks in HL7's own wording, for parts the pattern pins beyond
+ * system and code (in practice `version`).
+ *
+ * Reporting these separately is what makes the finding comparable: HL7 locates the
+ * intended coding and blames the specific absent sub-element —
+ * `Missing element 'version' - required by fixed value assigned in profile`, at
+ * location `ExplanationOfBenefit.type.coding.version`. A single message naming the
+ * parent element instead classifies as a `type` finding against HL7's `version`
+ * one, so the two never line up even though both validators agree the resource is
+ * wrong — which is precisely what left carin-bb at 7/15 after the comparison
+ * itself was fixed.
+ */
+function emitPinnedDetailChecks(output, accessor, coding, varName) {
+    const details = pinnedParts(coding).filter(part => part !== 'system' && part !== 'code');
+    if (details.length === 0)
+        return;
+    const identity = codingIdentityPredicate(coding, 'c');
+    details.forEach((part, i) => {
+        const found = `_${varName}_${part}${i}`;
         output.push(`
-  // Pattern constraint for ${humanRel}: every ${parentPath} element must include a coding matching pattern
-  if (resource.${parentPath} && Array.isArray(resource.${parentPath})) {
-    for (const _item of resource.${parentPath}) {
-      const _hasMatch = _item?.coding?.some((coding) => (coding?.code as string) === "${code}");
-      if (!_hasMatch) {
-        errors.push("Pattern constraint violation: ${humanRel} requires code='${code}'");
-      }
+  // Pattern on ${accessor} pins ${part}; reported the way HL7 does when it is absent
+  {
+    const ${found} = codings(${accessor}).find((c) => ${identity});
+    if (${found} && (${found}.${part} as string) !== "${String(coding[part])}") {
+      errors.push("Missing element '${part}' - required by fixed value assigned in profile");
     }
   }`);
-    }
+    });
+}
+/**
+ * Human-readable form of the pattern, for the error message.
+ *
+ * `identityOnly` keeps it to the parts the headline check compares, so the message
+ * does not promise a comparison the emitted code no longer makes there.
+ */
+function codingPatternDescription(coding, identityOnly = false) {
+    return pinnedParts(coding)
+        .filter(part => !identityOnly || part === 'system' || part === 'code')
+        .map(part => `${part}='${String(coding[part])}'`)
+        .join(' and ');
 }
 function emitCodeableConceptPattern(output, field, rel, humanRel, pattern, fieldPathMap, _arrayFieldPaths) {
     const requiredCodings = pattern.coding.filter((c) => c !== null && typeof c === 'object' && 'code' in c);
     if (requiredCodings.length === 0)
         return;
     requiredCodings.forEach((requiredCoding, idx) => {
-        const system = requiredCoding.system ? String(requiredCoding.system) : null;
-        const code = String(requiredCoding.code);
+        // The headline check asks only whether the *intended* coding is present, so it
+        // stays a `type` finding. Sub-elements the pattern additionally pins are
+        // reported separately by emitPinnedDetailChecks, which is how HL7 splits it —
+        // otherwise both fire and we report a `type` finding HL7 never raises.
+        const match = codingIdentityPredicate(requiredCoding);
+        const described = codingPatternDescription(requiredCoding, true);
         const varName = rel.replace(/[^a-zA-Z0-9_]/g, '_') + `_pattern${idx}`;
         const pathInfo = fieldPathMap.get(rel);
         const isResourceFieldArray = field.isArray || (field.sliceName && pathInfo?.isNestedInArray !== true) || rel.includes('.');
         if (isResourceFieldArray) {
-            if (system) {
-                output.push(`
-  // Pattern constraint for ${humanRel}: at least one element must include coding with system="${system}" and code="${code}"
-  if (resource.${rel} && Array.isArray(resource.${rel}) && resource.${rel}.length > 0) {
-    const ${varName}Valid = resource.${rel}.some((item) =>
-      item?.coding?.some((coding) => (coding?.system as string) === "${system}" && (coding?.code as string) === "${code}")
-    );
-    if (!${varName}Valid) {
-      errors.push("${humanRel} must include at least one element with a coding with system '${system}' and code '${code}'");
-    }
-  }`);
-            }
-            else {
-                output.push(`
-  // Pattern constraint for ${humanRel}: at least one element must include coding with code="${code}"
+            output.push(`
+  // Pattern constraint for ${humanRel}: at least one element must include a coding matching ${described}
   if (resource.${rel} && Array.isArray(resource.${rel}) && resource.${rel}.length > 0) {
-    const ${varName}Valid = resource.${rel}.some((item) =>
-      item?.coding?.some((coding) => (coding?.code as string) === "${code}")
+    const ${varName}Valid = elements(resource.${rel}).some((item) =>
+      codings(item).some((coding) => ${match})
     );
     if (!${varName}Valid) {
-      errors.push("${humanRel} must include at least one element with a coding with code '${code}'");
+      errors.push("${humanRel} must include at least one element with a coding with ${described}");
     }
   }`);
-            }
         }
         else {
-            if (system) {
-                output.push(`
-  // Pattern constraint for ${humanRel}: must include coding with system="${system}" and code="${code}"
-  if (resource.${rel}) {
-    const ${varName}Valid = resource.${rel}.coding?.some((coding) =>
-      (coding?.system as string) === "${system}" && (coding?.code as string) === "${code}"
-    );
-    if (!${varName}Valid) {
-      errors.push("${humanRel} must include a coding with system '${system}' and code '${code}'");
-    }
-  }`);
-            }
-            else {
-                output.push(`
-  // Pattern constraint for ${humanRel}: must include coding with code="${code}"
+            output.push(`
+  // Pattern constraint for ${humanRel}: must include a coding matching ${described}
   if (resource.${rel}) {
-    const ${varName}Valid = resource.${rel}.coding?.some((coding) =>
-      (coding?.code as string) === "${code}"
-    );
+    const ${varName}Valid = codings(resource.${rel}).some((coding) => ${match});
     if (!${varName}Valid) {
-      errors.push("${humanRel} must include a coding with code '${code}'");
+      errors.push("${humanRel} must include a coding with ${described}");
     }
   }`);
-            }
         }
+        // Blame the specific pinned sub-element when the intended coding is present
+        // but incomplete, matching how HL7 reports it.
+        emitPinnedDetailChecks(output, `resource.${rel}`, requiredCoding, varName);
     });
 }
 /**
@@ -396,8 +436,9 @@ export function buildChoiceTypeNarrowingValidations(fields, profileUrl) {
   // Choice-type narrowing: ${relPath} allows only: ${allowedTypesStr}
   {
     const _ckAllowed = [${allowedKeys.join(', ')}];
-    for (const _ckKey of Object.keys(_bRes)) {
-      if (_ckKey.startsWith('${basePropName}') && _ckKey.length > ${baseLen} && _ckKey.charCodeAt(${baseLen}) >= 65 && _ckKey.charCodeAt(${baseLen}) <= 90 && !_ckAllowed.includes(_ckKey) && _bRes[_ckKey] !== undefined) {
+    const _ckNode = node(resource);
+    for (const _ckKey of Object.keys(_ckNode)) {
+      if (_ckKey.startsWith('${basePropName}') && _ckKey.length > ${baseLen} && _ckKey.charCodeAt(${baseLen}) >= 65 && _ckKey.charCodeAt(${baseLen}) <= 90 && !_ckAllowed.includes(_ckKey) && _ckNode[_ckKey] !== undefined) {
         errors.push("The Profile '${escapedUrl}' definition allows for the type ${allowedTypesStr} but found type " + _ckKey.substring(${baseLen}));
       }
     }
@@ -413,7 +454,7 @@ function emitCodingPattern(output, field, rel, humanRel, pattern) {
             output.push(`
   // Pattern constraint for ${humanRel}: at least one element must have system="${system}" and code="${code}"
   if (resource.${rel} && Array.isArray(resource.${rel}) && resource.${rel}.length > 0) {
-    const ${rel.replace(/[^a-zA-Z0-9_]/g, '_')}_patternValid = resource.${rel}.some((item) =>
+    const ${rel.replace(/[^a-zA-Z0-9_]/g, '_')}_patternValid = elements(resource.${rel}).some((item) =>
       (item?.system as string) === "${system}" && (item?.code as string) === "${code}"
     );
     if (!${rel.replace(/[^a-zA-Z0-9_]/g, '_')}_patternValid) {
@@ -425,7 +466,7 @@ function emitCodingPattern(output, field, rel, humanRel, pattern) {
             output.push(`
   // Pattern constraint for ${humanRel}: at least one element must have code="${code}"
   if (resource.${rel} && Array.isArray(resource.${rel}) && resource.${rel}.length > 0) {
-    const ${rel.replace(/[^a-zA-Z0-9_]/g, '_')}_patternValid = resource.${rel}.some((item) =>
+    const ${rel.replace(/[^a-zA-Z0-9_]/g, '_')}_patternValid = elements(resource.${rel}).some((item) =>
       (item?.code as string) === "${code}"
     );
     if (!${rel.replace(/[^a-zA-Z0-9_]/g, '_')}_patternValid) {

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

@@ -0,0 +1,54 @@
+/**
+ * FHIRPath expression normalisation shared by the constraint emitters.
+ *
+ * Each function here exists because fhirpath.js holds the spec more strictly than
+ * HL7's Java engine does, or because a FHIR-supplied expression is not valid
+ * FHIRPath as written.
+ */
+const FHIRPATH_KEYWORDS = new Set([
+    'and', 'as', 'contains', 'day', 'days', 'div', 'false', 'hour', 'hours',
+    'implies', 'in', 'is', 'millisecond', 'milliseconds', 'minute', 'minutes',
+    'mod', 'month', 'months', 'not', 'or', 'second', 'seconds', 'true', 'week',
+    'weeks', 'xor', 'year', 'years',
+]);
+/**
+ * Delimit any keyword segment of a FHIRPath navigation path.
+ *
+ * Scoping a constraint to its field path used to emit the raw path, so a
+ * constraint on Narrative.div produced `text.div.all(htmlChecks())`, which
+ * fhirpath.js rejects outright ("mismatched input 'div'") and which threw out of
+ * validate() at runtime for every profile carrying txt-1.
+ */
+export function quoteFhirPathPath(path) {
+    return path
+        .split('.')
+        .map(segment => (FHIRPATH_KEYWORDS.has(segment) ? `\`${segment}\`` : segment))
+        .join('.');
+}
+/**
+ * Rewrite `as()` applied to a collection into the equivalent `ofType()`.
+ *
+ * FHIRPath defines `as` on a singleton and `ofType` as the collection filter, so
+ * `descendants().as(canonical)` is a spec violation. HL7's Java engine tolerates
+ * it, fhirpath.js rejects it outright ("Expected singleton on left side of 'as'")
+ * and the throw escaped validate(), losing every finding for the resource — dom-3
+ * is written this way. The two forms select the same items, so normalising keeps
+ * the invariant evaluated instead of dropped. `as()` applied per item inside
+ * `where()` is already a singleton and is left alone.
+ */
+export function normalizeCollectionTypeFilters(expression) {
+    return expression.replace(/\b(descendants\(\)|children\(\)|repeat\([^()]*\))\s*\.\s*as\s*\(/g, '$1.ofType(');
+}
+/**
+ * The two base FHIR element invariants whose evaluation diverges between
+ * fhirpath.js and HL7 once they are applied below the top level:
+ *   ele-1: hasValue() or (children().count() > id.count())
+ *   ext-1: extension.exists() != value.exists()
+ *
+ * They are dropped for nested field paths, and kept at a single level for
+ * recursive elements, rather than being walked through the whole recursion.
+ */
+export function isBaseElementInvariant(expression) {
+    return /^hasValue\(\)\s+or\s+\(children\(\)\.count\(\)\s*>\s*id\.count\(\)\)$/.test(expression)
+        || /^extension\.exists\(\)\s*!=\s*value\.exists\(\)$/.test(expression);
+}