@archznn/xavva 3.0.0 → 3.1.0

package/src/services/DockerService.ts

@@ -0,0 +1,361 @@
+/**
+ * Serviço de integração com Docker
+ * Gera configs e gerencia containers
+ */
+
+import { Logger } from "../utils/ui";
+import { spawn } from "child_process";
+import fs from "fs";
+import path from "path";
+
+export interface DockerConfig {
+    imageName: string;
+    tag?: string;
+    port?: number;
+    javaVersion?: string;
+    tomcatVersion?: string;
+}
+
+export interface ContainerInfo {
+    id: string;
+    name: string;
+    image: string;
+    status: string;
+    ports: string;
+    created: string;
+}
+
+export class DockerService {
+    private projectPath: string;
+    private projectName: string;
+
+    constructor(projectPath: string = process.cwd()) {
+        this.projectPath = projectPath;
+        this.projectName = path.basename(projectPath).toLowerCase().replace(/[^a-z0-9]/g, "-");
+    }
+
+    /**
+     * Verifica se Docker está disponível
+     */
+    async isDockerAvailable(): Promise<boolean> {
+        return new Promise((resolve) => {
+            const child = spawn("docker", ["--version"], { shell: true });
+            child.on("close", (code) => resolve(code === 0));
+            child.on("error", () => resolve(false));
+        });
+    }
+
+    /**
+     * Gera Dockerfile para o projeto
+     */
+    async generateDockerfile(config: DockerConfig = {}): Promise<void> {
+        const imageName = config.imageName || this.projectName;
+        const javaVersion = config.javaVersion || "17";
+        const port = config.port || 8080;
+
+        // Detectar build tool
+        const hasMaven = fs.existsSync(path.join(this.projectPath, "pom.xml"));
+        const hasGradle = fs.existsSync(path.join(this.projectPath, "build.gradle")) ||
+                         fs.existsSync(path.join(this.projectPath, "build.gradle.kts"));
+
+        const dockerfile = hasMaven 
+            ? this.generateMavenDockerfile(javaVersion, port)
+            : hasGradle 
+                ? this.generateGradleDockerfile(javaVersion, port)
+                : this.generateGenericDockerfile(javaVersion, port);
+
+        const dockerfilePath = path.join(this.projectPath, "Dockerfile");
+        fs.writeFileSync(dockerfilePath, dockerfile);
+
+        Logger.success(`Dockerfile generated: ${dockerfilePath}`);
+    }
+
+    /**
+     * Gera docker-compose.yml
+     */
+    async generateCompose(config: DockerConfig = {}): Promise<void> {
+        const serviceName = config.imageName || this.projectName;
+        const port = config.port || 8080;
+
+        const compose = `version: '3.8'
+
+services:
+  ${serviceName}:
+    build: .
+    ports:
+      - "${port}:8080"
+    environment:
+      - SPRING_PROFILES_ACTIVE=docker
+      - JAVA_OPTS=-Xmx512m
+    volumes:
+      - ./logs:/app/logs
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+
+  # Optional: Add database service
+  # postgres:
+  #   image: postgres:15-alpine
+  #   environment:
+  #     POSTGRES_DB: ${serviceName}
+  #     POSTGRES_USER: app
+  #     POSTGRES_PASSWORD: secret
+  #   ports:
+  #     - "5432:5432"
+  #   volumes:
+  #     - postgres_data:/var/lib/postgresql/data
+
+# volumes:
+#   postgres_data:
+`;
+
+        const composePath = path.join(this.projectPath, "docker-compose.yml");
+        fs.writeFileSync(composePath, compose);
+
+        Logger.success(`docker-compose.yml generated: ${composePath}`);
+    }
+
+    /**
+     * Build da imagem Docker
+     */
+    async buildImage(tag?: string): Promise<boolean> {
+        const imageTag = tag || `${this.projectName}:latest`;
+        
+        Logger.section("Building Docker Image");
+        Logger.info("Image", imageTag);
+
+        return new Promise((resolve) => {
+            const args = ["build", "-t", imageTag, "."];
+            const child = spawn("docker", args, {
+                cwd: this.projectPath,
+                stdio: "inherit",
+                shell: true
+            });
+
+            child.on("close", (code) => {
+                if (code === 0) {
+                    Logger.success(`Image built: ${imageTag}`);
+                } else {
+                    Logger.error("Build failed");
+                }
+                resolve(code === 0);
+            });
+        });
+    }
+
+    /**
+     * Roda container com hot-reload
+     */
+    async runDevMode(port?: number): Promise<boolean> {
+        const containerPort = port || 8080;
+        const containerName = `${this.projectName}-dev`;
+
+        Logger.section("Running Docker Dev Mode");
+        Logger.info("Container", containerName);
+        Logger.info("Port", `${containerPort}:8080`);
+
+        // Verifica se já existe container rodando
+        await this.stopContainer(containerName);
+
+        return new Promise((resolve) => {
+            const args = [
+                "run", "--rm",
+                "--name", containerName,
+                "-p", `${containerPort}:8080`,
+                "-v", `${this.projectPath}:/app`,
+                "-w", "/app",
+                "-e", "MAVEN_OPTS=-XX:+UseG1GC",
+                "maven:3.9-eclipse-temurin-17",
+                "mvn", "tomcat7:run"
+            ];
+
+            const child = spawn("docker", args, {
+                stdio: "inherit",
+                shell: true
+            });
+
+            child.on("close", (code) => {
+                resolve(code === 0);
+            });
+        });
+    }
+
+    /**
+     * Roda docker-compose
+     */
+    async composeUp(detached: boolean = false): Promise<boolean> {
+        Logger.section("Starting Docker Compose");
+
+        return new Promise((resolve) => {
+            const args = ["up"];
+            if (detached) args.push("-d");
+            args.push("--build");
+
+            const child = spawn("docker-compose", args, {
+                cwd: this.projectPath,
+                stdio: "inherit",
+                shell: true
+            });
+
+            child.on("close", (code) => {
+                if (code === 0 && detached) {
+                    Logger.success("Containers started");
+                    this.showContainerStatus();
+                }
+                resolve(code === 0);
+            });
+        });
+    }
+
+    /**
+     * Para containers do compose
+     */
+    async composeDown(): Promise<boolean> {
+        Logger.section("Stopping Docker Compose");
+
+        return new Promise((resolve) => {
+            const child = spawn("docker-compose", ["down"], {
+                cwd: this.projectPath,
+                stdio: "inherit",
+                shell: true
+            });
+
+            child.on("close", (code) => {
+                if (code === 0) {
+                    Logger.success("Containers stopped");
+                }
+                resolve(code === 0);
+            });
+        });
+    }
+
+    /**
+     * Lista containers do projeto
+     */
+    async listContainers(): Promise<ContainerInfo[]> {
+        return new Promise((resolve) => {
+            const child = spawn("docker", [
+                "ps", "-a",
+                "--filter", `name=${this.projectName}`,
+                "--format", "{{.ID}}|{{.Names}}|{{.Image}}|{{.Status}}|{{.Ports}}|{{.CreatedAt}}"
+            ], { shell: true });
+
+            let output = "";
+            child.stdout?.on("data", (data) => output += data.toString());
+
+            child.on("close", () => {
+                const containers: ContainerInfo[] = [];
+                for (const line of output.trim().split("\n")) {
+                    const parts = line.split("|");
+                    if (parts.length >= 6) {
+                        containers.push({
+                            id: parts[0].slice(0, 12),
+                            name: parts[1],
+                            image: parts[2],
+                            status: parts[3],
+                            ports: parts[4],
+                            created: parts[5]
+                        });
+                    }
+                }
+                resolve(containers);
+            });
+        });
+    }
+
+    /**
+     * Mostra status dos containers
+     */
+    async showContainerStatus(): Promise<void> {
+        const containers = await this.listContainers();
+        
+        if (containers.length === 0) {
+            Logger.info("Containers", "None found");
+            return;
+        }
+
+        Logger.divider();
+        for (const c of containers) {
+            const statusColor = c.status.includes("Up") ? Logger.C.success : Logger.C.error;
+            Logger.info(c.name, `${statusColor}${c.status}${Logger.C.reset}`);
+            if (c.ports) {
+                Logger.dim(`  ${c.ports}`);
+            }
+        }
+    }
+
+    /**
+     * Para um container específico
+     */
+    private async stopContainer(name: string): Promise<void> {
+        return new Promise((resolve) => {
+            const child = spawn("docker", ["stop", name], { shell: true });
+            child.on("close", () => resolve());
+        });
+    }
+
+    // ===== Dockerfile Generators =====
+
+    private generateMavenDockerfile(javaVersion: string, port: number): string {
+        return `# Build stage
+FROM maven:3.9-eclipse-temurin-${javaVersion}-alpine AS builder
+WORKDIR /app
+COPY pom.xml .
+RUN mvn dependency:go-offline -B
+COPY src ./src
+RUN mvn clean package -DskipTests -B
+
+# Runtime stage
+FROM eclipse-temurin:${javaVersion}-jdk-alpine
+WORKDIR /app
+COPY --from=builder /app/target/*.war app.war
+
+EXPOSE ${port}
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \\
+    CMD wget --no-verbose --tries=1 --spider http://localhost:${port}/ || exit 1
+
+ENTRYPOINT ["java", "-jar", "app.jar"]
+`;
+    }
+
+    private generateGradleDockerfile(javaVersion: string, port: number): string {
+        return `# Build stage
+FROM gradle:8-jdk${javaVersion}-alpine AS builder
+WORKDIR /app
+COPY build.gradle settings.gradle ./
+COPY gradle ./gradle
+RUN gradle dependencies --no-daemon
+COPY src ./src
+RUN gradle bootWar -x test --no-daemon
+
+# Runtime stage
+FROM eclipse-temurin:${javaVersion}-jdk-alpine
+WORKDIR /app
+COPY --from=builder /app/build/libs/*.war app.war
+
+EXPOSE ${port}
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \\
+    CMD wget --no-verbose --tries=1 --spider http://localhost:${port}/ || exit 1
+
+ENTRYPOINT ["java", "-jar", "app.jar"]
+`;
+    }
+
+    private generateGenericDockerfile(javaVersion: string, port: number): string {
+        return `FROM eclipse-temurin:${javaVersion}-jdk-alpine
+WORKDIR /app
+COPY . .
+RUN ./mvnw package -DskipTests || ./gradlew bootWar -x test || echo "Build manually"
+
+EXPOSE ${port}
+ENTRYPOINT ["java", "-jar", "app.war"]
+`;
+    }
+}

