@atomic-ehr/codegen 0.0.1-canary.20250821160126.c552195 → 0.0.1-canary.20250822150706.c3b8669

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AAGH,cAAc,OAAO,CAAC;AAGtB,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AAGH,cAAc,gBAAgB,CAAC;AAG/B,cAAc,aAAa,CAAC"}

package/dist/index.js

@@ -1,38 +1,84 @@
-import {
-  APIBuilder,
-  CONFIG_FILE_NAMES,
-  ConfigLoader,
-  ConfigValidator,
-  DEFAULT_CONFIG,
-  RestClientGenerator,
-  TypeSchemaCache,
-  TypeSchemaGenerator,
-  TypeSchemaParser,
-  TypeScriptGenerator,
-  configLoader,
-  createAPI,
-  createAPIFromConfig,
-  generateTypesFromFiles,
-  generateTypesFromPackage,
-  isConfig,
-  loadConfig
-} from "./index-e7pfye24.js";
-export {
-  loadConfig,
-  isConfig,
-  generateTypesFromPackage,
-  generateTypesFromFiles,
-  createAPIFromConfig,
-  createAPI,
-  configLoader,
-  TypeScriptGenerator,
-  TypeSchemaParser,
-  TypeSchemaGenerator,
-  TypeSchemaCache,
-  RestClientGenerator,
-  DEFAULT_CONFIG,
-  ConfigValidator,
-  ConfigLoader,
-  CONFIG_FILE_NAMES,
-  APIBuilder
-};
+/**
+ * Main entry point for the @atomic-ehr/codegen library
+ *
+ * ## Overview
+ *
+ * atomic-codegen is a comprehensive code generation toolkit for FHIR healthcare standards,
+ * designed with TypeSchema as the intermediate format for maximum flexibility and type safety.
+ *
+ * ## Key Features
+ *
+ * - **🔥 FHIR R4/R5 Support**: Complete FHIR resource and profile generation
+ * - **🇺🇸 US Core Profiles**: Built-in support for US healthcare implementation guides
+ * - **📋 TypeSchema Integration**: Uses TypeSchema as universal intermediate format
+ * - **🎯 Type Safety**: Full TypeScript support with runtime validation
+ * - **⚡ Performance**: Built with Bun for maximum speed
+ * - **🏗️ Extensible**: Plugin architecture for custom generators
+ *
+ * ## Quick Start
+ *
+ * ```typescript
+ * import { APIBuilder } from '@atomic-ehr/codegen';
+ *
+ * // High-level API for common workflows
+ * const api = new APIBuilder();
+ *
+ * // Generate FHIR types from packages
+ * await api
+ *   .fromFHIRPackages(['hl7.fhir.r4.core@4.0.1', 'hl7.fhir.us.core@6.1.0'])
+ *   .typescript('./src/types/fhir')
+ *   .withValidation()
+ *   .generate();
+ * ```
+ *
+ * ## Architecture
+ *
+ * The library follows a three-stage architecture:
+ *
+ * 1. **Input**: FHIR packages, JSON Schema, or custom schemas
+ * 2. **TypeSchema**: Universal intermediate representation
+ * 3. **Output**: TypeScript, Python, Go, or custom target languages
+ *
+ * ## Examples
+ *
+ * ### FHIR Patient with US Core Extensions
+ *
+ * ```typescript
+ * import { USCorePatient, USCoreRaceExtension } from './types/fhir';
+ *
+ * const patient: USCorePatient = {
+ *   resourceType: 'Patient',
+ *   identifier: [{ value: 'MRN-123' }],
+ *   name: [{ family: 'Johnson', given: ['Maria'] }],
+ *   gender: 'female',
+ *   extension: [{
+ *     url: 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-race',
+ *     extension: [{ url: 'text', valueString: 'Hispanic or Latino' }]
+ *   } as USCoreRaceExtension]
+ * };
+ * ```
+ *
+ * ### Runtime Validation
+ *
+ * ```typescript
+ * import { isUSCorePatient, validateFHIRResource } from './types/fhir/guards';
+ *
+ * if (isUSCorePatient(someData)) {
+ *   // TypeScript knows this is a USCorePatient
+ *   const validation = await validateFHIRResource(someData);
+ *   if (validation.valid) {
+ *     console.log('Valid US Core Patient!');
+ *   }
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ * @module @atomic-ehr/codegen
+ * @version 0.0.1
+ * @author Atomic EHR Team
+ * @since 0.0.1
+ */
+// Export new high-level API (primary)
+export * from "./api/index.js";
+// Export new config system
+export * from "./config.js";

