react-native-nitro-fetch 0.1.6 → 0.2.0

package/src/fetch.ts

@@ -1,5 +1,7 @@
+import 'web-streams-polyfill/polyfill';
 import type {
   NitroFetch as NitroFetchModule,
+  NitroFormDataPart,
   NitroHeader,
   NitroRequest,
   NitroResponse,
@@ -7,6 +9,7 @@ import type {
 import {
   boxedNitroFetch,
   NitroFetch as NitroFetchSingleton,
+  NitroCronetSingleton,
 } from './NitroInstances';
 import { NativeStorage as NativeStorageSingleton } from './NitroInstances';
 
@@ -65,18 +68,73 @@ function headersToPairs(headers?: HeadersInit): NitroHeader[] | undefined {
   return pairs;
 }
 
-function normalizeBody(
-  body: BodyInit | null | undefined
-): { bodyString?: string; bodyBytes?: ArrayBuffer } | undefined {
+function serializeFormData(fd: FormData): NitroFormDataPart[] {
+  const parts: NitroFormDataPart[] = [];
+
+  if (typeof (fd as any).getParts === 'function') {
+    const rnParts: any[] = (fd as any).getParts();
+    for (const part of rnParts) {
+      if (part.string !== undefined) {
+        parts.push({ name: part.fieldName, value: String(part.string) });
+      } else if (part.uri) {
+        parts.push({
+          name: part.fieldName,
+          fileUri: part.uri,
+          fileName: part.fileName ?? part.name ?? 'file',
+          mimeType: part.type ?? 'application/octet-stream',
+        });
+      }
+    }
+    return parts;
+  }
+
+  fd.forEach((value: any, key: string) => {
+    if (typeof value === 'string') {
+      parts.push({ name: key, value });
+    } else if (value && typeof value === 'object') {
+      parts.push({
+        name: key,
+        fileUri: value.uri ?? value.fileUri,
+        fileName: value.name ?? value.fileName ?? 'file',
+        mimeType: value.type ?? value.mimeType ?? 'application/octet-stream',
+      });
+    }
+  });
+  return parts;
+}
+
+function isFormData(body: unknown): body is FormData {
+  if (typeof FormData !== 'undefined' && body instanceof FormData) return true;
+  if (
+    body &&
+    typeof body === 'object' &&
+    typeof (body as any).append === 'function' &&
+    typeof (body as any).getParts === 'function'
+  ) {
+    return true;
+  }
+  return false;
+}
+
+function normalizeBody(body: BodyInit | null | undefined):
+  | {
+      bodyString?: string;
+      bodyBytes?: ArrayBuffer;
+      bodyFormData?: NitroFormDataPart[];
+    }
+  | undefined {
   'worklet';
   if (body == null) return undefined;
   if (typeof body === 'string') return { bodyString: body };
+
+  if (isFormData(body)) {
+    return { bodyFormData: serializeFormData(body as FormData) };
+  }
   if (body instanceof URLSearchParams) return { bodyString: body.toString() };
   if (typeof ArrayBuffer !== 'undefined' && body instanceof ArrayBuffer)
     return { bodyBytes: body };
   if (ArrayBuffer.isView(body)) {
     const view = body as ArrayBufferView;
-    // Pass a copy/slice of the underlying bytes without base64
     return {
       //@ts-ignore
       bodyBytes: view.buffer.slice(
@@ -85,7 +143,6 @@ function normalizeBody(
       ),
     };
   }
-  // TODO: Blob/FormData support can be added later
   throw new Error('Unsupported body type for nitro fetch');
 }
 
@@ -136,8 +193,8 @@ function buildNitroRequest(
     method: (method?.toUpperCase() as any) ?? 'GET',
     headers,
     bodyString: normalized?.bodyString,
-    // Only include bodyBytes when provided to avoid signaling upload data unintentionally
     bodyBytes: undefined as any,
+    bodyFormData: normalized?.bodyFormData,
     followRedirects: true,
   };
 }
@@ -224,7 +281,6 @@ function normalizeBodyPure(
 
   if (ArrayBuffer.isView(body)) {
     const view = body as ArrayBufferView;
-    // Pass a copy/slice of the underlying bytes without base64
     return {
       //@ts-ignore
       bodyBytes: view.buffer.slice(
@@ -233,8 +289,9 @@ function normalizeBodyPure(
       ),
     };
   }
-  // TODO: Blob/FormData support can be added later
-  throw new Error('Unsupported body type for nitro fetch');
+  throw new Error(
+    'Unsupported body type for nitro fetch worklet (FormData is not available in worklets)'
+  );
 }
 // Pure JS version of buildNitroRequest that doesnt use anything that breaks worklets
 export function buildNitroRequestPure(
@@ -282,10 +339,23 @@ export function buildNitroRequestPure(
   };
 }
 
+function createAbortError(): Error {
+  const err = new Error('The operation was aborted.');
+  err.name = 'AbortError';
+  return err;
+}
+
 async function nitroFetchRaw(
   input: RequestInfo | URL,
   init?: RequestInit
 ): Promise<NitroResponse> {
+  const signal = init?.signal as AbortSignal | undefined | null;
+
+  // Fast-abort: reject synchronously before any bridge work.
+  if (signal?.aborted) {
+    throw createAbortError();
+  }
+
   const hasNative =
     typeof (NitroFetchHybrid as any)?.createClient === 'function';
   if (!hasNative) {
@@ -309,11 +379,46 @@ async function nitroFetchRaw(
   }
 
   const req = buildNitroRequest(input, init);
+
+  // Only allocate a requestId when a signal is present — zero overhead otherwise.
+  const requestId = signal ? String(Math.random()) : undefined;
+  if (requestId) req.requestId = requestId;
+
   ensureClient();
   if (!client || typeof (client as any).request !== 'function')
     throw new Error('NitroFetch client not available');
-  const res: NitroResponse = await client.request(req);
-  return res;
+
+  // Wire up the abort listener with { once: true } so it auto-removes
+  // after firing, avoiding a dangling reference to the client closure.
+  let abortListener: (() => void) | undefined;
+  if (signal && requestId) {
+    abortListener = () => {
+      try {
+        client!.cancelRequest(requestId);
+      } catch {
+        // Client may already be torn down — swallow.
+      }
+    };
+    signal.addEventListener('abort', abortListener, { once: true });
+  }
+
+  try {
+    const res: NitroResponse = await client.request(req);
+    return res;
+  } catch (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) {
+      throw createAbortError();
+    }
+    throw e;
+  } finally {
+    // Idempotent cleanup — removeEventListener is a no-op if the listener
+    // already fired (thanks to { once: true }) or was never added.
+    if (signal && abortListener) {
+      signal.removeEventListener('abort', abortListener);
+    }
+  }
 }
 
 // Simple Headers-like class that supports get() method
@@ -353,10 +458,102 @@ class NitroHeaders {
   }
 }
 
-export async function nitroFetch(
+async function nitroStreamFetch(
   input: RequestInfo | URL,
   init?: RequestInit
 ): Promise<Response> {
+  const url = typeof input === 'string' ? input : String(input);
+  const method = init?.method?.toUpperCase() ?? 'GET';
+  const headers = headersToPairs(init?.headers);
+
+  const builder = NitroCronetSingleton.newUrlRequestBuilder(url);
+  builder.setHttpMethod(method);
+  headers?.forEach((h) => builder.addHeader(h.key, h.value));
+
+  const body = init?.body;
+  if (body != null) {
+    if (typeof body === 'string') builder.setUploadBody(body);
+    else if (body instanceof ArrayBuffer) builder.setUploadBody(body);
+  }
+
+  return new Promise((resolveResponse, rejectResponse) => {
+    let streamController: ReadableStreamDefaultController<Uint8Array>;
+
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        streamController = controller;
+      },
+    });
+
+    let responseResolved = false;
+
+    builder.onResponseStarted((info) => {
+      if (responseResolved) return;
+      responseResolved = true;
+      const status = info.httpStatusCode;
+      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 = {
+        url: info.url,
+        ok: status >= 200 && status < 300,
+        status,
+        statusText: info.httpStatusText,
+        headers: responseHeaders,
+        redirected: false,
+        body: stream,
+        bodyUsed: false,
+      };
+      resolveResponse(response as Response);
+      // Android/Cronet: kick off the first buffer read.
+      // iOS/URLSession handles reading automatically so this is a no-op there.
+      request.read();
+    });
+
+    builder.onReadCompleted((_info, byteBuffer, bytesRead) => {
+      const chunk = new Uint8Array(byteBuffer, 0, bytesRead).slice();
+      streamController.enqueue(chunk);
+      if (!request.isDone()) {
+        request.read();
+      }
+    });
+
+    builder.onSucceeded(() => streamController.close());
+
+    builder.onFailed((_info, error) => {
+      const err = new Error(error.message);
+      if (!responseResolved) {
+        responseResolved = true;
+        rejectResponse(err);
+      } else {
+        streamController.error(err);
+      }
+    });
+
+    builder.onCanceled(() => {
+      const err = createAbortError();
+      if (!responseResolved) {
+        responseResolved = true;
+        rejectResponse(err);
+      } else {
+        streamController.error(err);
+      }
+    });
+
+    const request = builder.build();
+    request.start();
+  });
+}
+
+export async function nitroFetch(
+  input: RequestInfo | URL,
+  init?: RequestInit & { stream?: boolean }
+): Promise<Response> {
+  if ((init as any)?.stream === true) {
+    return nitroStreamFetch(input, init);
+  }
   const res = await nitroFetchRaw(input, init);
 
   const headersObj = new NitroHeaders(res.headers);
@@ -598,4 +795,8 @@ export async function nitroFetchOnWorklet<T>(
 export const x = ensureWorkletRuntime();
 export const y = getWorklets();
 
-export type { NitroRequest, NitroResponse } from './NitroFetch.nitro';
+export type {
+  NitroFormDataPart,
+  NitroRequest,
+  NitroResponse,
+} from './NitroFetch.nitro';

package/src/index.tsx

@@ -6,7 +6,7 @@ export {
   removeFromAutoPrefetch,
   removeAllFromAutoprefetch,
 } from './fetch';
-export type { NitroRequest, NitroResponse } from './fetch';
+export type { NitroFormDataPart, NitroRequest, NitroResponse } from './fetch';
 export { NitroFetch } from './NitroInstances';
 import './fetch';