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

package/dist/api/generators/base/FileManager.js

@@ -1,202 +0,0 @@
-/**
- * Core file management system with batching and performance optimizations
- *
- * This replaces scattered writeFile calls with a comprehensive file management
- * system that provides better error handling, performance, and maintainability.
- */
-import { access, mkdir, rm, stat, writeFile } from "node:fs/promises";
-import { dirname, join, relative } from "node:path";
-import { FileOperationError } from "./errors";
-/**
- * High-performance file manager with batching and error recovery
- *
- * Features:
- * - Automatic directory creation
- * - Batch operations for better performance
- * - Comprehensive error handling with recovery suggestions
- * - Import path resolution
- * - File existence checks
- */
-export class FileManager {
-    options;
-    logger;
-    constructor(options) {
-        this.options = {
-            overwrite: true,
-            batchSize: 10,
-            ...options,
-        };
-        this.logger = options.logger;
-    }
-    /**
-     * Write a file with automatic directory creation
-     * @param relativePath Path relative to output directory
-     * @param content File content
-     * @param options Write options
-     */
-    async writeFile(relativePath, content, options = {}) {
-        const startTime = performance.now();
-        const fullPath = join(this.options.outputDir, relativePath);
-        const encoding = options.encoding || "utf-8";
-        const overwrite = options.overwrite ?? this.options.overwrite;
-        try {
-            // Check if file exists and overwrite is disabled
-            if (!overwrite) {
-                try {
-                    await access(fullPath);
-                    this.logger.debug(`Skipping existing file: ${relativePath}`);
-                    const stats = await stat(fullPath);
-                    return {
-                        path: fullPath,
-                        size: stats.size,
-                        writeTime: 0,
-                    };
-                }
-                catch {
-                    // File doesn't exist, continue with write
-                }
-            }
-            // Ensure directory exists
-            await this.ensureDirectory(dirname(fullPath));
-            // Write file
-            await writeFile(fullPath, content, encoding);
-            const writeTime = performance.now() - startTime;
-            const size = Buffer.byteLength(content, encoding);
-            this.logger.debug(`Written ${relativePath} (${size} bytes, ${writeTime.toFixed(2)}ms)`);
-            return {
-                path: fullPath,
-                size,
-                writeTime,
-            };
-        }
-        catch (error) {
-            throw new FileOperationError(`Failed to write file '${relativePath}': ${error}`, "write", fullPath, error instanceof Error ? error : undefined, {
-                canRetry: true,
-                alternativePaths: [join(process.cwd(), "backup-output", relativePath)],
-            });
-        }
-    }
-    /**
-     * Write multiple files in batch for better performance
-     * @param files Map of relative path to content
-     */
-    async writeBatch(files) {
-        this.logger.debug(`Writing batch of ${files.size} files`);
-        const entries = Array.from(files.entries());
-        const results = [];
-        // Process in batches to avoid overwhelming the filesystem
-        for (let i = 0; i < entries.length; i += this.options.batchSize) {
-            const batch = entries.slice(i, i + this.options.batchSize);
-            const batchPromises = batch.map(([path, content]) => this.writeFile(path, content));
-            const batchResults = await Promise.all(batchPromises);
-            results.push(...batchResults);
-            // Small delay between batches to be filesystem-friendly
-            if (i + this.options.batchSize < entries.length) {
-                await new Promise((resolve) => setTimeout(resolve, 10));
-            }
-        }
-        return results;
-    }
-    /**
-     * Ensure directory exists, creating parent directories as needed
-     * @param dirPath Full directory path
-     */
-    async ensureDirectory(dirPath) {
-        try {
-            await mkdir(dirPath, { recursive: true });
-        }
-        catch (error) {
-            throw new FileOperationError(`Failed to create directory '${dirPath}': ${error}`, "create", dirPath, error instanceof Error ? error : undefined, {
-                canRetry: true,
-                permissionFix: `chmod 755 "${dirname(dirPath)}"`,
-            });
-        }
-    }
-    /**
-     * Clean directory by removing all contents
-     * @param relativePath Path relative to output directory
-     */
-    async cleanDirectory(relativePath = ".") {
-        const fullPath = join(this.options.outputDir, relativePath);
-        try {
-            await access(fullPath);
-            this.logger.debug(`Cleaning directory: ${relativePath}`);
-            await rm(fullPath, { recursive: true, force: true });
-        }
-        catch (error) {
-            // Directory doesn't exist - that's fine
-            if (error?.code !== "ENOENT") {
-                throw new FileOperationError(`Failed to clean directory '${relativePath}': ${error}`, "delete", fullPath, error instanceof Error ? error : undefined, {
-                    canRetry: true,
-                });
-            }
-        }
-    }
-    /**
-     * Get relative import path between two files
-     * @param fromFile Source file path
-     * @param toFile Target file path
-     */
-    getRelativeImportPath(fromFile, toFile) {
-        const from = dirname(join(this.options.outputDir, fromFile));
-        const to = join(this.options.outputDir, toFile);
-        let relativePath = relative(from, to);
-        // Ensure relative imports start with './' or '../'
-        if (!relativePath.startsWith(".")) {
-            relativePath = `./${relativePath}`;
-        }
-        // Remove file extension for imports (handle .d.ts files properly)
-        return relativePath.replace(/\.(d\.ts|ts|tsx|js|jsx)$/, "");
-    }
-    /**
-     * Check if a file would be overwritten
-     * @param relativePath Path relative to output directory
-     */
-    async wouldOverwrite(relativePath) {
-        const fullPath = join(this.options.outputDir, relativePath);
-        try {
-            await access(fullPath);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Get file statistics
-     * @param relativePath Path relative to output directory
-     */
-    async getFileStats(relativePath) {
-        const fullPath = join(this.options.outputDir, relativePath);
-        try {
-            const stats = await stat(fullPath);
-            return {
-                size: stats.size,
-                generationTime: 0, // Will be set by caller
-                writeTime: 0, // Will be set by caller
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Get output directory
-     */
-    getOutputDirectory() {
-        return this.options.outputDir;
-    }
-    /**
-     * Set batch size for operations
-     * @param size Batch size
-     */
-    setBatchSize(size) {
-        this.options.batchSize = Math.max(1, Math.min(50, size));
-    }
-    /**
-     * Get current batch size
-     */
-    getBatchSize() {
-        return this.options.batchSize;
-    }
-}

package/dist/api/generators/base/PythonTypeMapper.d.ts

@@ -1,16 +0,0 @@
-/**
- * Python type mapper implementation (basic version)
- */
-import type { Identifier } from "@typeschema/index";
-import { type LanguageType, TypeMapper } from "./TypeMapper";
-export declare class PythonTypeMapper extends TypeMapper {
-    getLanguageName(): string;
-    mapPrimitive(fhirType: string): LanguageType;
-    mapReference(_targets: Identifier[]): LanguageType;
-    mapArray(elementType: LanguageType): LanguageType;
-    mapOptional(type: LanguageType, required: boolean): LanguageType;
-    mapEnum(_values: string[], name?: string): LanguageType;
-    formatTypeName(name: string): string;
-    formatFieldName(name: string): string;
-    formatFileName(name: string): string;
-}

package/dist/api/generators/base/PythonTypeMapper.js

@@ -1,71 +0,0 @@
-/**
- * Python type mapper implementation (basic version)
- */
-import { TypeMapper } from "./TypeMapper";
-export class PythonTypeMapper extends TypeMapper {
-    getLanguageName() {
-        return "Python";
-    }
-    mapPrimitive(fhirType) {
-        const primitiveMap = {
-            string: "str",
-            integer: "int",
-            decimal: "float",
-            boolean: "bool",
-            dateTime: "datetime",
-            date: "date",
-            time: "time",
-        };
-        return {
-            name: primitiveMap[fhirType] || "Any",
-            isPrimitive: true,
-            nullable: false,
-        };
-    }
-    mapReference(_targets) {
-        return {
-            name: "Reference",
-            isPrimitive: false,
-            importPath: ".reference",
-            nullable: false,
-        };
-    }
-    mapArray(elementType) {
-        return {
-            name: `List[${elementType.name}]`,
-            isPrimitive: false,
-            importPath: "typing",
-            isArray: true,
-            nullable: false,
-        };
-    }
-    mapOptional(type, required) {
-        if (required)
-            return type;
-        return {
-            ...type,
-            name: `Optional[${type.name}]`,
-            nullable: true,
-        };
-    }
-    mapEnum(_values, name) {
-        return {
-            name: name ? this.formatTypeName(name) : "Literal",
-            isPrimitive: false,
-            nullable: false,
-        };
-    }
-    formatTypeName(name) {
-        return this.applyNamingConvention(name);
-    }
-    formatFieldName(name) {
-        // Convert camelCase to snake_case
-        return name
-            .replace(/([A-Z])/g, "_$1")
-            .toLowerCase()
-            .replace(/^_/, "");
-    }
-    formatFileName(name) {
-        return this.formatFieldName(name);
-    }
-}

package/dist/api/generators/base/TemplateEngine.d.ts

@@ -1,126 +0,0 @@
-/**
- * Abstract template engine for code generation
- *
- * Supports multiple template formats:
- * - Handlebars templates (.hbs)
- * - String templates (.template)
- * - Function templates (TypeScript functions)
- * - Inline templates (template literals)
- */
-import type { CodegenLogger } from "../../../utils/codegen-logger";
-/**
- * Template context passed to templates
- */
-export interface TemplateContext {
-    /** The schema being processed */
-    schema?: any;
-    /** Type mapper for language-specific types */
-    typeMapper?: any;
-    /** File name being generated */
-    filename?: string;
-    /** Target language */
-    language?: string;
-    /** Timestamp for generation */
-    timestamp?: string;
-    /** Import statements */
-    imports?: Map<string, string>;
-    /** Export names */
-    exports?: Set<string>;
-    /** Any additional context */
-    [key: string]: unknown;
-}
-/**
- * Template registration options
- */
-export interface TemplateOptions {
-    /** Template format */
-    format?: "handlebars" | "string" | "function";
-    /** Whether to cache compiled templates */
-    cache?: boolean;
-    /** Custom helpers for the template */
-    helpers?: Record<string, Function>;
-    /** Template-specific options */
-    options?: Record<string, unknown>;
-}
-/**
- * Template metadata
- */
-export interface TemplateInfo {
-    name: string;
-    format: string;
-    path?: string;
-    description?: string;
-    examples?: Array<{
-        context: TemplateContext;
-        expected: string;
-    }>;
-}
-/**
- * Abstract template engine
- */
-export declare abstract class TemplateEngine {
-    protected readonly logger: CodegenLogger;
-    protected readonly templates: Map<string, any>;
-    protected readonly templateCache: Map<string, any>;
-    protected readonly helpers: Map<string, Function>;
-    constructor(options: {
-        logger: CodegenLogger;
-    });
-    /**
-     * Render a template with context
-     * @param templateName Name of template to render
-     * @param context Template context
-     */
-    abstract render(templateName: string, context: TemplateContext): Promise<string>;
-    /**
-     * Register a template
-     * @param name Template name
-     * @param template Template content or function
-     * @param options Template options
-     */
-    abstract registerTemplate(name: string, template: string | Function, options?: TemplateOptions): void;
-    /**
-     * Load templates from directory
-     * @param directory Directory containing templates
-     */
-    abstract loadTemplatesFromDirectory(directory: string): Promise<void>;
-    /**
-     * Register a template helper function
-     * @param name Helper name
-     * @param helper Helper function
-     */
-    registerHelper(name: string, helper: Function): void;
-    /**
-     * Get available template names
-     */
-    getAvailableTemplates(): string[];
-    /**
-     * Get template information
-     * @param templateName Template name
-     */
-    getTemplateInfo(templateName: string): TemplateInfo | undefined;
-    /**
-     * Check if template exists
-     * @param templateName Template name
-     */
-    hasTemplate(templateName: string): boolean;
-    /**
-     * Remove a template
-     * @param templateName Template name
-     */
-    unregisterTemplate(templateName: string): boolean;
-    /**
-     * Clear all templates and cache
-     */
-    clearTemplates(): void;
-    /**
-     * Validate template context
-     * @param context Template context
-     * @param requiredFields Required context fields
-     */
-    protected validateContext(context: TemplateContext, requiredFields?: string[]): void;
-    /**
-     * Register default template helpers
-     */
-    protected registerDefaultHelpers(): void;
-}

package/dist/api/generators/base/TemplateEngine.js

@@ -1,133 +0,0 @@
-/**
- * Abstract template engine for code generation
- *
- * Supports multiple template formats:
- * - Handlebars templates (.hbs)
- * - String templates (.template)
- * - Function templates (TypeScript functions)
- * - Inline templates (template literals)
- */
-import { TemplateError } from "./errors";
-/**
- * Abstract template engine
- */
-export class TemplateEngine {
-    logger;
-    templates = new Map();
-    templateCache = new Map();
-    helpers = new Map();
-    constructor(options) {
-        this.logger = options.logger;
-        this.registerDefaultHelpers();
-    }
-    // ==========================================
-    // Concrete Methods
-    // ==========================================
-    /**
-     * Register a template helper function
-     * @param name Helper name
-     * @param helper Helper function
-     */
-    registerHelper(name, helper) {
-        this.helpers.set(name, helper);
-        this.logger.debug(`Registered template helper: ${name}`);
-    }
-    /**
-     * Get available template names
-     */
-    getAvailableTemplates() {
-        return Array.from(this.templates.keys()).sort();
-    }
-    /**
-     * Get template information
-     * @param templateName Template name
-     */
-    getTemplateInfo(templateName) {
-        const template = this.templates.get(templateName);
-        if (!template)
-            return undefined;
-        return {
-            name: templateName,
-            format: template.format || "unknown",
-            path: template.path,
-            description: template.description,
-            examples: template.examples || [],
-        };
-    }
-    /**
-     * Check if template exists
-     * @param templateName Template name
-     */
-    hasTemplate(templateName) {
-        return this.templates.has(templateName);
-    }
-    /**
-     * Remove a template
-     * @param templateName Template name
-     */
-    unregisterTemplate(templateName) {
-        const removed = this.templates.delete(templateName);
-        this.templateCache.delete(templateName);
-        if (removed) {
-            this.logger.debug(`Unregistered template: ${templateName}`);
-        }
-        return removed;
-    }
-    /**
-     * Clear all templates and cache
-     */
-    clearTemplates() {
-        this.templates.clear();
-        this.templateCache.clear();
-        this.logger.debug("Cleared all templates");
-    }
-    /**
-     * Validate template context
-     * @param context Template context
-     * @param requiredFields Required context fields
-     */
-    validateContext(context, requiredFields = []) {
-        for (const field of requiredFields) {
-            if (!(field in context)) {
-                throw new TemplateError(`Missing required context field: ${field}`, "unknown", context, {
-                    missingVariables: [field],
-                    availableTemplates: this.getAvailableTemplates(),
-                });
-            }
-        }
-    }
-    /**
-     * Register default template helpers
-     */
-    registerDefaultHelpers() {
-        // String manipulation helpers
-        this.registerHelper("capitalize", (str) => str.charAt(0).toUpperCase() + str.slice(1));
-        this.registerHelper("lowercase", (str) => str.toLowerCase());
-        this.registerHelper("uppercase", (str) => str.toUpperCase());
-        this.registerHelper("camelCase", (str) => str.replace(/[-_\s]+(.)/g, (_, char) => char.toUpperCase()));
-        this.registerHelper("pascalCase", (str) => {
-            const camelCase = str.replace(/[-_\s]+(.)/g, (_, char) => char.toUpperCase());
-            return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
-        });
-        this.registerHelper("snakeCase", (str) => str
-            .replace(/([A-Z])/g, "_$1")
-            .replace(/[-\s]+/g, "_")
-            .toLowerCase()
-            .replace(/^_/, ""));
-        // Array helpers
-        this.registerHelper("join", (arr, separator = ", ") => (Array.isArray(arr) ? arr.join(separator) : ""));
-        this.registerHelper("length", (arr) => (Array.isArray(arr) ? arr.length : 0));
-        // Logic helpers
-        this.registerHelper("eq", (a, b) => a === b);
-        this.registerHelper("ne", (a, b) => a !== b);
-        this.registerHelper("gt", (a, b) => a > b);
-        this.registerHelper("lt", (a, b) => a < b);
-        // Utility helpers
-        this.registerHelper("json", (obj) => JSON.stringify(obj, null, 2));
-        this.registerHelper("indent", (str, spaces = 2) => str
-            .split("\n")
-            .map((line) => " ".repeat(spaces) + line)
-            .join("\n"));
-        this.registerHelper("timestamp", () => new Date().toISOString());
-    }
-}

package/dist/api/generators/base/TypeMapper.d.ts

@@ -1,129 +0,0 @@
-/**
- * Abstract base class for language-specific type mapping
- *
- * This provides the interface that all language generators must implement
- * to convert FHIR TypeSchema types into their target language types.
- */
-import type { Identifier } from "@typeschema/types";
-/**
- * Represents a type in the target language
- */
-export interface LanguageType {
-    /** The type name in the target language */
-    name: string;
-    /** Whether this is a primitive type (doesn't need imports) */
-    isPrimitive: boolean;
-    /** Import path if this type needs to be imported */
-    importPath?: string;
-    /** Generic type parameters if applicable */
-    generics?: string[];
-    /** Whether this type can be null/undefined */
-    nullable?: boolean;
-    /** Whether this is an array type */
-    isArray?: boolean;
-    /** Additional metadata for language-specific features */
-    metadata?: Record<string, unknown>;
-}
-/**
- * Configuration for type mapping behavior
- */
-export interface TypeMapperOptions {
-    /** Whether to generate nullable types (e.g., T | null) */
-    generateNullable?: boolean;
-    /** Whether to use strict type checking */
-    strictTypes?: boolean;
-    /** Custom type mappings */
-    customMappings?: Record<string, string>;
-    /** Whether to generate array types or use generic collections */
-    preferArraySyntax?: boolean;
-    /** Naming convention strategy */
-    namingConvention?: "camelCase" | "PascalCase" | "snake_case" | "kebab-case";
-}
-/**
- * Abstract type mapper for language-specific type conversion
- */
-export declare abstract class TypeMapper {
-    protected readonly options: Required<TypeMapperOptions>;
-    constructor(options?: TypeMapperOptions);
-    /**
-     * Get the target language name (e.g., "TypeScript", "Python")
-     */
-    abstract getLanguageName(): string;
-    /**
-     * Map a FHIR primitive type to target language
-     * @param fhirType FHIR primitive type (string, integer, boolean, etc.)
-     */
-    abstract mapPrimitive(fhirType: string): LanguageType;
-    /**
-     * Map a reference type to target language
-     * @param targets Array of possible reference targets
-     */
-    abstract mapReference(targets: Identifier[]): LanguageType;
-    /**
-     * Map an array type to target language
-     * @param elementType The type of array elements
-     */
-    abstract mapArray(elementType: LanguageType): LanguageType;
-    /**
-     * Map an optional/nullable type
-     * @param type The base type
-     * @param required Whether the field is required
-     */
-    abstract mapOptional(type: LanguageType, required: boolean): LanguageType;
-    /**
-     * Map an enum/coded type
-     * @param values Possible enum values
-     * @param name Optional enum name
-     */
-    abstract mapEnum(values: string[], name?: string): LanguageType;
-    /**
-     * Format a type name according to language conventions
-     * @param name Raw type name
-     */
-    abstract formatTypeName(name: string): string;
-    /**
-     * Format a field name according to language conventions
-     * @param name Raw field name
-     */
-    abstract formatFieldName(name: string): string;
-    /**
-     * Format a file name according to language conventions
-     * @param name Raw file name (without extension)
-     */
-    abstract formatFileName(name: string): string;
-    /**
-     * Main entry point for type mapping
-     * @param schemaType Type from TypeSchema
-     */
-    mapType(schemaType: any): LanguageType;
-    /**
-     * Map a complex type (resource, complex-type)
-     * @param schemaType Complex type from schema
-     */
-    protected mapComplexType(schemaType: any): LanguageType;
-    /**
-     * Handle unknown/unmapped types
-     * @param schemaType Unknown type
-     */
-    protected mapUnknownType(schemaType: any): LanguageType;
-    /**
-     * Calculate import path for a type
-     * @param schemaType Type to calculate import for
-     */
-    protected calculateImportPath(schemaType: any): string | undefined;
-    /**
-     * Apply naming convention to a string
-     * @param name Input name
-     */
-    protected applyNamingConvention(name: string): string;
-    /**
-     * Get custom mapping if available
-     * @param type Original type name
-     */
-    protected getCustomMapping(type: string): string | undefined;
-    /**
-     * Check if type should be nullable
-     * @param required Whether field is required
-     */
-    protected shouldBeNullable(required: boolean): boolean;
-}