babelfhir-ts 1.0.31 → 1.0.32

package/out/generator/index.js

@@ -7,7 +7,6 @@ import { extractPackage, readStructureDefinitionsFromDir, createPackageFromDir,
 import { fetchStructureDefinitions, parseStructureDefinition, fetchStructureDefinition, registerLocalStructureDefinitions, buildFhirChildTypeMap } from './sdParser.js';
 import { writeInterfaceAndValidatorToFile, mergeFields, alignFields, ensureDirectoryExists, writeToFile, getBaseResource, downloadFile, sanitizeIdentifier, toPascalCase } from './utils.js';
 import { generateValidateProfileFunction } from './validatorGenerator.js';
-import { loadExamplesFromPackage, generateTestFile } from './testGenerator.js';
 import { generateValueSetTypeScript, generateValueSetRegistry } from './valueSetGenerator.js';
 import { generateRandomSupportContent } from './randomSupportGenerator.js';
 import { logger } from '../logger.js';
@@ -177,7 +176,7 @@ async function generateIndexFile(dir) {
 }
 // Reusable processor for a single StructureDefinition
 async function processStructureDefinition(sd, ctx) {
-    const { outputDir, fhirSourceHint, valueSetCodesMap, valueSets, examplesMap, existingStructureDefinitions, profileIdToName, profileUrlToName, flags, fhirChildTypeMap } = ctx;
+    const { outputDir, fhirSourceHint, valueSetCodesMap, valueSets, existingStructureDefinitions, profileIdToName, profileUrlToName, flags, fhirChildTypeMap } = ctx;
     const rawInterfaceName = sd.name || sd.id || 'UnnamedInterface';
     let interfaceName = toPascalCase(rawInterfaceName);
     // Check if the interface name conflicts with a FHIR base type
@@ -234,7 +233,7 @@ async function processStructureDefinition(sd, ctx) {
         if (externalSD) {
             try {
                 logger.log(`Processing external profile as StructureDefinition: ${normalizedTypeName}`);
-                const actualInterfaceName = await processStructureDefinition(externalSD, { outputDir, fhirSourceHint: profileInfo.profileUrl, valueSetCodesMap, valueSets, examplesMap, existingStructureDefinitions, profileIdToName, profileUrlToName, flags, fhirChildTypeMap });
+                const actualInterfaceName = await processStructureDefinition(externalSD, { outputDir, fhirSourceHint: profileInfo.profileUrl, valueSetCodesMap, valueSets, existingStructureDefinitions, profileIdToName, profileUrlToName, flags, fhirChildTypeMap });
                 // If the actual generated interface name differs from what we expected,
                 // add a mapping so other profiles can find it
                 if (actualInterfaceName !== normalizedTypeName) {
@@ -402,10 +401,6 @@ async function processStructureDefinition(sd, ctx) {
     // Only generate class files if --no-classes flag is not set
     if (!flags?.noClasses) {
         writeToFile(path.join(outputDir, `${interfaceName}Class.ts`), classContent);
-        if (examplesMap && examplesMap[interfaceName]) {
-            const { valid, invalid } = examplesMap[interfaceName];
-            generateTestFile(outputDir, interfaceName, valid, invalid);
-        }
     }
     console.log(`Generated artifacts for ${interfaceName}`);
     return interfaceName;
@@ -482,9 +477,8 @@ export async function generate(fhirSource, outputDir, flags) {
         }
     }
     logger.log(`Profile registries pre-populated: ${profileUrlToName.size} URLs, ${profileIdToName.size} IDs`);
-    const examples = loadExamplesFromPackage(fhirSource);
     for (const sd of structureDefinitions) {
-        await processStructureDefinition(sd, { outputDir, fhirSourceHint: fhirSource, valueSetCodesMap, valueSets, examplesMap: examples, existingStructureDefinitions, profileIdToName, profileUrlToName, flags, fhirChildTypeMap });
+        await processStructureDefinition(sd, { outputDir, fhirSourceHint: fhirSource, valueSetCodesMap, valueSets, existingStructureDefinitions, profileIdToName, profileUrlToName, flags, fhirChildTypeMap });
     }
 }
 /**
@@ -585,9 +579,8 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
         logger.log(`Profile registries pre-populated: ${profileUrlToName.size} URLs, ${profileIdToName.size} IDs`);
         // Register all local StructureDefinitions for resolution before HTTP fetches
         registerLocalStructureDefinitions(structureDefinitions);
-        const examples = loadExamplesFromPackage(extractedRoot);
         for (const sd of structureDefinitions) {
-            await processStructureDefinition(sd, { outputDir, fhirSourceHint: '', valueSetCodesMap, valueSets, examplesMap: examples, existingStructureDefinitions, profileIdToName, profileUrlToName, flags });
+            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');
@@ -637,6 +630,10 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
         // Compile TypeScript to JavaScript
         logger.log('Compiling TypeScript to JavaScript...');
         await compileTypeScriptToJS(outputDir);
+        // Copy package.json to root of extractedRoot so it's at the tarball root
+        const rootPackageJsonPath = path.join(extractedRoot, 'package.json');
+        fs.copyFileSync(generatedPackageJsonPath, rootPackageJsonPath);
+        logger.log('Copied package.json to tarball root');
         const finalArchive = outArchivePath || deriveOutputArchiveName(packageArchivePath);
         await createPackageFromDir(extractedRoot, finalArchive);
         return finalArchive;

package/out/generator/validatorGenerator.js

@@ -674,10 +674,10 @@ export function generateValidateProfileFunction(interfaceName, fields // Array o
     // Only import fhirpath and run evaluation logic when there are constraints.
     if (!hasConstraints) {
         return `
-export async function validate${interfaceName}(resource: ${interfaceName}): Promise<{ errors: string[], warnings: string[] }> {\n  // Touch the parameter so eslint no-unused-vars doesn't flag it when there are no constraints.\n  void resource;\n  return { errors: [], warnings: [] };\n}`;
+export async function validate${interfaceName}(resource: ${interfaceName}): Promise<{ errors: string[]; warnings: string[] }> {\n  // Touch the parameter so eslint no-unused-vars doesn't flag it when there are no constraints.\n  void resource;\n  return { errors: [], warnings: [] };\n}`;
     }
-    const fhirpathImport = filteredConstraints.length > 0 ? 'import fhirpath from "fhirpath";\nimport fhirpath_r4_model from "fhirpath/fhir-context/r4";\n\n' : '';
-    return `${fhirpathImport}export async function validate${interfaceName}(resource: ${interfaceName}): Promise<{ errors: string[], warnings: string[] }> {
+    const fhirpathImport = filteredConstraints.length > 0 ? 'import fhirpath from "fhirpath";\nimport fhirpath_r4_model from "fhirpath/fhir-context/r4/index.js";\n\n' : '';
+    return `${fhirpathImport}export async function validate${interfaceName}(resource: ${interfaceName}): Promise<{ errors: string[]; warnings: string[] }> {
   const errors: string[] = [];
   const warnings: string[] = [];
   ${validationLogic}${patternValidations.join('')}${fixedValueValidations.join('')}${sliceValidations.join('')}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelfhir-ts",
-  "version": "1.0.31",
+  "version": "1.0.32",
   "description": "BabelFHIR-TS: generate TypeScript interfaces, validators, and helper classes from FHIR R4 StructureDefinitions (profiles) directly inside package archives.",
   "type": "module",
   "main": "out/main.js",

package/out/generator/testGenerator.js

@@ -1,71 +0,0 @@
-import path from "path";
-import fs from "fs";
-import { logger } from "../logger.js";
-export function loadExamplesFromPackage(packagePath) {
-    const examplesDir = path.join(packagePath, "examples");
-    const resourceMap = {};
-    if (!fs.existsSync(examplesDir)) {
-        console.warn(`No examples directory found in package: ${examplesDir}`);
-        return resourceMap;
-    }
-    const files = fs.readdirSync(examplesDir);
-    files.forEach((file) => {
-        const match = file.match(/^(Example|Invalid)(\w+)\.json$/);
-        if (match) {
-            const [, type, resourceName] = match;
-            if (!resourceMap[resourceName]) {
-                resourceMap[resourceName] = { valid: [], invalid: [] };
-            }
-            if (type === "Example") {
-                resourceMap[resourceName].valid.push(path.join(examplesDir, file));
-            }
-            else if (type === "Invalid") {
-                resourceMap[resourceName].invalid.push(path.join(examplesDir, file));
-            }
-        }
-    });
-    return resourceMap;
-}
-export function generateTestFile(outputDir, resourceName, validExamples, invalidExamples) {
-    const className = `${resourceName}Class`;
-    const testFileName = `${resourceName}.test.ts`;
-    const testFilePath = path.join(outputDir, testFileName);
-    const testContent = `
-import { describe, it, expect } from "vitest";
-import { ${className} } from "../../generated/${className}";
-import fs from "fs";
-import path from "path";
-
-function loadExample(filePath: string) {
-    const fileContent = fs.readFileSync(filePath, "utf-8");
-    return JSON.parse(fileContent);
-}
-
-describe("${className} Validation", () => {
-    ${validExamples
-        .map((examplePath) => `
-    it("should validate ${path.basename(examplePath)} without errors", async () => {
-        const resource = loadExample("${examplePath.replace(/\\/g, "/")}");
-        const instance = new ${className}(resource);
-        const errors = await instance.validate();
-        expect(errors.errors).toEqual([]);
-    });
-    `)
-        .join("\n")}
-
-    ${invalidExamples
-        .map((examplePath) => `
-    it("should validate ${path.basename(examplePath)} with errors", async () => {
-        const resource = loadExample("${examplePath.replace(/\\/g, "/")}");
-        const instance = new ${className}(resource);
-        const { errors } = await instance.validate();
-        expect(errors.length).toBeGreaterThan(0);
-    });
-    `)
-        .join("\n")}
-
-});
-`;
-    fs.writeFileSync(testFilePath, testContent);
-    logger.log(`Generated test file: ${testFilePath}`);
-}