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

package/dist/api/generators/base/error-handler.d.ts

@@ -1,89 +0,0 @@
-/**
- * Centralized error handling and reporting system
- *
- * This module provides a comprehensive error handling solution that:
- * - Handles both generator-specific and unknown errors gracefully
- * - Provides rich, context-aware error reporting
- * - Supports multiple output formats (console, JSON, structured)
- * - Includes batch error handling for multiple failures
- * - Offers smart error recovery suggestions
- */
-import type { TypeSchema } from "@typeschema/types";
-import type { CodegenLogger } from "../../../utils/codegen-logger";
-export interface ErrorHandlerOptions {
-    logger: CodegenLogger;
-    verbose?: boolean;
-    beginnerMode?: boolean;
-    outputFormat?: "console" | "json" | "structured";
-}
-/**
- * Centralized error handler with smart reporting
- */
-export declare class ErrorHandler {
-    private options;
-    constructor(options: ErrorHandlerOptions);
-    /**
-     * Handle a single error with appropriate reporting
-     */
-    handleError(error: Error, context?: {
-        schema?: TypeSchema;
-        filename?: string;
-    }): void;
-    /**
-     * Handle multiple errors in batch
-     */
-    handleBatchErrors(errors: Error[]): void;
-    /**
-     * Handle generator-specific errors with rich context
-     */
-    private handleGeneratorError;
-    /**
-     * Handle unknown errors gracefully
-     */
-    private handleUnknownError;
-    /**
-     * Report error to console with formatting
-     */
-    private reportErrorToConsole;
-    /**
-     * Report error as JSON for programmatic consumption
-     */
-    private reportErrorAsJson;
-    /**
-     * Report error in structured format
-     */
-    private reportErrorStructured;
-    /**
-     * Report multiple errors efficiently
-     */
-    private reportBatchErrors;
-    /**
-     * Get common suggestions across similar errors
-     */
-    private getCommonSuggestions;
-    /**
-     * Get recovery actions for an error
-     */
-    private getRecoveryActions;
-}
-/**
- * Error boundary for catching and handling all generator errors
- */
-export declare class GeneratorErrorBoundary {
-    private errorHandler;
-    constructor(errorHandler: ErrorHandler);
-    /**
-     * Wrap an async operation with error boundary
-     */
-    withErrorBoundary<T>(operation: () => Promise<T>, context?: {
-        schema?: TypeSchema;
-        filename?: string;
-        operationName?: string;
-    }): Promise<T>;
-    /**
-     * Wrap a batch operation with error boundary
-     */
-    withBatchErrorBoundary<T>(operations: Array<() => Promise<T>>, _context?: {
-        operationName?: string;
-    }): Promise<T[]>;
-}

package/dist/api/generators/base/error-handler.js

