@salve-software/salvetron-react-native 1.0.1

package/src/library/interceptors/__tests__/xhr.test.ts

@@ -0,0 +1,313 @@
+import { XHRInterceptor } from '../xhr'
+
+describe('XHRInterceptor', () => {
+  let interceptor: XHRInterceptor
+
+  const originalXMLHttpRequest = global.XMLHttpRequest
+
+  const openMock = jest.fn()
+  const sendMock = jest.fn()
+  const setRequestHeaderMock = jest.fn()
+
+  class MockXMLHttpRequest {
+    static HEADERS_RECEIVED = 2
+    static DONE = 4
+
+    public readonly HEADERS_RECEIVED =
+      MockXMLHttpRequest.HEADERS_RECEIVED
+
+    public readonly DONE =
+      MockXMLHttpRequest.DONE
+
+    public readyState = 0
+    public status = 200
+    public timeout = 0
+    public response = '{"success":true}'
+    public responseURL = 'https://api.test.com'
+    public responseType = 'json'
+
+    private listeners: Record<string, Array<() => void>> = {}
+
+    open(method: string, url: string) {
+      openMock(method, url)
+    }
+
+    send(data?: unknown) {
+      sendMock(data)
+    }
+
+    setRequestHeader(header: string, value: string) {
+      setRequestHeaderMock(header, value)
+    }
+
+    addEventListener(event: string, callback: () => void) {
+      if (!this.listeners[event]) {
+        this.listeners[event] = []
+      }
+
+      this.listeners[event].push(callback)
+    }
+
+    emit(event: string) {
+      this.listeners[event]?.forEach(listener => listener())
+    }
+
+    getResponseHeader(name: string) {
+      if (name === 'Content-Type') {
+        return 'application/json; charset=utf-8'
+      }
+
+      if (name === 'Content-Length') {
+        return '128'
+      }
+
+      return null
+    }
+
+    getAllResponseHeaders() {
+      return 'Content-Type: application/json'
+    }
+  }
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    jest.spyOn(console, 'log').mockImplementation(() => {})
+    jest.spyOn(console, 'warn').mockImplementation(() => {})
+
+    global.XMLHttpRequest = MockXMLHttpRequest as any
+
+    interceptor = XHRInterceptor.getInstance()
+
+    interceptor.disable()
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  afterAll(() => {
+    global.XMLHttpRequest = originalXMLHttpRequest
+  })
+
+  it('should enable interceptor', () => {
+    const result = interceptor.enable({
+      onOpen: jest.fn(),
+      onSend: jest.fn(),
+      onRequestHeader: jest.fn(),
+      onHeaderReceived: jest.fn(),
+      onResponse: jest.fn(),
+    })
+
+    expect(result).toBe(true)
+    expect(interceptor.isEnabled()).toBe(true)
+  })
+
+  it('should prevent double enable', () => {
+    interceptor.enable({
+      onOpen: jest.fn(),
+      onSend: jest.fn(),
+      onRequestHeader: jest.fn(),
+      onHeaderReceived: jest.fn(),
+      onResponse: jest.fn(),
+    })
+
+    const result = interceptor.enable({
+      onOpen: jest.fn(),
+      onSend: jest.fn(),
+      onRequestHeader: jest.fn(),
+      onHeaderReceived: jest.fn(),
+      onResponse: jest.fn(),
+    })
+
+    expect(result).toBe(false)
+
+    expect(console.warn).toHaveBeenCalledWith(
+      '[Salvetron] Network interceptor already enabled'
+    )
+  })
+
+  it('should intercept open calls', () => {
+    const onOpen = jest.fn()
+
+    interceptor.enable({
+      onOpen,
+      onSend: jest.fn(),
+      onRequestHeader: jest.fn(),
+      onHeaderReceived: jest.fn(),
+      onResponse: jest.fn(),
+    })
+
+    const xhr = new XMLHttpRequest()
+
+    xhr.open('GET', 'https://api.test.com')
+
+    expect(onOpen).toHaveBeenCalledTimes(1)
+
+    expect(onOpen).toHaveBeenCalledWith(
+      'GET',
+      'https://api.test.com',
+      xhr
+    )
+
+    expect(openMock).toHaveBeenCalledTimes(1)
+
+    expect(openMock).toHaveBeenCalledWith(
+      'GET',
+      'https://api.test.com'
+    )
+  })
+
+  it('should intercept request headers', () => {
+    const onRequestHeader = jest.fn()
+
+    interceptor.enable({
+      onOpen: jest.fn(),
+      onSend: jest.fn(),
+      onRequestHeader,
+      onHeaderReceived: jest.fn(),
+      onResponse: jest.fn(),
+    })
+
+    const xhr = new XMLHttpRequest()
+
+    xhr.setRequestHeader('Authorization', 'Bearer token')
+
+    expect(onRequestHeader).toHaveBeenCalledTimes(1)
+
+    expect(onRequestHeader).toHaveBeenCalledWith(
+      'Authorization',
+      'Bearer token',
+      xhr
+    )
+
+    expect(setRequestHeaderMock).toHaveBeenCalledTimes(1)
+
+    expect(setRequestHeaderMock).toHaveBeenCalledWith(
+      'Authorization',
+      'Bearer token'
+    )
+  })
+
+  it('should intercept send calls', () => {
+    const onSend = jest.fn()
+
+    interceptor.enable({
+      onOpen: jest.fn(),
+      onSend,
+      onRequestHeader: jest.fn(),
+      onHeaderReceived: jest.fn(),
+      onResponse: jest.fn(),
+    })
+
+    const xhr = new XMLHttpRequest()
+
+    xhr.send({ hello: true })
+
+    expect(onSend).toHaveBeenCalledTimes(1)
+
+    expect(onSend).toHaveBeenCalledWith(
+      { hello: true },
+      xhr
+    )
+
+    expect(sendMock).toHaveBeenCalledTimes(1)
+
+    expect(sendMock).toHaveBeenCalledWith({
+      hello: true,
+    })
+  })
+
+  it('should intercept HEADERS_RECEIVED state', () => {
+    const onHeaderReceived = jest.fn()
+
+    interceptor.enable({
+      onOpen: jest.fn(),
+      onSend: jest.fn(),
+      onRequestHeader: jest.fn(),
+      onHeaderReceived,
+      onResponse: jest.fn(),
+    })
+
+    const xhr = new XMLHttpRequest() as any
+
+    xhr.send()
+
+    xhr.readyState = xhr.HEADERS_RECEIVED
+
+    xhr.emit('readystatechange')
+
+    expect(onHeaderReceived).toHaveBeenCalledTimes(1)
+
+    expect(onHeaderReceived).toHaveBeenCalledWith(
+      'application/json',
+      128,
+      'Content-Type: application/json',
+      xhr
+    )
+  })
+
+  it('should intercept DONE state', () => {
+    const onResponse = jest.fn()
+
+    interceptor.enable({
+      onOpen: jest.fn(),
+      onSend: jest.fn(),
+      onRequestHeader: jest.fn(),
+      onHeaderReceived: jest.fn(),
+      onResponse,
+    })
+
+    const xhr = new XMLHttpRequest() as any
+
+    xhr.send()
+
+    xhr.readyState = xhr.DONE
+
+    xhr.emit('readystatechange')
+
+    expect(onResponse).toHaveBeenCalledTimes(1)
+
+    expect(onResponse).toHaveBeenCalledWith(
+      200,
+      false,
+      '{"success":true}',
+      'https://api.test.com',
+      'json',
+      xhr
+    )
+  })
+
+  it('should restore original methods on disable', () => {
+    const originalOpen = XMLHttpRequest.prototype.open
+    const originalSend = XMLHttpRequest.prototype.send
+    const originalSetRequestHeader =
+      XMLHttpRequest.prototype.setRequestHeader
+
+    interceptor.enable({
+      onOpen: jest.fn(),
+      onSend: jest.fn(),
+      onRequestHeader: jest.fn(),
+      onHeaderReceived: jest.fn(),
+      onResponse: jest.fn(),
+    })
+
+    expect(XMLHttpRequest.prototype.open).not.toBe(originalOpen)
+
+    expect(XMLHttpRequest.prototype.send).not.toBe(originalSend)
+
+    expect(XMLHttpRequest.prototype.setRequestHeader).not.toBe(
+      originalSetRequestHeader
+    )
+
+    interceptor.disable()
+
+    expect(XMLHttpRequest.prototype.open).toBe(originalOpen)
+
+    expect(XMLHttpRequest.prototype.send).toBe(originalSend)
+
+    expect(XMLHttpRequest.prototype.setRequestHeader).toBe(
+      originalSetRequestHeader
+    )
+  })
+})

