@fluwa-tool/sdk 1.0.0 → 1.0.26

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

@@ -21,6 +21,7 @@ export declare class FetchInterceptor implements IFetchInterceptor {
     private appName;
     private originalFetch;
     private isInstalled;
+    private isIntercepting;
     constructor(logger: ILogger, requestLogger: IRequestLogger, mockResolver: IMockResolver, sessionId: string, appName: string);
     /**
      * Instalar o interceptador
@@ -48,4 +49,9 @@ export declare class FetchInterceptor implements IFetchInterceptor {
      * Sleep (para delays de mock)
      */
     private delay;
+    /**
+     * Verificar se requisição é interna do Fluwa
+     * Suporta headers como plain object ou Headers instance
+     */
+    private isFluwaInternalRequest;
 }

package/dist/features/network/FetchInterceptor.js

@@ -19,6 +19,7 @@ class FetchInterceptor {
         this.appName = appName;
         this.originalFetch = null;
         this.isInstalled = false;
+        this.isIntercepting = false; // Flag para prevenir re-intercepção
     }
     /**
      * Instalar o interceptador
@@ -64,13 +65,14 @@ class FetchInterceptor {
         return async (...args) => {
             const startTime = performance.now();
             const [resource, init] = args;
+            // Evitar re-intercepção: se já estamos interceptando, usar fetch original
+            if (this.isIntercepting) {
+                return this.originalFetch.apply(globalThis, 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);
-                }
+            if (this.isFluwaInternalRequest(init)) {
+                // 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();
@@ -87,6 +89,8 @@ class FetchInterceptor {
                 appName: this.appName,
                 source: types_1.RequestSource.REAL, // Default, pode mudar se usar mock
             };
+            // Marcar que estamos interceptando para evitar re-intercepção
+            this.isIntercepting = true;
             try {
                 // Registrar que começou
                 await this.requestLogger.logStart(requestMetadata);
@@ -140,6 +144,10 @@ class FetchInterceptor {
                 await this.requestLogger.logComplete(requestMetadata);
                 throw error;
             }
+            finally {
+                // Sempre restaurar a flag
+                this.isIntercepting = false;
+            }
         };
     }
     /**
@@ -168,5 +176,24 @@ class FetchInterceptor {
     delay(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
+    /**
+     * Verificar se requisição é interna do Fluwa
+     * Suporta headers como plain object ou Headers instance
+     */
+    isFluwaInternalRequest(init) {
+        if (!init || !init.headers) {
+            return false;
+        }
+        const headers = init.headers;
+        // Verificar se é plain object
+        if (typeof headers === 'object' && headers.constructor === Object) {
+            return headers['X-Fluwa-Internal'] === 'true';
+        }
+        // Verificar se é Headers instance
+        if (headers instanceof Headers || (typeof headers?.get === 'function')) {
+            return headers.get('X-Fluwa-Internal') === 'true';
+        }
+        return false;
+    }
 }
 exports.FetchInterceptor = FetchInterceptor;

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

@@ -0,0 +1,27 @@
+/**
+ * Interceptador de XMLHttpRequest
+ * Intercepta requisições axios, jQuery, XMLHttpRequest nativo
+ */
+import { ILogger } from '../../core/Logger';
+import { IRequestLogger } from './RequestLogger';
+import { IMockResolver } from './MockResolver';
+export interface IXMLHttpRequestInterceptor {
+    install(): void;
+    uninstall(): void;
+}
+export declare class XMLHttpRequestInterceptor implements IXMLHttpRequestInterceptor {
+    private logger;
+    private requestLogger;
+    private mockResolver;
+    private sessionId;
+    private appName;
+    private originalOpen;
+    private originalSend;
+    private originalSetRequestHeader;
+    private isInstalled;
+    constructor(logger: ILogger, requestLogger: IRequestLogger, mockResolver: IMockResolver, sessionId: string, appName: string);
+    install(): void;
+    uninstall(): void;
+    private safeParseBody;
+    private generateId;
+}

