babelfhir-ts 1.5.19 → 1.5.21

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

@@ -40,16 +40,19 @@ export function buildRefinements(allFields, rootPrefix, valueSets) {
             for (const coding of requiredCodings) {
                 const system = coding.system ? String(coding.system) : undefined;
                 const code = String(coding.code);
-                const accessor = field.isArray
-                    ? `(d as any).${rel}`
-                    : `[(d as any).${rel}]`;
+                // arr() flattens the array case and [] wraps the scalar case, so both
+                // reduce to "some member carries a matching coding". codings() reads the
+                // CodeableConcept's .coding and yields typed CodingShapes.
+                const members = field.isArray
+                    ? `arr(at(d, '${rel}'))`
+                    : `[at(d, '${rel}')]`;
                 const matchExpr = system
-                    ? `(c as any).system === "${system}" && (c as any).code === "${code}"`
-                    : `(c as any).code === "${code}"`;
+                    ? `c.system === "${system}" && c.code === "${code}"`
+                    : `c.code === "${code}"`;
                 const msg = system
                     ? `${rel} must include coding ${system}|${code}`
                     : `${rel} must include coding ${code}`;
-                refinements.push(`.refine(d => !(d as any).${rel} || ${accessor}.flat().some((item: any) => item?.coding?.some((c: any) => ${matchExpr})), { message: "${escStr(msg)}" })`);
+                refinements.push(`.refine(d => !at(d, '${rel}') || ${members}.some((item) => codings(item).some((c) => ${matchExpr})), { message: "${escStr(msg)}" })`);
             }
         }
         // patternCoding
@@ -57,10 +60,11 @@ export function buildRefinements(allFields, rootPrefix, valueSets) {
             const system = String(pattern.system);
             const code = String(pattern.code);
             if (field.isArray) {
-                refinements.push(`.refine(d => !(d as any).${rel} || (d as any).${rel}.some((c: any) => c.system === "${system}" && c.code === "${code}"), { message: "${escStr(rel)} must include coding ${system}|${code}" })`);
+                // An array of Codings passes straight through codings() as CodingShapes.
+                refinements.push(`.refine(d => !at(d, '${rel}') || codings(at(d, '${rel}')).some((c) => c.system === "${system}" && c.code === "${code}"), { message: "${escStr(rel)} must include coding ${system}|${code}" })`);
             }
             else {
-                refinements.push(`.refine(d => !(d as any).${rel} || ((d as any).${rel}.system === "${system}" && (d as any).${rel}.code === "${code}"), { message: "${escStr(rel)} must match coding ${system}|${code}" })`);
+                refinements.push(`.refine(d => { const _c = coding(at(d, '${rel}')); return !at(d, '${rel}') || (_c.system === "${system}" && _c.code === "${code}"); }, { message: "${escStr(rel)} must match coding ${system}|${code}" })`);
             }
         }
     }