package/src/library/interceptors/index.ts

@@ -0,0 +1,5 @@
+import { XHRInterceptor } from './xhr'
+import { JSConsoleInterceptor } from './js-console'
+
+export const xhrInterceptor = XHRInterceptor.getInstance()
+export const jsConsoleInterceptor = JSConsoleInterceptor.getInstance()

package/src/library/interceptors/js-console.ts

@@ -0,0 +1,93 @@
+import type { LogLevel } from '../types'
+
+export interface JSConsoleCallbacks {
+  onLog: (level: LogLevel, message: string, metadata?: Record<string, unknown>) => void
+}
+
+export class JSConsoleInterceptor {
+  private static instance: JSConsoleInterceptor | null = null
+
+  private enabled = false
+  private callbacks: JSConsoleCallbacks | null = null
+
+  private readonly originalLog = console.log
+  private readonly originalWarn = console.warn
+  private readonly originalError = console.error
+
+  public static getInstance(): JSConsoleInterceptor {
+    if (!JSConsoleInterceptor.instance) {
+      JSConsoleInterceptor.instance = new JSConsoleInterceptor()
+    }
+    return JSConsoleInterceptor.instance
+  }
+
+  public isEnabled(): boolean {
+    return this.enabled
+  }
+
+  public start(callbacks: JSConsoleCallbacks): boolean {
+    if (this.enabled) {
+      return false
+    }
+
+    this.callbacks = callbacks
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this
+
+    console.log = function (...args: unknown[]) {
+      self.originalLog.apply(console, args)
+      try {
+        const first = args[0]
+        if (typeof first === 'string' && first.startsWith('[Salvetron]')) return
+        const message = String(args[0])
+        const metadata = args.length > 1 ? { args: args.slice(1) } : undefined
+        self.callbacks?.onLog('log', message, metadata)
+      } catch {
+        // swallow forwarding errors
+      }
+    }
+
+    console.warn = function (...args: unknown[]) {
+      self.originalWarn.apply(console, args)
+      try {
+        const first = args[0]
+        if (typeof first === 'string' && first.startsWith('[Salvetron]')) return
+        const message = String(args[0])
+        const metadata = args.length > 1 ? { args: args.slice(1) } : undefined
+        self.callbacks?.onLog('warn', message, metadata)
+      } catch {
+        // swallow forwarding errors
+      }
+    }
+
+    console.error = function (...args: unknown[]) {
+      self.originalError.apply(console, args)
+      try {
+        const first = args[0]
+        if (typeof first === 'string' && first.startsWith('[Salvetron]')) return
+        const message = String(args[0])
+        const metadata = args.length > 1 ? { args: args.slice(1) } : undefined
+        self.callbacks?.onLog('error', message, metadata)
+      } catch {
+        // swallow forwarding errors
+      }
+    }
+
+    this.enabled = true
+    return true
+  }
+
+  public stop(): void {
+    if (!this.enabled) {
+      return
+    }
+
+    console.log = this.originalLog
+    console.warn = this.originalWarn
+    console.error = this.originalError
+
+    this.callbacks = null
+    this.enabled = false
+  }
+}

