react-native-nitro-fetch 0.3.0-beta.1 → 1.0.1

package/src/NetworkInspector.ts

@@ -0,0 +1,278 @@
+import { generateCurl } from './CurlGenerator';
+
+export interface NetworkEntry {
+  id: string;
+  type: 'http';
+  url: string;
+  method: string;
+  requestHeaders: Array<{ key: string; value: string }>;
+  requestBody: string | undefined;
+  requestBodySize: number;
+  status: number;
+  statusText: string;
+  responseHeaders: Array<{ key: string; value: string }>;
+  responseBody?: string;
+  responseBodySize: number;
+  startTime: number;
+  endTime: number;
+  duration: number;
+  curl: string;
+  error?: string;
+}
+
+export interface WebSocketMessage {
+  direction: 'sent' | 'received';
+  data: string;
+  size: number;
+  isBinary: boolean;
+  timestamp: number;
+}
+
+export interface WebSocketEntry {
+  id: string;
+  type: 'websocket';
+  url: string;
+  protocols: string[];
+  requestHeaders: Array<{ key: string; value: string }>;
+  startTime: number;
+  endTime: number;
+  duration: number;
+  readyState: string;
+  messages: WebSocketMessage[];
+  messagesSent: number;
+  messagesReceived: number;
+  bytesSent: number;
+  bytesReceived: number;
+  closeCode?: number;
+  closeReason?: string;
+  error?: string;
+}
+
+export type InspectorEntry = NetworkEntry | WebSocketEntry;
+
+export type NetworkEntryCallback = (entry: InspectorEntry) => void;
+
+class NetworkInspectorImpl {
+  private _enabled: boolean = false;
+  private _entries: InspectorEntry[] = [];
+  private _maxEntries: number = 500;
+  private _maxBodyCapture: number = 4096;
+  private _listeners: Set<NetworkEntryCallback> = new Set();
+
+  enable(options?: { maxEntries?: number; maxBodyCapture?: number }): void {
+    this._enabled = true;
+    if (options?.maxEntries != null) this._maxEntries = options.maxEntries;
+    if (options?.maxBodyCapture != null)
+      this._maxBodyCapture = options.maxBodyCapture;
+  }
+
+  disable(): void {
+    this._enabled = false;
+  }
+
+  isEnabled(): boolean {
+    return this._enabled;
+  }
+
+  getEntries(): ReadonlyArray<InspectorEntry> {
+    return this._entries;
+  }
+
+  getHttpEntries(): ReadonlyArray<NetworkEntry> {
+    return this._entries.filter((e): e is NetworkEntry => e.type === 'http');
+  }
+
+  getWebSocketEntries(): ReadonlyArray<WebSocketEntry> {
+    return this._entries.filter(
+      (e): e is WebSocketEntry => e.type === 'websocket'
+    );
+  }
+
+  getEntry(id: string): InspectorEntry | undefined {
+    return this._entries.find((e) => e.id === id);
+  }
+
+  clear(): void {
+    this._entries = [];
+  }
+
+  onEntry(callback: NetworkEntryCallback): () => void {
+    this._listeners.add(callback);
+    return () => {
+      this._listeners.delete(callback);
+    };
+  }
+
+  private _notify(entry: InspectorEntry): void {
+    for (const cb of this._listeners) {
+      try {
+        cb(entry);
+      } catch {
+        // swallow listener errors
+      }
+    }
+  }
+
+  private _trimEntries(): void {
+    if (this._entries.length > this._maxEntries) {
+      this._entries.shift();
+    }
+  }
+
+  // --- HTTP recording ---
+
+  _recordStart(
+    id: string,
+    url: string,
+    method: string,
+    headers: Array<{ key: string; value: string }>,
+    body?: string
+  ): void {
+    if (!this._enabled) return;
+    const bodySize = body ? body.length : 0;
+    const entry: NetworkEntry = {
+      id,
+      type: 'http',
+      url,
+      method,
+      requestHeaders: headers.map((h) => ({ key: h.key, value: h.value })),
+      requestBody: body ? body.slice(0, this._maxBodyCapture) : undefined,
+      requestBodySize: bodySize,
+      status: 0,
+      statusText: '',
+      responseHeaders: [],
+      responseBodySize: 0,
+      startTime: performance.now(),
+      endTime: 0,
+      duration: 0,
+      curl: generateCurl({ url, method, headers, body }),
+    };
+    this._entries.push(entry);
+    this._trimEntries();
+  }
+
+  _recordEnd(
+    id: string,
+    status: number,
+    statusText: string,
+    headers: Array<{ key: string; value: string }>,
+    bodySize: number,
+    error?: string,
+    responseBody?: string
+  ): void {
+    if (!this._enabled) return;
+    const entry = this._entries.find(
+      (e) => e.id === id && e.type === 'http'
+    ) as NetworkEntry | undefined;
+    if (!entry) return;
+    entry.status = status;
+    entry.statusText = statusText;
+    entry.responseHeaders = headers.map((h) => ({
+      key: h.key,
+      value: h.value,
+    }));
+    entry.responseBodySize = bodySize;
+    entry.endTime = performance.now();
+    entry.duration = entry.endTime - entry.startTime;
+    if (error) entry.error = error;
+    if (responseBody != null) {
+      entry.responseBody = responseBody.slice(0, this._maxBodyCapture);
+    }
+    this._notify(entry);
+  }
+
+  // --- WebSocket recording ---
+
+  _recordWsOpen(
+    id: string,
+    url: string,
+    protocols: string[],
+    headers: Array<{ key: string; value: string }>
+  ): void {
+    if (!this._enabled) return;
+    const entry: WebSocketEntry = {
+      id,
+      type: 'websocket',
+      url,
+      protocols,
+      requestHeaders: headers.map((h) => ({ key: h.key, value: h.value })),
+      startTime: performance.now(),
+      endTime: 0,
+      duration: 0,
+      readyState: 'CONNECTING',
+      messages: [],
+      messagesSent: 0,
+      messagesReceived: 0,
+      bytesSent: 0,
+      bytesReceived: 0,
+    };
+    this._entries.push(entry);
+    this._trimEntries();
+    this._notify(entry);
+  }
+
+  _recordWsConnected(id: string): void {
+    if (!this._enabled) return;
+    const entry = this._entries.find(
+      (e) => e.id === id && e.type === 'websocket'
+    ) as WebSocketEntry | undefined;
+    if (!entry) return;
+    entry.readyState = 'OPEN';
+    this._notify(entry);
+  }
+
+  _recordWsMessage(
+    id: string,
+    direction: 'sent' | 'received',
+    data: string,
+    size: number,
+    isBinary: boolean
+  ): void {
+    if (!this._enabled) return;
+    const entry = this._entries.find(
+      (e) => e.id === id && e.type === 'websocket'
+    ) as WebSocketEntry | undefined;
+    if (!entry) return;
+    entry.messages.push({
+      direction,
+      data: data.slice(0, this._maxBodyCapture),
+      size,
+      isBinary,
+      timestamp: performance.now(),
+    });
+    if (direction === 'sent') {
+      entry.messagesSent++;
+      entry.bytesSent += size;
+    } else {
+      entry.messagesReceived++;
+      entry.bytesReceived += size;
+    }
+    this._notify(entry);
+  }
+
+  _recordWsClose(id: string, code: number, reason: string): void {
+    if (!this._enabled) return;
+    const entry = this._entries.find(
+      (e) => e.id === id && e.type === 'websocket'
+    ) as WebSocketEntry | undefined;
+    if (!entry) return;
+    entry.readyState = 'CLOSED';
+    entry.closeCode = code;
+    entry.closeReason = reason;
+    entry.endTime = performance.now();
+    entry.duration = entry.endTime - entry.startTime;
+    this._notify(entry);
+  }
+
+  _recordWsError(id: string, error: string): void {
+    if (!this._enabled) return;
+    const entry = this._entries.find(
+      (e) => e.id === id && e.type === 'websocket'
+    ) as WebSocketEntry | undefined;
+    if (!entry) return;
+    entry.error = error;
+    this._notify(entry);
+  }
+}
+
+export const NetworkInspector = new NetworkInspectorImpl();

