babelfhir-ts 1.5.5 → 1.5.7

package/out/src/cli/installCommand.js

@@ -125,47 +125,53 @@ function npmInstall(packagePath) {
     });
 }
 /**
- * Bun caches extracted tgz content in `node_modules/.bun/<pkg>@<path-hash>/`.
- * The cache key is derived from the file *path*, not its content, so replacing a
- * tgz at the same path silently serves stale content — even with `--force`.
- * This function removes those cache entries so the next `bun add` re-extracts.
- * In monorepos the .bun cache lives at the workspace root, not in the app subdir,
- * so we walk up the directory tree to find it (same as detectPackageManager).
- * No-op when bun is not the package manager or no .bun cache dir is found.
+ * Bust stale bun cache entries for a local-tarball dependency.
+ *
+ * Bun caches extracted tgz content keyed by file *path*, not content hash.
+ * Replacing a tgz at the same path silently serves stale content — even with
+ * `--force`.  Two cache locations are relevant:
+ *
+ * 1. **node_modules/.bun/** (bun ≥ 1.1) — per-project extraction cache.
+ * 2. **node_modules/<packageName>/** — the already-installed copy.  When we run
+ *    `bun install` (bare, dep already in package.json) bun skips re-extraction
+ *    if the directory already exists, regardless of whether the underlying tgz
+ *    changed.
+ *
+ * We walk up the directory tree (monorepo-safe) to find both locations and
+ * remove matching entries so the next install re-extracts the fresh tarball.
+ *
+ * No-op when bun is not the package manager.
  */
 function clearBunCache(packageName) {
     const pm = detectPackageManager();
     if (!pm.cmd.includes('bun'))
         return;
-    // Walk up to find node_modules/.bun — in monorepos it's at the workspace root.
-    let bunCacheDir = null;
     let dir = process.cwd();
     while (true) {
-        const candidate = path.join(dir, 'node_modules', '.bun');
-        if (fs.existsSync(candidate)) {
-            bunCacheDir = candidate;
-            break;
+        const nodeModules = path.join(dir, 'node_modules');
+        // (1) Remove .bun/<pkg>@… extraction cache (bun ≥ 1.1)
+        const bunCacheDir = path.join(nodeModules, '.bun');
+        if (fs.existsSync(bunCacheDir)) {
+            const prefix = `${packageName}@`;
+            for (const entry of fs.readdirSync(bunCacheDir, { withFileTypes: true })) {
+                if (entry.isDirectory() && entry.name.startsWith(prefix)) {
+                    fs.rmSync(path.join(bunCacheDir, entry.name), { recursive: true, force: true });
+                }
+            }
+        }
+        // (2) Remove the already-installed node_modules/<pkg> directory.
+        // Without this, `bun install` (bare) sees the existing directory and
+        // skips re-extraction even though the tarball content has changed.
+        const installedDir = path.join(nodeModules, packageName);
+        if (fs.existsSync(installedDir)) {
+            fs.rmSync(installedDir, { recursive: true, force: true });
+            console.log(`Cleared stale node_modules/${packageName} for re-extraction`);
         }
         const parent = path.dirname(dir);
         if (parent === dir)
             break;
         dir = parent;
     }
-    if (!bunCacheDir)
-        return;
-    // Entries look like: <pkg>@<encoded-path>+<hash>
-    // The package name may contain dots/scopes — match by startsWith.
-    const prefix = `${packageName}@`;
-    let removed = 0;
-    for (const entry of fs.readdirSync(bunCacheDir, { withFileTypes: true })) {
-        if (entry.isDirectory() && entry.name.startsWith(prefix)) {
-            fs.rmSync(path.join(bunCacheDir, entry.name), { recursive: true, force: true });
-            removed++;
-        }
-    }
-    if (removed > 0) {
-        console.log(`Cleared ${removed} stale bun cache entr${removed === 1 ? 'y' : 'ies'} for ${packageName}`);
-    }
 }
 export async function handleInstallCommand(opts) {
     const { packageToInstall, registry, generationFlags, downloadPackage } = opts;

package/out/src/cli/updateCommand.js

@@ -405,7 +405,9 @@ function clearBunCacheForPackage(packageName) {
         return;
     let dir = process.cwd();
     while (true) {
-        const candidate = path.join(dir, 'node_modules', '.bun');
+        const nm = path.join(dir, 'node_modules');
+        // Remove .bun/<pkg>@… extraction cache (bun ≥ 1.1)
+        const candidate = path.join(nm, '.bun');
         if (fs.existsSync(candidate)) {
             const prefix = `${packageName}@`;
             for (const entry of fs.readdirSync(candidate, { withFileTypes: true })) {
@@ -413,7 +415,11 @@ function clearBunCacheForPackage(packageName) {
                     fs.rmSync(path.join(candidate, entry.name), { recursive: true, force: true });
                 }
             }
-            break;
+        }
+        // Remove the installed node_modules/<pkg> directory so bun re-extracts
+        const installedDir = path.join(nm, packageName);
+        if (fs.existsSync(installedDir)) {
+            fs.rmSync(installedDir, { recursive: true, force: true });
         }
         const parent = path.dirname(dir);
         if (parent === dir)

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.5",
+  "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",