babelfhir-ts 1.2.2 → 1.2.4

package/out/src/cli/installCommand.js

@@ -1,4 +1,4 @@
-import { generateIntoPackage, resetFetchFailureTracking, getFetchFailureWarning } from "../generator/index.js";
+import { generateIntoPackageDirect, resetFetchFailureTracking, getFetchFailureWarning } from "../generator/index.js";
 import { getCacheConfig, clearAllCaches } from "../generator/core/cacheConfig.js";
 import { buildQualityReport, formatReportSummary, resetDiagnostics } from "../generator/core/sdDiagnostics.js";
 import fs from 'fs';
@@ -22,18 +22,29 @@ function cleanupCache() {
         console.log('Cache cleaned.');
     }
 }
-/** Detect the package manager used in the current working directory */
-function detectPackageManager() {
-    const cwd = process.cwd();
+/** Detect the package manager by walking up from startDir (default: cwd) to find a lock file */
+export function detectPackageManager(startDir) {
     const isWin = process.platform === 'win32';
-    if (fs.existsSync(path.join(cwd, 'bun.lock')) || fs.existsSync(path.join(cwd, 'bun.lockb'))) {
-        return { cmd: isWin ? 'bun.exe' : 'bun', args: ['add'] };
-    }
-    if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'))) {
-        return { cmd: isWin ? 'pnpm.cmd' : 'pnpm', args: ['add'] };
-    }
-    if (fs.existsSync(path.join(cwd, 'yarn.lock'))) {
-        return { cmd: isWin ? 'yarn.cmd' : 'yarn', args: ['add'] };
+    // Walk up the directory tree — in monorepos the lock file lives at the root,
+    // not in the package subdirectory where the command is run.
+    let dir = startDir ?? process.cwd();
+    while (true) {
+        if (fs.existsSync(path.join(dir, 'bun.lock')) || fs.existsSync(path.join(dir, 'bun.lockb'))) {
+            return { cmd: isWin ? 'bun.exe' : 'bun', args: ['add'] };
+        }
+        if (fs.existsSync(path.join(dir, 'pnpm-lock.yaml'))) {
+            return { cmd: isWin ? 'pnpm.cmd' : 'pnpm', args: ['add'] };
+        }
+        if (fs.existsSync(path.join(dir, 'yarn.lock'))) {
+            return { cmd: isWin ? 'yarn.cmd' : 'yarn', args: ['add'] };
+        }
+        if (fs.existsSync(path.join(dir, 'package-lock.json'))) {
+            return { cmd: isWin ? 'npm.cmd' : 'npm', args: ['install'] };
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break; // reached filesystem root
+        dir = parent;
     }
     return { cmd: isWin ? 'npm.cmd' : 'npm', args: ['install'] };
 }
@@ -94,10 +105,10 @@ function npmInstall(packagePath) {
 }
 export async function handleInstallCommand(opts) {
     const { packageToInstall, registry, generationFlags, downloadPackage } = opts;
-    // Default to cleaning cache for install command
-    if (!generationFlags.noCache) {
-        generationFlags.noCache = true;
-    }
+    // Keep cache by default — dependency packages are large (hl7.fhir.r4.core ~50 MB)
+    // and re-downloading them every run is the single biggest bottleneck.
+    // Users can opt in to cache cleanup with --no-cache.
+    let generationCleanup;
     try {
         let downloadedPath;
         if (fs.existsSync(packageToInstall) && (packageToInstall.endsWith('.tgz') || packageToInstall.endsWith('.zip'))) {
@@ -108,11 +119,11 @@ export async function handleInstallCommand(opts) {
             downloadedPath = await downloadPackage(packageToInstall, registry);
         }
         console.log(`Processing package...`);
-        const baseName = path.basename(downloadedPath, path.extname(downloadedPath));
-        const outputArchive = path.join(process.cwd(), `${baseName}.with-generated.tgz`);
         resetFetchFailureTracking();
         resetDiagnostics();
-        await generateIntoPackage(downloadedPath, outputArchive, generationFlags);
+        // Generate directly into extracted package — no intermediate archive round-trip
+        const { generatedDir, cleanup } = await generateIntoPackageDirect(downloadedPath, generationFlags);
+        generationCleanup = cleanup;
         // Clean up temp directory only if we downloaded from registry (not for local files)
         if (!fs.existsSync(packageToInstall) || !(packageToInstall.endsWith('.tgz') || packageToInstall.endsWith('.zip'))) {
             const tempDir = path.join(process.cwd(), '.temp-download');
@@ -120,29 +131,11 @@ export async function handleInstallCommand(opts) {
                 fs.rmSync(tempDir, { recursive: true, force: true });
             }
         }
-        console.log(`✓ Package processed successfully: ${path.basename(outputArchive)}`);
-        // Extract the archive to access generated folder
-        console.log(`Extracting generated code...`);
-        const { extract } = await import('tar');
-        const extractDir = path.join(process.cwd(), '.temp-install');
-        if (!fs.existsSync(extractDir)) {
-            fs.mkdirSync(extractDir, { recursive: true });
-        }
-        await extract({ cwd: extractDir, file: outputArchive });
-        // Look for generated folder - could be at root or under 'package' subfolder
-        let generatedDir = path.join(extractDir, 'generated');
-        if (!fs.existsSync(generatedDir)) {
-            generatedDir = path.join(extractDir, 'package', 'generated');
-        }
-        if (!fs.existsSync(generatedDir)) {
-            throw new Error('Generated folder not found in package archive');
-        }
-        // Verify package.json exists
+        // Verify package.json exists in generated folder
         const pkgJsonPath = path.join(generatedDir, 'package.json');
         if (!fs.existsSync(pkgJsonPath)) {
             throw new Error(`package.json not found in generated folder: ${generatedDir}`);
         }
-        // Create a tarball from the generated folder to avoid symlink issues on Windows
         const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
         const packageName = pkgJson.name;
         console.log(`Creating package tarball for ${packageName}...`);
@@ -163,15 +156,9 @@ export async function handleInstallCommand(opts) {
         }, ['.']);
         console.log(`Installing ${packageName}...`);
         await npmInstall(tarballPath);
-        // Clean up temporary files (but keep the tarball that npm references in package.json under ./lib)
-        console.log(`Cleaning up temporary files...`);
-        if (fs.existsSync(extractDir)) {
-            fs.rmSync(extractDir, { recursive: true, force: true });
-        }
-        if (fs.existsSync(outputArchive)) {
-            fs.unlinkSync(outputArchive);
-            console.log(`✓ Removed ${path.basename(outputArchive)}`);
-        }
+        // Clean up extracted package tree (but keep the tarball under ./lib)
+        generationCleanup();
+        generationCleanup = undefined;
         console.log(`✓ Package tarball saved to ./lib: ${path.basename(tarballPath)}`);
         showGenerationWarnings();
         const report = buildQualityReport();
@@ -184,20 +171,12 @@ export async function handleInstallCommand(opts) {
         console.log(`\n✓ Package ${packageToInstall} installed and ready to use!`);
     }
     catch (error) {
-        // Clean up temporary files on error
-        for (const dir of ['.temp-download', '.temp-install']) {
-            const fullPath = path.join(process.cwd(), dir);
-            if (fs.existsSync(fullPath)) {
-                fs.rmSync(fullPath, { recursive: true, force: true });
-            }
-        }
-        // Clean up any leftover archive
-        const baseName = packageToInstall.includes('@')
-            ? packageToInstall.replace('@', '-').replace(/\//g, '-')
-            : path.basename(packageToInstall, path.extname(packageToInstall));
-        const outputArchive = path.join(process.cwd(), `${baseName}.with-generated.tgz`);
-        if (fs.existsSync(outputArchive)) {
-            fs.unlinkSync(outputArchive);
+        // Clean up extracted package on error
+        generationCleanup?.();
+        // Clean up temp download directory
+        const tempDir = path.join(process.cwd(), '.temp-download');
+        if (fs.existsSync(tempDir)) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
         }
         if (generationFlags.noCache) {
             cleanupCache();

package/out/src/generator/core/utils.js

@@ -44,6 +44,25 @@ export function capitalize(str) {
         return str;
     return str.charAt(0).toUpperCase() + str.slice(1);
 }
+/**
+ * Extract base FHIR types from all interface declarations in a file.
+ * Handles:
+ *   - `export interface Foo extends Bar { ... }`
+ *   - `export interface Foo extends Omit<Bar, 'a' | 'b'> { ... }`
+ * Returns ALL candidates — files may have nested types (e.g.,
+ * AllergyIntoleranceReaction) before the main resource interface.
+ */
+function extractBaseTypes(content) {
+    const results = [];
+    const allMatches = [...content.matchAll(/export\s+interface\s+\w+\s+extends\s+(?:Omit|Pick|Partial)<(\w+)|export\s+interface\s+\w+\s+extends\s+(\w+)/g)];
+    for (const m of allMatches) {
+        const candidate = m[1] ?? m[2];
+        if (candidate && candidate !== 'Omit' && candidate !== 'Pick' && candidate !== 'Partial') {
+            results.push(candidate);
+        }
+    }
+    return results;
+}
 export function getResourceTypes(options) {
     const outputDir = options.outputDir;
     if (!fs.existsSync(outputDir)) {
@@ -51,40 +70,44 @@ export function getResourceTypes(options) {
     }
     const files = fs.readdirSync(outputDir);
     const resourceTypes = new Map(); // Maps profile name -> base resource type
-    // Check if index.ts exists
-    const indexPath = path.join(outputDir, "index.ts");
+    // Check if index.ts (or index.d.ts after compilation) exists
+    const indexPath = fs.existsSync(path.join(outputDir, "index.ts"))
+        ? path.join(outputDir, "index.ts")
+        : fs.existsSync(path.join(outputDir, "index.d.ts"))
+            ? path.join(outputDir, "index.d.ts")
+            : null;
     let exportedTypes = null;
-    if (fs.existsSync(indexPath)) {
+    if (indexPath) {
         const indexContent = fs.readFileSync(indexPath, "utf-8");
         exportedTypes = new Set();
-        // Extract exported type names from index.ts
-        const exportRegex = /export \* from ['"]\.\/([\w-]+)\.js['"]/g;
+        // Extract module names from export statements (both wildcard and named)
+        const exportRegex = /export\s+(?:\*|{[^}]+})\s+from\s+['"]\.\/([\w-]+)\.js['"]/g;
         let match;
         while ((match = exportRegex.exec(indexContent)) !== null) {
             exportedTypes.add(match[1]);
         }
     }
     for (const file of files) {
-        if (file.endsWith("Class.ts")) {
-            const profileName = file.replace("Class.ts", "");
-            if (!exportedTypes || exportedTypes.has(profileName)) {
+        if (file.endsWith("Class.ts") || file.endsWith("Class.d.ts")) {
+            const profileName = file.replace(/Class\.(ts|d\.ts)$/, "");
+            if (!exportedTypes || exportedTypes.has(profileName) || exportedTypes.has(`${profileName}Class`)) {
                 const interfaceFile = path.join(outputDir, `${profileName}.ts`);
-                if (fs.existsSync(interfaceFile)) {
-                    const content = fs.readFileSync(interfaceFile, "utf-8");
+                const interfaceDtsFile = path.join(outputDir, `${profileName}.d.ts`);
+                const actualFile = fs.existsSync(interfaceFile) ? interfaceFile : fs.existsSync(interfaceDtsFile) ? interfaceDtsFile : null;
+                if (actualFile) {
+                    const content = fs.readFileSync(actualFile, "utf-8");
                     // Check if it has resourceType property (base resource)
                     const resourceTypeMatch = content.match(/resourceType:\s*["'](\w+)["']/);
                     if (resourceTypeMatch) {
                         resourceTypes.set(profileName, resourceTypeMatch[1]);
                         continue;
                     }
-                    // Check if it extends a FHIR resource
-                    const extendsMatch = content.match(/export\s+interface\s+\w+\s+extends\s+(\w+)/);
-                    if (extendsMatch) {
-                        const baseType = extendsMatch[1];
-                        // Check if it's a known FHIR resource type
-                        if (ctx().resourceNames.includes(baseType)) {
-                            resourceTypes.set(profileName, baseType);
-                        }
+                    // Check if it extends a FHIR resource (handles both `extends Foo` and `extends Omit<Foo, ...>`)
+                    // Try all interface declarations — files may contain nested types before the main resource.
+                    const baseTypes = extractBaseTypes(content);
+                    const knownBase = baseTypes.find(bt => ctx().resourceNames.includes(bt));
+                    if (knownBase) {
+                        resourceTypes.set(profileName, knownBase);
                     }
                 }
             }
@@ -94,19 +117,22 @@ export function getResourceTypes(options) {
 }
 export function getBaseResourceType(profileName, outputDir) {
     const interfaceFile = path.join(outputDir, `${profileName}.ts`);
-    if (!fs.existsSync(interfaceFile)) {
+    const interfaceDtsFile = path.join(outputDir, `${profileName}.d.ts`);
+    const actualFile = fs.existsSync(interfaceFile) ? interfaceFile : fs.existsSync(interfaceDtsFile) ? interfaceDtsFile : null;
+    if (!actualFile) {
         return profileName; // fallback
     }
-    const content = fs.readFileSync(interfaceFile, "utf-8");
+    const content = fs.readFileSync(actualFile, "utf-8");
     // Check for explicit resourceType property
     const resourceTypeMatch = content.match(/resourceType:\s*["'](\w+)["']/);
     if (resourceTypeMatch) {
         return resourceTypeMatch[1];
     }
-    // Check for extends clause
-    const extendsMatch = content.match(/export\s+interface\s+\w+\s+extends\s+(\w+)/);
-    if (extendsMatch) {
-        return extendsMatch[1];
+    // Check for extends clause (handles both `extends Foo` and `extends Omit<Foo, ...>`)
+    const baseTypes = extractBaseTypes(content);
+    if (baseTypes.length > 0) {
+        // Prefer a known resource type, fall back to the first candidate
+        return baseTypes.find(bt => ctx().resourceNames.includes(bt)) ?? baseTypes[0];
     }
     return profileName; // fallback
 }

package/out/src/generator/fhir/corePackageResolver.js

@@ -13,7 +13,7 @@
 import fs from 'fs';
 import path from 'path';
 import { getFhirPackagesCacheDir, ensureCacheDir } from '../core/cacheConfig.js';
-import { fetchArrayBuffer } from '../core/fetchUtils.js';
+import { downloadFile } from '../core/utils.js';
 import { logger } from '../../logger.js';
 const log = logger.withTag('core-resolver');
 /**
@@ -58,7 +58,7 @@ export async function ensureCorePackage(corePackageSpec) {
             return candidate;
         }
     }
-    // Not cached — download from registry
+    // Not cached — download from registry (streaming to avoid buffering large packages in RAM)
     ensureCacheDir(configuredCacheDir);
     const packageDir = path.join(configuredCacheDir, dirName);
     let downloaded = false;
@@ -67,8 +67,7 @@ export async function ensureCorePackage(corePackageSpec) {
         const url = `${registry}/${packageName}/${version}`;
         try {
             log.info(`Downloading core package ${corePackageSpec} from ${registry}…`);
-            const response = await fetchArrayBuffer(url);
-            fs.writeFileSync(tgzPath, Buffer.from(response.data));
+            await downloadFile(url, tgzPath);
             downloaded = true;
             break;
         }

package/out/src/generator/fhir/corePackageResolver.ts

@@ -14,7 +14,7 @@
 import fs from 'fs';
 import path from 'path';
 import { getFhirPackagesCacheDir, ensureCacheDir } from '../core/cacheConfig.js';
-import { fetchArrayBuffer } from '../core/fetchUtils.js';
+import { downloadFile } from '../core/utils.js';
 import { logger } from '../../logger.js';
 
 const log = logger.withTag('core-resolver');
@@ -88,7 +88,7 @@ export async function ensureCorePackage(corePackageSpec: string): Promise<string
     }
   }
 
-  // Not cached — download from registry
+  // Not cached — download from registry (streaming to avoid buffering large packages in RAM)
   ensureCacheDir(configuredCacheDir);
   const packageDir = path.join(configuredCacheDir, dirName);
 
@@ -98,8 +98,7 @@ export async function ensureCorePackage(corePackageSpec: string): Promise<string
     const url = `${registry}/${packageName}/${version}`;
     try {
       log.info(`Downloading core package ${corePackageSpec} from ${registry}…`);
-      const response = await fetchArrayBuffer(url);
-      fs.writeFileSync(tgzPath, Buffer.from(response.data));
+      await downloadFile(url, tgzPath);
       downloaded = true;
       break;
     } catch (err) {