@archznn/xavva 3.1.3 → 3.2.0

package/src/di/container.ts

@@ -1,6 +1,10 @@
 /**
- * Container de Injeção de Dependência (DI) simplificado
- * Centraliza a criação e injeção de serviços
+ * Container de Injeção de Dependência (DI) com Lazy Loading
+ * 
+ * Características:
+ * - Serviços são criados apenas quando necessários
+ * - Cache de instâncias para reuso
+ * - Inicialização rápida (só cria o essencial)
  */
 
 import type { AppConfig } from "../types/config";
@@ -36,7 +40,8 @@ import { TestCommand } from "../commands/TestCommand";
 import { DbCommand } from "../commands/DbCommand";
 import { HttpCommand } from "../commands/HttpCommand";
 import { DockerCommand } from "../commands/DockerCommand";
-import { NotificationService } from "../services/NotificationService";
+import { CleanCommand } from "../commands/CleanCommand";
+import { IdeCommand } from "../commands/IdeCommand";
 import type { Command } from "../commands/Command";
 import { Logger } from "../utils/ui";
 
@@ -78,20 +83,150 @@ export interface Commands {
     db: DbCommand;
     http: HttpCommand;
     docker: DockerCommand;
+    clean: CleanCommand;
+    ide: IdeCommand;
 }
 
