react-native-nitro-fetch 1.3.0 → 1.3.2

package/android/build.gradle

@@ -85,6 +85,18 @@ android {
     release {
       minifyEnabled false
     }
+
+    // Reverting due to build failure
+    // // The app's RN-managed `debugOptimized` build type (added by the React Native
+    // // gradle plugin, app-only) falls back to this library's `release` variant, where
+    // // BuildConfig.DEBUG is false — which constant-folds out the native DevTools/CDP
+    // // network reporting in NitroFetchClient.kt. Define a matching debuggable variant
+    // // so debugOptimized links a BuildConfig.DEBUG=true build and requests surface in
+    // // the React Native DevTools Network panel.
+    // debugOptimized {
+    //   initWith debug
+    //   matchingFallbacks += ["release"]
+    // }
   }
 
   lintOptions {

package/android/src/main/java/com/margelo/nitro/nitrofetch/AutoPrefetcher.kt

@@ -31,9 +31,21 @@ object AutoPrefetcher {
     context: Context,
     url: String,
     prefetchKey: String,
-    headers: Map<String, String> = emptyMap()
+    headers: Map<String, String> = emptyMap(),
+    method: String? = null,
+    bodyString: String? = null,
+    bodyBytes: String? = null,
+    bodyFormData: List<Map<String, String?>>? = null,
+    timeoutMs: Double? = null,
+    followRedirects: Boolean? = null,
+    prefetchCacheTtlMs: Double? = null,
   ) {
     if (url.isEmpty() || prefetchKey.isEmpty()) return
+    val entry = buildEntryJson(
+      url, prefetchKey, headers,
+      method, bodyString, bodyBytes, bodyFormData, timeoutMs, followRedirects,
+      prefetchCacheTtlMs
+    )
     try {
       val prefs = context.applicationContext
         .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
@@ -46,14 +58,6 @@ object AutoPrefetcher {
         if (o.optString("prefetchKey", "") == prefetchKey) continue
         next.put(o)
       }
-
-      val headersObj = JSONObject()
-      headers.forEach { (k, v) -> headersObj.put(k, v) }
-      val entry = JSONObject().apply {
-        put("url", url)
-        put("prefetchKey", prefetchKey)
-        put("headers", headersObj)
-      }
       next.put(entry)
       prefs.edit().putString(KEY_QUEUE, next.toString()).apply()
     } catch (_: Throwable) {
@@ -61,28 +65,14 @@ object AutoPrefetcher {
     }
 
     if (initialized) {
-      // late path — kick a single immediate prefetch with cached token headers
+      // late path — kick a single immediate prefetch with cached tokens
       try {
         val prefs = context.applicationContext
           .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
-        val cacheRaw = NitroFetchSecureAtRest.getDecryptedForPrefs(prefs, KEY_TOKEN_CACHE)
-        val tokenHeaders: Map<String, String> = if (!cacheRaw.isNullOrEmpty()) {
-          try {
-            val co = JSONObject(cacheRaw)
-            co.keys().asSequence().associateWith { k -> co.optString(k, "") }
-          } catch (_: Throwable) { emptyMap() }
-        } else emptyMap()
-
-        val single = JSONArray().apply {
-          val headersObj = JSONObject()
-          headers.forEach { (k, v) -> headersObj.put(k, v) }
-          put(JSONObject().apply {
-            put("url", url)
-            put("prefetchKey", prefetchKey)
-            put("headers", headersObj)
-          })
-        }
-        startPrefetches(single, tokenHeaders)
+        val tokens = deserializeCache(NitroFetchSecureAtRest.getDecryptedForPrefs(prefs, KEY_TOKEN_CACHE))
+
+        val single = JSONArray().apply { put(entry) }
+        startPrefetches(single, tokens)
       } catch (_: Throwable) {}
     }
   }
@@ -109,13 +99,11 @@ object AutoPrefetcher {
 
             val refreshed = callTokenRefreshSync(refreshConfig)
 
-            val tokenHeaders: Map<String, String> = if (refreshed != null) {
-              android.util.Log.d("NitroFetch", "[TokenRefresh] ✅ Success — got ${refreshed.size} header(s)")
-              refreshed.forEach { (k, v) -> android.util.Log.d("NitroFetch", "[TokenRefresh]   $k: $v") }
-              // Cache fresh token headers for useStoredHeaders fallback on next cold start
-              val cacheJson = JSONObject()
-              refreshed.forEach { (k, v) -> cacheJson.put(k, v) }
-              NitroFetchSecureAtRest.putEncrypted(prefs, KEY_TOKEN_CACHE, cacheJson.toString())
+            val tokens: TokenRefreshResult = if (refreshed != null) {
+              android.util.Log.d("NitroFetch", "[TokenRefresh] ✅ Success — got ${refreshed.headers.size} header(s)")
+              refreshed.headers.forEach { (k, v) -> android.util.Log.d("NitroFetch", "[TokenRefresh]   $k: $v") }
+              // Cache fresh tokens for useStoredHeaders fallback on next cold start
+              NitroFetchSecureAtRest.putEncrypted(prefs, KEY_TOKEN_CACHE, serializeCache(refreshed))
               refreshed
             } else {
               android.util.Log.d("NitroFetch", "[TokenRefresh] ❌ Refresh failed — onFailure: $onFailure")
@@ -123,36 +111,28 @@ object AutoPrefetcher {
                 android.util.Log.d("NitroFetch", "[TokenRefresh] Skipping all prefetches")
                 return@Thread
               }
-              // Use last cached token headers (or empty map if none cached yet)
-              val cacheRaw = NitroFetchSecureAtRest.getDecryptedForPrefs(prefs, KEY_TOKEN_CACHE)
-              val cached = if (cacheRaw != null) {
-                try {
-                  val co = JSONObject(cacheRaw)
-                  co.keys().asSequence().associateWith { k -> co.optString(k, "") }
-                } catch (_: Throwable) { emptyMap() }
-              } else {
-                emptyMap()
-              }
-              android.util.Log.d("NitroFetch", "[TokenRefresh] Using cached headers (${cached.size} header(s))")
+              // Use last cached tokens (or empty if none cached yet)
+              val cached = deserializeCache(NitroFetchSecureAtRest.getDecryptedForPrefs(prefs, KEY_TOKEN_CACHE))
+              android.util.Log.d("NitroFetch", "[TokenRefresh] Using cached headers (${cached.headers.size} header(s))")
               cached
             }
 
             android.util.Log.d("NitroFetch", "[TokenRefresh] Injecting token headers into ${arr.length()} prefetch URL(s)")
-            startPrefetches(arr, tokenHeaders)
+            startPrefetches(arr, tokens)
           } catch (_: Throwable) {
             // Best-effort — never crash the app
           }
         }.start()
       } else {
         // No token refresh config — proceed on current thread (Cronet is async)
-        startPrefetches(arr, emptyMap())
+        startPrefetches(arr, TokenRefreshResult.EMPTY)
       }
     } catch (_: Throwable) {
       // ignore – prefetch-on-start is best-effort
     }
   }
 
