@atomic-ehr/codegen 0.0.1-canary.20251002114154.42f165c → 0.0.1-canary.20251003082149.3db28b4

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

@@ -5,21 +5,12 @@
  */
 import type { FHIRSchemaElement } from "@atomic-ehr/fhirschema";
 import type { Register } from "@typeschema/register";
-import type { BindingTypeSchema, CanonicalUrl, PackageMeta, RichFHIRSchema } from "@typeschema/types";
-/**
- * Extract concepts from a ValueSet
- */
+import type { BindingTypeSchema, CanonicalUrl, RichFHIRSchema } from "@typeschema/types";
 export declare function extractValueSetConcepts(valueSetUrl: CanonicalUrl, register: Register): {
     system: string;
     code: string;
     display?: string;
 }[] | undefined;
-/**
- * Build enum values from binding if applicable
- */
 export declare function buildEnum(element: FHIRSchemaElement, register: Register): string[] | undefined;
-export declare function generateBindingSchema(fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement, register: Register, packageInfo?: PackageMeta): Promise<BindingTypeSchema | undefined>;
-/**
- * Collect all binding schemas from a FHIRSchema
- */
-export declare function collectBindingSchemas(fhirSchema: RichFHIRSchema, register: Register): Promise<BindingTypeSchema[]>;
+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

@@ -5,16 +5,12 @@
  */
 import { buildFieldType } from "./field-builder";
 import { dropVersionFromUrl, mkBindingIdentifier, mkValueSetIdentifier } from "./identifier";