package/src/library/interceptors/xhr.ts

@@ -0,0 +1,123 @@
+import type { NetworkCallbacks } from '../types';
+
+export class XHRInterceptor {
+  private static instance: XHRInterceptor | null = null;
+
+  private readonly originalOpen = XMLHttpRequest.prototype.open;
+  private readonly originalSend = XMLHttpRequest.prototype.send;
+  private readonly originalSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
+
+  private enabled = false;
+
+  private callbacks: {
+    onOpen?: NetworkCallbacks['onOpen'];
+    onSend?: NetworkCallbacks['onSend'];
+    onRequestHeader?: NetworkCallbacks['onRequestHeader'];
+    onHeaderReceived?: NetworkCallbacks['onHeaderReceived'];
+    onResponse?: NetworkCallbacks['onResponse'];
+  } = {};
+
+  public static getInstance(): XHRInterceptor {
+    if (!XHRInterceptor.instance) {
+      XHRInterceptor.instance = new XHRInterceptor();
+    }
+
+    return XHRInterceptor.instance;
+  }
+
+  public isEnabled(): boolean {
+    return this.enabled;
+  }
+
+  public enable(callbacks: NetworkCallbacks): boolean {
+    if (this.enabled) {
+      console.warn('[Salvetron] Network interceptor already enabled');
+      return false;
+    }
+
+    this.callbacks = callbacks;
+
+    XMLHttpRequest.prototype.open = function (
+      this: XMLHttpRequest,
+      method: string,
+      url: string | URL
+    ) {
+      XHRInterceptor.getInstance().callbacks.onOpen?.(method, url.toString(), this);
+
+      return XHRInterceptor.getInstance().originalOpen.apply(this, arguments as any);
+    };
+
+    XMLHttpRequest.prototype.setRequestHeader = function (
+      this: XMLHttpRequest,
+      header: string,
+      value: string
+    ) {
+      XHRInterceptor.getInstance().callbacks.onRequestHeader?.(header, value, this);
+
+      return XHRInterceptor.getInstance().originalSetRequestHeader.apply(
+        this,
+        arguments as any
+      );
+    };
+
+    XMLHttpRequest.prototype.send = function (this: XMLHttpRequest, data?: unknown) {
+      const interceptor = XHRInterceptor.getInstance();
+
+      interceptor.callbacks.onSend?.(data, this);
+
+      if (this.addEventListener) {
+        this.addEventListener('readystatechange', () => {
+          if (!interceptor.enabled) {
+            return;
+          }
+
+          if (this.readyState === this.HEADERS_RECEIVED) {
+            const contentType = this.getResponseHeader('Content-Type');
+            const contentLength = this.getResponseHeader('Content-Length');
+
+            interceptor.callbacks.onHeaderReceived?.(
+              contentType?.split(';')[0],
+              contentLength ? parseInt(contentLength, 10) : undefined,
+              this.getAllResponseHeaders(),
+              this
+            );
+          }
+
+          if (this.readyState === this.DONE) {
+            interceptor.callbacks.onResponse?.(
+              this.status,
+              this.timeout > 0,
+              this.response,
+              this.responseURL,
+              this.responseType,
+              this
+            );
+          }
+        });
+      }
+
+      return interceptor.originalSend.apply(this, arguments as any);
+    };
+
+    this.enabled = true;
+
+    console.log('[Salvetron] Network interception enabled (XMLHttpRequest monkey-patch)');
+
+    return true;
+  }
+
+  public disable(): void {
+    if (!this.enabled) {
+      return;
+    }
+
+    XMLHttpRequest.prototype.open = this.originalOpen;
+    XMLHttpRequest.prototype.send = this.originalSend;
+    XMLHttpRequest.prototype.setRequestHeader = this.originalSetRequestHeader;
+
+    this.callbacks = {};
+    this.enabled = false;
+
+    console.log('[Salvetron] Network interception disabled');
+  }
+}