@atomic-ehr/codegen 0.0.1-canary.20251003082149.3db28b4 → 0.0.1-canary.20251003142740.59082f8

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

@@ -5,12 +5,9 @@
  */
 import type { FHIRSchemaElement } from "@atomic-ehr/fhirschema";
 import type { Register } from "@typeschema/register";
-import type { BindingTypeSchema, CanonicalUrl, RichFHIRSchema } from "@typeschema/types";
-export declare function extractValueSetConcepts(valueSetUrl: CanonicalUrl, register: Register): {
-    system: string;
-    code: string;
-    display?: string;
-}[] | undefined;
-export declare function buildEnum(element: FHIRSchemaElement, register: Register): string[] | undefined;
+import type { BindingTypeSchema, CanonicalUrl, Concept, RichFHIRSchema, RichValueSet } from "@typeschema/types";
+export declare function extractValueSetConceptsByUrl(register: Register, valueSetUrl: CanonicalUrl): Concept[] | undefined;
+export declare function extractValueSetConcepts(register: Register, valueSet: RichValueSet): Concept[] | undefined;
+export declare function buildEnum(register: Register, element: FHIRSchemaElement): string[] | undefined;
 export declare function generateBindingSchema(register: Register, fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement): Promise<BindingTypeSchema | undefined>;
 export declare function collectBindingSchemas(register: Register, fhirSchema: RichFHIRSchema): Promise<BindingTypeSchema[]>;

package/dist/typeschema/core/binding.js

@@ -4,70 +4,63 @@
  * Functions for processing value set bindings and generating enums
  */
 import { buildFieldType } from "./field-builder";