@@ -1,243 +0,0 @@
-/**
- * Centralized error handling and reporting system
- *
- * This module provides a comprehensive error handling solution that:
- * - Handles both generator-specific and unknown errors gracefully
- * - Provides rich, context-aware error reporting
- * - Supports multiple output formats (console, JSON, structured)
- * - Includes batch error handling for multiple failures
- * - Offers smart error recovery suggestions
- */
-import { BatchOperationError, GeneratorError } from "./errors";
-/**
- * Centralized error handler with smart reporting
- */
-export class ErrorHandler {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    /**
-     * Handle a single error with appropriate reporting
-     */
-    handleError(error, context) {
-        if (error instanceof GeneratorError) {
-            this.handleGeneratorError(error, context);
-        }
-        else {
-            this.handleUnknownError(error, context);
-        }
-    }
-    /**
-     * Handle multiple errors in batch
-     */
-    handleBatchErrors(errors) {
-        const generatorErrors = errors.filter((e) => e instanceof GeneratorError);
-        const unknownErrors = errors.filter((e) => !(e instanceof GeneratorError));
-        if (generatorErrors.length > 0) {
-            this.reportBatchErrors(generatorErrors);
-        }
-        unknownErrors.forEach((error) => {
-            this.handleUnknownError(error);
-        });
-    }
-    /**
-     * Handle generator-specific errors with rich context
-     */
-    handleGeneratorError(error, _context) {
-        switch (this.options.outputFormat) {
-            case "json":
-                this.reportErrorAsJson(error);
-                break;
-            case "structured":
-                this.reportErrorStructured(error);
-                break;
-            default:
-                this.reportErrorToConsole(error);
-        }
-    }
-    /**
-     * Handle unknown errors gracefully
-     */
-    handleUnknownError(error, context) {
-        this.options.logger.error("Unexpected error occurred:", error);
-        if (this.options.verbose) {
-            console.error("\n🚨 Unexpected Error Details:");
-            console.error(`   Type: ${error.constructor.name}`);
-            console.error(`   Message: ${error.message}`);
-            if (error.stack) {
-                console.error(`   Stack: ${error.stack}`);
-            }
-            if (context?.schema) {
-                console.error(`   Schema: ${context.schema.identifier.name}`);
-            }
-            if (context?.filename) {
-                console.error(`   File: ${context.filename}`);
-            }
-        }
-        console.error("\n💡 General troubleshooting suggestions:");
-        console.error("   • Run with --verbose flag for more details");
-        console.error("   • Check your input files for corruption");
-        console.error("   • Update to the latest version of atomic-codegen");
-        console.error("   • Report this issue at: https://github.com/atomic-ehr/codegen/issues");
-    }
-    /**
-     * Report error to console with formatting
-     */
-    reportErrorToConsole(error) {
-        if ("getFormattedMessage" in error) {
-            console.error(error.getFormattedMessage());
-        }
-        else {
-            console.error(`\n❌ ${error.constructor.name}: ${error.message}`);
-            const suggestions = error.getSuggestions();
-            if (suggestions.length > 0) {
-                console.error("\n💡 Suggestions:");
-                suggestions.forEach((suggestion) => {
-                    console.error(`   • ${suggestion}`);
-                });
-            }
-        }
-        if (this.options.verbose && error.context) {
-            console.error("\n🔍 Debug Information:");
-            console.error(JSON.stringify(error.context, null, 2));
-        }
-    }
-    /**
-     * Report error as JSON for programmatic consumption
-     */
-    reportErrorAsJson(error) {
-        const errorData = {
-            type: error.constructor.name,
-            message: error.message,
-            phase: error.phase,
-            context: error.context,
-            suggestions: error.getSuggestions(),
-            timestamp: new Date().toISOString(),
-        };
-        console.error(JSON.stringify(errorData, null, 2));
-    }
-    /**
-     * Report error in structured format
-     */
-    reportErrorStructured(error) {
-        const structure = {
-            error: {
-                type: error.constructor.name,
-                message: error.message,
-                phase: error.phase,
-            },
-            context: error.context,
-            suggestions: error.getSuggestions(),
-            actions: this.getRecoveryActions(error),
-        };
-        console.error("---");
-        console.error("Error Report:");
-        console.error(JSON.stringify(structure, null, 2));
-        console.error("---");
-    }
-    /**
-     * Report multiple errors efficiently
-     */
-    reportBatchErrors(errors) {
-        console.error(`\n❌ ${errors.length} errors occurred during generation:`);
-        // Group errors by type
-        const errorGroups = new Map();
-        errors.forEach((error) => {
-            const type = error.constructor.name;
-            if (!errorGroups.has(type)) {
-                errorGroups.set(type, []);
-            }
-            errorGroups.get(type)?.push(error);
-        });
-        // Report each group
-        for (const [type, groupErrors] of errorGroups) {
-            console.error(`\n📋 ${type} (${groupErrors.length} occurrences):`);
-            groupErrors.forEach((error, index) => {
-                console.error(`   ${index + 1}. ${error.message}`);
-                if (error.context?.schemaName) {
-                    console.error(`      Schema: ${error.context.schemaName}`);
-                }
-            });
-            // Show common suggestions for this error type
-            const commonSuggestions = this.getCommonSuggestions(groupErrors);
-            if (commonSuggestions.length > 0) {
-                console.error("\n   💡 Common suggestions:");
-                commonSuggestions.forEach((suggestion) => {
-                    console.error(`      • ${suggestion}`);
-                });
-            }
-        }
-    }
-    /**
-     * Get common suggestions across similar errors
-     */
-    getCommonSuggestions(errors) {
-        const allSuggestions = errors.flatMap((e) => e.getSuggestions());
-        const suggestionCounts = new Map();
-        allSuggestions.forEach((suggestion) => {
-            suggestionCounts.set(suggestion, (suggestionCounts.get(suggestion) || 0) + 1);
-        });
-        // Return suggestions that appear in at least half the errors
-        const threshold = Math.ceil(errors.length / 2);
-        return Array.from(suggestionCounts.entries())
-            .filter(([_, count]) => count >= threshold)
-            .map(([suggestion, _]) => suggestion)
-            .slice(0, 5); // Limit to 5 most common
-    }
-    /**
-     * Get recovery actions for an error
-     */
-    getRecoveryActions(error) {
-        if ("getRecoveryActions" in error) {
-            return error.getRecoveryActions();
-        }
-        return [
-            { action: "Review error message and suggestions above" },
-            { action: "Check input files and configuration" },
-            { action: "Try with --verbose flag for more information" },
-        ];
-    }
-}
-/**
- * Error boundary for catching and handling all generator errors
- */
-export class GeneratorErrorBoundary {
-    errorHandler;
-    constructor(errorHandler) {
-        this.errorHandler = errorHandler;
-    }
-    /**
-     * Wrap an async operation with error boundary
-     */
-    async withErrorBoundary(operation, context) {
-        try {
-            return await operation();
-        }
-        catch (error) {
-            this.errorHandler.handleError(error instanceof Error ? error : new Error(String(error)), context);
-            throw error; // Re-throw after handling
-        }
-    }
-    /**
-     * Wrap a batch operation with error boundary
-     */
-    async withBatchErrorBoundary(operations, _context) {
-        const results = [];
-        const errors = [];
-        for (const operation of operations) {
-            try {
-                const result = await operation();
-                results.push(result);
-            }
-            catch (error) {
-                errors.push(error instanceof Error ? error : new Error(String(error)));
-            }
-        }
-        if (errors.length > 0) {
-            this.errorHandler.handleBatchErrors(errors);
-            throw new BatchOperationError(`${errors.length} operations failed`, errors.filter((e) => e instanceof GeneratorError));
-        }
-        return results;
-    }
-}

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

