@atomic-ehr/codegen 0.0.1-canary.20251001154933.613f6c7 → 0.0.1-canary.20251002082521.96cb084

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

@@ -5,7 +5,7 @@
  */
 import type { FHIRSchemaElement } from "@atomic-ehr/fhirschema";
 import type { Register } from "@typeschema/register";
-import type { CanonicalUrl, PackageMeta, RichFHIRSchema, TypeSchemaForBinding } from "@typeschema/types";
+import type { BindingTypeSchema, CanonicalUrl, PackageMeta, RichFHIRSchema } from "@typeschema/types";
 /**
  * Extract concepts from a ValueSet
  */
@@ -18,8 +18,8 @@ export declare function extractValueSetConcepts(valueSetUrl: CanonicalUrl, regis
  * 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<TypeSchemaForBinding | 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<TypeSchemaForBinding[]>;
+export declare function collectBindingSchemas(fhirSchema: RichFHIRSchema, register: Register): Promise<BindingTypeSchema[]>;

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

@@ -4,16 +4,13 @@
  * Functions for transforming FHIRSchema elements into TypeSchema fields
  */
 import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-import type { FHIRSchema, FHIRSchemaElement } from "@atomic-ehr/fhirschema";
+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(fhirSchema: FHIRSchema, path: string[]): boolean;
-export declare function isExcluded(fhirSchema: FHIRSchema, path: string[]): boolean;
+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;
-/**
- * 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 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;
+export declare function mkNestedField(register: Register, fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement): RegularField;

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

@@ -5,49 +5,37 @@
  */
 import { buildEnum } from "./binding";
 import { mkBindingIdentifier, mkIdentifier, mkNestedIdentifier } from "./identifier";
-export function isRequired(fhirSchema, path) {
-    if (path.length === 0)
-        return false;
+export function isRequired(register, fhirSchema, path) {
     const fieldName = path[path.length - 1];
     const parentPath = path.slice(0, -1);
-    // Navigate to parent element
-    let parentElement = fhirSchema;
-    for (const key of parentPath) {
-        parentElement = parentElement.elements?.[key];
-        if (!parentElement)
-            break;
-    }
-    // Check if field is in required array
-    if (parentElement?.required?.includes(fieldName)) {
-        return true;
-    }
-    // Also check at root level
-    if (parentPath.length === 0 && fieldName && fhirSchema.required?.includes(fieldName)) {
-        return true;
-    }
-    return false;
+    const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs) => {
+        if (parentPath.length === 0)
+            return fs.required || [];
+        if (!fs.elements)
+            return [];
+        let elem = fs;
+        for (const k of parentPath) {
+            elem = elem?.elements?.[k];
+        }
+        return elem?.required || [];
+    });
+    return new Set(requires).has(fieldName);
 }
-export function isExcluded(fhirSchema, path) {
-    if (path.length === 0)
-        return false;
+export function isExcluded(register, fhirSchema, path) {
     const fieldName = path[path.length - 1];
     const parentPath = path.slice(0, -1);
-    // Navigate to parent element
-    let parentElement = fhirSchema;
-    for (const key of parentPath) {
-        parentElement = parentElement.elements?.[key];
-        if (!parentElement)
-            break;
-    }
-    // Check if field is in excluded array
-    if (parentElement?.excluded?.includes(fieldName)) {
-        return true;
-    }
-    // Also check at root level
-    if (parentPath.length === 0 && fieldName && fhirSchema.excluded?.includes(fieldName)) {
-        return true;
-    }
-    return false;
+    const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs) => {
+        if (parentPath.length === 0)
+            return fs.excluded || [];
+        if (!fs.elements)
+            return [];
+        let elem = fs;
+        for (const k of parentPath) {
+            elem = elem?.elements?.[k];
+        }
+        return elem?.excluded || [];
+    });
+    return new Set(requires).has(fieldName);
 }
 export const buildReferences = (element, register, _packageInfo) => {
     if (!element.refers)
@@ -58,9 +46,6 @@ export const buildReferences = (element, register, _packageInfo) => {
         return mkIdentifier(fs);
     });
 };
