babelfhir-ts 1.5.21 → 1.6.1

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

@@ -1,4 +1,4 @@
-import { choicePropertyName, narrowedChoiceType } from '../../core/utils.js';
+import { choicePropertyName, narrowedChoiceType, stripSliceSuffix } from '../../core/utils.js';
 /**
  * The element slots FHIR types as `Resource`, i.e. the ones that hold an inline
  * resource rather than a reference to one: DomainResource.contained,
@@ -22,7 +22,7 @@ const ABSTRACT_RESOURCE_TYPES = new Set(['Resource', 'DomainResource']);
  * HL7 uses, so this cannot flag a conformant resource.
  */
 function buildNestedObjectTypeValidations(fields, arrayFieldPaths, result) {
-    const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(p.split(':')[0]);
+    const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(stripSliceSuffix(p));
     const seen = new Set();
     for (const field of fields) {
         if (field.sliceName || field.isArray)
@@ -63,6 +63,7 @@ function buildNestedObjectTypeValidations(fields, arrayFieldPaths, result) {
         const body = `${indent}const _soValue = at(${expr}, '${leaf}');
 ${indent}if (_soValue !== undefined && _soValue !== null && typeof _soValue !== 'object') {
 ${indent}  errors.push("The property ${leaf} must be an Object, not a Primitive property (at ${rel})");
+${indent}  _structuralFailures.add('${rel}');
 ${indent}}`;
         result.push(`
   // Structural type check: ${rel} must be an Object
@@ -160,8 +161,9 @@ export function buildInlineResourceTypeValidations(fields, profileUrl) {
  * is one identifier among several, so requiring its children of every identifier
  * would report a conformant resource.
  */
+/** Undefined for an empty path, which callers treat as "nothing to check". */
 function leafFieldName(parts) {
-    return parts[parts.length - 1];
+    return parts.at(-1);
 }
 function resolveChoiceSliceSegments(elementIdRel) {
     const segments = elementIdRel.split('.');
@@ -172,7 +174,7 @@ function resolveChoiceSliceSegments(elementIdRel) {
             continue;
         }
         const [base, sliceName] = segment.split(':');
-        if (!base.endsWith('[x]') || !sliceName)
+        if (!base || !base.endsWith('[x]') || !sliceName)
             return undefined;
         const baseProp = base.slice(0, -'[x]'.length);
         if (!sliceName.startsWith(baseProp) || sliceName === baseProp)
@@ -236,17 +238,20 @@ export function buildNestedRequiredValidations(fields, arrayFieldPaths) {
             // Only an unambiguous choice yields one property name. A multi-typed choice
             // may legitimately carry any variant, and picking one would flag a conformant
             // resource — which is what the previous depth guard was protecting against.
-            if (uniqueTypes.length !== 1)
+            const [onlyType] = uniqueTypes;
+            if (uniqueTypes.length !== 1 || !onlyType)
                 return;
-            const choiceSuffix = uniqueTypes[0].charAt(0).toUpperCase() + uniqueTypes[0].slice(1);
+            const choiceSuffix = onlyType.charAt(0).toUpperCase() + onlyType.slice(1);
             rel = relFull.replace(/^[^.]+\./, '').replace(/\[x\]/, choiceSuffix);
         }
         const resolvedParts = rel.split('.');
-        const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(p.split(':')[0]);
+        const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(stripSliceSuffix(p));
         // Check which intermediate parts are arrays
         const intermediateParts = resolvedParts.slice(1, -1);
         const hasIntermediateArray = intermediateParts.some((_part, idx) => isArrayPath(resolvedParts.slice(0, idx + 2).join('.')));
         const arrayParent = resolvedParts[0];
+        if (!arrayParent)
+            return;
         const topIsArray = isArrayPath(arrayParent);
         // An array is needed somewhere above the leaf, but it need not be the first
         // segment: the flat branches below index straight into resource.<arrayParent>,
@@ -275,17 +280,22 @@ export function buildNestedRequiredValidations(fields, arrayFieldPaths) {
   }`);
             return;
         }
-        const leafField = resolvedParts[resolvedParts.length - 1];
+        const leafField = resolvedParts.at(-1);
+        if (!leafField)
+            return;
         // Check if the leaf field itself is an array — if so, don't flag Array values as absent
         const fullLeafPath = resolvedParts.join('.');
-        const leafIsArray = arrayFieldPaths.has(fullLeafPath) || arrayFieldPaths.has(fullLeafPath.split(':')[0]);
+        const leafIsArray = arrayFieldPaths.has(fullLeafPath) || arrayFieldPaths.has(stripSliceSuffix(fullLeafPath));
         if (hasIntermediateArray) {
             // Build nested for-loops for paths with intermediate arrays
             const levels = [];
             for (let i = 0; i < resolvedParts.length - 1; i++) {
+                const name = resolvedParts[i];
+                if (!name)
+                    continue;
                 const pathToHere = resolvedParts.slice(0, i + 1).join('.');
-                const isArr = arrayFieldPaths.has(pathToHere) || arrayFieldPaths.has(pathToHere.split(':')[0]);
-                levels.push({ name: resolvedParts[i], isArray: isArr });
+                const isArr = arrayFieldPaths.has(pathToHere) || arrayFieldPaths.has(stripSliceSuffix(pathToHere));
+                levels.push({ name, isArray: isArr });
             }
             const lines = [];
             let indent = '  ';
@@ -295,6 +305,8 @@ export function buildNestedRequiredValidations(fields, arrayFieldPaths) {
             let isTyped = true;
             for (let i = 0; i < levels.length; i++) {
                 const level = levels[i];
+                if (!level)
+                    continue;
                 const child = isTyped ? `${currentVar}.${level.name}` : `at(${currentVar}, '${level.name}')`;
                 if (level.isArray) {
                     const loopVar = `_nrEl${i}`;
@@ -393,7 +405,7 @@ function emitNestedFixedValue(result, rel, field, arrayFieldPaths, profileUrl, b
         .some(candidate => candidate.split('.').some(segment => segment.includes(':')));
     if (hasSliceQualifier)
         return;
-    const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(p.split(':')[0]);
+    const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(stripSliceSuffix(p));
     const segments = rel.split('.');
     const parents = segments.slice(0, -1);
     const leaf = segments[segments.length - 1];
@@ -547,9 +559,9 @@ export function buildProhibitedFieldValidations(fields, arrayFieldPaths, fieldPa
         const resolvedParts = eidRel.split('.').map(p => {
             if (p.includes(':')) {
                 const [basePart, sliceName] = p.split(':', 2);
-                if (basePart.includes('[x]') && sliceName)
+                if (basePart?.includes('[x]') && sliceName)
                     return sliceName;
-                return basePart;
+                return basePart ?? p;
             }
             return p.replace(/\[x\]$/, '');
         });
@@ -573,9 +585,13 @@ export function buildProhibitedFieldValidations(fields, arrayFieldPaths, fieldPa
         }
         else if (pathParts.length >= 2) {
             const arrayParent = pathParts[0];
-            if (!arrayFieldPaths.has(arrayParent) && !arrayFieldPaths.has(arrayParent.split(':')[0]))
+            if (!arrayParent)
+                return;
+            if (!arrayFieldPaths.has(arrayParent) && !arrayFieldPaths.has(stripSliceSuffix(arrayParent)))
+                return;
+            const leafField = pathParts.at(-1);
+            if (!leafField)
                 return;
-            const leafField = pathParts[pathParts.length - 1];
             const fullPath = `${resourceType}.${rel}`;
             // `at()` walks the dotted path and yields `unknown`, so the prohibited
             // field is probed without widening the element to `any`.
@@ -703,7 +719,7 @@ const CONTAINER_TYPES = new Set([
  * `constraint` looking like an HL7-only finding.
  */
 function buildArrayNestedPrimitiveKindValidations(fields, arrayFieldPaths, result) {
-    const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(p.split(':')[0]);
+    const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(stripSliceSuffix(p));
     const seen = new Set();
     for (const field of fields) {
         if (field.sliceName || field.isArray)
@@ -846,6 +862,7 @@ export function buildStructuralTypeValidations(fields, arrayFieldPaths) {
     if (_stValue !== undefined && _stValue !== null && typeof _stValue !== 'object') {
       const _stType = at(resource, 'resourceType');
       errors.push("The property ${rel} must be an Object, not a Primitive property (at " + (typeof _stType === 'string' ? _stType : "Resource") + ".${rel})");
+      _structuralFailures.add('${rel}');
     }
   }`);
             }

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

@@ -1,3 +1,4 @@
+import { stripSliceSuffix, stripVersionFromCanonicalUrl } from '../../core/utils.js';
 import { logger } from '../../../logger.js';
 import { sanitizeValueSetName } from '../valueset/valueSetGenerator.js';
 import { generateSliceValidations } from './sliceValidatorGenerator.js';
@@ -8,7 +9,7 @@ import { buildNestedRequiredValidations, buildFixedValueValidations, buildProhib
 import { buildBindingValidations } from './validatorBindingBuilder.js';
 import { generateBundleRefValidation, generateContainedRefValidation, generateExtensionStructuralValidation, generateAggregationRefValidation, buildReferenceTargetTypeValidation, buildBundleEntryResolution } from './validatorTemplates.js';
 import { HELPER_NAMES } from './validatorRuntime.js';
-import { quoteFhirPathPath, normalizeCollectionTypeFilters, isBaseElementInvariant } from './validatorExpressions.js';
+import { isBaseElementInvariant, scopeConstraintExpression } from './validatorExpressions.js';
 const log = logger.withTag('validator');
 /**
  * A constraint declared on a slice applies only to that slice's members.
@@ -52,6 +53,8 @@ function sliceScopedBindingPath(rel, field, fields) {
     if (!sliceMatch)
         return rel;
     const sliceId = sliceMatch[1];
+    if (!sliceId)
+        return rel;
     const pinned = fields.find(f => {
         if (!f.elementId || !f.elementId.startsWith(sliceId + '.'))
             return false;
@@ -63,7 +66,9 @@ function sliceScopedBindingPath(rel, field, fields) {
     const discriminatorProp = pinned.elementId.substring(sliceId.length + 1);
     if (!discriminatorProp || discriminatorProp.includes('.'))
         return rel;
-    const coding = pinned.patternConstraint.coding[0];
+    const [coding] = pinned.patternConstraint.coding;
+    if (!coding)
+        return rel;
     const system = typeof coding.system === 'string' ? coding.system : undefined;
     const code = typeof coding.code === 'string' ? coding.code : undefined;
     if (!code)
@@ -71,9 +76,9 @@ function sliceScopedBindingPath(rel, field, fields) {
     const terms = [system ? `system='${system}'` : '', `code='${code}'`].filter(Boolean).join(' and ');
     const segments = rel.split('.');
     // rel is <base>.<leaf>; the where() goes on the repeating base element.
-    if (segments.length < 2)
+    const leaf = segments.length >= 2 ? segments.pop() : undefined;
+    if (!leaf)
         return rel;
-    const leaf = segments.pop();
     return `${segments.join('.')}.where(${discriminatorProp}.coding.where(${terms}).exists()).${leaf}`;
 }
 export function generateValidateProfileFunction(interfaceName, fields, valueSets, profileUrl, baseResourceType, profileUrlToName, extensionMetadata, baseDefinition, profileUrlToType, datatypeProfilePins) {
@@ -110,7 +115,7 @@ export function generateValidateProfileFunction(interfaceName, fields, valueSets
             const relPath = fullPath.replace(/^[^.]+\./, "");
             arrayFieldPaths.add(relPath);
             if (relPath.includes(':')) {
-                arrayFieldPaths.add(relPath.split(':')[0]);
+                arrayFieldPaths.add(stripSliceSuffix(relPath));
             }
         }
     });
@@ -126,7 +131,7 @@ export function generateValidateProfileFunction(interfaceName, fields, valueSets
                 let isNestedInArray = false;
                 for (let j = 0; j < i; j++) {
                     const parentPath = parts.slice(0, j + 1).join('.');
-                    const basePath = parentPath.split(':')[0];
+                    const basePath = stripSliceSuffix(parentPath);
                     if (arrayFieldPaths.has(parentPath) || arrayFieldPaths.has(basePath)) {
                         isNestedInArray = true;
                         break;
@@ -169,7 +174,7 @@ export function generateValidateProfileFunction(interfaceName, fields, valueSets
         let vs = valueSets.get(bindingUri);
         let resolvedUri = bindingUri;
         if (!vs && bindingUri.includes('|')) {
-            resolvedUri = bindingUri.split('|')[0];
+            resolvedUri = stripVersionFromCanonicalUrl(bindingUri);
             vs = valueSets.get(resolvedUri);
         }
         if (!vs)
@@ -225,7 +230,7 @@ export function generateValidateProfileFunction(interfaceName, fields, valueSets
         if (!fieldPath)
             return;
         fieldPath = sliceScopedBindingPath(fieldPath, f, fields);
-        const vsUri = (f.binding.uri || '').split('|')[0];
+        const vsUri = stripVersionFromCanonicalUrl(f.binding.uri || '');
         const vsDisplayName = vsUri.split('/').pop() || vsUri;
         constraintsWithContext.push({
             constraint: {
@@ -407,55 +412,40 @@ export function generateValidateProfileFunction(interfaceName, fields, valueSets
         const lastSegment = path.split('.').pop() || '';
         return !!lastSegment && relativeFieldNames.has(`${path}.${lastSegment}`);
     };
+    // Paths a structural type check can actually record, read back from the code
+    // just emitted rather than re-deriving which fields qualify — two copies of
+    // that predicate would drift, and a guard on a path nothing records is a dead
+    // conditional in every generated validator.
+    const structuralFailurePaths = new Set([...structuralTypeValidations.join('').matchAll(/_structuralFailures\.add\('([^']+)'\)/g)].map(m => m[1]));
+    const hasStructuralChecks = structuralFailurePaths.size > 0;
     // ── Generate FHIRPath evaluation code ───────────────────────────────────
     const validationLogic = filteredConstraints
         .map((item, index) => {
         const constraint = item.constraint;
         const fieldPath = item.fieldPath;
-        let escapedExpression = normalizeCollectionTypeFilters(constraint.expression || '')
-            .replace(/\s*\n\s*/g, ' ')
-            .replace(/\\/g, '\\\\')
-            .replace(/"/g, '\\"');
+        // Shared with the Zod emitter so both evaluate the identical expression.
+        const escapedExpression = scopeConstraintExpression(constraint.expression || '', fieldPath, {
+            isRecursiveElement,
+            sliceFilter: item.sliceFilter,
+        });
         const escapedHuman = (constraint.human || '').replace(/"/g, '\\"').replace(/[\r\n]+/g, ' ');
-        // Scope constraints to their fieldPath if needed
-        // If fieldPath exists and the expression doesn't already navigate FROM it,
-        // wrap with .all() so the constraint evaluates relative to each element.
-        // Only check the START of the expression — built constraints (e.g.,
-        // "action.exists()") always begin with the fieldPath, while field-level
-        // constraints are relative to the element and start with child names.
-        // Checking for fieldPath anywhere in the expression causes false positives
-        // for recursive elements (e.g., "resource.exists() != action.exists()"
-        // on fieldPath "action" — the expression contains "action" but only as a
-        // child property reference, not a root navigation).
-        //
-        // NOTE: resource-root constraints (fieldPath === baseResourceType) also
-        // need .all() wrapping.  FHIRPath `implies` returns empty when the
-        // antecedent is missing, and .all() correctly converts that to false —
-        // matching the HL7 / Firely validator behavior which fires the constraint.
-        if (fieldPath) {
-            const escaped = fieldPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            const fieldPathNavigationPattern = new RegExp(`^${escaped}\\s*\\.`);
-            const fieldPathStandalonePattern = new RegExp(`^${escaped}(?:[^.\\w]|$)`);
-            const expressionRefersToField = fieldPathNavigationPattern.test(escapedExpression) || fieldPathStandalonePattern.test(escapedExpression);
-            if (!expressionRefersToField) {
-                const resourceTypePattern = /^[A-Z][a-zA-Z]+\./;
-                if (!resourceTypePattern.test(escapedExpression)) {
-                    const walkRecursion = isRecursiveElement(fieldPath)
-                        && !isBaseElementInvariant(constraint.expression || '');
-                    const navigation = item.sliceFilter
-                        ? `${quoteFhirPathPath(fieldPath)}.where(${item.sliceFilter})`
-                        : quoteFhirPathPath(fieldPath);
-                    const scope = walkRecursion ? `repeat(${navigation})` : navigation;
-                    escapedExpression = `${scope}.all(${escapedExpression})`;
-                }
-            }
-        }
         const needsTerminology = /\bmemberOf\b/.test(constraint.expression || '');
         let evaluateBlock = `
     const result${index} = await fhirpath.evaluate(resource, "${escapedExpression}", { resource, rootResource: resource }, fhirpath_model, fhirpathOptions);
     if (!result${index}.every(Boolean)) {
       ${constraint.severity === "error" ? "errors" : "warnings"}.push("Constraint violation: ${escapedHuman}");
     }`;
+        // One defect, one diagnostic. An element that failed its structural type
+        // check cannot satisfy an invariant that inspects its children, so
+        // evaluating them here adds a second error for the same root cause — the
+        // ele-1 ("must have a @value or children") cascade behind
+        // ClinicalUseDefinition*, where HL7 reports only the type error. HL7 is
+        // the reference implementation and reports the root cause once.
+        if (fieldPath && structuralFailurePaths.has(fieldPath)) {
+            evaluateBlock = `
+    if (!_structuralFailures.has('${fieldPath}')) {${evaluateBlock}
+    }`;
+        }
         // Gate memberOf() behind terminologyUrl.  For resolve(), use try/catch
         // instead of a hard gate: FHIRPath `and` short-circuits, so expressions
         // like `(A and resolve().is(X)) or (B and focus.exists().not())` can still
@@ -545,6 +535,12 @@ ${body}
         fhirpathOptionsLines.push('    async: true as const,', '    ...(options?.terminologyUrl ? { terminologyUrl: options.terminologyUrl } : {}),', '    ...(options?.fhirServerUrl ? { fhirServerUrl: options.fhirServerUrl } : {}),');
     }
     const fhirpathOptionsBlock = `const fhirpathOptions = {\n${fhirpathOptionsLines.join('\n')}\n  };`;
+    // Paths whose value is the wrong JSON kind. Populated by the structural type
+    // checks, which the assembled body now runs before any invariant so the guard
+    // has something to read.
+    const structuralFailureDecl = hasStructuralChecks
+        ? 'const _structuralFailures = new Set<string>();\n  '
+        : '';
     let valueSetImportStatements = '';
     if (valueSetImports.size > 0) {
         valueSetImportStatements = Array.from(valueSetImports.entries())
@@ -562,8 +558,8 @@ ${body}
         code: `${fhirpathImport}${optionsImport}${valueSetImportStatements}${validatorImportStatements}export async function validate${interfaceName}(resource: ${interfaceName}, options?: ValidatorOptions): Promise<{ errors: string[]; warnings: string[] }> {
   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('')}${closedSlicingValidations.join('')}${datatypeProfileDelegations.join('')}${nonDomainTextCheck}${extensionStructuralValidation}${containedRefValidation}${bundledAggregationValidation}${bundleRefValidation}
+  ${structuralFailureDecl}${fhirpathOptionsBlock}
+  ${bundleEntryResolution}${referenceTargetTypeValidation}${structuralTypeValidations.join('')}${validationLogic}${fixedPatternValidations.join('')}${nestedRequiredValidations.join('')}${fixedValueValidations.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

@@ -26,8 +26,19 @@ export interface ValidatorOptions {
   terminologyUrl?: string;
   /** FHIR server URL for resolve() evaluation (e.g. "https://hapi.fhir.org/baseR4"). */
   fhirServerUrl?: string;
-  /** HTTP headers keyed by server URL — used for auth with terminology or FHIR servers. */
-  httpHeaders?: Record<string, string>;
+  /**
+   * HTTP headers for auth with terminology or FHIR servers, keyed by server base
+   * URL, each mapping header name to value:
+   *
+   *     { "https://tx.fhir.org/r4": { Authorization: "Bearer …" } }
+   *
+   * Two levels, not one. The comment always said "keyed by server URL" while the
+   * type said \`Record<string, string>\`, so a caller typing against it wrote
+   * \`{ Authorization: "Bearer …" }\` — which fhirpath reads as base URL
+   * "Authorization" with a string where a header map belongs, and the header is
+   * never sent. fhirpath 5.1.0 corrected the same mistake in its own declaration.
+   */
+  httpHeaders?: Record<string, Record<string, string>>;
   /** AbortSignal for cancelling long-running async evaluations. */
   signal?: AbortSignal;
   /** Debug tracing callback — invoked for every FHIRPath trace() call. */

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

@@ -1,3 +1,4 @@
+import { stripVersionFromCanonicalUrl } from '../../core/utils.js';
 /**
  * Emit the reference target-type check for one profile.
  *
@@ -13,7 +14,7 @@
  */
 export function buildReferenceTargetTypeValidation(fields, profileUrlToType) {
     const resolveTargetType = (url) => {
-        const bare = url.split('|')[0];
+        const bare = stripVersionFromCanonicalUrl(url);
         const lastSegment = bare.split('/').pop() || '';
         if (/^[A-Z][A-Za-z]+$/.test(lastSegment))
             return lastSegment;
@@ -328,6 +329,8 @@ ${indent}  errors.push('${message}' + ${refVar});
 ${indent}}`;
         }
         const segment = segments[index];
+        if (segment === undefined)
+            return '';
         if (isArray[index]) {
             const itemVar = `_aggItem${id}${index}`;
             return `

package/out/src/generator/emitters/valueset/valueSetGenerator.js

@@ -2,6 +2,7 @@
  * ValueSet Generator
  * Generates TypeScript files for FHIR ValueSets with runtime validation support
  */
+import { pascalCaseIdentifier } from '../../core/utils.js';
 /**
  * Assign a unique identifier to every ValueSet that will be emitted.
  *
@@ -148,16 +149,11 @@ export function generateValueSetTypeScript(valueSet, options) {
  * Sanitize ValueSet name for use as TypeScript identifier
  */
 export function sanitizeValueSetName(name) {
-    // Remove common prefixes
-    let sanitized = name.replace(/^ValueSet[-_]?/i, '');
-    // Split on non-alphanumeric and capitalize each part
-    const parts = sanitized.split(/[^a-zA-Z0-9]+/).filter(Boolean);
-    sanitized = parts.map(p => p.charAt(0).toUpperCase() + p.slice(1)).join('');
-    // Ensure it starts with a letter
-    if (/^[0-9]/.test(sanitized)) {
-        sanitized = 'VS' + sanitized;
-    }
-    return sanitized || 'UnnamedValueSet';
+    return pascalCaseIdentifier(name, {
+        stripPrefix: /^ValueSet[-_]?/i,
+        digitPrefix: 'VS',
+        fallback: 'UnnamedValueSet',
+    });
 }
 /**
  * Generate a ValueSet registry file that exports all ValueSets

package/out/src/generator/emitters/zod/zodRefinementBuilder.js

@@ -3,6 +3,8 @@
  * and required ValueSet bindings.
  */
 import { sanitizeValueSetName } from '../valueset/valueSetGenerator.js';
+import { scopeConstraintExpression } from '../validator/validatorExpressions.js';
+import { stripSliceSuffix, stripVersionFromCanonicalUrl } from '../../core/utils.js';
 /** Escape double-quote characters in refinement messages */
 function escStr(s) {
     return s.replace(/"/g, '\\"');
@@ -11,15 +13,19 @@ function escStr(s) {
  * Build refinement chains for pattern constraints, required slice cardinalities,
  * and FHIRPath invariants. Returns refinement code strings plus tracked constraint metadata.
  */
-export function buildRefinements(allFields, rootPrefix, valueSets) {
+export function buildRefinements(allFields, rootPrefix, valueSets, 
+/** See generateZodSchema's `emitInvariants`: opt-in, for the per-parse cost. */
+emitInvariants = false) {
     const refinements = [];
+    const invariantEvaluators = [];
     const bindingVsImports = new Map();
     // Build set of direct (root-level) field names for safety checks
     const directFieldNames = new Set();
     for (const field of allFields) {
         const parts = field.name.split('.');
-        if (parts.length === 2 && parts[0] === rootPrefix) {
-            directFieldNames.add(parts[1].split(':')[0]); // strip slice suffix
+        const [root, direct] = parts;
+        if (parts.length === 2 && root === rootPrefix && direct) {
+            directFieldNames.add(stripSliceSuffix(direct));
         }
     }
     // 1. Pattern constraints (patternCodeableConcept, patternCoding)
@@ -31,7 +37,7 @@ export function buildRefinements(allFields, rootPrefix, valueSets) {
             continue;
         if (rel.includes('.') || rel.endsWith('.coding'))
             continue;
-        if (!directFieldNames.has(rel.split(':')[0]))
+        if (!directFieldNames.has(stripSliceSuffix(rel)))
             continue;
         const pattern = field.patternConstraint;
         // patternCodeableConcept
@@ -84,7 +90,7 @@ export function buildRefinements(allFields, rootPrefix, valueSets) {
             continue;
         if (relPath.includes('[x]'))
             continue;
-        if (!directFieldNames.has(relPath.split(':')[0]))
+        if (!directFieldNames.has(stripSliceSuffix(relPath)))
             continue;
         for (const slice of slices) {
             const min = typeof slice.min === 'number' ? slice.min : (slice.isOptional ? 0 : 1);
@@ -163,10 +169,42 @@ export function buildRefinements(allFields, rootPrefix, valueSets) {
             unsupportedConstraints.push(meta);
         }
         else {
-            // Supported but not yet emitted — future FHIRPath→JS translation point
             supportedConstraints.push(meta);
         }
     }
+    // Emit the supported invariants.
+    //
+    // These were tracked and never emitted, on the premise that FHIRPath
+    // evaluation is async while Zod refinements are synchronous. Neither half
+    // holds: fhirpath.js returns an array and only returns a Promise when async
+    // mode is opted into, which it needs solely for memberOf()/resolve() — and
+    // those are already in `unsupportedConstraints` above. So every constraint
+    // here evaluates synchronously inside a plain refinement, and `safeParse`
+    // keeps working for consumers.
+    //
+    // The expression goes through the same scoping the validator uses, and the
+    // message repeats its wording, so the two agree per profile rather than
+    // reporting the same defect under different text.
+    supportedConstraints.forEach((meta, i) => {
+        if (!emitInvariants)
+            return;
+        const scoped = scopeConstraintExpression(meta.expression, meta.fieldPath);
+        if (!scoped)
+            return;
+        const human = escStr(meta.human).replace(/[\r\n]+/g, ' ');
+        const fn = `_inv${i}`;
+        // Compiled once at module load, not per parse. `evaluate` re-parses the
+        // expression on every call, which cost ~0.3ms each: 69 invariants made a
+        // C4BBOrganization parse 242x slower on an empty resource and 964x on a
+        // populated one. `compile` parses once and returns a reusable evaluator.
+        //
+        // traceFn is silenced deliberately: fhirpath's trace() defaults to writing
+        // to the console, so a schema parse would print "TRACE:[…]" out of a
+        // published package.
+        invariantEvaluators.push(`const ${fn} = fhirpath.compile("${scoped}", fhirpath_model, { preciseMath: true, traceFn: () => {} });`);
+        refinements.push(`.refine(d => { try { const _r = ${fn}(d, { resource: d, rootResource: d }); return Array.isArray(_r) ? _r.every(Boolean) : true; } catch { return true; } },`
+            + ` { message: "Constraint violation: ${human}", when: () => true })`);
+    });
     // 4. Meta sub-field constraints
     // When a profile constrains meta.lastUpdated, meta.profile, etc. with min>=1,
     // emit refinements that check for their presence. Uses `when: () => true` so
@@ -201,6 +239,8 @@ export function buildRefinements(allFields, rootPrefix, valueSets) {
         if (field.binding?.strength !== 'required')
             continue;
         const rel = parts[1];
+        if (!rel)
+            continue;
         // Skip choice-type placeholders (code[x], value[x], etc.) — the binding applies
         // to the resolved variant (e.g. codeCodeableConcept) which we cannot reliably
         // identify here. Emitting d.code[x] would produce invalid TypeScript.
@@ -216,7 +256,7 @@ export function buildRefinements(allFields, rootPrefix, valueSets) {
             vsDisplayName = field.binding.uri?.split('/').pop() || 'ValueSet';
         }
         else if (field.binding.uri && valueSets) {
-            const vsUri = field.binding.uri.split('|')[0];
+            const vsUri = stripVersionFromCanonicalUrl(field.binding.uri);
             const vs = valueSets.get(vsUri) || valueSets.get(field.binding.uri);
             if (vs && vs.concepts.length > 0 && vs.concepts.length <= 200) {
                 codes = vs.concepts.map(c => c.code);
@@ -253,5 +293,5 @@ export function buildRefinements(allFields, rootPrefix, valueSets) {
             }
         }
     }
-    return { refinements, supportedConstraints, unsupportedConstraints, valueSetImports: bindingVsImports };
+    return { refinements, supportedConstraints, unsupportedConstraints, valueSetImports: bindingVsImports, invariantEvaluators };
 }