@archznn/xavva 3.0.0 → 3.1.1

package/README.md

@@ -2,7 +2,7 @@
 
 > Ultra-fast development toolkit for Java Enterprise (Tomcat) on Windows, Linux & macOS
 
-[![Version](https://img.shields.io/badge/version-2.9.0-blue.svg)](https://github.com/leorsousa05/Xavva)
+[![Version](https://img.shields.io/badge/version-3.1.1-blue.svg)](https://github.com/leorsousa05/Xavva)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 
 Xavva is a high-performance CLI built with **Bun** that transforms the Java/Tomcat development experience. It brings modern development workflows (like Node.js/Vite) to the Java Enterprise ecosystem with hot-reload, smart logging, and automated deployment.
@@ -26,6 +26,11 @@ Xavva is a high-performance CLI built with **Bun** that transforms the Java/Tomc
 - 📜 **Command History** — Track and replay commands with `xavva history` and `xavva redo`
 - 🏥 **Health Check** — Verify environment (Java, ports, memory, disk) with `xavva health`
 - 🔮 **Shell Completions** — Auto-complete for bash, zsh, and fish
+- 🧪 **Test Runner** — Run JUnit/TestNG tests with watch mode and coverage
+- 🗄️ **Database Migrations** — Flyway/Liquibase integration
+- 🌐 **HTTP Client** — Test APIs without leaving the terminal
+- 🐳 **Docker Integration** — Generate configs, build and run containers
+- 🌍 **Multi-Environment** — Dev, test, staging configurations
 
 ---
 
@@ -80,6 +85,29 @@ xavva history
 # Repeat last command
 xavva redo
 
+# Run tests
+xavva test
+xavva test --watch
+xavva test --coverage
+
+# Database migrations
+xavva db status
+xavva db migrate
+xavva db reset --force
+
+# HTTP API testing
+xavva http GET /api/users
+xavva http POST /api/users --body '{"name":"John"}'
+
+# Docker integration
+xavva docker init
+xavva docker build
+xavva docker up
+
+# Multi-environment
+xavva deploy --env staging
+xavva dev --env dev
+
 # Enable shell completions (bash example)
 eval "$(xavva completion bash)"
 ```
@@ -130,6 +158,56 @@ eval "$(xavva completion bash)"
 | `xavva redo`            | Repeat the last executed command               |
 | `xavva completion <shell>` | Generate shell completions (bash/zsh/fish)  |
 
+### Testing & Database
+
+| Command | Description |
+|---------|-------------|
+| `xavva test` | Run all tests (JUnit/TestNG) |
+| `xavva test --watch` | Run tests in watch mode |
+| `xavva test --coverage` | Generate coverage report |
+| `xavva test <filter>` | Run specific test class |
+| `xavva db status` | Show migration status |
+| `xavva db migrate` | Run pending migrations |
+| `xavva db reset --force` | Reset database (⚠️ destructive) |
+| `xavva db seed` | Populate with test data |
+
+### HTTP Client
+
+| Command | Description |
+|---------|-------------|
+| `xavva http GET <path>` | Send GET request |
+| `xavva http POST <path> --body '{}'` | Send POST request |
+| `xavva http <path> --param key=value` | Add query parameters |
+| `xavva http <path> --header "Auth: token"` | Add custom headers |
+
+### Docker
+
+| Command | Description |
+|---------|-------------|
+| `xavva docker init` | Generate Dockerfile & docker-compose.yml |
+| `xavva docker build` | Build Docker image |
+| `xavva docker up` | Start with docker-compose |
+| `xavva docker down` | Stop containers |
+| `xavva docker run` | Run development container |
+| `xavva docker status` | Show container status |
+
+### Multi-Environment
+
+| Command | Description |
+|---------|-------------|
+| `xavva deploy --env <name>` | Deploy to specific environment |
+| `xavva dev --env <name>` | Use environment configuration |
+
+Configure environments in `xavva.json`:
+```json
+{
+  "environments": {
+    "dev": { "port": 8080, "profile": "dev" },
+    "staging": { "port": 8081, "profile": "staging" }
+  }
+}
+```
+
 ---
 
 ## 🐱 Embedded Tomcat

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@archznn/xavva",
-	"version": "3.0.0",
+	"version": "3.1.1",
 	"description": "Ultra-fast CLI tool for Java/Tomcat development with Hot-Reload and Zero Config. Supports Windows, Linux and macOS.",
 	"module": "src/index.ts",
 	"type": "module",

package/src/commands/ConfigCommand.ts

@@ -141,6 +141,54 @@ export class ConfigCommand implements Command {
                 default: String(config.tomcatPath || "")
             });
         }
+
+        // Edit environments
+        const editEnvs = await confirm({
+            message: "Editar environments?",
+            default: false
+        });
+
+        if (editEnvs) {
+            await this.editEnvironments(config);
+        }
+    }
+
+    private async editEnvironments(config: Record<string, unknown>): Promise<void> {
+        const environments = (config.environments as Record<string, unknown>) || {};
+        
+        const envNames = Object.keys(environments);
+        if (envNames.length > 0) {
+            Logger.info("Environments existentes:", envNames.join(", "));
+        }
+
+        const addNew = await confirm({
+            message: "Adicionar novo environment?",
+            default: envNames.length === 0
+        });
+
+        if (addNew) {
+            const name = await input({
+                message: "Nome do environment:",
+                default: "staging"
+            });
+
+            const port = await number({
+                message: `Porta para ${name}:`,
+                default: 8080
+            });
+
+            const profile = await input({
+                message: `Profile para ${name}:`,
+                default: name
+            });
+
+            environments[name] = {
+                port,
+                profile
+            };
+        }
+
+        config.environments = environments;
     }
 
     private async editBuild(config: Record<string, unknown>): Promise<void> {

package/src/commands/DbCommand.ts

@@ -0,0 +1,126 @@
+/**
+ * Comando de migrações de banco de dados
+ * xavva db <action> [options]
+ */
+
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { DbService, type DbConfig } from "../services/DbService";
+import { Logger } from "../utils/ui";
+import { ProcessManager } from "../utils/processManager";
+
+export class DbCommand implements Command {
+    async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
+        const processManager = ProcessManager.getInstance();
+        const action = positionals?.[1] || "status";
+        
+        const service = new DbService(config.project.buildTool);
+
+        // Extrair config de DB do environment ou args
+        const dbConfig = this.extractDbConfig(config, args);
+
+        try {
+            switch (action) {
+                case "migrate":
+                case "up":
+                    const migrateResult = await service.migrate(dbConfig);
+                    if (!migrateResult.success) {
+                        Logger.error(migrateResult.message);
+                        await processManager.shutdown(1);
+                    }
+                    break;
+
+                case "status":
+                case "info":
+                    await service.status(dbConfig);
+                    break;
+
+                case "reset":
+                case "clean":
+                case "drop":
+                    if (!args?.force) {
+                        Logger.warn("This will DELETE all data in the database!");
+                        Logger.info("Use", "--force to confirm");
+                        await processManager.shutdown(1);
+                        return;
+                    }
+                    const resetResult = await service.reset(dbConfig);
+                    if (!resetResult.success) {
+                        await processManager.shutdown(1);
+                    }
+                    // Roda migrações novamente após reset
+                    await service.migrate(dbConfig);
+                    break;
+
+                case "seed":
+                    const seedResult = await service.seed(dbConfig, args?.src);
+                    if (!seedResult.success) {
+                        Logger.error(seedResult.message);
+                        await processManager.shutdown(1);
+                    }
+                    break;
+
+                case "create":
+                    await this.createMigration(service, args);
+                    break;
+
+                default:
+                    Logger.error(`Unknown db action: ${action}`);
+                    Logger.info("Actions", "migrate, status, reset, seed, create");
+                    await processManager.shutdown(1);
+            }
+        } catch (error) {
+            Logger.error(`Database command failed: ${(error as Error).message}`);
+            await processManager.shutdown(1);
+        }
+    }
+
+    private extractDbConfig(config: AppConfig, args?: CLIArguments): DbConfig | undefined {
+        // Tenta pegar do environment config
+        const envName = config.project.environment;
+        const envConfig = envName && config.project.environments?.[envName];
+        
+        if (envConfig?.db) {
+            return {
+                url: envConfig.db.url || process.env.JDBC_URL || "",
+                username: envConfig.db.username || process.env.JDBC_USER || "",
+                password: envConfig.db.password || process.env.JDBC_PASSWORD || "",
+                driver: envConfig.db.driver
+            };
+        }
+
+        // Fallback para env vars
+        if (process.env.JDBC_URL) {
+            return {
+                url: process.env.JDBC_URL,
+                username: process.env.JDBC_USER || "",
+                password: process.env.JDBC_PASSWORD || ""
+            };
+        }
+
+        return undefined;
+    }
+
+    private async createMigration(service: DbService, args?: CLIArguments): Promise<void> {
+        const name = args?.name || "new_migration";
+        Logger.section("Create Migration");
+        Logger.info("Name", name);
+        
+        // Detecta ferramenta
+        const tool = await service.detectTool();
+        
+        if (tool === "flyway") {
+            const timestamp = new Date().toISOString().replace(/[-:T]/g, "").slice(0, 14);
+            const filename = `V${timestamp}__${name}.sql`;
+            const filepath = `src/main/resources/db/migration/${filename}`;
+            
+            Logger.success(`Create file: ${filepath}`);
+            Logger.dim("-- Add your SQL here");
+        } else if (tool === "liquibase") {
+            const filename = `${name}.sql`;
+            Logger.success(`Add to changelog: db/changelog/${filename}`);
+        } else {
+            Logger.warn("No migration tool detected");
+        }
+    }
+}

package/src/commands/DockerCommand.ts

@@ -0,0 +1,133 @@
+/**
+ * Comando de integração Docker
+ * xavva docker <action> [options]
+ */
+
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { DockerService, type DockerConfig } from "../services/DockerService";
+import { Logger } from "../utils/ui";
+import { ProcessManager } from "../utils/processManager";
+
+export class DockerCommand implements Command {
+    async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
+        const processManager = ProcessManager.getInstance();
+        const action = positionals?.[1] || "status";
+
+        const service = new DockerService();
+
+        // Verifica se Docker está disponível
+        const isAvailable = await service.isDockerAvailable();
+        if (!isAvailable) {
+            Logger.error("Docker CLI not found");
+            Logger.info("Install", "https://docs.docker.com/get-docker/");
+            await processManager.shutdown(1);
+            return;
+        }
+
+        // Verifica se o daemon está rodando
+        const isRunning = await service.isDaemonRunning();
+        if (!isRunning) {
+            Logger.error("Docker daemon is not running");
+            Logger.info("Windows", "Start Docker Desktop from the system tray");
+            Logger.info("Linux", "Run: sudo systemctl start docker");
+            Logger.info("macOS", "Start Docker Desktop from Applications");
+            await processManager.shutdown(1);
+            return;
+        }
+
+        const dockerConfig: DockerConfig = {
+            imageName: (args?.name as string) || config.project.appName,
+            tag: (args?.tag as string) || "latest",
+            port: args?.port ? parseInt(args.port as string) : config.tomcat.port,
+            javaVersion: (args?.["java-version"] as string) || "17",
+            tomcatVersion: config.tomcat.version
+        };
+
+        try {
+            switch (action) {
+                case "init":
+                    await this.handleInit(service, dockerConfig);
+                    break;
+
+                case "build":
+                    const built = await service.buildImage(dockerConfig.tag);
+                    if (!built) {
+                        await processManager.shutdown(1);
+                    }
+                    break;
+
+                case "run":
+                case "dev":
+                    const running = await service.runDevMode(dockerConfig.port);
+                    if (!running) {
+                        await processManager.shutdown(1);
+                    }
+                    break;
+
+                case "up":
+                    const up = await service.composeUp(args?.detached);
+                    if (!up) {
+                        await processManager.shutdown(1);
+                    }
+                    break;
+
+                case "down":
+                case "stop":
+                    const down = await service.composeDown();
+                    if (!down) {
+                        await processManager.shutdown(1);
+                    }
+                    break;
+
+                case "status":
+                case "ps":
+                    await service.showContainerStatus();
+                    break;
+
+                case "push":
+                    await this.handlePush(service, dockerConfig, args);
+                    break;
+
+                default:
+                    Logger.error(`Unknown docker action: ${action}`);
+                    Logger.info("Actions", "init, build, run, up, down, status, push");
+                    await processManager.shutdown(1);
+            }
+        } catch (error) {
+            Logger.error(`Docker command failed: ${(error as Error).message}`);
+            await processManager.shutdown(1);
+        }
+    }
+
+    private async handleInit(service: DockerService, config: DockerConfig): Promise<void> {
+        Logger.section("Docker Init");
+        Logger.info("Generating", "Docker configuration files");
+
+        await service.generateDockerfile(config);
+        await service.generateCompose(config);
+
+        Logger.divider();
+        Logger.info("Next steps", "");
+        Logger.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva docker build${Logger.C.reset}  ${Logger.C.gray}- Build image${Logger.C.reset}`);
+        Logger.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva docker up${Logger.C.reset}      ${Logger.C.gray}- Start containers${Logger.C.reset}`);
+        Logger.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva docker run${Logger.C.reset}     ${Logger.C.gray}- Run dev mode${Logger.C.reset}`);
+        Logger.endSection();
+    }
+
+    private async handlePush(service: DockerService, config: DockerConfig, args?: CLIArguments): Promise<void> {
+        const registry = args?.registry as string || "docker.io";
+        const namespace = args?.namespace as string || "";
+        
+        const fullImageName = namespace 
+            ? `${registry}/${namespace}/${config.imageName}:${config.tag}`
+            : `${registry}/${config.imageName}:${config.tag}`;
+
+        Logger.section("Docker Push");
+        Logger.info("Image", fullImageName);
+        Logger.info("Registry", registry);
+
+        Logger.success("Use: docker push " + fullImageName);
+        Logger.dim("Make sure you're logged in: docker login " + registry);
+    }
+}

