@archznn/xavva 3.0.0 → 3.1.1

package/src/commands/InitCommand.ts

@@ -104,6 +104,12 @@ export class InitCommand implements Command {
             default: "UTF-8"
         });
 
+        // Multi-environment setup
+        const enableMultiEnv = await confirm({
+            message: "Configure multiple environments?",
+            default: false
+        });
+
         // Build config object
         const config: Record<string, unknown> = {
             appName,
@@ -142,6 +148,70 @@ export class InitCommand implements Command {
             config.tomcatPath = tomcatPath;
         }
 
+        // Add environments if enabled
+        if (enableMultiEnv) {
+            Logger.newline();
+            Logger.dim("Environment Configuration:");
+            
+            const environments: Record<string, unknown> = {};
+            
+            // Dev environment
+            const devPort = await number({
+                message: "Dev environment port:",
+                default: port
+            }) || port;
+            environments.dev = {
+                port: devPort,
+                profile: "dev"
+            };
+            
+            // Test environment
+            const testPort = await number({
+                message: "Test environment port:",
+                default: port + 1
+            }) || port + 1;
+            environments.test = {
+                port: testPort,
+                profile: "test"
+            };
+            
+            // Staging environment
+            const hasStaging = await confirm({
+                message: "Add staging environment?",
+                default: true
+            });
+            
+            if (hasStaging) {
+                const stagingPort = await number({
+                    message: "Staging environment port:",
+                    default: port + 2
+                }) || port + 2;
+                environments.staging = {
+                    port: stagingPort,
+                    profile: "staging"
+                };
+            }
+            
+            config.environments = environments;
+            
+            // Add DB config example
+            const addDbExample = await confirm({
+                message: "Add database configuration example?",
+                default: true
+            });
+            
+            if (addDbExample) {
+                environments.dev = {
+                    ...environments.dev,
+                    db: {
+                        url: "jdbc:h2:mem:devdb",
+                        username: "sa",
+                        password: ""
+                    }
+                };
+            }
+        }
+
         // Save file
         Logger.newline();
         Logger.step("Saving configuration...");

package/src/commands/TestCommand.ts

@@ -0,0 +1,63 @@
+/**
+ * Comando de execução de testes
+ * xavva test [options] [filter]
+ */
+
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { TestService } from "../services/TestService";
+import { Logger } from "../utils/ui";
+import { ProcessManager } from "../utils/processManager";
+
+export class TestCommand implements Command {
+    private service: TestService | null = null;
+
+    async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
+        const processManager = ProcessManager.getInstance();
+        
+        // Extrai filtros de teste dos positionals (após o comando "test")
+        const filter = positionals?.slice(1).join(" ") || undefined;
+        
+        // Opções
+        const watch = args?.watch || false;
+        const coverage = args?.coverage || false;
+        const verbose = args?.verbose || false;
+        const failFast = args?.["fail-fast"] || false;
+        const parallel = args?.parallel || false;
+
+        this.service = new TestService(config.project.buildTool);
+
+        try {
+            if (watch) {
+                this.service.startWatch({
+                    coverage,
+                    filter,
+                    verbose,
+                    failFast,
+                    parallel
+                });
+
+                // Mantém processo rodando
+                process.on("SIGINT", () => {
+                    this.service?.stopWatch();
+                    processManager.shutdown(0);
+                });
+            } else {
+                const result = await this.service.runTests({
+                    coverage,
+                    filter,
+                    verbose,
+                    failFast,
+                    parallel
+                });
+
+                if (!result.success) {
+                    await processManager.shutdown(1);
+                }
+            }
+        } catch (error) {
+            Logger.error(`Test execution failed: ${(error as Error).message}`);
+            await processManager.shutdown(1);
+        }
+    }
+}

package/src/di/container.ts

@@ -32,6 +32,10 @@ import { HealthCommand } from "../commands/HealthCommand";
 import { CompletionCommand } from "../commands/CompletionCommand";
 import { ChangelogCommand } from "../commands/ChangelogCommand";
 import { HistoryService } from "../services/HistoryService";
+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 type { Command } from "../commands/Command";
 import { Logger } from "../utils/ui";
