@atomic-ehr/codegen 0.0.1-canary.20251001154933.613f6c7 → 0.0.1-canary.20251002074252.e71a294

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/types.d.ts

@@ -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;
@@ -183,7 +183,7 @@ 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;

package/package.json

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