-/**
- * Build field type identifier
- */
 export function buildFieldType(fhirSchema, _path, element, _manager, packageInfo) {
     // Handle element reference (for slicing)
     if (element.elementReference) {
@@ -102,8 +87,8 @@ export const mkField = (register, fhirSchema, path, element) => {
     }
     return {
         type: buildFieldType(fhirSchema, path, element, register, fhirSchema.package_meta),
-        required: isRequired(fhirSchema, path),
-        excluded: isExcluded(fhirSchema, path),
+        required: isRequired(register, fhirSchema, path),
+        excluded: isExcluded(register, fhirSchema, path),
         reference: buildReferences(element, register, fhirSchema.package_meta),
         array: element.array || false,
         min: element.min,
@@ -127,11 +112,11 @@ export function isNestedElement(element) {
         Object.keys(element.elements).length > 0;
     return isBackbone || isElement || elementsWithoutType;
 }
-export function mkNestedField(_register, fhirSchema, path, element) {
+export function mkNestedField(register, fhirSchema, path, element) {
     return {
         type: mkNestedIdentifier(fhirSchema, path),
         array: element.array || false,
-        required: isRequired(fhirSchema, path),
-        excluded: isExcluded(fhirSchema, path),
+        required: isRequired(register, fhirSchema, path),
+        excluded: isExcluded(register, 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, CanonicalUrl, Identifier, NestedIdentifier, PackageMeta, RichFHIRSchema, TypeSchemaForValueSet } from "@typeschema/types";
+import type { BindingIdentifier, CanonicalUrl, Identifier, NestedIdentifier, PackageMeta, RichFHIRSchema, ValueSetTypeSchema } 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: CanonicalUrl, valueSet: any, packageInfo?: PackageMeta): TypeSchemaForValueSet["identifier"];
+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;

package/dist/typeschema/profile/processor.d.ts

@@ -6,9 +6,9 @@
  */
 import type { Register } from "@root/typeschema/register";
 import type { RichFHIRSchema } from "@typeschema/types";
-import type { TypeSchemaForProfile } from "../types";
+import type { ProfileTypeSchema } from "../types";
 /**
  * Transform a FHIR profile to TypeSchema format
  * Profiles are treated as specialized resources that extend base resources
  */
-export declare function transformProfile(register: Register, fhirSchema: RichFHIRSchema): Promise<TypeSchemaForProfile>;
+export declare function transformProfile(register: Register, fhirSchema: RichFHIRSchema): Promise<ProfileTypeSchema>;

package/dist/typeschema/types.d.ts

@@ -52,8 +52,8 @@ type LogicalIdentifier = {
     kind: "logical";
 } & IdentifierBase;
 export type Identifier = PrimitiveIdentifier | ComplexTypeIdentifier | ResourceIdentifier | NestedIdentifier | BindingIdentifier | ValueSetIdentifier | ProfileIdentifier | LogicalIdentifier;
-export type TypeSchema = TypeSchemaForPrimitiveType | TypeSchemaForResourceComplexTypeLogical | TypeSchemaForValueSet | TypeSchemaForBinding | TypeSchemaForProfile;
-interface TypeSchemaForPrimitiveType {
+export type TypeSchema = RegularTypeSchema | PrimitiveTypeSchema | ValueSetTypeSchema | BindingTypeSchema | ProfileTypeSchema;
+interface PrimitiveTypeSchema {
     identifier: PrimitiveIdentifier;
     description?: string;
     base: Identifier;
@@ -64,7 +64,7 @@ export interface NestedType {
     base: Identifier;
     fields: Record<string, Field>;
 }
-export interface TypeSchemaForProfile {
+export interface ProfileTypeSchema {
     identifier: ProfileIdentifier;
     base: Identifier;
     description?: string;
@@ -121,7 +121,7 @@ export interface ProfileMetadata {
     jurisdiction?: any[];
     package?: string;
 }
-export interface TypeSchemaForResourceComplexTypeLogical {
+export interface RegularTypeSchema {
     identifier: Identifier;
     base?: Identifier;
     description?: string;
@@ -142,7 +142,7 @@ export interface RegularField {
     min?: number;
     max?: number;
 }
-export interface PolymorphicDeclarationField {
+export interface ChoiceFieldDeclaration {
     choices: string[];
     required?: boolean;
     excluded?: boolean;
@@ -150,7 +150,7 @@ export interface PolymorphicDeclarationField {
     min?: number;
     max?: number;
 }
-export interface PolymorphicInstanceField {
+export interface ChoiceFieldInstance {
     choiceOf: string;
     type: Identifier;
     required?: boolean;
@@ -162,7 +162,7 @@ export interface PolymorphicInstanceField {
     min?: number;
     max?: number;
 }
-export interface TypeSchemaForValueSet {
+export interface ValueSetTypeSchema {
     identifier: ValueSetIdentifier;
     description?: string;
     concept?: {
@@ -174,7 +174,7 @@ export interface TypeSchemaForValueSet {
         [k: string]: unknown;
     };
 }
-export interface TypeSchemaForBinding {
+export interface BindingTypeSchema {
     identifier: BindingIdentifier;
     description?: string;
     type?: Identifier;
@@ -183,14 +183,14 @@ export interface TypeSchemaForBinding {
     valueset?: ValueSetIdentifier;
     dependencies?: Identifier[];
 }
-export type Field = RegularField | PolymorphicDeclarationField | PolymorphicInstanceField;
+export type Field = RegularField | ChoiceFieldDeclaration | ChoiceFieldInstance;
 export interface TypeschemaGeneratorOptions {
     verbose?: boolean;
     logger?: import("../utils/codegen-logger").CodegenLogger;
     treeshake?: string[];
     manager?: ReturnType<typeof CanonicalManager> | null;
 }
-export declare function isBindingSchema(schema: TypeSchema): schema is TypeSchemaForBinding;
+export declare function isBindingSchema(schema: TypeSchema): schema is BindingTypeSchema;
 export type TypeschemaParserOptions = {
     format?: "auto" | "ndjson" | "json";
     validate?: boolean;

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

@@ -4,7 +4,7 @@
  * Functions for transforming FHIR ValueSets into TypeSchema format
  */
 import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-import type { PackageMeta, TypeSchemaForValueSet } from "../types";
+import type { PackageMeta, ValueSetTypeSchema } from "../types";
 /**
  * Extract all concepts from a ValueSet
  */
@@ -16,4 +16,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<TypeSchemaForValueSet>;
+export declare function transformValueSet(valueSet: any, manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageMeta): Promise<ValueSetTypeSchema>;

package/package.json

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