babelfhir-ts 1.5.4 → 1.5.6

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

@@ -70,7 +70,7 @@ export function generateBackboneSliceTypes(ctx) {
                 return childId.startsWith(sliceElementId + '.');
             });
             // Build interface body lines from slice children and the slice's own constraints
-            const { lines: bodyLines, referencedFhirTypes } = buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, backboneType);
+            const { lines: bodyLines, referencedFhirTypes } = buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, backboneType, baseFields, parentField.name);
             if (bodyLines.length === 0) {
                 // No constrainable properties — skip this slice interface
                 log.debug(`No constraints for slice ${sliceName} of ${parentField.name}, skipping`);
@@ -197,7 +197,7 @@ function gatherChildFields(fields, path) {
 /**
  * Build the body lines for a slice-specific interface.
  */
-function buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, _backboneType) {
+function buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, _backboneType, baseFields, parentPath) {
     const lines = [];
     const referencedFhirTypes = [];
     // Add pattern constraint from the slice field itself (discriminator value)
@@ -211,16 +211,58 @@ function buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, _bac
             }
         }
     }
-    // Process direct children of the slice
+    // Pre-scan: identify choice-type parent elements (value[x]) that have
+    // sub-slices (value[x]:valueQuantity, etc.). These parents carry only slicing
+    // metadata and should not be emitted as typed properties.
+    // Match only direct choice-type slices like "value[x]:valueString" — NOT deeper
+    // elements like "value[x].extension:questionnaireDisplay" where the colon is
+    // on a different segment.
+    const choiceTypeParents = new Set();
+    const choiceTypeSlices = [];
+    const choiceSlicePattern = /^([^.]+\[x]):([^.]+)$/; // e.g. "value[x]:valueString"
     for (const child of sliceChildren) {
         const childId = child.elementId || child.name;
         const relativePath = childId.substring(sliceElementId.length + 1);
-        // Only handle direct children (no dots in relative path)
-        if (relativePath.includes('.'))
+        const match = choiceSlicePattern.exec(relativePath);
+        if (match) {
+            choiceTypeSlices.push(child);
+            choiceTypeParents.add(match[1]); // e.g. "value[x]"
+        }
+    }
+    // Collect deeply nested fixed values for object literal synthesis.
+    // e.g. code.coding.code = "confidence" → code: { coding: [{ code: "confidence" }] }
+    const nestedFixedByProp = new Map();
+    // Process children of the slice
+    for (const child of sliceChildren) {
+        const childId = child.elementId || child.name;
+        const relativePath = childId.substring(sliceElementId.length + 1);
+        // Nested children (dots in relative path) — collect fixed values for synthesis
+        if (relativePath.includes('.')) {
+            if (child.fixedValue !== undefined) {
+                const segments = relativePath.split('.');
+                const rawPropName = segments[0];
+                const propName = rawPropName.replace(/\[x\]$/, '');
+                // Skip nested values under:
+                // - choice-type elements ([x]) — handled by direct child or sub-slices
+                // - slice notation (part:LineItem.name) — deeper-level constraints
+                // - extension/modifierExtension — handled by postProcessExtensions
+                if (!rawPropName.includes('[x]') && !rawPropName.includes(':')
+                    && propName !== 'extension' && propName !== 'modifierExtension') {
+                    const nestedPath = segments.slice(1).join('.');
+                    if (!nestedFixedByProp.has(propName))
+                        nestedFixedByProp.set(propName, new Map());
+                    nestedFixedByProp.get(propName).set(nestedPath, String(child.fixedValue));
+                }
+            }
             continue;
-        // Skip slice notation in child paths
+        }
+        // Choice-type sub-slices (value[x]:valueXxx) are processed separately below
         if (relativePath.includes(':'))
             continue;
+        // Skip choice-type parents that have sub-slices — they carry only slicing
+        // metadata and their inherited type (e.g. Quantity) is misleading
+        if (choiceTypeParents.has(relativePath))
+            continue;
         const propName = relativePath.replace(/\[x\]$/, '');
         if (child.fixedValue !== undefined) {
             // Fixed value constraint
@@ -270,6 +312,43 @@ function buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, _bac
             }
         }
     }
