@silasfmartins/testhub 1.0.0

package/dist/src/helpers/BancoActions.js

@@ -0,0 +1,581 @@
+import { createRequire } from 'module';
+import oracledb from 'oracledb';
+import { BaseError, IntegrationError, ValidationError, } from '../functions/errors/index.js';
+import { AutoDocs } from '../hubdocs/HubDocs.js';
+import { TestContext } from '../testContext/TestContext.js';
+import { UnifiedReportManager } from '../testContext/UnifiedReportManager.js';
+import { Logger } from '../utils/Logger.js';
+import { EnviromentHelper } from './EnviromentHelper.js';
+// 🤖 IMPORTAÇÃO CRÍTICA: Força inicialização do StatementTracker para projetos Banco
+import '../hubdocs/StatementTracker.js';
+import { StatementTracker } from '../hubdocs/StatementTracker.js';
+// 🚫 REMOVIDO: import { installDatabaseInterceptor } from '../utils/DatabaseInterceptor.js'
+const require = createRequire(import.meta.url);
+/**
+ * Tipos suportados para seleção de coluna.
+ */
+export const BancoType = {
+    LONG: 'LONG',
+    VARCHAR: 'VARCHAR',
+    DOUBLE: 'DOUBLE',
+    INTEGER: 'INTEGER',
+    DATE: 'DATE',
+};
+/**
+ * Classe de ações utilitárias para automação de banco Oracle.
+ * Inspirada no padrão Actions do Qandalf/Java.
+ * Todos métodos registram logs e metadados no UnifiedReportManager.
+ *
+ * ✅ CONSOLIDADO: Funcionalidades de BancoHelper foram integradas aqui.
+ */
+export class BancoActions {
+    static successCount = 0;
+    static failureCount = 0;
+    static inicioExecucao;
+    static fimExecucao;
+    static queryExecutadas = 0;
+    /**
+     * Registra o início da execução para relatórios.
+     */
+    static registrarInicioExecucao() {
+        BancoActions.inicioExecucao = new Date();
+        Logger.info(`⏱️ Início da execução de Banco registrado: ${BancoActions.inicioExecucao.toLocaleTimeString()}`);
+    }
+    /**
+     * Registra o fim da execução para relatórios.
+     */
+    static registrarFimExecucao() {
+        BancoActions.fimExecucao = new Date();
+        if (BancoActions.inicioExecucao) {
+            const duration = (BancoActions.fimExecucao.getTime() -
+                BancoActions.inicioExecucao.getTime()) /
+                1000;
+            Logger.info(`⏱️ Execução de Banco concluída em ${duration.toFixed(2)}s`);
+        }
+    }
+    /**
+     * Registra um evento de log para o teste atual.
+     * @param message Mensagem de log.
+     */
+    static logEvent(message) {
+        const testInfo = TestContext.getSafeTestInfo();
+        if (testInfo?.title) {
+            try {
+                UnifiedReportManager.adicionarLog(testInfo.title, message);
+            }
+            catch (error) {
+                Logger.info(message);
+            }
+        }
+        else {
+            Logger.info(message);
+        }
+        // Log tradicional para annotations
+        if (testInfo &&
+            testInfo.annotations &&
+            Array.isArray(testInfo.annotations)) {
+            testInfo.annotations.push({ type: 'log', description: message });
+        }
+    }
+    /**
+     * Marca que o BancoActions foi utilizado automaticamente.
+     * @private
+     */
+    static marcarUsoAutomatico() {
+        if (!BancoActions.inicioExecucao) {
+            BancoActions.registrarInicioExecucao();
+        }
+    }
+    /**
+     * Executa uma query Oracle e retorna os resultados (método base).
+     * Registra logs, métricas e metadados no UnifiedReportManager.
+     * @param query Query SQL a ser executada.
+     * @param options Opções de execução (autoCommit, bindParams, outFormat).
+     * @returns Promise<Array<unknown>> Array de resultados.
+     */
+    static async executarQuery(query, options = {}) {
+        const startTime = Date.now();
+        // 🆕 Registrar statement no StatementTracker
+        let statementTimestamp = null;
+        try {
+            const { StatementTracker } = require('../hubdocs/StatementTracker.js');
+            statementTimestamp = StatementTracker.startStatement('BancoActions', `executarQuery: ${query.substring(0, 50)}...`);
+        }
+        catch (error) {
+            Logger.warning(`Não foi possível registrar statement no StatementTracker: ${error}`);
+        }
+        const execOptions = {
+            outFormat: oracledb.OUT_FORMAT_OBJECT,
+            ...options,
+        };
+        let connection;
+        const queryTimestamp = new Date().toISOString();
+        try {
+            BancoActions.marcarUsoAutomatico();
+            const bindParamsForAutoDocs = Array.isArray(options.bindParams)
+                ? options.bindParams
+                : options.bindParams
+                    ? Object.values(options.bindParams)
+                    : [];
+            AutoDocs.interceptDB(query, bindParamsForAutoDocs, 'oracle', 'Execução de Query Oracle', 'BancoActions');
+            if (process.env.NODE_ORACLEDB_DRIVER_MODE === 'thick') {
+                oracledb.initOracleClient({ libDir: process.env.ORACLE_CLIENT_PATH });
+            }
+            const connectionString = EnviromentHelper.buildConnectionString();
+            const connectionParts = connectionString.match(/^([^/]+)\/([^@]+)@(.+)$/);
+            if (!connectionParts) {
+                throw new IntegrationError('INVALID_CONNECTION_STRING', 'Invalid connection string format', 'String de conexão inválida. Formato esperado: user/password@connectString', undefined, { metadata: { connectionString } });
+            }
+            connection = await oracledb.getConnection({
+                user: connectionParts[1],
+                password: connectionParts[2],
+                connectString: connectionParts[3],
+            });
+            const queryTruncated = query.slice(0, 100) + (query.length > 100 ? '...' : '');
+            BancoActions.logEvent(`🔍 Executando query: ${queryTruncated}`);
+            const bindParams = options.bindParams || {};
+            const result = await connection.execute(query, bindParams, {
+                autoCommit: options.autoCommit,
+                outFormat: options.outFormat,
+            });
+            const duration = (Date.now() - startTime) / 1000;
+            const rowCount = result.rows?.length || 0;
+            AutoDocs.updateDBResult(query, queryTimestamp, true, duration * 1000, undefined, rowCount);
+            try {
+                const queryTruncatedForAction = query.slice(0, 200) + (query.length > 200 ? '...' : '');
+                StatementTracker.recordAction('DB', queryTruncatedForAction, true, duration * 1000, {
+                    query: query.slice(0, 500),
+                });
+            }
+            catch (error) {
+                // Falha silenciosa
+            }
+            BancoActions.queryExecutadas++;
+            BancoActions.logEvent(`✅ Query executada com sucesso em ${duration.toFixed(2)}s - ${rowCount} registros retornados`);
+            // 🆕 Finalizar statement com sucesso
+            if (statementTimestamp) {
+                try {
+                    const { StatementTracker } = require('../hubdocs/StatementTracker.js');
+                    StatementTracker.finishStatement(statementTimestamp, true, `✅ Query executada: ${rowCount} registros em ${duration.toFixed(2)}s`);
+                }
+                catch (error) {
+                    Logger.warning(`Não foi possível finalizar statement no StatementTracker: ${error}`);
+                }
+            }
+            const testInfo = TestContext.getSafeTestInfo();
+            if (testInfo?.title) {
+                try {
+                    const currentMetadata = UnifiedReportManager.getMetrics().testes.find((t) => t.nome === testInfo.title)?.metadata || {};
+                    UnifiedReportManager.setTestMetadata(testInfo.title, {
+                        ...currentMetadata,
+                        queries: (currentMetadata.queries || 0) + 1,
+                        totalRecords: (currentMetadata.totalRecords || 0) + rowCount,
+                        lastQueryDuration: duration,
+                    });
+                }
+                catch {
+                    // Ignorar
+                }
+            }
+            return result.rows || [];
+        }
+        catch (error) {
+            const duration = (Date.now() - startTime) / 1000;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            AutoDocs.updateDBResult(query, queryTimestamp, false, duration * 1000, errorMessage);
+            try {
+                const queryTruncatedForAction = query.slice(0, 200) + (query.length > 200 ? '...' : '');
+                StatementTracker.recordAction('DB', queryTruncatedForAction, false, duration * 1000, {
+                    query: query.slice(0, 500),
+                });
+            }
+            catch (error) {
+                // Falha silenciosa
+            }
+            BancoActions.logEvent(`❌ Erro ao executar query em ${duration.toFixed(2)}s: ${errorMessage}`);
+            // 🆕 Finalizar statement com erro
+            if (statementTimestamp) {
+                try {
+                    const { StatementTracker } = require('../hubdocs/StatementTracker.js');
+                    StatementTracker.finishStatement(statementTimestamp, false, `❌ Erro na query: ${errorMessage}`);
+                }
+                catch (error) {
+                    Logger.warning(`Não foi possível finalizar statement no StatementTracker: ${error}`);
+                }
+            }
+            if (error instanceof BaseError) {
+                throw error;
+            }
+            throw new IntegrationError('DATABASE_QUERY_FAILED', `Database query failed: ${errorMessage}`, `Falha ao executar query: ${errorMessage}`, error instanceof Error ? error : new Error(String(error)), { metadata: { query: query.slice(0, 500), duration } });
+        }
+        finally {
+            if (connection) {
+                try {
+                    await connection.close();
+                }
+                catch (err) {
+                    BancoActions.logEvent(`⚠️ Erro ao fechar conexão: ${err}`);
+                }
+            }
+        }
+    }
+    /**
+     * Executa uma instrução SQL (DDL/DML) com descrição.
+     * Registra logs e metadados no UnifiedReportManager.
+     * @param descriptionToAction Descrição da ação.
+     * @param sql SQL a ser executado.
+     * @returns Promise<void>
+     */
+    static async execute(descriptionToAction, sql) {
+        const startTime = Date.now();
+        Logger.info(`🔶 Executando: ${descriptionToAction} >> ${sql}`);
+        BancoActions.logToUnified(`🔶 ${descriptionToAction} >> ${sql}`);
+        try {
+            await BancoActions.executarQuery(sql);
+            const duration = Date.now() - startTime;
+            Logger.success(`✅ ${descriptionToAction} executada com sucesso (${duration}ms)`);
+            BancoActions.logToUnified(`✅ ${descriptionToAction} executada com sucesso (${duration}ms)`);
+            BancoActions.addActionMetadata('Executar', true, duration);
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            Logger.error(`❌ Erro ao executar: ${descriptionToAction}`, error);
+            BancoActions.logToUnified(`❌ Erro ao executar: ${descriptionToAction} - ${error}`);
+            BancoActions.addActionMetadata('Executar', false, duration);
+            if (error instanceof BaseError) {
+                throw error;
+            }
+            throw new IntegrationError('DATABASE_EXECUTION_FAILED', `Database execution failed: ${error}`, `Falha na execução do banco: ${error}`, error instanceof Error ? error : new Error(String(error)), { metadata: { action: descriptionToAction, duration } });
+        }
+    }
+    /**
+     * Executa uma instrução SQL de consulta e retorna os resultados.
+     * Registra logs e metadados no UnifiedReportManager.
+     * @param sql SQL de consulta.
+     * @returns Promise<Array<any>> Array de resultados.
+     */
+    static async executeQuery(sql) {
+        const startTime = Date.now();
+        BancoActions.logToUnified(`🔍 Executando executeQuery: ${sql}`);
+        // ✅ REMOVIDO: Interceptação duplicada - executarQuery já faz isso
+        // AutoDocs.interceptDB(sql, [], 'oracle')
+        try {
+            const result = await BancoActions.executarQuery(sql);
+            const duration = Date.now() - startTime;
+            BancoActions.logToUnified(`✅ executeQuery executado (${duration}ms) - ${result.length} registros`);
+            BancoActions.addActionMetadata('Select', true, duration);
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            BancoActions.logToUnified(`❌ Erro no executeQuery: ${error}`);
+            BancoActions.addActionMetadata('Select', false, duration);
+            if (error instanceof BaseError) {
+                throw error;
+            }
+            throw new IntegrationError('DATABASE_QUERY_FAILED', `Database query failed: ${error}`, `Falha na consulta do banco: ${error}`, error instanceof Error ? error : new Error(String(error)), { metadata: { sql, duration } });
+        }
+    }
+    /**
+     * Executa uma instrução SQL de atualização com descrição.
+     * Registra logs e metadados no UnifiedReportManager.
+     * @param descriptionToAction Descrição da ação.
+     * @param sql SQL de update.
+     * @returns Promise<number> Número de linhas afetadas.
+     */
+    static async update(descriptionToAction, sql) {
+        const startTime = Date.now();
+        BancoActions.logToUnified(`🔄 ${descriptionToAction} >> ${sql}`);
+        try {
+            const result = await BancoActions.executarQuery(sql);
+            const affected = Array.isArray(result) ? result.length : 0;
+            const duration = Date.now() - startTime;
+            BancoActions.logToUnified(`✅ UPDATE executado (${duration}ms) - ${affected} linhas`);
+            BancoActions.addActionMetadata('Update', true, duration);
+            return affected;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            BancoActions.logToUnified(`❌ Erro no UPDATE: ${error}`);
+            BancoActions.addActionMetadata('Update', false, duration);
+            if (error instanceof BaseError) {
+                throw error;
+            }
+            throw new IntegrationError('DATABASE_UPDATE_FAILED', `Database update failed: ${error}`, `Falha no update do banco: ${error}`, error instanceof Error ? error : new Error(String(error)), { metadata: { sql, duration } });
+        }
+    }
+    /**
+     * Executa uma instrução SQL de seleção e retorna os resultados.
+     * @param sql SQL de seleção.
+     * @returns Promise<Array<any>> Array de resultados.
+     */
+    static async select(sql) {
+        return BancoActions.executeQuery(sql);
+    }
+    /**
+     * Executa uma instrução SQL de seleção e retorna o valor de uma coluna, convertido para o tipo especificado.
+     * @param sql SQL de seleção.
+     * @param column Nome da coluna.
+     * @param type Tipo do valor (BancoType).
+     * @returns Promise<unknown> Valor da coluna convertido.
+     * @throws {Error} Se não houver resultados.
+     */
+    static async selectColumn(sql, column, type) {
+        const results = await BancoActions.executeQuery(sql);
+        if (!results || results.length === 0) {
+            throw new ValidationError('DATABASE_NO_RESULTS', `No results found for query: ${sql}`, `Nenhum resultado encontrado para a query: ${sql}`, undefined, { metadata: { sql, column, type } });
+        }
+        const row = results[0];
+        const value = row[column];
+        switch (type) {
+            case BancoType.VARCHAR:
+                return value != null ? String(value) : null;
+            case BancoType.DOUBLE:
+                return value != null ? Number(value) : null;
+            case BancoType.INTEGER:
+                return value != null ? Number.parseInt(value, 10) : null;
+            case BancoType.LONG:
+                return value != null ? Number(value) : null;
+            case BancoType.DATE:
+                return value != null ? new Date(value) : null;
+            default:
+                return value;
+        }
+    }
+    /**
+     * Pausa a execução por um tempo fixo em segundos.
+     * @param time Tempo em segundos.
+     * @returns Promise<void>
+     */
+    static async esperarPorTempo(time) {
+        BancoActions.logToUnified(`⏳ Esperando ${time}s`);
+        await new Promise((resolve) => setTimeout(resolve, time * 1000));
+        BancoActions.logToUnified(`⏱️ Espera de ${time}s concluída`);
+    }
+    /**
+     * Relata uma tabela de resultados no log em formato HTML.
+     * @param registros Array de registros.
+     * @returns void
+     */
+    static reportarTabela(registros) {
+        if (!registros || registros.length === 0) {
+            BancoActions.logToUnified('⚠️ Nenhum registro para exibir na tabela');
+            return;
+        }
+        const colunas = Object.keys(registros[0]);
+        let html = '<div style="overflow-x:auto;max-width:500px;"><span>Dados retornados:</span><table><thead><tr>';
+        for (const col of colunas) {
+            html += `<th style="word-break:normal;border:2px solid #dee2e6;">${col}</th>`;
+        }
+        html += '</tr></thead><tbody>';
+        for (const row of registros) {
+            html += '<tr>';
+            for (const col of colunas) {
+                html += `<td style="word-break:normal;border:2px solid #dee2e6;">${row[col] ?? '&#91;null&#93;'}</td>`;
+            }
+            html += '</tr>';
+        }
+        html += '</tbody></table></div>';
+        BancoActions.logToUnified(html);
+    }
+    /**
+     * 🆕 NOVO: Obtém informações da conexão atual de forma segura.
+     * @returns String com informações da conexão (sem senha).
+     */
+    static getConnectionInfo() {
+        try {
+            const { DB_USER, DB_HOST, DB_PORT, DB_SERVICE, ENV } = process.env;
+            return `Ambiente: ${ENV || 'não definido'}, Usuário: ${DB_USER}, Host: ${DB_HOST}:${DB_PORT}, Serviço: ${DB_SERVICE}`;
+        }
+        catch (error) {
+            return 'Informações de conexão não disponíveis';
+        }
+    }
+    /**
+     * 🆕 NOVO: Exibe detalhes dos resultados de uma consulta.
+     * @param resultado Array de resultados da consulta.
+     */
+    static async exibirDetalhesResultados(resultado) {
+        if (!resultado || resultado.length === 0) {
+            Logger.warning('Nenhum resultado encontrado.');
+            BancoActions.logToUnified('⚠️ Nenhum resultado encontrado na consulta');
+            return;
+        }
+        const message = `Serviço executado com sucesso! Encontrados ${resultado.length} registros.`;
+        Logger.success(message);
+        BancoActions.logToUnified(`✅ ${message}`);
+        // Exibir até 3 registros no console
+        Logger.info('\n📋 Primeiros 3 registros:');
+        resultado.slice(0, 3).forEach((registro, index) => {
+            Logger.info(`\n--- Registro ${index + 1} ---`);
+            Object.entries(registro).forEach(([chave, valor]) => {
+                Logger.info(`${chave}: ${valor}`);
+            });
+        });
+    }
+    /**
+     * 🆕 NOVO: Executa um serviço de banco com logs automáticos.
+     * @param descricao Descrição do serviço sendo executado.
+     * @param servico Função que executa o serviço.
+     * @returns Promise com resultado do serviço.
+     */
+    static async executarServico(descricao, servico) {
+        const startTime = Date.now();
+        // Log inicial
+        Logger.info(`🚀 Executando serviço: ${descricao}`);
+        BancoActions.logToUnified(`🚀 Executando serviço: ${descricao}`);
+        BancoActions.logToUnified(`🔗 Conexão: ${BancoActions.getConnectionInfo()}`);
+        try {
+            const resultado = await servico();
+            const duration = Date.now() - startTime;
+            // Log de sucesso
+            Logger.success(`✅ ${descricao} executado com sucesso (${duration}ms)`);
+            BancoActions.logToUnified(`✅ ${descricao} executado com sucesso (${duration}ms)`);
+            BancoActions.addActionMetadata('Serviço', true, duration);
+            // Se resultado é array, mostrar detalhes
+            if (Array.isArray(resultado)) {
+                await BancoActions.exibirDetalhesResultados(resultado);
+            }
+            return resultado;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            // Log de erro
+            Logger.error(`❌ Erro ao executar ${descricao}:`, error);
+            BancoActions.logToUnified(`❌ Erro ao executar ${descricao}: ${error}`);
+            BancoActions.addActionMetadata('Serviço', false, duration);
+            if (error instanceof BaseError) {
+                throw error;
+            }
+            throw new IntegrationError('SERVICE_EXECUTION_FAILED', `Service execution failed: ${error}`, `Falha na execução do serviço: ${error}`, error instanceof Error ? error : new Error(String(error)), { metadata: { descricao, duration } });
+        }
+    }
+    /**
+     * Valida se dois valores são iguais.
+     * Registra sucesso ou falha nos logs e incrementa métricas.
+     * @param actual Valor atual.
+     * @param expected Valor esperado.
+     * @param message Mensagem descritiva da validação.
+     * @throws {Error} Se os valores não forem iguais.
+     */
+    static validateEquals(actual, expected, message) {
+        if (actual !== expected) {
+            BancoActions.failureCount++;
+            BancoActions.logEvent(`❌ ${message}: esperado ${expected}, obtido ${actual}`);
+            throw new ValidationError('VALIDATION_FAILED', `Validation failed: expected ${expected}, got ${actual}`, `${message}: esperado ${expected}, obtido ${actual}`, undefined, { metadata: { actual, expected, message } });
+        }
+        BancoActions.successCount++;
+        BancoActions.logEvent(`✅ ${message}: esperado ${expected}, obtido ${actual}`);
+    }
+    /**
+     * Verifica se o BancoActions foi utilizado.
+     * @returns true se houve queries executadas ou início de execução registrado.
+     */
+    static foiUtilizado() {
+        return !!BancoActions.inicioExecucao || BancoActions.queryExecutadas > 0;
+    }
+    /**
+     * Registra duração do teste para relatórios.
+     * @param nome Nome do teste.
+     * @param duracao Duração em segundos.
+     */
+    static registrarDuracaoDoTeste(nome, duracao) {
+        const testInfo = TestContext.getSafeTestInfo();
+        if (testInfo?.title) {
+            try {
+                UnifiedReportManager.setTestDuration(testInfo.title, duracao);
+            }
+            catch (error) {
+                Logger.warning(`Não foi possível registrar duração do teste: ${error}`);
+            }
+        }
+    }
+    /**
+     * Obtém métricas do BancoActions.
+     * @returns Objeto com queryExecutadas, sucessos, erros e duracaoTotal.
+     */
+    static getMetrics() {
+        const duracao = BancoActions.inicioExecucao && BancoActions.fimExecucao
+            ? (BancoActions.fimExecucao.getTime() -
+                BancoActions.inicioExecucao.getTime()) /
+                1000
+            : 0;
+        return {
+            queryExecutadas: BancoActions.queryExecutadas,
+            sucessos: BancoActions.successCount,
+            erros: BancoActions.failureCount,
+            duracaoTotal: duracao,
+        };
+    }
+    /**
+     * Método unificado para anexar relatórios (delegado para UnifiedReportManager).
+     */
+    static async anexarRelatorioFinal() {
+        try {
+            await UnifiedReportManager.finalizarTeste();
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao anexar relatórios finais via UnifiedReportManager', error);
+        }
+    }
+    /**
+     * Limpa todos os dados para nova execução.
+     */
+    static limparTudo() {
+        BancoActions.successCount = 0;
+        BancoActions.failureCount = 0;
+        BancoActions.queryExecutadas = 0;
+        BancoActions.inicioExecucao = undefined;
+        BancoActions.fimExecucao = undefined;
+    }
+    /**
+     * Adiciona log ao UnifiedReportManager para o teste atual.
+     * @private
+     * @param message Mensagem de log a ser registrada.
+     */
+    static logToUnified(message) {
+        const testInfo = TestContext.getSafeTestInfo();
+        if (testInfo?.title) {
+            try {
+                UnifiedReportManager.adicionarLog(testInfo.title, message);
+            }
+            catch {
+                // Silenciosamente ignorar se o contexto não estiver configurado
+            }
+        }
+    }
+    /**
+     * Registra metadados de ação no UnifiedReportManager.
+     * @private
+     * @param actionType Tipo da ação executada.
+     * @param success Indica se a ação foi bem-sucedida.
+     * @param duration Duração da ação em milissegundos.
+     */
+    static addActionMetadata(actionType, success, duration) {
+        const testInfo = TestContext.getSafeTestInfo();
+        if (testInfo?.title) {
+            try {
+                UnifiedReportManager.setTestMetadata(testInfo.title, {
+                    actionType,
+                    success,
+                    duration,
+                });
+            }
+            catch {
+                // Silenciosamente ignorar se o contexto não estiver configurado
+            }
+        }
+    }
+}
+// 🚫 AUTO-ATIVAÇÃO REMOVIDA: BancoActions são métodos internos que não devem ser interceptados
+// BancoActions.execute(), .select(), etc. não são CTs válidos e devem ser filtrados
+// A interceptação foi removida para evitar falsos CTs nos relatórios
+// CTs reais vêm das classes Statement (StatementsBanco, etc.) via InterceptacaoMagica.ts
+// CÓDIGO REMOVIDO:
+// try {
+//   installDatabaseInterceptor(BancoActions, 'BancoActions')
+// } catch (error) {
+//   if (process.env.AUTOCORE_DEBUG_LOGS === 'true') {
+//     process.stderr.write(`[DatabaseInterceptor] Falha na auto-ativação BancoActions: ${String(error)}\n`)
+//   }
+// }

