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

package/dist/typeschema/register.js

@@ -1,117 +0,0 @@
-import { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-import * as fhirschema from "@atomic-ehr/fhirschema";
-import { enrichFHIRSchema } from "@typeschema/types";
-// FIXME: working with multiple packages
-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") {
-            const url = resource.url;
-            structureDefinitions[url] = resource;
-        }
-    }
-    const fhirSchemas = {};
-    const nameDict = {};
-    let [success, failed] = [0, 0];
-    for (const sd of Object.values(structureDefinitions)) {
-        try {
-            const rfs = enrichFHIRSchema(fhirschema.translate(sd), packageInfo);
-            fhirSchemas[rfs.url] = rfs;
-            nameDict[rfs.name] = rfs.url;
-            success++;
-        }
-        catch (error) {
-            logger?.warn(`Failed to convert StructureDefinition ${sd.name || sd.id}: ${error instanceof Error ? error.message : String(error)}`);
-            failed++;
-        }
-        logger?.success(`FHIR Schema conversion completed: ${success}/${Object.values(structureDefinitions).length} successful, ${failed} failed`);
-    }
-    const valueSets = {};
-    for (const resource of resources) {
-        if (resource.resourceType === "ValueSet") {
-            if (!resource.package_meta) {
-                resource.package_meta = packageInfo;
-            }
-            valueSets[resource.url] = resource;
-        }
-    }
-    const complexTypes = {};
-    for (const fs of Object.values(fhirSchemas)) {
-        if (fs.kind === "complex-type") {
-            complexTypes[fs.url] = fs;
-        }
-    }
-    const resolveFsGenealogy = (canonicalUrl) => {
-        let fs = fhirSchemas[canonicalUrl];
-        if (fs === undefined)
-            throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
-        const genealogy = [fs];
-        while (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;
-    };
-    return {
-        ...manager,
-        appendFs(fs) {
-            const rfs = enrichFHIRSchema(fs);
-            fhirSchemas[rfs.url] = rfs;
-            nameDict[rfs.name] = rfs.url;
-        },
-        resolveFs: (canonicalUrl) => fhirSchemas[canonicalUrl],
-        resolveFsGenealogy: resolveFsGenealogy,
-        ensureCanonicalUrl: (name) => nameDict[name] || name,
-        allSd: () => Object.values(structureDefinitions),
-        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) => {
-    const packageNames = packageMetas.map((meta) => `${meta.name}@${meta.version}`);
-    logger?.step(`Loading FHIR packages: ${packageNames.join(", ")}`);
-    const manager = CanonicalManager({
-        packages: packageNames,
-        workingDir: "tmp/fhir",
-    });
-    await manager.init();
-    // Pass package info from the first package (assuming single package for now)
-    return await registerFromManager(manager, logger, packageMetas[0]);
-};
-export const resolveFsElementGenealogy = (genealogy, path) => {
-    const [top, ...rest] = path;
-    if (top === undefined)
-        return [];
-    return genealogy
-        .map((fs) => {
-        if (!fs.elements)
-            return undefined;
-        let elem = fs.elements?.[top];
-        for (const k of rest) {
-            elem = elem?.elements?.[k];
-        }
-        return elem;
-    })
-        .filter((elem) => elem !== undefined);
-};
-export function fsElementSnapshot(genealogy) {
-    // FIXME: nested elements will break it
-    const snapshot = genealogy.reverse().reduce((snapshot, elem) => ({ ...snapshot, ...elem }), {});
-    // NOTE: to avoid regeneration nested types
-    snapshot.elements = undefined;
-    return snapshot;
-}

package/dist/typeschema/types.d.ts

@@ -1,240 +0,0 @@
-/**
- * A code generation friendly representation of FHIR StructureDefinition and
- * FHIR Schema designed to simplify SDK resource classes/types generation.
- */
-import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-import type * as FS from "@atomic-ehr/fhirschema";
-export type Name = string & {
-    readonly __brand: unique symbol;
-};
-export type CanonicalUrl = string & {
-    readonly __brand: unique symbol;
-};
-export interface PackageMeta {
-    name: string;
-    version: string;
-}
-export type RichFHIRSchema = Omit<FS.FHIRSchema, "package_meta" | "base" | "name" | "url"> & {
-    package_meta: PackageMeta;
-    name: Name;
-    url: CanonicalUrl;
-    base: CanonicalUrl;
-};
-export declare const enrichFHIRSchema: (schema: FS.FHIRSchema, packageMeta?: PackageMeta) => RichFHIRSchema;
-type IdentifierBase = {
-    name: Name;
-    url: CanonicalUrl;
-    package: string;
-    version: string;
-};
-type PrimitiveIdentifier = {
-    kind: "primitive-type";
-} & IdentifierBase;
-type ComplexTypeIdentifier = {
-    kind: "complex-type";
-} & IdentifierBase;
-type ResourceIdentifier = {
-    kind: "resource";
-} & IdentifierBase;
-export type ValueSetIdentifier = {
-    kind: "value-set";
-} & IdentifierBase;
-export type NestedIdentifier = {
-    kind: "nested";
-} & IdentifierBase;
-export type BindingIdentifier = {
-    kind: "binding";
-} & IdentifierBase;
-type ProfileIdentifier = {
-    kind: "profile";
-} & IdentifierBase;
-type LogicalIdentifier = {
-    kind: "logical";
-} & IdentifierBase;
-export type Identifier = PrimitiveIdentifier | ComplexTypeIdentifier | ResourceIdentifier | NestedIdentifier | BindingIdentifier | ValueSetIdentifier | ProfileIdentifier | LogicalIdentifier;
-export type TypeSchema = RegularTypeSchema | PrimitiveTypeSchema | ValueSetTypeSchema | BindingTypeSchema | ProfileTypeSchema;
-interface PrimitiveTypeSchema {
-    identifier: PrimitiveIdentifier;
-    description?: string;
-    base: Identifier;
-    dependencies?: Identifier[];
-}
-export interface NestedType {
-    identifier: NestedIdentifier;
-    base: Identifier;
-    fields: Record<string, Field>;
-}
-export interface ProfileTypeSchema {
-    identifier: ProfileIdentifier;
-    base: Identifier;
-    description?: string;
-    fields?: Record<string, Field>;
-    constraints?: Record<string, ProfileConstraint>;
-    extensions?: ProfileExtension[];
-    validation?: ValidationRule[];
-    dependencies?: Identifier[];
-    metadata?: ProfileMetadata;
-    nested?: NestedType[];
-}
-export interface ProfileConstraint {
-    min?: number;
-    max?: string;
-    mustSupport?: boolean;
-    fixedValue?: any;
-    patternValue?: any;
-    binding?: {
-        strength: "required" | "extensible" | "preferred" | "example";
-        valueSet: string;
-    };
-    types?: Array<{
-        code: string;
-        profile?: string[];
-        targetProfile?: string[];
-    }>;
-    slicing?: {
-        discriminator: any[];
-        rules: string;
-        ordered?: boolean;
-    };
-}
-export interface ProfileExtension {
-    path: string;
-    profile: string | string[];
-    min?: number;
-    max?: string;
-    mustSupport?: boolean;
-}
-export interface ValidationRule {
-    path: string;
-    key: string;
-    severity: "error" | "warning" | "information";
-    human: string;
-    expression?: string;
-}
-export interface ProfileMetadata {
-    publisher?: string;
-    contact?: any[];
-    copyright?: string;
-    purpose?: string;
-    experimental?: boolean;
-    date?: string;
-    jurisdiction?: any[];
-    package?: string;
-}
-interface RegularTypeSchema {
-    identifier: Identifier;
-    base?: Identifier;
-    description?: string;
-    fields?: {
-        [k: string]: Field;
-    };
-    nested?: NestedType[];
-    dependencies?: Identifier[];
-}
-export interface RegularField {
-    type: Identifier;
-    reference?: Identifier[];
-    required?: boolean;
-    excluded?: boolean;
-    array?: boolean;
-    binding?: BindingIdentifier;
-    enum?: string[];
-    min?: number;
-    max?: number;
-}
-export interface ChoiceFieldDeclaration {
-    choices: string[];
-    required?: boolean;
-    excluded?: boolean;
-    array?: boolean;
-    min?: number;
-    max?: number;
-}
-interface ChoiceFieldInstance {
-    choiceOf: string;
-    type: Identifier;
-    required?: boolean;
-    excluded?: boolean;
-    array?: boolean;
-    reference?: Identifier[];
-    binding?: BindingIdentifier;
-    enum?: string[];
-    min?: number;
-    max?: number;
-}
-export type Concept = {
-    code: string;
-    display?: string;
-    system?: string;
-};
-export interface ValueSetTypeSchema {
-    identifier: ValueSetIdentifier;
-    description?: string;
-    concept?: Concept[];
-    compose?: ValueSetCompose;
-}
-export interface BindingTypeSchema {
-    identifier: BindingIdentifier;
-    description?: string;
-    type?: Identifier;
-    strength?: string;
-    enum?: string[];
-    valueset?: ValueSetIdentifier;
-    dependencies?: Identifier[];
-}
-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 BindingTypeSchema;
-export type TypeschemaParserOptions = {
-    format?: "auto" | "ndjson" | "json";
-    validate?: boolean;
-    strict?: boolean;
-};
-export type ValueSet = {
-    resourceType: "ValueSet";
-    id: string;
-    name?: string;
-    url?: string;
-    description?: string;
-    compose?: ValueSetCompose;
-    expansion?: {
-        contains: Concept[];
-    };
-    experimental?: boolean;
-    immutable?: boolean;
-    extension?: any[];
-    status?: string;
-    identifier?: any[];
-    title?: string;
-    publisher?: string;
-    version?: string;
-    meta?: any;
-    date?: string;
-    contact?: any;
-};
-type ValueSetCompose = {
-    include: {
-        concept?: Concept[];
-        system?: string;
-        filter?: {}[];
-    }[];
-};
-export type CodeSystem = {
-    concept: CodeSystemConcept[];
-};
-export type CodeSystemConcept = {
-    concept: CodeSystemConcept[];
-    code: string;
-    display: string;
-};
-export type RichValueSet = Omit<ValueSet, "name" | "url"> & {
-    package_meta: PackageMeta;
-    name?: Name;
-    url?: CanonicalUrl;
-};
-export {};

package/dist/typeschema/types.js

@@ -1,19 +0,0 @@
-/**
- * A code generation friendly representation of FHIR StructureDefinition and
- * FHIR Schema designed to simplify SDK resource classes/types generation.
- */
-export const enrichFHIRSchema = (schema, packageMeta) => {
-    if (!packageMeta) {
-        packageMeta = { name: "undefined", version: "undefined" };
-    }
-    return {
-        ...schema,
-        package_meta: schema.package_meta || packageMeta,
-        name: schema.name,
-        url: schema.url,
-        base: schema.base,
-    };
-};
-export function isBindingSchema(schema) {
-    return schema.identifier.kind === "binding";
-}

package/dist/utils/codegen-logger.d.ts

@@ -1,102 +0,0 @@
-/**
- * CodeGen Logger
- *
- * Clean, colorful logging designed for code generation tools
- */
-export interface LogOptions {
-    prefix?: string;
-    timestamp?: boolean;
-    verbose?: boolean;
-}
-/**
- * Simple code generation logger with pretty colors and clean formatting
- */
-export declare class CodegenLogger {
-    private options;
-    constructor(options?: LogOptions);
-    private formatMessage;
-    /**
-     * Success message with checkmark
-     */
-    success(message: string): void;
-    /**
-     * Error message with X mark
-     */
-    error(message: string, error?: Error): void;
-    /**
-     * Warning message with warning sign
-     */
-    warn(message: string): void;
-    /**
-     * Info message with info icon
-     */
-    info(message: string): void;
-    /**
-     * Debug message (only shows in verbose mode)
-     */
-    debug(message: string): void;
-    /**
-     * Step message with rocket
-     */
-    step(message: string): void;
-    /**
-     * Progress message with clock
-     */
-    progress(message: string): void;
-    /**
-     * Plain message (no icon, just colored text)
-     */
-    plain(message: string, color?: (str: string) => string): void;
-    /**
-     * Dimmed/gray text for less important info
-     */
-    dim(message: string): void;
-    /**
-     * Create a child logger with a prefix
-     */
-    child(prefix: string): CodegenLogger;
-    /**
-     * Update options
-     */
-    configure(options: Partial<LogOptions>): void;
-}
-export declare function success(message: string): void;
-export declare function error(message: string, err?: Error): void;
-export declare function warn(message: string): void;
-export declare function info(message: string): void;
-export declare function debug(message: string): void;
-export declare function step(message: string): void;
-export declare function progress(message: string): void;
-export declare function plain(message: string, color?: (str: string) => string): void;
-export declare function dim(message: string): void;
-/**
- * Configure the default logger
- */
-export declare function configure(options: Partial<LogOptions>): void;
-/**
- * Create a new logger instance
- */
-export declare function createLogger(options?: LogOptions): CodegenLogger;
-/**
- * Convenience functions for common CLI patterns
- */
-/**
- * Show a command header with separator
- */
-export declare function header(title: string): void;
-/**
- * Show a section break
- */
-export declare function section(title: string): void;
-/**
- * Show completion message with stats
- */
-export declare function complete(message: string, duration?: number, stats?: Record<string, number>): void;
-/**
- * Show a list of items
- */
-export declare function list(items: string[], bullet?: string): void;
-/**
- * Show key-value pairs
- */
-export declare function table(data: Record<string, string | number>): void;

package/dist/utils/codegen-logger.js

@@ -1,196 +0,0 @@
-/**
- * CodeGen Logger
- *
- * Clean, colorful logging designed for code generation tools
- */
-import pc from "picocolors";
-/**
- * Simple code generation logger with pretty colors and clean formatting
- */
-export class CodegenLogger {
-    options;
-    constructor(options = {}) {
-        this.options = {
-            timestamp: false,
-            verbose: false,
-            ...options,
-        };
-    }
-    formatMessage(level, message, color) {
-        const timestamp = this.options.timestamp ? `${pc.gray(new Date().toLocaleTimeString())} ` : "";
-        const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
-        return `${timestamp}${color(level)} ${prefix}${message}`;
-    }
-    /**
-     * Success message with checkmark
-     */
-    success(message) {
-        console.log(this.formatMessage("✅", message, pc.green));
-    }
-    /**
-     * Error message with X mark
-     */
-    error(message, error) {
-        console.error(this.formatMessage("❌", message, pc.red));
-        if (error && this.options.verbose) {
-            console.error(pc.red(`   ${error.message}`));
-            if (error.stack) {
-                console.error(pc.gray(error.stack));
-            }
-        }
-    }
-    /**
-     * Warning message with warning sign
-     */
-    warn(message) {
-        console.warn(this.formatMessage("⚠️", message, pc.yellow));
-    }
-    /**
-     * Info message with info icon
-     */
-    info(message) {
-        console.log(this.formatMessage("ℹ️", message, pc.blue));
-    }
-    /**
-     * Debug message (only shows in verbose mode)
-     */
-    debug(message) {
-        if (this.options.verbose) {
-            console.log(this.formatMessage("🐛", message, pc.magenta));
-        }
-    }
-    /**
-     * Step message with rocket
-     */
-    step(message) {
-        console.log(this.formatMessage("🚀", message, pc.cyan));
-    }
-    /**
-     * Progress message with clock
-     */
-    progress(message) {
-        console.log(this.formatMessage("⏳", message, pc.blue));
-    }
-    /**
-     * Plain message (no icon, just colored text)
-     */
-    plain(message, color = (s) => s) {
-        const timestamp = this.options.timestamp ? `${pc.gray(new Date().toLocaleTimeString())} ` : "";
-        const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
-        console.log(`${timestamp}${prefix}${color(message)}`);
-    }
-    /**
-     * Dimmed/gray text for less important info
-     */
-    dim(message) {
-        this.plain(message, pc.gray);
-    }
-    /**
-     * Create a child logger with a prefix
-     */
-    child(prefix) {
-        return new CodegenLogger({
-            ...this.options,
-            prefix: this.options.prefix ? `${this.options.prefix}:${prefix}` : prefix,
-        });
-    }
-    /**
-     * Update options
-     */
-    configure(options) {
-        this.options = { ...this.options, ...options };
-    }
-}
-/**
- * Quick logging functions for simple usage
- */
-const defaultLogger = new CodegenLogger();
-export function success(message) {
-    defaultLogger.success(message);
-}
-export function error(message, err) {
-    defaultLogger.error(message, err);
-}
-export function warn(message) {
-    defaultLogger.warn(message);
-}
-export function info(message) {
-    defaultLogger.info(message);
-}
-export function debug(message) {
-    defaultLogger.debug(message);
-}
-export function step(message) {
-    defaultLogger.step(message);
-}
-export function progress(message) {
-    defaultLogger.progress(message);
-}
-export function plain(message, color) {
-    defaultLogger.plain(message, color);
-}
-export function dim(message) {
-    defaultLogger.dim(message);
-}
-/**
- * Configure the default logger
- */
-export function configure(options) {
-    defaultLogger.configure(options);
-}
-/**
- * Create a new logger instance
- */
-export function createLogger(options = {}) {
-    return new CodegenLogger(options);
-}
-/**
- * Convenience functions for common CLI patterns
- */
-/**
- * Show a command header with separator
- */
-export function header(title) {
-    console.log();
-    console.log(pc.cyan(pc.bold(`━━━ ${title} ━━━`)));
-}
-/**
- * Show a section break
- */
-export function section(title) {
-    console.log();
-    console.log(pc.bold(title));
-}
-/**
- * Show completion message with stats
- */
-export function complete(message, duration, stats) {
-    let msg = message;
-    if (duration) {
-        msg += ` ${pc.gray(`(${duration}ms)`)}`;
-    }
-    success(msg);
-    if (stats) {
-        Object.entries(stats).forEach(([key, value]) => {
-            dim(`  ${key}: ${value}`);
-        });
-    }
-}
-/**
- * Show a list of items
- */
-export function list(items, bullet = "•") {
-    items.forEach((item) => {
-        console.log(pc.gray(`  ${bullet} ${item}`));
-    });
-}
-/**
- * Show key-value pairs
- */
-export function table(data) {
-    const maxKeyLength = Math.max(...Object.keys(data).map((k) => k.length));
-    Object.entries(data).forEach(([key, value]) => {
-        const paddedKey = key.padEnd(maxKeyLength);
-        console.log(`  ${pc.blue(paddedKey)} ${pc.gray("─")} ${value}`);
-    });
-}

package/dist/utils.d.ts

@@ -1,22 +0,0 @@
-/**
- * Convert a string into PascalCase.
- * Examples:
- *  - "patient-name" -> "PatientName"
- *  - "Patient name" -> "PatientName"
- *  - "patient_name" -> "PatientName"
- *  - "patientName" -> "PatientName"
- */
-export declare function toPascalCase(input: string): string;
-/**
- * Split an array into chunks of a given size.
- *
- * Examples:
- *  - chunkArray([1,2,3,4,5], 2) -> [[1,2],[3,4],[5]]
- *  - chunkArray([], 3) -> []
- *
- * @param arr - The array to split.
- * @param size - The maximum size of each chunk (must be >= 1).
- * @returns An array of chunks (each chunk is an array of T).
- * @throws RangeError if size is less than 1.
- */
-export declare function chunkArray<T>(arr: T[], size: number): T[][];