babelfhir-ts 1.2.1 → 1.2.2

package/out/src/cli/installCommand.js

@@ -0,0 +1,208 @@
+import { generateIntoPackage, 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;
+    // Default to cleaning cache for install command
+    if (!generationFlags.noCache) {
+        generationFlags.noCache = true;
+    }
+    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...`);
+        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);
+        // 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 });
+            }
+        }
+        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
+        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}...`);
+        // 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 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)}`);
+        }
+        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 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);
+        }
+        if (generationFlags.noCache) {
+            cleanupCache();
+        }
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}

package/out/src/generator/index.js

@@ -65,6 +65,7 @@ async function compileTypeScriptToJS(dir) {
                 allowSyntheticDefaultImports: true,
                 strict: false,
                 resolveJsonModule: true,
+                typeRoots: [path.join(dir, 'node_modules', '@types')],
                 types: ['node']
             },
             include: [`${dir}/**/*.ts`],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelfhir-ts",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "BabelFHIR-TS: generate TypeScript interfaces, validators, and helper classes from FHIR R4/R4B StructureDefinitions (profiles) directly inside package archives.",
   "type": "module",
   "main": "out/src/main.js",
@@ -9,6 +9,7 @@
   },
   "files": [
     "out/src/generator/",
+    "out/src/cli/",
     "out/src/main.js",
     "out/src/logger.js",
     "out/fhir-r4.d.ts",