babelfhir-ts 1.2.0 → 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/emitters/validator/validatorGenerator.js

@@ -5,7 +5,7 @@ import { versionSlug } from '../../fhir/versionContext.js';
 import { buildRequiredConstraints, buildMaxCardinalityConstraints, buildForbiddenFieldConstraintEntries, buildPatternValidations, } from './validatorConstraintBuilders.js';
 import { buildNestedRequiredValidations, buildFixedValueValidations, buildProhibitedFieldValidations, buildPrimitiveFormatValidations, } from './validatorFieldBuilders.js';
 import { buildBindingValidations } from './validatorBindingBuilder.js';
-import { generateBundleRefValidation, generateExtensionStructuralValidation } from './validatorTemplates.js';
+import { generateBundleRefValidation, generateContainedRefValidation, generateExtensionStructuralValidation } from './validatorTemplates.js';
 const log = logger.withTag('validator');
 /**
  * Returns the content of ValidatorOptions.ts — the shared runtime options type
@@ -146,6 +146,7 @@ export function generateValidateProfileFunction(interfaceName, fields, valueSets
     });
     const primitiveFormatValidations = buildPrimitiveFormatValidations(fields);
     const bundleRefValidation = generateBundleRefValidation(baseResourceType);
+    const containedRefValidation = generateContainedRefValidation(baseResourceType);
     const extensionStructuralValidation = generateExtensionStructuralValidation();
     // ── Deduplicate & filter constraints ────────────────────────────────────
     const uniqueConstraints = Array.from(new Map(constraintsWithContext.map((item) => [item.constraint.expression + "|" + item.fieldPath, item])).values());
@@ -229,7 +230,7 @@ export async function validate${interfaceName}(resource: ${interfaceName}, optio
   const errors: string[] = [];
   const warnings: string[] = [];
   void options;
-${extensionStructuralValidation}
+${extensionStructuralValidation}${containedRefValidation}
   return { errors, warnings };
 }`,
             valueSetImports
@@ -265,7 +266,7 @@ ${extensionStructuralValidation}
   const errors: string[] = [];
   const warnings: string[] = [];
   ${fhirpathOptionsBlock}
-  ${validationLogic}${fixedPatternValidations.join('')}${nestedRequiredValidations.join('')}${fixedValueValidations.join('')}${(bindingValidations.length > 0 || prohibitedFieldValidations.length > 0 || primitiveFormatValidations.length > 0) ? `\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const _bRes = resource as Record<string, any>;` : ''}${prohibitedFieldValidations.join('')}${bindingValidations.join('')}${primitiveFormatValidations.join('')}${sliceValidations.join('')}${extensionStructuralValidation}${bundleRefValidation}
+  ${validationLogic}${fixedPatternValidations.join('')}${nestedRequiredValidations.join('')}${fixedValueValidations.join('')}${(bindingValidations.length > 0 || prohibitedFieldValidations.length > 0 || primitiveFormatValidations.length > 0) ? `\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const _bRes = resource as Record<string, any>;` : ''}${prohibitedFieldValidations.join('')}${bindingValidations.join('')}${primitiveFormatValidations.join('')}${sliceValidations.join('')}${extensionStructuralValidation}${containedRefValidation}${bundleRefValidation}
   return { errors, warnings };
 }`,
         valueSetImports

package/out/src/generator/emitters/validator/validatorTemplates.js

@@ -31,7 +31,7 @@ export function generateBundleRefValidation(baseResourceType) {
         const ref = rec.reference as string;
         if (ref.startsWith('urn:uuid:') || ref.startsWith('urn:oid:')) {
           if (!_fullUrls.has(ref)) {
-            errors.push('Bundled or contained reference not found within the bundle/resource ' + ref);
+            errors.push('Bundle reference not found: ' + ref);
           }
         } else if (/^[A-Za-z]+\\//.test(ref)) {
           if (!_resIds.has(ref)) {
@@ -40,7 +40,7 @@ export function generateBundleRefValidation(baseResourceType) {
               if (_fu.endsWith('/' + ref) || _fu.endsWith(ref)) { _found = true; break; }
             }
             if (!_found) {
-              errors.push('Bundled or contained reference not found within the bundle/resource ' + ref);
+              errors.push('Bundle reference not found: ' + ref);
             }
           }
         }
@@ -56,6 +56,46 @@ export function generateBundleRefValidation(baseResourceType) {
   }
 `;
 }
+/**
+ * Generate standalone contained reference resolution validation code.
+ * For non-Bundle resources, verifies that #fragment references resolve to contained[] entries.
+ * Bundle validation is handled separately by generateBundleRefValidation.
+ */
+export function generateContainedRefValidation(baseResourceType) {
+    // Bundle resources have their own reference resolution check; skip them here
+    if (baseResourceType === 'Bundle')
+        return '';
+    return `
+  // Standalone contained reference resolution: verify #id references resolve to contained[] entries
+  {
+    const _res = resource as unknown as Record<string, unknown>;
+    const _containedIds = new Set<string>();
+    if (Array.isArray(_res.contained)) {
+      for (const _c of _res.contained as Array<Record<string, unknown>>) {
+        if (_c && typeof _c.id === 'string') _containedIds.add(_c.id);
+      }
+    }
+    const _checkContainedRef = (obj: unknown): void => {
+      if (!obj || typeof obj !== 'object') return;
+      if (Array.isArray(obj)) { obj.forEach(_checkContainedRef); return; }
+      const _rec = obj as Record<string, unknown>;
+      if (typeof _rec.reference === 'string') {
+        const _ref = _rec.reference as string;
+        if (_ref.startsWith('#')) {
+          const _id = _ref.substring(1);
+          if (_id && !_containedIds.has(_id)) {
+            errors.push('Contained reference not found: ' + _ref);
+          }
+        }
+      }
+      for (const [_k, _v] of Object.entries(_rec)) {
+        if (_k !== 'contained') _checkContainedRef(_v);
+      }
+    };
+    _checkContainedRef(_res);
+  }
+`;
+}
 /**
  * Generate extension structural validation code.
  * Checks extension.url required, ext-1 constraint, empty objects.

package/out/src/generator/index.js

@@ -1,7 +1,7 @@
 import path from 'path';
 import fs from 'fs';
 import { fileURLToPath } from 'url';
-import { extractPackage, readStructureDefinitionsFromDir, createPackageFromDir, readValueSetCodesWithDependencies, readValueSetsFromDir, detectFhirVersion, ensureDependenciesDownloaded } from './parser/packageParser.js';
+import { extractPackage, readStructureDefinitionsFromDir, readStructureDefinitionsFromDependencies, createPackageFromDir, readValueSetCodesWithDependencies, readValueSetsFromDir, detectFhirVersion, ensureDependenciesDownloaded } from './parser/packageParser.js';
 import { fetchStructureDefinitions, fetchStructureDefinition, registerLocalStructureDefinitions, clearLocalStructureDefinitions, collectValueSetBindingUrls } from './parser/sdParser.js';
 import { ensureDirectoryExists, downloadFile } from './core/utils.js';
 import { getFhirPackagesCacheDir } from './core/cacheConfig.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`],
@@ -235,6 +236,9 @@ export async function generate(fhirSource, outputDir, flags) {
             structureDefinitions = readStructureDefinitionsFromDir(extracted);
             // Ensure dependency packages are downloaded before loading ValueSets
             await ensureDependenciesDownloaded(extracted);
+            // Register SDs from dependency packages so external profile resolution can find them
+            const depSDs = readStructureDefinitionsFromDependencies(extracted);
+            registerLocalStructureDefinitions(depSDs);
             // Load ValueSets from package AND its dependencies (for binding resolution)
             valueSetCodesMap = readValueSetCodesWithDependencies(extracted);
             valueSets = readValueSetsFromDir(extracted);
@@ -326,6 +330,9 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
         const { existingStructureDefinitions, profileIdToName, profileUrlToName } = buildProfileRegistries(structureDefinitions, fhirInterfaceNames);
         // Register all local StructureDefinitions for resolution before HTTP fetches
         registerLocalStructureDefinitions(structureDefinitions);
+        // Register SDs from dependency packages so external profile resolution can find them
+        const depSDs = readStructureDefinitionsFromDependencies(extractedRoot);
+        registerLocalStructureDefinitions(depSDs);
         for (const sd of structureDefinitions) {
             await processStructureDefinition(sd, { outputDir, fhirSourceHint: '', valueSetCodesMap, valueSets, existingStructureDefinitions, profileIdToName, profileUrlToName, flags });
         }
@@ -390,11 +397,21 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
         // Install fhirpath type stub so tsc can resolve validator imports
         const { installFhirpathStub, removeFhirpathStub } = await import('./emitters/validator/fhirpathStubInstaller.js');
         installFhirpathStub(outputDir);
+        // Install minimal @types/node stub so tsc can resolve `import { createRequire } from 'module'`
+        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' }));
         // Compile TypeScript to JavaScript
         logger.log('Compiling TypeScript to JavaScript...');
         await compileTypeScriptToJS(outputDir);
         // Remove fhirpath stub — the real package is a peer dependency
         removeFhirpathStub(outputDir);
+        // Remove @types/node stub — only needed for compilation
+        try {
+            fs.rmSync(path.join(outputDir, 'node_modules', '@types'), { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
         // Remove base client type stubs — they were only needed for tsc to resolve
         // @babelfhir-ts/client-<version> imports during compilation. The real package is
         // installed by the consumer via npm.
@@ -467,6 +484,9 @@ export async function generateForDirectory(inputDir, outputDir, flags) {
     const valueSets = readValueSetsFromDir(inputDir);
     // Ensure dependency packages are downloaded before loading ValueSets
     await ensureDependenciesDownloaded(inputDir);
+    // Register SDs from dependency packages so external profile resolution can find them
+    const depSDs = readStructureDefinitionsFromDependencies(inputDir);
+    registerLocalStructureDefinitions(depSDs);
     const valueSetCodesMap = readValueSetCodesWithDependencies(inputDir);
     logger.log(`Loaded ${valueSets.size} ValueSets from ${inputDir} (${Array.from(valueSets.values()).filter(vs => vs.isSmall).length} suitable for union types)`);
     const entries = fs.readdirSync(inputDir);

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

@@ -521,6 +521,52 @@ export async function ensureDependenciesDownloaded(extractedRoot) {
     }
     await walkDeps(extractedRoot);
 }
+/**
+ * Reads StructureDefinitions from all dependency packages (recursively).
+ * Returns SDs from dependencies only — the main package SDs are loaded separately.
+ * This allows external profile resolution to find extension SDs from dependency packages
+ * (e.g., hl7.fhir.uv.extensions) without HTTP fetching.
+ */
+export function readStructureDefinitionsFromDependencies(extractedRoot) {
+    const cacheDir = getFhirPackagesCacheDir();
+    const visited = new Set();
+    const allSDs = [];
+    function walkDeps(pkgDir, isRoot) {
+        const pkgDirNorm = path.normalize(pkgDir);
+        if (visited.has(pkgDirNorm))
+            return;
+        visited.add(pkgDirNorm);
+        // Read SDs from this package (skip the root — those are loaded separately)
+        if (!isRoot) {
+            const sds = readStructureDefinitionsFromDir(pkgDir);
+            allSDs.push(...sds);
+        }
+        // Find package.json and recurse into dependencies
+        const packageJsonPath = path.join(pkgDir, 'package', 'package.json');
+        const altPath = path.join(pkgDir, 'package.json');
+        const pkgJsonPath = fs.existsSync(packageJsonPath) ? packageJsonPath
+            : fs.existsSync(altPath) ? altPath : null;
+        if (!pkgJsonPath)
+            return;
+        try {
+            const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+            const deps = pkgJson.dependencies || {};
+            for (const [depName, depVersion] of Object.entries(deps)) {
+                for (const sep of ['@', '#']) {
+                    const depDir = path.join(cacheDir, `${depName}${sep}${depVersion}`);
+                    if (fs.existsSync(depDir)) {
+                        walkDeps(depDir, false);
+                        break;
+                    }
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    walkDeps(extractedRoot, true);
+    log.info(`Loaded ${allSDs.length} StructureDefinitions from dependency packages`);
+    return allSDs;
+}
 /**
  * Reads ValueSet codes from a package and all its dependencies (recursively).
  * Looks for dependency packages in the FHIR package cache directory.

package/package.json

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