@silasfmartins/testhub 1.0.0

package/dist/src/utils/DataStore.js

@@ -0,0 +1,484 @@
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { Logger } from './Logger.js';
+/**
+ * Store compartilhado para transferência de dados entre projetos e testes
+ *
+ * Funcionalidades:
+ * - Cache em memória para performance
+ * - Persistência em arquivo JSON
+ * - Métodos especializados para diferentes tipos de dados
+ * - Limpeza automática com TTL
+ * - Thread-safe operations
+ * - Type-safe getters para evitar erros de null
+ *
+ * @example
+ * ```typescript
+ * // ✅ FORMA CORRETA - Armazenar dados
+ * DataStore.set('user_id', '12345')
+ * DataStore.set('URL_CLIENTE', 'https://example.com')
+ *
+ * // ✅ FORMA CORRETA - Recuperar com type safety
+ * const userId = DataStore.getString('user_id') // retorna string (nunca null)
+ * const url = DataStore.getString('URL_CLIENTE', 'https://default.com') // com fallback
+ * const count = DataStore.getNumber('attempts', 0) // retorna number
+ * const isActive = DataStore.getBoolean('active') // retorna boolean
+ *
+ * // ✅ FORMA CORRETA - Quando você TEM CERTEZA que o valor existe
+ * const token = DataStore.getOrThrow<string>('ACCESS_TOKEN') // lança erro se null
+ *
+ * // ❌ EVITE - Pode causar erro TypeScript "Type 'string | null' is not assignable to type 'string'"
+ * const url: string = DataStore.get('URL_CLIENTE') // ❌ ERRO!
+ * Logger.info(DataStore.get('URL_CLIENTE')) // ❌ ERRO!
+ *
+ * // ✅ CORRIJA USANDO - Operador de coalescência nula
+ * const url: string = DataStore.get('URL_CLIENTE') ?? 'default'
+ * Logger.info(DataStore.getString('URL_CLIENTE'))
+ *
+ * // Armazenar com TTL
+ * DataStore.setWithTTL('session_token', 'abc123', 3600) // expira em 1h
+ *
+ * // Armazenar resultado de query
+ * DataStore.storeQueryResult('user_details', userData)
+ *
+ * // Armazenar screenshot
+ * DataStore.storeScreenshot('login_page', screenshotBuffer)
+ * ```
+ */
+export class DataStore {
+    static dataFilePath = resolve(process.cwd(), '.test-data-store.json');
+    static persistEnabled = process.env.AUTOCORE_DATASTORE_PERSIST !== 'false';
+    static cache = {};
+    static initialized = false;
+    static lastSaveTime = 0;
+    static SAVE_THROTTLE_MS = 100; // Throttle saves to avoid excessive I/O
+    /**
+     * Inicializa o DataStore carregando dados existentes
+     */
+    static initialize() {
+        if (DataStore.initialized)
+            return;
+        try {
+            if (DataStore.persistEnabled && existsSync(DataStore.dataFilePath)) {
+                const fileContent = readFileSync(DataStore.dataFilePath, 'utf8');
+                const rawData = JSON.parse(fileContent);
+                // Migrar dados antigos para novo formato
+                DataStore.cache = DataStore.migrateOldFormat(rawData);
+                // Limpar itens expirados
+                DataStore.cleanupExpiredItems();
+                Logger.info(`DataStore: Carregados ${Object.keys(DataStore.cache).length} valores`);
+            }
+            else {
+                DataStore.cache = {};
+                if (DataStore.persistEnabled) {
+                    DataStore.save();
+                }
+                else {
+                    Logger.info('DataStore: Modo memória (persistência desabilitada)');
+                }
+            }
+            DataStore.initialized = true;
+        }
+        catch (error) {
+            Logger.error('DataStore: Erro ao inicializar', error);
+            DataStore.cache = {};
+            DataStore.initialized = true;
+        }
+    }
+    /**
+     * Migra dados do formato antigo para o novo com metadados
+     */
+    static migrateOldFormat(rawData) {
+        const migratedData = {};
+        for (const [key, value] of Object.entries(rawData)) {
+            // Se já está no novo formato
+            if (value &&
+                typeof value === 'object' &&
+                'value' in value &&
+                'timestamp' in value) {
+                migratedData[key] = value;
+            }
+            else {
+                // Migrar formato antigo
+                migratedData[key] = {
+                    value,
+                    timestamp: new Date().toISOString(),
+                    type: DataStore.determineItemType(key, value),
+                };
+            }
+        }
+        return migratedData;
+    }
+    /**
+     * Determina o tipo do item baseado na chave e valor
+     */
+    static determineItemType(key, value) {
+        if (key.startsWith('db_query_'))
+            return 'query';
+        if (key.startsWith('screenshot_'))
+            return 'screenshot';
+        if (key.startsWith('temp_'))
+            return 'temp';
+        if (key.includes('metadata') ||
+            key.includes('SYSTEM_') ||
+            key.includes('SETUP_'))
+            return 'metadata';
+        return 'simple';
+    }
+    /**
+     * Remove itens expirados baseado no TTL
+     */
+    static cleanupExpiredItems() {
+        const now = Date.now();
+        let cleanedCount = 0;
+        for (const [key, item] of Object.entries(DataStore.cache)) {
+            if (item.ttl) {
+                const itemTime = new Date(item.timestamp).getTime();
+                const expirationTime = itemTime + item.ttl * 1000;
+                if (now > expirationTime) {
+                    delete DataStore.cache[key];
+                    cleanedCount++;
+                }
+            }
+        }
+        if (cleanedCount > 0) {
+            Logger.info(`DataStore: Removidos ${cleanedCount} itens expirados`);
+            DataStore.save();
+        }
+    }
+    /**
+     * Salva os dados no arquivo com throttling
+     */
+    static save() {
+        if (!DataStore.persistEnabled) {
+            // Persistência desabilitada: apenas atualizar marcação de tempo
+            DataStore.lastSaveTime = Date.now();
+            return;
+        }
+        const now = Date.now();
+        // Throttle saves para evitar I/O excessivo
+        if (now - DataStore.lastSaveTime < DataStore.SAVE_THROTTLE_MS) {
+            // Agenda save para depois se não houver um pendente
+            setTimeout(() => DataStore.save(), DataStore.SAVE_THROTTLE_MS);
+            return;
+        }
+        try {
+            writeFileSync(DataStore.dataFilePath, JSON.stringify(DataStore.cache, null, 2), 'utf8');
+            DataStore.lastSaveTime = now;
+        }
+        catch (error) {
+            Logger.error('DataStore: Erro ao salvar dados', error);
+        }
+    }
+    /**
+     * Armazena um valor com uma chave específica
+     */
+    static set(key, value) {
+        DataStore.initialize();
+        DataStore.cache[key] = {
+            value,
+            timestamp: new Date().toISOString(),
+            type: DataStore.determineItemType(key, value),
+        };
+        DataStore.save();
+    }
+    /**
+     * Armazena um valor com TTL (Time To Live)
+     */
+    static setWithTTL(key, value, ttlSeconds) {
+        DataStore.initialize();
+        DataStore.cache[key] = {
+            value,
+            timestamp: new Date().toISOString(),
+            ttl: ttlSeconds,
+            type: DataStore.determineItemType(key, value),
+        };
+        DataStore.save();
+    }
+    /**
+     * Recupera um valor usando sua chave
+     */
+    static get(key, defaultValue = null) {
+        DataStore.initialize();
+        const item = DataStore.cache[key];
+        if (!item) {
+            Logger.info(`DataStore: Chave '${key}' não encontrada`);
+            return defaultValue;
+        }
+        // Verificar se expirou
+        if (item.ttl) {
+            const now = Date.now();
+            const itemTime = new Date(item.timestamp).getTime();
+            const expirationTime = itemTime + item.ttl * 1000;
+            if (now > expirationTime) {
+                delete DataStore.cache[key];
+                DataStore.save();
+                Logger.info(`DataStore: Chave '${key}' expirada e removida`);
+                return defaultValue;
+            }
+        }
+        return item.value;
+    }
+    /**
+     * Recupera um valor ou lança erro se não existir
+     * Útil quando você tem certeza que o valor existe
+     */
+    static getOrThrow(key) {
+        const value = DataStore.get(key);
+        if (value === null || value === undefined) {
+            throw new Error(`DataStore: Chave obrigatória '${key}' não encontrada`);
+        }
+        return value;
+    }
+    /**
+     * Recupera um valor string ou retorna string vazia
+     * Útil para evitar problemas com null
+     */
+    static getString(key, defaultValue = '') {
+        const value = DataStore.get(key);
+        return value ?? defaultValue;
+    }
+    /**
+     * Recupera um valor number ou retorna 0
+     */
+    static getNumber(key, defaultValue = 0) {
+        const value = DataStore.get(key);
+        return value ?? defaultValue;
+    }
+    /**
+     * Recupera um valor boolean ou retorna false
+     */
+    static getBoolean(key, defaultValue = false) {
+        const value = DataStore.get(key);
+        return value ?? defaultValue;
+    }
+    /**
+     * Verifica se uma chave existe e não expirou
+     */
+    static has(key) {
+        DataStore.initialize();
+        const item = DataStore.cache[key];
+        if (!item)
+            return false;
+        // Verificar TTL
+        if (item.ttl) {
+            const now = Date.now();
+            const itemTime = new Date(item.timestamp).getTime();
+            const expirationTime = itemTime + item.ttl * 1000;
+            if (now > expirationTime) {
+                delete DataStore.cache[key];
+                DataStore.save();
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Remove um valor específico
+     */
+    static remove(key) {
+        DataStore.initialize();
+        if (key in DataStore.cache) {
+            delete DataStore.cache[key];
+            DataStore.save();
+            Logger.info(`DataStore: Removida chave '${key}'`);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Limpa todos os valores armazenados
+     */
+    static clear() {
+        DataStore.initialize();
+        DataStore.cache = {};
+        DataStore.save();
+        Logger.info('DataStore: Todos os valores foram limpos');
+    }
+    /**
+     * Limpa apenas itens temporários
+     */
+    static clearTempItems() {
+        DataStore.initialize();
+        let removedCount = 0;
+        for (const [key, item] of Object.entries(DataStore.cache)) {
+            if (item.type === 'temp' || key.startsWith('temp_')) {
+                delete DataStore.cache[key];
+                removedCount++;
+            }
+        }
+        if (removedCount > 0) {
+            DataStore.save();
+            Logger.info(`DataStore: Removidos ${removedCount} itens temporários`);
+        }
+    }
+    /**
+     * Retorna todos os dados armazenados com metadados
+     */
+    static getAll() {
+        DataStore.initialize();
+        DataStore.cleanupExpiredItems();
+        const result = {};
+        for (const [key, item] of Object.entries(DataStore.cache)) {
+            result[key] = item.value;
+        }
+        return result;
+    }
+    /**
+     * Retorna estatísticas do DataStore
+     */
+    static getStats() {
+        DataStore.initialize();
+        const stats = {
+            totalItems: Object.keys(DataStore.cache).length,
+            itemsByType: {},
+            expiredItems: 0,
+            totalSizeKB: 0,
+        };
+        const now = Date.now();
+        for (const item of Object.values(DataStore.cache)) {
+            // Contar por tipo
+            stats.itemsByType[item.type] = (stats.itemsByType[item.type] || 0) + 1;
+            // Contar expirados
+            if (item.ttl) {
+                const itemTime = new Date(item.timestamp).getTime();
+                const expirationTime = itemTime + item.ttl * 1000;
+                if (now > expirationTime) {
+                    stats.expiredItems++;
+                }
+            }
+        }
+        // Calcular tamanho aproximado
+        try {
+            const jsonString = JSON.stringify(DataStore.cache);
+            stats.totalSizeKB = Math.round(Buffer.byteLength(jsonString, 'utf8') / 1024);
+        }
+        catch {
+            stats.totalSizeKB = 0;
+        }
+        return stats;
+    }
+    /**
+     * Armazena resultado de consulta de banco para uso posterior
+     */
+    static storeQueryResult(queryName, data, ttlSeconds) {
+        const key = `db_query_${queryName}`;
+        const item = {
+            value: {
+                timestamp: new Date().toISOString(),
+                data,
+                queryName,
+            },
+            timestamp: new Date().toISOString(),
+            type: 'query',
+            ...(ttlSeconds && { ttl: ttlSeconds }),
+        };
+        DataStore.initialize();
+        DataStore.cache[key] = item;
+        DataStore.save();
+        Logger.info(`DataStore: Resultado da query '${queryName}' armazenado`);
+    }
+    /**
+     * Recupera resultado de consulta de banco
+     */
+    static getQueryResult(queryName) {
+        const result = DataStore.get(`db_query_${queryName}`);
+        return result ? result.data : null;
+    }
+    /**
+     * Armazena screenshot para evidências
+     */
+    static storeScreenshot(name, screenshotData, metadata) {
+        const key = `screenshot_${name}`;
+        DataStore.initialize();
+        DataStore.cache[key] = {
+            value: {
+                data: screenshotData,
+                metadata: metadata || {},
+                timestamp: new Date().toISOString(),
+            },
+            timestamp: new Date().toISOString(),
+            type: 'screenshot',
+        };
+        DataStore.save();
+        Logger.info(`DataStore: Screenshot '${name}' armazenado`);
+    }
+    /**
+     * Recupera screenshot
+     */
+    static getScreenshot(name) {
+        return DataStore.get(`screenshot_${name}`);
+    }
+    /**
+     * Armazena dados temporários com TTL curto
+     */
+    static setTemp(key, value, ttlSeconds = 300) {
+        DataStore.setWithTTL(`temp_${key}`, value, ttlSeconds);
+    }
+    /**
+     * Recupera dados temporários
+     */
+    static getTemp(key) {
+        return DataStore.get(`temp_${key}`);
+    }
+    /**
+     * Força limpeza completa e remove arquivo
+     */
+    static cleanup() {
+        DataStore.cache = {};
+        DataStore.initialized = false;
+        if (DataStore.persistEnabled && existsSync(DataStore.dataFilePath)) {
+            try {
+                unlinkSync(DataStore.dataFilePath);
+            }
+            catch (error) {
+                Logger.error('Erro ao remover o arquivo .test-data-store.json', error);
+            }
+        }
+    }
+    /**
+     * Backup dos dados para outro arquivo
+     */
+    static backup(backupPath) {
+        DataStore.initialize();
+        if (!DataStore.persistEnabled) {
+            Logger.warning('DataStore: Backup ignorado (persistência desabilitada)');
+            return '';
+        }
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const finalBackupPath = backupPath || resolve(process.cwd(), `datastore-backup-${timestamp}.json`);
+        try {
+            writeFileSync(finalBackupPath, JSON.stringify(DataStore.cache, null, 2), 'utf8');
+            Logger.info(`DataStore: Backup criado em ${finalBackupPath}`);
+            return finalBackupPath;
+        }
+        catch (error) {
+            Logger.error('DataStore: Erro ao criar backup', error);
+            throw error;
+        }
+    }
+    /**
+     * Restaura dados de um backup
+     */
+    static restore(backupPath) {
+        try {
+            if (!DataStore.persistEnabled) {
+                Logger.warning('DataStore: Restore ignorado (persistência desabilitada)');
+                return;
+            }
+            if (!existsSync(backupPath)) {
+                throw new Error(`Arquivo de backup não encontrado: ${backupPath}`);
+            }
+            const backupContent = readFileSync(backupPath, 'utf8');
+            const backupData = JSON.parse(backupContent);
+            DataStore.cache = DataStore.migrateOldFormat(backupData);
+            DataStore.save();
+            DataStore.initialized = true;
+            Logger.info(`DataStore: Dados restaurados de ${backupPath}`);
+        }
+        catch (error) {
+            Logger.error('DataStore: Erro ao restaurar backup', error);
+            throw error;
+        }
+    }
+}

package/dist/src/utils/DatabaseInterceptor.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 🚀 Instala interceptação automática em uma classe
+ */
+export declare function installDatabaseInterceptor(targetClass: unknown, className: string): void;
+/**
+ * 🚀 Instala interceptação automática em múltiplas classes
+ */
+export declare function installDatabaseInterceptors(classes: {
+    class: unknown;
+    name: string;
+}[]): void;
+/**
+ * 📋 Lista interceptadores instalados
+ */
+export declare function getInstalledDatabaseInterceptors(): string[];
+/**
+ * 🧹 Remove todos os interceptadores
+ */
+export declare function clearDatabaseInterceptors(): void;