-  private fun startPrefetches(arr: JSONArray, tokenHeaders: Map<String, String>) {
+  private fun startPrefetches(arr: JSONArray, tokens: TokenRefreshResult) {
     for (i in 0 until arr.length()) {
       val o = arr.optJSONObject(i) ?: continue
       val url = o.optString("url", null) ?: continue
@@ -164,26 +144,18 @@ object AutoPrefetcher {
       headersObj.keys().forEachRemaining { k ->
         merged[k] = headersObj.optString(k, "")
       }
-      tokenHeaders.forEach { (k, v) -> merged[k] = v }
+      tokens.headers.forEach { (k, v) -> merged[k] = v }
       merged["prefetchKey"] = prefetchKey
 
       android.util.Log.d("NitroFetch", "[TokenRefresh] Prefetching $url with ${merged.size} header(s)")
       merged.forEach { (k, v) -> android.util.Log.d("NitroFetch", "[TokenRefresh]   $k: $v") }
-      val headerObjs = merged.map { (k, v) -> NitroHeader(k, v) }.toTypedArray()
-      val req = NitroRequest(
-        url = url,
-        method = null,
-        headers = headerObjs,
-        bodyString = null,
-        bodyBytes = null,
-        bodyFormData = null,
-        timeoutMs = null,
-        followRedirects = null,
-        requestId = null
-      )
+      val req = buildNitroRequestFromEntry(url, merged, o, tokens)
 
       if (FetchCache.getPending(prefetchKey) != null) continue
-      if (FetchCache.hasFreshResult(prefetchKey, 5_000L)) continue
+      val entryTtlMs = if (o.has("prefetchCacheTtlMs") && !o.isNull("prefetchCacheTtlMs")) {
+        o.optDouble("prefetchCacheTtlMs").toLong()
+      } else 5_000L
+      if (FetchCache.hasFreshResult(prefetchKey, entryTtlMs)) continue
 
       val future = CompletableFuture<NitroResponse>()
       FetchCache.setPending(prefetchKey, future)
@@ -205,9 +177,118 @@ object AutoPrefetcher {
     }
   }
 
+  private fun buildEntryJson(
+    url: String,
+    prefetchKey: String,
+    headers: Map<String, String>,
+    method: String?,
+    bodyString: String?,
+    bodyBytes: String?,
+    bodyFormData: List<Map<String, String?>>?,
+    timeoutMs: Double?,
+    followRedirects: Boolean?,
+    prefetchCacheTtlMs: Double? = null,
+  ): JSONObject {
+    val headersObj = JSONObject()
+    headers.forEach { (k, v) -> headersObj.put(k, v) }
+    return JSONObject().apply {
+      put("url", url)
+      put("prefetchKey", prefetchKey)
+      put("headers", headersObj)
+      if (method != null && method.isNotEmpty() && method != "GET") put("method", method)
+      if (bodyString != null) put("bodyString", bodyString)
+      if (bodyBytes != null) put("bodyBytes", bodyBytes)
+      if (!bodyFormData.isNullOrEmpty()) {
+        val arr = JSONArray()
+        bodyFormData.forEach { part ->
+          val obj = JSONObject()
+          part["name"]?.let { obj.put("name", it) }
+          part["value"]?.let { obj.put("value", it) }
+          part["fileUri"]?.let { obj.put("fileUri", it) }
+          part["fileName"]?.let { obj.put("fileName", it) }
+          part["mimeType"]?.let { obj.put("mimeType", it) }
+          arr.put(obj)
+        }
+        put("bodyFormData", arr)
+      }
+      if (timeoutMs != null) put("timeoutMs", timeoutMs)
+      if (followRedirects == false) put("followRedirects", false)
+      if (prefetchCacheTtlMs != null) put("prefetchCacheTtlMs", prefetchCacheTtlMs)
+    }
+  }
+
+  private fun buildNitroRequestFromEntry(
+    url: String,
+    mergedHeaders: Map<String, String>,
+    entry: JSONObject?,
+    tokens: TokenRefreshResult = TokenRefreshResult.EMPTY,
+  ): NitroRequest {
+    val headerObjs = mergedHeaders.map { (k, v) -> NitroHeader(k, v) }.toTypedArray()
+
+    val methodStr = entry?.optString("method", "")?.takeIf { it.isNotEmpty() }
+    val method: NitroRequestMethod? = methodStr?.let {
+      runCatching { NitroRequestMethod.valueOf(it) }.getOrNull()
+    }
+    val rawBodyString = entry
+      ?.takeIf { it.has("bodyString") && !it.isNull("bodyString") }
+      ?.optString("bodyString")
+    val bodyString = injectBodyFields(rawBodyString, tokens.bodyFields)
+    val bodyBytes = entry
+      ?.takeIf { it.has("bodyBytes") && !it.isNull("bodyBytes") }
+      ?.optString("bodyBytes")
+    val timeoutMs = entry
+      ?.takeIf { it.has("timeoutMs") && !it.isNull("timeoutMs") }
+      ?.optDouble("timeoutMs")
+    val followRedirects = entry
+      ?.takeIf { it.has("followRedirects") && !it.isNull("followRedirects") }
+      ?.optBoolean("followRedirects")
+    val prefetchCacheTtlMs = entry
+      ?.takeIf { it.has("prefetchCacheTtlMs") && !it.isNull("prefetchCacheTtlMs") }
+      ?.optDouble("prefetchCacheTtlMs")
+
+    val formArr = entry?.optJSONArray("bodyFormData")
+    val baseParts: List<NitroFormDataPart> = formArr?.let { ja ->
+      List(ja.length()) { i ->
+        val p = ja.optJSONObject(i) ?: JSONObject()
+        NitroFormDataPart(
+          name = p.optString("name", ""),
+          value = if (p.has("value") && !p.isNull("value")) p.optString("value") else null,
+          fileUri = if (p.has("fileUri") && !p.isNull("fileUri")) p.optString("fileUri") else null,
+          fileName = if (p.has("fileName") && !p.isNull("fileName")) p.optString("fileName") else null,
+          mimeType = if (p.has("mimeType") && !p.isNull("mimeType")) p.optString("mimeType") else null
+        )
+      }
+    } ?: emptyList()
+    val bodyFormData: Array<NitroFormDataPart>? =
+      injectFormFields(baseParts, tokens.formFields)?.toTypedArray()
+
+    return NitroRequest(
+      url = url,
+      method = method,
+      headers = headerObjs,
+      bodyString = bodyString,
+      bodyBytes = bodyBytes,
+      bodyFormData = bodyFormData,
+      timeoutMs = timeoutMs,
+      followRedirects = followRedirects,
+      prefetchCacheTtlMs = prefetchCacheTtlMs,
+      requestId = null
+    )
+  }
+
   // MARK: - Token refresh (synchronous, runs on background thread)
 
-  private fun callTokenRefreshSync(config: JSONObject): Map<String, String>? {
+  private data class TokenRefreshResult(
+    val headers: Map<String, String>,
+    val bodyFields: Map<String, String>,
+    val formFields: Map<String, String>,
+  ) {
+    companion object {
+      val EMPTY = TokenRefreshResult(emptyMap(), emptyMap(), emptyMap())
+    }
+  }
+
+  private fun callTokenRefreshSync(config: JSONObject): TokenRefreshResult? {
     return try {
       val urlStr = config.optString("url", null) ?: return null
       val method = config.optString("method", "POST")
@@ -255,33 +336,31 @@ object AutoPrefetcher {
     body: String,
     responseType: String,
     config: JSONObject
-  ): Map<String, String> {
-    val result = mutableMapOf<String, String>()
+  ): TokenRefreshResult {
+    val headers = mutableMapOf<String, String>()
+    val bodyFields = mutableMapOf<String, String>()
+    val formFields = mutableMapOf<String, String>()
 
     if (responseType == "text") {
       val textHeader = config.optString("textHeader", null)
       if (textHeader != null) {
         val textTemplate = config.optString("textTemplate", null)
-        result[textHeader] = textTemplate?.replace("{{value}}", body) ?: body
+        headers[textHeader] = textTemplate?.replace("{{value}}", body) ?: body
       }
-      return result
+      config.optString("bodyTextPath", null)?.let { bodyFields[it] = body }
+      config.optString("formDataTextField", null)?.let { formFields[it] = body }
+      return TokenRefreshResult(headers, bodyFields, formFields)
     }
 
     // JSON
-    val json = try { JSONObject(body) } catch (_: Throwable) { return result }
-
-    val mappings = config.optJSONArray("mappings")
-    if (mappings != null) {
-      for (i in 0 until mappings.length()) {
-        val m = mappings.optJSONObject(i) ?: continue
-        val jsonPath = m.optString("jsonPath", null) ?: continue
-        val header = m.optString("header", null) ?: continue
-        val value = getNestedField(json, jsonPath) ?: continue
-        val tmpl = m.optString("valueTemplate", null)
-        result[header] = tmpl?.replace("{{value}}", value) ?: value
-      }
+    val json = try { JSONObject(body) } catch (_: Throwable) {
+      return TokenRefreshResult(headers, bodyFields, formFields)
     }
 
+    collectMappings(json, config.optJSONArray("mappings"), "header", headers)
+    collectMappings(json, config.optJSONArray("bodyMappings"), "bodyPath", bodyFields)
+    collectMappings(json, config.optJSONArray("formDataMappings"), "field", formFields)
+
     val compositeHeaders = config.optJSONArray("compositeHeaders")
     if (compositeHeaders != null) {
       for (i in 0 until compositeHeaders.length()) {
@@ -294,11 +373,29 @@ object AutoPrefetcher {
           val val2 = getNestedField(json, paths.optString(ph, ""))
           built = built.replace("{{$ph}}", val2 ?: "")
         }
-        result[header] = built
+        headers[header] = built
       }
     }
 
-    return result
+    return TokenRefreshResult(headers, bodyFields, formFields)
+  }
+
+  // jsonPath -> value (optionally templated), keyed by the mapping's `destKey` field.
+  private fun collectMappings(
+    json: JSONObject,
+    arr: JSONArray?,
+    destKey: String,
+    into: MutableMap<String, String>,
+  ) {
+    if (arr == null) return
+    for (i in 0 until arr.length()) {
+      val m = arr.optJSONObject(i) ?: continue
+      val jsonPath = m.optString("jsonPath", null) ?: continue
+      val dest = m.optString(destKey, null) ?: continue
+      val value = getNestedField(json, jsonPath) ?: continue
+      val tmpl = m.optString("valueTemplate", null)
+      into[dest] = tmpl?.replace("{{value}}", value) ?: value
+    }
   }
 
   private fun getNestedField(obj: JSONObject, dotPath: String): String? {
@@ -310,4 +407,83 @@ object AutoPrefetcher {
     }
     return current.toString()
   }
+
+  private fun setNestedField(root: JSONObject, dotPath: String, value: String) {
+    val parts = dotPath.split(".")
+    var current = root
+    for (i in 0 until parts.size - 1) {
+      val key = parts[i]
+      val existing = current.optJSONObject(key)
+      current = existing ?: JSONObject().also { current.put(key, it) }
+    }
+    current.put(parts.last(), value)
+  }
+
+  private fun injectBodyFields(rawBody: String?, fields: Map<String, String>): String? {
+    if (fields.isEmpty()) return rawBody
+    // Don't synthesize a JSON body where there wasn't one (e.g. a GET or a
+    // form-data request) — only rewrite an existing JSON body.
+    if (rawBody.isNullOrEmpty()) return rawBody
+    val root = try {
+      JSONObject(rawBody)
+    } catch (_: Throwable) {
+      return rawBody
+    }
+    fields.forEach { (path, value) -> setNestedField(root, path, value) }
+    return root.toString()
+  }
+
+  private fun injectFormFields(
+    parts: List<NitroFormDataPart>,
+    fields: Map<String, String>,
+  ): List<NitroFormDataPart>? {
+    if (fields.isEmpty()) return parts.ifEmpty { null }
+    // Don't synthesize a multipart body where there wasn't one.
+    if (parts.isEmpty()) return null
+    val result = parts.toMutableList()
+    fields.forEach { (name, value) ->
+      val idx = result.indexOfFirst { it.name == name }
+      if (idx >= 0) {
+        val old = result[idx]
+        result[idx] = NitroFormDataPart(
+          name = old.name, value = value,
+          fileUri = null, fileName = old.fileName, mimeType = old.mimeType
+        )
+      } else {
+        result.add(NitroFormDataPart(name, value, null, null, null))
+      }
+    }
+    return result
+  }
+
+  private fun mapToJson(map: Map<String, String>): JSONObject {
+    val o = JSONObject()
+    map.forEach { (k, v) -> o.put(k, v) }
+    return o
+  }
+
+  private fun jsonToMap(obj: JSONObject?): Map<String, String> {
+    if (obj == null) return emptyMap()
+    return obj.keys().asSequence().associateWith { k -> obj.optString(k, "") }
+  }
+
+  private fun serializeCache(result: TokenRefreshResult): String =
+    JSONObject().apply {
+      put("headers", mapToJson(result.headers))
+      put("bodyFields", mapToJson(result.bodyFields))
+      put("formFields", mapToJson(result.formFields))
+    }.toString()
+
+  private fun deserializeCache(raw: String?): TokenRefreshResult {
+    if (raw.isNullOrEmpty()) return TokenRefreshResult.EMPTY
+    val o = try { JSONObject(raw) } catch (_: Throwable) { return TokenRefreshResult.EMPTY }
+    if (!o.has("headers") && !o.has("bodyFields") && !o.has("formFields")) {
+      return TokenRefreshResult(jsonToMap(o), emptyMap(), emptyMap())
+    }
+    return TokenRefreshResult(
+      headers = jsonToMap(o.optJSONObject("headers")),
+      bodyFields = jsonToMap(o.optJSONObject("bodyFields")),
+      formFields = jsonToMap(o.optJSONObject("formFields")),
+    )
+  }
 }

package/android/src/main/java/com/margelo/nitro/nitrofetch/NitroFetchClient.kt

@@ -403,7 +403,7 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
           throw e.cause ?: e
         }
       }
-      FetchCache.getResultIfFresh(key, 5_000L)?.let { cached ->
+      FetchCache.getResultIfFresh(key, req.prefetchCacheTtlMs?.toLong() ?: 5_000L)?.let { cached ->
         return withPrefetchedHeader(cached)
       }
     }
@@ -445,8 +445,8 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
         }
         return promise
       }
-      // If a fresh prefetched result exists (<=5s old), return it immediately
-      FetchCache.getResultIfFresh(key, 5_000L)?.let { cached ->
+      // If a fresh prefetched result exists, return it immediately
+      FetchCache.getResultIfFresh(key, req.prefetchCacheTtlMs?.toLong() ?: 5_000L)?.let { cached ->
         promise.resolve(withPrefetchedHeader(cached))
         return promise
       }
@@ -479,7 +479,7 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
       return promise
     }
     // If already have a fresh result, resolve immediately (NON-DESTRUCTIVE CHECK)
-    if (FetchCache.hasFreshResult(key, 5_000L)) {
+    if (FetchCache.hasFreshResult(key, req.prefetchCacheTtlMs?.toLong() ?: 5_000L)) {
       promise.resolve(Unit)
       return promise
     }

package/ios/NitroAutoPrefetcher.h

@@ -20,6 +20,27 @@ NS_ASSUME_NONNULL_BEGIN
                     prefetchKey:(NSString *)prefetchKey
                         headers:(NSDictionary<NSString *, NSString *> *)headers;
 
++ (void)registerPrefetchWithURL:(NSString *)url
+                    prefetchKey:(NSString *)prefetchKey
+                        headers:(NSDictionary<NSString *, NSString *> *)headers
+                         method:(nullable NSString *)method
+                     bodyString:(nullable NSString *)bodyString
+                      bodyBytes:(nullable NSString *)bodyBytes
+                   bodyFormData:(nullable NSArray<NSDictionary<NSString *, NSString *> *> *)bodyFormData
+                      timeoutMs:(nullable NSNumber *)timeoutMs
+                followRedirects:(nullable NSNumber *)followRedirects;
+
++ (void)registerPrefetchWithURL:(NSString *)url
+                    prefetchKey:(NSString *)prefetchKey
+                        headers:(NSDictionary<NSString *, NSString *> *)headers
+                         method:(nullable NSString *)method
+                     bodyString:(nullable NSString *)bodyString
+                      bodyBytes:(nullable NSString *)bodyBytes
+                   bodyFormData:(nullable NSArray<NSDictionary<NSString *, NSString *> *> *)bodyFormData
+                      timeoutMs:(nullable NSNumber *)timeoutMs
+                followRedirects:(nullable NSNumber *)followRedirects
+             prefetchCacheTtlMs:(nullable NSNumber *)prefetchCacheTtlMs;
+
 @end
 
 NS_ASSUME_NONNULL_END