@atomic-ehr/codegen 0.0.1-canary.20250930151649.b68ce8a → 0.0.1-canary.20251001075906.44a8bb9

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

@@ -7,17 +7,6 @@ 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";
-/**
- * Get the full element hierarchy for a given path
- */
-export declare function getElementHierarchy(fhirSchema: FHIRSchema, path: string[], _manager: ReturnType<typeof CanonicalManager>): FHIRSchemaElement[];
-/**
- * Merge element hierarchy into a snapshot
- */
-export declare function mergeElementHierarchy(hierarchy: FHIRSchemaElement[]): FHIRSchemaElement;
-/**
- * Check if a field is required based on parent required arrays
- */
 export declare function isRequired(fhirSchema: FHIRSchema, path: string[], _manager: ReturnType<typeof CanonicalManager>): boolean;
 /**
  * Check if a field is excluded

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

@@ -5,75 +5,6 @@
  */
 import { buildEnum } from "./binding";
 import { mkBindingIdentifier, mkIdentifier, mkNestedIdentifier } from "./identifier";
-/**
- * Get the full element hierarchy for a given path
- */
-export function getElementHierarchy(fhirSchema, path, _manager) {
-    const hierarchy = [];
-    // Get element at path from current schema
-    let element = fhirSchema.elements;
-    for (const key of path) {
-        element = element?.[key];
-        if (!element)
-            break;
-    }
-    if (element) {
-        hierarchy.push(element);
-    }
-    // For now, we only use the current schema's element
-    // TODO: Implement base schema traversal when we have proper schema loading
-    return hierarchy;
-}
-/**
- * Merge element hierarchy into a snapshot
- */
-export function mergeElementHierarchy(hierarchy) {
-    // Handle empty hierarchy
-    if (hierarchy.length === 0) {
-        return {};
-    }
-    // Start with the most specific (first) element
-    const snapshot = { ...hierarchy[0] };
-    // Merge properties from base elements (reverse order to apply from base to specific)
-    for (let i = hierarchy.length - 1; i >= 0; i--) {
-        const element = hierarchy[i];
-        // Properties that should be taken from the most specific element
-        const specificProps = [
-            "choices",
-            "short",
-            "index",
-            "elements",
-            "required",
-            "excluded",
-            "binding",
-            "refers",
-            "elementReference",
-            "mustSupport",
-            "slices",
-            "slicing",
-            "url",
-            "extensions",
-        ];
-        // Merge non-specific properties
-        for (const [key, value] of Object.entries(element)) {
-            if (!specificProps.includes(key) && value !== undefined) {
-                snapshot[key] = value;
-            }
-        }
-    }
-    // Override with specific properties from the first element
-    for (const prop of ["choices", "binding", "refers", "elementReference"]) {
-        // @ts-ignore
-        if (hierarchy[0] && hierarchy[0][prop] !== undefined) {
-            // @ts-ignore
-            snapshot[prop] = hierarchy[0][prop];
-        }
-    }
-    return snapshot;
-}
-/**
- * Check if a field is required based on parent required arrays
- */
 export function isRequired(fhirSchema, path, _manager) {
     if (path.length === 0)
         return false;

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

@@ -9,4 +9,4 @@ export declare function dropVersionFromUrl(url: string | undefined): string | un
 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 mkBindingIdentifier(fhirSchema: FHIRSchema, path: string[], bindingName?: string, packageInfo?: PackageMeta): BindingIdentifier;
+export declare function mkBindingIdentifier(fhirSchema: FHIRSchema, path: string[], bindingName?: string, _packageInfo?: PackageMeta): BindingIdentifier;

package/dist/typeschema/core/identifier.js

@@ -65,7 +65,7 @@ export function mkValueSetIdentifier(valueSetUrl, valueSet, packageInfo) {
         url: cleanUrl,
     };
 }
