@silasfmartins/testhub 1.0.0

package/dist/src/infrastructure/adapters/OracleAdapter.js

@@ -0,0 +1,388 @@
+/**
+ * @fileoverview Adaptador Oracle para operações de banco de dados seguindo padrões DDD
+ * @module Infrastructure/Adapters
+ */
+import { DatabaseConfigSchema, SchemaValidator, } from '../../domain/schemas/ValidationSchemas.js';
+import { IntegrationError } from '../../functions/errors/IntegrationError.js';
+import { ValidationError } from '../../functions/errors/ValidationError.js';
+/**
+ * Adaptador que integra oracledb com a arquitetura do AutoCore
+ * Implementa a interface IDatabaseClient usando oracledb
+ */
+export class OracleAdapter {
+    connection = null;
+    pool = null;
+    oracledb = null;
+    connected = false;
+    connectionConfig = null;
+    inTransaction = false;
+    constructor() {
+        // Lazy loading da biblioteca oracledb
+    }
+    /**
+     * Conecta ao banco Oracle
+     */
+    async connect(config) {
+        try {
+            // Validação usando Zod
+            const validConfig = SchemaValidator.validate(DatabaseConfigSchema, config);
+            // Lazy loading da biblioteca Oracle
+            if (!this.oracledb) {
+                try {
+                    this.oracledb = await import('oracledb');
+                    // Configurar oracledb
+                    this.oracledb.outFormat = this.oracledb.OUT_FORMAT_OBJECT;
+                    this.oracledb.autoCommit = false;
+                }
+                catch (error) {
+                    // Fallback para implementação mock se oracledb não estiver disponível
+                    this.oracledb = {
+                        getConnection: async () => ({
+                            execute: async () => ({ rows: [], rowsAffected: 0 }),
+                            close: async () => { },
+                            commit: async () => { },
+                            rollback: async () => { },
+                        }),
+                        createPool: async () => ({
+                            getConnection: async () => this.oracledb.getConnection(),
+                            close: async () => { },
+                        }),
+                        OUT_FORMAT_OBJECT: 'object',
+                    };
+                }
+            }
+            // Configurar conexão
+            const connectionConfig = {
+                user: validConfig.username,
+                password: validConfig.password,
+                connectString: `${validConfig.host}:${validConfig.port}/${validConfig.database}`,
+                connectTimeout: validConfig.connectionTimeout || 30,
+                poolMin: config.poolMin || 1,
+                poolMax: config.poolMax || 10,
+            };
+            // Criar pool de conexões
+            this.pool = await this.oracledb.createPool(connectionConfig);
+            // Testar conexão
+            this.connection = await this.pool.getConnection();
+            this.connected = true;
+            this.connectionConfig = validConfig;
+        }
+        catch (error) {
+            const err = error;
+            this.connected = false;
+            this.connectionConfig = null;
+            throw IntegrationError.databaseConnectionFailed(`${config.host}:${config.port}/${config.database}`, err);
+        }
+    }
+    /**
+     * Desconecta do banco
+     */
+    async disconnect() {
+        try {
+            if (this.connection) {
+                await this.connection.close().catch(() => { });
+                this.connection = null;
+            }
+            if (this.pool) {
+                await this.pool.close(0).catch(() => { });
+                this.pool = null;
+            }
+        }
+        finally {
+            this.connected = false;
+            this.connectionConfig = null;
+            this.inTransaction = false;
+        }
+    }
+    /**
+     * Verifica se está conectado
+     */
+    isConnected() {
+        return this.connected && !!this.connection;
+    }
+    /**
+     * Executa uma consulta SQL
+     */
+    async query(sql, parameters = []) {
+        if (!this.isConnected()) {
+            throw ValidationError.invalidConfiguration('database', 'Banco não está conectado');
+        }
+        if (!sql.trim()) {
+            throw ValidationError.missingRequiredParameter('sql');
+        }
+        const startTime = Date.now();
+        try {
+            const result = await this.connection.execute(sql, parameters);
+            const executionTime = Date.now() - startTime;
+            return {
+                rows: result.rows || [],
+                rowCount: result.rows ? result.rows.length : 0,
+                columns: result.metaData
+                    ? result.metaData.map((col) => col.name)
+                    : [],
+                executionTime,
+                query: sql,
+                parameters,
+            };
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('query', `Falha ao executar consulta: ${sql}`, err);
+        }
+    }
+    /**
+     * Executa consulta e retorna um registro
+     */
+    async queryOne(sql, parameters = []) {
+        const result = await this.query(sql, parameters);
+        return result.rows.length > 0 ? result.rows[0] : null;
+    }
+    /**
+     * Executa consulta e retorna múltiplos registros
+     */
+    async queryMany(sql, parameters = []) {
+        const result = await this.query(sql, parameters);
+        return result.rows;
+    }
+    /**
+     * Executa comando SQL (INSERT, UPDATE, DELETE)
+     */
+    async execute(sql, parameters = []) {
+        if (!this.isConnected()) {
+            throw ValidationError.invalidConfiguration('database', 'Banco não está conectado');
+        }
+        if (!sql.trim()) {
+            throw ValidationError.missingRequiredParameter('sql');
+        }
+        try {
+            const result = await this.connection.execute(sql, parameters);
+            if (!this.inTransaction) {
+                await this.connection.commit();
+            }
+            return {
+                affectedRows: result.rowsAffected || 0,
+                lastInsertId: result.lastRowid,
+            };
+        }
+        catch (error) {
+            if (!this.inTransaction) {
+                await this.connection.rollback();
+            }
+            const err = error;
+            throw IntegrationError.webOperationFailed('execute', `Falha ao executar comando: ${sql}`, err);
+        }
+    }
+    /**
+     * Executa múltiplos comandos em lote
+     */
+    async executeBatch(sql, parametersArray) {
+        if (!this.isConnected()) {
+            throw ValidationError.invalidConfiguration('database', 'Banco não está conectado');
+        }
+        if (!sql.trim()) {
+            throw ValidationError.missingRequiredParameter('sql');
+        }
+        if (!parametersArray || parametersArray.length === 0) {
+            throw ValidationError.missingRequiredParameter('parametersArray');
+        }
+        const affectedRows = [];
+        try {
+            const wasInTransaction = this.inTransaction;
+            if (!wasInTransaction) {
+                await this.beginTransaction();
+            }
+            for (const parameters of parametersArray) {
+                const result = await this.connection.execute(sql, parameters);
+                affectedRows.push(result.rowsAffected || 0);
+            }
+            if (!wasInTransaction) {
+                await this.commit();
+            }
+            return { affectedRows };
+        }
+        catch (error) {
+            if (!this.inTransaction) {
+                await this.rollback();
+            }
+            const err = error;
+            throw IntegrationError.webOperationFailed('executeBatch', `Falha ao executar lote: ${sql}`, err);
+        }
+    }
+    /**
+     * Inicia transação
+     */
+    async beginTransaction() {
+        if (!this.isConnected()) {
+            throw ValidationError.invalidConfiguration('database', 'Banco não está conectado');
+        }
+        if (this.inTransaction) {
+            throw ValidationError.invalidConfiguration('transaction', 'Transação já está ativa');
+        }
+        this.inTransaction = true;
+    }
+    /**
+     * Confirma transação
+     */
+    async commit() {
+        if (!this.isConnected()) {
+            throw ValidationError.invalidConfiguration('database', 'Banco não está conectado');
+        }
+        try {
+            await this.connection.commit();
+            this.inTransaction = false;
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('commit', 'Falha ao confirmar transação', err);
+        }
+    }
+    /**
+     * Desfaz transação
+     */
+    async rollback() {
+        if (!this.isConnected()) {
+            throw ValidationError.invalidConfiguration('database', 'Banco não está conectado');
+        }
+        try {
+            await this.connection.rollback();
+            this.inTransaction = false;
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('rollback', 'Falha ao desfazer transação', err);
+        }
+    }
+    /**
+     * Testa conexão com o banco
+     */
+    async testConnection() {
+        try {
+            if (!this.isConnected()) {
+                return false;
+            }
+            const result = await this.query('SELECT 1 FROM DUAL');
+            return result.rows.length > 0;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Obtém informações da conexão
+     */
+    getConnectionInfo() {
+        return this.connectionConfig;
+    }
+    /**
+     * Executa script SQL de arquivo
+     */
+    async executeScript(scriptPath) {
+        if (!scriptPath.trim()) {
+            throw ValidationError.missingRequiredParameter('scriptPath');
+        }
+        try {
+            const fs = await import('fs/promises');
+            const scriptContent = await fs.readFile(scriptPath, 'utf8');
+            // Dividir script em comandos individuais
+            const commands = scriptContent
+                .split(/;\s*[\r\n]+/)
+                .map((cmd) => cmd.trim())
+                .filter((cmd) => cmd.length > 0 && !cmd.startsWith('--'));
+            await this.beginTransaction();
+            for (const command of commands) {
+                if (command.trim()) {
+                    await this.execute(command);
+                }
+            }
+            await this.commit();
+        }
+        catch (error) {
+            await this.rollback();
+            const err = error;
+            throw IntegrationError.fileSystemError('executeScript', scriptPath, err);
+        }
+    }
+    /**
+     * Chama procedure armazenada
+     */
+    async callProcedure(procedureName, parameters = []) {
+        if (!procedureName.trim()) {
+            throw ValidationError.missingRequiredParameter('procedureName');
+        }
+        const placeholders = parameters
+            .map((_, index) => `:${index + 1}`)
+            .join(', ');
+        const sql = `BEGIN ${procedureName}(${placeholders}); END;`;
+        try {
+            const result = await this.execute(sql, parameters);
+            return result;
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('callProcedure', `Falha ao executar procedure: ${procedureName}`, err);
+        }
+    }
+    /**
+     * Chama função armazenada
+     */
+    async callFunction(functionName, parameters = []) {
+        if (!functionName.trim()) {
+            throw ValidationError.missingRequiredParameter('functionName');
+        }
+        const placeholders = parameters
+            .map((_, index) => `:${index + 2}`)
+            .join(', ');
+        const sql = `BEGIN :1 := ${functionName}(${placeholders}); END;`;
+        try {
+            // Adicionar parâmetro de saída no início
+            const allParameters = [
+                { dir: this.oracledb.BIND_OUT, type: this.oracledb.STRING },
+                ...parameters,
+            ];
+            const result = await this.connection.execute(sql, allParameters);
+            return result.outBinds ? result.outBinds[0] : null;
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('callFunction', `Falha ao executar função: ${functionName}`, err);
+        }
+    }
+    /**
+     * Obtém a instância da conexão Oracle
+     * Para casos onde é necessário acessar funcionalidades específicas
+     */
+    getConnection() {
+        return this.connection;
+    }
+    /**
+     * Obtém o pool de conexões
+     */
+    getPool() {
+        return this.pool;
+    }
+    /**
+     * Executa consulta com cursor (para grandes volumes)
+     */
+    async *queryWithCursor(sql, parameters = [], batchSize = 1000) {
+        if (!this.isConnected()) {
+            throw ValidationError.invalidConfiguration('database', 'Banco não está conectado');
+        }
+        const connection = this.connection;
+        const result = await connection.execute(sql, parameters, {
+            resultSet: true,
+        });
+        const resultSet = result.resultSet;
+        try {
+            let rows;
+            do {
+                rows = await resultSet.getRows(batchSize);
+                if (rows.length > 0) {
+                    yield rows;
+                }
+            } while (rows.length === batchSize);
+        }
+        finally {
+            await resultSet.close();
+        }
+    }
+}

package/dist/src/infrastructure/adapters/PlaywrightAdapter.d.ts

@@ -0,0 +1,192 @@
+/**
+ * @fileoverview Adaptador Playwright para automação web seguindo padrões DDD
+ * @module Infrastructure/Adapters
+ *
+ * 🎯 OBJETIVO: Abstrai Playwright com interface padronizada IWebDriver
+ * - ✅ Facilita futuras migrações de tecnologia web (Playwright → outras)
+ * - ✅ Padroniza métodos entre diferentes drivers web
+ * - ✅ Adiciona validação automática com Zod
+ * - ✅ Integra automaticamente com sistema de evidências
+ * - ✅ Compatível 100% com WebActions atuais
+ *
+ * 🔄 DIFERENÇA DO SELENIUM/WebDriver:
+ * - Selenium: Protocolo W3C WebDriver padrão, mais lento, sem recursos modernos
+ * - Playwright: API nativa moderna, mais rápido, recursos avançados (auto-wait, interceptação)
+ *
+ * 🏗️ ARQUITETURA DDD:
+ * - Domain Layer: Interface IWebDriver (contrato independente de tecnologia)
+ * - Infrastructure Layer: PlaywrightAdapter (implementação específica)
+ * - Application Layer: WebActions (mantém compatibilidade com código atual)
+ *
+ * 💡 BENEFÍCIOS DESTA ABSTRAÇÃO:
+ * - Possibilita trocar Playwright por Selenium/Puppeteer sem quebrar código
+ * - Adiciona validação que Playwright puro não tem
+ * - Integra automaticamente com coverage/evidências do AutoCore
+ * - Permite DI (Dependency Injection) para testes unitários
+ * - Facilita mocking e debugging
+ *
+ * EXEMPLO USO DIRETO (DDD):
+ * ```typescript
+ * const webDriver: IWebDriver = new PlaywrightAdapter(page)
+ * await webDriver.click('#submit') // Validação automática + evidências
+ * ```
+ *
+ * EXEMPLO USO ATUAL (continua funcionando):
+ * ```typescript
+ * import { WebActions } from '@silasfmartins/testhub'
+ * await WebActions.click('#submit') // Usa PlaywrightAdapter internamente
+ * ```
+ */
+import type { BrowserContext, Page } from '@playwright/test';
+/**
+ * Interface para drivers web
+ */
+export interface IWebDriver {
+    navigate(url: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    click(selector: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    fill(selector: string, value: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    getText(selector: string): Promise<string>;
+    getAttribute(selector: string, attribute: string): Promise<string | null>;
+    isVisible(selector: string): Promise<boolean>;
+    isEnabled(selector: string): Promise<boolean>;
+    waitForElement(selector: string, options?: {
+        timeout?: number;
+        state?: 'visible' | 'hidden' | 'attached' | 'detached';
+    }): Promise<void>;
+    selectOption(selector: string, value: string): Promise<void>;
+    hover(selector: string): Promise<void>;
+    doubleClick(selector: string): Promise<void>;
+    rightClick(selector: string): Promise<void>;
+    screenshot(options?: {
+        path?: string;
+        fullPage?: boolean;
+    }): Promise<Buffer>;
+    setViewport(width: number, height: number): Promise<void>;
+    evaluateScript<T>(script: string): Promise<T>;
+    goBack(): Promise<void>;
+    goForward(): Promise<void>;
+    reload(): Promise<void>;
+    getCurrentUrl(): Promise<string>;
+    getTitle(): Promise<string>;
+    close(): Promise<void>;
+}
+/**
+ * Adaptador que integra Playwright com a arquitetura do AutoCore
+ * Implementa a interface IWebDriver usando Playwright como infraestrutura
+ */
+export declare class PlaywrightAdapter implements IWebDriver {
+    private page;
+    private context?;
+    constructor(page: Page, context?: BrowserContext | undefined);
+    /**
+     * Navega para uma URL
+     */
+    navigate(url: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    /**
+     * Clica em um elemento
+     */
+    click(selector: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    /**
+     * Preenche um campo
+     */
+    fill(selector: string, value: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    /**
+     * Obtém texto de um elemento
+     */
+    getText(selector: string): Promise<string>;
+    /**
+     * Obtém atributo de um elemento
+     */
+    getAttribute(selector: string, attribute: string): Promise<string | null>;
+    /**
+     * Verifica se elemento está visível
+     */
+    isVisible(selector: string): Promise<boolean>;
+    /**
+     * Verifica se elemento está habilitado
+     */
+    isEnabled(selector: string): Promise<boolean>;
+    /**
+     * Aguarda elemento ficar em estado específico
+     */
+    waitForElement(selector: string, options?: {
+        timeout?: number;
+        state?: 'visible' | 'hidden' | 'attached' | 'detached';
+    }): Promise<void>;
+    /**
+     * Seleciona opção em dropdown
+     */
+    selectOption(selector: string, value: string): Promise<void>;
+    /**
+     * Hover sobre elemento
+     */
+    hover(selector: string): Promise<void>;
+    /**
+     * Duplo clique
+     */
+    doubleClick(selector: string): Promise<void>;
+    /**
+     * Clique com botão direito
+     */
+    rightClick(selector: string): Promise<void>;
+    /**
+     * Captura screenshot
+     */
+    screenshot(options?: {
+        path?: string;
+        fullPage?: boolean;
+    }): Promise<Buffer>;
+    /**
+     * Define tamanho do viewport
+     */
+    setViewport(width: number, height: number): Promise<void>;
+    /**
+     * Executa JavaScript na página
+     */
+    evaluateScript<T>(script: string): Promise<T>;
+    /**
+     * Voltar página
+     */
+    goBack(): Promise<void>;
+    /**
+     * Avançar página
+     */
+    goForward(): Promise<void>;
+    /**
+     * Recarregar página
+     */
+    reload(): Promise<void>;
+    /**
+     * Obtém URL atual
+     */
+    getCurrentUrl(): Promise<string>;
+    /**
+     * Obtém título da página
+     */
+    getTitle(): Promise<string>;
+    /**
+     * Fecha a página
+     */
+    close(): Promise<void>;
+    /**
+     * Obtém a instância do Page do Playwright
+     * Para casos onde é necessário acessar funcionalidades específicas
+     */
+    getPage(): Page;
+    /**
+     * Obtém o contexto do browser
+     */
+    getContext(): BrowserContext | undefined;
+}