+// Tipo para factory functions
+type ServiceFactory<T> = () => T;
+type CommandFactory<T> = (services: Services) => T;
+
 export class DIContainer {
     private config: AppConfig;
-    private services: Partial<Services> = {};
-    private commands: Partial<Commands> = {};
+    
+    // Cache de instâncias criadas
+    private serviceCache: Partial<Services> = {};
+    private commandCache: Partial<Commands> = {};
+    
+    // Factories para lazy loading
+    private serviceFactories: Map<keyof Services, ServiceFactory<any>> = new Map();
+    private commandFactories: Map<keyof Commands, CommandFactory<any>> = new Map();
+    
     private isInitialized = false;
+    private initTime: number = 0;
 
     constructor(config: AppConfig) {
         this.config = config;
+        this.registerServiceFactories();
+        this.registerCommandFactories();
+    }
+
+    /**
+     * Registra todas as factories de serviços
+     */
+    private registerServiceFactories(): void {
+        // Serviços base (sem dependências)
+        this.serviceFactories.set("projectService", () => 
+            new ProjectService(this.config.project)
+        );
+        
+        this.serviceFactories.set("buildCacheService", () => 
+            new BuildCacheService()
+        );
+        
+        this.serviceFactories.set("historyService", () => 
+            new HistoryService()
+        );
+        
+        // Serviços com dependências
+        this.serviceFactories.set("dashboardService", () => {
+            const service = new DashboardService(this.config);
+            // Configura Logger com dashboard
+            Logger.setDashboard(service);
+            return service;
+        });
+        
+        this.serviceFactories.set("logAnalyzer", () => 
+            new LogAnalyzer(this.config.project)
+        );
+        
+        this.serviceFactories.set("tomcatService", () => {
+            const service = new TomcatService(this.config.tomcat);
+            // Lazy injeção de projectService
+            const projectService = this.getService("projectService");
+            service.setProjectService(projectService);
+            return service;
+        });
+        
+        this.serviceFactories.set("buildService", () => {
+            const projectService = this.getService("projectService");
+            const buildCacheService = this.getService("buildCacheService");
+            return new BuildService(
+                this.config.project,
+                this.config.tomcat,
+                projectService,
+                buildCacheService
+            );
+        });
+        
+        this.serviceFactories.set("auditService", () => 
+            new AuditService(this.config.tomcat)
+        );
     }
 
     /**
-     * Inicializa todos os serviços e comandos
+     * Registra todas as factories de comandos
+     */
+    private registerCommandFactories(): void {
+        this.commandFactories.set("deploy", (s) => 
+            new DeployCommand(s.tomcatService, s.buildService)
+        );
+        
+        this.commandFactories.set("dev", (s) => 
+            new DeployCommand(s.tomcatService, s.buildService)
+        );
+        
+        this.commandFactories.set("build", (s) => 
+            new BuildCommand(s.buildService)
+        );
+        
+        this.commandFactories.set("start", (s) => 
+            new StartCommand(s.tomcatService)
+        );
+        
+        this.commandFactories.set("logs", (s) => 
+            new LogsCommand(s.dashboardService, s.logAnalyzer)
+        );
+        
+        this.commandFactories.set("audit", (s) => 
+            new AuditCommand(s.auditService)
+        );
+        
+        this.commandFactories.set("profiles", (s) => 
+            new ProfilesCommand(s.projectService)
+        );
+        
+        this.commandFactories.set("run", (s) => 
+            new RunCommand(s.buildService)
+        );
+        
+        this.commandFactories.set("debug", (s) => 
+            new RunCommand(s.buildService)
+        );
+        
+        this.commandFactories.set("help", () => new HelpCommand());
+        this.commandFactories.set("doctor", () => new DoctorCommand());
+        this.commandFactories.set("deps", () => new DepsCommand());
+        this.commandFactories.set("tomcat", () => new TomcatCommand());
+        this.commandFactories.set("encoding", () => new EncodingCommand());
+        this.commandFactories.set("docs", () => new DocsCommand());
+        this.commandFactories.set("init", () => new InitCommand());
+        this.commandFactories.set("config", () => new ConfigCommand());
+        this.commandFactories.set("history", () => new HistoryCommand());
+        this.commandFactories.set("redo", () => new RedoCommand());
+        this.commandFactories.set("health", () => new HealthCommand());
+        this.commandFactories.set("completion", () => new CompletionCommand());
+        this.commandFactories.set("changelog", () => new ChangelogCommand());
+        this.commandFactories.set("test", () => new TestCommand());
+        this.commandFactories.set("db", () => new DbCommand());
+        this.commandFactories.set("http", () => new HttpCommand());
+        this.commandFactories.set("docker", () => new DockerCommand());
+        this.commandFactories.set("clean", () => new CleanCommand());
+        this.commandFactories.set("ide", () => new IdeCommand());
+    }
+
+    /**
+     * Inicialização rápida - só cria serviços essenciais
      */
     initialize(): void {
         if (this.isInitialized) {
@@ -99,148 +234,147 @@ export class DIContainer {
             return;
         }
 
-        this.initializeServices();
-        this.initializeCommands();
+        const startTime = performance.now();
+        
+        // Só inicializa serviços essenciais
+        this.initEssentialServices();
+        
+        this.initTime = performance.now() - startTime;
         this.isInitialized = true;
+        
+        Logger.debug(`DI Container inicializado em ${this.initTime.toFixed(2)}ms`);
     }
 
-    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);
-        const historyService = new HistoryService();
-
-        this.services = {
-            projectService,
-            buildCacheService,
-            buildService,
-            tomcatService,
-            auditService,
-            dashboardService,
-            logAnalyzer,
-            historyService,
-        };
-    }
-
-    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(),
-            init: new InitCommand(),
-            config: new ConfigCommand(),
-            history: new HistoryCommand(),
-            redo: new RedoCommand(),
-            health: new HealthCommand(),
-            completion: new CompletionCommand(),
-            changelog: new ChangelogCommand(),
-            test: new TestCommand(),
-            db: new DbCommand(),
-            http: new HttpCommand(),
-            docker: new DockerCommand(),
-        };
+    /**
+     * Inicializa apenas serviços essenciais
+     */
+    private initEssentialServices(): void {
+        // ProjectService é essencial (usado por muitos outros serviços)
+        this.getService("projectService");
     }
 
     /**
-     * Obtém um serviço pelo nome
+     * Obtém um serviço (lazy load com cache)
      */
     getService<K extends keyof Services>(name: K): Services[K] {
-        if (!this.isInitialized) {
-            this.initialize();
+        // Retorna do cache se já existe
+        if (this.serviceCache[name]) {
+            return this.serviceCache[name]!;
         }
-        const service = this.services[name];
-        if (!service) {
+
+        // Cria via factory
+        const factory = this.serviceFactories.get(name);
+        if (!factory) {
             throw new Error(`Serviço '${name}' não encontrado no container`);
         }
-        return service;
+
+        const instance = factory();
+        this.serviceCache[name] = instance;
+        return instance;
     }
 
     /**
-     * Obtém um comando pelo nome
+     * Obtém um comando (lazy load com cache)
      */
     getCommand<K extends keyof Commands>(name: K): Commands[K] {
-        if (!this.isInitialized) {
-            this.initialize();
+        // Retorna do cache se já existe
+        if (this.commandCache[name]) {
+            return this.commandCache[name]!;
         }
-        const command = this.commands[name];
-        if (!command) {
+
+        // Cria via factory
+        const factory = this.commandFactories.get(name);
+        if (!factory) {
             throw new Error(`Comando '${name}' não encontrado no container`);
         }
-        return command;
+
+        // Garante que serviços necessários estão disponíveis
+        const services = this.getAllServices();
+        const instance = factory(services);
+        this.commandCache[name] = instance;
+        return instance;
     }
 
     /**
-     * Obtém todos os serviços
+     * Obtém todos os serviços (cria todos)
      */
     getAllServices(): Services {
-        if (!this.isInitialized) {
-            this.initialize();
+        // Força criação de todos os serviços
+        const serviceNames = Array.from(this.serviceFactories.keys()) as Array<keyof Services>;
+        for (const name of serviceNames) {
+            this.getService(name);
         }
-        return this.services as Services;
+        return this.serviceCache as Services;
     }
 
     /**
-     * Obtém todos os comandos
+     * Obtém todos os comandos (cria todos)
      */
     getAllCommands(): Commands {
-        if (!this.isInitialized) {
-            this.initialize();
+        // Força criação de todos os comandos
+        const commandNames = Array.from(this.commandFactories.keys()) as Array<keyof Commands>;
+        for (const name of commandNames) {
+            this.getCommand(name);
         }
-        return this.commands as Commands;
+        return this.commandCache as Commands;
+    }
+
+    /**
+     * Verifica se um serviço está carregado
+     */
+    isServiceLoaded<K extends keyof Services>(name: K): boolean {
+        return name in this.serviceCache;
+    }
+
+    /**
+     * Lista serviços carregados
+     */
+    getLoadedServices(): Array<keyof Services> {
+        return Object.keys(this.serviceCache) as Array<keyof Services>;
     }
 
     /**
      * Registra um serviço customizado (útil para testes)
      */
     registerService<K extends keyof Services>(name: K, service: Services[K]): void {
-        this.services[name] = service;
+        this.serviceCache[name] = service;
     }
 
     /**
      * Registra um comando customizado (útil para testes)
      */
     registerCommand<K extends keyof Commands>(name: K, command: Commands[K]): void {
-        this.commands[name] = command;
+        this.commandCache[name] = command;
+    }
+
+    /**
+     * Limpa todos os caches (útil para testes)
+     */
+    reset(): void {
+        this.serviceCache = {};
+        this.commandCache = {};
+        this.isInitialized = false;
+    }
+
+    /**
+     * Obtém estatísticas do container
+     */
+    getStats(): { 
+        initialized: boolean; 
+        initTime: number; 
+        loadedServices: number; 
+        loadedCommands: number;
+        totalServices: number;
+        totalCommands: number;
+    } {
+        return {
+            initialized: this.isInitialized,
+            initTime: this.initTime,
+            loadedServices: Object.keys(this.serviceCache).length,
+            loadedCommands: Object.keys(this.commandCache).length,
+            totalServices: this.serviceFactories.size,
+            totalCommands: this.commandFactories.size,
+        };
     }
 }
 

package/src/errors/ErrorHandler.ts

@@ -13,7 +13,7 @@ import {
     TomcatError,
     ConfigError
 } from "./XavvaError";
-import { Logger } from "../utils/ui";
+import { Logger } from "../logging";
 import { ProcessManager } from "../utils/processManager";
 
 export interface ErrorReport {
@@ -30,6 +30,7 @@ export class ErrorHandler {
     private errorHistory: ErrorReport[] = [];
     private maxHistorySize = 10;
     private isShuttingDown = false;
+    private logger = Logger.getInstance();
 
     private constructor() {}
 
@@ -61,8 +62,8 @@ export class ErrorHandler {
 
         // Se não for erro operacional, mostra stack trace em verbose
         if (!report.isOperational) {
-            Logger.debug("Stack trace:");
-            Logger.debug(normalizedError.stack || "N/A");
+            this.logger.debug("Stack trace:");
+            this.logger.debug(normalizedError.stack || "N/A");
         }
 
         // Shutdown com código apropriado
@@ -82,7 +83,7 @@ export class ErrorHandler {
         if (normalizedError instanceof XavvaError) {
             this.logXavvaError(normalizedError, false);
         } else {
-            Logger.warn(`Erro inesperado: ${normalizedError.message}`);
+            this.logger.warn(`Erro inesperado: ${normalizedError.message}`);
         }
 
         return report;
@@ -142,42 +143,45 @@ export class ErrorHandler {
      * Loga erro Xavva com formatação adequada
      */
     private logXavvaError(error: XavvaError, isFatal: boolean): void {
-        const logMethod = isFatal ? Logger.error : Logger.warn;
+        const logMethod = isFatal ? this.logger.error.bind(this.logger) : this.logger.warn.bind(this.logger);
         
         // Cabeçalho do erro
-        logMethod.call(Logger, error.message);
+        logMethod(error.message);
         
         // Detalhes adicionais se houver
         if (error instanceof NetworkError) {
-            Logger.info("Dica", "Verifique sua conexão de internet e tente novamente");
+            this.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");
+            this.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");
+            this.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");
+            this.logger.info("Dica: Verifique se o Tomcat está configurado corretamente");
         } else if (error instanceof ConfigError) {
-            Logger.info("Dica", "Verifique seu arquivo xavva.json");
+            this.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})`);
+        this.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");
+        this.logger.error("Erro inesperado:");
+        this.logger.error(error.message);
+        this.logger.newline();
+        this.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"));
+            this.logger.newline();
+            this.logger.debug("Stack trace:");
+            const lines = error.stack.split("\n").slice(1, 5);
+            for (const line of lines) {
+                this.logger.debug(line.trim());
+            }
         }
     }