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

package/src/fetch.ts

@@ -3,8 +3,8 @@ import type {
   NitroFetch as NitroFetchModule,
   NitroFormDataPart,
   NitroHeader,
-  NitroRequest,
-  NitroResponse,
+  NitroRequest as NitroRequestNative,
+  NitroResponse as NitroResponseNative,
 } from './NitroFetch.nitro';
 import {
   boxedNitroFetch,
@@ -12,6 +12,11 @@ import {
   NitroCronetSingleton,
 } from './NitroInstances';
 import { NativeStorage as NativeStorageSingleton } from './NitroInstances';
+import { NitroHeaders } from './Headers';
+import { NitroResponse } from './Response';
+import { NitroRequest as NitroRequestClass } from './Request';
+import type { RequestRedirect, RequestCache } from './Request';
+import { NetworkInspector } from './NetworkInspector';
 
 // No base64: pass strings/ArrayBuffers directly
 
@@ -163,39 +168,63 @@ function ensureClient() {
 
 function buildNitroRequest(
   input: RequestInfo | URL,
-  init?: RequestInit
-): NitroRequest {
+  init?: RequestInit & { redirect?: RequestRedirect; cache?: RequestCache }
+): NitroRequestNative {
   'worklet';
   let url: string;
   let method: string | undefined;
   let headersInit: HeadersInit | undefined;
   let body: BodyInit | null | undefined;
+  let redirectOption: RequestRedirect =
+    (init?.redirect as RequestRedirect) ?? 'follow';
+  let cacheOption: RequestCache | undefined = init?.cache as
+    | RequestCache
+    | undefined;
 
-  if (typeof input === 'string' || input instanceof URL) {
+  if (input instanceof NitroRequestClass) {
+    url = input.url;
+    method = init?.method ?? input.method;
+    headersInit = init?.headers ?? (input.headers as any);
+    body = init?.body ?? input.body ?? null;
+    if (!init?.redirect) redirectOption = input.redirect;
+    if (!init?.cache) cacheOption = input.cache;
+  } else if (typeof input === 'string' || input instanceof URL) {
     url = String(input);
     method = init?.method;
     headersInit = init?.headers;
     body = init?.body ?? null;
   } else {
-    // Request object
+    // Standard Request object
     url = input.url;
     method = input.method;
     headersInit = input.headers as any;
-    // Clone body if needed – Request objects in RN typically allow direct access
     body = init?.body ?? null;
   }
 
-  const headers = headersToPairs(headersInit);
+  const headers = headersToPairs(headersInit) ?? [];
   const normalized = normalizeBody(body);
 
+  // Inject cache-control headers based on cache option
+  if (cacheOption === 'no-store') {
+    headers.push({ key: 'Cache-Control', value: 'no-store' });
+  } else if (cacheOption === 'no-cache') {
+    headers.push({ key: 'Cache-Control', value: 'no-cache' });
+  } else if (cacheOption === 'reload') {
+    headers.push({ key: 'Cache-Control', value: 'no-cache' });
+    headers.push({ key: 'Pragma', value: 'no-cache' });
+  }
+
+  // Determine followRedirects based on redirect option
+  const followRedirects = redirectOption === 'follow';
+
   return {
     url,
     method: (method?.toUpperCase() as any) ?? 'GET',
-    headers,
+    headers: headers.length > 0 ? headers : undefined,
     bodyString: normalized?.bodyString,
     bodyBytes: undefined as any,
     bodyFormData: normalized?.bodyFormData,
-    followRedirects: true,
+    followRedirects,
   };
 }
 
@@ -297,7 +326,7 @@ function normalizeBodyPure(
 export function buildNitroRequestPure(
   input: RequestInfo | URL,
   init?: RequestInit
-): NitroRequest {
+): NitroRequestNative {
   'worklet';
   let url: string;
   let method: string | undefined;
@@ -345,10 +374,39 @@ function createAbortError(): Error {
   return err;
 }
 
+async function resolveBlobBody(
+  init: RequestInit | undefined
+): Promise<RequestInit | undefined> {
+  if (!init?.body) return init;
+  if (typeof Blob !== 'undefined' && init.body instanceof Blob) {
+    const blob = init.body as Blob;
+    const text = await new Promise<string>((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => resolve(reader.result as string);
+      reader.onerror = () => reject(reader.error);
+      reader.readAsText(blob);
+    });
+    // Auto-set Content-Type from Blob.type if not already provided
+    let headers = init.headers;
+    if (blob.type) {
+      const pairs = headersToPairs(headers) ?? [];
+      const hasContentType = pairs.some(
+        (h) => h.key.toLowerCase() === 'content-type'
+      );
+      if (!hasContentType) {
+        pairs.push({ key: 'Content-Type', value: blob.type });
+        headers = pairs.map((h) => [h.key, h.value] as [string, string]);
+      }
+    }
+    return { ...init, body: text, headers };
+  }
+  return init;
+}
+
 async function nitroFetchRaw(
   input: RequestInfo | URL,
   init?: RequestInit
-): Promise<NitroResponse> {
+): Promise<NitroResponseNative> {
   const signal = init?.signal as AbortSignal | undefined | null;
 
   // Fast-abort: reject synchronously before any bridge work.
@@ -356,6 +414,9 @@ async function nitroFetchRaw(
     throw createAbortError();
   }
 
+  // Resolve Blob body to string before passing to sync buildNitroRequest
+  init = await resolveBlobBody(init);
+
   const hasNative =
     typeof (NitroFetchHybrid as any)?.createClient === 'function';
   if (!hasNative) {
@@ -375,11 +436,24 @@ async function nitroFetchRaw(
       headers,
       bodyBytes: bytes,
       bodyString: undefined,
-    } as any as NitroResponse; // bleee
+    } as any as NitroResponseNative; // bleee
   }
 
   const req = buildNitroRequest(input, init);
 
+  // Inspector: record start (zero cost when disabled — single boolean check)
+  let inspectorId: string | undefined;
+  if (NetworkInspector.isEnabled()) {
+    inspectorId = String(Date.now()) + '-' + String(Math.random()).slice(2, 8);
+    NetworkInspector._recordStart(
+      inspectorId,
+      req.url,
+      req.method ?? 'GET',
+      req.headers ?? [],
+      req.bodyString
+    );
+  }
+
   // Only allocate a requestId when a signal is present — zero overhead otherwise.
   const requestId = signal ? String(Math.random()) : undefined;
   if (requestId) req.requestId = requestId;
@@ -403,9 +477,23 @@ async function nitroFetchRaw(
   }
 
   try {
-    const res: NitroResponse = await client.request(req);
+    const res: NitroResponseNative = await client.request(req);
+    if (inspectorId) {
+      NetworkInspector._recordEnd(
+        inspectorId,
+        res.status,
+        res.statusText,
+        res.headers ?? [],
+        res.bodyString?.length ?? 0,
+        undefined,
+        res.bodyString ?? undefined
+      );
+    }
     return res;
   } catch (e) {
+    if (inspectorId) {
+      NetworkInspector._recordEnd(inspectorId, 0, '', [], 0, String(e));
+    }
     // If the signal was aborted (either before or during the request),
     // surface a spec-compliant AbortError regardless of what native threw.
     if (signal?.aborted) {
@@ -421,42 +509,7 @@ async function nitroFetchRaw(
   }
 }
 
-// Simple Headers-like class that supports get() method
-class NitroHeaders {
-  private _headers: Map<string, string>;
-
-  constructor(headers: NitroHeader[]) {
-    this._headers = new Map();
-    for (const { key, value } of headers) {
-      // Headers are case-insensitive, normalize to lowercase
-      this._headers.set(key.toLowerCase(), value);
-    }
-  }
-
-  get(name: string): string | null {
-    return this._headers.get(name.toLowerCase()) ?? null;
-  }
-
-  has(name: string): boolean {
-    return this._headers.has(name.toLowerCase());
-  }
-
-  forEach(callback: (value: string, key: string) => void): void {
-    this._headers.forEach(callback);
-  }
-
-  entries(): IterableIterator<[string, string]> {
-    return this._headers.entries();
-  }
-
-  keys(): IterableIterator<string> {
-    return this._headers.keys();
-  }
-
-  values(): IterableIterator<string> {
-    return this._headers.values();
-  }
-}
+// NitroHeaders is now imported from './Headers'
 
 async function nitroStreamFetch(
   input: RequestInfo | URL,
@@ -466,6 +519,19 @@ async function nitroStreamFetch(
   const method = init?.method?.toUpperCase() ?? 'GET';
   const headers = headersToPairs(init?.headers);
 
+  // Inspector: record start
+  let inspectorId: string | undefined;
+  if (NetworkInspector.isEnabled()) {
+    inspectorId = String(Date.now()) + '-' + String(Math.random()).slice(2, 8);
+    NetworkInspector._recordStart(
+      inspectorId,
+      url,
+      method,
+      headers ?? [],
+      typeof init?.body === 'string' ? init.body : undefined
+    );
+  }
+
   const builder = NitroCronetSingleton.newUrlRequestBuilder(url);
   builder.setHttpMethod(method);
   headers?.forEach((h) => builder.addHeader(h.key, h.value));
@@ -486,6 +552,7 @@ async function nitroStreamFetch(
     });
 
     let responseResolved = false;
+    let streamBytesReceived = 0;
 
     builder.onResponseStarted((info) => {
       if (responseResolved) return;
@@ -494,9 +561,7 @@ async function nitroStreamFetch(
       const responseHeaders = new NitroHeaders(
         Object.entries(info.allHeaders).map(([key, value]) => ({ key, value }))
       );
-      // Use a plain object — React Native's Response constructor does not
-      // propagate a ReadableStream to .body, so we set it explicitly.
-      const response: any = {
+      const response = new NitroResponse({
         url: info.url,
         ok: status >= 200 && status < 300,
         status,
@@ -504,9 +569,8 @@ async function nitroStreamFetch(
         headers: responseHeaders,
         redirected: false,
         body: stream,
-        bodyUsed: false,
-      };
-      resolveResponse(response as Response);
+      });
+      resolveResponse(response as unknown as Response);
       // Android/Cronet: kick off the first buffer read.
       // iOS/URLSession handles reading automatically so this is a no-op there.
       request.read();
@@ -514,16 +578,34 @@ async function nitroStreamFetch(
 
     builder.onReadCompleted((_info, byteBuffer, bytesRead) => {
       const chunk = new Uint8Array(byteBuffer, 0, bytesRead).slice();
+      streamBytesReceived += bytesRead;
       streamController.enqueue(chunk);
       if (!request.isDone()) {
         request.read();
       }
     });
 
-    builder.onSucceeded(() => streamController.close());
+    builder.onSucceeded((_info) => {
+      streamController.close();
+      if (inspectorId) {
+        const info = _info as any;
+        const status = info?.httpStatusCode ?? 0;
+        const hdrs = info?.allHeadersAsList ?? [];
+        NetworkInspector._recordEnd(
+          inspectorId,
+          status,
+          info?.httpStatusText ?? '',
+          hdrs,
+          streamBytesReceived
+        );
+      }
+    });
 
     builder.onFailed((_info, error) => {
       const err = new Error(error.message);
+      if (inspectorId) {
+        NetworkInspector._recordEnd(inspectorId, 0, '', [], 0, error.message);
+      }
       if (!responseResolved) {
         responseResolved = true;
         rejectResponse(err);
@@ -534,6 +616,16 @@ async function nitroStreamFetch(
 
     builder.onCanceled(() => {
       const err = createAbortError();
+      if (inspectorId) {
+        NetworkInspector._recordEnd(
+          inspectorId,
+          0,
+          '',
+          [],
+          0,
+          'Request canceled'
+        );
+      }
       if (!responseResolved) {
         responseResolved = true;
         rejectResponse(err);
@@ -549,33 +641,48 @@ async function nitroStreamFetch(
 
 export async function nitroFetch(
   input: RequestInfo | URL,
-  init?: RequestInit & { stream?: boolean }
+  init?: RequestInit & {
+    stream?: boolean;
+    redirect?: RequestRedirect;
+    cache?: RequestCache;
+  }
 ): Promise<Response> {
+  // Merge defaults from NitroRequestClass if input is one
+  if (input instanceof NitroRequestClass) {
+    init = {
+      ...init,
+      signal: init?.signal ?? input.signal,
+      redirect: (init?.redirect as RequestRedirect) ?? input.redirect,
+      cache: (init?.cache as RequestCache) ?? input.cache,
+    } as any;
+  }
+
   if ((init as any)?.stream === true) {
     return nitroStreamFetch(input, init);
   }
-  const res = await nitroFetchRaw(input, init);
 
-  const headersObj = new NitroHeaders(res.headers);
+  const redirectOption: RequestRedirect =
+    (init?.redirect as RequestRedirect) ?? 'follow';
+  const res = await nitroFetchRaw(input, init);
 
-  const bodyBytes = res.bodyBytes;
-  const bodyString = res.bodyString;
+  // Handle redirect: "error" — if we got a 3xx back (followRedirects was false), throw
+  if (redirectOption === 'error' && res.status >= 300 && res.status < 400) {
+    throw new TypeError(
+      `redirect mode is "error": redirected request to "${res.url}"`
+    );
+  }
 
-  const makeLight = (): any => ({
+  const response = new NitroResponse({
     url: res.url,
-    ok: res.ok,
     status: res.status,
     statusText: res.statusText,
+    ok: res.ok,
     redirected: res.redirected,
-    headers: headersObj,
-    arrayBuffer: async () => bodyBytes,
-    text: async () => bodyString,
-    json: async () => JSON.parse(bodyString ?? '{}'),
-    clone: () => makeLight(),
+    headers: res.headers,
+    bodyBytes: res.bodyBytes as unknown as ArrayBuffer | undefined,
+    bodyString: res.bodyString,
   });
-
-  const light: any = makeLight();
-  return light as Response;
+  return response as unknown as Response;
 }
 
 // Start a native prefetch. Requires a `prefetchKey` header on the request.
@@ -778,8 +885,12 @@ export async function nitroFetchOnWorklet<T>(
   });
 }
 
+export type { NitroFormDataPart } from './NitroFetch.nitro';
 export type {
-  NitroFormDataPart,
-  NitroRequest,
-  NitroResponse,
+  NitroRequest as NitroRequestNativeType,
+  NitroResponse as NitroResponseNativeType,
 } from './NitroFetch.nitro';
+export { NitroHeaders } from './Headers';
+export { NitroResponse } from './Response';
+export { NitroRequest as NitroRequestClass } from './Request';
+export type { RequestRedirect, RequestCache } from './Request';

package/src/index.tsx

@@ -6,7 +6,16 @@ export {
   removeFromAutoPrefetch,
   removeAllFromAutoprefetch,
 } from './fetch';
-export type { NitroFormDataPart, NitroRequest, NitroResponse } from './fetch';
+export type { NitroFormDataPart } from './fetch';
+export type {
+  NitroRequestNativeType as NitroRequest,
+  NitroResponseNativeType as NitroResponse,
+} from './fetch';
+export type { RequestRedirect, RequestCache } from './fetch';
+export type { BodyInit, ResponseInit } from './Response';
+export { NitroHeaders as Headers } from './Headers';
+export { NitroResponse as Response } from './Response';
+export { NitroRequest as Request } from './Request';
 export { NitroFetch } from './NitroInstances';
 export {
   registerTokenRefresh,
@@ -17,6 +26,18 @@ export {
   applyTemplate,
 } from './tokenRefresh';
 export type { TokenRefreshConfig } from './tokenRefresh';
+export { NetworkInspector } from './NetworkInspector';
+export type {
+  NetworkEntry,
+  NetworkEntryCallback,
+  WebSocketEntry,
+  WebSocketMessage,
+  InspectorEntry,
+} from './NetworkInspector';
+export { generateCurl } from './CurlGenerator';
+export type { CurlOptions } from './CurlGenerator';
+export { profileFetch } from './HermesProfiler';
+export type { ProfileResult } from './HermesProfiler';
 import './fetch';
 
 // Keep legacy export to avoid breaking any local tests/usages during scaffolding.

package/src/utf8.ts

@@ -0,0 +1,40 @@
+let _TextEncoder: typeof TextEncoder | undefined;
+let _TextDecoder: typeof TextDecoder | undefined;
+
+try {
+  _TextEncoder =
+    typeof TextEncoder !== 'undefined'
+      ? TextEncoder
+      : require('react-native-nitro-text-decoder').TextEncoder;
+} catch {
+  /* resolved at first use */
+}
+
+try {
+  _TextDecoder =
+    typeof TextDecoder !== 'undefined'
+      ? TextDecoder
+      : require('react-native-nitro-text-decoder').TextDecoder;
+} catch {
+  /* resolved at first use */
+}
+
+export function stringToUTF8(str: string): Uint8Array {
+  if (!_TextEncoder) {
+    console.warn(
+      'stringToUTF8: TextEncoder not available. Install react-native-nitro-text-decoder.'
+    );
+    return new Uint8Array(0);
+  }
+  return new _TextEncoder().encode(str);
+}
+
+export function utf8ToString(bytes: Uint8Array): string {
+  if (!_TextDecoder) {
+    console.warn(
+      'utf8ToString: TextDecoder not available. Install react-native-nitro-text-decoder.'
+    );
+    return '';
+  }
+  return new _TextDecoder().decode(bytes);
+}