@atomic-ehr/codegen 0.0.1-canary.20251001075906.44a8bb9 → 0.0.1-canary.20251001154933.613f6c7

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

@@ -3,23 +3,23 @@
  *
  * Functions for processing value set bindings and generating enums
  */
-import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
 import type { FHIRSchemaElement } from "@atomic-ehr/fhirschema";
-import type { PackageMeta, RichFHIRSchema, TypeSchemaForBinding } from "../types";
+import type { Register } from "@typeschema/register";
+import type { CanonicalUrl, PackageMeta, RichFHIRSchema, TypeSchemaForBinding } from "@typeschema/types";
 /**
  * Extract concepts from a ValueSet
  */
-export declare function extractValueSetConcepts(valueSetUrl: string, manager: ReturnType<typeof CanonicalManager>): Promise<Array<{
+export declare function extractValueSetConcepts(valueSetUrl: CanonicalUrl, register: Register): {
     system: string;
     code: string;
     display?: string;
-}> | undefined>;
+}[] | undefined;
 /**
  * Build enum values from binding if applicable
  */
-export declare function buildEnum(element: FHIRSchemaElement, manager: ReturnType<typeof CanonicalManager>): Promise<string[] | undefined>;
-export declare function generateBindingSchema(fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement, manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageMeta): Promise<TypeSchemaForBinding | undefined>;
+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<TypeSchemaForBinding | undefined>;
 /**
  * Collect all binding schemas from a FHIRSchema
  */
-export declare function collectBindingSchemas(fhirSchema: RichFHIRSchema, manager: ReturnType<typeof CanonicalManager>): Promise<TypeSchemaForBinding[]>;
+export declare function collectBindingSchemas(fhirSchema: RichFHIRSchema, register: Register): Promise<TypeSchemaForBinding[]>;

package/dist/typeschema/core/binding.js

@@ -8,10 +8,10 @@ import { dropVersionFromUrl, mkBindingIdentifier, mkValueSetIdentifier } from ".
 /**
  * Extract concepts from a ValueSet
  */