package/dist/logger.js

@@ -0,0 +1,290 @@
+/**
+ * Structured Logging System for Atomic Codegen
+ *
+ * Provides configurable logging with levels, structured output, and context
+ */
+/**
+ * Log levels in order of severity
+ */
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["SILENT"] = 4] = "SILENT";
+})(LogLevel || (LogLevel = {}));
+/**
+ * Console output implementation
+ */
+export class ConsoleOutput {
+    useStderr;
+    constructor(useStderr = false) {
+        this.useStderr = useStderr;
+    }
+    write(entry, formatted) {
+        const output = this.useStderr || entry.level >= LogLevel.WARN
+            ? console.error
+            : console.log;
+        output(formatted);
+    }
+}
+/**
+ * File output implementation
+ */
+export class FileOutput {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async write(_entry, formatted) {
+        const _file = Bun.file(this.filePath);
+        const content = `${formatted}\n`;
+        try {
+            // Append to file
+            await Bun.write(this.filePath, content, { createPath: true });
+        }
+        catch (error) {
+            // Fallback to console if file write fails
+            console.error(`Failed to write to log file ${this.filePath}:`, error);
+            console.error(formatted);
+        }
+    }
+}
+/**
+ * Main logger class
+ */
+export class Logger {
+    config;
+    constructor(config = {}) {
+        this.config = {
+            level: LogLevel.INFO,
+            format: "pretty",
+            includeTimestamp: true,
+            includeContext: true,
+            colorize: true,
+            outputs: [new ConsoleOutput()],
+            ...config,
+        };
+    }
+    /**
+     * Update logger configuration
+     */
+    configure(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Check if a log level should be output
+     */
+    shouldLog(level) {
+        return level >= this.config.level;
+    }
+    /**
+     * Create a log entry
+     */
+    createEntry(level, message, context, error, operation) {
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            levelName: LogLevel[level],
+            message,
+            component: this.config.component,
+        };
+        if (context && this.config.includeContext) {
+            entry.context = context;
+        }
+        if (operation) {
+            entry.operation = operation;
+        }
+        if (error) {
+            entry.error = {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+            };
+        }
+        return entry;
+    }
+    /**
+     * Format log entry for output
+     */
+    formatEntry(entry) {
+        switch (this.config.format) {
+            case "json":
+                return JSON.stringify(entry);
+            case "compact":
+                return this.formatCompact(entry);
+            default:
+                return this.formatPretty(entry);
+        }
+    }
+    /**
+     * Format entry in compact format
+     */
+    formatCompact(entry) {
+        const timestamp = this.config.includeTimestamp ? `${entry.timestamp} ` : "";
+        const component = entry.component ? `[${entry.component}] ` : "";
+        const operation = entry.operation ? `(${entry.operation}) ` : "";
+        const level = this.colorizeLevel(entry.levelName, entry.level);
+        return `${timestamp}${level} ${component}${operation}${entry.message}`;
+    }
+    /**
+     * Format entry in pretty format
+     */
+    formatPretty(entry) {
+        let formatted = "";
+        // Header line
+        const timestamp = this.config.includeTimestamp ? `${entry.timestamp} ` : "";
+        const component = entry.component ? `[${entry.component}] ` : "";
+        const operation = entry.operation ? `(${entry.operation}) ` : "";
+        const level = this.colorizeLevel(entry.levelName.padEnd(5), entry.level);
+        formatted += `${timestamp}${level} ${component}${operation}${entry.message}`;
+        // Context
+        if (entry.context && Object.keys(entry.context).length > 0) {
+            formatted += `\n  Context: ${JSON.stringify(entry.context, null, 2).split("\n").join("\n  ")}`;
+        }
+        // Error details
+        if (entry.error) {
+            formatted += `\n  Error: [${entry.error.code || entry.error.name}] ${entry.error.message}`;
+            if (entry.error.context && Object.keys(entry.error.context).length > 0) {
+                formatted += `\n  Error Context: ${JSON.stringify(entry.error.context, null, 2).split("\n").join("\n  ")}`;
+            }
+            if (entry.error.suggestions && entry.error.suggestions.length > 0) {
+                formatted += `\n  Suggestions:\n${entry.error.suggestions.map((s) => `    • ${s}`).join("\n")}`;
+            }
+            if (entry.level === LogLevel.DEBUG && entry.error.stack) {
+                formatted += `\n  Stack: ${entry.error.stack.split("\n").join("\n  ")}`;
+            }
+        }
+        return formatted;
+    }
+    /**
+     * Colorize log level if enabled
+     */
+    colorizeLevel(levelName, level) {
+        if (!this.config.colorize) {
+            return levelName;
+        }
+        const colors = {
+            [LogLevel.DEBUG]: "\x1b[36m", // Cyan
+            [LogLevel.INFO]: "\x1b[32m", // Green
+            [LogLevel.WARN]: "\x1b[33m", // Yellow
+            [LogLevel.ERROR]: "\x1b[31m", // Red
+        };
+        const reset = "\x1b[0m";
+        // @ts-ignore
+        const color = colors[level] || "";
+        return `${color}${levelName}${reset}`;
+    }
+    /**
+     * Write log entry to all outputs
+     */
+    async writeEntry(entry) {
+        if (!this.shouldLog(entry.level)) {
+            return;
+        }
+        const formatted = this.formatEntry(entry);
+        for (const output of this.config.outputs) {
+            try {
+                await output.write(entry, formatted);
+            }
+            catch (error) {
+                // Fallback to console if output fails
+                console.error("Logger output failed:", error);
+                console.error(formatted);
+            }
+        }
+    }
+    /**
+     * Log debug message
+     */
+    async debug(message, context, operation) {
+        const entry = this.createEntry(LogLevel.DEBUG, message, context, undefined, operation);
+        await this.writeEntry(entry);
+    }
+    /**
+     * Log info message
+     */
+    async info(message, context, operation) {
+        const entry = this.createEntry(LogLevel.INFO, message, context, undefined, operation);
+        await this.writeEntry(entry);
+    }
+    /**
+     * Log warning message
+     */
+    async warn(message, context, operation) {
+        const entry = this.createEntry(LogLevel.WARN, message, context, undefined, operation);
+        await this.writeEntry(entry);
+    }
+    /**
+     * Log error message
+     */
+    async error(message, error, context, operation) {
+        const entry = this.createEntry(LogLevel.ERROR, message, context, error, operation);
+        await this.writeEntry(entry);
+    }
+    /**
+     * Create a child logger with additional context
+     */
+    child(component, context) {
+        const childLogger = new Logger({
+            ...this.config,
+            component: this.config.component
+                ? `${this.config.component}.${component}`
+                : component,
+        });
+        // If context is provided, wrap all logging methods to include it
+        if (context) {
+            const originalMethods = {
+                debug: childLogger.debug.bind(childLogger),
+                info: childLogger.info.bind(childLogger),
+                warn: childLogger.warn.bind(childLogger),
+                error: childLogger.error.bind(childLogger),
+            };
+            childLogger.debug = (message, additionalContext, operation) => originalMethods.debug(message, { ...context, ...additionalContext }, operation);
+            childLogger.info = (message, additionalContext, operation) => originalMethods.info(message, { ...context, ...additionalContext }, operation);
+            childLogger.warn = (message, additionalContext, operation) => originalMethods.warn(message, { ...context, ...additionalContext }, operation);
+            childLogger.error = (message, error, additionalContext, operation) => originalMethods.error(message, error, { ...context, ...additionalContext }, operation);
+        }
+        return childLogger;
+    }
+}
+/**
+ * Default logger instance
+ */
+export const logger = new Logger();
+/**
+ * Configure the default logger
+ */
+export function configureLogger(config) {
+    logger.configure(config);
+}
+/**
+ * Create logger from environment variables and config
+ */
+export function createLoggerFromConfig(config) {
+    const level = config?.debug
+        ? LogLevel.DEBUG
+        : config?.verbose
+            ? LogLevel.INFO
+            : config?.logLevel
+                ? (LogLevel[config.logLevel.toUpperCase()] ??
+                    LogLevel.INFO)
+                : LogLevel.INFO;
+    const format = config?.logFormat === "json"
+        ? "json"
+        : config?.logFormat === "compact"
+            ? "compact"
+            : "pretty";
+    const outputs = [new ConsoleOutput()];
+    if (config?.logFile) {
+        outputs.push(new FileOutput(config.logFile));
+    }
+    return new Logger({
+        level,
+        format,
+        component: config?.component,
+        outputs,
+        colorize: !config?.logFile, // Disable colors when logging to file
+    });
+}