-/**
- * Extract concepts from a ValueSet
- */
 export function extractValueSetConcepts(valueSetUrl, register) {
     try {
         const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
         const valueSet = register.resolveVs(cleanUrl);
         if (!valueSet)
             return undefined;
-        // If expansion is available, use it
         if (valueSet.expansion?.contains) {
             return valueSet.expansion.contains.map((concept) => ({
                 system: concept.system,
@@ -22,12 +18,10 @@ export function extractValueSetConcepts(valueSetUrl, register) {
                 display: concept.display,
             }));
         }
-        // Otherwise try to extract from compose
         const concepts = [];
         if (valueSet.compose?.include) {
             for (const include of valueSet.compose.include) {
                 if (include.concept) {
-                    // Direct concept list
                     for (const concept of include.concept) {
                         concepts.push({
                             system: include.system,
@@ -37,7 +31,6 @@ export function extractValueSetConcepts(valueSetUrl, register) {
                     }
                 }
                 else if (include.system && !include.filter) {
-                    // Include all from CodeSystem
                     try {
                         const codeSystem = register.resolveAny(include.system);
                         if (codeSystem?.concept) {
@@ -69,9 +62,7 @@ export function extractValueSetConcepts(valueSetUrl, register) {
         return undefined;
     }
 }
-/**
- * Build enum values from binding if applicable
- */
+const MAX_ENUM_LENGTH = 100;
 export function buildEnum(element, register) {
     if (!element.binding)
         return undefined;
@@ -90,36 +81,30 @@ export function buildEnum(element, register) {
     if (!shouldGenerateEnum) {
         return undefined;
     }
-    try {
-        const concepts = extractValueSetConcepts(valueSet, register);
-        if (!concepts || concepts.length === 0)
-            return undefined;
-        // Extract just the codes and filter out any empty/invalid ones
-        const codes = concepts
-            .map((c) => c.code)
-            .filter((code) => code && typeof code === "string" && code.trim().length > 0);
-        // Only return if we have valid codes and not too many (avoid huge enums)
-        // Increased limit from 50 to 100 for better value set coverage
-        return codes.length > 0 && codes.length <= 100 ? codes : undefined;
-    }
-    catch (error) {
-        // Log the error for debugging but don't fail the generation
-        console.debug(`Failed to extract enum values for ${valueSet}: ${error}`);
+    const concepts = extractValueSetConcepts(valueSet, register);
+    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.`);
         return undefined;
     }
+    return codes.length > 0 ? codes : undefined;
 }
-export async function generateBindingSchema(fhirSchema, path, element, register, packageInfo) {
+export async function generateBindingSchema(register, fhirSchema, path, element) {
     if (!element.binding?.valueSet)
         return undefined;
-    const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName, packageInfo);
-    const fieldType = buildFieldType(fhirSchema, path, element, register, packageInfo);
-    const valueSetIdentifier = mkValueSetIdentifier(element.binding.valueSet, undefined, packageInfo);
+    const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
+    const fieldType = buildFieldType(register, fhirSchema, element);
+    const valueSetIdentifier = mkValueSetIdentifier(register, element.binding.valueSet);
     const dependencies = [];
     if (fieldType) {
         dependencies.push(fieldType);
     }
     dependencies.push(valueSetIdentifier);
-    const enumValues = await buildEnum(element, register);
+    const enumValues = buildEnum(element, register);
     return {
         identifier,
         type: fieldType,
@@ -129,37 +114,30 @@ export async function generateBindingSchema(fhirSchema, path, element, register,
         dependencies,
     };
 }
-/**
- * Collect all binding schemas from a FHIRSchema
- */
-export async function collectBindingSchemas(fhirSchema, register) {
-    const packageInfo = fhirSchema.package_meta;
-    const bindings = [];
+export async function collectBindingSchemas(register, fhirSchema) {
     const processedPaths = new Set();
-    // Recursive function to process elements
-    async function processElement(elements, parentPath) {
+    if (!fhirSchema.elements)
+        return [];
+    const bindings = [];
+    async function collectBindings(elements, parentPath) {
         for (const [key, element] of Object.entries(elements)) {
             const path = [...parentPath, key];
             const pathKey = path.join(".");
-            // Skip if already processed
             if (processedPaths.has(pathKey))
                 continue;
             processedPaths.add(pathKey);
-            // Generate binding if present
             if (element.binding) {
-                const binding = await generateBindingSchema(fhirSchema, path, element, register, packageInfo);
+                const binding = await generateBindingSchema(register, fhirSchema, path, element);
                 if (binding) {
                     bindings.push(binding);
                 }
             }
             if (element.elements) {
-                await processElement(element.elements, path);
+                await collectBindings(element.elements, path);
             }
         }
     }
-    if (fhirSchema.elements) {
-        await processElement(fhirSchema.elements, []);
-    }
+    await collectBindings(fhirSchema.elements, []);
     bindings.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
     const uniqueBindings = [];
     const seenUrls = new Set();

package/dist/typeschema/core/field-builder.d.ts

@@ -3,14 +3,13 @@
  *
  * Functions for transforming FHIRSchema elements into TypeSchema fields
  */
-import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
 import type { FHIRSchemaElement } from "@atomic-ehr/fhirschema";
 import type { Register } from "@root/typeschema/register";
 import type { Field, Identifier, PackageMeta, RegularField, RichFHIRSchema } from "../types";
 export declare function isRequired(register: Register, fhirSchema: RichFHIRSchema, path: string[]): boolean;
 export declare function isExcluded(register: Register, fhirSchema: RichFHIRSchema, path: string[]): boolean;
 export declare const buildReferences: (element: FHIRSchemaElement, register: Register, _packageInfo?: PackageMeta) => Identifier[] | undefined;
-export declare function buildFieldType(fhirSchema: RichFHIRSchema, _path: string[], element: FHIRSchemaElement, _manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageMeta): Identifier | undefined;
+export declare function buildFieldType(register: Register, fhirSchema: RichFHIRSchema, element: FHIRSchemaElement): Identifier | undefined;
 export declare const mkField: (register: Register, fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement) => Field;
 export declare function isNestedElement(element: FHIRSchemaElement): boolean;
 export declare function mkNestedField(register: Register, fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement): RegularField;

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

@@ -48,7 +48,7 @@ export const buildReferences = (element, register, _packageInfo) => {
         return mkIdentifier(fs);
     });
 };
-export function buildFieldType(fhirSchema, _path, element, _manager, packageInfo) {
+export function buildFieldType(register, fhirSchema, element) {
     // Handle element reference (for slicing)
     if (element.elementReference) {
         const refPath = element.elementReference
@@ -60,20 +60,19 @@ export function buildFieldType(fhirSchema, _path, element, _manager, packageInfo
             return mkNestedIdentifier(fhirSchema, refPath);
         }
     }
-    // Handle normal type
     if (element.type) {
-        const typeUrl = element.type.includes("/")
-            ? element.type
-            : `http://hl7.org/fhir/StructureDefinition/${element.type}`;
-        // Always create a type identifier, even if we can't resolve
         const kind = element.type.match(/^[a-z]/) ? "primitive-type" : "complex-type";
-        const isStandardFhir = typeUrl.startsWith("http://hl7.org/fhir/");
+        const url = register.ensureCanonicalUrl(element.type);
+        const fieldFs = register.resolveFs(url);
+        if (!fieldFs) {
+            throw new Error(`Could not resolve field '${element.type}'`);
+        }
         return {
             kind: kind,
-            package: isStandardFhir ? "hl7.fhir.r4.core" : packageInfo?.name || "undefined",
-            version: isStandardFhir ? "4.0.1" : packageInfo?.version || "undefined",
+            package: fieldFs.package_meta.name,
+            version: fieldFs.package_meta.version,
             name: element.type,
-            url: typeUrl,
+            url: url,
         };
     }
     return undefined;
@@ -82,13 +81,13 @@ export const mkField = (register, fhirSchema, path, element) => {
     let binding;
     let enumValues;
     if (element.binding) {
-        binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName, fhirSchema.package_meta);
+        binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
         if (element.binding.strength === "required" && element.type === "code") {
             enumValues = buildEnum(element, register);
         }
     }
     return {
-        type: buildFieldType(fhirSchema, path, element, register, fhirSchema.package_meta),
+        type: buildFieldType(register, fhirSchema, element),
         required: isRequired(register, fhirSchema, path),
         excluded: isExcluded(register, fhirSchema, path),
         reference: buildReferences(element, register, fhirSchema.package_meta),

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

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

package/dist/typeschema/core/identifier.js

@@ -4,9 +4,8 @@
  * Functions for creating TypeSchema identifiers from FHIRSchema entities
  */
 export function dropVersionFromUrl(url) {
-    if (!url)
-        return undefined;
-    return url.split("|")[0];
+    const baseUrl = url.split("|")[0];
+    return baseUrl ? baseUrl : url;
 }
 function determineKind(fhirSchema) {
     if (fhirSchema.derivation === "constraint")
@@ -38,12 +37,13 @@ export function mkNestedIdentifier(fhirSchema, path) {
         url: `${fhirSchema.url}#${nestedName}`,
     };
 }
-export function mkValueSetIdentifier(valueSetUrl, valueSet, packageInfo) {
-    const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
+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 = cleanUrl.split("/");
+    const urlParts = valueSetUrl.split("/");
     const lastSegment = urlParts[urlParts.length - 1];
     if (lastSegment && lastSegment.length > 0) {
         // Convert kebab-case or snake_case to PascalCase for better readability
@@ -59,21 +59,24 @@ export function mkValueSetIdentifier(valueSetUrl, valueSet, packageInfo) {
     }
     return {
         kind: "value-set",
-        package: packageInfo?.name || valueSet?.package_name || "undefined",
-        version: packageInfo?.version || valueSet?.package_version || "undefined",
+        package: valueSet?.package_meta.name,
+        version: valueSet?.package_meta.version,
         name: name,
-        url: cleanUrl,
+        url: valueSetUrl,
     };
 }
-export function mkBindingIdentifier(fhirSchema, path, bindingName, _packageInfo) {
+export function mkBindingIdentifier(fhirSchema, path, bindingName) {
     const pathStr = path.join(".");
-    const [name, url] = bindingName
-        ? [bindingName, `urn:fhir:binding:${bindingName}`]
-        : [`${fhirSchema.name}.${pathStr}_binding`, `${fhirSchema.url}#${pathStr}_binding`];
+    // NOTE: if SD specify `bindingName`, the definition should be shared between all
+    // packages. So we put it in the dedicated shared package.
+    // TODO: provide setting for `shared` package name.
+    const [pkg, name, url] = bindingName
+        ? [{ name: "shared", version: "1.0.0" }, bindingName, `urn:fhir:binding:${bindingName}`]
+        : [fhirSchema.package_meta, `${fhirSchema.name}.${pathStr}_binding`, `${fhirSchema.url}#${pathStr}_binding`];
     return {
         kind: "binding",
-        package: fhirSchema.package_meta.name,
-        version: fhirSchema.package_meta.version,
+        package: pkg.name,
+        version: pkg.version,
         name: name,
         url: url,
     };

package/dist/typeschema/core/transformer.js

@@ -236,7 +236,7 @@ async function transformResource(register, fhirSchema) {
         description: fhirSchema.description,
         dependencies,
     };
-    const bindingSchemas = await collectBindingSchemas(fhirSchema, register);
+    const bindingSchemas = await collectBindingSchemas(register, fhirSchema);
     return [typeSchema, ...bindingSchemas];
 }
 export async function transformFHIRSchema(register, fhirSchema) {
@@ -247,7 +247,7 @@ export async function transformFHIRSchema(register, fhirSchema) {
         const profileSchema = await transformProfile(register, fhirSchema);
         results.push(profileSchema);
         // Collect binding schemas for profiles too
-        const bindingSchemas = await collectBindingSchemas(fhirSchema, register);
+        const bindingSchemas = await collectBindingSchemas(register, fhirSchema);
         results.push(...bindingSchemas);
         return results;
     }

package/dist/typeschema/generator.js

@@ -80,7 +80,7 @@ export class TypeSchemaGenerator {
             let valueSetFailedCount = 0;
             for (const vs of valueSets) {
                 try {
-                    const valueSetSchema = await transformValueSet(vs, this.manager, packageInfo);
+                    const valueSetSchema = await transformValueSet(vs, await registerFromManager(this.manager), packageInfo);
                     if (valueSetSchema) {
                         valueSetSchemas.push(valueSetSchema);
                         valueSetConvertedCount++;

package/dist/typeschema/register.d.ts

@@ -4,7 +4,7 @@ import type { CodegenLogger } from "@root/utils/codegen-logger";
 import type { CanonicalUrl, Name, PackageMeta, RichFHIRSchema } from "@typeschema/types";
 export type Register = {
     appendFs(fs: FHIRSchema): void;
-    ensureCanonicalUrl(name: Name | CanonicalUrl): CanonicalUrl;
+    ensureCanonicalUrl(name: string | Name | CanonicalUrl): CanonicalUrl;
     resolveSd(canonicalUrl: CanonicalUrl): StructureDefinition | undefined;
     resolveFs(canonicalUrl: CanonicalUrl): RichFHIRSchema | undefined;
     resolveFsGenealogy(canonicalUrl: CanonicalUrl): RichFHIRSchema[];

package/dist/typeschema/register.js

@@ -1,6 +1,7 @@
 import { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
 import * as fhirschema from "@atomic-ehr/fhirschema";
 import { enrichFHIRSchema } from "@typeschema/types";
+// FIXME: working with multiple packages
 export const registerFromManager = async (manager, logger, packageInfo) => {
     const resources = await manager.search({});
     const any = {};
@@ -36,6 +37,9 @@ export const registerFromManager = async (manager, logger, packageInfo) => {
     const valueSets = {};
     for (const resource of resources) {
         if (resource.resourceType === "ValueSet") {
+            if (!resource.package_meta) {
+                resource.package_meta = packageInfo;
+            }
             valueSets[resource.url] = resource;
         }
     }

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

@@ -4,6 +4,7 @@
  * 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
@@ -16,4 +17,4 @@ export declare function extractValueSetConcepts(valueSet: any, manager: ReturnTy
 /**
  * Transform a FHIR ValueSet to TypeSchema format
  */
-export declare function transformValueSet(valueSet: any, manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageMeta): Promise<ValueSetTypeSchema>;
+export declare function transformValueSet(valueSet: any, register: Register, packageInfo?: PackageMeta): Promise<ValueSetTypeSchema>;

package/dist/typeschema/value-set/processor.js

@@ -116,8 +116,8 @@ export async function extractValueSetConcepts(valueSet, manager) {
 /**
  * Transform a FHIR ValueSet to TypeSchema format
  */
-export async function transformValueSet(valueSet, manager, packageInfo) {
-    const identifier = mkValueSetIdentifier(valueSet.url, valueSet, packageInfo);
+export async function transformValueSet(valueSet, register, packageInfo) {
+    const identifier = mkValueSetIdentifier(valueSet.url, valueSet);
     const typeSchemaValueSet = {
         identifier,
     };
@@ -126,7 +126,7 @@ export async function transformValueSet(valueSet, manager, packageInfo) {
         typeSchemaValueSet.description = valueSet.description;
     }
     // Try to extract concepts
-    const concepts = await extractValueSetConcepts(valueSet, manager);
+    const concepts = await extractValueSetConcepts(valueSet, register);
     if (concepts && concepts.length > 0) {
         // If we can expand, include the concepts
         typeSchemaValueSet.concept = concepts;
@@ -152,7 +152,7 @@ export async function transformValueSet(valueSet, manager, packageInfo) {
                 }
                 if (item.valueSet) {
                     for (const vsUrl of item.valueSet) {
-                        deps.push(mkValueSetIdentifier(vsUrl, undefined, packageInfo));
+                        deps.push(mkValueSetIdentifier(register, vsUrl));
                     }
                 }
             }

package/package.json

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