-export async function extractValueSetConcepts(valueSetUrl, manager) {
+export function extractValueSetConcepts(valueSetUrl, register) {
     try {
         const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
-        const valueSet = await manager.resolve(cleanUrl);
+        const valueSet = register.resolveVs(cleanUrl);
         if (!valueSet)
             return undefined;
         // If expansion is available, use it
@@ -39,7 +39,7 @@ export async function extractValueSetConcepts(valueSetUrl, manager) {
                 else if (include.system && !include.filter) {
                     // Include all from CodeSystem
                     try {
-                        const codeSystem = await manager.resolve(include.system);
+                        const codeSystem = register.resolveAny(include.system);
                         if (codeSystem?.concept) {
                             const extractConcepts = (conceptList, system) => {
                                 for (const concept of conceptList) {
@@ -72,7 +72,7 @@ export async function extractValueSetConcepts(valueSetUrl, manager) {
 /**
  * Build enum values from binding if applicable
  */
-export async function buildEnum(element, manager) {
+export function buildEnum(element, register) {
     if (!element.binding)
         return undefined;
     const { strength, valueSet } = element.binding;
@@ -90,12 +90,8 @@ export async function buildEnum(element, manager) {
     if (!shouldGenerateEnum) {
         return undefined;
     }
-    // Check if manager is available and functional
-    if (!manager.resolve) {
-        return undefined;
-    }
     try {
-        const concepts = await extractValueSetConcepts(valueSet, manager);
+        const concepts = extractValueSetConcepts(valueSet, register);
         if (!concepts || concepts.length === 0)
             return undefined;
         // Extract just the codes and filter out any empty/invalid ones
@@ -112,18 +108,18 @@ export async function buildEnum(element, manager) {
         return undefined;
     }
 }
-export async function generateBindingSchema(fhirSchema, path, element, manager, packageInfo) {
+export async function generateBindingSchema(fhirSchema, path, element, register, packageInfo) {
     if (!element.binding?.valueSet)
         return undefined;
     const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName, packageInfo);
-    const fieldType = buildFieldType(fhirSchema, path, element, manager, packageInfo);
+    const fieldType = buildFieldType(fhirSchema, path, element, register, packageInfo);
     const valueSetIdentifier = mkValueSetIdentifier(element.binding.valueSet, undefined, packageInfo);
     const dependencies = [];
     if (fieldType) {
         dependencies.push(fieldType);
     }
     dependencies.push(valueSetIdentifier);
-    const enumValues = await buildEnum(element, manager);
+    const enumValues = await buildEnum(element, register);
     return {
         identifier,
         type: fieldType,
@@ -136,7 +132,7 @@ export async function generateBindingSchema(fhirSchema, path, element, manager,
 /**
  * Collect all binding schemas from a FHIRSchema
  */
-export async function collectBindingSchemas(fhirSchema, manager) {
+export async function collectBindingSchemas(fhirSchema, register) {
     const packageInfo = fhirSchema.package_meta;
     const bindings = [];
     const processedPaths = new Set();
@@ -151,7 +147,7 @@ export async function collectBindingSchemas(fhirSchema, manager) {
             processedPaths.add(pathKey);
             // Generate binding if present
             if (element.binding) {
-                const binding = await generateBindingSchema(fhirSchema, path, element, manager, packageInfo);
+                const binding = await generateBindingSchema(fhirSchema, path, element, register, packageInfo);
                 if (binding) {
                     bindings.push(binding);
                 }

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

@@ -6,20 +6,14 @@
 import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
 import type { FHIRSchema, FHIRSchemaElement } from "@atomic-ehr/fhirschema";
 import type { Register } from "@root/typeschema/register";
-import type { Identifier, PackageMeta, RichFHIRSchema, TypeSchemaField } from "../types";
-export declare function isRequired(fhirSchema: FHIRSchema, path: string[], _manager: ReturnType<typeof CanonicalManager>): boolean;
-/**
- * Check if a field is excluded
- */
-export declare function isExcluded(fhirSchema: FHIRSchema, path: string[], _manager: ReturnType<typeof CanonicalManager>): boolean;
+import type { Field, Identifier, PackageMeta, RegularField, RichFHIRSchema } from "../types";
+export declare function isRequired(fhirSchema: FHIRSchema, path: string[]): boolean;
+export declare function isExcluded(fhirSchema: FHIRSchema, path: string[]): boolean;
 export declare const buildReferences: (element: FHIRSchemaElement, register: Register, _packageInfo?: PackageMeta) => Identifier[] | undefined;
 /**
  * Build field type identifier
  */
 export declare function buildFieldType(fhirSchema: RichFHIRSchema, _path: string[], element: FHIRSchemaElement, _manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageMeta): Identifier | undefined;
-export declare const buildField: (fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement, register: Register, packageInfo?: PackageMeta) => TypeSchemaField;
-/**
- * Check if an element represents a nested type (BackboneElement)
- */
+export declare const mkField: (register: Register, fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement) => Field;
 export declare function isNestedElement(element: FHIRSchemaElement): boolean;
-export declare function mkNestedField(fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement, manager: ReturnType<typeof CanonicalManager>, _packageInfo?: PackageMeta): TypeSchemaField;
+export declare function mkNestedField(_register: Register, fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement): RegularField;

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

@@ -5,7 +5,7 @@
  */
 import { buildEnum } from "./binding";
 import { mkBindingIdentifier, mkIdentifier, mkNestedIdentifier } from "./identifier";
-export function isRequired(fhirSchema, path, _manager) {
+export function isRequired(fhirSchema, path) {
     if (path.length === 0)
         return false;
     const fieldName = path[path.length - 1];
@@ -27,10 +27,7 @@ export function isRequired(fhirSchema, path, _manager) {
     }
     return false;
 }
-/**
- * Check if a field is excluded
- */
-export function isExcluded(fhirSchema, path, _manager) {
+export function isExcluded(fhirSchema, path) {
     if (path.length === 0)
         return false;
     const fieldName = path[path.length - 1];
@@ -94,51 +91,47 @@ export function buildFieldType(fhirSchema, _path, element, _manager, packageInfo
     }
     return undefined;
 }
-export const buildField = (fhirSchema, path, element, register, packageInfo) => {
+export const mkField = (register, fhirSchema, path, element) => {
     let binding;
-    let _enumValues;
+    let enumValues;
     if (element.binding) {
-        binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName, packageInfo);
+        binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName, fhirSchema.package_meta);
         if (element.binding.strength === "required" && element.type === "code") {
-            _enumValues = buildEnum(element, register);
+            enumValues = buildEnum(element, register);
         }
     }
     return {
-        type: buildFieldType(fhirSchema, path, element, register, packageInfo),
-        required: isRequired(fhirSchema, path, register),
-        excluded: isExcluded(fhirSchema, path, register),
-        reference: buildReferences(element, register, packageInfo),
+        type: buildFieldType(fhirSchema, path, element, register, fhirSchema.package_meta),
+        required: isRequired(fhirSchema, path),
+        excluded: isExcluded(fhirSchema, path),
+        reference: buildReferences(element, register, fhirSchema.package_meta),
         array: element.array || false,
         min: element.min,
         max: element.max,
         choices: element.choices,
         choiceOf: element.choiceOf,
         binding: binding,
+        enum: enumValues,
     };
 };
-function _removeEmptyValues(obj) {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-        if (value !== undefined && value !== null) {
-            if (Array.isArray(value) && value.length === 0) {
-                continue;
-            }
-            result[key] = value;
-        }
-    }
-    return result;
-}
-/**
- * Check if an element represents a nested type (BackboneElement)
- */
 export function isNestedElement(element) {
-    return (element.type === "BackboneElement" || (element.elements && Object.keys(element.elements).length > 0) || false);
+    const isBackbone = element.type === "BackboneElement";
+    const isElement = element.type === "Element" && element.elements !== undefined && Object.keys(element.elements).length > 0;
+    // TODO: Observation <- vitalsigns <- bodyweight
+    // In Observation we have value[x] with choices
+    // In bodyweight we have valueQuantity with additional constaraints on it's elements
+    // So we need to build nested type from Quantity for here, but don't do that right now.
+    const elementsWithoutType = element.type === undefined &&
+        element.choiceOf === undefined &&
+        element.elements !== undefined &&
+        Object.keys(element.elements).length > 0;
+    return isBackbone || isElement || elementsWithoutType;
 }
-export function mkNestedField(fhirSchema, path, element, manager, _packageInfo) {
+export function mkNestedField(_register, fhirSchema, path, element) {
     return {
         type: mkNestedIdentifier(fhirSchema, path),
         array: element.array || false,
-        required: isRequired(fhirSchema, path, manager),
-        excluded: isExcluded(fhirSchema, path, manager),
+        required: isRequired(fhirSchema, path),
+        excluded: isExcluded(fhirSchema, path),
     };
 }

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

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

package/dist/typeschema/core/nested-types.d.ts

@@ -5,17 +5,8 @@
  */
 import type { FHIRSchema, FHIRSchemaElement } from "@atomic-ehr/fhirschema";
 import type { Register } from "@root/typeschema/register";
-import type { Identifier, PackageMeta, RichFHIRSchema, TypeSchemaField, TypeSchemaNestedType } from "../types";
-/**
- * Collect all nested elements from a FHIRSchema
- */
+import type { Field, Identifier, NestedType, PackageMeta, RichFHIRSchema } from "../types";
 export declare function collectNestedElements(fhirSchema: FHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement>): Array<[string[], FHIRSchemaElement]>;
-export declare function transformNestedElements(fhirSchema: RichFHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement>, register: Register, packageInfo?: PackageMeta): Promise<Record<string, TypeSchemaField>>;
-/**
- * Build TypeSchema for all nested types in a FHIRSchema
- */
-export declare function buildNestedTypes(fhirSchema: RichFHIRSchema, register: Register, packageInfo?: PackageMeta): Promise<any[] | undefined>;
-/**
- * Extract dependencies from nested types
- */
-export declare function extractNestedDependencies(nestedTypes: TypeSchemaNestedType[]): Identifier[];
+export declare function transformNestedElements(fhirSchema: RichFHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement>, register: Register, _packageInfo?: PackageMeta): Promise<Record<string, Field>>;
+export declare function mkNestedTypes(register: Register, fhirSchema: RichFHIRSchema): Promise<NestedType[] | undefined>;
+export declare function extractNestedDependencies(nestedTypes: NestedType[]): Identifier[];

package/dist/typeschema/core/nested-types.js

@@ -3,51 +3,40 @@
  *
  * Functions for extracting and transforming nested types from FHIRSchema
  */
-import { buildField, isNestedElement, mkNestedField } from "./field-builder";
+import { isNestedElement, mkField, mkNestedField } from "./field-builder";
 import { mkNestedIdentifier } from "./identifier";
-/**
- * Collect all nested elements from a FHIRSchema
- */
 export function collectNestedElements(fhirSchema, parentPath, elements) {
     const nested = [];
     for (const [key, element] of Object.entries(elements)) {
         const path = [...parentPath, key];
-        // Add this element if it's nested (BackboneElement or has elements)
         if (isNestedElement(element)) {
             nested.push([path, element]);
         }
-        // Recursively collect from child elements
         if (element.elements) {
             nested.push(...collectNestedElements(fhirSchema, path, element.elements));
         }
     }
     return nested;
 }
-export async function transformNestedElements(fhirSchema, parentPath, elements, register, packageInfo) {
+export async function transformNestedElements(fhirSchema, parentPath, elements, register, _packageInfo) {
     const fields = {};
     for (const [key, element] of Object.entries(elements)) {
         const path = [...parentPath, key];
         if (isNestedElement(element)) {
-            // Reference to another nested type
-            fields[key] = mkNestedField(fhirSchema, path, element, register, packageInfo);
+            fields[key] = mkNestedField(register, fhirSchema, path, element);
         }
         else {
-            // Regular field
-            fields[key] = await buildField(fhirSchema, path, element, register, packageInfo);
+            fields[key] = mkField(register, fhirSchema, path, element);
         }
     }
     return fields;
 }
-/**
- * Build TypeSchema for all nested types in a FHIRSchema
- */
-export async function buildNestedTypes(fhirSchema, register, packageInfo) {
+export async function mkNestedTypes(register, fhirSchema) {
     if (!fhirSchema.elements)
         return undefined;
-    const nestedTypes = [];
     const nestedElements = collectNestedElements(fhirSchema, [], fhirSchema.elements);
-    // Filter to only include elements that have sub-elements (actual nested types)
     const actualNested = nestedElements.filter(([_, element]) => element.elements && Object.keys(element.elements).length > 0);
+    const nestedTypes = [];
     for (const [path, element] of actualNested) {
         const identifier = mkNestedIdentifier(fhirSchema, path);
         // Base is usually BackboneElement - ensure all nested types have a base
@@ -57,8 +46,8 @@ export async function buildNestedTypes(fhirSchema, register, packageInfo) {
             // For BackboneElement or undefined type, always use BackboneElement as base
             base = {
                 kind: "complex-type",
-                package: packageInfo?.name || "hl7.fhir.r4.core",
-                version: packageInfo?.version || "4.0.1",
+                package: fhirSchema.package_meta.name,
+                version: fhirSchema.package_meta.version,
                 name: "BackboneElement",
                 url: "http://hl7.org/fhir/StructureDefinition/BackboneElement",
             };
@@ -67,38 +56,31 @@ export async function buildNestedTypes(fhirSchema, register, packageInfo) {
             // Use the specified type as base
             base = {
                 kind: "complex-type",
-                package: packageInfo?.name || "hl7.fhir.r4.core",
-                version: packageInfo?.version || "4.0.1",
+                package: fhirSchema.package_meta.name,
+                version: fhirSchema.package_meta.version,
                 name: element.type,
                 url: `http://hl7.org/fhir/StructureDefinition/${element.type}`,
             };
         }
         // Transform sub-elements into fields
-        const fields = await transformNestedElements(fhirSchema, path, element.elements, register, packageInfo);
+        const fields = await transformNestedElements(fhirSchema, path, element.elements, register, fhirSchema.package_meta);
         const nestedType = {
             identifier,
-            base, // Always include base
+            base,
             fields,
         };
         nestedTypes.push(nestedType);
     }
     // Sort by URL for consistent output
     nestedTypes.sort((a, b) => a.identifier.url.localeCompare(b.identifier.url));
-    return nestedTypes;
+    return nestedTypes.length === 0 ? undefined : nestedTypes;
 }
-/**
- * Extract dependencies from nested types
- */
 export function extractNestedDependencies(nestedTypes) {
     const deps = [];
     for (const nested of nestedTypes) {
-        // Add the nested type itself as a dependency
-        deps.push(nested.identifier);
-        // Add base dependency
         if (nested.base) {
             deps.push(nested.base);
         }
-        // Add field type dependencies
         for (const field of Object.values(nested.fields || {})) {
             if ("type" in field && field.type) {
                 deps.push(field.type);

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

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

package/dist/typeschema/core/transformer.js

@@ -6,23 +6,37 @@
 import { fsElementSnapshot, resolveFsElementGenealogy } from "@typeschema/register";
 import { transformProfile } from "../profile/processor";
 import { collectBindingSchemas } from "./binding";
-import { buildField, isNestedElement, mkNestedField } from "./field-builder";
+import { isNestedElement, mkField, mkNestedField } from "./field-builder";
 import { mkIdentifier } from "./identifier";
-import { buildNestedTypes, extractNestedDependencies } from "./nested-types";
-export async function transformElements(register, fhirSchema, parentPath, elements) {
+import { extractNestedDependencies, mkNestedTypes } from "./nested-types";
+export async function mkFields(register, fhirSchema, parentPath, elements) {
     if (!elements)
         return undefined;
     const geneology = register.resolveFsGenealogy(fhirSchema.url);
-    const fields = {};
-    for (const [key, _element] of Object.entries(elements)) {
+    const elems = {};
+    for (const [key, elem] of Object.entries(elements)) {
         const path = [...parentPath, key];
         const elemGeneology = resolveFsElementGenealogy(geneology, path);
-        const snapshot = fsElementSnapshot(elemGeneology);
-        if (isNestedElement(snapshot)) {
-            fields[key] = mkNestedField(fhirSchema, path, snapshot, register, fhirSchema.package_meta);
+        const elemSnapshot = fsElementSnapshot(elemGeneology);
+        elems[key] = { elem, elemSnapshot, path };
+    }
+    for (const [_key, { elem, elemSnapshot, path }] of Object.entries(elems)) {
+        for (const choiceKey of elem?.choices || []) {
+            if (!elems[choiceKey]) {
+                const path = [...parentPath, choiceKey];
+                const elemGeneology = resolveFsElementGenealogy(geneology, path);
+                const elemSnapshot = fsElementSnapshot(elemGeneology);
+                elems[choiceKey] = { elem: undefined, elemSnapshot, path };
+            }
+        }
+    }
+    const fields = {};
+    for (const [key, { elem, elemSnapshot, path }] of Object.entries(elems)) {
+        if (isNestedElement(elemSnapshot)) {
+            fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot);
         }
         else {
-            fields[key] = buildField(fhirSchema, path, snapshot, register, fhirSchema.package_meta);
+            fields[key] = mkField(register, fhirSchema, path, elemSnapshot);
         }
     }
     return fields;
@@ -115,7 +129,7 @@ async function transformValueSet(fhirSchema, _register, _packageInfo) {
 /**
  * Transform an Extension FHIRSchema to TypeSchema with extension metadata
  */
-async function transformExtension(fhirSchema, register, packageInfo) {
+async function transformExtension(fhirSchema, register, _packageInfo) {
     try {
         const identifier = mkIdentifier(fhirSchema);
         // Build base identifier if present
@@ -158,14 +172,14 @@ async function transformExtension(fhirSchema, register, packageInfo) {
         }
         // Transform elements into fields if present
         if (fhirSchema.elements) {
-            const fields = await transformElements(register, fhirSchema, [], fhirSchema.elements);
+            const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements);
             if (fields && Object.keys(fields).length > 0) {
                 extensionSchema.fields = fields;
                 extensionSchema.dependencies.push(...extractFieldDependencies(fields));
             }
         }
         // Build nested types
-        const nestedTypes = await buildNestedTypes(fhirSchema, register, packageInfo);
+        const nestedTypes = await mkNestedTypes(register, fhirSchema);
         if (nestedTypes && nestedTypes.length > 0) {
             extensionSchema.nested = nestedTypes;
             extensionSchema.dependencies.push(...extractNestedDependencies(nestedTypes));
@@ -195,7 +209,10 @@ function extractDependencies(identifier, base, fields, nestedTypes) {
             continue;
         uniqDeps[dep.url] = dep;
     }
-    const result = Object.values(uniqDeps).sort((a, b) => a.name.localeCompare(b.name));
+    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));
     return result.length > 0 ? result : undefined;
 }
 async function transformResource(register, fhirSchema) {
@@ -203,10 +220,13 @@ async function transformResource(register, fhirSchema) {
     let base;
     if (fhirSchema.base && fhirSchema.type !== "Element") {
         const baseFs = register.resolveFs(register.ensureCanonicalUrl(fhirSchema.base));
+        if (!baseFs) {
+            throw new Error(`Base resource not found '${fhirSchema.base}' for '${fhirSchema.url}'`);
+        }
         base = mkIdentifier(baseFs);
     }
-    const fields = await transformElements(register, fhirSchema, [], fhirSchema.elements);
-    const nested = await buildNestedTypes(fhirSchema, register, fhirSchema.package_meta);
+    const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements);
+    const nested = await mkNestedTypes(register, fhirSchema);
     const dependencies = extractDependencies(identifier, base, fields, nested);
     const typeSchema = {
         identifier,

package/dist/typeschema/profile/processor.js

@@ -5,7 +5,7 @@
  * This file is deprecated as profiles are not part of the core TypeSchema specification
  */
 import { mkIdentifier } from "../core/identifier";
-import { transformElements } from "../core/transformer";
+import { mkFields } from "../core/transformer";
 /**
  * Transform a FHIR profile to TypeSchema format
  * Profiles are treated as specialized resources that extend base resources
@@ -54,7 +54,7 @@ export async function transformProfile(register, fhirSchema) {
     }
     // Process profile fields from differential elements
     if (fhirSchema.elements) {
-        const fields = await transformElements(register, fhirSchema, [], fhirSchema.elements);
+        const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements);
         if (fields && Object.keys(fields).length > 0) {
             profileSchema.fields = fields;
         }
@@ -79,10 +79,12 @@ export async function transformProfile(register, fhirSchema) {
 /**
  * Determine the kind of the base type for a profile
  */
-async function determineBaseKind(baseUrl, manager) {
+async function determineBaseKind(baseUrl, register) {
     try {
         // Try to resolve the base schema
-        const baseSchema = await manager.resolve(baseUrl);
+        const baseSchema = register.resolveFs(baseUrl);
+        if (!baseSchema)
+            return "resource";
         if (baseSchema) {
             // If it's also a constraint, it's likely another profile
             if (baseSchema.derivation === "constraint") {

package/dist/typeschema/register.d.ts

@@ -11,7 +11,9 @@ export type Register = {
     allSd(): StructureDefinition[];
     allFs(): RichFHIRSchema[];
     allVs(): any[];
+    resolveVs(canonicalUrl: CanonicalUrl): any | undefined;
     complexTypeDict(): Record<string, RichFHIRSchema>;
+    resolveAny(canonicalUrl: CanonicalUrl): any | undefined;
 } & ReturnType<typeof CanonicalManager>;
 export declare const registerFromManager: (manager: ReturnType<typeof CanonicalManager>, logger?: CodegenLogger, packageInfo?: PackageMeta) => Promise<Register>;
 export declare const registerFromPackageMetas: (packageMetas: PackageMeta[], logger?: CodegenLogger) => Promise<Register>;

package/dist/typeschema/register.js

@@ -3,6 +3,13 @@ import * as fhirschema from "@atomic-ehr/fhirschema";
 import { enrichFHIRSchema } from "@typeschema/types";
 export const registerFromManager = async (manager, logger, packageInfo) => {
     const resources = await manager.search({});
+    const any = {};
+    for (const resource of resources) {
+        const url = resource.url;
+        if (!url)
+            continue;
+        any[url] = resource;
+    }
     const structureDefinitions = {};
     for (const resource of resources) {
         if (resource.resourceType === "StructureDefinition") {
@@ -41,14 +48,13 @@ export const registerFromManager = async (manager, logger, packageInfo) => {
     const resolveFsGenealogy = (canonicalUrl) => {
         let fs = fhirSchemas[canonicalUrl];
         if (fs === undefined)
-            throw new Error(`Failed to resolve FHIR Schema genealogy for ${canonicalUrl}`);
+            throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
         const genealogy = [fs];
         while (fs?.base) {
-            console.log(1, fs.base);
             fs = fhirSchemas[fs.base] || fhirSchemas[nameDict[fs.base]];
             genealogy.push(fs);
             if (fs === undefined)
-                throw new Error(`Failed to resolve FHIR Schema genealogy for ${canonicalUrl}`);
+                throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
         }
         return genealogy;
     };
@@ -57,6 +63,7 @@ export const registerFromManager = async (manager, logger, packageInfo) => {
         appendFs(fs) {
             const rfs = enrichFHIRSchema(fs);
             fhirSchemas[rfs.url] = rfs;
+            nameDict[rfs.name] = rfs.url;
         },
         resolveFs: (canonicalUrl) => fhirSchemas[canonicalUrl],
         resolveFsGenealogy: resolveFsGenealogy,
@@ -65,7 +72,9 @@ export const registerFromManager = async (manager, logger, packageInfo) => {
         resolveSd: (canonicalUrl) => structureDefinitions[canonicalUrl],
         allFs: () => Object.values(fhirSchemas),
         allVs: () => Object.values(valueSets),
+        resolveVs: (canonicalUrl) => valueSets[canonicalUrl],
         complexTypeDict: () => complexTypes,
+        resolveAny: (canonicalUrl) => any[canonicalUrl],
     };
 };
 export const registerFromPackageMetas = async (packageMetas, logger) => {
@@ -97,5 +106,8 @@ export const resolveFsElementGenealogy = (genealogy, path) => {
 };
 export function fsElementSnapshot(genealogy) {
     // FIXME: nested elements will break it
-    return genealogy.reverse().reduce((snapshot, elem) => ({ ...snapshot, ...elem }), {});
+    const snapshot = genealogy.reverse().reduce((snapshot, elem) => ({ ...snapshot, ...elem }), {});
+    // NOTE: to avoid regeneration nested types
+    snapshot.elements = undefined;
+    return snapshot;
 }