@silasfmartins/testhub 1.0.0

package/dist/src/config/envLoader.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Interface que define as opções disponíveis para o carregamento de variáveis de ambiente
+ */
+interface LoadEnvOptions {
+    /** Define se deve registrar as configurações carregadas no log */
+    logConfig?: boolean;
+    /** Define se os logs devem ser gravados em arquivo */
+    logToFile?: boolean;
+    /** Lista de variáveis de ambiente obrigatórias que devem estar definidas */
+    required?: string[];
+    /** Arquivos .env personalizados para carregar além dos padrões */
+    customEnvFiles?: string[];
+    /** Define se deve carregar arquivos específicos do modo de ambiente (ex: .env.test, .env.production) */
+    loadModeSpecificFiles?: boolean;
+    /** Define se deve aplicar logs silenciosos (para não poluir a saída) */
+    silent?: boolean;
+    /** Define se deve forçar o recarregamento mesmo se já foi carregado */
+    forceReload?: boolean;
+}
+/**
+ * Estado interno do carregador de ambiente
+ */
+interface EnvLoaderState {
+    /** Indica se as variáveis já foram carregadas */
+    isLoaded: boolean;
+    /** Lista de arquivos .env carregados */
+    loadedFiles: string[];
+    /** Quantidade de variáveis carregadas */
+    loadedVarsCount: number;
+    /** Data/hora do último carregamento */
+    lastLoadTime: Date | null;
+    /** Modo de ambiente detectado (ex: preprod, staging) */
+    environmentMode: string | null;
+}
+/**
+ * Carrega variáveis de ambiente a partir de arquivos .env.
+ *
+ * Processa arquivos .env na seguinte ordem de prioridade:
+ * 1. Arquivo .env base (para obter ENV se não estiver definido)
+ * 2. Arquivo específico do ambiente (.env.preprod, .env.staging, etc)
+ * 3. Arquivos personalizados especificados em customEnvFiles
+ *
+ * Usa um mecanismo de bloqueio para evitar carregamentos múltiplos entre processos.
+ *
+ * @param options Configurações para controlar o comportamento de carregamento
+ * @throws {Error} Se ocorrer erro ao carregar variáveis
+ */
+export declare function loadEnv(options?: LoadEnvOptions): void;
+/**
+ * Limpa o arquivo de bloqueio usado para garantir que o ambiente
+ * seja carregado apenas uma vez entre diferentes processos.
+ * Também reseta o estado interno.
+ */
+export declare function cleanupEnvLock(): void;
+/**
+ * Verifica se uma variável de ambiente específica está definida e não está vazia.
+ * @param varName Nome da variável de ambiente.
+ * @returns True se definida e não vazia.
+ */
+export declare function isEnvVarDefined(varName: string): boolean;
+/**
+ * Obtém o valor de uma variável de ambiente ou retorna um valor padrão se não definida.
+ * @param varName Nome da variável de ambiente.
+ * @param defaultValue Valor padrão caso não definida.
+ * @returns Valor da variável ou valor padrão.
+ */
+export declare function getEnvVar(varName: string, defaultValue?: string): string;
+/**
+ * Obtém informações sobre o estado atual do carregamento de ambiente.
+ * @returns Objeto somente leitura com estado do carregador.
+ */
+export declare function getEnvState(): Readonly<EnvLoaderState>;
+/**
+ * Força o recarregamento das variáveis de ambiente.
+ * @param options Opções para o carregamento (opcional).
+ */
+export declare function reloadEnv(options?: LoadEnvOptions): void;
+/**
+ * Verifica se as variáveis de ambiente foram carregadas.
+ * @returns True se carregadas.
+ */
+export declare function isEnvLoaded(): boolean;
+/**
+ * Obtém lista de arquivos .env carregados.
+ * @returns Array de nomes de arquivos carregados.
+ */
+export declare function getLoadedEnvFiles(): string[];
+/**
+ * Obtém o ambiente atual detectado (ex: preprod, staging).
+ * @returns Nome do ambiente ou null.
+ */
+export declare function getCurrentEnvironment(): string | null;
+/**
+ * Valida se todas as variáveis necessárias para um tipo de projeto estão presentes.
+ * @param projectType Tipo do projeto (ex: API, Frontend, Mobile, SSH, Banco, Mixed).
+ * @returns Objeto com isValid, missing e warnings.
+ */
+export declare function validateEnvironmentForProjectType(projectType: string): {
+    isValid: boolean;
+    missing: string[];
+    warnings: string[];
+};
+/**
+ * Utilitário para mascarar valores sensíveis em logs.
+ * @param key Nome da variável.
+ * @param value Valor da variável.
+ * @returns Valor mascarado se sensível, senão valor original.
+ */
+export declare function maskSensitiveValue(key: string, value: string): string;
+/**
+ * Gera relatório de status das variáveis de ambiente.
+ * @returns Objeto com informações do carregamento e validação do projeto.
+ */
+export declare function generateEnvReport(): {
+    loaded: boolean;
+    loadTime: Date | null;
+    filesCount: number;
+    varsCount: number;
+    environment: string | null;
+    files: string[];
+    projectValidation?: ReturnType<typeof validateEnvironmentForProjectType>;
+};
+export {};