package/src/commands/HelpCommand.ts

@@ -40,6 +40,11 @@ export class HelpCommand implements Command {
     ${this.c("cyan", "completion")}        Generate shell completions (bash/zsh/fish)
     ${this.c("cyan", "changelog")}         Generate changelog from conventional commits
 
+    ${this.c("magenta", "test")}             Run tests (JUnit/TestNG)
+    ${this.c("magenta", "db")}               Database migrations (Flyway/Liquibase)
+    ${this.c("magenta", "http")}             HTTP client for API testing
+    ${this.c("magenta", "docker")}           Docker integration (build, run, compose)
+
   ${this.c("yellow", "GENERAL OPTIONS")}
     ${this.c("cyan", "-p, --path")} <path>     Tomcat installation path
     ${this.c("cyan", "-t, --tool")} <tool>     Build tool: maven | gradle
@@ -151,6 +156,33 @@ export class HelpCommand implements Command {
     xavva deploy --debug-level trace    # Trace all operations
     xavva deploy --debug-level silly    # Everything including config
 
+    ${this.c("dim", "# Multi-environment")}
+    xavva deploy --env staging          # Deploy to staging environment
+    xavva dev --env dev                 # Use dev environment config
+
+    ${this.c("dim", "# Test runner")}
+    xavva test                          # Run all tests
+    xavva test --watch                  # Watch mode
+    xavva test --coverage               # Generate coverage report
+    xavva test UserServiceTest          # Run specific test class
+
+    ${this.c("dim", "# Database migrations")}
+    xavva db status                     # Show migration status
+    xavva db migrate                    # Run pending migrations
+    xavva db reset --force              # Reset database (drops all!)
+    xavva db seed                       # Populate with test data
+
+    ${this.c("dim", "# HTTP Client")}
+    xavva http GET /api/users           # Test endpoint
+    xavva http POST /api/users --body '{"name":"John"}'
+    xavva http GET /api/users --param page=1 --param size=10
+
+    ${this.c("dim", "# Docker")}
+    xavva docker init                   # Generate Dockerfile & compose
+    xavva docker build                  # Build image
+    xavva docker up                     # Start with docker-compose
+    xavva docker run                    # Run dev container
+
   ${this.c("yellow", "CONFIGURATION")}
     Settings are loaded from ${this.c("cyan", "xavva.json")} in the project root:
     

package/src/commands/HttpCommand.ts

@@ -0,0 +1,134 @@
+/**
+ * Comando de HTTP Client
+ * xavva http <method> <url> [options]
+ * xavva http --interactive
+ */
+
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { HttpService, type HttpRequest } from "../services/HttpService";
+import { EndpointService } from "../services/EndpointService";
+import { Logger } from "../utils/ui";
+import { ProcessManager } from "../utils/processManager";
+import fs from "fs";
+import path from "path";
+
+export class HttpCommand implements Command {
+    async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
+        const processManager = ProcessManager.getInstance();
+        
+        // Modo interativo
+        if (args?.interactive || positionals?.length === 1) {
+            const baseUrl = `http://localhost:${config.tomcat.port}`;
+            const service = new HttpService(baseUrl);
+            await service.interactive();
+            return;
+        }
+
+        // Extrai método e URL
+        const method = (positionals?.[1] || "GET").toUpperCase() as HttpRequest["method"];
+        let url = positionals?.[2] || "/";
+
+        // Se URL não começar com http, adiciona base
+        const baseUrl = args?.["base-url"] || `http://localhost:${config.tomcat.port}`;
+        if (!url.startsWith("http")) {
+            url = `${baseUrl}${url.startsWith("/") ? url : `/${url}`}`;
+        }
+
+        // Parse headers
+        const headers = this.parseHeaders(args);
+
+        // Parse body
+        let body: string | object | undefined;
+        if (args?.body) {
+            body = this.parseBody(args.body as string);
+        } else if (args?.file) {
+            const filePath = args.file as string;
+            if (fs.existsSync(filePath)) {
+                body = fs.readFileSync(filePath, "utf-8");
+            } else {
+                Logger.error(`File not found: ${filePath}`);
+                await processManager.shutdown(1);
+                return;
+            }
+        }
+
+        // Parse query params
+        const params = this.parseParams(args);
+
+        // Cria request
+        const request: HttpRequest = {
+            method,
+            url,
+            headers,
+            body,
+            params,
+            timeout: args?.timeout ? parseInt(args.timeout as string) : 30000
+        };
+
+        // Executa
+        const service = new HttpService();
+        
+        try {
+            await service.request(request);
+        } catch (error) {
+            await processManager.shutdown(1);
+        }
+    }
+
+    private parseHeaders(args?: CLIArguments): Record<string, string> | undefined {
+        const headers: Record<string, string> = {};
+        
+        // Formato: --header "Authorization: Bearer token"
+        const headerArgs = args?.header;
+        if (headerArgs) {
+            const headerList = Array.isArray(headerArgs) ? headerArgs : [headerArgs];
+            for (const h of headerList) {
+                const match = h.match(/^([^:]+):\s*(.+)$/);
+                if (match) {
+                    headers[match[1]] = match[2];
+                }
+            }
+        }
+
+        // Content-Type shorthand
+        if (args?.["content-type"]) {
+            headers["Content-Type"] = args["content-type"] as string;
+        }
+
+        // Accept shorthand
+        if (args?.accept) {
+            headers["Accept"] = args.accept as string;
+        }
+
+        return Object.keys(headers).length > 0 ? headers : undefined;
+    }
+
+    private parseBody(bodyStr: string): string | object {
+        // Tenta parsear como JSON
+        try {
+            return JSON.parse(bodyStr);
+        } catch {
+            // Retorna como string
+            return bodyStr;
+        }
+    }
+
+    private parseParams(args?: CLIArguments): Record<string, string> | undefined {
+        const params: Record<string, string> = {};
+        
+        // Formato: --param "key=value"
+        const paramArgs = args?.param;
+        if (paramArgs) {
+            const paramList = Array.isArray(paramArgs) ? paramArgs : [paramArgs];
+            for (const p of paramList) {
+                const [key, value] = p.split("=");
+                if (key && value !== undefined) {
+                    params[key] = value;
+                }
+            }
+        }
+
+        return Object.keys(params).length > 0 ? params : undefined;
+    }
+}