babelfhir-ts 1.2.2 → 1.2.3

package/out/src/generator/index.js

@@ -345,6 +345,9 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
             packageName = originalPkg.name || packageName;
             packageVersion = originalPkg.version || packageVersion;
         }
+        const generatedExports = {
+            '.': { types: './index.d.ts', import: './index.js' }
+        };
         const generatedPackageJson = {
             name: `${packageName}-generated`,
             version: packageVersion,
@@ -352,6 +355,7 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
             type: 'module',
             main: 'index.js',
             types: 'index.d.ts',
+            exports: generatedExports,
             scripts: {},
             keywords: ['fhir', 'typescript', 'generated'],
             license: 'MIT',
@@ -367,6 +371,7 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
         // When client is generated, add @babelfhir-ts/client-<version> as dependency (generated client extends base)
         if (!flags?.noClient) {
             generatedPackageJson.dependencies[`@babelfhir-ts/client-${versionSlug()}`] = '^0.2.0';
+            generatedExports['./fhir-client'] = { types: './fhir-client/index.d.ts', import: './fhir-client/index.js' };
         }
         // When zod schemas are generated, add @babelfhir-ts/zod-<version> + zod peer dependency
         if (flags?.schema === 'zod') {
@@ -458,6 +463,149 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
         }
     }
 }
