@atomic-ehr/codegen 0.0.1-canary.20251006070905.fb6ed98 → 0.0.1-canary.20251006094042.7f0be72

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

@@ -1,565 +0,0 @@
-/**
- * Abstract base generator class
- *
- * This is the foundation of the generator system. All language-specific generators
- * extend this class to inherit common functionality while implementing their own
- * specific logic for type mapping, content generation, and validation.
- */
-import { createLogger } from "../../../utils/codegen-logger";
-import { ErrorHandler, GeneratorErrorBoundary } from "./error-handler";
-import { ConfigurationError, SchemaValidationError } from "./errors";
-import { FileManager } from "./FileManager";
-/**
- * Abstract base generator class with comprehensive functionality
- *
- * Provides common functionality for all generators including:
- * - Schema validation and processing
- * - File management with fluent API
- * - Template processing
- * - Error handling and recovery
- * - Progress monitoring
- * - Performance optimization
- */
-export class BaseGenerator {
-    /** Validated and merged options */
-    options;
-    /** Logger instance for this generator */
-    logger;
-    /** File manager for all file operations */
-    fileManager;
-    /** Template engine for content generation (optional) */
-    templateEngine;
-    /** Language-specific type mapper */
-    typeMapper;
-    /** Enhanced error handler for comprehensive error reporting */
-    errorHandler;
-    /** Error boundary for catching and handling all generator errors */
-    errorBoundary;
-    /** Progress callback if provided */
-    progressCallback;
-    /** Generated files tracking */
-    generatedFiles = [];
-    /** Generation start time for performance metrics */
-    generationStartTime = 0;
-    /** Cache for expensive operations */
-    cache = new Map();
-    constructor(options) {
-        // Validate configuration first
-        const validation = this.validateConfiguration(options);
-        if (!validation.isValid) {
-            throw new ConfigurationError(`Invalid generator configuration: ${validation.errors.join(", ")}`, "configuration", options);
-        }
-        // Merge with defaults and store
-        this.options = this.mergeWithDefaults(options);
-        // Initialize logger
-        this.logger =
-            options.logger ||
-                createLogger({
-                    prefix: this.getLanguageName(),
-                    verbose: this.options.verbose || false,
-                });
-        // Initialize core components
-        this.fileManager = this.createFileManager();
-        this.templateEngine = this.createTemplateEngine();
-        this.typeMapper = this.createTypeMapper();
-        // Initialize enhanced error handling
-        this.errorHandler = new ErrorHandler({
-            logger: this.logger,
-            verbose: this.options.verbose || false,
-            beginnerMode: this.options.beginnerMode || false,
-            outputFormat: this.options.errorFormat || "console",
-        });
-        this.errorBoundary = new GeneratorErrorBoundary(this.errorHandler);
-        this.logger.debug(`${this.getLanguageName()} generator initialized`);
-        // Log any configuration warnings
-        if (validation.warnings.length > 0) {
-            validation.warnings.forEach((warning) => {
-                this.logger.warn(`Configuration warning: ${warning}`);
-            });
-        }
-    }
-    // ==========================================
-    // Optional Abstract Methods - Can be overridden
-    // ==========================================
-    /**
-     * Get generator capabilities - can be overridden for introspection
-     */
-    getCapabilities() {
-        return {
-            language: this.getLanguageName(),
-            fileExtensions: [this.getFileExtension()],
-            supportsTemplates: true,
-            supportsCustomTypeMapping: true,
-            supportsIncrementalGeneration: false,
-            supportsValidation: true,
-            supportedSchemaKinds: ["resource", "complex-type", "profile", "logical"],
-            version: "1.0.0",
-        };
-    }
-    /**
-     * Create file manager instance - can be overridden for custom file handling
-     */
-    createFileManager() {
-        return new FileManager({
-            outputDir: this.options.outputDir,
-            logger: this.logger.child("FileManager"),
-            overwrite: this.options.overwrite,
-        });
-    }
-    /**
-     * Create template engine instance - can be overridden for custom templates
-     * Returns undefined if template engine is not needed
-     */
-    createTemplateEngine() {
-        // Default implementation returns undefined (no template engine)
-        // Subclasses can override to provide template engine if needed
-        return undefined;
-    }
-    // ==========================================
-    // Public API - Main entry points
-    // ==========================================
-    /**
-     * Generate code from TypeSchema documents
-     * This is the main method that orchestrates the entire generation process
-     * @param schemas - Array of TypeSchema documents
-     */
-    async generate(schemas) {
-        return this.errorBoundary.withErrorBoundary(async () => {
-            this.generationStartTime = performance.now();
-            this.generatedFiles = [];
-            this.logger.info(`Starting ${this.getLanguageName()} generation for ${schemas.length} schemas`);
-            // Phase 1: Schema validation
-            this.reportProgress("validation", 0, schemas.length, "Validating schemas...");
-            await this.validateSchemas(schemas);
-            // Phase 2: Schema processing and filtering
-            this.reportProgress("generation", 0, schemas.length, "Processing schemas...");
-            const processedSchemas = this.filterAndSortSchemas(schemas);
-            this.logger.debug(`Filtered to ${processedSchemas.length} schemas for generation`);
-            // Phase 3: Content generation
-            await this.generateFiles(processedSchemas);
-            // Phase 4: Post-generation hooks
-            await this.runPostGenerationHooks();
-            this.reportProgress("complete", schemas.length, schemas.length, "Generation complete");
-            const duration = performance.now() - this.generationStartTime;
-            this.logger.info(`Generated ${this.generatedFiles.length} files in ${duration.toFixed(2)}ms ` +
-                `(avg ${(duration / this.generatedFiles.length).toFixed(2)}ms per file)`);
-            return this.generatedFiles;
-        }, { operationName: "generate" });
-    }
-    /**
-     * Generate and return content without writing files (useful for testing)
-     * @param schemas - Array of TypeSchema documents
-     */
-    async build(schemas) {
-        // Temporarily disable file writing by mocking the writeFile method
-        const originalWriteFile = this.fileManager.writeFile;
-        const mockWriteResults = new Map();
-        this.fileManager.writeFile = async (path, content) => {
-            const result = {
-                path: `${this.options.outputDir}/${path}`,
-                size: Buffer.byteLength(content, "utf-8"),
-                writeTime: 0,
-            };
-            mockWriteResults.set(path, result);
-            return result;
-        };
-        try {
-            const result = await this.generate(schemas);
-            // Update file paths to reflect what would have been written
-            result.forEach((file) => {
-                const mockResult = mockWriteResults.get(file.filename);
-                if (mockResult) {
-                    file.path = mockResult.path;
-                    file.size = mockResult.size;
-                }
-            });
-            return result;
-        }
-        finally {
-            // Restore original file writing function
-            this.fileManager.writeFile = originalWriteFile;
-        }
-    }
-    // ==========================================
-    // Fluent API - Builder pattern methods
-    // ==========================================
-    /**
-     * Create a file builder for fluent file generation
-     * @param filename - Name of the file to create
-     */
-    file(filename) {
-        if (!this.templateEngine) {
-            throw new Error("Template engine is required for fluent file generation. Override createTemplateEngine() in your generator.");
-        }
-        const { FileBuilder } = require("./builders/FileBuilder");
-        return new FileBuilder({
-            filename: this.ensureFileExtension(filename),
-            fileManager: this.fileManager,
-            templateEngine: this.templateEngine,
-            typeMapper: this.typeMapper,
-            logger: this.logger.child("FileBuilder"),
-        });
-    }
-    /**
-     * Create a directory builder for batch operations
-     * @param path - Directory path relative to output directory
-     */
-    directory(path) {
-        const { DirectoryBuilder } = require("./builders/DirectoryBuilder");
-        return new DirectoryBuilder({
-            path,
-            fileManager: this.fileManager,
-            logger: this.logger.child("DirectoryBuilder"),
-        });
-    }
-    /**
-     * Create an index file builder
-     * @param directory - Directory to create index for
-     */
-    index(directory = ".") {
-        if (!this.templateEngine) {
-            throw new Error("Template engine is required for index file generation. Override createTemplateEngine() in your generator.");
-        }
-        const { IndexBuilder } = require("./builders/IndexBuilder");
-        return new IndexBuilder({
-            directory,
-            fileManager: this.fileManager,
-            templateEngine: this.templateEngine,
-            logger: this.logger.child("IndexBuilder"),
-        });
-    }
-    /**
-     * Set progress callback for monitoring generation
-     * @param callback - Progress callback function
-     */
-    onProgress(callback) {
-        this.progressCallback = callback;
-        return this;
-    }
-    // ==========================================
-    // Configuration and Validation
-    // ==========================================
-    /**
-     * Validate generator configuration
-     */
-    validateConfiguration(options) {
-        const errors = [];
-        const warnings = [];
-        const suggestions = [];
-        // Required options validation
-        if (!options.outputDir) {
-            errors.push("outputDir is required");
-            suggestions.push("Provide a valid output directory path");
-        }
-        // Type validation
-        if (options.outputDir && typeof options.outputDir !== "string") {
-            errors.push("outputDir must be a string");
-        }
-        if (options.overwrite !== undefined && typeof options.overwrite !== "boolean") {
-            errors.push("overwrite must be a boolean");
-        }
-        if (options.validate !== undefined && typeof options.validate !== "boolean") {
-            errors.push("validate must be a boolean");
-        }
-        // Warnings for suboptimal configuration
-        if (options.outputDir && !require("node:path").isAbsolute(options.outputDir)) {
-            warnings.push("Using relative path for outputDir - consider using absolute path");
-            suggestions.push("Use path.resolve() to convert to absolute path");
-        }
-        if (options.validate === false) {
-            warnings.push("Validation is disabled - this may lead to invalid generated code");
-            suggestions.push("Consider enabling validation for better code quality");
-        }
-        return {
-            isValid: errors.length === 0,
-            errors,
-            warnings,
-            suggestions,
-        };
-    }
-    /**
-     * Merge options with defaults
-     */
-    mergeWithDefaults(options) {
-        return {
-            overwrite: true,
-            validate: true,
-            verbose: false,
-            beginnerMode: false,
-            errorFormat: "console",
-            ...options,
-        };
-    }
-    // ==========================================
-    // Schema Processing
-    // ==========================================
-    /**
-     * Validate schemas before processing
-     */
-    async validateSchemas(schemas) {
-        if (!this.options.validate) {
-            this.logger.debug("Schema validation disabled");
-            return;
-        }
-        this.logger.info(`🔍 Starting schema validation for ${schemas.length} schemas`);
-        this.logger.debug("Schema validation enabled - performing comprehensive validation");
-        const operations = schemas.map((schema) => () => this.errorBoundary.withErrorBoundary(async () => {
-            await this.validateSchema(schema);
-            this.reportProgress("validation", schemas.indexOf(schema) + 1, schemas.length, `Validated ${schema.identifier?.name || "schema"}`);
-        }, { schema, operationName: "validateSchema" }));
-        await this.errorBoundary.withBatchErrorBoundary(operations, {
-            operationName: "validateSchemas",
-        });
-        this.logger.debug(`Successfully validated ${schemas.length} schemas`);
-    }
-    /**
-     * Validate individual schema
-     */
-    async validateSchema(schema) {
-        const errors = [];
-        const schemaName = schema.identifier?.name || "unknown";
-        this.logger.debug(`🔍 Validating schema: ${schemaName} (kind: ${schema.identifier?.kind})`);
-        // Basic structure validation
-        if (!schema.identifier) {
-            errors.push("Schema missing identifier");
-            this.logger.warn(`❌ Schema missing identifier: ${JSON.stringify(schema, null, 2).substring(0, 200)}...`);
-        }
-        else {
-            if (!schema.identifier.name) {
-                errors.push("Schema identifier missing name");
-            }
-            if (!schema.identifier.kind) {
-                errors.push("Schema identifier missing kind");
-            }
-            else {
-                const validKinds = [
-                    "resource",
-                    "complex-type",
-                    "profile",
-                    "primitive-type",
-                    "logical",
-                    "value-set",
-                    "binding",
-                    "extension",
-                ];
-                if (!validKinds.includes(schema.identifier.kind)) {
-                    errors.push(`Schema identifier.kind must be one of: ${validKinds.join(", ")}`);
-                }
-            }
-        }
-        // Field validation
-        if ("fields" in schema && schema.fields) {
-            for (const [fieldName, field] of Object.entries(schema.fields)) {
-                if (!fieldName.trim()) {
-                    errors.push("Field name cannot be empty");
-                }
-                if (!field) {
-                    errors.push(`Field '${fieldName}' is null or undefined`);
-                }
-                // Add more field-specific validation as needed
-            }
-        }
-        // Circular reference detection (make it a warning, not an error for FHIR schemas)
-        if (await this.detectCircularReferences(schema)) {
-            this.logger.warn(`⚠️ Circular reference detected in schema '${schemaName}' - this may be expected for FHIR primitive types`);
-            // Don't add to errors - FHIR schemas often have legitimate circular references
-        }
-        if (errors.length > 0) {
-            this.logger.error(`❌ Schema validation failed for '${schemaName}': ${errors.join(", ")}`);
-            this.logger.debug(`Schema details: ${JSON.stringify(schema, null, 2)}`);
-            throw new SchemaValidationError(`Schema validation failed for '${schema.identifier?.name || "unknown"}'`, schema, errors);
-        }
-        this.logger.debug(`✅ Schema validation passed for '${schemaName}'`);
-    }
-    /**
-     * Detect circular references in schema dependencies
-     */
-    async detectCircularReferences(schema) {
-        // Simple implementation - can be enhanced for complex cases
-        const visited = new Set();
-        const visiting = new Set();
-        const checkCircular = (currentSchema) => {
-            const name = currentSchema.identifier?.name;
-            if (!name)
-                return false;
-            if (visiting.has(name)) {
-                return true; // Circular reference found
-            }
-            if (visited.has(name)) {
-                return false; // Already processed
-            }
-            visiting.add(name);
-            // Check field references
-            if ("fields" in currentSchema && currentSchema.fields) {
-                for (const field of Object.values(currentSchema.fields)) {
-                    if (field?.type?.name === name) {
-                        return true; // Self-reference
-                    }
-                    // Add more complex reference checking as needed
-                }
-            }
-            visiting.delete(name);
-            visited.add(name);
-            return false;
-        };
-        return checkCircular(schema);
-    }
-    // ==========================================
-    // File Generation
-    // ==========================================
-    /**
-     * Generate files from processed schemas
-     */
-    async generateFiles(schemas) {
-        const operations = schemas.map((schema, index) => () => this.errorBoundary.withErrorBoundary(async () => {
-            const file = await this.generateFileForSchema(schema, index, schemas.length);
-            this.generatedFiles.push(file);
-            return file;
-        }, { schema, operationName: "generateFile" }));
-        await this.errorBoundary.withBatchErrorBoundary(operations, {
-            operationName: "generateFiles",
-        });
-        this.logger.debug(`Generated ${this.generatedFiles.length} files`);
-    }
-    /**
-     * Generate a single file from a schema
-     */
-    async generateFileForSchema(schema, index, total) {
-        const fileStartTime = performance.now();
-        // Create template context
-        const context = {
-            schema,
-            typeMapper: this.typeMapper,
-            filename: this.typeMapper.formatFileName(schema.identifier?.name || "unknown"),
-            language: this.getLanguageName(),
-            timestamp: new Date().toISOString(),
-            imports: new Map(),
-            exports: new Set(),
-        };
-        // Generate content
-        const content = await this.generateSchemaContent(schema, context);
-        // Validate content if enabled
-        if (this.options.validate) {
-            await this.validateContent(content, context);
-        }
-        // Write file
-        const filename = context.filename + this.getFileExtension();
-        const writeResult = await this.fileManager.writeFile(filename, content);
-        const generationTime = performance.now() - fileStartTime;
-        // Report progress
-        this.reportProgress("writing", index + 1, total, `Generated ${filename} (${writeResult.size} bytes)`);
-        // Create GeneratedFile result
-        const generatedFile = {
-            path: writeResult.path,
-            filename,
-            content,
-            exports: this.extractExports(content),
-            size: writeResult.size,
-            timestamp: new Date(),
-            metadata: {
-                generationTime,
-                schemaCount: 1,
-                templateName: context.templateName?.toString(),
-                warnings: [],
-            },
-        };
-        return generatedFile;
-    }
-    // ==========================================
-    // Helper Methods
-    // ==========================================
-    /**
-     * Ensure filename has correct extension
-     */
-    ensureFileExtension(filename) {
-        const extension = this.getFileExtension();
-        return filename.endsWith(extension) ? filename : `${filename}${extension}`;
-    }
-    /**
-     * Extract exported symbols from generated content
-     * Can be overridden by language-specific implementations
-     */
-    extractExports(content) {
-        const exports = [];
-        // Handle export { name1, name2 } syntax
-        const exportListRegex = /export\s*\{\s*([^}]+)\s*\}/g;
-        let match;
-        while ((match = exportListRegex.exec(content)) !== null) {
-            if (match[1]) {
-                const names = match[1]
-                    .split(",")
-                    .map((name) => name.trim())
-                    .filter(Boolean);
-                exports.push(...names);
-            }
-        }
-        // Handle direct export declarations
-        const directExportRegex = /export\s+(?:const|let|var|function|class|interface|type|enum)\s+(\w+)/g;
-        while ((match = directExportRegex.exec(content)) !== null) {
-            if (match[1]) {
-                exports.push(match[1]);
-            }
-        }
-        // Remove duplicates
-        return [...new Set(exports)];
-    }
-    /**
-     * Report progress to callback if provided
-     */
-    reportProgress(phase, current, total, message, schema) {
-        if (this.progressCallback) {
-            this.progressCallback(phase, current, total, message, schema);
-        }
-        if (message && this.options.verbose) {
-            this.logger.debug(`[${phase}] ${message} (${current}/${total})`);
-        }
-    }
-    /**
-     * Run post-generation hooks
-     * Can be overridden to add custom post-processing
-     */
-    async runPostGenerationHooks() {
-        // Default implementation does nothing
-        // Subclasses can override to add custom logic
-    }
-    /**
-     * Get cached value or compute and cache it
-     */
-    getCachedOrCompute(key, computeFn) {
-        if (this.cache.has(key)) {
-            return this.cache.get(key);
-        }
-        const result = computeFn();
-        if (result instanceof Promise) {
-            return result.then((value) => {
-                this.cache.set(key, value);
-                return value;
-            });
-        }
-        else {
-            this.cache.set(key, result);
-            return result;
-        }
-    }
-    /**
-     * Clear internal cache
-     */
-    clearCache() {
-        this.cache.clear();
-    }
-    /**
-     * Get generation statistics
-     */
-    getGenerationStats() {
-        const totalSize = this.generatedFiles.reduce((sum, file) => sum + file.size, 0);
-        const generationTime = performance.now() - this.generationStartTime;
-        return {
-            filesGenerated: this.generatedFiles.length,
-            totalSize,
-            averageFileSize: this.generatedFiles.length > 0 ? totalSize / this.generatedFiles.length : 0,
-            generationTime,
-            averageTimePerFile: this.generatedFiles.length > 0 ? generationTime / this.generatedFiles.length : 0,
-            cacheHitRate: 0, // TODO: Implement cache hit tracking
-        };
-    }
-}

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