package/dist/src/config/envLoader.js

@@ -0,0 +1,361 @@
+import * as dotenv from 'dotenv';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ConfigLogger } from '../utils/ConfigLogger.js';
+/**
+ * Caminho para o diretório de bloqueio usado para prevenir carregamentos múltiplos
+ * das variáveis de ambiente entre diferentes processos.
+ * Usa mkdirSync como operação atômica (mais seguro que writeFileSync).
+ */
+const lockDirPath = path.resolve(process.cwd(), '.env.lock');
+/**
+ * Estado interno para rastreamento do carregamento de variáveis
+ */
+const envState = {
+    isLoaded: false,
+    loadedFiles: [],
+    loadedVarsCount: 0,
+    lastLoadTime: null,
+    environmentMode: null,
+};
+/**
+ * Carrega variáveis de ambiente a partir de arquivos .env.
+ *
+ * Processa arquivos .env na seguinte ordem de prioridade:
+ * 1. Arquivo .env base (para obter ENV se não estiver definido)
+ * 2. Arquivo específico do ambiente (.env.preprod, .env.staging, etc)
+ * 3. Arquivos personalizados especificados em customEnvFiles
+ *
+ * Usa um mecanismo de bloqueio para evitar carregamentos múltiplos entre processos.
+ *
+ * @param options Configurações para controlar o comportamento de carregamento
+ * @throws {Error} Se ocorrer erro ao carregar variáveis
+ */
+export function loadEnv(options = {}) {
+    if (envState.isLoaded && !options.forceReload) {
+        if (!options.silent) {
+            ConfigLogger.info(`Variáveis de ambiente já carregadas (${envState.loadedVarsCount} variáveis de ${envState.loadedFiles.length} arquivos)`);
+        }
+        return;
+    }
+    if (fs.existsSync(lockDirPath) && !options.forceReload) {
+        // Limpar locks stale (mais de 30s) para evitar deadlock
+        try {
+            const stat = fs.statSync(lockDirPath);
+            if (Date.now() - stat.mtimeMs > 30_000) {
+                fs.rmSync(lockDirPath, { recursive: true, force: true });
+            }
+        }
+        catch {
+            // Ignorar erros ao verificar lock stale
+        }
+    }
+    // Adquirir lock atômico via mkdirSync
+    let lockAcquired = false;
+    try {
+        fs.mkdirSync(lockDirPath);
+        lockAcquired = true;
+    }
+    catch {
+        if (!options.forceReload) {
+            if (!options.silent) {
+                ConfigLogger.info('Lock de ambiente já existe, aguardando...');
+            }
+            // Outro processo está carregando — pular ao invés de competir
+            return;
+        }
+    }
+    try {
+        // PRIMEIRA etapa - carregar .env base para obter ENV
+        const baseEnvPath = path.resolve(process.cwd(), '.env');
+        let environmentMode = process.env.NODE_ENV || process.env.ENV;
+        let baseVarsCount = 0;
+        const loadedFiles = [];
+        if (fs.existsSync(baseEnvPath)) {
+            if (!options.silent) {
+                ConfigLogger.info(`Encontrado arquivo .env: ${baseEnvPath}`);
+            }
+            // Usar override: true para garantir que ENV seja lido do arquivo
+            const baseResult = dotenv.config({ path: baseEnvPath, override: true });
+            if (!baseResult.error) {
+                baseVarsCount = Object.keys(baseResult.parsed || {}).length;
+                loadedFiles.push('.env');
+                if (!options.silent) {
+                    ConfigLogger.success(`Variáveis carregadas com sucesso de .env (${baseVarsCount} variáveis)`);
+                }
+                // Obter ENV do arquivo carregado se não estava definido
+                if (!environmentMode && baseResult.parsed?.ENV) {
+                    environmentMode = baseResult.parsed.ENV;
+                    if (!options.silent) {
+                        ConfigLogger.info(`ENV obtido do arquivo .env: ${environmentMode}`);
+                    }
+                }
+            }
+        }
+        if (!options.silent) {
+            const nodeEnv = process.env.NODE_ENV || 'não definido';
+            const envVar = process.env.ENV || environmentMode || 'não definido';
+            ConfigLogger.info(`Carregando variáveis de ambiente (NODE_ENV=${nodeEnv}, ENV=${envVar})`);
+        }
+        let loadedVars = 0;
+        // SEGUNDA etapa - carregar arquivo específico do ambiente se existir
+        if (environmentMode && options.loadModeSpecificFiles !== false) {
+            const envSpecificFile = `.env.${environmentMode.toLowerCase()}`;
+            const envSpecificPath = path.resolve(process.cwd(), envSpecificFile);
+            if (fs.existsSync(envSpecificPath)) {
+                if (!options.silent) {
+                    ConfigLogger.info(`Encontrado arquivo .env: ${envSpecificPath}`);
+                }
+                // Usar override: true para sobrescrever valores do .env base
+                const result = dotenv.config({ path: envSpecificPath, override: true });
+                if (result.error) {
+                    if (!options.silent) {
+                        ConfigLogger.warning(`Erro ao carregar arquivo ${envSpecificFile}: ${result.error.message}`);
+                    }
+                }
+                else {
+                    const varsCount = Object.keys(result.parsed || {}).length;
+                    loadedVars += varsCount;
+                    loadedFiles.push(envSpecificFile);
+                    if (!options.silent) {
+                        ConfigLogger.success(`Variáveis carregadas com sucesso de ${envSpecificFile} (${varsCount} variáveis)`);
+                    }
+                }
+            }
+            else if (!options.silent) {
+                ConfigLogger.warning(`Arquivo específico do ambiente não encontrado: ${envSpecificPath}`);
+            }
+        }
+        // TERCEIRA etapa - carregar arquivos personalizados se especificados
+        if (options.customEnvFiles && options.customEnvFiles.length > 0) {
+            for (const customFile of options.customEnvFiles) {
+                const customPath = path.isAbsolute(customFile)
+                    ? customFile
+                    : path.resolve(process.cwd(), customFile);
+                if (fs.existsSync(customPath)) {
+                    if (!options.silent) {
+                        ConfigLogger.info(`Encontrado arquivo .env personalizado: ${customPath}`);
+                    }
+                    const result = dotenv.config({ path: customPath, override: true });
+                    if (!result.error) {
+                        const varsCount = Object.keys(result.parsed || {}).length;
+                        loadedVars += varsCount;
+                        loadedFiles.push(customFile);
+                        if (!options.silent) {
+                            ConfigLogger.success(`Variáveis carregadas com sucesso de ${customFile} (${varsCount} variáveis)`);
+                        }
+                    }
+                }
+            }
+        }
+        // Verificar ambiente final
+        const finalEnv = process.env.NODE_ENV || process.env.ENV;
+        if (finalEnv) {
+            if (!options.silent) {
+                ConfigLogger.success(`Ambiente configurado: ${finalEnv}`);
+            }
+        }
+        else if (!options.silent) {
+            ConfigLogger.warning('Ambiente não foi definido - usando configurações padrão');
+        }
+        if (loadedFiles.length > 1 && !options.silent) {
+            ConfigLogger.info(`Carregados ${loadedFiles.length} arquivos .env: ${loadedFiles.join(', ')}`);
+            ConfigLogger.info(`Ordem de prioridade: ${[...loadedFiles].reverse().join(' > ')}`);
+        }
+        // Verificar variáveis obrigatórias
+        if (options.required &&
+            Array.isArray(options.required) &&
+            options.required.length > 0) {
+            const missing = options.required.filter((varName) => !process.env[varName]);
+            if (missing.length > 0) {
+                ConfigLogger.warning(`Variáveis obrigatórias não encontradas: ${missing.join(', ')}`);
+            }
+            else if (!options.silent) {
+                ConfigLogger.success('Todas as variáveis obrigatórias estão presentes');
+            }
+        }
+        // Verificação de variáveis sensíveis
+        const sensitiveVarsToCheck = [
+            'DB_PASSWORD',
+            'DB_PASS',
+            'SSH_PASSWORD',
+            'SSH_PASS',
+            'API_KEY',
+            'TOKEN',
+            'SECRET',
+            'PRIVATE_KEY',
+            ...Object.keys(process.env).filter((key) => key.toLowerCase().includes('password') ||
+                key.toLowerCase().includes('secret') ||
+                key.toLowerCase().includes('token') ||
+                key.toLowerCase().includes('key')),
+        ];
+        const presentSensitiveVars = [...new Set(sensitiveVarsToCheck)].filter((varName) => !!process.env[varName]);
+        if (presentSensitiveVars.length > 0 && !options.silent) {
+            ConfigLogger.info(`${presentSensitiveVars.length} variáveis sensíveis configuradas`);
+        }
+        if (options.logConfig === true) {
+            ConfigLogger.logEnvironmentConfig();
+        }
+        // Atualizar estado interno
+        const totalVars = baseVarsCount + loadedVars;
+        envState.isLoaded = true;
+        envState.loadedFiles = loadedFiles;
+        envState.loadedVarsCount = totalVars;
+        envState.lastLoadTime = new Date();
+        envState.environmentMode = finalEnv || null;
+        if (!options.silent) {
+            ConfigLogger.success(`${totalVars} variáveis de ambiente carregadas de ${loadedFiles.length} arquivo(s)`);
+        }
+    }
+    catch (error) {
+        ConfigLogger.error('Erro ao carregar variáveis de ambiente', error);
+        throw error;
+    }
+    finally {
+        // Liberar lock atômico
+        if (lockAcquired) {
+            try {
+                fs.rmSync(lockDirPath, { recursive: true, force: true });
+            }
+            catch {
+                // Ignorar erros ao liberar lock
+            }
+        }
+    }
+}
+/**
+ * Limpa o arquivo de bloqueio usado para garantir que o ambiente
+ * seja carregado apenas uma vez entre diferentes processos.
+ * Também reseta o estado interno.
+ */
+export function cleanupEnvLock() {
+    if (fs.existsSync(lockDirPath)) {
+        try {
+            fs.rmSync(lockDirPath, { recursive: true, force: true });
+            envState.isLoaded = false;
+        }
+        catch (error) {
+            // Ignora erros ao limpar o lock
+        }
+    }
+}
+/**
+ * Verifica se uma variável de ambiente específica está definida e não está vazia.
+ * @param varName Nome da variável de ambiente.
+ * @returns True se definida e não vazia.
+ */
+export function isEnvVarDefined(varName) {
+    return !!process.env[varName] && process.env[varName].trim() !== '';
+}
+/**
+ * Obtém o valor de uma variável de ambiente ou retorna um valor padrão se não definida.
+ * @param varName Nome da variável de ambiente.
+ * @param defaultValue Valor padrão caso não definida.
+ * @returns Valor da variável ou valor padrão.
+ */
+export function getEnvVar(varName, defaultValue = '') {
+    return process.env[varName] || defaultValue;
+}
+/**
+ * Obtém informações sobre o estado atual do carregamento de ambiente.
+ * @returns Objeto somente leitura com estado do carregador.
+ */
+export function getEnvState() {
+    return { ...envState };
+}
+/**
+ * Força o recarregamento das variáveis de ambiente.
+ * @param options Opções para o carregamento (opcional).
+ */
+export function reloadEnv(options = {}) {
+    loadEnv({ ...options, forceReload: true });
+}
+/**
+ * Verifica se as variáveis de ambiente foram carregadas.
+ * @returns True se carregadas.
+ */
+export function isEnvLoaded() {
+    return envState.isLoaded;
+}
+/**
+ * Obtém lista de arquivos .env carregados.
+ * @returns Array de nomes de arquivos carregados.
+ */
+export function getLoadedEnvFiles() {
+    return [...envState.loadedFiles];
+}
+/**
+ * Obtém o ambiente atual detectado (ex: preprod, staging).
+ * @returns Nome do ambiente ou null.
+ */
+export function getCurrentEnvironment() {
+    return envState.environmentMode;
+}
+/**
+ * Valida se todas as variáveis necessárias para um tipo de projeto estão presentes.
+ * @param projectType Tipo do projeto (ex: API, Frontend, Mobile, SSH, Banco, Mixed).
+ * @returns Objeto com isValid, missing e warnings.
+ */
+export function validateEnvironmentForProjectType(projectType) {
+    const validationRules = {
+        API: ['BASE_URL_API', 'API_URL'],
+        Frontend: ['BASE_URL'],
+        Mobile: ['USE_MOBILE'],
+        SSH: ['SSH_HOST', 'SSH_USER'],
+        Banco: ['DB_HOST', 'DB_USER', 'DB_PASS', 'DB_SERVICE'],
+        Mixed: [],
+    };
+    const requiredVars = validationRules[projectType] || [];
+    const missing = requiredVars.filter((varName) => !isEnvVarDefined(varName));
+    const warnings = [];
+    if (projectType === 'Banco' && !process.env.DB_PORT) {
+        warnings.push('DB_PORT não definido, usando porta padrão');
+    }
+    if (projectType === 'SSH' && !process.env.SSH_PORT) {
+        warnings.push('SSH_PORT não definido, usando porta 22');
+    }
+    return {
+        isValid: missing.length === 0,
+        missing,
+        warnings,
+    };
+}
+/**
+ * Utilitário para mascarar valores sensíveis em logs.
+ * @param key Nome da variável.
+ * @param value Valor da variável.
+ * @returns Valor mascarado se sensível, senão valor original.
+ */
+export function maskSensitiveValue(key, value) {
+    const sensitivePatterns = [
+        'password',
+        'pass',
+        'secret',
+        'token',
+        'key',
+        'auth',
+    ];
+    const isSensitive = sensitivePatterns.some((pattern) => key.toLowerCase().includes(pattern));
+    if (isSensitive) {
+        return value.length > 0 ? '********' : '';
+    }
+    return value;
+}
+/**
+ * Gera relatório de status das variáveis de ambiente.
+ * @returns Objeto com informações do carregamento e validação do projeto.
+ */
+export function generateEnvReport() {
+    const projectType = process.env.PROJECT_TYPE || 'unknown';
+    return {
+        loaded: envState.isLoaded,
+        loadTime: envState.lastLoadTime,
+        filesCount: envState.loadedFiles.length,
+        varsCount: envState.loadedVarsCount,
+        environment: envState.environmentMode,
+        files: [...envState.loadedFiles],
+        projectValidation: projectType !== 'unknown'
+            ? validateEnvironmentForProjectType(projectType)
+            : undefined,
+    };
+}

package/dist/src/config/jest-safe-setup.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 🔧 AutoCore Jest-Safe Setup - Configuração Avançada Jest/Vitest
+ * @silasfmartins/testhub v1.1.48
+ *
+ * Sistema automático de resolução de conflitos Jest/Vitest para projetos
+ * que utilizam ambos os padrões .test.ts e .spec.ts
+ *
+ * OPÇÃO B COMPLETA: 8 Métodos Avançados de Resolução
+ */
+/**
+ * 🛡️ Função Principal: Resolver Conflitos Jest/Vitest
+ *
+ * Implementa 8 métodos de proteção para evitar:
+ * - TypeError: Cannot redefine property: Symbol($$jest-matchers-object)
+ * - Conflitos entre expect() do Jest vs Vitest
+ * - Problemas de Symbol registry
+ * - Redefinição de propriedades globais
+ */
+export declare function resolveJestVitestConflict(): void;