@archznn/xavva 2.6.0 → 2.7.0

package/src/di/container.ts

@@ -0,0 +1,226 @@
+/**
+ * Container de Injeção de Dependência (DI) simplificado
+ * Centraliza a criação e injeção de serviços
+ */
+
+import type { AppConfig } from "../types/config";
+import { ProjectService } from "../services/ProjectService";
+import { TomcatService } from "../services/TomcatService";
+import { BuildService } from "../services/BuildService";
+import { BuildCacheService } from "../services/BuildCacheService";
+import { AuditService } from "../services/AuditService";
+import { DashboardService } from "../services/DashboardService";
+import { LogAnalyzer } from "../services/LogAnalyzer";
+import { DeployCommand } from "../commands/DeployCommand";
+import { BuildCommand } from "../commands/BuildCommand";
+import { StartCommand } from "../commands/StartCommand";
+import { LogsCommand } from "../commands/LogsCommand";
+import { AuditCommand } from "../commands/AuditCommand";
+import { ProfilesCommand } from "../commands/ProfilesCommand";
+import { RunCommand } from "../commands/RunCommand";
+import { HelpCommand } from "../commands/HelpCommand";
+import { DoctorCommand } from "../commands/DoctorCommand";
+import { DepsCommand } from "../commands/DepsCommand";
+import { TomcatCommand } from "../commands/TomcatCommand";
+import { EncodingCommand } from "../commands/EncodingCommand";
+import { DocsCommand } from "../commands/DocsCommand";
+import type { Command } from "../commands/Command";
+import { Logger } from "../utils/ui";
+
+export interface Services {
+    projectService: ProjectService;
+    tomcatService: TomcatService;
+    buildCacheService: BuildCacheService;
+    buildService: BuildService;
+    auditService: AuditService;
+    dashboardService: DashboardService;
+    logAnalyzer: LogAnalyzer;
+}
+
+export interface Commands {
+    deploy: DeployCommand;
+    dev: DeployCommand;
+    build: BuildCommand;
+    start: StartCommand;
+    logs: LogsCommand;
+    audit: AuditCommand;
+    profiles: ProfilesCommand;
+    run: RunCommand;
+    debug: RunCommand;
+    help: HelpCommand;
+    doctor: DoctorCommand;
+    deps: DepsCommand;
+    tomcat: TomcatCommand;
+    encoding: EncodingCommand;
+    docs: DocsCommand;
+}
+
+export class DIContainer {
+    private config: AppConfig;
+    private services: Partial<Services> = {};
+    private commands: Partial<Commands> = {};
+    private isInitialized = false;
+
+    constructor(config: AppConfig) {
+        this.config = config;
+    }
+
+    /**
+     * Inicializa todos os serviços e comandos
+     */
+    initialize(): void {
+        if (this.isInitialized) {
+            Logger.debug("DI Container já inicializado");
+            return;
+        }
+
+        this.initializeServices();
+        this.initializeCommands();
+        this.isInitialized = true;
+    }
+
+    private initializeServices(): void {
+        // Serviços base (sem dependências ou com dependências simples)
+        const projectService = new ProjectService(this.config.project);
+        const buildCacheService = new BuildCacheService();
+        const dashboardService = new DashboardService(this.config);
+        const logAnalyzer = new LogAnalyzer(this.config.project);
+
+        // Configura Logger com dashboard
+        Logger.setDashboard(dashboardService);
+
+        // Serviços com dependências
+        const buildService = new BuildService(
+            this.config.project,
+            this.config.tomcat,
+            projectService,
+            buildCacheService
+        );
+
+        const tomcatService = new TomcatService(this.config.tomcat);
+        tomcatService.setProjectService(projectService);
+
+        const auditService = new AuditService(this.config.tomcat);
+
+        this.services = {
+            projectService,
+            buildCacheService,
+            buildService,
+            tomcatService,
+            auditService,
+            dashboardService,
+            logAnalyzer,
+        };
+    }
+
+    private initializeCommands(): void {
+        const { tomcatService, buildService, auditService, dashboardService, logAnalyzer } = this.services;
+
+        if (!tomcatService || !buildService || !auditService || !dashboardService || !logAnalyzer) {
+            throw new Error("Serviços não inicializados corretamente");
+        }
+
+        // Comandos que compartilham instâncias
+        const deployCmd = new DeployCommand(tomcatService, buildService);
+        const logsCmd = new LogsCommand(dashboardService, logAnalyzer);
+
+        this.commands = {
+            deploy: deployCmd,
+            dev: deployCmd, // dev reusa deploy
+            build: new BuildCommand(buildService),
+            start: new StartCommand(tomcatService),
+            logs: logsCmd,
+            audit: new AuditCommand(auditService),
+            profiles: new ProfilesCommand(this.services.projectService!),
+            run: new RunCommand(),
+            debug: new RunCommand(),
+            help: new HelpCommand(),
+            doctor: new DoctorCommand(),
+            deps: new DepsCommand(),
+            tomcat: new TomcatCommand(),
+            encoding: new EncodingCommand(),
+            docs: new DocsCommand(),
+        };
+    }
+
+    /**
+     * Obtém um serviço pelo nome
+     */
+    getService<K extends keyof Services>(name: K): Services[K] {
+        if (!this.isInitialized) {
+            this.initialize();
+        }
+        const service = this.services[name];
+        if (!service) {
+            throw new Error(`Serviço '${name}' não encontrado no container`);
+        }
+        return service;
+    }
+
+    /**
+     * Obtém um comando pelo nome
+     */
+    getCommand<K extends keyof Commands>(name: K): Commands[K] {
+        if (!this.isInitialized) {
+            this.initialize();
+        }
+        const command = this.commands[name];
+        if (!command) {
+            throw new Error(`Comando '${name}' não encontrado no container`);
+        }
+        return command;
+    }
+
+    /**
+     * Obtém todos os serviços
+     */
+    getAllServices(): Services {
+        if (!this.isInitialized) {
+            this.initialize();
+        }
+        return this.services as Services;
+    }
+
+    /**
+     * Obtém todos os comandos
+     */
+    getAllCommands(): Commands {
+        if (!this.isInitialized) {
+            this.initialize();
+        }
+        return this.commands as Commands;
+    }
+
+    /**
+     * Registra um serviço customizado (útil para testes)
+     */
+    registerService<K extends keyof Services>(name: K, service: Services[K]): void {
+        this.services[name] = service;
+    }
+
+    /**
+     * Registra um comando customizado (útil para testes)
+     */
+    registerCommand<K extends keyof Commands>(name: K, command: Commands[K]): void {
+        this.commands[name] = command;
+    }
+}
+
+// Singleton para uso global
+let globalContainer: DIContainer | null = null;
+
+export function createContainer(config: AppConfig): DIContainer {
+    globalContainer = new DIContainer(config);
+    return globalContainer;
+}
+
+export function getContainer(): DIContainer {
+    if (!globalContainer) {
+        throw new Error("Container não inicializado. Chame createContainer primeiro.");
+    }
+    return globalContainer;
+}
+
+export function resetContainer(): void {
+    globalContainer = null;
+}