@@ -95,23 +99,26 @@ export function buildRefinements(allFields, rootPrefix, valueSets) {
                     const checks = codings
                         .map(c => {
                         return c.system
-                            ? `(item as any)?.coding?.some((cd: any) => cd.system === "${c.system}" && cd.code === "${c.code}")`
-                            : `(item as any)?.coding?.some((cd: any) => cd.code === "${c.code}")`;
+                            ? `codings(item).some((cd) => cd.system === "${c.system}" && cd.code === "${c.code}")`
+                            : `codings(item).some((cd) => cd.code === "${c.code}")`;
                     })
                         .join(' || ');
-                    refinements.push(`.refine(d => !Array.isArray((d as any).${relPath}) || (d as any).${relPath}.filter((item: any) => ${checks}).length >= ${min}, { message: "Required slice '${escStr(relPath)}:${escStr(sliceLabel)}' not satisfied", when: () => true })`);
+                    refinements.push(`.refine(d => !Array.isArray(at(d, '${relPath}')) || arr(at(d, '${relPath}')).filter((item) => ${checks}).length >= ${min}, { message: "Required slice '${escStr(relPath)}:${escStr(sliceLabel)}' not satisfied", when: () => true })`);
                 }
             }
             // patternCoding discriminator
             if (slice.patternConstraint && typeof slice.patternConstraint === 'object' && 'system' in slice.patternConstraint && 'code' in slice.patternConstraint && !('coding' in slice.patternConstraint)) {
                 const pat = slice.patternConstraint;
-                refinements.push(`.refine(d => !Array.isArray((d as any).${relPath}) || (d as any).${relPath}.filter((c: any) => c.system === "${pat.system}" && c.code === "${pat.code}").length >= ${min}, { message: "Required slice '${escStr(relPath)}:${escStr(sliceLabel)}' not satisfied", when: () => true })`);
+                refinements.push(`.refine(d => !Array.isArray(at(d, '${relPath}')) || codings(at(d, '${relPath}')).filter((c) => c.system === "${pat.system}" && c.code === "${pat.code}").length >= ${min}, { message: "Required slice '${escStr(relPath)}:${escStr(sliceLabel)}' not satisfied", when: () => true })`);
             }
             // Binding codes discriminator
             if (!slice.patternConstraint && slice.binding?.codes && slice.binding.codes.length > 0) {
                 const codes = slice.binding.codes.map(c => JSON.stringify(c.code));
                 const codesSet = `[${codes.join(', ')}]`;
-                refinements.push(`.refine(d => !Array.isArray((d as any).${relPath}) || (d as any).${relPath}.filter((item: any) => ${codesSet}.includes(item?.code ?? item)).length >= ${min}, { message: "Required slice '${escStr(relPath)}:${escStr(sliceLabel)}' not satisfied", when: () => true })`);
+                refinements.push(
+                // A binding-discriminated slice member is either a coded element or a
+                // bare code string, so fall back to the member itself.
+                `.refine(d => !Array.isArray(at(d, '${relPath}')) || arr(at(d, '${relPath}')).filter((item) => { const _code = coding(item).code ?? item; return typeof _code === 'string' && ${codesSet}.includes(_code); }).length >= ${min}, { message: "Required slice '${escStr(relPath)}:${escStr(sliceLabel)}' not satisfied", when: () => true })`);
             }
         }
     }
@@ -173,10 +180,10 @@ export function buildRefinements(allFields, rootPrefix, valueSets) {
         if (min <= 0)
             continue;
         if (field.isArray) {
-            refinements.push(`.refine(d => (d as any).meta?.${subField}?.length >= ${min}, { message: "meta.${subField} must be present", when: () => true })`);
+            refinements.push(`.refine(d => arr(at(d, 'meta', '${subField}')).length >= ${min}, { message: "meta.${subField} must be present", when: () => true })`);
         }
         else {
-            refinements.push(`.refine(d => (d as any).meta?.${subField} !== undefined, { message: "meta.${subField} must be present", when: () => true })`);
+            refinements.push(`.refine(d => at(d, 'meta', '${subField}') !== undefined, { message: "meta.${subField} must be present", when: () => true })`);
         }
     }
     // 5. Required ValueSet bindings on CodeableConcept / Coding fields
@@ -223,23 +230,26 @@ export function buildRefinements(allFields, rootPrefix, valueSets) {
             continue;
         const codesLiteral = `[${codes.map(c => JSON.stringify(c)).join(', ')}]`;
         const msgBase = `None of the codings provided are in the value set '${escStr(vsDisplayName)}' (${escStr(field.binding.uri || '')})`;
+        // `allowed` is a string[], so each candidate code is narrowed to a string
+        // before the lookup rather than asserted through an `any`.
+        const isAllowed = (codeExpr) => `${codeExpr} !== undefined && ${codesLiteral}.includes(${codeExpr})`;
         if (type === 'CodeableConcept') {
             if (field.isArray) {
                 // Array of CodeableConcept: each entry must have at least one valid coding
-                refinements.push(`.refine(d => { const arr = (d as any).${rel}; if (!Array.isArray(arr)) return true; const allowed = ${codesLiteral}; return arr.every((cc: any) => cc?.coding?.some((c: any) => allowed.includes(c?.code))); }, { message: "${escStr(msgBase)}", when: () => true })`);
+                refinements.push(`.refine(d => { const _value = at(d, '${rel}'); if (!Array.isArray(_value)) return true; return arr(_value).every((cc) => codings(cc).some((c) => ${isAllowed('c.code')})); }, { message: "${escStr(msgBase)}", when: () => true })`);
             }
             else {
                 // Single CodeableConcept: coding must include at least one valid code
-                refinements.push(`.refine(d => { const cc = (d as any).${rel}; if (!cc) return true; const allowed = ${codesLiteral}; return cc.coding?.some((c: any) => allowed.includes(c?.code)); }, { message: "${escStr(msgBase)}", when: () => true })`);
+                refinements.push(`.refine(d => { const _value = at(d, '${rel}'); if (!_value) return true; return codings(_value).some((c) => ${isAllowed('c.code')}); }, { message: "${escStr(msgBase)}", when: () => true })`);
             }
         }
         else {
             // Coding field
             if (field.isArray) {
-                refinements.push(`.refine(d => { const arr = (d as any).${rel}; if (!Array.isArray(arr)) return true; const allowed = ${codesLiteral}; return arr.every((c: any) => allowed.includes(c?.code)); }, { message: "${escStr(msgBase)}", when: () => true })`);
+                refinements.push(`.refine(d => { const _value = at(d, '${rel}'); if (!Array.isArray(_value)) return true; return codings(_value).every((c) => ${isAllowed('c.code')}); }, { message: "${escStr(msgBase)}", when: () => true })`);
             }
             else {
-                refinements.push(`.refine(d => { const c = (d as any).${rel}; if (!c) return true; const allowed = ${codesLiteral}; return allowed.includes(c.code); }, { message: "${escStr(msgBase)}", when: () => true })`);
+                refinements.push(`.refine(d => { const _value = at(d, '${rel}'); if (!_value) return true; const _c = coding(_value); return ${isAllowed('_c.code')}; }, { message: "${escStr(msgBase)}", when: () => true })`);
             }
         }
     }

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