+    // Emit choice-type sub-slice properties (e.g. value[x]:valueQuantity → valueQuantity: Quantity)
+    for (const child of choiceTypeSlices) {
+        if (!child.sliceName || !child.type)
+            continue;
+        if (child.type === 'BackboneElement' || child.type === 'Element' || child.type === 'any')
+            continue;
+        const rawType = getRules().mapTypeToTS(child.type);
+        const mappedType = sanitizeIdentifier(rawType);
+        if (mappedType !== rawType && child.isProfiled)
+            continue;
+        const optMark = child.isOptional ? '?' : '';
+        lines.push(`${child.sliceName}${optMark}: ${mappedType};`);
+        if (getRules().isFhirType(mappedType)) {
+            referencedFhirTypes.push(mappedType);
+        }
+    }
+    // Emit synthesized nested object literals from deeply nested fixed values.
+    // Skip properties already emitted by the direct child or choice-type loops
+    // to prevent TS2717 (duplicate property) and TS2430 (incompatible extends).
+    const emittedProps = new Set(lines.map(l => l.match(/^(\w+)[?]?:/)?.[1]).filter(Boolean));
+    for (const [propName, paths] of nestedFixedByProp) {
+        if (emittedProps.has(propName))
+            continue;
+        // Check if this property is an array — look in both slice children and
+        // base fields. Synthesized literals for array properties need wrapping
+        // in [] to avoid TS2430 (incompatible extends).
+        const propFullPath = `${parentPath}.${propName}`;
+        const isArrayProp = sliceChildren.some(c => {
+            const cId = c.elementId || c.name;
+            const rel = cId.substring(sliceElementId.length + 1);
+            return rel === propName && c.isArray;
+        }) || baseFields.some(f => f.name === propFullPath && f.isArray);
+        const literal = synthesizeNestedLiteral(paths);
+        if (literal) {
+            lines.push(`${propName}: ${isArrayProp ? `[${literal}]` : literal};`);
+        }
+    }
     return { lines, referencedFhirTypes };
 }
 /**
@@ -294,6 +373,39 @@ function formatCodingLiteral(codings) {
         return null;
     return `[${entries.join(', ')}]`;
 }
+/**
+ * Synthesize a nested object literal from deeply nested fixed values.
+ *
+ * Given a map of nested paths → values (e.g. { "coding.code" → "confidence" }),
+ * produces an object literal like `{ coding: [{ code: "confidence" }] }`.
+ *
+ * Special handling: `coding` segments are wrapped in array brackets because
+ * `CodeableConcept.coding` is always an array in FHIR.
+ */
+function synthesizeNestedLiteral(paths) {
+    const codingFields = new Map();
+    const scalarFields = [];
+    for (const [path, value] of paths) {
+        if (path.startsWith('coding.')) {
+            codingFields.set(path.substring('coding.'.length), value);
+        }
+        else if (!path.includes('.')) {
+            scalarFields.push([path, value]);
+        }
+        // Deeper nesting (3+ levels) is uncommon; skip gracefully
+    }
+    const parts = [];
+    if (codingFields.size > 0) {
+        const codingParts = [...codingFields.entries()].map(([k, v]) => `${k}: "${v}"`);
+        parts.push(`coding: [{ ${codingParts.join('; ')} }]`);
+    }
+    for (const [field, value] of scalarFields) {
+        parts.push(`${field}: "${value}"`);
+    }
+    if (parts.length === 0)
+        return null;
+    return `{ ${parts.join('; ')} }`;
+}
 /**
  * Update the root interface to use the union type for a sliced backbone field.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelfhir-ts",
-  "version": "1.5.4",
+  "version": "1.5.6",
   "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",