@fluwa-tool/sdk 1.0.0

package/dist/features/network/FetchInterceptor.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * Interceptador de fetch nativo do navegador
+ * Responsabilidade única: interceptar e logar requisições fetch
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchInterceptor = void 0;
+const types_1 = require("../../types");
+/**
+ * Implementação de interceptador de fetch
+ * Preserva fetch original e sobrescreve com versão interceptada
+ */
+class FetchInterceptor {
+    constructor(logger, requestLogger, mockResolver, sessionId, appName) {
+        this.logger = logger;
+        this.requestLogger = requestLogger;
+        this.mockResolver = mockResolver;
+        this.sessionId = sessionId;
+        this.appName = appName;
+        this.originalFetch = null;
+        this.isInstalled = false;
+    }
+    /**
+     * Instalar o interceptador
+     * Substitui fetch global
+     */
+    install() {
+        if (this.isInstalled) {
+            this.logger.warn('Fetch interceptor já foi instalado');
+            return;
+        }
+        // Detectar ambiente (navegador ou Node.js)
+        const isBrowser = typeof window !== 'undefined';
+        const globalObj = isBrowser ? window : globalThis;
+        if (typeof globalObj.fetch === 'undefined') {
+            this.logger.warn('Fetch não disponível nesse ambiente');
+            return;
+        }
+        this.originalFetch = globalObj.fetch;
+        // Sobrescrever fetch global
+        globalObj.fetch = this.createInterceptedFetch();
+        this.isInstalled = true;
+        this.logger.success('Fetch interceptor instalado');
+    }
+    /**
+     * Desinstalar o interceptador
+     * Restaura fetch original
+     */
+    uninstall() {
+        if (!this.isInstalled || !this.originalFetch) {
+            return;
+        }
+        const isBrowser = typeof window !== 'undefined';
+        const globalObj = isBrowser ? window : globalThis;
+        globalObj.fetch = this.originalFetch;
+        this.originalFetch = null;
+        this.isInstalled = false;
+        this.logger.success('Fetch interceptor desinstalado');
+    }
+    /**
+     * Criar versão interceptada de fetch
+     */
+    createInterceptedFetch() {
+        return async (...args) => {
+            const startTime = performance.now();
+            const [resource, init] = args;
+            // Ignorar requisições internas do Fluwa (header X-Fluwa-Internal)
+            if (init?.headers && typeof init.headers === 'object') {
+                const headers = init.headers;
+                if (headers['X-Fluwa-Internal'] === 'true') {
+                    // Usar fetch original para requisições internas
+                    return this.originalFetch.apply(globalThis, args);
+                }
+            }
+            // Extrair informações da requisição
+            const method = (init?.method || 'GET').toUpperCase();
+            const url = typeof resource === 'string' ? resource : (resource instanceof Request ? resource.url : resource.toString());
+            const requestId = this.generateId();
+            const requestMetadata = {
+                id: requestId,
+                method,
+                url,
+                headers: init?.headers || {},
+                body: init?.body ? this.safeParseBody(init.body) : undefined,
+                timestamp: new Date().toISOString(),
+                sessionId: this.sessionId,
+                appName: this.appName,
+                source: types_1.RequestSource.REAL, // Default, pode mudar se usar mock
+            };
+            try {
+                // Registrar que começou
+                await this.requestLogger.logStart(requestMetadata);
+                // Verificar se há mock disponível
+                const mockResponse = await this.mockResolver.resolve(method, url);
+                if (mockResponse) {
+                    // Usar mock
+                    requestMetadata.source = types_1.RequestSource.MOCK;
+                    requestMetadata.response = mockResponse.response;
+                    requestMetadata.status = mockResponse.status;
+                    // Aplicar delay se configurado
+                    if (mockResponse.delay) {
+                        await this.delay(mockResponse.delay);
+                    }
+                    const duration = performance.now() - startTime;
+                    requestMetadata.duration = duration;
+                    // Registrar completamento
+                    await this.requestLogger.logComplete(requestMetadata);
+                    // Retornar mock como Response
+                    return new Response(JSON.stringify(mockResponse.response), {
+                        status: mockResponse.status || 200,
+                        statusText: 'Mock',
+                        headers: { 'Content-Type': 'application/json' },
+                    });
+                }
+                // Fazer request real
+                const response = await this.originalFetch.apply(globalThis, args);
+                const responseClone = response.clone();
+                requestMetadata.source = types_1.RequestSource.REAL;
+                requestMetadata.status = response.status;
+                // Tentar extrair body da resposta
+                try {
+                    const responseBody = await responseClone.json();
+                    requestMetadata.response = responseBody;
+                }
+                catch {
+                    // Se não conseguir parsear JSON, deixa vazio
+                }
+                const duration = performance.now() - startTime;
+                requestMetadata.duration = duration;
+                // Registrar completamento
+                await this.requestLogger.logComplete(requestMetadata);
+                return response;
+            }
+            catch (error) {
+                const duration = performance.now() - startTime;
+                requestMetadata.source = types_1.RequestSource.ERROR;
+                requestMetadata.duration = duration;
+                requestMetadata.error = error instanceof Error ? error.message : String(error);
+                // Registrar erro
+                await this.requestLogger.logComplete(requestMetadata);
+                throw error;
+            }
+        };
+    }
+    /**
+     * Parse seguro do body (string ou object)
+     */
+    safeParseBody(body) {
+        if (typeof body === 'string') {
+            try {
+                return JSON.parse(body);
+            }
+            catch {
+                return body;
+            }
+        }
+        return body;
+    }
+    /**
+     * Gerar ID único para requisição
+     */
+    generateId() {
+        return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Sleep (para delays de mock)
+     */
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.FetchInterceptor = FetchInterceptor;

package/dist/features/network/MockResolver.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Resolvedor de mocks
+ * Responsabilidade única: encontrar e retornar mock baseado em URL/método
+ */
+import { ILogger } from '../../core/Logger';
+import { HttpMethod, MockRoute } from '../../types';
+import { IHttpClient } from '../communication/HttpClient';
+export interface IMockResolver {
+    resolve(method: HttpMethod, url: string): Promise<MockRoute | null>;
+    setActiveScenario(scenarioId: string | null): void;
+    refreshActiveScenario(): Promise<void>;
+}
+/**
+ * Implementação do resolvedor de mocks
+ * Busca cenário ativo do servidor e faz matching local
+ */
+export declare class MockResolver implements IMockResolver {
+    private httpClient;
+    private logger;
+    private cachedScenario;
+    private lastFetchTime;
+    private cacheTimeout;
+    constructor(httpClient: IHttpClient, logger: ILogger);
+    /**
+     * Resolver mock para método e URL
+     * Retorna null se não houver mock
+     */
+    resolve(method: HttpMethod, url: string): Promise<MockRoute | null>;
+    /**
+     * Atualizar cenário ativo do servidor
+     */
+    refreshActiveScenario(): Promise<void>;
+    /**
+     * Atualizar cenário ativo (interface anterior)
+     */
+    setActiveScenario(scenarioId: string | null): void;
+    /**
+     * Encontrar rota que corresponde ao método e URL
+     */
+    private findMatchingRoute;
+    /**
+     * Verificar se a URL atual corresponde ao padrão da rota
+     */
+    private urlMatches;
+    /**
+     * Verificar correspondência com parâmetros
+     */
+    private matchesParamPattern;
+}

package/dist/features/network/MockResolver.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * Resolvedor de mocks
+ * Responsabilidade única: encontrar e retornar mock baseado em URL/método
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockResolver = void 0;
+/**
+ * Implementação do resolvedor de mocks
+ * Busca cenário ativo do servidor e faz matching local
+ */
+class MockResolver {
+    constructor(httpClient, logger) {
+        this.httpClient = httpClient;
+        this.logger = logger;
+        this.cachedScenario = null;
+        this.lastFetchTime = 0;
+        this.cacheTimeout = 5000; // 5 segundos
+    }
+    /**
+     * Resolver mock para método e URL
+     * Retorna null se não houver mock
+     */
+    async resolve(method, url) {
+        try {
+            // Atualizar scenario do servidor se necessário
+            await this.refreshActiveScenario();
+            if (!this.cachedScenario) {
+                return null;
+            }
+            // Encontrar rota correspondente
+            const matchingRoute = this.findMatchingRoute(method, url, this.cachedScenario.routes);
+            if (matchingRoute) {
+                this.logger.debug(`Mock encontrado para ${method} ${url}`);
+                return matchingRoute;
+            }
+            return null;
+        }
+        catch (error) {
+            this.logger.warn(`Erro ao resolver mock: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Atualizar cenário ativo do servidor
+     */
+    async refreshActiveScenario() {
+        const now = Date.now();
+        // Usar cache se recente
+        if (this.lastFetchTime && now - this.lastFetchTime < this.cacheTimeout) {
+            return;
+        }
+        try {
+            const response = await this.httpClient.get('/api/scenarios/active');
+            this.cachedScenario = response.data || null;
+            this.lastFetchTime = now;
+            if (this.cachedScenario) {
+                this.logger.debug(`Cenário ativo atualizado: ${this.cachedScenario.name}`);
+            }
+        }
+        catch (error) {
+            this.logger.debug('Nenhum cenário ativo no servidor');
+            this.cachedScenario = null;
+            this.lastFetchTime = now;
+        }
+    }
+    /**
+     * Atualizar cenário ativo (interface anterior)
+     */
+    setActiveScenario(scenarioId) {
+        // Invalidar cache para forçar atualização do servidor
+        this.lastFetchTime = 0;
+        if (scenarioId) {
+            this.logger.info(`Cenário ativo definido para: ${scenarioId}`);
+        }
+        else {
+            this.logger.info('Mocks desativados');
+        }
+    }
+    /**
+     * Encontrar rota que corresponde ao método e URL
+     */
+    findMatchingRoute(method, url, routes) {
+        return routes.find((route) => {
+            // Verificar se o método corresponde
+            if (route.method.toString() !== method.toString()) {
+                return false;
+            }
+            // Verificar se a URL corresponde
+            return this.urlMatches(url, route.url);
+        });
+    }
+    /**
+     * Verificar se a URL atual corresponde ao padrão da rota
+     */
+    urlMatches(actualUrl, routePattern) {
+        // Remover query string e hash
+        const actualUrlPath = actualUrl.split('?')[0].split('#')[0];
+        // Correspondência exata
+        if (routePattern === actualUrlPath) {
+            return true;
+        }
+        // Correspondência com wildcard
+        if (routePattern.endsWith('/*')) {
+            const basePath = routePattern.slice(0, -2);
+            return actualUrlPath.startsWith(basePath);
+        }
+        // Correspondência com :param (ex: /api/users/:id)
+        return this.matchesParamPattern(actualUrlPath, routePattern);
+    }
+    /**
+     * Verificar correspondência com parâmetros
+     */
+    matchesParamPattern(actualUrl, pattern) {
+        const actualParts = actualUrl.split('/').filter(Boolean);
+        const patternParts = pattern.split('/').filter(Boolean);
+        if (actualParts.length !== patternParts.length) {
+            return false;
+        }
+        return patternParts.every((patternPart, index) => {
+            const actualPart = actualParts[index];
+            if (patternPart.startsWith(':')) {
+                return actualPart !== undefined;
+            }
+            return patternPart === actualPart;
+        });
+    }
+}
+exports.MockResolver = MockResolver;

package/dist/features/network/RequestLogger.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Logger de requisições
+ * Responsabilidade única: enviar requisições para o servidor Fluwa
+ */
+import { ILogger } from '../../core/Logger';
+import { RequestMetadata } from '../../types';
+import { IHttpClient } from '../communication/HttpClient';
+export interface IRequestLogger {
+    logStart(request: RequestMetadata): Promise<void>;
+    logComplete(request: RequestMetadata): Promise<void>;
+}
+/**
+ * Implementação do logger de requisições
+ * Envia dados para servidor via HTTP
+ */
+export declare class RequestLogger implements IRequestLogger {
+    private httpClient;
+    private logger;
+    constructor(httpClient: IHttpClient, logger: ILogger);
+    /**
+     * Logar início de uma requisição
+     */
+    logStart(request: RequestMetadata): Promise<void>;
+    /**
+     * Logar completamento de uma requisição
+     */
+    logComplete(request: RequestMetadata): Promise<void>;
+}

package/dist/features/network/RequestLogger.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Logger de requisições
+ * Responsabilidade única: enviar requisições para o servidor Fluwa
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestLogger = void 0;
+/**
+ * Implementação do logger de requisições
+ * Envia dados para servidor via HTTP
+ */
+class RequestLogger {
+    constructor(httpClient, logger) {
+        this.httpClient = httpClient;
+        this.logger = logger;
+    }
+    /**
+     * Logar início de uma requisição
+     */
+    async logStart(request) {
+        try {
+            await this.httpClient.post('/api/requests', request);
+            this.logger.debug(`Request iniciado: ${request.method} ${request.url}`);
+        }
+        catch (error) {
+            this.logger.warn(`Falha ao logar request start`, error);
+        }
+    }
+    /**
+     * Logar completamento de uma requisição
+     */
+    async logComplete(request) {
+        try {
+            await this.httpClient.put(`/api/requests/${request.id}`, request);
+            this.logger.debug(`Request completado: ${request.method} ${request.url}`);
+        }
+        catch (error) {
+            this.logger.warn(`Falha ao logar request complete`, error);
+        }
+    }
+}
+exports.RequestLogger = RequestLogger;

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 🔧 Fluwa SDK
+ * Entry point principal do SDK
+ *
+ * Uso:
+ * import { initFluwaTool } from '@fluwa-tool/sdk';
+ * initFluwaTool({ serverUrl: 'http://localhost:5555' });
+ */
+import { FluwaConfig } from './types';
+/**
+ * Inicializar Fluwa-Tool
+ * Deve ser chamado no início da aplicação
+ */
+export declare function initFluwaTool(partialConfig?: Partial<FluwaConfig>): Promise<void>;
+/**
+ * Desativar Fluwa
+ */
+export declare function disableFluwaTool(): void;
+/**
+ * Habilitar Fluwa
+ */
+export declare function enableFluwaTool(): Promise<void>;
+/**
+ * Verificar se Fluwa está ativo
+ */
+export declare function isFluwaTooIialized(): boolean;
+export * from './types';
+export { Logger, LogLevel } from './core/Logger';
+export { ConfigManager } from './core/Config';

package/dist/index.js

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * 🔧 Fluwa SDK
+ * Entry point principal do SDK
+ *
+ * Uso:
+ * import { initFluwaTool } from '@fluwa-tool/sdk';
+ * initFluwaTool({ serverUrl: 'http://localhost:5555' });
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = exports.LogLevel = exports.Logger = void 0;
+exports.initFluwaTool = initFluwaTool;
+exports.disableFluwaTool = disableFluwaTool;
+exports.enableFluwaTool = enableFluwaTool;
+exports.isFluwaTooIialized = isFluwaTooIialized;
+const types_1 = require("./types");
+const Logger_1 = require("./core/Logger");
+const Config_1 = require("./core/Config");
+const HttpClient_1 = require("./features/communication/HttpClient");
+const WebSocketClient_1 = require("./features/communication/WebSocketClient");
+const FetchInterceptor_1 = require("./features/network/FetchInterceptor");
+const RequestLogger_1 = require("./features/network/RequestLogger");
+const MockResolver_1 = require("./features/network/MockResolver");
+const IdGenerator_1 = require("./core/IdGenerator");
+// ============================================
+// ESTADO GLOBAL
+// ============================================
+let isInitialized = false;
+let logger = Logger_1.defaultLogger;
+let config;
+let sessionId;
+let httpClient;
+let wsClient;
+let fetchInterceptor;
+let mockResolver;
+// ============================================
+// INICIALIZAÇÃO
+// ============================================
+/**
+ * Inicializar Fluwa-Tool
+ * Deve ser chamado no início da aplicação
+ */
+async function initFluwaTool(partialConfig = {}) {
+    if (isInitialized) {
+        logger.warn('Fluwa já foi inicializado');
+        return;
+    }
+    try {
+        // 1. Configurar
+        config = (0, Config_1.getConfigManager)(partialConfig);
+        logger = new Logger_1.Logger('Fluwa', config.getConfig().debug ? Logger_1.LogLevel.DEBUG : Logger_1.LogLevel.INFO);
+        logger.success('Inicializando Fluwa-Tool');
+        logger.debug('Configuração', config.getConfig());
+        if (!config.isEnabled()) {
+            logger.warn('Fluwa desativado via config.enabled=false');
+            return;
+        }
+        // 2. Gerar session ID
+        sessionId = IdGenerator_1.idGenerator.generate();
+        logger.debug(`Session ID: ${sessionId}`);
+        // 3. Criar clientes HTTP e WebSocket
+        const { requestTimeout, serverUrl } = config.getConfig();
+        httpClient = new HttpClient_1.HttpClient(serverUrl, logger, requestTimeout || 5000);
+        wsClient = new WebSocketClient_1.WebSocketClient(serverUrl, logger, config.getAppName());
+        // 4. Criar resolvedor de mocks
+        mockResolver = new MockResolver_1.MockResolver(httpClient, logger);
+        // 5. Criar logger de requisições
+        const requestLogger = new RequestLogger_1.RequestLogger(httpClient, logger);
+        // 6. Criar interceptador de fetch
+        fetchInterceptor = new FetchInterceptor_1.FetchInterceptor(logger, requestLogger, mockResolver, sessionId, config.getAppName());
+        // 7. Instalar interceptadores
+        fetchInterceptor.install();
+        // 8. Conectar WebSocket
+        logger.debug('Conectando ao WebSocket...');
+        try {
+            await wsClient.connect();
+            setupWebSocketListeners();
+        }
+        catch (error) {
+            logger.warn('Falha ao conectar WebSocket, continuando em modo offline', error);
+        }
+        // 9. Enviar init session
+        wsClient.send({
+            type: types_1.WebSocketMessageType.INIT_SESSION,
+            sessionId,
+            appName: config.getAppName(),
+        });
+        isInitialized = true;
+        logger.success('Fluwa-Tool inicializado com sucesso!');
+    }
+    catch (error) {
+        logger.error('Erro ao inicializar Fluwa', error);
+        throw error;
+    }
+}
+/**
+ * Configurar listeners do WebSocket
+ */
+function setupWebSocketListeners() {
+    wsClient.on('message', (message) => {
+        try {
+            if (message?.type === types_1.WebSocketMessageType.SCENARIO_CHANGED) {
+                mockResolver.setActiveScenario(message.scenario || null);
+            }
+        }
+        catch (error) {
+            logger.warn('Erro ao processar mensagem WebSocket', error);
+        }
+    });
+    wsClient.on('disconnected', () => {
+        logger.warn('WebSocket desconectado');
+    });
+    wsClient.on('error', (error) => {
+        logger.error('Erro no WebSocket', error);
+    });
+}
+// ============================================
+// CONTROLE
+// ============================================
+/**
+ * Desativar Fluwa
+ */
+function disableFluwaTool() {
+    if (!isInitialized) {
+        return;
+    }
+    fetchInterceptor.uninstall();
+    wsClient.disconnect();
+    isInitialized = false;
+    logger.success('Fluwa-Tool desativado');
+}
+/**
+ * Habilitar Fluwa
+ */
+async function enableFluwaTool() {
+    if (isInitialized) {
+        return;
+    }
+    fetchInterceptor.install();
+    try {
+        await wsClient.connect();
+    }
+    catch (error) {
+        logger.warn('Falha ao reconectar WebSocket', error);
+    }
+    isInitialized = true;
+    logger.success('Fluwa-Tool habilitado');
+}
+/**
+ * Verificar se Fluwa está ativo
+ */
+function isFluwaTooIialized() {
+    return isInitialized;
+}
+// ============================================
+// EXPORTS
+// ============================================
+__exportStar(require("./types"), exports);
+var Logger_2 = require("./core/Logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return Logger_2.Logger; } });
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return Logger_2.LogLevel; } });
+var Config_2 = require("./core/Config");
+Object.defineProperty(exports, "ConfigManager", { enumerable: true, get: function () { return Config_2.ConfigManager; } });