@@ -1,88 +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 type { CodegenLogger } from "../../../utils/codegen-logger";
-import type { FileStats } from "./types";
-export interface FileManagerOptions {
-    outputDir: string;
-    logger: CodegenLogger;
-    overwrite?: boolean;
-    batchSize?: number;
-}
-export interface WriteFileResult {
-    path: string;
-    size: number;
-    writeTime: number;
-}
-/**
- * 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 declare class FileManager {
-    private readonly options;
-    private readonly logger;
-    constructor(options: FileManagerOptions);
-    /**
-     * Write a file with automatic directory creation
-     * @param relativePath Path relative to output directory
-     * @param content File content
-     * @param options Write options
-     */
-    writeFile(relativePath: string, content: string, options?: {
-        encoding?: BufferEncoding;
-        overwrite?: boolean;
-    }): Promise<WriteFileResult>;
-    /**
-     * Write multiple files in batch for better performance
-     * @param files Map of relative path to content
-     */
-    writeBatch(files: Map<string, string>): Promise<WriteFileResult[]>;
-    /**
-     * Ensure directory exists, creating parent directories as needed
-     * @param dirPath Full directory path
-     */
-    ensureDirectory(dirPath: string): Promise<void>;
-    /**
-     * Clean directory by removing all contents
-     * @param relativePath Path relative to output directory
-     */
-    cleanDirectory(relativePath?: string): Promise<void>;
-    /**
-     * Get relative import path between two files
-     * @param fromFile Source file path
-     * @param toFile Target file path
-     */
-    getRelativeImportPath(fromFile: string, toFile: string): string;
-    /**
-     * Check if a file would be overwritten
-     * @param relativePath Path relative to output directory
-     */
-    wouldOverwrite(relativePath: string): Promise<boolean>;
-    /**
-     * Get file statistics
-     * @param relativePath Path relative to output directory
-     */
-    getFileStats(relativePath: string): Promise<FileStats | null>;
-    /**
-     * Get output directory
-     */
-    getOutputDirectory(): string;
-    /**
-     * Set batch size for operations
-     * @param size Batch size
-     */
-    setBatchSize(size: number): void;
-    /**
-     * Get current batch size
-     */
-    getBatchSize(): number;
-}