package/dist/features/network/XMLHttpRequestInterceptor.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * Interceptador de XMLHttpRequest
+ * Intercepta requisições axios, jQuery, XMLHttpRequest nativo
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XMLHttpRequestInterceptor = void 0;
+const types_1 = require("../../types");
+class XMLHttpRequestInterceptor {
+    constructor(logger, requestLogger, mockResolver, sessionId, appName) {
+        this.logger = logger;
+        this.requestLogger = requestLogger;
+        this.mockResolver = mockResolver;
+        this.sessionId = sessionId;
+        this.appName = appName;
+        this.isInstalled = false;
+    }
+    install() {
+        if (this.isInstalled) {
+            this.logger.warn('XMLHttpRequest interceptor já foi instalado');
+            return;
+        }
+        // Verificar se XMLHttpRequest está disponível (apenas em navegadores)
+        if (typeof XMLHttpRequest === 'undefined') {
+            this.logger.debug('XMLHttpRequest não disponível nesse ambiente (requer navegador)');
+            return;
+        }
+        const self = this;
+        const originalXHR = XMLHttpRequest.prototype;
+        // Armazenar referência ao open original
+        this.originalOpen = originalXHR.open;
+        this.originalSend = originalXHR.send;
+        this.originalSetRequestHeader = originalXHR.setRequestHeader;
+        // Interceptar open()
+        originalXHR.open = function (method, url, ...args) {
+            const xhr = this;
+            xhr._fluwaMethod = method.toUpperCase();
+            xhr._fluwaUrl = url;
+            xhr._fluwaRequestId = self.generateId();
+            xhr._fluwaHeaders = {};
+            xhr._fluwaStartTime = Date.now();
+            return self.originalOpen.apply(this, [method, url, ...args]);
+        };
+        // Interceptar setRequestHeader()
+        originalXHR.setRequestHeader = function (header, value) {
+            const xhr = this;
+            if (!xhr._fluwaHeaders) {
+                xhr._fluwaHeaders = {};
+            }
+            xhr._fluwaHeaders[header] = value;
+            return self.originalSetRequestHeader.apply(this, [header, value]);
+        };
+        // Interceptar send()
+        this.originalSend = originalXHR.send;
+        originalXHR.send = function (body) {
+            const xhr = this;
+            const method = (xhr._fluwaMethod || 'GET');
+            const url = xhr._fluwaUrl;
+            const requestId = xhr._fluwaRequestId;
+            const headers = xhr._fluwaHeaders || {};
+            const requestMetadata = {
+                id: requestId,
+                method,
+                url,
+                headers,
+                body: body ? self.safeParseBody(body) : undefined,
+                timestamp: new Date().toISOString(),
+                sessionId: self.sessionId,
+                appName: self.appName,
+                source: types_1.RequestSource.REAL,
+            };
+            // Verificar se há mock
+            self.mockResolver.resolve(method, url)
+                .then((mockResponse) => {
+                if (mockResponse) {
+                    // Há mock disponível
+                    requestMetadata.source = types_1.RequestSource.MOCK;
+                    requestMetadata.status = mockResponse.status || 200;
+                    requestMetadata.response = mockResponse.response;
+                    // Logar
+                    self.requestLogger.logStart(requestMetadata).catch(() => { });
+                    // Aplicar delay se configurado
+                    if (mockResponse.delay) {
+                        return new Promise(resolve => setTimeout(resolve, mockResponse.delay));
+                    }
+                }
+                else {
+                    // Sem mock, será requisição real
+                    self.requestLogger.logStart(requestMetadata).catch(() => { });
+                }
+            })
+                .catch(() => {
+                self.requestLogger.logStart(requestMetadata).catch(() => { });
+            });
+            // Interceptar mudanças de estado
+            const originalOnReadyStateChange = xhr.onreadystatechange;
+            xhr.onreadystatechange = function () {
+                if (xhr.readyState === 4) {
+                    // Requisição completou
+                    requestMetadata.status = xhr.status;
+                    // Tentar extrair response
+                    try {
+                        if (xhr.responseText) {
+                            requestMetadata.response = self.safeParseBody(xhr.responseText);
+                        }
+                    }
+                    catch (e) {
+                        requestMetadata.response = xhr.responseText;
+                    }
+                    const duration = Date.now() - (xhr._fluwaStartTime || 0);
+                    requestMetadata.duration = duration;
+                    self.requestLogger.logComplete(requestMetadata).catch(() => { });
+                }
+                // Chamar handler original
+                if (originalOnReadyStateChange) {
+                    originalOnReadyStateChange.call(this);
+                }
+            };
+            // Chamar send original
+            return self.originalSend.apply(this, [body]);
+        };
+        this.isInstalled = true;
+        this.logger.success('XMLHttpRequest interceptor instalado');
+    }
+    uninstall() {
+        if (!this.isInstalled || !this.originalOpen) {
+            return;
+        }
+        const originalXHR = XMLHttpRequest.prototype;
+        originalXHR.open = this.originalOpen;
+        originalXHR.send = this.originalSend;
+        originalXHR.setRequestHeader = this.originalSetRequestHeader;
+        this.isInstalled = false;
+        this.logger.success('XMLHttpRequest interceptor desinstalado');
+    }
+    safeParseBody(body) {
+        if (typeof body === 'string') {
+            try {
+                return JSON.parse(body);
+            }
+            catch {
+                return body;
+            }
+        }
+        return body;
+    }
+    generateId() {
+        return `${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+    }
+}
+exports.XMLHttpRequestInterceptor = XMLHttpRequestInterceptor;

package/dist/index.js

@@ -33,6 +33,7 @@ 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 XMLHttpRequestInterceptor_1 = require("./features/network/XMLHttpRequestInterceptor");
 const RequestLogger_1 = require("./features/network/RequestLogger");
 const MockResolver_1 = require("./features/network/MockResolver");
 const IdGenerator_1 = require("./core/IdGenerator");
@@ -46,6 +47,7 @@ let sessionId;
 let httpClient;
 let wsClient;
 let fetchInterceptor;
+let xmlHttpRequestInterceptor;
 let mockResolver;
 // ============================================
 // INICIALIZAÇÃO
@@ -82,8 +84,11 @@ async function initFluwaTool(partialConfig = {}) {
         const requestLogger = new RequestLogger_1.RequestLogger(httpClient, logger);
         // 6. Criar interceptador de fetch
         fetchInterceptor = new FetchInterceptor_1.FetchInterceptor(logger, requestLogger, mockResolver, sessionId, config.getAppName());
+        // 6b. Criar interceptador de XMLHttpRequest (para axios, jQuery, etc)
+        xmlHttpRequestInterceptor = new XMLHttpRequestInterceptor_1.XMLHttpRequestInterceptor(logger, requestLogger, mockResolver, sessionId, config.getAppName());
         // 7. Instalar interceptadores
         fetchInterceptor.install();
+        xmlHttpRequestInterceptor.install();
         // 8. Conectar WebSocket
         logger.debug('Conectando ao WebSocket...');
         try {
@@ -139,6 +144,7 @@ function disableFluwaTool() {
         return;
     }
     fetchInterceptor.uninstall();
+    xmlHttpRequestInterceptor.uninstall();
     wsClient.disconnect();
     isInitialized = false;
     logger.success('Fluwa-Tool desativado');
@@ -151,6 +157,7 @@ async function enableFluwaTool() {
         return;
     }
     fetchInterceptor.install();
+    xmlHttpRequestInterceptor.install();
     try {
         await wsClient.connect();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluwa-tool/sdk",
-  "version": "1.0.0",
+  "version": "1.0.26",
   "description": "Fluwa DevTools SDK for network interception and mocking",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",