@atomic-ehr/codegen 0.0.1-canary.20250923152114.2852906 → 0.0.1-canary.20250924082247.588e04a

package/dist/typeschema/core/transformer.d.ts

@@ -15,8 +15,4 @@ export declare function transformElements(fhirSchema: FHIRSchema, parentPath: st
  * Transform a single FHIRSchema to TypeSchema(s) with enhanced categorization
  * Returns the main schema plus any binding schemas
  */
-export declare function transformFHIRSchema(fhirSchema: FHIRSchema, manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageInfo): Promise<TypeSchema[]>;
-/**
- * Transform multiple FHIRSchemas
- */
-export declare function transformFHIRSchemas(fhirSchemas: FHIRSchema[], manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageInfo): Promise<TypeSchema[]>;
+export declare function transformFHIRSchema(manager: ReturnType<typeof CanonicalManager>, fhirSchema: FHIRSchema, packageInfo: PackageInfo): Promise<TypeSchema[]>;

package/dist/typeschema/core/transformer.js

@@ -191,7 +191,7 @@ async function transformExtension(fhirSchema, manager, packageInfo) {
  * Transform a single FHIRSchema to TypeSchema(s) with enhanced categorization
  * Returns the main schema plus any binding schemas
  */
-export async function transformFHIRSchema(fhirSchema, manager, packageInfo) {
+export async function transformFHIRSchema(manager, fhirSchema, packageInfo) {
     const results = [];
     // Extract package info from schema if not provided
     if (!packageInfo && (fhirSchema.package_name || fhirSchema.package_id)) {
@@ -332,14 +332,3 @@ export async function transformFHIRSchema(fhirSchema, manager, packageInfo) {
     results.push(...bindingSchemas);
     return results;
 }
-/**
- * Transform multiple FHIRSchemas
- */
-export async function transformFHIRSchemas(fhirSchemas, manager, packageInfo) {
-    const allResults = [];
-    for (const fhirSchema of fhirSchemas) {
-        const results = await transformFHIRSchema(fhirSchema, manager, packageInfo);
-        allResults.push(...results);
-    }
-    return allResults;
-}

package/dist/typeschema/generator.d.ts

@@ -4,7 +4,7 @@
  * Generates TypeSchema documents from FHIR packages using fhrischema.
  * Provides high-level API for converting FHIR Structure Definitions to TypeSchema format.
  */
-import { type FHIRSchema } from "@atomic-ehr/fhirschema";
+import { type FHIRSchema, type StructureDefinition } from "@atomic-ehr/fhirschema";
 import type { TypeSchemaConfig } from "../config.js";
 import type { TypeSchema } from "./type-schema.types.js";
 import type { PackageInfo, TypeschemaGeneratorOptions } from "./types.js";
@@ -22,17 +22,14 @@ export declare class TypeSchemaGenerator {
     private logger;
     constructor(options?: TypeschemaGeneratorOptions, cacheConfig?: TypeSchemaConfig);
     private initializeCache;
+    fetchPackage(packageName: string, packageVersion?: string): Promise<{
+        structureDefinitions: StructureDefinition[];
+        valueSets: any[];
+    }>;
+    generateFhirSchemas(structureDefinitions: StructureDefinition[]): FHIRSchema[];
+    generateValueSetSchemas(valueSets: any[], packageInfo: PackageInfo): Promise<TypeSchema[]>;
     generateFromPackage(packageName: string, packageVersion?: string): Promise<TypeSchema[]>;
-    generateFromFhirSchema(fhirSchema: FHIRSchema, packageInfo?: PackageInfo): Promise<TypeSchema[]>;
-    /**
-     * Generate TypeSchema from multiple FHIR schemas with FHIR-specific enhancements
-     */
-    generateFromSchemas(fhirSchemas: FHIRSchema[], packageInfo?: PackageInfo): Promise<TypeSchema[]>;
-    private groupTypeSchemas;
-    private enhanceProfiles;
-    private enhanceExtensions;
-    private enhanceValueSets;
-    private enhanceCodeSystems;
+    generateFromSchemas(packageInfo: PackageInfo, fhirSchemas: FHIRSchema[]): Promise<TypeSchema[]>;
     /**
      * Apply treeshaking to StructureDefinitions before FHIR schema transformation
      * This is more efficient and includes smart reference handling
@@ -48,15 +45,3 @@ export declare class TypeSchemaGenerator {
      */
     private extractResourceNameFromUrl;
 }
-/**
- * Convenience function to generate TypeSchema from a package
- */
-export declare function generateTypeSchemaFromPackage(packageName: string, options?: TypeschemaGeneratorOptions): Promise<TypeSchema[]>;
-/**
- * Convenience function to generate TypeSchema from FHIR schemas
- */
-export declare function generateTypeSchemaFromSchemas(fhirSchemas: FHIRSchema[], packageInfo?: PackageInfo, options?: TypeschemaGeneratorOptions): Promise<TypeSchema[]>;
-/**
- * Convenience function to generate TypeSchema from a single FHIR schema
- */
-export declare function generateTypeSchemaFromSchema(fhirSchema: FHIRSchema, packageInfo?: PackageInfo, options?: TypeschemaGeneratorOptions): Promise<TypeSchema[]>;

package/dist/typeschema/generator.js

@@ -5,10 +5,10 @@
  * Provides high-level API for converting FHIR Structure Definitions to TypeSchema format.
  */
 import { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-import { translate, } from "@atomic-ehr/fhirschema";
+import * as fhirschema from "@atomic-ehr/fhirschema";
 import { createLogger } from "../utils/codegen-logger.js";
 import { TypeSchemaCache } from "./cache.js";
-import { transformFHIRSchema, transformFHIRSchemas, } from "./core/transformer.js";
+import { transformFHIRSchema } from "./core/transformer.js";
 import { transformValueSet } from "./value-set/processor.js";
 /**
  * TypeSchema Generator class
@@ -39,16 +39,7 @@ export class TypeSchemaGenerator {
             await this.cache.initialize();
         }
     }
-    async generateFromPackage(packageName, packageVersion) {
-        await this.initializeCache();
-        const forceRegenerate = this.cacheConfig?.forceRegenerate ?? false;
-        if (this.cache && !forceRegenerate) {
-            const cachedSchemas = this.cache.getByPackage(packageName);
-            if (cachedSchemas.length > 0) {
-                this.logger.info(`Using cached TypeSchemas for package: ${packageName} (${cachedSchemas.length} schemas)`);
-                return cachedSchemas;
-            }
-        }
+    async fetchPackage(packageName, packageVersion) {
         this.logger.step(`Loading FHIR package: ${packageName}${packageVersion ? `@${packageVersion}` : ""}`);
         this.manager = CanonicalManager({
             packages: [`${packageName}${packageVersion ? `@${packageVersion}` : ""}`],
@@ -59,14 +50,18 @@ export class TypeSchemaGenerator {
         const structureDefinitions = allResources.filter((resource) => resource.resourceType === "StructureDefinition");
         const valueSets = allResources.filter((resource) => resource.resourceType === "ValueSet");
         this.logger.info(`Found ${structureDefinitions.length} StructureDefinitions and ${valueSets.length} ValueSets in package`);
+        return { structureDefinitions, valueSets };
+    }
+    generateFhirSchemas(structureDefinitions) {
         this.logger.progress(`Converting ${structureDefinitions.length} StructureDefinitions to FHIRSchemas`);
+        // TODO: do it on the TypeSchema
         const filteredStructureDefinitions = this.applyStructureDefinitionTreeshaking(structureDefinitions);
         const fhirSchemas = [];
         let convertedCount = 0;
         let failedCount = 0;
         for (const sd of filteredStructureDefinitions) {
             try {
-                const fhirSchema = translate(sd);
+                const fhirSchema = fhirschema.translate(sd);
                 fhirSchemas.push(fhirSchema);
                 convertedCount++;
                 this.logger.debug(`Converted StructureDefinition: ${sd.name || sd.id} (${sd.resourceType})`);
@@ -76,14 +71,13 @@ export class TypeSchemaGenerator {
                 this.logger.warn(`Failed to convert StructureDefinition ${sd.name || sd.id}: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-        this.logger.success(`Schema conversion completed: ${convertedCount}/${filteredStructureDefinitions.length} successful, ${failedCount} failed`);
+        this.logger.success(`FHIR Schema conversion completed: ${convertedCount}/${filteredStructureDefinitions.length} successful, ${failedCount} failed`);
+        return fhirSchemas;
+    }
+    async generateValueSetSchemas(valueSets, packageInfo) {
         if (valueSets.length > 0) {
             this.logger.debug(`${valueSets.length} ValueSets available for enum extraction`);
         }
-        const packageInfo = {
-            name: packageName,
-            version: packageVersion || "latest",
-        };
         // Process ValueSets separately to add to TypeSchema output
         const valueSetSchemas = [];
         if (valueSets.length > 0) {
@@ -106,111 +100,40 @@ export class TypeSchemaGenerator {
             }
             this.logger.success(`ValueSet conversion completed: ${valueSetConvertedCount}/${valueSets.length} successful, ${valueSetFailedCount} failed`);
         }
-        const schemas = await this.generateFromSchemas(fhirSchemas, packageInfo);
-        // Add the converted ValueSets to the final results
+        return valueSetSchemas;
+    }
+    async generateFromPackage(packageName, packageVersion) {
+        await this.initializeCache();
+        if (this.cache && !(this.cacheConfig?.forceRegenerate ?? false)) {
+            const cachedSchemas = this.cache.getByPackage(packageName);
+            if (cachedSchemas.length > 0) {
+                this.logger.info(`Using cached TypeSchemas for package: ${packageName} (${cachedSchemas.length} schemas)`);
+                return cachedSchemas;
+            }
+        }
+        const packageInfo = {
+            name: packageName,
+            version: packageVersion || "latest",
+        };
+        const { valueSets, structureDefinitions } = await this.fetchPackage(packageName, packageVersion);
+        const fhirSchemas = this.generateFhirSchemas(structureDefinitions);
+        const valueSetSchemas = await this.generateValueSetSchemas(valueSets, packageInfo);
+        const schemas = await this.generateFromSchemas(packageInfo, fhirSchemas);
         const allSchemas = [...schemas, ...valueSetSchemas];
-        if (this.cache && allSchemas.length > 0) {
-            this.logger.info(`Caching ${allSchemas.length} generated schemas for package: ${packageName}`);
+        if (this.cache) {
             for (const schema of allSchemas) {
                 await this.cache.set(schema);
             }
-            this.logger.success(`Cached ${allSchemas.length} TypeSchemas for package: ${packageName}`);
         }
         return allSchemas;
     }
-    async generateFromFhirSchema(fhirSchema, packageInfo) {
-        this.logger.info("Transforming FHIR schema to TypeSchema");
-        return transformFHIRSchema(fhirSchema, this.manager, packageInfo);
-    }
-    /**
-     * Generate TypeSchema from multiple FHIR schemas with FHIR-specific enhancements
-     */
-    async generateFromSchemas(fhirSchemas, packageInfo) {
-        this.logger.info(`Transforming ${fhirSchemas.length} FHIR schemas to TypeSchema`);
-        const baseSchemas = await transformFHIRSchemas(fhirSchemas, this.manager, packageInfo);
-        const results = [];
-        const groupedSchemas = this.groupTypeSchemas(baseSchemas);
-        results.push(...groupedSchemas.resources);
-        results.push(...groupedSchemas.complexTypes);
-        results.push(...groupedSchemas.primitives);
-        if (groupedSchemas.profiles.length > 0) {
-            this.logger.info(`Enhancing ${groupedSchemas.profiles.length} profiles`);
-            const profileResults = await this.enhanceProfiles(groupedSchemas.profiles);
-            results.push(...profileResults);
-        }
-        if (groupedSchemas.extensions.length > 0) {
-            this.logger.info(`Enhancing ${groupedSchemas.extensions.length} extensions`);
-            const extensionResults = await this.enhanceExtensions(groupedSchemas.extensions);
-            results.push(...extensionResults);
-        }
-        if (groupedSchemas.valueSets.length > 0) {
-            this.logger.info(`Enhancing ${groupedSchemas.valueSets.length} value sets`);
-            const valueSetResults = await this.enhanceValueSets(groupedSchemas.valueSets);
-            results.push(...valueSetResults);
-        }
-        if (groupedSchemas.codeSystems.length > 0) {
-            this.logger.info(`Enhancing ${groupedSchemas.codeSystems.length} code systems`);
-            const codeSystemResults = await this.enhanceCodeSystems(groupedSchemas.codeSystems);
-            results.push(...codeSystemResults);
-        }
-        this.logger.success(`Generated ${results.length} enhanced FHIR type schemas: ${groupedSchemas.resources.length} resources, ${groupedSchemas.complexTypes.length} complex types, ${groupedSchemas.primitives.length} primitives`);
-        return results;
-    }
-    groupTypeSchemas(schemas) {
-        const groups = {
-            resources: [],
-            complexTypes: [],
-            primitives: [],
-            profiles: [],
-            extensions: [],
-            valueSets: [],
-            codeSystems: [],
-        };
-        for (const schema of schemas) {
-            switch (schema.identifier.kind) {
-                case "resource":
-                    groups.resources.push(schema);
-                    break;
-                case "complex-type":
-                    groups.complexTypes.push(schema);
-                    break;
-                case "primitive-type":
-                    groups.primitives.push(schema);
-                    break;
-                case "binding":
-                    if ("metadata" in schema && schema.metadata?.isExtension) {
-                        groups.extensions.push(schema);
-                    }
-                    else {
-                        groups.complexTypes.push(schema);
-                    }
-                    break;
-                case "value-set":
-                    groups.valueSets.push(schema);
-                    break;
-                default:
-                    if ("metadata" in schema && schema.metadata?.isCodeSystem) {
-                        groups.codeSystems.push(schema);
-                    }
-                    else {
-                        groups.complexTypes.push(schema);
-                    }
-                    break;
-            }
+    async generateFromSchemas(packageInfo, fhirSchemas) {
+        this.logger.info(`Transforming ${fhirSchemas.length} FHIR schemas to Type Schema`);
+        const typeSchemas = [];
+        for (const fhirSchema of fhirSchemas) {
+            typeSchemas.push(...(await transformFHIRSchema(this.manager, fhirSchema, packageInfo)));
         }
-        return groups;
-    }
-    async enhanceProfiles(schemas) {
-        return schemas;
-    }
-    async enhanceExtensions(schemas) {
-        return schemas;
-    }
-    async enhanceValueSets(schemas) {
-        return schemas;
-    }
-    async enhanceCodeSystems(schemas) {
-        return schemas;
+        return typeSchemas;
     }
     /**
      * Apply treeshaking to StructureDefinitions before FHIR schema transformation
@@ -340,24 +263,3 @@ export class TypeSchemaGenerator {
         return match ? (match[1] ?? null) : null;
     }
 }
-/**
- * Convenience function to generate TypeSchema from a package
- */
-export async function generateTypeSchemaFromPackage(packageName, options = {}) {
-    const generator = new TypeSchemaGenerator(options);
-    return await generator.generateFromPackage(packageName);
-}
-/**
- * Convenience function to generate TypeSchema from FHIR schemas
- */
-export async function generateTypeSchemaFromSchemas(fhirSchemas, packageInfo, options = {}) {
-    const generator = new TypeSchemaGenerator(options);
-    return await generator.generateFromSchemas(fhirSchemas, packageInfo);
-}
-/**
- * Convenience function to generate TypeSchema from a single FHIR schema
- */
-export async function generateTypeSchemaFromSchema(fhirSchema, packageInfo, options = {}) {
-    const generator = new TypeSchemaGenerator(options);
-    return await generator.generateFromFhirSchema(fhirSchema, packageInfo);
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomic-ehr/codegen",
-  "version": "0.0.1-canary.20250923152114.2852906",
+  "version": "0.0.1-canary.20250924082247.588e04a",
   "description": "Code generation tools for FHIR resources and TypeSchema definitions",
   "keywords": [
     "fhir",