package/src/errors/ErrorHandler.ts

@@ -0,0 +1,249 @@
+/**
+ * ErrorHandler centralizado
+ * Trata todos os erros do aplicativo de forma uniforme
+ */
+
+import { 
+    XavvaError, 
+    isOperationalError, 
+    getExitCode,
+    NetworkError,
+    FileSystemError,
+    BuildError,
+    TomcatError,
+    ConfigError
+} from "./XavvaError";
+import { Logger } from "../utils/ui";
+import { ProcessManager } from "../utils/processManager";
+
+export interface ErrorReport {
+    error: Error;
+    code: string;
+    exitCode: number;
+    isOperational: boolean;
+    context?: Record<string, unknown>;
+    timestamp: Date;
+}
+
+export class ErrorHandler {
+    private static instance: ErrorHandler;
+    private errorHistory: ErrorReport[] = [];
+    private maxHistorySize = 10;
+    private isShuttingDown = false;
+
+    private constructor() {}
+
+    static getInstance(): ErrorHandler {
+        if (!ErrorHandler.instance) {
+            ErrorHandler.instance = new ErrorHandler();
+        }
+        return ErrorHandler.instance;
+    }
+
+    /**
+     * Trata qualquer erro de forma apropriada
+     */
+    async handle(error: unknown, context?: Record<string, unknown>): Promise<void> {
+        if (this.isShuttingDown) return;
+
+        const normalizedError = this.normalizeError(error);
+        const report = this.createReport(normalizedError, context);
+        
+        // Adiciona ao histórico
+        this.addToHistory(report);
+
+        // Log apropriado baseado no tipo de erro
+        if (normalizedError instanceof XavvaError) {
+            this.handleXavvaError(normalizedError);
+        } else {
+            this.handleUnexpectedError(normalizedError);
+        }
+
+        // Se não for erro operacional, mostra stack trace em verbose
+        if (!report.isOperational) {
+            Logger.debug("Stack trace:");
+            Logger.debug(normalizedError.stack || "N/A");
+        }
+
+        // Shutdown com código apropriado
+        const processManager = ProcessManager.getInstance();
+        await processManager.shutdown(report.exitCode);
+    }
+
+    /**
+     * Trata erro sem fazer shutdown (para operações que podem continuar)
+     */
+    handleGraceful(error: unknown, context?: Record<string, unknown>): ErrorReport {
+        const normalizedError = this.normalizeError(error);
+        const report = this.createReport(normalizedError, context);
+        
+        this.addToHistory(report);
+
+        if (normalizedError instanceof XavvaError) {
+            this.logXavvaError(normalizedError, false);
+        } else {
+            Logger.warn(`Erro inesperado: ${normalizedError.message}`);
+        }
+
+        return report;
+    }
+
+    /**
+     * Normaliza qualquer valor para Error
+     */
+    private normalizeError(error: unknown): Error {
+        if (error instanceof Error) {
+            return error;
+        }
+        
+        if (typeof error === "string") {
+            return new Error(error);
+        }
+        
+        if (error && typeof error === "object" && "message" in error) {
+            return new Error(String((error as { message: unknown }).message));
+        }
+        
+        return new Error("Erro desconhecido");
+    }
+
+    /**
+     * Cria um relatório de erro estruturado
+     */
+    private createReport(error: Error, context?: Record<string, unknown>): ErrorReport {
+        return {
+            error,
+            code: error instanceof XavvaError ? error.code : "UNKNOWN_ERROR",
+            exitCode: getExitCode(error),
+            isOperational: isOperationalError(error),
+            context,
+            timestamp: new Date(),
+        };
+    }
+
+    /**
+     * Adiciona erro ao histórico (com limite)
+     */
+    private addToHistory(report: ErrorReport): void {
+        this.errorHistory.push(report);
+        if (this.errorHistory.length > this.maxHistorySize) {
+            this.errorHistory.shift();
+        }
+    }
+
+    /**
+     * Trata erros específicos do Xavva
+     */
+    private handleXavvaError(error: XavvaError): void {
+        this.logXavvaError(error, true);
+    }
+
+    /**
+     * Loga erro Xavva com formatação adequada
+     */
+    private logXavvaError(error: XavvaError, isFatal: boolean): void {
+        const logMethod = isFatal ? Logger.error : Logger.warn;
+        
+        // Cabeçalho do erro
+        logMethod.call(Logger, error.message);
+        
+        // Detalhes adicionais se houver
+        if (error instanceof NetworkError) {
+            Logger.info("Dica", "Verifique sua conexão de internet e tente novamente");
+        } else if (error instanceof FileSystemError) {
+            Logger.info("Dica", "Verifique as permissões do arquivo/diretório");
+        } else if (error instanceof BuildError) {
+            Logger.info("Dica", "Use --verbose para ver detalhes completos do build");
+        } else if (error instanceof TomcatError) {
+            Logger.info("Dica", "Verifique se o Tomcat está configurado corretamente");
+        } else if (error instanceof ConfigError) {
+            Logger.info("Dica", "Verifique seu arquivo xavva.json");
+        }
+
+        // Código do erro em debug
+        Logger.debug(`Código do erro: ${error.code} (exit ${error.exitCode})`);
+    }
+
+    /**
+     * Trata erros inesperados (bugs)
+     */
+    private handleUnexpectedError(error: Error): void {
+        Logger.error("Erro inesperado:");
+        Logger.error(error.message);
+        Logger.newline();
+        Logger.info("Isso parece ser um bug", "Por favor, reporte em github.com/leorsousa05/Xavva/issues");
+        
+        // Sempre mostra stack trace para erros inesperados
+        if (error.stack) {
+            Logger.newline();
+            Logger.dim("Stack trace:");
+            Logger.dim(error.stack.split("\n").slice(1, 5).join("\n"));
+        }
+    }
+
+    /**
+     * Obtém histórico de erros
+     */
+    getErrorHistory(): ErrorReport[] {
+        return [...this.errorHistory];
+    }
+
+    /**
+     * Limpa histórico de erros
+     */
+    clearHistory(): void {
+        this.errorHistory = [];
+    }
+
+    /**
+     * Verifica se houve erros recentes de um tipo específico
+     */
+    hasRecentError(code: string, withinMs: number = 60000): boolean {
+        const now = Date.now();
+        return this.errorHistory.some(
+            report => 
+                report.code === code && 
+                (now - report.timestamp.getTime()) < withinMs
+        );
+    }
+
+    /**
+     * Wrapper para executar função com tratamento de erro automático
+     */
+    async wrap<T>(
+        fn: () => Promise<T>, 
+        context?: Record<string, unknown>
+    ): Promise<T | undefined> {
+        try {
+            return await fn();
+        } catch (error) {
+            await this.handle(error, context);
+            return undefined;
+        }
+    }
+
+    /**
+     * Wrapper para executar função sem shutdown em caso de erro
+     */
+    wrapGraceful<T>(
+        fn: () => T, 
+        fallback: T,
+        context?: Record<string, unknown>
+    ): T {
+        try {
+            return fn();
+        } catch (error) {
+            this.handleGraceful(error, context);
+            return fallback;
+        }
+    }
+}
+
+// Helper para uso rápido
+export function handleError(error: unknown, context?: Record<string, unknown>): Promise<void> {
+    return ErrorHandler.getInstance().handle(error, context);
+}
+
+export function handleGraceful(error: unknown, context?: Record<string, unknown>): ErrorReport {
+    return ErrorHandler.getInstance().handleGraceful(error, context);
+}