@silasfmartins/testhub 1.0.0

package/dist/src/hubdocs/SwaggerGenerator.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 📖 SwaggerGenerator - Gerador de Documentação OpenAPI
+ * @silasfmartins/testhub - Auto Documentation System
+ */
+import type { ExecutionData } from './types.js';
+export declare class SwaggerGenerator {
+    private static readonly SWAGGER_VERSION;
+    /**
+     * 🔄 Gerar especificação OpenAPI completa
+     */
+    static generateSwagger(data: ExecutionData): any;
+    /**
+     * 🌐 Extrair servidores únicos
+     */
+    private static extractServers;
+    /**
+     * 🛣️ Gerar paths da API
+     */
+    private static generatePaths;
+    /**
+     * 🎯 Gerar operação individual
+     */
+    private static generateOperation;
+    /**
+     * 📝 Gerar resumo da operação
+     */
+    private static generateSummary;
+    /**
+     * 📋 Gerar descrição detalhada
+     */
+    private static generateDescription;
+    /**
+     * 🏷️ Extrair tags
+     */
+    private static extractTags;
+    /**
+     * 📊 Gerar parâmetros
+     */
+    private static generateParameters;
+    /**
+     * 📤 Gerar request body
+     */
+    private static generateRequestBody;
+    /**
+     * 📥 Gerar responses
+     */
+    private static generateResponses;
+    /**
+     * 🔧 Métodos auxiliares
+     */
+    private static groupApisByEndpoint;
+    private static groupByMethod;
+    private static generateSchemas;
+    private static generateSecuritySchemes;
+    private static generateTags;
+    private static generateSchemaFromObject;
+    private static calculateAvgResponseTime;
+    private static getStatusDescription;
+}

package/dist/src/hubdocs/SwaggerGenerator.js

