babelfhir-ts 1.2.1 → 1.2.3

package/out/src/cli/installCommand.js

@@ -0,0 +1,176 @@
+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';
+import path from 'path';
+import { spawn } from 'child_process';
+/** Display all generation warnings (fetch failures, incomplete extension slices, etc.) */
+function showGenerationWarnings() {
+    let hasWarnings = false;
+    const fetchWarning = getFetchFailureWarning();
+    if (fetchWarning) {
+        console.warn(fetchWarning);
+        hasWarnings = true;
+    }
+    return hasWarnings;
+}
+function cleanupCache() {
+    const cacheConfig = getCacheConfig();
+    if (fs.existsSync(cacheConfig.rootDir)) {
+        console.log('Cleaning up cache directory...');
+        clearAllCaches();
+        console.log('Cache cleaned.');
+    }
+}
+/** Detect the package manager used in the current working directory */
+function detectPackageManager() {
+    const cwd = process.cwd();
+    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'] };
+    }
+    return { cmd: isWin ? 'npm.cmd' : 'npm', args: ['install'] };
+}
+function npmInstall(packagePath) {
+    return new Promise((resolve, reject) => {
+        const pm = detectPackageManager();
+        const pmName = path.basename(pm.cmd).replace(/\.(cmd|exe)$/, '');
+        // Check if the package already exists in package.json to avoid dependency loops.
+        const projectPkgPath = path.join(process.cwd(), 'package.json');
+        let useInstallOnly = false;
+        if (fs.existsSync(projectPkgPath)) {
+            try {
+                const tgzRelPath = './' + path.relative(process.cwd(), packagePath).replace(/\\/g, '/');
+                const projectPkg = JSON.parse(fs.readFileSync(projectPkgPath, 'utf8'));
+                const deps = projectPkg.dependencies || {};
+                for (const [name, value] of Object.entries(deps)) {
+                    if (typeof value === 'string' && (value === tgzRelPath || value === packagePath)) {
+                        console.log(`Package ${name} already in dependencies, running ${pmName} install`);
+                        useInstallOnly = true;
+                        break;
+                    }
+                }
+                if (!useInstallOnly) {
+                    const tgzBaseName = path.basename(packagePath, '.tgz').replace(/^-/, '');
+                    for (const name of Object.keys(deps)) {
+                        if (name.replace(/[@/]/g, '-') === tgzBaseName) {
+                            deps[name] = tgzRelPath;
+                            projectPkg.dependencies = deps;
+                            fs.writeFileSync(projectPkgPath, JSON.stringify(projectPkg, null, 2) + '\n');
+                            console.log(`Updated ${name} dependency to ${tgzRelPath}`);
+                            useInstallOnly = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            catch { /* ignore, fall through to normal add */ }
+        }
+        const args = useInstallOnly ? ['install'] : [...pm.args, packagePath];
+        console.log(`Installing package with ${pmName}...`);
+        const child = spawn(pm.cmd, args, {
+            stdio: 'inherit',
+            shell: true
+        });
+        child.on('exit', (code) => {
+            if (code === 0) {
+                console.log(`✓ Package installed successfully`);
+                resolve();
+            }
+            else {
+                reject(new Error(`${pmName} install failed with exit code ${code}`));
+            }
+        });
+        child.on('error', (err) => {
+            reject(new Error(`Failed to run ${pmName} install: ${err.message}`));
+        });
+    });
+}
+export async function handleInstallCommand(opts) {
+    const { packageToInstall, registry, generationFlags, downloadPackage } = opts;
+    // 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'))) {
+            console.log(`Using local package: ${packageToInstall}`);
+            downloadedPath = path.resolve(packageToInstall);
+        }
+        else {
+            downloadedPath = await downloadPackage(packageToInstall, registry);
+        }
+        console.log(`Processing package...`);
+        resetFetchFailureTracking();
+        resetDiagnostics();
+        // 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');
+            if (fs.existsSync(tempDir)) {
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            }
+        }
+        // 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}`);
+        }
+        const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+        const packageName = pkgJson.name;
+        console.log(`Creating package tarball for ${packageName}...`);
+        // Ensure ./lib exists for storing the generated tarball
+        const libDir = path.join(process.cwd(), 'lib');
+        if (!fs.existsSync(libDir)) {
+            fs.mkdirSync(libDir, { recursive: true });
+        }
+        const { create } = await import('tar');
+        const tarballName = `${packageName.replace(/[@/]/g, '-')}.tgz`;
+        const tarballPath = path.join(libDir, tarballName);
+        // npm expects tarballs to have content under a 'package/' root folder
+        await create({
+            gzip: true,
+            file: tarballPath,
+            cwd: generatedDir,
+            prefix: 'package'
+        }, ['.']);
+        console.log(`Installing ${packageName}...`);
+        await npmInstall(tarballPath);
+        // 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();
+        const summary = formatReportSummary(report);
+        if (summary.trim())
+            console.log(summary);
+        if (generationFlags.noCache) {
+            cleanupCache();
+        }
+        console.log(`\n✓ Package ${packageToInstall} installed and ready to use!`);
+    }
+    catch (error) {
+        // 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();
+        }
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}

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) {