package/src/services/HttpService.ts

@@ -0,0 +1,259 @@
+/**
+ * Serviço de HTTP Client para testar APIs
+ * Similar ao Postman/curl mas integrado com o projeto
+ */
+
+import { Logger } from "../utils/ui";
+import type { ApiEndpoint } from "../types/endpoint";
+
+export interface HttpRequest {
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+    url: string;
+    headers?: Record<string, string>;
+    body?: string | object;
+    params?: Record<string, string>;
+    timeout?: number;
+}
+
+export interface HttpResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string | object;
+    duration: number;
+    size: number;
+}
+
+export interface HttpCollection {
+    name: string;
+    requests: HttpRequest[];
+}
+
+export class HttpService {
+    private baseUrl: string;
+    private defaultHeaders: Record<string, string>;
+
+    constructor(baseUrl: string = "", defaultHeaders: Record<string, string> = {}) {
+        this.baseUrl = baseUrl;
+        this.defaultHeaders = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            ...defaultHeaders
+        };
+    }
+
+    /**
+     * Executa uma requisição HTTP
+     */
+    async request(req: HttpRequest): Promise<HttpResponse> {
+        const startTime = Date.now();
+        const url = this.buildUrl(req.url, req.params);
+        
+        Logger.step(`${req.method} ${url}`);
+
+        const headers = { ...this.defaultHeaders, ...req.headers };
+        const body = req.body ? (typeof req.body === "string" ? req.body : JSON.stringify(req.body)) : undefined;
+
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), req.timeout || 30000);
+
+            const response = await fetch(url, {
+                method: req.method,
+                headers,
+                body,
+                signal: controller.signal
+            });
+
+            clearTimeout(timeoutId);
+
+            const duration = Date.now() - startTime;
+            const responseHeaders: Record<string, string> = {};
+            response.headers.forEach((value, key) => {
+                responseHeaders[key] = value;
+            });
+
+            const responseBody = await this.parseBody(response);
+            const size = JSON.stringify(responseBody).length;
+
+            const result: HttpResponse = {
+                status: response.status,
+                statusText: response.statusText,
+                headers: responseHeaders,
+                body: responseBody,
+                duration,
+                size
+            };
+
+            this.printResponse(result);
+            return result;
+
+        } catch (error) {
+            const duration = Date.now() - startTime;
+            Logger.error(`Request failed: ${(error as Error).message}`);
+            throw error;
+        }
+    }
+
+    /**
+     * Executa múltiplas requisições em sequência
+     */
+    async runCollection(requests: HttpRequest[]): Promise<HttpResponse[]> {
+        Logger.section(`Running ${requests.length} requests`);
+        const results: HttpResponse[] = [];
+
+        for (let i = 0; i < requests.length; i++) {
+            Logger.info(`Request`, `${i + 1}/${requests.length}`);
+            try {
+                const result = await this.request(requests[i]);
+                results.push(result);
+            } catch (error) {
+                Logger.error(`Request ${i + 1} failed`);
+            }
+        }
+
+        Logger.endSection();
+        return results;
+    }
+
+    /**
+     * Testa um endpoint descoberto automaticamente
+     */
+    async testEndpoint(endpoint: ApiEndpoint, baseUrl: string): Promise<HttpResponse> {
+        const url = `${baseUrl}${endpoint.fullPath}`;
+        
+        // Gera um body de exemplo baseado nos parâmetros
+        const body = this.generateExampleBody(endpoint);
+
+        return this.request({
+            method: endpoint.method === "ALL" ? "GET" : endpoint.method,
+            url,
+            body
+        });
+    }
+
+    /**
+     * Modo interativo - CLI HTTP client
+     */
+    async interactive(): Promise<void> {
+        Logger.section("HTTP Client Interactive Mode");
+        Logger.info("Commands:", "GET /path, POST /path, PUT /path, DELETE /path");
+        Logger.info("Headers:", "header:Name:Value");
+        Logger.info("Body:", "body:{\"key\":\"value\"}");
+        Logger.info("Exit:", "quit or exit");
+        Logger.endSection();
+
+        // Implementação básica - em produção usaria readline
+        Logger.info("Tip", "Use individual commands instead:");
+        Logger.info("Example", "xavva http GET /api/users");
+    }
+
+    /**
+     * Carrega uma coleção de requisições de um arquivo
+     */
+    loadCollection(filePath: string): HttpCollection {
+        const fs = require("fs");
+        const content = fs.readFileSync(filePath, "utf-8");
+        return JSON.parse(content);
+    }
+
+    /**
+     * Salva uma coleção de requisições
+     */
+    saveCollection(collection: HttpCollection, filePath: string): void {
+        const fs = require("fs");
+        fs.writeFileSync(filePath, JSON.stringify(collection, null, 2));
+    }
+
+    private buildUrl(url: string, params?: Record<string, string>): string {
+        let fullUrl = url.startsWith("http") ? url : `${this.baseUrl}${url}`;
+        
+        if (params && Object.keys(params).length > 0) {
+            const searchParams = new URLSearchParams();
+            for (const [key, value] of Object.entries(params)) {
+                searchParams.append(key, value);
+            }
+            fullUrl += `?${searchParams.toString()}`;
+        }
+
+        return fullUrl;
+    }
+
+    private async parseBody(response: Response): Promise<string | object> {
+        const contentType = response.headers.get("content-type") || "";
+        const text = await response.text();
+
+        if (contentType.includes("application/json")) {
+            try {
+                return JSON.parse(text);
+            } catch {
+                return text;
+            }
+        }
+
+        return text;
+    }
+
+    private printResponse(res: HttpResponse): void {
+        const statusColor = res.status < 300 ? Logger.C.success 
+            : res.status < 400 ? Logger.C.warning 
+            : Logger.C.error;
+
+        Logger.divider();
+        Logger.info("Status", `${statusColor}${res.status} ${res.statusText}${Logger.C.reset}`);
+        Logger.info("Duration", `${res.duration}ms`);
+        Logger.info("Size", `${this.formatBytes(res.size)}`);
+
+        if (typeof res.body === "object") {
+            Logger.divider();
+            console.log(JSON.stringify(res.body, null, 2));
+        } else if (res.body) {
+            Logger.divider();
+            console.log(res.body.slice(0, 1000));
+            if (res.body.length > 1000) {
+                Logger.dim(`... (${res.body.length - 1000} more characters)`);
+            }
+        }
+    }
+
+    private formatBytes(bytes: number): string {
+        if (bytes < 1024) return `${bytes} B`;
+        if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
+        return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+    }
+
+    private generateExampleBody(endpoint: ApiEndpoint): object | undefined {
+        if (endpoint.method === "GET" || endpoint.method === "DELETE") {
+            return undefined;
+        }
+
+        const body: Record<string, unknown> = {};
+        for (const param of endpoint.parameters) {
+            if (param.source === "BODY") {
+                // Gera exemplo baseado no tipo
+                switch (param.type.toLowerCase()) {
+                    case "string":
+                        body[param.name] = "example";
+                        break;
+                    case "int":
+                    case "integer":
+                    case "long":
+                        body[param.name] = 123;
+                        break;
+                    case "boolean":
+                        body[param.name] = true;
+                        break;
+                    case "double":
+                    case "float":
+                    case "bigdecimal":
+                        body[param.name] = 99.99;
+                        break;
+                    default:
+                        body[param.name] = null;
+                }
+            }
+        }
+
+        return Object.keys(body).length > 0 ? body : undefined;
+    }
+}