-export function mkBindingIdentifier(fhirSchema, path, bindingName, packageInfo) {
+export function mkBindingIdentifier(fhirSchema, path, bindingName, _packageInfo) {
     const pathStr = path.join(".");
     const [name, url] = bindingName
         ? [bindingName, `urn:fhir:binding:${bindingName}`]

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

@@ -4,7 +4,7 @@
  * Core transformation logic for converting FHIRSchema to TypeSchema format
  */
 import type { FHIRSchemaElement } from "@atomic-ehr/fhirschema";
-import type { Register } from "@typeschema/register";
+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>;
 export declare function transformFHIRSchema(register: Register, fhirSchema: RichFHIRSchema): Promise<TypeSchema[]>;

package/dist/typeschema/core/transformer.js

@@ -3,19 +3,21 @@
  *
  * Core transformation logic for converting FHIRSchema to TypeSchema format
  */
+import { fsElementSnapshot, resolveFsElementGenealogy } from "@typeschema/register";
 import { transformProfile } from "../profile/processor";
 import { collectBindingSchemas } from "./binding";
-import { buildField, getElementHierarchy, isNestedElement, mergeElementHierarchy, mkNestedField, } from "./field-builder";
+import { buildField, isNestedElement, mkNestedField } from "./field-builder";
 import { mkIdentifier } from "./identifier";
 import { buildNestedTypes, extractNestedDependencies } from "./nested-types";
 export async function transformElements(register, fhirSchema, parentPath, elements) {
     if (!elements)
         return undefined;
+    const geneology = register.resolveFsGenealogy(fhirSchema.url);
     const fields = {};
-    for (const [key, element] of Object.entries(elements)) {
+    for (const [key, _element] of Object.entries(elements)) {
         const path = [...parentPath, key];
-        const hierarchy = getElementHierarchy(fhirSchema, path, register);
-        const snapshot = hierarchy.length > 0 ? mergeElementHierarchy(hierarchy) : element;
+        const elemGeneology = resolveFsElementGenealogy(geneology, path);
+        const snapshot = fsElementSnapshot(elemGeneology);
         if (isNestedElement(snapshot)) {
             fields[key] = mkNestedField(fhirSchema, path, snapshot, register, fhirSchema.package_meta);
         }

package/dist/typeschema/profile/processor.js

@@ -13,7 +13,7 @@ import { transformElements } from "../core/transformer";
 export async function transformProfile(register, fhirSchema) {
     // Build profile identifier
     const identifier = mkIdentifier(fhirSchema);
-    const packageInfo = fhirSchema.package_meta;
+    const _packageInfo = fhirSchema.package_meta;
     // Ensure this is recognized as a profile
     if (identifier.kind !== "profile") {
         throw new Error(`Expected profile, got ${identifier.kind} for ${fhirSchema.name}`);

package/dist/typeschema/register.d.ts

@@ -7,7 +7,7 @@ export type Register = {
     ensureCanonicalUrl(name: Name | CanonicalUrl): CanonicalUrl;
     resolveSd(canonicalUrl: CanonicalUrl): StructureDefinition | undefined;
     resolveFs(canonicalUrl: CanonicalUrl): RichFHIRSchema | undefined;
-    resolveFsGenealogy(canonicalUrl: CanonicalUrl): RichFHIRSchema[] | undefined;
+    resolveFsGenealogy(canonicalUrl: CanonicalUrl): RichFHIRSchema[];
     allSd(): StructureDefinition[];
     allFs(): RichFHIRSchema[];
     allVs(): any[];

package/dist/typeschema/register.js

@@ -40,12 +40,15 @@ export const registerFromManager = async (manager, logger, packageInfo) => {
     }
     const resolveFsGenealogy = (canonicalUrl) => {
         let fs = fhirSchemas[canonicalUrl];
-        if (!fs)
-            return undefined;
+        if (fs === undefined)
+            throw new Error(`Failed to resolve FHIR Schema genealogy for ${canonicalUrl}`);
         const genealogy = [fs];
-        while (fs && fs.base) {
-            fs = fhirSchemas[fs.base];
+        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}`);
         }
         return genealogy;
     };

package/package.json

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