package/dist/typeschema/cache.d.ts

@@ -3,8 +3,8 @@
  *
  * Caching system for TypeSchema documents with both in-memory and persistent file-based storage.
  */
-import type { TypeSchemaConfig } from "../config";
-import type { TypeSchema, TypeSchemaIdentifier } from "./type-schema.types";
+import type { TypeSchemaConfig } from "../config.js";
+import type { TypeSchema, TypeSchemaIdentifier } from "./type-schema.types.js";
 /**
  * TypeSchema Cache with optional persistent storage
  */

package/dist/typeschema/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/typeschema/cache.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAW5E;;GAEG;AACH,qBAAa,eAAe;IAC3B,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,QAAQ,CAAC,CAAS;gBAEd,MAAM,CAAC,EAAE,gBAAgB;IAcrC;;OAEG;IACG,GAAG,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAU5C;;OAEG;IACH,GAAG,CAAC,UAAU,EAAE,oBAAoB,GAAG,UAAU,GAAG,IAAI;IAKxD;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IASxC;;OAEG;IACH,GAAG,CAAC,UAAU,EAAE,oBAAoB,GAAG,OAAO;IAK9C;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAS9B;;OAEG;IACH,MAAM,CAAC,UAAU,EAAE,oBAAoB,GAAG,OAAO;IAKjD;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IASjC;;OAEG;IACH,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,UAAU,EAAE;IAU/C;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE;IAUrC;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,IAAI;IAMpC;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,OAAO,CAAC,WAAW;IAInB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAYjC;;OAEG;YACW,YAAY;IA+C1B;;OAEG;YACW,aAAa;IAgC3B;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CAgBhC;AAKD;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,eAAe,CAKzE;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAC1C,MAAM,CAAC,EAAE,gBAAgB,GACvB,OAAO,CAAC,eAAe,CAAC,CAI1B;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAKvC;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAEpD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC9B,UAAU,EAAE,oBAAoB,GAC9B,UAAU,GAAG,IAAI,CAEnB;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,UAAU,EAAE,oBAAoB,GAAG,OAAO,CAElE"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/typeschema/cache.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAW/E;;GAEG;AACH,qBAAa,eAAe;IAC3B,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,QAAQ,CAAC,CAAS;gBAEd,MAAM,CAAC,EAAE,gBAAgB;IAcrC;;OAEG;IACG,GAAG,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAU5C;;OAEG;IACH,GAAG,CAAC,UAAU,EAAE,oBAAoB,GAAG,UAAU,GAAG,IAAI;IAKxD;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IASxC;;OAEG;IACH,GAAG,CAAC,UAAU,EAAE,oBAAoB,GAAG,OAAO;IAK9C;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAS9B;;OAEG;IACH,MAAM,CAAC,UAAU,EAAE,oBAAoB,GAAG,OAAO;IAKjD;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IASjC;;OAEG;IACH,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,UAAU,EAAE;IAU/C;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE;IAUrC;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,IAAI;IAMpC;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,OAAO,CAAC,WAAW;IAInB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAYjC;;OAEG;YACW,YAAY;IA+C1B;;OAEG;YACW,aAAa;IAgC3B;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CAgBhC;AAKD;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,eAAe,CAKzE;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAC1C,MAAM,CAAC,EAAE,gBAAgB,GACvB,OAAO,CAAC,eAAe,CAAC,CAI1B;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAKvC;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAEpD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC9B,UAAU,EAAE,oBAAoB,GAC9B,UAAU,GAAG,IAAI,CAEnB;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,UAAU,EAAE,oBAAoB,GAAG,OAAO,CAElE"}