fix: install @types/node stub for tsc compilation + add contained ref validation

- Install minimal @types/node stub (declares 'module' built-in) before tsc
  compilation so generated Class files using createRequire() compile without
  TS2591 errors. Stub is removed after compilation.

- Add generateContainedRefValidation() for standalone (non-Bundle) resources:
  verifies #fragment references resolve against Resource.contained[] entries.
  Uses same error message as HL7 validator for parity.

- Wire containedRefValidation into both hasConstraints and no-constraints
  output paths (same pattern as extensionStructuralValidation).

- Update validatorGaps test to expect contained ref check on non-Bundle types
  while still verifying Bundle-specific logic (fullUrls, urn:uuid) is absent.

Closes #54

Author: quotentiroler

src/generator/emitters/validator/validatorGenerator.ts

@@ -18,7 +18,7 @@ import {
   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');
 
@@ -180,6 +180,7 @@ export function generateValidateProfileFunction(
   });
   const primitiveFormatValidations = buildPrimitiveFormatValidations(fields);
   const bundleRefValidation = generateBundleRefValidation(baseResourceType);
+  const containedRefValidation = generateContainedRefValidation(baseResourceType);
   const extensionStructuralValidation = generateExtensionStructuralValidation();
 
   // ── Deduplicate & filter constraints ────────────────────────────────────
@@ -274,7 +275,7 @@ export async function validate${interfaceName}(resource: ${interfaceName}, optio
   const errors: string[] = [];
   const warnings: string[] = [];
   void options;
-${extensionStructuralValidation}
+${extensionStructuralValidation}${containedRefValidation}
   return { errors, warnings };
 }`,
       valueSetImports
@@ -323,7 +324,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

src/generator/emitters/validator/validatorTemplates.ts

@@ -56,6 +56,46 @@ export function generateBundleRefValidation(baseResourceType: string | undefined
 `;
 }
 
+/**
+ * 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: string | undefined): string {
+  // 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('Bundled or contained reference not found within the bundle/resource ' + _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.

src/generator/index.ts

@@ -423,13 +423,24 @@ export async function generateIntoPackage(packageArchivePath: string, outArchive
     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.

src/test/validatorGaps.test.ts

@@ -476,7 +476,11 @@ describe('validatorGenerator gaps', () => {
       ];
       const code = generateCode('TestPatient', fields, { baseResourceType: 'Patient' });
 
-      expect(code).not.toContain('Bundled or contained reference not found');
+      // Non-Bundle types should not have the Bundle-specific entry/fullUrl resolution logic
+      expect(code).not.toContain('_fullUrls');
+      expect(code).not.toContain('urn:uuid:');
+      // But they SHOULD have standalone contained reference resolution (#id checks)
+      expect(code).toContain('_checkContainedRef');
     });
   });