package/src/Request.ts

@@ -0,0 +1,187 @@
+import { NitroHeaders } from './Headers';
+import { stringToUTF8, utf8ToString } from './utf8';
+
+export type RequestRedirect = 'follow' | 'error' | 'manual';
+export type RequestCache =
+  | 'default'
+  | 'no-store'
+  | 'no-cache'
+  | 'reload'
+  | 'force-cache'
+  | 'only-if-cached';
+
+export interface NitroRequestInit {
+  method?: string;
+  headers?: HeadersInit | NitroHeaders;
+  body?: BodyInit | null;
+  redirect?: RequestRedirect;
+  signal?: AbortSignal | null;
+  cache?: RequestCache;
+  credentials?: RequestCredentials;
+  mode?: RequestMode;
+  referrer?: string;
+  referrerPolicy?: ReferrerPolicy;
+  integrity?: string;
+  keepalive?: boolean;
+}
+
+export class NitroRequest {
+  readonly url: string;
+  readonly method: string;
+  readonly headers: NitroHeaders;
+  readonly redirect: RequestRedirect;
+  readonly signal: AbortSignal;
+  readonly cache: RequestCache;
+  readonly credentials: RequestCredentials;
+  readonly mode: RequestMode;
+  readonly referrer: string;
+  readonly referrerPolicy: ReferrerPolicy;
+  readonly integrity: string;
+  readonly keepalive: boolean;
+  readonly destination: string;
+
+  private _body: BodyInit | null;
+  private _bodyUsed: boolean = false;
+
+  constructor(input: string | URL | NitroRequest, init?: NitroRequestInit) {
+    if (input instanceof NitroRequest) {
+      // Clone from another NitroRequest
+      this.url = init?.method ? input.url : input.url; // URL always from input
+      this.method = (init?.method ?? input.method).toUpperCase();
+      this.headers = new NitroHeaders(
+        init?.headers
+          ? init.headers instanceof NitroHeaders
+            ? init.headers
+            : (init.headers as any)
+          : input.headers
+      );
+      this.redirect = init?.redirect ?? input.redirect;
+      this.signal = init?.signal ?? input.signal;
+      this.cache = init?.cache ?? input.cache;
+      this.credentials = init?.credentials ?? input.credentials;
+      this.mode = init?.mode ?? input.mode;
+      this.referrer = init?.referrer ?? input.referrer;
+      this.referrerPolicy = init?.referrerPolicy ?? input.referrerPolicy;
+      this.integrity = init?.integrity ?? input.integrity;
+      this.keepalive = init?.keepalive ?? input.keepalive;
+      this._body = init?.body !== undefined ? (init.body ?? null) : input._body;
+    } else {
+      this.url = String(input);
+      this.method = (init?.method ?? 'GET').toUpperCase();
+      this.headers = new NitroHeaders(
+        init?.headers
+          ? init.headers instanceof NitroHeaders
+            ? init.headers
+            : (init.headers as any)
+          : undefined
+      );
+      this.redirect = init?.redirect ?? 'follow';
+      this.signal = init?.signal ?? new AbortController().signal;
+      this.cache = init?.cache ?? 'default';
+      this.credentials = init?.credentials ?? 'same-origin';
+      this.mode = init?.mode ?? 'cors';
+      this.referrer = init?.referrer ?? 'about:client';
+      this.referrerPolicy = init?.referrerPolicy ?? '';
+      this.integrity = init?.integrity ?? '';
+      this.keepalive = init?.keepalive ?? false;
+      this._body = init?.body ?? null;
+    }
+
+    this.destination = '';
+  }
+
+  get bodyUsed(): boolean {
+    return this._bodyUsed;
+  }
+
+  get body(): ReadableStream<Uint8Array> | null {
+    if (this._body == null) return null;
+    const bodyBytes = this._getBodyBytes();
+    if (!bodyBytes) return null;
+    return new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(new Uint8Array(bodyBytes));
+        controller.close();
+      },
+    });
+  }
+
+  private _throwIfBodyUsed(): void {
+    if (this._bodyUsed) {
+      throw new TypeError('Body has already been consumed.');
+    }
+  }
+
+  private _getBodyBytes(): ArrayBuffer | undefined {
+    if (this._body == null) return undefined;
+    if (typeof this._body === 'string') {
+      const encoded = stringToUTF8(this._body);
+      return (encoded.buffer as ArrayBuffer).slice(
+        encoded.byteOffset,
+        encoded.byteOffset + encoded.byteLength
+      );
+    }
+    if (this._body instanceof ArrayBuffer) return this._body;
+    if (ArrayBuffer.isView(this._body)) {
+      const view = this._body;
+      return (view.buffer as ArrayBuffer).slice(
+        view.byteOffset,
+        view.byteOffset + view.byteLength
+      );
+    }
+    return undefined;
+  }
+
+  private _getBodyString(): string {
+    if (this._body == null) return '';
+    if (typeof this._body === 'string') return this._body;
+    const bytes = this._getBodyBytes();
+    if (bytes) return utf8ToString(new Uint8Array(bytes));
+    return '';
+  }
+
+  async text(): Promise<string> {
+    this._throwIfBodyUsed();
+    this._bodyUsed = true;
+    return this._getBodyString();
+  }
+
+  async json(): Promise<any> {
+    this._throwIfBodyUsed();
+    this._bodyUsed = true;
+    const t = this._getBodyString();
+    return JSON.parse(t || '{}');
+  }
+
+  async arrayBuffer(): Promise<ArrayBuffer> {
+    this._throwIfBodyUsed();
+    this._bodyUsed = true;
+    return this._getBodyBytes() ?? new ArrayBuffer(0);
+  }
+
+  async blob(): Promise<Blob> {
+    this._throwIfBodyUsed();
+    this._bodyUsed = true;
+    const buffer = this._getBodyBytes() ?? new ArrayBuffer(0);
+    const contentType = this.headers.get('content-type') ?? '';
+    return new Blob([buffer], { type: contentType });
+  }
+
+  async bytes(): Promise<Uint8Array> {
+    this._throwIfBodyUsed();
+    this._bodyUsed = true;
+    const buffer = this._getBodyBytes() ?? new ArrayBuffer(0);
+    return new Uint8Array(buffer);
+  }
+
+  clone(): NitroRequest {
+    if (this._bodyUsed) {
+      throw new TypeError('Cannot clone a Request whose body has been used.');
+    }
+    return new NitroRequest(this);
+  }
+
+  async formData(): Promise<never> {
+    throw new TypeError('formData() is not supported in NitroRequest');
+  }
+}