+/**
+ * Generate TypeScript artefacts into a package but skip the intermediate archive
+ * round-trip. Returns the generated directory path and a cleanup callback.
+ * Used by the install command to avoid double tar operations.
+ */
+export async function generateIntoPackageDirect(packageArchivePath, flags) {
+    initGenerationContext(flags, path.dirname(packageArchivePath));
+    if (!packageArchivePath.endsWith('.tgz') && !packageArchivePath.endsWith('.zip'))
+        throw new Error('Only .tgz or .zip supported.');
+    const extractResult = await extractPackage(packageArchivePath);
+    const extractedRoot = extractResult.path;
+    const shouldCleanup = !extractResult.isCached;
+    // Auto-detect FHIR version from package when not explicitly set
+    if (!flags?.fhirVersion) {
+        const detected = detectFhirVersion(extractedRoot);
+        await initVersionContext(detected ?? DEFAULT_FHIR_VERSION);
+    }
+    else {
+        await initVersionContext(flags.fhirVersion);
+    }
+    const fhirInterfaceNames = ctx().interfaceNames;
+    const { getPackageManager } = await import('./parser/packageManager.js');
+    const packageManager = getPackageManager();
+    packageManager.loadDependenciesFromExtractedPackage(extractedRoot);
+    logger.log(`Loaded package dependencies (${packageManager.getTotalStructureDefinitionCount()} total SDs available)`);
+    const structureDefinitions = readStructureDefinitionsFromDir(extractedRoot);
+    await ensureDependenciesDownloaded(extractedRoot);
+    const valueSetCodesMap = readValueSetCodesWithDependencies(extractedRoot);
+    let valueSets = readValueSetsFromDir(extractedRoot);
+    logger.log(`Package contains ${structureDefinitions.length} StructureDefinitions.`);
+    logger.log(`Loaded ${Object.keys(valueSetCodesMap).length} ValueSet code mappings (including dependencies)`);
+    const bindingUrls = collectValueSetBindingUrls(structureDefinitions);
+    enrichValueSetsFromCodeMap(valueSets, valueSetCodesMap, bindingUrls);
+    if (flags?.txServer) {
+        valueSets = await expandValueSetsWithTx(valueSets, valueSetCodesMap, structureDefinitions, flags.txServer);
+    }
+    const outputDir = path.join(extractedRoot, 'generated');
+    ensureDirectoryExists(outputDir);
+    const didGenerateValueSets = emitValueSetFiles(valueSets, outputDir, { deduplicateFilenames: true });
+    if (!didGenerateValueSets)
+        cleanupStaleValueSetDir(outputDir);
+    const { existingStructureDefinitions, profileIdToName, profileUrlToName } = buildProfileRegistries(structureDefinitions, fhirInterfaceNames);
+    registerLocalStructureDefinitions(structureDefinitions);
+    const depSDs = readStructureDefinitionsFromDependencies(extractedRoot);
+    registerLocalStructureDefinitions(depSDs);
+    for (const sd of structureDefinitions) {
+        await processStructureDefinition(sd, { outputDir, fhirSourceHint: '', valueSetCodesMap, valueSets, existingStructureDefinitions, profileIdToName, profileUrlToName, flags });
+    }
+    // Create package.json in generated folder
+    const originalPackageJsonPath = path.join(extractedRoot, 'package', 'package.json');
+    let packageName = path.basename(packageArchivePath, path.extname(packageArchivePath));
+    let packageVersion = '1.0.0';
+    if (fs.existsSync(originalPackageJsonPath)) {
+        const originalPkg = JSON.parse(fs.readFileSync(originalPackageJsonPath, 'utf-8'));
+        packageName = originalPkg.name || packageName;
+        packageVersion = originalPkg.version || packageVersion;
+    }
+    const generatedExports = {
+        '.': { types: './index.d.ts', import: './index.js' }
+    };
+    const generatedPackageJson = {
+        name: `${packageName}-generated`,
+        version: packageVersion,
+        description: `Generated TypeScript interfaces for ${packageName}`,
+        type: 'module',
+        main: 'index.js',
+        types: 'index.d.ts',
+        exports: generatedExports,
+        scripts: {},
+        keywords: ['fhir', 'typescript', 'generated'],
+        license: 'MIT',
+        peerDependencies: { 'fhirpath': '^3.0.0 || ^4.0.0' },
+        dependencies: { '@types/fhir': '^0.0.41' }
+    };
+    if (!flags?.noClient) {
+        generatedPackageJson.dependencies[`@babelfhir-ts/client-${versionSlug()}`] = '^0.2.0';
+        generatedExports['./fhir-client'] = { types: './fhir-client/index.d.ts', import: './fhir-client/index.js' };
+    }
+    if (flags?.schema === 'zod') {
+        generatedPackageJson.dependencies[`@babelfhir-ts/zod-${versionSlug()}`] = '^0.1.0';
+        generatedPackageJson.peerDependencies['zod'] = '^4.0.0';
+    }
+    const generatedPackageJsonPath = path.join(outputDir, 'package.json');
+    fs.writeFileSync(generatedPackageJsonPath, JSON.stringify(generatedPackageJson, null, 2));
+    logger.log(`Created package.json in generated folder: ${packageName}-generated@${packageVersion}`);
+    copyFhirAmbientDeclaration(outputDir);
+    logger.log('Generating index.ts exports...');
+    await generateIndexFile(outputDir);
+    if (!flags?.noClient) {
+        logger.log('Generating FHIR client...');
+        const { generateClient } = await import('./emitters/client/clientGenerator.js');
+        generateClient({ outputDir });
+        logger.log('FHIR client generated');
+    }
+    if (flags?.schema === 'zod') {
+        const { installBaseZodTypes } = await import('./emitters/zod/zodStubInstaller.js');
+        installBaseZodTypes(outputDir);
+    }
+    const { installFhirpathStub, removeFhirpathStub } = await import('./emitters/validator/fhirpathStubInstaller.js');
+    installFhirpathStub(outputDir);
+    const nodeTypesDir = path.join(outputDir, 'node_modules', '@types', 'node');
+    fs.mkdirSync(nodeTypesDir, { recursive: true });
+    fs.writeFileSync(path.join(nodeTypesDir, 'index.d.ts'), `declare module 'module' {\n  export function createRequire(filename: string | URL): NodeRequire;\n}\n`);
+    fs.writeFileSync(path.join(nodeTypesDir, 'package.json'), JSON.stringify({ name: '@types/node', version: '0.0.0-stub', types: 'index.d.ts' }));
+    logger.log('Compiling TypeScript to JavaScript...');
+    await compileTypeScriptToJS(outputDir);
+    removeFhirpathStub(outputDir);
+    try {
+        fs.rmSync(path.join(outputDir, 'node_modules', '@types'), { recursive: true, force: true });
+    }
+    catch { /* ignore */ }
+    const babelfhirDir = path.join(outputDir, 'node_modules', '@babelfhir-ts');
+    if (fs.existsSync(babelfhirDir)) {
+        for (const entry of fs.readdirSync(babelfhirDir)) {
+            if (flags?.schema === 'zod' && entry.startsWith('zod-'))
+                continue;
+            try {
+                fs.rmSync(path.join(babelfhirDir, entry), { recursive: true, force: true });
+            }
+            catch { /* ignore */ }
+        }
+        try {
+            fs.rmdirSync(babelfhirDir);
+        }
+        catch { /* not empty — fine */ }
+    }
+    const nodeModulesDir = path.join(outputDir, 'node_modules');
+    try {
+        fs.rmdirSync(nodeModulesDir);
+    }
+    catch { /* not empty or doesn't exist — fine */ }
+    return {
+        generatedDir: outputDir,
+        cleanup: () => {
+            if (shouldCleanup) {
+                try {
+                    fs.rmSync(extractedRoot, { recursive: true, force: true });
+                }
+                catch { /* ignore */ }
+            }
+        }
+    };
+}
 function deriveOutputArchiveName(input) {
     const ext = input.endsWith('.tgz') ? '.tgz' : '.zip';
     return input.replace(ext, `.with-generated${ext}`);

package/out/src/generator/parser/packageParser.js

@@ -5,7 +5,7 @@ import unzipper from "unzipper";
 import { parseValueSet } from "./vsParser.js";
 import { logger } from "../../logger.js";
 import { getFhirPackagesCacheDir, ensureCacheDir } from "../core/cacheConfig.js";
-import { fetchArrayBuffer } from '../core/fetchUtils.js';
+import { downloadFile } from '../core/utils.js';
 import { versionSlug } from '../fhir/versionContext.js';
 /**
  * FHIR package registries in priority order.
@@ -451,7 +451,51 @@ export function readValueSetCodesFromDir(extractedRoot, codeSystemMap) {
  */
 export async function ensureDependenciesDownloaded(extractedRoot) {
     const cacheDir = getFhirPackagesCacheDir();
+    ensureCacheDir(cacheDir);
     const visited = new Set();
+    async function downloadAndExtract(depName, depVersion) {
+        const depDir = path.join(cacheDir, `${depName}@${depVersion}`);
+        // Already cached (@ separator)?
+        if (fs.existsSync(depDir) && fs.readdirSync(depDir).length > 0) {
+            return depDir;
+        }
+        // Already cached (# separator used by Java tooling)?
+        const altDir = path.join(cacheDir, `${depName}#${depVersion}`);
+        if (fs.existsSync(altDir) && fs.readdirSync(altDir).length > 0) {
+            return altDir;
+        }
+        // Download from registries (streaming to avoid buffering large packages in RAM)
+        log.info(`Downloading dependency: ${depName}@${depVersion}`);
+        const tgzPath = path.join(cacheDir, `${depName}-${depVersion}.tgz`);
+        let downloaded = false;
+        for (const registry of FHIR_REGISTRIES) {
+            const url = `${registry}/${depName}/${depVersion}`;
+            try {
+                await downloadFile(url, tgzPath);
+                downloaded = true;
+                break;
+            }
+            catch (err) {
+                log.debug(`Failed to download ${depName}@${depVersion} from ${registry}: ${err.message}`);
+            }
+        }
+        if (!downloaded) {
+            log.warn(`Could not download dependency ${depName}@${depVersion} from any registry`);
+            return null;
+        }
+        // Extract the downloaded package
+        fs.mkdirSync(depDir, { recursive: true });
+        try {
+            const { extract } = await import('tar');
+            await extract({ cwd: depDir, file: tgzPath });
+            log.info(`Cached dependency: ${depName}@${depVersion}`);
+            return depDir;
+        }
+        catch (err) {
+            log.warn(`Failed to extract ${depName}@${depVersion}: ${err.message}`);
+            return null;
+        }
+    }
     async function walkDeps(pkgDir) {
         const pkgDirNorm = path.normalize(pkgDir);
         if (visited.has(pkgDirNorm))
@@ -472,52 +516,16 @@ export async function ensureDependenciesDownloaded(extractedRoot) {
         catch {
             return;
         }
-        for (const [depName, depVersion] of Object.entries(deps)) {
-            const depDir = path.join(cacheDir, `${depName}@${depVersion}`);
-            // Already cached (@ separator)?
-            if (fs.existsSync(depDir) && fs.readdirSync(depDir).length > 0) {
-                await walkDeps(depDir);
-                continue;
-            }
-            // Already cached (# separator used by Java tooling)?
-            const altDir = path.join(cacheDir, `${depName}#${depVersion}`);
-            if (fs.existsSync(altDir) && fs.readdirSync(altDir).length > 0) {
-                await walkDeps(altDir);
-                continue;
-            }
-            // Download from registries
-            log.info(`Downloading dependency: ${depName}@${depVersion}`);
-            const tgzPath = path.join(cacheDir, `${depName}-${depVersion}.tgz`);
-            let downloaded = false;
-            for (const registry of FHIR_REGISTRIES) {
-                const url = `${registry}/${depName}/${depVersion}`;
-                try {
-                    const response = await fetchArrayBuffer(url);
-                    ensureCacheDir(cacheDir);
-                    fs.writeFileSync(tgzPath, Buffer.from(response.data));
-                    downloaded = true;
-                    break;
-                }
-                catch (err) {
-                    log.debug(`Failed to download ${depName}@${depVersion} from ${registry}: ${err.message}`);
-                }
-            }
-            if (!downloaded) {
-                log.warn(`Could not download dependency ${depName}@${depVersion} from any registry`);
-                continue;
-            }
-            // Extract the downloaded package
-            fs.mkdirSync(depDir, { recursive: true });
-            try {
-                const { extract } = await import('tar');
-                await extract({ cwd: depDir, file: tgzPath });
-                log.info(`Cached dependency: ${depName}@${depVersion}`);
-                await walkDeps(depDir);
-            }
-            catch (err) {
-                log.warn(`Failed to extract ${depName}@${depVersion}: ${err.message}`);
-            }
+        // Download all sibling dependencies in parallel
+        const depEntries = Object.entries(deps);
+        const results = await Promise.all(depEntries.map(([depName, depVersion]) => downloadAndExtract(depName, depVersion)));
+        // Recursively walk downloaded dependencies in parallel
+        const walkPromises = [];
+        for (const depDir of results) {
+            if (depDir)
+                walkPromises.push(walkDeps(depDir));
         }
+        await Promise.all(walkPromises);
     }
     await walkDeps(extractedRoot);
 }

package/package.json

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