@@ -0,0 +1,405 @@
+/**
+ * 📖 SwaggerGenerator - Gerador de Documentação OpenAPI
+ * @silasfmartins/testhub - Auto Documentation System
+ */
+export class SwaggerGenerator {
+    static SWAGGER_VERSION = '3.0.3';
+    /**
+     * 🔄 Gerar especificação OpenAPI completa
+     */
+    static generateSwagger(data) {
+        const swagger = {
+            openapi: SwaggerGenerator.SWAGGER_VERSION,
+            info: {
+                title: `${data.metadata.projectName} - API Documentation`,
+                version: data.metadata.version,
+                description: `Documentação automática gerada pelo @silasfmartins/testhub\n\nGerada em: ${new Date().toLocaleString()}\nTipo do projeto: ${data.metadata.projectType}\nAmbiente: ${data.metadata.environment}`,
+                contact: {
+                    name: 'AutoCore Website System',
+                    url: 'http://brtlvlty0559pl:3002/',
+                },
+            },
+            servers: SwaggerGenerator.extractServers(data.apis),
+            paths: SwaggerGenerator.generatePaths(data.apis),
+            components: {
+                schemas: SwaggerGenerator.generateSchemas(data.apis),
+                securitySchemes: SwaggerGenerator.generateSecuritySchemes(data.apis),
+            },
+            tags: SwaggerGenerator.generateTags(data.apis),
+        };
+        return swagger;
+    }
+    /**
+     * 🌐 Extrair servidores únicos
+     */
+    static extractServers(apis) {
+        const serverSet = new Set();
+        apis.forEach((api) => {
+            try {
+                const url = new URL(api.url);
+                const baseUrl = `${url.protocol}//${url.host}`;
+                serverSet.add(baseUrl);
+            }
+            catch (error) {
+                // Ignorar URLs inválidas
+            }
+        });
+        return Array.from(serverSet).map((url) => ({
+            url,
+            description: 'Servidor extraído automaticamente',
+        }));
+    }
+    /**
+     * 🛣️ Gerar paths da API
+     */
+    static generatePaths(apis) {
+        const paths = {};
+        // Agrupar APIs por endpoint
+        const groupedApis = SwaggerGenerator.groupApisByEndpoint(apis);
+        Object.entries(groupedApis).forEach(([endpoint, calls]) => {
+            paths[endpoint] = {};
+            // Agrupar por método HTTP
+            const methodGroups = SwaggerGenerator.groupByMethod(calls);
+            Object.entries(methodGroups).forEach(([method, methodCalls]) => {
+                paths[endpoint][method.toLowerCase()] =
+                    SwaggerGenerator.generateOperation(methodCalls);
+            });
+        });
+        return paths;
+    }
+    /**
+     * 🎯 Gerar operação individual
+     */
+    static generateOperation(calls) {
+        const firstCall = calls[0];
+        const successfulCalls = calls.filter((c) => c.success);
+        const failedCalls = calls.filter((c) => !c.success);
+        return {
+            summary: SwaggerGenerator.generateSummary(firstCall),
+            description: SwaggerGenerator.generateDescription(calls),
+            tags: SwaggerGenerator.extractTags(firstCall),
+            parameters: SwaggerGenerator.generateParameters(calls),
+            requestBody: SwaggerGenerator.generateRequestBody(calls),
+            responses: SwaggerGenerator.generateResponses(successfulCalls, failedCalls),
+            'x-autocore-stats': {
+                totalCalls: calls.length,
+                successRate: `${((successfulCalls.length / calls.length) * 100).toFixed(1)}%`,
+                avgResponseTime: SwaggerGenerator.calculateAvgResponseTime(calls),
+                lastExecuted: Math.max(...calls.map((c) => new Date(c.timestamp).getTime())),
+            },
+        };
+    }
+    /**
+     * 📝 Gerar resumo da operação
+     */
+    static generateSummary(call) {
+        const pathParts = new URL(call.url).pathname.split('/').filter(Boolean);
+        const lastPart = pathParts[pathParts.length - 1] || 'root';
+        const actionVerbs = {
+            GET: 'Obter',
+            POST: 'Criar',
+            PUT: 'Atualizar',
+            DELETE: 'Remover',
+            PATCH: 'Modificar',
+        };
+        return `${actionVerbs[call.method] || call.method} ${lastPart}`;
+    }
+    /**
+     * 📋 Gerar descrição detalhada
+     */
+    static generateDescription(calls) {
+        const contexts = [
+            ...new Set(calls.map((c) => c.testContext).filter(Boolean)),
+        ];
+        const files = [...new Set(calls.map((c) => c.testFile).filter(Boolean))];
+        let description = 'Esta operação foi capturada automaticamente durante a execução dos testes.\n\n';
+        if (contexts.length > 0) {
+            description += `**Contextos de teste:** ${contexts.join(', ')}\n\n`;
+        }
+        if (files.length > 0) {
+            description += `**Arquivos de teste:** ${files.join(', ')}\n\n`;
+        }
+        description += `**Execuções registradas:** ${calls.length}`;
+        return description;
+    }
+    /**
+     * 🏷️ Extrair tags
+     */
+    static extractTags(call) {
+        const tags = [];
+        // Tag baseada no caminho
+        try {
+            const pathParts = new URL(call.url).pathname.split('/').filter(Boolean);
+            if (pathParts.length > 0) {
+                tags.push(pathParts[0]);
+            }
+        }
+        catch (error) {
+            // Ignorar
+        }
+        // Tag baseada no arquivo de teste
+        if (call.testFile) {
+            const fileName = call.testFile
+                .split('/')
+                .pop()
+                ?.replace('.test.ts', '')
+                .replace('.spec.ts', '');
+            if (fileName) {
+                tags.push(fileName);
+            }
+        }
+        return tags.length > 0 ? tags : ['default'];
+    }
+    /**
+     * 📊 Gerar parâmetros
+     */
+    static generateParameters(calls) {
+        const parameters = [];
+        // Extrair parâmetros de query únicos
+        const queryParams = new Set();
+        calls.forEach((call) => {
+            try {
+                const url = new URL(call.url);
+                url.searchParams.forEach((value, key) => {
+                    queryParams.add(key);
+                });
+            }
+            catch (error) {
+                // Ignorar
+            }
+        });
+        queryParams.forEach((param) => {
+            parameters.push({
+                name: param,
+                in: 'query',
+                description: 'Parâmetro extraído automaticamente',
+                required: false,
+                schema: { type: 'string' },
+            });
+        });
+        // Extrair parâmetros de path
+        const firstCall = calls[0];
+        try {
+            const pathParams = new URL(firstCall.url).pathname.match(/{([^}]+)}/g);
+            if (pathParams) {
+                pathParams.forEach((param) => {
+                    const paramName = param.slice(1, -1);
+                    parameters.push({
+                        name: paramName,
+                        in: 'path',
+                        description: 'Parâmetro de caminho',
+                        required: true,
+                        schema: { type: 'string' },
+                    });
+                });
+            }
+        }
+        catch (error) {
+            // Ignorar
+        }
+        return parameters;
+    }
+    /**
+     * 📤 Gerar request body
+     */
+    static generateRequestBody(calls) {
+        const callsWithPayload = calls.filter((c) => c.payload);
+        if (callsWithPayload.length === 0)
+            return;
+        const firstPayload = callsWithPayload[0].payload;
+        return {
+            description: 'Request body extraído automaticamente',
+            required: true,
+            content: {
+                'application/json': {
+                    schema: SwaggerGenerator.generateSchemaFromObject(firstPayload),
+                    example: firstPayload,
+                },
+            },
+        };
+    }
+    /**
+     * 📥 Gerar responses
+     */
+    static generateResponses(successCalls, failedCalls) {
+        const responses = {};
+        // Responses de sucesso
+        if (successCalls.length > 0) {
+            const statusCodes = [
+                ...new Set(successCalls
+                    .map((c) => c.statusCode)
+                    .filter((code) => code !== undefined)),
+            ];
+            statusCodes.forEach((statusCode) => {
+                const callsWithStatus = successCalls.filter((c) => c.statusCode === statusCode);
+                const firstResponse = callsWithStatus.find((c) => c.response)?.response;
+                responses[statusCode.toString()] = {
+                    description: SwaggerGenerator.getStatusDescription(statusCode),
+                    content: firstResponse
+                        ? {
+                            'application/json': {
+                                schema: SwaggerGenerator.generateSchemaFromObject(firstResponse),
+                                example: firstResponse,
+                            },
+                        }
+                        : undefined,
+                };
+            });
+        }
+        // Responses de erro
+        if (failedCalls.length > 0) {
+            const errorCodes = [
+                ...new Set(failedCalls
+                    .map((c) => c.statusCode)
+                    .filter((code) => code !== undefined)),
+            ];
+            errorCodes.forEach((statusCode) => {
+                const callsWithStatus = failedCalls.filter((c) => c.statusCode === statusCode);
+                const firstError = callsWithStatus.find((c) => c.error)?.error;
+                responses[statusCode.toString()] = {
+                    description: SwaggerGenerator.getStatusDescription(statusCode),
+                    content: firstError
+                        ? {
+                            'application/json': {
+                                schema: SwaggerGenerator.generateSchemaFromObject(firstError),
+                                example: firstError,
+                            },
+                        }
+                        : undefined,
+                };
+            });
+        }
+        // Response padrão se não houver nenhum
+        if (Object.keys(responses).length === 0) {
+            responses['200'] = {
+                description: 'Resposta bem-sucedida',
+            };
+        }
+        return responses;
+    }
+    /**
+     * 🔧 Métodos auxiliares
+     */
+    static groupApisByEndpoint(apis) {
+        const groups = {};
+        apis.forEach((api) => {
+            try {
+                let path = new URL(api.url).pathname;
+                // Garantir que o path sempre comece com "/"
+                if (!path || path === '') {
+                    path = '/root';
+                }
+                else if (!path.startsWith('/')) {
+                    path = '/' + path;
+                }
+                // Limpar caracteres inválidos e normalizar
+                path = path.replace(/[^a-zA-Z0-9\-._~:/?#[\]@!$&'()*+,;=%]/g, '_');
+                if (!groups[path])
+                    groups[path] = [];
+                groups[path].push(api);
+            }
+            catch (error) {
+                // Gerar um path válido baseado na URL
+                const safePath = '/generated_' +
+                    Buffer.from(api.url)
+                        .toString('base64')
+                        .substring(0, 20)
+                        .replace(/[^a-zA-Z0-9]/g, '_');
+                if (!groups[safePath])
+                    groups[safePath] = [];
+                groups[safePath].push(api);
+            }
+        });
+        return groups;
+    }
+    static groupByMethod(calls) {
+        const groups = {};
+        calls.forEach((call) => {
+            if (!groups[call.method])
+                groups[call.method] = [];
+            groups[call.method].push(call);
+        });
+        return groups;
+    }
+    static generateSchemas(apis) {
+        // Por simplicidade, retornamos um schema básico
+        // Em implementação futura, podemos analisar todos os payloads/responses
+        return {
+            Error: {
+                type: 'object',
+                properties: {
+                    message: { type: 'string' },
+                    code: { type: 'string' },
+                    details: { type: 'object' },
+                },
+            },
+        };
+    }
+    static generateSecuritySchemes(apis) {
+        // Detectar esquemas de segurança comuns
+        const hasBearer = apis.some((api) => api.headers &&
+            Object.keys(api.headers).some((h) => h.toLowerCase() === 'authorization' &&
+                typeof api.headers[h] === 'string' &&
+                api.headers[h].startsWith('Bearer ')));
+        const schemes = {};
+        if (hasBearer) {
+            schemes.bearerAuth = {
+                type: 'http',
+                scheme: 'bearer',
+                bearerFormat: 'JWT',
+            };
+        }
+        return schemes;
+    }
+    static generateTags(apis) {
+        const tagSet = new Set();
+        apis.forEach((api) => {
+            SwaggerGenerator.extractTags(api).forEach((tag) => tagSet.add(tag));
+        });
+        return Array.from(tagSet).map((name) => ({
+            name,
+            description: `Operações relacionadas a ${name}`,
+        }));
+    }
+    static generateSchemaFromObject(obj) {
+        if (!obj || typeof obj !== 'object') {
+            return { type: 'string' };
+        }
+        if (Array.isArray(obj)) {
+            return {
+                type: 'array',
+                items: obj.length > 0
+                    ? SwaggerGenerator.generateSchemaFromObject(obj[0])
+                    : { type: 'string' },
+            };
+        }
+        const properties = {};
+        Object.keys(obj).forEach((key) => {
+            const value = obj[key];
+            properties[key] = SwaggerGenerator.generateSchemaFromObject(value);
+        });
+        return {
+            type: 'object',
+            properties,
+        };
+    }
+    static calculateAvgResponseTime(calls) {
+        const timesWithDuration = calls.filter((c) => c.duration !== undefined);
+        if (timesWithDuration.length === 0)
+            return 0;
+        const total = timesWithDuration.reduce((sum, call) => sum + (call.duration || 0), 0);
+        return Math.round(total / timesWithDuration.length);
+    }
+    static getStatusDescription(statusCode) {
+        const descriptions = {
+            200: 'Sucesso',
+            201: 'Criado com sucesso',
+            400: 'Requisição inválida',
+            401: 'Não autorizado',
+            403: 'Acesso negado',
+            404: 'Não encontrado',
+            500: 'Erro interno do servidor',
+        };
+        return descriptions[statusCode] || `Status ${statusCode}`;
+    }
+}

package/dist/src/hubdocs/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 📚 Auto Documentation System - Main Export
+ * @silasfmartins/testhub - Comprehensive Documentation Generation
+ */
+export { CategoryDetector } from './CategoryDetector.js';
+export { ExecutionTracker, ExecutionTracker as Tracker, } from './ExecutionTracker.js';
+export { AutoDocs, AutoDocs as Docs } from './HubDocs.js';
+export { SwaggerGenerator } from './SwaggerGenerator.js';
+export type { APICall, DBQuery, DocsConfig, ExecutionData, ExecutionMetadata, MobileAction, SSHCommand, TestCategory, UIAction, } from './types.js';

package/dist/src/hubdocs/index.js

@@ -0,0 +1,9 @@
+/**
+ * 📚 Auto Documentation System - Main Export
+ * @silasfmartins/testhub - Comprehensive Documentation Generation
+ */
+export { CategoryDetector } from './CategoryDetector.js';
+export { ExecutionTracker, ExecutionTracker as Tracker, } from './ExecutionTracker.js';
+// Convenience re-exports for common usage
+export { AutoDocs, AutoDocs as Docs } from './HubDocs.js';
+export { SwaggerGenerator } from './SwaggerGenerator.js';

package/dist/src/hubdocs/types.d.ts

@@ -0,0 +1,114 @@
+/**
+ * 📚 Types para o sistema de documentação automática
+ * @silasfmartins/testhub - Auto Documentation System
+ */
+export interface ExecutionData {
+    apis: APICall[];
+    ssh: SSHCommand[];
+    db: DBQuery[];
+    ui: UIAction[];
+    mobile: MobileAction[];
+    metadata: ExecutionMetadata;
+}
+export interface APICall {
+    id: string;
+    method: string;
+    url: string;
+    payload?: any;
+    response?: any;
+    statusCode?: number;
+    timestamp: string;
+    testName: string;
+    environment: string;
+    headers?: Record<string, string | string[]>;
+    duration?: number;
+    success: boolean;
+    error?: any;
+    testFile?: string;
+    testContext?: string;
+}
+export interface SSHCommand {
+    command: string;
+    output: string;
+    host: string;
+    timestamp: string;
+    testName: string;
+    exitCode?: number;
+    duration: number;
+    user?: string;
+    success?: boolean;
+    error?: string;
+}
+export interface DBQuery {
+    query: string;
+    params: any[];
+    result?: any;
+    duration: number;
+    timestamp: string;
+    testName: string;
+    database: string;
+    type: 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE' | 'DDL' | 'OTHER';
+    rowCount?: number;
+    description?: string;
+    serviceName?: string;
+    success?: boolean;
+    error?: string;
+}
+export interface UIAction {
+    action: string;
+    element: string;
+    value?: string;
+    page: string;
+    timestamp: string;
+    testName: string;
+    screenshot?: string;
+    selector: string;
+    success?: boolean;
+    duration?: number;
+    error?: string;
+}
+export interface MobileAction {
+    action: string;
+    element?: string;
+    device: string;
+    platform: 'iOS' | 'Android' | 'Web';
+    timestamp: string;
+    testName: string;
+    value?: string;
+    coordinates?: {
+        x: number;
+        y: number;
+    };
+    screenshot?: string;
+}
+export interface ExecutionMetadata {
+    startTime: string;
+    endTime: string;
+    environment: string;
+    totalTests: number;
+    passedTests: number;
+    failedTests: number;
+    framework: string;
+    version: string;
+    projectName: string;
+    projectType: string;
+    duration: number;
+}
+export interface TestCategory {
+    name: string;
+    icon: string;
+    count: number;
+    description: string;
+    hasData: boolean;
+}
+export interface DocsConfig {
+    enabled: boolean;
+    categories: string[];
+    outputDir: string;
+    includeRequestBody: boolean;
+    includeResponseBody: boolean;
+    generateSwagger: boolean;
+    includeScreenshots: boolean;
+    maxRequestSize: number;
+    maxResponseSize: number;
+}

package/dist/src/hubdocs/types.js

@@ -0,0 +1,5 @@
+/**
+ * 📚 Types para o sistema de documentação automática
+ * @silasfmartins/testhub - Auto Documentation System
+ */
+export {};