-import { dropVersionFromUrl, mkBindingIdentifier, mkValueSetIdentifier } from "./identifier";
-export function extractValueSetConcepts(valueSetUrl, register) {
-    try {
-        const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
-        const valueSet = register.resolveVs(cleanUrl);
-        if (!valueSet)
-            return undefined;
-        if (valueSet.expansion?.contains) {
-            return valueSet.expansion.contains.map((concept) => ({
-                system: concept.system,
-                code: concept.code,
-                display: concept.display,
-            }));
-        }
-        const concepts = [];
-        if (valueSet.compose?.include) {
-            for (const include of valueSet.compose.include) {
-                if (include.concept) {
-                    for (const concept of include.concept) {
-                        concepts.push({
-                            system: include.system,
-                            code: concept.code,
-                            display: concept.display,
-                        });
-                    }
+import { dropVersionFromUrl, mkBindingIdentifier, mkValueSetIdentifierByUrl } from "./identifier";
+export function extractValueSetConceptsByUrl(register, valueSetUrl) {
+    const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
+    const valueSet = register.resolveVs(cleanUrl);
+    if (!valueSet)
+        return undefined;
+    return extractValueSetConcepts(register, valueSet);
+}
+export function extractValueSetConcepts(register, valueSet) {
+    if (valueSet.expansion?.contains)
+        return valueSet.expansion.contains;
+    const concepts = [];
+    if (valueSet.compose?.include) {
+        for (const include of valueSet.compose.include) {
+            if (include.concept) {
+                for (const concept of include.concept) {
+                    concepts.push({
+                        system: include.system,
+                        code: concept.code,
+                        display: concept.display,
+                    });
                 }
-                else if (include.system && !include.filter) {
-                    try {
-                        const codeSystem = register.resolveAny(include.system);
-                        if (codeSystem?.concept) {
-                            const extractConcepts = (conceptList, system) => {
-                                for (const concept of conceptList) {
-                                    concepts.push({
-                                        system,
-                                        code: concept.code,
-                                        display: concept.display,
-                                    });
-                                    // Handle nested concepts
-                                    if (concept.concept) {
-                                        extractConcepts(concept.concept, system);
-                                    }
+            }
+            else if (include.system && !include.filter) {
+                try {
+                    const codeSystem = register.resolveAny(include.system);
+                    if (codeSystem?.concept) {
+                        const extractConcepts = (conceptList, system) => {
+                            for (const concept of conceptList) {
+                                concepts.push({
+                                    system,
+                                    code: concept.code,
+                                    display: concept.display,
+                                });
+                                if (concept.concept) {
+                                    extractConcepts(concept.concept, system);
                                 }
-                            };
-                            extractConcepts(codeSystem.concept, include.system);
-                        }
-                    }
-                    catch {
-                        // Ignore if we can't resolve the CodeSystem
+                            }
+                        };
+                        extractConcepts(codeSystem.concept, include.system);
                     }
                 }
+                catch {
+                    // Ignore if we can't resolve the CodeSystem
+                }
             }
         }
-        return concepts.length > 0 ? concepts : undefined;
-    }
-    catch {
-        return undefined;
     }
+    return concepts.length > 0 ? concepts : undefined;
 }
 const MAX_ENUM_LENGTH = 100;
-export function buildEnum(element, register) {
+export function buildEnum(register, element) {
     if (!element.binding)
         return undefined;
-    const { strength, valueSet } = element.binding;
-    if (!valueSet)
+    const strength = element.binding.strength;
+    const valueSetUrl = element.binding.valueSet;
+    if (!valueSetUrl)
         return undefined;
     // Enhanced support for more binding strengths and types
     // Generate enum for:
@@ -78,17 +71,16 @@ export function buildEnum(element, register) {
     const shouldGenerateEnum = strength === "required" ||
         (strength === "extensible" && (element.type === "code" || element.type === "Coding")) ||
         (strength === "preferred" && (element.type === "code" || element.type === "Coding"));
-    if (!shouldGenerateEnum) {
+    if (!shouldGenerateEnum)
         return undefined;
-    }
-    const concepts = extractValueSetConcepts(valueSet, register);
+    const concepts = extractValueSetConceptsByUrl(register, valueSetUrl);
     if (!concepts || concepts.length === 0)
         return undefined;
     const codes = concepts
         .map((c) => c.code)
         .filter((code) => code && typeof code === "string" && code.trim().length > 0);
     if (codes.length > MAX_ENUM_LENGTH) {
-        console.warn(`Value set ${valueSet} has more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`);
+        console.warn(`Value set ${valueSetUrl} has more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`);
         return undefined;
     }
     return codes.length > 0 ? codes : undefined;
@@ -98,13 +90,13 @@ export async function generateBindingSchema(register, fhirSchema, path, element)
         return undefined;
     const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
     const fieldType = buildFieldType(register, fhirSchema, element);
-    const valueSetIdentifier = mkValueSetIdentifier(register, element.binding.valueSet);
+    const valueSetIdentifier = mkValueSetIdentifierByUrl(register, element.binding.valueSet);
     const dependencies = [];
     if (fieldType) {
         dependencies.push(fieldType);
     }
     dependencies.push(valueSetIdentifier);
-    const enumValues = buildEnum(element, register);
+    const enumValues = buildEnum(register, element);
     return {
         identifier,
         type: fieldType,

package/dist/typeschema/core/field-builder.js

@@ -83,7 +83,7 @@ export const mkField = (register, fhirSchema, path, element) => {
     if (element.binding) {
         binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
         if (element.binding.strength === "required" && element.type === "code") {
-            enumValues = buildEnum(element, register);
+            enumValues = buildEnum(register, element);
         }
     }
     return {

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

@@ -4,10 +4,11 @@
  * Functions for creating TypeSchema identifiers from FHIRSchema entities
  */
 import type { FHIRSchema } from "@atomic-ehr/fhirschema";
-import type { BindingIdentifier, CanonicalUrl, Identifier, NestedIdentifier, RichFHIRSchema, ValueSetTypeSchema } from "@typeschema/types";
+import type { BindingIdentifier, CanonicalUrl, Identifier, NestedIdentifier, RichFHIRSchema, ValueSetIdentifier } from "@typeschema/types";
 import type { Register } from "../register";
 export declare function dropVersionFromUrl(url: CanonicalUrl): CanonicalUrl;
+export declare function getVersionFromUrl(url: CanonicalUrl): string | undefined;
 export declare function mkIdentifier(fhirSchema: RichFHIRSchema): Identifier;
 export declare function mkNestedIdentifier(fhirSchema: RichFHIRSchema, path: string[]): NestedIdentifier;
-export declare function mkValueSetIdentifier(register: Register, valueSetUrl: CanonicalUrl): ValueSetTypeSchema["identifier"];
+export declare function mkValueSetIdentifierByUrl(register: Register, fullValueSetUrl: CanonicalUrl): ValueSetIdentifier;
 export declare function mkBindingIdentifier(fhirSchema: FHIRSchema, path: string[], bindingName?: string): BindingIdentifier;

package/dist/typeschema/core/identifier.js

@@ -7,6 +7,10 @@ export function dropVersionFromUrl(url) {
     const baseUrl = url.split("|")[0];
     return baseUrl ? baseUrl : url;
 }
+export function getVersionFromUrl(url) {
+    const version = url.split("|")[1];
+    return version;
+}
 function determineKind(fhirSchema) {
     if (fhirSchema.derivation === "constraint")
         return "profile";
@@ -37,31 +41,38 @@ export function mkNestedIdentifier(fhirSchema, path) {
         url: `${fhirSchema.url}#${nestedName}`,
     };
 }
-export function mkValueSetIdentifier(register, valueSetUrl) {
-    valueSetUrl = dropVersionFromUrl(valueSetUrl);
-    const valueSet = register.resolveVs(valueSetUrl);
-    // Generate a meaningful name from the URL instead of using potentially hash-like IDs
-    let name = "unknown";
-    // First try to get the last segment of the URL path
-    const urlParts = valueSetUrl.split("/");
+const getValueSetName = (url) => {
+    const urlParts = url.split("/");
     const lastSegment = urlParts[urlParts.length - 1];
     if (lastSegment && lastSegment.length > 0) {
-        // Convert kebab-case or snake_case to PascalCase for better readability
-        name = lastSegment
+        return lastSegment
             .split(/[-_]/)
             .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
             .join("");
     }
-    // Only fall back to valueSet.id if we couldn't extract a meaningful name from URL
-    // and the ID doesn't look like a hash (no long alphanumeric strings)
-    if (name === "unknown" && valueSet?.id && !/^[a-zA-Z0-9_-]{20,}$/.test(valueSet.id)) {
-        name = valueSet.id;
-    }
+    return url;
+};
+export function mkValueSetIdentifierByUrl(register, fullValueSetUrl) {
+    const valueSetUrl = dropVersionFromUrl(fullValueSetUrl);
+    const valueSetNameFallback = getValueSetName(valueSetUrl);
+    const valuesSetFallback = {
+        resourceType: "ValueSet",
+        package_meta: {
+            name: "missing_valuesets",
+            version: getVersionFromUrl(valueSetUrl) || "0.0.0",
+        },
+        name: valueSetNameFallback,
+        id: fullValueSetUrl,
+        url: valueSetUrl,
+    };
+    const valueSet = register.resolveVs(valueSetUrl) || valuesSetFallback;
+    // NOTE: ignore valueSet.name due to human name
+    const valueSetName = valueSet?.id && !/^[a-zA-Z0-9_-]{20,}$/.test(valueSet.id) ? valueSet.id : valueSetNameFallback;
     return {
         kind: "value-set",
         package: valueSet?.package_meta.name,
         version: valueSet?.package_meta.version,
-        name: name,
+        name: valueSetName,
         url: valueSetUrl,
     };
 }

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

@@ -5,6 +5,7 @@
  */
 import type { FHIRSchemaElement } from "@atomic-ehr/fhirschema";
 import { type Register } from "@typeschema/register";
-import type { Field, RichFHIRSchema, TypeSchema } from "@typeschema/types";
+import type { Field, RichFHIRSchema, RichValueSet, TypeSchema, ValueSetTypeSchema } from "@typeschema/types";
 export declare function mkFields(register: Register, fhirSchema: RichFHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement> | undefined): Promise<Record<string, Field> | undefined>;
+export declare function transformValueSet(register: Register, valueSet: RichValueSet): Promise<ValueSetTypeSchema>;
 export declare function transformFHIRSchema(register: Register, fhirSchema: RichFHIRSchema): Promise<TypeSchema[]>;

package/dist/typeschema/core/transformer.js

@@ -5,9 +5,9 @@
  */
 import { fsElementSnapshot, resolveFsElementGenealogy } from "@typeschema/register";
 import { transformProfile } from "../profile/processor";
-import { collectBindingSchemas } from "./binding";
+import { collectBindingSchemas, extractValueSetConceptsByUrl } from "./binding";
 import { isNestedElement, mkField, mkNestedField } from "./field-builder";
-import { mkIdentifier } from "./identifier";
+import { mkIdentifier, mkValueSetIdentifierByUrl } from "./identifier";
 import { extractNestedDependencies, mkNestedTypes } from "./nested-types";
 export async function mkFields(register, fhirSchema, parentPath, elements) {
     if (!elements)
@@ -89,42 +89,17 @@ function isExtensionSchema(fhirSchema, _identifier) {
     }
     return false;
 }
-/**
- * Transform a ValueSet FHIRSchema to TypeSchemaValueSet
- */
-async function transformValueSet(fhirSchema, _register, _packageInfo) {
-    try {
-        const identifier = mkIdentifier(fhirSchema);
-        identifier.kind = "value-set";
-        const valueSetSchema = {
-            identifier: identifier,
-            description: fhirSchema.description,
-        };
-        // If there are elements that represent concepts
-        if (fhirSchema.elements) {
-            const concepts = [];
-            // Extract concepts from elements (simplified approach)
-            for (const [_key, element] of Object.entries(fhirSchema.elements)) {
-                if ("code" in element && element.code) {
-                    concepts.push({
-                        code: element.code,
-                        // @ts-ignore
-                        display: element.short || element.definition,
-                        // @ts-ignore
-                        system: element.system,
-                    });
-                }
-            }
-            if (concepts.length > 0) {
-                valueSetSchema.concept = concepts;
-            }
-        }
-        return valueSetSchema;
-    }
-    catch (error) {
-        console.warn(`Failed to transform value set ${fhirSchema.name}: ${error}`);
-        return null;
-    }
+export async function transformValueSet(register, valueSet) {
+    if (!valueSet.url)
+        throw new Error("ValueSet URL is required");
+    const identifier = mkValueSetIdentifierByUrl(register, valueSet.url);
+    const concept = extractValueSetConceptsByUrl(register, valueSet.url);
+    return {
+        identifier: identifier,
+        description: valueSet.description,
+        concept: concept,
+        compose: !concept ? valueSet.compose : undefined,
+    };
 }
 /**
  * Transform an Extension FHIRSchema to TypeSchema with extension metadata
@@ -212,7 +187,7 @@ function extractDependencies(identifier, base, fields, nestedTypes) {
     const localNestedTypeUrls = new Set(nestedTypes?.map((nt) => nt.identifier.url));
     const result = Object.values(uniqDeps)
         .filter((e) => !(e.kind === "nested" && localNestedTypeUrls.has(e.url)))
-        .sort((a, b) => a.name.localeCompare(b.name));
+        .sort((a, b) => a.url.localeCompare(b.url));
     return result.length > 0 ? result : undefined;
 }
 async function transformResource(register, fhirSchema) {
@@ -242,24 +217,13 @@ async function transformResource(register, fhirSchema) {
 export async function transformFHIRSchema(register, fhirSchema) {
     const results = [];
     const identifier = mkIdentifier(fhirSchema);
-    // Handle profiles with specialized processor
     if (identifier.kind === "profile") {
         const profileSchema = await transformProfile(register, fhirSchema);
         results.push(profileSchema);
-        // Collect binding schemas for profiles too
         const bindingSchemas = await collectBindingSchemas(register, fhirSchema);
         results.push(...bindingSchemas);
         return results;
     }
-    // Handle value sets specially
-    if (identifier.kind === "value-set" || fhirSchema.kind === "value-set") {
-        const valueSetSchema = await transformValueSet(fhirSchema, register, fhirSchema.package_meta);
-        if (valueSetSchema) {
-            results.push(valueSetSchema);
-        }
-        return results;
-    }
-    // Handle extensions specially
     if (isExtensionSchema(fhirSchema, identifier)) {
         const extensionSchema = await transformExtension(fhirSchema, register, fhirSchema.package_meta);
         if (extensionSchema) {

package/dist/typeschema/generator.d.ts

@@ -24,7 +24,7 @@ export declare class TypeSchemaGenerator {
     private initializeCache;
     registerFromPackageMetas(packageMetas: PackageMeta[]): Promise<Register>;
     generateFhirSchemas(structureDefinitions: StructureDefinition[]): FHIRSchema[];
-    generateValueSetSchemas(valueSets: any[], packageInfo: PackageMeta): Promise<TypeSchema[]>;
+    generateValueSetSchemas(valueSets: any[], _packageInfo: PackageMeta): Promise<TypeSchema[]>;
     generateFromPackage(packageName: string, packageVersion?: string): Promise<TypeSchema[]>;
     /**
      * Apply treeshaking to StructureDefinitions before FHIR schema transformation

package/dist/typeschema/generator.js

@@ -9,8 +9,7 @@ import * as fhirschema from "@atomic-ehr/fhirschema";
 import { createLogger } from "@root/utils/codegen-logger";
 import { registerFromManager } from "@typeschema/register";
 import { TypeSchemaCache } from "./cache";
-import { transformFHIRSchema } from "./core/transformer";
-import { transformValueSet } from "./value-set/processor";
+import { transformFHIRSchema, transformValueSet } from "./core/transformer";
 /**
  * TypeSchema Generator class
  *
@@ -48,7 +47,7 @@ export class TypeSchemaGenerator {
     }
     generateFhirSchemas(structureDefinitions) {
         this.logger.progress(`Converting ${structureDefinitions.length} StructureDefinitions to FHIRSchemas`);
-        // TODO: do it on the TypeSchema
+        // TODO: do it on the TypeSchema?
         const filteredStructureDefinitions = this.applyStructureDefinitionTreeshaking(structureDefinitions);
         const fhirSchemas = [];
         let convertedCount = 0;
@@ -68,7 +67,7 @@ export class TypeSchemaGenerator {
         this.logger.success(`FHIR Schema conversion completed: ${convertedCount}/${filteredStructureDefinitions.length} successful, ${failedCount} failed`);
         return fhirSchemas;
     }
-    async generateValueSetSchemas(valueSets, packageInfo) {
+    async generateValueSetSchemas(valueSets, _packageInfo) {
         if (valueSets.length > 0) {
             this.logger.debug(`${valueSets.length} ValueSets available for enum extraction`);
         }
@@ -80,7 +79,7 @@ export class TypeSchemaGenerator {
             let valueSetFailedCount = 0;
             for (const vs of valueSets) {
                 try {
-                    const valueSetSchema = await transformValueSet(vs, await registerFromManager(this.manager), packageInfo);
+                    const valueSetSchema = await transformValueSet(await registerFromManager(this.manager), vs);
                     if (valueSetSchema) {
                         valueSetSchemas.push(valueSetSchema);
                         valueSetConvertedCount++;

package/dist/typeschema/register.d.ts

@@ -1,7 +1,7 @@
 import { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
 import type { FHIRSchema, FHIRSchemaElement, StructureDefinition } from "@atomic-ehr/fhirschema";
 import type { CodegenLogger } from "@root/utils/codegen-logger";
-import type { CanonicalUrl, Name, PackageMeta, RichFHIRSchema } from "@typeschema/types";
+import type { CanonicalUrl, Name, PackageMeta, RichFHIRSchema, RichValueSet } from "@typeschema/types";
 export type Register = {
     appendFs(fs: FHIRSchema): void;
     ensureCanonicalUrl(name: string | Name | CanonicalUrl): CanonicalUrl;
@@ -10,8 +10,8 @@ export type Register = {
     resolveFsGenealogy(canonicalUrl: CanonicalUrl): RichFHIRSchema[];
     allSd(): StructureDefinition[];
     allFs(): RichFHIRSchema[];
-    allVs(): any[];
-    resolveVs(canonicalUrl: CanonicalUrl): any | undefined;
+    allVs(): RichValueSet[];
+    resolveVs(canonicalUrl: CanonicalUrl): RichValueSet | undefined;
     complexTypeDict(): Record<string, RichFHIRSchema>;
     resolveAny(canonicalUrl: CanonicalUrl): any | undefined;
 } & ReturnType<typeof CanonicalManager>;

package/dist/typeschema/types.d.ts

@@ -162,17 +162,16 @@ export interface ChoiceFieldInstance {
     min?: number;
     max?: number;
 }
+export type Concept = {
+    code: string;
+    display?: string;
+    system?: string;
+};
 export interface ValueSetTypeSchema {
     identifier: ValueSetIdentifier;
     description?: string;
-    concept?: {
-        code: string;
-        display?: string;
-        system?: string;
-    }[];
-    compose?: {
-        [k: string]: unknown;
-    };
+    concept?: Concept[];
+    compose?: ValueSetCompose;
 }
 export interface BindingTypeSchema {
     identifier: BindingIdentifier;
@@ -196,4 +195,46 @@ export type TypeschemaParserOptions = {
     validate?: boolean;
     strict?: boolean;
 };
+export type ValueSet = {
+    resourceType: "ValueSet";
+    id: string;
+    name?: string;
+    url?: string;
+    description?: string;
+    compose?: ValueSetCompose;
+    expansion?: {
+        contains: Concept[];
+    };
+    experimental?: boolean;
+    immutable?: boolean;
+    extension?: any[];
+    status?: string;
+    identifier?: any[];
+    title?: string;
+    publisher?: string;
+    version?: string;
+    meta?: any;
+    date?: string;
+    contact?: any;
+};
+export type ValueSetCompose = {
+    include: {
+        concept?: Concept[];
+        system?: string;
+        filter?: {}[];
+    }[];
+};
+export type CodeSystem = {
+    concept: CodeSystemConcept[];
+};
+export type CodeSystemConcept = {
+    concept: CodeSystemConcept[];
+    code: string;
+    display: string;
+};
+export type RichValueSet = Omit<ValueSet, "name" | "url"> & {
+    package_meta: PackageMeta;
+    name?: Name;
+    url?: CanonicalUrl;
+};
 export {};

package/package.json

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

package/dist/typeschema/value-set/processor.d.ts

@@ -1,20 +0,0 @@
-/**
- * Value Set Processing
- *
- * Functions for transforming FHIR ValueSets into TypeSchema format
- */
-import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-import type { Register } from "../register";
-import type { PackageMeta, ValueSetTypeSchema } from "../types";
-/**
- * Extract all concepts from a ValueSet
- */
-export declare function extractValueSetConcepts(valueSet: any, manager: ReturnType<typeof CanonicalManager>): Promise<Array<{
-    system: string;
-    code: string;
-    display?: string;
-}> | undefined>;
-/**
- * Transform a FHIR ValueSet to TypeSchema format
- */
-export declare function transformValueSet(valueSet: any, register: Register, packageInfo?: PackageMeta): Promise<ValueSetTypeSchema>;