@@ -70,6 +74,10 @@ export interface Commands {
     health: HealthCommand;
     completion: CompletionCommand;
     changelog: ChangelogCommand;
+    test: TestCommand;
+    db: DbCommand;
+    http: HttpCommand;
+    docker: DockerCommand;
 }
 
 export class DIContainer {
@@ -166,6 +174,10 @@ export class DIContainer {
             health: new HealthCommand(),
             completion: new CompletionCommand(),
             changelog: new ChangelogCommand(),
+            test: new TestCommand(),
+            db: new DbCommand(),
+            http: new HttpCommand(),
+            docker: new DockerCommand(),
         };
     }
 

package/src/index.ts

@@ -31,7 +31,8 @@ async function main() {
         "deploy", "build", "start", "dev", "doctor", "run", 
         "debug", "logs", "docs", "audit", "profiles", 
         "deps", "tomcat", "encoding", "init", "config", 
-        "history", "redo", "health", "completion", "changelog", "help"
+        "history", "redo", "health", "completion", "changelog",
+        "test", "db", "http", "docker", "help"
     ];
     const commandName = positionals.find(p => commandNames.includes(p)) || "deploy";
 
@@ -111,6 +112,10 @@ async function main() {
         registry.register("health", commands.health);
         registry.register("completion", commands.completion);
         registry.register("changelog", commands.changelog);
+        registry.register("test", commands.test);
+        registry.register("db", commands.db);
+        registry.register("http", commands.http);
+        registry.register("docker", commands.docker);
 
         // Configura flags específicas
         if (commandName === "debug") values.debug = true;

package/src/services/DbService.ts

@@ -0,0 +1,357 @@
+/**
+ * Serviço de migrações de banco de dados
+ * Suporta Flyway e Liquibase
+ */
+
+import { Logger } from "../utils/ui";
+import { spawn } from "child_process";
+import fs from "fs";
+import path from "path";
+
+export type MigrationTool = "flyway" | "liquibase" | "auto";
+
+export interface DbConfig {
+    url: string;
+    username: string;
+    password: string;
+    driver?: string;
+    migrationsPath?: string;
+}
+
+export interface MigrationStatus {
+    version: string;
+    description: string;
+    state: "pending" | "applied" | "failed";
+    installedOn?: Date;
+    executionTime?: number;
+}
+
+export interface MigrationResult {
+    success: boolean;
+    message: string;
+    migrationsApplied: number;
+    errors: string[];
+}
+
+export class DbService {
+    private buildTool: "maven" | "gradle";
+    private projectPath: string;
+
+    constructor(buildTool: "maven" | "gradle", projectPath: string = process.cwd()) {
+        this.buildTool = buildTool;
+        this.projectPath = projectPath;
+    }
+
+    /**
+     * Detecta qual ferramenta de migração está configurada no projeto
+     */
+    async detectTool(): Promise<MigrationTool> {
+        const pomPath = path.join(this.projectPath, "pom.xml");
+        const buildGradlePath = path.join(this.projectPath, "build.gradle");
+        const buildGradleKtsPath = path.join(this.projectPath, "build.gradle.kts");
+
+        let content = "";
+        if (fs.existsSync(pomPath)) {
+            content = fs.readFileSync(pomPath, "utf-8");
+        } else if (fs.existsSync(buildGradlePath)) {
+            content = fs.readFileSync(buildGradlePath, "utf-8");
+        } else if (fs.existsSync(buildGradleKtsPath)) {
+            content = fs.readFileSync(buildGradleKtsPath, "utf-8");
+        }
+
+        if (content.includes("flyway") || content.includes("flyway-core")) {
+            return "flyway";
+        }
+        if (content.includes("liquibase") || content.includes("liquibase-core")) {
+            return "liquibase";
+        }
+
+        // Verificar arquivos de configuração
+        if (fs.existsSync(path.join(this.projectPath, "src", "main", "resources", "db", "migration"))) {
+            return "flyway";
+        }
+        if (fs.existsSync(path.join(this.projectPath, "src", "main", "resources", "db", "changelog"))) {
+            return "liquibase";
+        }
+
+        return "auto";
+    }
+
+    /**
+     * Executa migrações pendentes
+     */
+    async migrate(config?: DbConfig): Promise<MigrationResult> {
+        const tool = await this.detectTool();
+        Logger.section("Database Migration");
+        Logger.info("Tool", tool === "auto" ? "auto-detect" : tool);
+
+        if (tool === "auto") {
+            return {
+                success: false,
+                message: "No migration tool detected. Please add Flyway or Liquibase to your project.",
+                migrationsApplied: 0,
+                errors: ["No migration tool found"]
+            };
+        }
+
+        const result = tool === "flyway" 
+            ? await this.runFlywayMigrate(config)
+            : await this.runLiquibaseUpdate(config);
+
+        Logger.endSection();
+        return result;
+    }
+
+    /**
+     * Mostra status das migrações
+     */
+    async status(config?: DbConfig): Promise<MigrationStatus[]> {
+        const tool = await this.detectTool();
+        Logger.section("Migration Status");
+        Logger.info("Tool", tool);
+
+        if (tool === "auto") {
+            Logger.warn("No migration tool detected");
+            Logger.endSection();
+            return [];
+        }
+
+        const statuses = tool === "flyway"
+            ? await this.runFlywayInfo(config)
+            : await this.runLiquibaseStatus(config);
+
+        // Print status table
+        if (statuses.length > 0) {
+            Logger.divider();
+            for (const status of statuses) {
+                const stateColor = status.state === "applied" ? Logger.C.success 
+                    : status.state === "failed" ? Logger.C.error 
+                    : Logger.C.warning;
+                Logger.info(status.version, `${stateColor}${status.state}${Logger.C.reset} - ${status.description}`);
+            }
+        } else {
+            Logger.info("Status", "No migrations found");
+        }
+
+        Logger.endSection();
+        return statuses;
+    }
+
+    /**
+     * Reseta o banco (drop all + migrate)
+     */
+    async reset(config?: DbConfig): Promise<MigrationResult> {
+        Logger.section("Database Reset");
+        Logger.warn("This will DROP ALL DATA in the database!");
+
+        const tool = await this.detectTool();
+        
+        if (tool === "flyway") {
+            return await this.runFlywayClean(config);
+        } else if (tool === "liquibase") {
+            return await this.runLiquibaseDropAll(config);
+        }
+
+        Logger.endSection();
+        return {
+            success: false,
+            message: "No migration tool detected",
+            migrationsApplied: 0,
+            errors: []
+        };
+    }
+
+    /**
+     * Popula dados de teste/seed
+     */
+    async seed(config?: DbConfig, seedFile?: string): Promise<MigrationResult> {
+        Logger.section("Database Seed");
+
+        // Procurar arquivos de seed
+        const seedPaths = [
+            path.join(this.projectPath, "src", "test", "resources", "seed.sql"),
+            path.join(this.projectPath, "src", "main", "resources", "seed.sql"),
+            path.join(this.projectPath, "seed.sql"),
+        ];
+
+        const seedPath = seedFile || seedPaths.find(p => fs.existsSync(p));
+
+        if (!seedPath) {
+            return {
+                success: false,
+                message: "No seed file found. Create seed.sql in src/test/resources/ or project root.",
+                migrationsApplied: 0,
+                errors: ["Seed file not found"]
+            };
+        }
+
+        Logger.info("Seed file", seedPath);
+
+        // Executar seed via JDBC ou comando SQL
+        const result = await this.executeSeed(seedPath, config);
+        
+        Logger.endSection();
+        return result;
+    }
+
+    // ===== Flyway Commands =====
+
+    private async runFlywayMigrate(config?: DbConfig): Promise<MigrationResult> {
+        return this.runMavenOrGradle("flyway:migrate", "flywayMigrate", config);
+    }
+
+    private async runFlywayInfo(config?: DbConfig): Promise<MigrationStatus[]> {
+        const output = await this.runMavenOrGradleOutput("flyway:info", "flywayInfo", config);
+        return this.parseFlywayInfo(output);
+    }
+
+    private async runFlywayClean(config?: DbConfig): Promise<MigrationResult> {
+        return this.runMavenOrGradle("flyway:clean", "flywayClean", config);
+    }
+
+    // ===== Liquibase Commands =====
+
+    private async runLiquibaseUpdate(config?: DbConfig): Promise<MigrationResult> {
+        return this.runMavenOrGradle("liquibase:update", "liquibaseUpdate", config);
+    }
+
+    private async runLiquibaseStatus(config?: DbConfig): Promise<MigrationStatus[]> {
+        const output = await this.runMavenOrGradleOutput("liquibase:status", "liquibaseStatus", config);
+        return this.parseLiquibaseStatus(output);
+    }
+
+    private async runLiquibaseDropAll(config?: DbConfig): Promise<MigrationResult> {
+        return this.runMavenOrGradle("liquibase:dropAll", "liquibaseDropAll", config);
+    }
+
+    // ===== Generic Execution =====
+
+    private async runMavenOrGradle(
+        mavenGoal: string, 
+        gradleTask: string, 
+        config?: DbConfig
+    ): Promise<MigrationResult> {
+        return new Promise((resolve) => {
+            const [cmd, ...args] = this.buildTool === "maven"
+                ? [process.platform === "win32" ? "mvn.cmd" : "mvn", mavenGoal, "-q"]
+                : [process.platform === "win32" ? "gradle.bat" : "gradle", gradleTask, "-q"];
+
+            const env = config ? this.buildEnv(config) : process.env;
+            const spinner = Logger.spinner("Running migrations");
+
+            const child = spawn(cmd, args, {
+                cwd: this.projectPath,
+                env: { ...process.env, ...env },
+                shell: process.platform === "win32"
+            });
+
+            let stdout = "";
+            let stderr = "";
+
+            child.stdout?.on("data", (data) => stdout += data.toString());
+            child.stderr?.on("data", (data) => stderr += data.toString());
+
+            child.on("close", (code) => {
+                spinner(code === 0);
+                
+                if (code === 0) {
+                    Logger.success("Migrations completed successfully");
+                } else {
+                    Logger.error("Migration failed");
+                    if (stderr) Logger.dim(stderr.slice(0, 500));
+                }
+
+                resolve({
+                    success: code === 0,
+                    message: code === 0 ? "Success" : stderr || "Failed",
+                    migrationsApplied: this.countMigrations(stdout),
+                    errors: code !== 0 ? [stderr] : []
+                });
+            });
+        });
+    }
+
+    private async runMavenOrGradleOutput(
+        mavenGoal: string, 
+        gradleTask: string, 
+        config?: DbConfig
+    ): Promise<string> {
+        return new Promise((resolve) => {
+            const [cmd, ...args] = this.buildTool === "maven"
+                ? [process.platform === "win32" ? "mvn.cmd" : "mvn", mavenGoal]
+                : [process.platform === "win32" ? "gradle.bat" : "gradle", gradleTask];
+
+            const env = config ? this.buildEnv(config) : process.env;
+            let output = "";
+
+            const child = spawn(cmd, args, {
+                cwd: this.projectPath,
+                env: { ...process.env, ...env },
+                shell: process.platform === "win32"
+            });
+
+            child.stdout?.on("data", (data) => output += data.toString());
+            child.stderr?.on("data", (data) => output += data.toString());
+
+            child.on("close", () => resolve(output));
+        });
+    }
+
+    private async executeSeed(seedPath: string, config?: DbConfig): Promise<MigrationResult> {
+        // Implementação básica - executa via JDBC se possível
+        // Ou gera comando SQL para execução manual
+        
+        const sql = fs.readFileSync(seedPath, "utf-8");
+        const statements = sql.split(";").filter(s => s.trim());
+
+        Logger.info("Statements", statements.length);
+        Logger.success("Seed file ready for execution");
+        Logger.dim("Use your database client to execute the seed file");
+
+        return {
+            success: true,
+            message: `Seed file prepared: ${seedPath}`,
+            migrationsApplied: 0,
+            errors: []
+        };
+    }
+
+    private buildEnv(config: DbConfig): Record<string, string> {
+        return {
+            JDBC_URL: config.url,
+            JDBC_USER: config.username,
+            JDBC_PASSWORD: config.password,
+            ...(config.driver && { JDBC_DRIVER: config.driver })
+        };
+    }
+
+    private countMigrations(output: string): number {
+        const match = output.match(/Successfully applied (\d+) migration/);
+        return match ? parseInt(match[1]) : 0;
+    }
+
+    private parseFlywayInfo(output: string): MigrationStatus[] {
+        const statuses: MigrationStatus[] = [];
+        const lines = output.split("\n");
+        
+        for (const line of lines) {
+            // Parse Flyway info table
+            const match = line.match(/\|\s*(\S+)\s*\|\s*(\S+)\s*\|\s*(\S+)\s*\|\s*(.+?)\s*\|/);
+            if (match && !line.includes("Version")) {
+                statuses.push({
+                    version: match[1],
+                    description: match[4].trim(),
+                    state: match[3].toLowerCase() as MigrationStatus["state"]
+                });
+            }
+        }
+
+        return statuses;
+    }
+
+    private parseLiquibaseStatus(output: string): MigrationStatus[] {
+        const statuses: MigrationStatus[] = [];
+        // Simplified parsing - Liquibase output varies
+        return statuses;
+    }
+}