babelfhir-ts 1.5.6 → 1.5.7

package/out/src/generator/emitters/interface/interfaceFieldProcessor.js

@@ -353,10 +353,11 @@ export function processFields(ctx, fields, parentInterfaceName, parentFieldType,
             }
         }
         // Conservative mode: if we failed to fetch base metadata (no base fields) skip emitting certain core properties
-        // to avoid degrading their types to primitives. Only skip if not profiled and not fixed.
+        // to avoid degrading their types to primitives. Only skip if not profiled, not fixed, and no narrowing binding.
         if (baseFieldByLastSegment.size === 0 && parentInterfaceName === interfaceName && fieldParts.length === 2 && fieldParts[0] === baseResource) {
             const conservativeSkip = new Set(['gender', 'status', 'intent', 'hospitalization', 'payor', 'entry', 'concept', 'identifier', 'use', 'system', 'priority']);
-            if (!field.isProfiled && field.fixedValue === undefined && conservativeSkip.has(fieldName)) {
+            const hasNarrowingBinding = !!(field.binding?.codes && field.binding.codes.length > 0 && field.binding.strength === 'required');
+            if (!field.isProfiled && field.fixedValue === undefined && !hasNarrowingBinding && conservativeSkip.has(fieldName)) {
                 debug('conservative skip (no base metadata)', field.name);
                 return;
             }

package/out/src/generator/emitters/interface/processFlatField.js

@@ -13,10 +13,13 @@ export function handleFlatField(args) {
     const conservative = baseFieldByLastSegment.size === 0;
     const isRootInterface = parentInterfaceName === interfaceName;
     const isNested = isRootInterface ? fieldParts.length > 1 : fieldParts.length >= 1;
+    // Does this field carry a narrowing required ValueSet binding with resolved codes?
+    // If so, it should bypass skip heuristics so we can emit a union literal type.
+    const hasNarrowingBinding = !!(field.binding?.codes && field.binding.codes.length > 0 && field.binding.strength === 'required');
     // Skip deeply nested enumerated fields at root level - they'll be handled by nested interfaces
     // (e.g., Patient.telecom.system should be emitted in UKCorePatientTelecom, not UKCorePatient)
     const enumeratedCodeFields = new Set(['system', 'use', 'status', 'gender', 'intent', 'priority', 'class', 'category', 'clinicalStatus', 'verificationStatus']);
-    if (fieldParts.length >= 3 && enumeratedCodeFields.has(fieldName) && !field.fixedValue) {
+    if (fieldParts.length >= 3 && enumeratedCodeFields.has(fieldName) && !field.fixedValue && !hasNarrowingBinding) {
         debug('skip deeply nested enumerated field at root level', field.name);
         return true;
     }
@@ -73,7 +76,7 @@ export function handleFlatField(args) {
         // Even if cardinality or mustSupport changed, we should NOT emit if it would widen the type
         // (e.g., base has category?: ('food'|'medication'|'environment'|'biologic')[] but we'd emit category: string[])
         // TypeScript doesn't allow assigning string[] to a more specific string literal union array
-        if (isPrimitiveType(mapped) && !hasExtensionSlices && !hasIdentifierSlices && !field.isProfiled && !field.fixedValue) {
+        if (isPrimitiveType(mapped) && !hasExtensionSlices && !hasIdentifierSlices && !field.isProfiled && !field.fixedValue && !hasNarrowingBinding) {
             debug('skip primitive override of base child - would widen type', field.name, 'mappedType=', mapped);
             return true;
         }
@@ -118,7 +121,7 @@ export function handleFlatField(args) {
     const enumeratedSkip = new Set(['status', 'gender', 'class', 'category', 'concept', 'entry', 'clinicalStatus', 'verificationStatus', 'use', 'system', 'priority']);
     const mustSupportChanged = baseField && (!baseField.mustSupport && field.mustSupport);
     const cardinalityChanged = baseField && (baseField.isOptional !== field.isOptional || baseField.isArray !== field.isArray);
-    if (parentInterfaceName === interfaceName && !field.fixedValue && !mustSupportChanged && !cardinalityChanged) {
+    if (parentInterfaceName === interfaceName && !field.fixedValue && !hasNarrowingBinding && !mustSupportChanged && !cardinalityChanged) {
         if (enumeratedSkip.has(fieldName))
             return true;
         if (baseResource === 'UsageContext' && fieldName === 'code' && field.type === 'string')
@@ -160,7 +163,7 @@ export function handleFlatField(args) {
         }
         // Special cases: known enumerated code fields (status, gender, intent, class, category) -> avoid overriding unless fixed or mustSupport changed
         const mustSupportChanged = baseField.mustSupport !== field.mustSupport && field.mustSupport === true;
-        if (!field.fixedValue && !mustSupportChanged && ['status', 'gender', 'intent', 'class', 'category', 'lifecycleStatus', 'clinicalStatus', 'verificationStatus', 'use', 'system', 'priority'].includes(fieldName)) {
+        if (!field.fixedValue && !hasNarrowingBinding && !mustSupportChanged && ['status', 'gender', 'intent', 'class', 'category', 'lifecycleStatus', 'clinicalStatus', 'verificationStatus', 'use', 'system', 'priority'].includes(fieldName)) {
             return true;
         }
         // CodeSystem.concept & Bundle.entry etc complex arrays: avoid overriding unless truly adding constraints
@@ -171,11 +174,12 @@ export function handleFlatField(args) {
         if (['concept', 'entry', 'content'].includes(fieldName) && !field.fixedValue)
             return true;
         // Even if mustSupport changes, we should inherit the base enum type, not override with string
-        if (['gender', 'status', 'intent', 'lifecycleStatus', 'clinicalStatus', 'verificationStatus', 'content', 'use', 'system', 'priority'].includes(fieldName) && isPrimitiveType(mapped)) {
+        if (['gender', 'status', 'intent', 'lifecycleStatus', 'clinicalStatus', 'verificationStatus', 'content', 'use', 'system', 'priority'].includes(fieldName) && isPrimitiveType(mapped) && !hasNarrowingBinding) {
             return true;
         }
         // Skip if identical to base (same type, array flag, optionality, AND mustSupport)
-        if (!field.fixedValue && !hasExtensionSlices) {
+        // Exception: fields with narrowing bindings should still be emitted (they constrain the type)
+        if (!field.fixedValue && !hasExtensionSlices && !hasNarrowingBinding) {
             const mappedType = mapTypeToTS(field.type || 'string');
             const mustSupportSame = baseField.mustSupport === field.mustSupport;
             if ((baseField.type === field.type || baseField.type === mappedType) && baseField.isArray === field.isArray && baseField.isOptional === field.isOptional && mustSupportSame) {
@@ -449,6 +453,25 @@ export function handleFlatField(args) {
     }
     // Apply ValueSet binding constraints for CodeableConcept types
     fieldType = applyBindingConstraint(fieldType, field, fields);
+    // Apply ValueSet binding constraints for primitive code fields (generates union literal type)
+    if (isPrimitiveType(fieldType) && hasNarrowingBinding && field.binding?.codes) {
+        const vsUri = field.binding.uri?.split('|')[0];
+        const vs = vsUri && valueSets ? (valueSets.get(vsUri) || valueSets.get(field.binding.uri)) : undefined;
+        if (vs && vs.isSmall && vs.concepts.length > 0) {
+            // Import the ValueSet Code type from the generated valuesets directory
+            const sanitizedVSName = sanitizeValueSetName(vs.name);
+            const vsTypeName = `${sanitizedVSName}Code`;
+            importManager.addPathBasedImport(vsTypeName, './valuesets/ValueSet-' + sanitizedVSName);
+            fieldType = vsTypeName;
+            debug(`Applied code binding constraint for ${field.name}: ${vsTypeName}`);
+        }
+        else {
+            // Fall back to inline union from binding.codes (wrap in parens for array compatibility)
+            const inlineUnion = field.binding.codes.map(c => JSON.stringify(c.code)).join(' | ');
+            fieldType = field.binding.codes.length > 1 ? `(${inlineUnion})` : inlineUnion;
+            debug(`Applied inline code binding constraint for ${field.name}: ${fieldType}`);
+        }
+    }
     // Preserve arrayness from base when known; if base metadata is missing and field name is a known repeating element (e.g., 'coverage' on Account),
     // default to array to avoid incorrect narrowing.
     // Skip adding [] if fieldType already contains array syntax (e.g., from identifier/extension union types)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelfhir-ts",
-  "version": "1.5.6",
+  "version": "1.5.7",
   "description": "BabelFHIR-TS: generate TypeScript interfaces, validators, and helper classes from FHIR R4/R4B/R5 StructureDefinitions (profiles) directly inside package archives.",
   "type": "module",
   "main": "out/src/main.js",