@@ -11,6 +11,8 @@ import { getZodPackageTypes } from './zodTypes.js';
 import { mergeFields } from '../../core/utils.js';
 import { buildRefinements } from './zodRefinementBuilder.js';
 /** Map FHIR primitive types to Zod schema calls */
+/** Runtime helpers a refinement may reference, imported from ValidatorOptions. */
+const ZOD_REFINEMENT_HELPERS = ['at', 'arr', 'coding', 'codings'];
 const ZOD_PRIMITIVE_MAP = {
     any: 'z.string()',
     string: 'z.string()',
@@ -262,6 +264,19 @@ export function generateZodSchema(interfaceName, newFields, baseResource, baseFi
             valueSetImports.set(name, importPath);
         }
     }
+    // Refinements read dynamic property paths through the same runtime helpers the
+    // generated validators use, rather than casting the parsed object to `any`.
+    // ValidatorOptions.ts is written into every output directory, so the relative
+    // import always resolves. Only the helpers actually referenced are imported.
+    // The required-choice[x] refinements are appended further below and always
+    // probe their variants with at(), so they count toward the helper set here.
+    const refinementCode = refinementResult.refinements.join('\n')
+        + (requiredChoiceVariants.length > 0 ? '\nat(' : '');
+    const usedHelpers = ZOD_REFINEMENT_HELPERS.filter(helper => new RegExp(`\\b${helper}\\(`).test(refinementCode));
+    if (usedHelpers.length > 0) {
+        const headerIndex = lines.indexOf(`import { z } from "zod";`);
+        lines.splice(headerIndex + 1, 0, `import { ${usedHelpers.join(', ')} } from "./ValidatorOptions.js";`);
+    }
     lines.push('');
     // Emit schema
     const schemaName = `${interfaceName}Schema`;
@@ -285,7 +300,7 @@ export function generateZodSchema(interfaceName, newFields, baseResource, baseFi
     // Uses `when: () => true` so the refinement fires even when base schema has errors
     // (e.g., missing required fields on an empty resource).
     for (const { basePropName, variantProps } of requiredChoiceVariants) {
-        const checks = variantProps.map(p => `(d as any).${p} !== undefined`).join(' || ');
+        const checks = variantProps.map(p => `at(d, '${p}') !== undefined`).join(' || ');
         lines.push(`.refine(d => ${checks}, { message: "${basePropName} must be present", when: () => true })`);
     }
     // Close with semicolon

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/packageParser.js

@@ -7,14 +7,7 @@ import { logger } from "../../logger.js";
 import { getFhirPackagesCacheDir, ensureCacheDir } from "../core/cacheConfig.js";
 import { downloadFile } from '../core/utils.js';
 import { versionSlug } from '../fhir/versionContext.js';
-/**
- * FHIR package registries in priority order.
- * packages.fhir.org is the canonical source; packages.simplifier.net is the fallback.
- */
-const FHIR_REGISTRIES = [
-    'https://packages.fhir.org',
-    'https://packages.simplifier.net',
-];
+import { FHIR_REGISTRIES } from '../core/constants.js';
 const log = logger.withTag('package');
 /**
  * Load curated sample codes for large external CodeSystems and core ValueSet→system mappings

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,