@atomic-ehr/codegen 0.0.1-canary.20251006092200.fdb4a88 → 0.0.1-canary.20251006094042.7f0be72

package/dist/typeschema/cache.js

@@ -1,239 +0,0 @@
-/**
- * TypeSchema Cache System
- *
- * Caching system for TypeSchema documents with both in-memory and persistent file-based storage.
- */
-import { existsSync, mkdirSync } from "node:fs";
-import { readdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-/**
- * TypeSchema Cache with optional persistent storage
- */
-export class TypeSchemaCache {
-    cache = new Map();
-    config;
-    cacheDir;
-    constructor(config) {
-        this.config = {
-            enablePersistence: true,
-            cacheDir: ".typeschema-cache",
-            maxAge: 24 * 60 * 60 * 1000, // 24 hours
-            validateCached: true,
-            ...config,
-        };
-        if (this.config.enablePersistence && this.config.cacheDir) {
-            this.cacheDir = this.config.cacheDir;
-        }
-    }
-    /**
-     * Store a schema in the cache
-     */
-    async set(schema) {
-        const key = this.generateKey(schema.identifier);
-        this.cache.set(key, schema);
-        // Persist to disk if enabled
-        if (this.config.enablePersistence && this.cacheDir) {
-            await this.persistSchema(schema);
-        }
-    }
-    /**
-     * Retrieve a schema by identifier
-     */
-    get(identifier) {
-        const key = this.generateKey(identifier);
-        return this.cache.get(key) || null;
-    }
-    /**
-     * Retrieve a schema by URL
-     */
-    getByUrl(url) {
-        for (const schema of this.cache.values()) {
-            if (schema.identifier.url === url) {
-                return schema;
-            }
-        }
-        return null;
-    }
-    /**
-     * Check if a schema exists in cache
-     */
-    has(identifier) {
-        const key = this.generateKey(identifier);
-        return this.cache.has(key);
-    }
-    /**
-     * Check if a schema exists by URL
-     */
-    hasByUrl(url) {
-        for (const schema of this.cache.values()) {
-            if (schema.identifier.url === url) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Delete a schema from cache
-     */
-    delete(identifier) {
-        const key = this.generateKey(identifier);
-        return this.cache.delete(key);
-    }
-    /**
-     * Delete a schema by URL
-     */
-    deleteByUrl(url) {
-        for (const [key, schema] of this.cache.entries()) {
-            if (schema.identifier.url === url) {
-                return this.cache.delete(key);
-            }
-        }
-        return false;
-    }
-    /**
-     * Get schemas by package
-     */
-    getByPackage(packageName) {
-        const results = [];
-        for (const schema of this.cache.values()) {
-            if (schema.identifier.package === packageName) {
-                results.push(schema);
-            }
-        }
-        return results;
-    }
-    /**
-     * Get schemas by kind
-     */
-    getByKind(kind) {
-        const results = [];
-        for (const schema of this.cache.values()) {
-            if (schema.identifier.kind === kind) {
-                results.push(schema);
-            }
-        }
-        return results;
-    }
-    /**
-     * Store multiple schemas
-     */
-    setMany(schemas) {
-        for (const schema of schemas) {
-            this.set(schema);
-        }
-    }
-    /**
-     * Clear all cached schemas
-     */
-    clear() {
-        this.cache.clear();
-    }
-    /**
-     * Generate cache key for identifier
-     */
-    generateKey(identifier) {
-        return `${identifier.package}:${identifier.version}:${identifier.kind}:${identifier.name}`;
-    }
-    /**
-     * Initialize cache directory if persistence is enabled
-     */
-    async initialize() {
-        if (this.config.enablePersistence && this.cacheDir) {
-            // Ensure cache directory exists
-            if (!existsSync(this.cacheDir)) {
-                mkdirSync(this.cacheDir, { recursive: true });
-            }
-            // Load all cached schemas from disk
-            await this.loadFromDisk();
-        }
-    }
-    /**
-     * Load all cached schemas from disk
-     */
-    async loadFromDisk() {
-        if (!this.cacheDir || !existsSync(this.cacheDir)) {
-            return;
-        }
-        try {
-            const files = await readdir(this.cacheDir);
-            const schemaFiles = files.filter((f) => f.endsWith(".typeschema.json"));
-            for (const file of schemaFiles) {
-                const filePath = join(this.cacheDir, file);
-                const stats = await stat(filePath);
-                // Check if cache is expired
-                if (this.config.maxAge) {
-                    const age = Date.now() - stats.mtimeMs;
-                    if (age > this.config.maxAge) {
-                        // Remove expired cache file
-                        await unlink(filePath);
-                        continue;
-                    }
-                }
-                try {
-                    const content = await readFile(filePath, "utf-8");
-                    const metadata = JSON.parse(content);
-                    // Validate cached schema if configured
-                    if (this.config.validateCached) {
-                        // Basic validation - check required fields
-                        if (!metadata.schema?.identifier) {
-                            continue;
-                        }
-                    }
-                    // Add to in-memory cache
-                    const key = this.generateKey(metadata.schema.identifier);
-                    this.cache.set(key, metadata.schema);
-                }
-                catch (error) {
-                    console.warn(`Failed to load cached schema from ${file}:`, error);
-                }
-            }
-        }
-        catch (error) {
-            console.warn("Failed to load cached schemas from disk:", error);
-        }
-    }
-    /**
-     * Persist a schema to disk
-     */
-    async persistSchema(schema) {
-        if (!this.cacheDir) {
-            return;
-        }
-        // Ensure cache directory exists
-        if (!existsSync(this.cacheDir)) {
-            mkdirSync(this.cacheDir, { recursive: true });
-        }
-        const metadata = {
-            schema,
-            timestamp: Date.now(),
-            version: schema.identifier.version,
-        };
-        // Generate filename from identifier
-        const fileName = `${schema.identifier.package}-${schema.identifier.version}-${schema.identifier.kind}-${schema.identifier.name}.typeschema.json`.replace(/[^a-zA-Z0-9.-]/g, "_");
-        const filePath = join(this.cacheDir, fileName);
-        try {
-            await writeFile(filePath, JSON.stringify(metadata, null, 2), "utf-8");
-        }
-        catch (error) {
-            console.warn(`Failed to persist schema to ${filePath}:`, error);
-        }
-    }
-    /**
-     * Clear cache directory
-     */
-    async clearDisk() {
-        if (!this.cacheDir || !existsSync(this.cacheDir)) {
-            return;
-        }
-        try {
-            const files = await readdir(this.cacheDir);
-            const schemaFiles = files.filter((f) => f.endsWith(".typeschema.json"));
-            for (const file of schemaFiles) {
-                await unlink(join(this.cacheDir, file));
-            }
-        }
-        catch (error) {
-            console.warn("Failed to clear cache directory:", error);
-        }
-    }
-}

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

@@ -1,11 +0,0 @@
-/**
- * Binding and Enum Handling
- *
- * Functions for processing value set bindings and generating enums
- */
-import type { FHIRSchemaElement } from "@atomic-ehr/fhirschema";
-import type { Register } from "@typeschema/register";
-import type { BindingTypeSchema, CanonicalUrl, Concept, RichFHIRSchema } from "@typeschema/types";
-export declare function extractValueSetConceptsByUrl(register: Register, valueSetUrl: CanonicalUrl): Concept[] | undefined;
-export declare function buildEnum(register: Register, element: FHIRSchemaElement): string[] | undefined;
-export declare function collectBindingSchemas(register: Register, fhirSchema: RichFHIRSchema): BindingTypeSchema[];

package/dist/typeschema/core/binding.js

@@ -1,143 +0,0 @@
-/**
- * Binding and Enum Handling
- *
- * Functions for processing value set bindings and generating enums
- */
-import { buildFieldType } from "./field-builder";
-import { dropVersionFromUrl, mkBindingIdentifier, mkValueSetIdentifierByUrl } from "./identifier";
-export function extractValueSetConceptsByUrl(register, valueSetUrl) {
-    const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
-    const valueSet = register.resolveVs(cleanUrl);
-    if (!valueSet)
-        return undefined;
-    return extractValueSetConcepts(register, valueSet);
-}
-function extractValueSetConcepts(register, valueSet) {
-    if (valueSet.expansion?.contains)
-        return valueSet.expansion.contains;
-    const concepts = [];
-    if (valueSet.compose?.include) {
-        for (const include of valueSet.compose.include) {
-            if (include.concept) {
-                for (const concept of include.concept) {
-                    concepts.push({
-                        system: include.system,
-                        code: concept.code,
-                        display: concept.display,
-                    });
-                }
-            }
-            else if (include.system && !include.filter) {
-                try {
-                    const codeSystem = register.resolveAny(include.system);
-                    if (codeSystem?.concept) {
-                        const extractConcepts = (conceptList, system) => {
-                            for (const concept of conceptList) {
-                                concepts.push({
-                                    system,
-                                    code: concept.code,
-                                    display: concept.display,
-                                });
-                                if (concept.concept) {
-                                    extractConcepts(concept.concept, system);
-                                }
-                            }
-                        };
-                        extractConcepts(codeSystem.concept, include.system);
-                    }
-                }
-                catch {
-                    // Ignore if we can't resolve the CodeSystem
-                }
-            }
-        }
-    }
-    return concepts.length > 0 ? concepts : undefined;
-}
-const MAX_ENUM_LENGTH = 100;
-export function buildEnum(register, element) {
-    if (!element.binding)
-        return undefined;
-    const strength = element.binding.strength;
-    const valueSetUrl = element.binding.valueSet;
-    if (!valueSetUrl)
-        return undefined;
-    // Enhanced support for more binding strengths and types
-    // Generate enum for:
-    // 1. Required bindings (always)
-    // 2. Extensible bindings on code types (for better type safety)
-    // 3. Preferred bindings on code types (for common usage patterns)
-    // 4. Extensible bindings on Coding types (broader coverage)
-    const shouldGenerateEnum = strength === "required" ||
-        (strength === "extensible" && (element.type === "code" || element.type === "Coding")) ||
-        (strength === "preferred" && (element.type === "code" || element.type === "Coding"));
-    if (!shouldGenerateEnum)
-        return undefined;
-    const concepts = extractValueSetConceptsByUrl(register, valueSetUrl);
-    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 ${valueSetUrl} has more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`);
-        return undefined;
-    }
-    return codes.length > 0 ? codes : undefined;
-}
-function generateBindingSchema(register, fhirSchema, path, element) {
-    if (!element.binding?.valueSet)
-        return undefined;
-    const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
-    const fieldType = buildFieldType(register, fhirSchema, element);
-    const valueSetIdentifier = mkValueSetIdentifierByUrl(register, element.binding.valueSet);
-    const dependencies = [];
-    if (fieldType) {
-        dependencies.push(fieldType);
-    }
-    dependencies.push(valueSetIdentifier);
-    const enumValues = buildEnum(register, element);
-    return {
-        identifier,
-        type: fieldType,
-        valueset: valueSetIdentifier,
-        strength: element.binding.strength,
-        enum: enumValues,
-        dependencies,
-    };
-}
-export function collectBindingSchemas(register, fhirSchema) {
-    const processedPaths = new Set();
-    if (!fhirSchema.elements)
-        return [];
-    const bindings = [];
-    function collectBindings(elements, parentPath) {
-        for (const [key, element] of Object.entries(elements)) {
-            const path = [...parentPath, key];
-            const pathKey = path.join(".");
-            if (processedPaths.has(pathKey))
-                continue;
-            processedPaths.add(pathKey);
-            if (element.binding) {
-                const binding = generateBindingSchema(register, fhirSchema, path, element);
-                if (binding) {
-                    bindings.push(binding);
-                }
-            }
-            if (element.elements) {
-                collectBindings(element.elements, path);
-            }
-        }
-    }
-    collectBindings(fhirSchema.elements, []);
-    bindings.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
-    const uniqueBindings = [];
-    const seenUrls = new Set();
-    for (const binding of bindings) {
-        if (!seenUrls.has(binding.identifier.url)) {
-            seenUrls.add(binding.identifier.url);
-            uniqueBindings.push(binding);
-        }
-    }
-    return uniqueBindings;
-}

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

@@ -1,12 +0,0 @@
-/**
- * Field Building Utilities
- *
- * Functions for transforming FHIRSchema elements into TypeSchema fields
- */
-import type { FHIRSchemaElement } from "@atomic-ehr/fhirschema";
-import type { Register } from "@root/typeschema/register";
-import type { Field, Identifier, RegularField, RichFHIRSchema } from "../types";
-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

@@ -1,123 +0,0 @@
-/**
- * Field Building Utilities
- *
- * Functions for transforming FHIRSchema elements into TypeSchema fields
- */
-import { buildEnum } from "./binding";
-import { mkBindingIdentifier, mkIdentifier, mkNestedIdentifier } from "./identifier";
-function isRequired(register, fhirSchema, path) {
-    const fieldName = path[path.length - 1];
-    const parentPath = path.slice(0, -1);
-    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);
-}
-function isExcluded(register, fhirSchema, path) {
-    const fieldName = path[path.length - 1];
-    if (!fieldName)
-        throw new Error(`Internal error: fieldName is missing for path ${path.join("/")}`);
-    const parentPath = path.slice(0, -1);
-    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);
-}
-const buildReferences = (element, register, _packageInfo) => {
-    if (!element.refers)
-        return undefined;
-    return element.refers.map((ref) => {
-        const curl = register.ensureCanonicalUrl(ref);
-        const fs = register.resolveFs(curl);
-        return mkIdentifier(fs);
-    });
-};
-export function buildFieldType(register, fhirSchema, element) {
-    // Handle element reference (for slicing)
-    if (element.elementReference) {
-        const refPath = element.elementReference
-            .filter((_, i) => i % 2 === 1) // Get odd indices (the actual path parts)
-            .map((p) => p)
-            .filter((p) => p !== "elements"); // Remove 'elements' which is just a container
-        // Only return nested identifier if we have a non-empty path
-        if (refPath.length > 0) {
-            return mkNestedIdentifier(fhirSchema, refPath);
-        }
-    }
-    if (element.type) {
-        const kind = element.type.match(/^[a-z]/) ? "primitive-type" : "complex-type";
-        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: fieldFs.package_meta.name,
-            version: fieldFs.package_meta.version,
-            name: element.type,
-            url: url,
-        };
-    }
-    return undefined;
-}
-export const mkField = (register, fhirSchema, path, element) => {
-    let binding;
-    let enumValues;
-    if (element.binding) {
-        binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
-        if (element.binding.strength === "required" && element.type === "code") {
-            enumValues = buildEnum(register, element);
-        }
-    }
-    return {
-        type: buildFieldType(register, fhirSchema, element),
-        required: isRequired(register, fhirSchema, path),
-        excluded: isExcluded(register, 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,
-    };
-};
-export function isNestedElement(element) {
-    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(register, fhirSchema, path, element) {
-    return {
-        type: mkNestedIdentifier(fhirSchema, path),
-        array: element.array || false,
-        required: isRequired(register, fhirSchema, path),
-        excluded: isExcluded(register, fhirSchema, path),
-    };
-}

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

@@ -1,13 +0,0 @@
-/**
- * Identifier Building Utilities
- *
- * Functions for creating TypeSchema identifiers from FHIRSchema entities
- */
-import type { FHIRSchema } from "@atomic-ehr/fhirschema";
-import type { BindingIdentifier, CanonicalUrl, Identifier, NestedIdentifier, RichFHIRSchema, ValueSetIdentifier } 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 mkValueSetIdentifierByUrl(register: Register, fullValueSetUrl: CanonicalUrl): ValueSetIdentifier;
-export declare function mkBindingIdentifier(fhirSchema: FHIRSchema, path: string[], bindingName?: string): BindingIdentifier;

package/dist/typeschema/core/identifier.js

@@ -1,94 +0,0 @@
-/**
- * Identifier Building Utilities
- *
- * Functions for creating TypeSchema identifiers from FHIRSchema entities
- */
-export function dropVersionFromUrl(url) {
-    const baseUrl = url.split("|")[0];
-    return baseUrl ? baseUrl : url;
-}
-function getVersionFromUrl(url) {
-    const version = url.split("|")[1];
-    return version;
-}
-function determineKind(fhirSchema) {
-    if (fhirSchema.derivation === "constraint")
-        return "profile";
-    if (fhirSchema.kind === "primitive-type")
-        return "primitive-type";
-    if (fhirSchema.kind === "complex-type")
-        return "complex-type";
-    if (fhirSchema.kind === "resource")
-        return "resource";
-    return "resource";
-}
-export function mkIdentifier(fhirSchema) {
-    return {
-        kind: determineKind(fhirSchema),
-        package: fhirSchema.package_meta.name,
-        version: fhirSchema.package_meta.version,
-        name: fhirSchema.name,
-        url: fhirSchema.url,
-    };
-}
-export function mkNestedIdentifier(fhirSchema, path) {
-    const nestedName = path.join(".");
-    return {
-        kind: "nested",
-        package: fhirSchema.package_meta.name,
-        version: fhirSchema.package_meta.version,
-        name: nestedName,
-        url: `${fhirSchema.url}#${nestedName}`,
-    };
-}
-const getValueSetName = (url) => {
-    const urlParts = url.split("/");
-    const lastSegment = urlParts[urlParts.length - 1];
-    if (lastSegment && lastSegment.length > 0) {
-        return lastSegment
-            .split(/[-_]/)
-            .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-            .join("");
-    }
-    return url;
-};
-export function mkValueSetIdentifierByUrl(register, fullValueSetUrl) {
-    const valueSetUrl = dropVersionFromUrl(fullValueSetUrl);
-    const valueSetNameFallback = getValueSetName(valueSetUrl);
-    const valuesSetFallback = {
-        resourceType: "ValueSet",
-        package_meta: {
-            name: "missing_valuesets",
-            version: getVersionFromUrl(valueSetUrl) || "0.0.0",
-        },
-        name: valueSetNameFallback,
-        id: fullValueSetUrl,
-        url: valueSetUrl,
-    };
-    const valueSet = register.resolveVs(valueSetUrl) || valuesSetFallback;
-    // NOTE: ignore valueSet.name due to human name
-    const valueSetName = valueSet?.id && !/^[a-zA-Z0-9_-]{20,}$/.test(valueSet.id) ? valueSet.id : valueSetNameFallback;
-    return {
-        kind: "value-set",
-        package: valueSet?.package_meta.name,
-        version: valueSet?.package_meta.version,
-        name: valueSetName,
-        url: valueSetUrl,
-    };
-}
-export function mkBindingIdentifier(fhirSchema, path, bindingName) {
-    const pathStr = path.join(".");
-    // 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: pkg.name,
-        version: pkg.version,
-        name: name,
-        url: url,
-    };
-}

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

@@ -1,9 +0,0 @@
-/**
- * Nested Types (BackboneElement) Handling
- *
- * Functions for extracting and transforming nested types from FHIRSchema
- */
-import type { Register } from "@root/typeschema/register";
-import type { Identifier, NestedType, RichFHIRSchema } from "../types";
-export declare function mkNestedTypes(register: Register, fhirSchema: RichFHIRSchema): NestedType[] | undefined;
-export declare function extractNestedDependencies(nestedTypes: NestedType[]): Identifier[];