package/dist/src/helpers/EnviromentHelper.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Classe utilitária para manipulação de strings de conexão Oracle a partir das variáveis de ambiente.
+ */
+export declare class EnviromentHelper {
+    /**
+     * Constrói a string de conexão Oracle a partir das variáveis de ambiente.
+     * @returns A string de conexão no formato: user/pass@host:port/service
+     * @throws {Error} Se algum parâmetro necessário não estiver definido no .env.
+     */
+    static buildConnectionString(): string;
+    /**
+     * Retorna a string de conexão com a senha mascarada (para logs).
+     * @param connectionString String de conexão original.
+     * @returns String de conexão com a senha oculta.
+     */
+    static mascaraSenha(connectionString: string): string;
+}

package/dist/src/helpers/EnviromentHelper.js

@@ -0,0 +1,66 @@
+/**
+ * Classe utilitária para manipulação de strings de conexão Oracle a partir das variáveis de ambiente.
+ */
+export class EnviromentHelper {
+    /**
+     * Constrói a string de conexão Oracle a partir das variáveis de ambiente.
+     * @returns A string de conexão no formato: user/pass@host:port/service
+     * @throws {Error} Se algum parâmetro necessário não estiver definido no .env.
+     */
+    static buildConnectionString() {
+        // 🎯 INJETAR credenciais Banco do AutoCore Hub se sistema foi selecionado
+        let dbUser;
+        let dbPass;
+        let dbHost;
+        let dbPort;
+        let dbService;
+        // ✅ CORRIGIDO: Só injetar configurações de Banco do AutoCore Hub se o CT atual tem sistema configurado
+        // ✅ NOVO: Obter sistema do CT atual via StatementTracker
+        let hasSystemConfigured = null;
+        try {
+            const { StatementTracker } = require('../hubdocs/StatementTracker.js');
+            hasSystemConfigured = StatementTracker.getCurrentCTSystem();
+        }
+        catch {
+            // Ignora se não conseguir importar
+        }
+        if (hasSystemConfigured) {
+            try {
+                // Importação dinâmica para evitar dependência circular
+                const { DynamicConfigManager, } = require('../testhub/DynamicConfigManager.js');
+                const configManager = DynamicConfigManager.getInstance();
+                const dbConfig = configManager.getDatabaseConfig();
+                if (dbConfig && dbConfig.host) {
+                    dbUser = dbConfig.user;
+                    dbPass = dbConfig.password;
+                    dbHost = dbConfig.host;
+                    dbPort = String(dbConfig.port || 1521);
+                    dbService = dbConfig.serviceName;
+                    const { Logger } = require('../utils/Logger.js');
+                    Logger.info(`🎯 [AutoCore Hub] Banco config injetado para sistema "${hasSystemConfigured}": ${dbHost}:${dbPort}/${dbService} (user: ${dbUser})`);
+                }
+            }
+            catch {
+                // Ignora se não conseguir importar
+            }
+        }
+        // Fallback para process.env se não houver config do AutoCore Hub OU se setSystem() não foi chamado
+        const DB_USER = dbUser || process.env.DB_USER;
+        const DB_PASS = dbPass || process.env.DB_PASS;
+        const DB_HOST = dbHost || process.env.DB_HOST;
+        const DB_PORT = dbPort || process.env.DB_PORT;
+        const DB_SERVICE = dbService || process.env.DB_SERVICE;
+        if (!(DB_USER && DB_PASS && DB_HOST && DB_PORT && DB_SERVICE)) {
+            throw new Error('Parâmetros de conexão incompletos no arquivo .env');
+        }
+        return `${DB_USER}/${DB_PASS}@${DB_HOST}:${DB_PORT}/${DB_SERVICE}`;
+    }
+    /**
+     * Retorna a string de conexão com a senha mascarada (para logs).
+     * @param connectionString String de conexão original.
+     * @returns String de conexão com a senha oculta.
+     */
+    static mascaraSenha(connectionString) {
+        return connectionString.replace(/\/([^@]+)@/, '/********@');
+    }
+}