babelfhir-ts 1.2.0 → 1.2.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';
@@ -235,6 +235,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 +329,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 +396,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 +483,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.1",
   "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",