@@ -1,251 +0,0 @@
-/**
- * Comprehensive error handling system for the base generator
- *
- * This module provides rich, contextual error classes that help developers
- * at all skill levels understand and resolve issues quickly.
- */
-import type { TypeSchema } from "@typeschema/index";
-import type { FileContext } from "./types";
-/**
- * Base error class for all generator-related errors
- *
- * Provides common functionality like context tracking, suggestions,
- * and detailed error reporting that makes debugging easier.
- */
-export declare abstract class GeneratorError extends Error {
-    /** Phase of generation where error occurred */
-    readonly phase: "validation" | "generation" | "writing" | "initialization";
-    /** Additional context about the error */
-    readonly context?: Record<string, unknown> | undefined;
-    /** When this error occurred */
-    readonly timestamp: Date;
-    /** Unique error ID for tracking */
-    readonly errorId: string;
-    constructor(message: string, 
-    /** Phase of generation where error occurred */
-    phase: "validation" | "generation" | "writing" | "initialization", 
-    /** Additional context about the error */
-    context?: Record<string, unknown> | undefined);
-    /**
-     * Generate a unique error ID for tracking
-     */
-    private generateErrorId;
-    /**
-     * Get formatted error message with full context
-     * This provides a comprehensive view of what went wrong
-     */
-    getDetailedMessage(): string;
-    /**
-     * Format context values for display
-     */
-    private formatContextValue;
-    /**
-     * Get actionable suggestions for fixing the error
-     * Each error type should provide specific, helpful suggestions
-     */
-    abstract getSuggestions(): string[];
-    /**
-     * Get error severity level
-     */
-    getSeverity(): "error" | "warning" | "info";
-    /**
-     * Check if this error is recoverable
-     */
-    isRecoverable(): boolean;
-    /**
-     * Get related documentation links
-     */
-    getDocumentationLinks(): string[];
-}
-/**
- * Schema validation errors with intelligent suggestions
- */
-export declare class SchemaValidationError extends GeneratorError {
-    /** The schema that failed validation */
-    readonly schema: TypeSchema;
-    /** Specific validation errors */
-    readonly validationErrors: string[];
-    /** Additional user context for better suggestions */
-    readonly userContext?: {
-        isBeginnerMode?: boolean;
-        previousSuccessfulSchemas?: string[];
-        commonPatterns?: string[];
-    } | undefined;
-    constructor(message: string, 
-    /** The schema that failed validation */
-    schema: TypeSchema, 
-    /** Specific validation errors */
-    validationErrors: string[], 
-    /** Additional user context for better suggestions */
-    userContext?: {
-        isBeginnerMode?: boolean;
-        previousSuccessfulSchemas?: string[];
-        commonPatterns?: string[];
-    } | undefined);
-    getSuggestions(): string[];
-    isRecoverable(): boolean;
-}
-/**
- * Template processing errors with debugging information
- */
-export declare class TemplateError extends GeneratorError {
-    /** Name of the template that failed */
-    readonly templateName: string;
-    /** Context data passed to the template */
-    readonly templateContext: Record<string, unknown>;
-    /** Additional debugging information */
-    readonly debugInfo?: {
-        availableTemplates?: string[];
-        missingVariables?: string[];
-        templateSource?: string;
-        lineNumber?: number;
-        columnNumber?: number;
-    } | undefined;
-    constructor(message: string, 
-    /** Name of the template that failed */
-    templateName: string, 
-    /** Context data passed to the template */
-    templateContext: Record<string, unknown>, 
-    /** Additional debugging information */
-    debugInfo?: {
-        availableTemplates?: string[];
-        missingVariables?: string[];
-        templateSource?: string;
-        lineNumber?: number;
-        columnNumber?: number;
-    } | undefined);
-    getSuggestions(): string[];
-    /**
-     * Find templates with similar names using Levenshtein distance
-     */
-    private findSimilarTemplates;
-    /**
-     * Calculate Levenshtein distance between two strings
-     */
-    private levenshteinDistance;
-    isRecoverable(): boolean;
-}
-/**
- * File operation errors with recovery suggestions
- */
-export declare class FileOperationError extends GeneratorError {
-    /** Type of file operation that failed */
-    readonly operation: "create" | "write" | "read" | "delete" | "copy" | "move";
-    /** Path of the file that caused the error */
-    readonly filePath: string;
-    /** Original system error if available */
-    readonly originalError?: Error | undefined;
-    /** Recovery options and suggestions */
-    readonly recoveryOptions?: {
-        canRetry?: boolean;
-        alternativePaths?: string[];
-        permissionFix?: string;
-        diskSpaceRequired?: number;
-    } | undefined;
-    constructor(message: string, 
-    /** Type of file operation that failed */
-    operation: "create" | "write" | "read" | "delete" | "copy" | "move", 
-    /** Path of the file that caused the error */
-    filePath: string, 
-    /** Original system error if available */
-    originalError?: Error | undefined, 
-    /** Recovery options and suggestions */
-    recoveryOptions?: {
-        canRetry?: boolean;
-        alternativePaths?: string[];
-        permissionFix?: string;
-        diskSpaceRequired?: number;
-    } | undefined);
-    getSuggestions(): string[];
-    isRecoverable(): boolean;
-    /**
-     * Get specific recovery actions that can be taken
-     */
-    getRecoveryActions(): Array<{
-        action: string;
-        command?: string;
-        automatic?: boolean;
-        riskLevel?: "low" | "medium" | "high";
-    }>;
-}
-/**
- * Type mapping errors for language-specific type conversion issues
- */
-export declare class TypeMappingError extends GeneratorError {
-    /** FHIR type that couldn't be mapped */
-    readonly fhirType: string;
-    /** Target language name */
-    readonly targetLanguage: string;
-    /** Additional mapping context */
-    readonly mappingContext?: {
-        availableMappings?: string[];
-        suggestedMappings?: Record<string, string>;
-        schema?: TypeSchema;
-    } | undefined;
-    constructor(message: string, 
-    /** FHIR type that couldn't be mapped */
-    fhirType: string, 
-    /** Target language name */
-    targetLanguage: string, 
-    /** Additional mapping context */
-    mappingContext?: {
-        availableMappings?: string[];
-        suggestedMappings?: Record<string, string>;
-        schema?: TypeSchema;
-    } | undefined);
-    getSuggestions(): string[];
-    isRecoverable(): boolean;
-}
-/**
- * Configuration errors with validation details
- */
-export declare class ConfigurationError extends GeneratorError {
-    /** Configuration key that has an issue */
-    readonly configKey: string;
-    /** The invalid value that was provided */
-    readonly providedValue: unknown;
-    /** Expected value type or format */
-    readonly expectedValue?: string | undefined;
-    /** Valid options if applicable */
-    readonly validOptions?: unknown[] | undefined;
-    constructor(message: string, 
-    /** Configuration key that has an issue */
-    configKey: string, 
-    /** The invalid value that was provided */
-    providedValue: unknown, 
-    /** Expected value type or format */
-    expectedValue?: string | undefined, 
-    /** Valid options if applicable */
-    validOptions?: unknown[] | undefined);
-    getSuggestions(): string[];
-    isRecoverable(): boolean;
-}
-/**
- * Batch operation error for multiple failures
- */
-export declare class BatchOperationError extends GeneratorError {
-    /** Individual errors that occurred */
-    readonly errors: GeneratorError[];
-    constructor(message: string, 
-    /** Individual errors that occurred */
-    errors: GeneratorError[]);
-    getSuggestions(): string[];
-    /**
-     * Get detailed breakdown of all errors
-     */
-    getErrorBreakdown(): string;
-    isRecoverable(): boolean;
-    /**
-     * Get errors that are recoverable
-     */
-    getRecoverableErrors(): GeneratorError[];
-    /**
-     * Get errors that are not recoverable
-     */
-    getNonRecoverableErrors(): GeneratorError[];
-}
-/**
- * Utility function to create context-aware errors
- * Helps maintain consistent error creation patterns
- */
-export declare function createErrorWithContext<T extends GeneratorError>(ErrorClass: new (...args: any[]) => T, message: string, context: FileContext, additionalContext?: Record<string, unknown>): T;