react-native-nitro-fetch 1.3.0 → 1.3.2

package/src/fetch.ts

@@ -167,7 +167,11 @@ function ensureClient() {
 
 function buildNitroRequest(
   input: RequestInfo | URL,
-  init?: RequestInit & { redirect?: RequestRedirect; cache?: RequestCache }
+  init?: RequestInit & {
+    redirect?: RequestRedirect;
+    cache?: RequestCache;
+    prefetchCacheTtlMs?: number;
+  }
 ): NitroRequestNative {
   'worklet';
   let url: string;
@@ -216,6 +220,11 @@ function buildNitroRequest(
   // Determine followRedirects based on redirect option
   const followRedirects = redirectOption === 'follow';
 
+  const prefetchCacheTtlMs =
+    typeof init?.prefetchCacheTtlMs === 'number'
+      ? init.prefetchCacheTtlMs
+      : undefined;
+
   return {
     url,
     method: (method?.toUpperCase() as any) ?? 'GET',
@@ -224,6 +233,7 @@ function buildNitroRequest(
     bodyBytes: undefined as any,
     bodyFormData: normalized?.bodyFormData,
     followRedirects,
+    prefetchCacheTtlMs,
   };
 }
 
@@ -324,7 +334,7 @@ function normalizeBodyPure(
 // Pure JS version of buildNitroRequest that doesnt use anything that breaks worklets
 export function buildNitroRequestPure(
   input: RequestInfo | URL,
-  init?: RequestInit
+  init?: RequestInit & { prefetchCacheTtlMs?: number }
 ): NitroRequestNative {
   'worklet';
   let url: string;
@@ -356,6 +366,11 @@ export function buildNitroRequestPure(
   const headers = headersToPairsPure(headersInit);
   const normalized = normalizeBodyPure(body);
 
+  const prefetchCacheTtlMs =
+    typeof init?.prefetchCacheTtlMs === 'number'
+      ? init.prefetchCacheTtlMs
+      : undefined;
+
   return {
     url,
     method: (method?.toUpperCase() as any) ?? 'GET',
@@ -364,6 +379,7 @@ export function buildNitroRequestPure(
     // Only include bodyBytes when provided to avoid signaling upload data unintentionally
     bodyBytes: undefined as any,
     followRedirects: true,
+    prefetchCacheTtlMs,
   };
 }
 
@@ -742,6 +758,8 @@ export async function prefetch(
   await client.prefetch(req);
 }
 
+const AUTOPREFETCH_QUEUE_KEY = 'nitrofetch_autoprefetch_queue';
+
 // Persist a request to storage so native can prefetch it on app start.
 export async function prefetchOnAppStart(
   input: RequestInfo | URL,
@@ -769,20 +787,27 @@ export async function prefetchOnAppStart(
     {} as Record<string, string>
   );
 
-  const entry = {
+  const entry: Record<string, any> = {
     url: req.url,
     prefetchKey,
     headers: headersObj,
-  } as const;
+  };
+  if (req.method && req.method !== 'GET') entry.method = req.method;
+  if (req.bodyString !== undefined) entry.bodyString = req.bodyString;
+  if (typeof req.bodyBytes === 'string' && req.bodyBytes.length > 0)
+    entry.bodyBytes = req.bodyBytes;
+  if (req.bodyFormData && req.bodyFormData.length > 0)
+    entry.bodyFormData = req.bodyFormData;
+  if (typeof req.timeoutMs === 'number') entry.timeoutMs = req.timeoutMs;
+  if (req.followRedirects === false) entry.followRedirects = false;
+  if (typeof req.prefetchCacheTtlMs === 'number')
+    entry.prefetchCacheTtlMs = req.prefetchCacheTtlMs;
 
   // Write or append to storage queue
   try {
-    const KEY = 'nitrofetch_autoprefetch_queue';
     let arr: any[] = [];
     try {
-      const raw = NativeStorageSingleton.getString(
-        'nitrofetch_autoprefetch_queue'
-      );
+      const raw = NativeStorageSingleton.getString(AUTOPREFETCH_QUEUE_KEY);
       if (raw) arr = JSON.parse(raw);
       if (!Array.isArray(arr)) arr = [];
     } catch {
@@ -792,7 +817,10 @@ export async function prefetchOnAppStart(
       arr = arr.filter((e) => e && e.prefetchKey !== prefetchKey);
     }
     arr.push(entry);
-    NativeStorageSingleton.setString(KEY, JSON.stringify(arr));
+    NativeStorageSingleton.setString(
+      AUTOPREFETCH_QUEUE_KEY,
+      JSON.stringify(arr)
+    );
   } catch (e) {
     console.warn('Failed to persist prefetch queue', e);
   }
@@ -803,12 +831,9 @@ export async function removeFromAutoPrefetch(
   prefetchKey: string
 ): Promise<void> {
   try {
-    const KEY = 'nitrofetch_autoprefetch_queue';
     let arr: any[] = [];
     try {
-      const raw = NativeStorageSingleton.getString(
-        'nitrofetch_autoprefetch_queue'
-      );
+      const raw = NativeStorageSingleton.getString(AUTOPREFETCH_QUEUE_KEY);
       if (raw) arr = JSON.parse(raw);
       if (!Array.isArray(arr)) arr = [];
     } catch {
@@ -816,9 +841,12 @@ export async function removeFromAutoPrefetch(
     }
     const next = arr.filter((e) => e && e.prefetchKey !== prefetchKey);
     if (next.length === 0) {
-      NativeStorageSingleton.removeString(KEY);
+      NativeStorageSingleton.removeString(AUTOPREFETCH_QUEUE_KEY);
     } else if (next.length !== arr.length) {
-      NativeStorageSingleton.setString(KEY, JSON.stringify(next));
+      NativeStorageSingleton.setString(
+        AUTOPREFETCH_QUEUE_KEY,
+        JSON.stringify(next)
+      );
     }
   } catch (e) {
     console.warn('Failed to remove from prefetch queue', e);
@@ -827,8 +855,18 @@ export async function removeFromAutoPrefetch(
 
 // Remove all entries from the auto-prefetch queue.
 export async function removeAllFromAutoprefetch(): Promise<void> {
-  const KEY = 'nitrofetch_autoprefetch_queue';
-  NativeStorageSingleton.setString(KEY, JSON.stringify([]));
+  NativeStorageSingleton.setString(AUTOPREFETCH_QUEUE_KEY, JSON.stringify([]));
+}
+
+export function __readAutoPrefetchQueue(): Array<Record<string, any>> {
+  try {
+    const raw = NativeStorageSingleton.getString(AUTOPREFETCH_QUEUE_KEY);
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
 }
 
 // Optional off-thread processing using react-native-worklets

package/src/index.js

@@ -0,0 +1,25 @@
+export {
+  nitroFetch as fetch,
+  nitroFetchOnWorklet,
+  prefetch,
+  prefetchOnAppStart,
+  removeFromAutoPrefetch,
+  removeAllFromAutoprefetch,
+  __readAutoPrefetchQueue,
+} from './fetch';
+export { NitroHeaders as Headers } from './Headers';
+export { NitroResponse as Response } from './Response';
+export { NitroRequest as Request } from './Request';
+export { NitroFetch } from './NitroInstances';
+export {
+  registerTokenRefresh,
+  clearTokenRefresh,
+  callRefreshEndpoint,
+  getStoredTokenRefreshConfig,
+  getNestedField,
+  applyTemplate,
+} from './tokenRefresh';
+export { NetworkInspector } from './NetworkInspector';
+export { generateCurl } from './CurlGenerator';
+export { profileFetch } from './HermesProfiler';
+import './fetch';

package/src/index.tsx

@@ -5,6 +5,7 @@ export {
   prefetchOnAppStart,
   removeFromAutoPrefetch,
   removeAllFromAutoprefetch,
+  __readAutoPrefetchQueue,
 } from './fetch';
 export type { NitroFormDataPart } from './fetch';
 export type {

package/src/index.web.js

@@ -0,0 +1,106 @@
+// Web entry for react-native-nitro-fetch.
+// Native (Cronet/URLSession) is unavailable on the web, so we delegate to the
+// browser's built-in fetch and stub native-only APIs with console.warn.
+import { NitroRequest as NitroRequestClass } from './Request';
+export { NitroHeaders as Headers } from './Headers';
+export { NitroResponse as Response } from './Response';
+export { NitroRequest as Request } from './Request';
+export { NetworkInspector } from './NetworkInspector';
+export { generateCurl } from './CurlGenerator';
+export { profileFetch } from './HermesProfiler';
+export async function fetch(input, init) {
+  let resolvedInput = input;
+  let resolvedInit = init;
+  if (input instanceof NitroRequestClass) {
+    const method = (init?.method ?? input.method).toUpperCase();
+    const hasBodyMethod = method !== 'GET' && method !== 'HEAD';
+    let body = init?.body;
+    if (body === undefined && hasBodyMethod) {
+      const bytes = await input.arrayBuffer().catch(() => undefined);
+      body = bytes && bytes.byteLength > 0 ? bytes : null;
+    }
+    resolvedInput = input.url;
+    resolvedInit = {
+      ...init,
+      method,
+      headers: init?.headers ?? input.headers,
+      body,
+      redirect: init?.redirect ?? input.redirect,
+      cache: init?.cache ?? input.cache,
+      signal: init?.signal ?? input.signal,
+    };
+  }
+  return globalThis.fetch(resolvedInput, resolvedInit);
+}
+export async function nitroFetchOnWorklet(input, init, mapWorklet, _options) {
+  console.warn(
+    'nitroFetchOnWorklet: worklets are not available on web; running on the JS thread'
+  );
+  const res = await globalThis.fetch(input, init);
+  const bodyBytes = await res.clone().arrayBuffer();
+  let bodyString;
+  try {
+    bodyString = await res.clone().text();
+  } catch {
+    bodyString = undefined;
+  }
+  const headers = [];
+  res.headers.forEach((v, k) => headers.push({ key: k, value: v }));
+  return mapWorklet({
+    url: res.url,
+    status: res.status,
+    statusText: res.statusText,
+    ok: res.ok,
+    redirected: res.redirected ?? false,
+    headers,
+    bodyBytes,
+    bodyString,
+  });
+}
+export async function prefetch(_input, _init) {
+  console.warn('prefetch is not available on web');
+}
+export async function prefetchOnAppStart(_input, _init) {
+  console.warn('prefetchOnAppStart is not available on web');
+}
+export async function removeFromAutoPrefetch(_prefetchKey) {
+  console.warn('removeFromAutoPrefetch is not available on web');
+}
+export async function removeAllFromAutoprefetch() {
+  console.warn('removeAllFromAutoprefetch is not available on web');
+}
+export const NitroFetch = new Proxy(
+  {},
+  {
+    get(_target, prop) {
+      console.warn(`NitroFetch.${String(prop)} is not available on web`);
+      return undefined;
+    },
+  }
+);
+export function registerTokenRefresh(_options) {
+  console.warn('registerTokenRefresh is not available on web');
+}
+export function clearTokenRefresh(_target) {
+  console.warn('clearTokenRefresh is not available on web');
+}
+export async function callRefreshEndpoint(_config) {
+  console.warn('callRefreshEndpoint is not available on web');
+  return {};
+}
+export function getStoredTokenRefreshConfig(_target) {
+  console.warn('getStoredTokenRefreshConfig is not available on web');
+  return null;
+}
+export function getNestedField(obj, dotPath) {
+  const parts = dotPath.split('.');
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== 'object') return undefined;
+    current = current[part];
+  }
+  return current != null ? String(current) : undefined;
+}
+export function applyTemplate(template, value) {
+  return template.replace(/\{\{value\}\}/g, value);
+}

package/src/tokenRefresh.js

@@ -0,0 +1,102 @@
+import { NativeStorage as NativeStorageSingleton } from './NitroInstances';
+// Storage keys
+const KEY_WS = 'nitro_token_refresh_websocket';
+const KEY_FETCH = 'nitro_token_refresh_fetch';
+const KEY_WS_CACHE = 'nitro_token_refresh_ws_cache';
+const KEY_FETCH_CACHE = 'nitro_token_refresh_fetch_cache';
+// — Helpers —
+/**
+ * Resolve a dot-notation path inside a parsed JSON object.
+ */
+export function getNestedField(obj, dotPath) {
+  const parts = dotPath.split('.');
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== 'object') return undefined;
+    current = current[part];
+  }
+  return current != null ? String(current) : undefined;
+}
+export function applyTemplate(template, value) {
+  return template.replace(/\{\{value\}\}/g, value);
+}
+function applyCompositeTemplate(template, values) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => values[key] ?? '');
+}
+export async function callRefreshEndpoint(config) {
+  const method = config.method ?? 'POST';
+  const response = await fetch(config.url, {
+    method,
+    headers: config.headers,
+    body: config.body,
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Token refresh failed: ${response.status} ${response.statusText}`
+    );
+  }
+  const headers = {};
+  if (config.responseType === 'text') {
+    const text = await response.text();
+    if (config.textHeader) {
+      headers[config.textHeader] = config.textTemplate
+        ? applyTemplate(config.textTemplate, text)
+        : text;
+    }
+    return headers;
+  }
+  // Default: json
+  const json = await response.json();
+  if (config.mappings) {
+    for (const mapping of config.mappings) {
+      const value = getNestedField(json, mapping.jsonPath);
+      if (value != null) {
+        headers[mapping.header] = mapping.valueTemplate
+          ? applyTemplate(mapping.valueTemplate, value)
+          : value;
+      }
+    }
+  }
+  if (config.compositeHeaders) {
+    for (const comp of config.compositeHeaders) {
+      const values = {};
+      for (const [placeholder, jsonPath] of Object.entries(comp.paths)) {
+        const val = getNestedField(json, jsonPath);
+        if (val != null) values[placeholder] = val;
+      }
+      headers[comp.header] = applyCompositeTemplate(comp.template, values);
+    }
+  }
+  return headers;
+}
+export function registerTokenRefresh(options) {
+  const { target, ...config } = options;
+  const raw = JSON.stringify(config);
+  if (target === 'websocket' || target === 'all') {
+    NativeStorageSingleton.setSecureString(KEY_WS, raw);
+  }
+  if (target === 'fetch' || target === 'all') {
+    NativeStorageSingleton.setSecureString(KEY_FETCH, raw);
+  }
+}
+export function clearTokenRefresh(target) {
+  const t = target ?? 'all';
+  if (t === 'websocket' || t === 'all') {
+    NativeStorageSingleton.removeSecureString(KEY_WS);
+    NativeStorageSingleton.removeSecureString(KEY_WS_CACHE);
+  }
+  if (t === 'fetch' || t === 'all') {
+    NativeStorageSingleton.removeSecureString(KEY_FETCH);
+    NativeStorageSingleton.removeSecureString(KEY_FETCH_CACHE);
+  }
+}
+export function getStoredTokenRefreshConfig(target) {
+  const key = target === 'websocket' ? KEY_WS : KEY_FETCH;
+  try {
+    const raw = NativeStorageSingleton.getSecureString(key);
+    if (!raw) return null;
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}

package/src/tokenRefresh.ts

@@ -20,6 +20,18 @@ type TokenRefreshCompositeHeader = {
   paths: Record<string, string>;
 };
 
+type TokenRefreshBodyMapping = {
+  jsonPath: string;
+  bodyPath: string;
+  valueTemplate?: string;
+};
+
+type TokenRefreshFormDataMapping = {
+  jsonPath: string;
+  field: string;
+  valueTemplate?: string;
+};
+
 export type TokenRefreshConfig = {
   url: string;
   method?: 'GET' | 'POST' | 'PUT' | 'PATCH';
@@ -30,6 +42,10 @@ export type TokenRefreshConfig = {
   compositeHeaders?: TokenRefreshCompositeHeader[];
   textHeader?: string;
   textTemplate?: string;
+  bodyMappings?: TokenRefreshBodyMapping[];
+  formDataMappings?: TokenRefreshFormDataMapping[];
+  bodyTextPath?: string;
+  formDataTextField?: string;
   onFailure?: 'skip' | 'useStoredHeaders';
 };
 

package/src/utf8.js

@@ -0,0 +1,41 @@
+let _TextEncoder;
+let _TextDecoder;
+const NITRO_TEXT_DECODER_PKG = 'react-native-nitro-text-decoder';
+function loadOptionalTextCodec() {
+  try {
+    // Hide require from the bundler so the package stays truly optional.
+    // eslint-disable-next-line no-new-func
+    const dynamicRequire = new Function('mod', 'return require(mod);');
+    return dynamicRequire(NITRO_TEXT_DECODER_PKG);
+  } catch {
+    return {};
+  }
+}
+if (typeof TextEncoder !== 'undefined') {
+  _TextEncoder = TextEncoder;
+} else {
+  _TextEncoder = loadOptionalTextCodec().TextEncoder;
+}
+if (typeof TextDecoder !== 'undefined') {
+  _TextDecoder = TextDecoder;
+} else {
+  _TextDecoder = loadOptionalTextCodec().TextDecoder;
+}
+export function stringToUTF8(str) {
+  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) {
+  if (!_TextDecoder) {
+    console.warn(
+      'utf8ToString: TextDecoder not available. Install react-native-nitro-text-decoder.'
+    );
+    return '';
+  }
+  return new _TextDecoder().decode(bytes);
+}