react-native-nitro-fetch 1.3.1 → 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

@@ -65,20 +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 tokens = deserializeCache(NitroFetchSecureAtRest.getDecryptedForPrefs(prefs, KEY_TOKEN_CACHE))
 
         val single = JSONArray().apply { put(entry) }
-        startPrefetches(single, tokenHeaders)
+        startPrefetches(single, tokens)
       } catch (_: Throwable) {}
     }
   }
@@ -105,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")
@@ -119,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
@@ -160,12 +144,12 @@ 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 req = buildNitroRequestFromEntry(url, merged, o)
+      val req = buildNitroRequestFromEntry(url, merged, o, tokens)
 
       if (FetchCache.getPending(prefetchKey) != null) continue
       val entryTtlMs = if (o.has("prefetchCacheTtlMs") && !o.isNull("prefetchCacheTtlMs")) {
@@ -237,6 +221,7 @@ object AutoPrefetcher {
     url: String,
     mergedHeaders: Map<String, String>,
     entry: JSONObject?,
+    tokens: TokenRefreshResult = TokenRefreshResult.EMPTY,
   ): NitroRequest {
     val headerObjs = mergedHeaders.map { (k, v) -> NitroHeader(k, v) }.toTypedArray()
 
@@ -244,9 +229,10 @@ object AutoPrefetcher {
     val method: NitroRequestMethod? = methodStr?.let {
       runCatching { NitroRequestMethod.valueOf(it) }.getOrNull()
     }
-    val bodyString = entry
+    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")
@@ -261,8 +247,8 @@ object AutoPrefetcher {
       ?.optDouble("prefetchCacheTtlMs")
 
     val formArr = entry?.optJSONArray("bodyFormData")
-    val bodyFormData: Array<NitroFormDataPart>? = formArr?.let { ja ->
-      Array(ja.length()) { i ->
+    val baseParts: List<NitroFormDataPart> = formArr?.let { ja ->
+      List(ja.length()) { i ->
         val p = ja.optJSONObject(i) ?: JSONObject()
         NitroFormDataPart(
           name = p.optString("name", ""),
@@ -272,7 +258,9 @@ object AutoPrefetcher {
           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,
@@ -290,7 +278,17 @@ object AutoPrefetcher {
 
   // 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")
@@ -338,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()) {
@@ -377,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? {
@@ -393,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/ios/NitroAutoPrefetcher.swift

@@ -111,19 +111,14 @@ public final class NitroAutoPrefetcher: NSObject {
     }
 
     if initialized {
-      // Late path — apply cached token headers + kick immediate prefetch
-      var tokenHeaders: [String: String] = [:]
-      if let cacheRaw = NitroFetchSecureAtRest.decryptedString(forKey: tokenCacheKey, defaults: userDefaults),
-         !cacheRaw.isEmpty,
-         let cacheData = cacheRaw.data(using: .utf8),
-         let cacheObj = try? JSONSerialization.jsonObject(with: cacheData) as? [String: String] {
-        tokenHeaders = cacheObj
-      }
+      // Late path — apply cached tokens + kick immediate prefetch
+      let tokens = deserializeCache(
+        NitroFetchSecureAtRest.decryptedString(forKey: tokenCacheKey, defaults: userDefaults))
       var merged: [String: String] = headers
-      for (k, v) in tokenHeaders { merged[k] = v }
+      for (k, v) in tokens.headers { merged[k] = v }
       var hdrs: [NitroHeader] = merged.map { NitroHeader(key: $0.key, value: $0.value) }
       hdrs.append(NitroHeader(key: "prefetchKey", value: prefetchKey))
-      let req = buildNitroRequest(from: entry, mergedHeaders: hdrs)
+      let req = buildNitroRequest(from: entry, mergedHeaders: hdrs, tokens: tokens)
       Task {
         do { try await NitroFetchClient.prefetchStatic(req) } catch { /* best-effort */ }
       }
@@ -143,8 +138,8 @@ public final class NitroAutoPrefetcher: NSObject {
     let refreshRaw = NitroFetchSecureAtRest.decryptedString(forKey: tokenRefreshKey, defaults: userDefaults)
 
     Task {
-      // Resolve token headers (may require a network call)
-      let tokenHeaders: [String: String]
+      // Resolve tokens (may require a network call)
+      let tokens: TokenRefreshResult
       if let refreshRaw = refreshRaw,
          !refreshRaw.isEmpty,
          let refreshData = refreshRaw.data(using: .utf8),
@@ -154,35 +149,29 @@ public final class NitroAutoPrefetcher: NSObject {
         print("[NitroFetch][TokenRefresh] Calling refresh endpoint: \(refreshURL)")
         let refreshed = try? await callTokenRefresh(config: refreshObj)
         if let refreshed = refreshed {
-          print("[NitroFetch][TokenRefresh] ✅ Success — got \(refreshed.count) header(s)")
-          for (k, v) in refreshed { print("[NitroFetch][TokenRefresh]   \(k): \(v)") }
-          // Cache fresh token headers for useStoredHeaders fallback on next cold start
-          if let cacheData = try? JSONSerialization.data(withJSONObject: refreshed),
-             let cacheStr = String(data: cacheData, encoding: .utf8) {
+          print("[NitroFetch][TokenRefresh] ✅ Success — got \(refreshed.headers.count) header(s)")
+          for (k, v) in refreshed.headers { print("[NitroFetch][TokenRefresh]   \(k): \(v)") }
+          // Cache fresh tokens for useStoredHeaders fallback on next cold start
+          if let cacheStr = serializeCache(refreshed) {
             try? NitroFetchSecureAtRest.setEncrypted(cacheStr, forKey: tokenCacheKey, defaults: userDefaults)
           }
-          tokenHeaders = refreshed
+          tokens = refreshed
         } else {
           print("[NitroFetch][TokenRefresh] ❌ Refresh failed — onFailure: \(onFailure)")
           if onFailure == "skip" {
             print("[NitroFetch][TokenRefresh] Skipping all prefetches")
             return
           }
-          var cached: [String: String] = [:]
-          if let cacheRaw = NitroFetchSecureAtRest.decryptedString(forKey: tokenCacheKey, defaults: userDefaults),
-             !cacheRaw.isEmpty,
-             let cacheData = cacheRaw.data(using: .utf8),
-             let cacheObj = try? JSONSerialization.jsonObject(with: cacheData) as? [String: String] {
-            cached = cacheObj
-          }
-          print("[NitroFetch][TokenRefresh] Using cached headers (\(cached.count) header(s))")
-          tokenHeaders = cached
+          let cached = deserializeCache(
+            NitroFetchSecureAtRest.decryptedString(forKey: tokenCacheKey, defaults: userDefaults))
+          print("[NitroFetch][TokenRefresh] Using cached headers (\(cached.headers.count) header(s))")
+          tokens = cached
         }
       } else {
-        tokenHeaders = [:]
+        tokens = .empty
       }
 
-      // Launch a prefetch task per entry with merged headers
+      // Launch a prefetch task per entry with merged headers + body/form injection
       print("[NitroFetch][TokenRefresh] Injecting token headers into \(arr.count) prefetch URL(s)")
       for item in arr {
         guard let obj = item as? [String: Any] else { continue }
@@ -193,7 +182,7 @@ public final class NitroAutoPrefetcher: NSObject {
         // Merge: static headers first, token headers override
         var merged: [String: String] = [:]
         for (k, v) in headersDict { merged[k] = String(describing: v) }
-        for (k, v) in tokenHeaders { merged[k] = v }
+        for (k, v) in tokens.headers { merged[k] = v }
 
         var headers: [NitroHeader] = merged.map { NitroHeader(key: $0.key, value: $0.value) }
         headers.append(NitroHeader(key: "prefetchKey", value: prefetchKey))
@@ -201,7 +190,7 @@ public final class NitroAutoPrefetcher: NSObject {
         print("[NitroFetch][TokenRefresh] Prefetching \(url) with \(merged.count) header(s)")
         for (k, v) in merged { print("[NitroFetch][TokenRefresh]   \(k): \(v)") }
 
-        let req = buildNitroRequest(from: obj, mergedHeaders: headers)
+        let req = buildNitroRequest(from: obj, mergedHeaders: headers, tokens: tokens)
         Task {
           do { try await NitroFetchClient.prefetchStatic(req) } catch { /* ignore – best effort */ }
         }
@@ -248,18 +237,19 @@ public final class NitroAutoPrefetcher: NSObject {
 
   private static func buildNitroRequest(
     from entry: [String: Any],
-    mergedHeaders: [NitroHeader]
+    mergedHeaders: [NitroHeader],
+    tokens: TokenRefreshResult = .empty
   ) -> NitroRequest {
     let url = (entry["url"] as? String) ?? ""
     let methodStr = entry["method"] as? String
     let method: NitroRequestMethod? = methodStr.flatMap { NitroRequestMethod(fromString: $0) }
-    let bodyString = entry["bodyString"] as? String
+    let bodyString = injectBodyFields(entry["bodyString"] as? String, fields: tokens.bodyFields)
     let bodyBytes = entry["bodyBytes"] as? String
     let timeoutMs = (entry["timeoutMs"] as? NSNumber)?.doubleValue
     let followRedirects = (entry["followRedirects"] as? Bool) ?? true
     let prefetchCacheTtlMs = (entry["prefetchCacheTtlMs"] as? NSNumber)?.doubleValue
 
-    let formData: [NitroFormDataPart]? = (entry["bodyFormData"] as? [[String: Any]])?.map { p in
+    let baseParts: [NitroFormDataPart] = (entry["bodyFormData"] as? [[String: Any]])?.map { p in
       NitroFormDataPart(
         name: (p["name"] as? String) ?? "",
         value: p["value"] as? String,
@@ -267,7 +257,8 @@ public final class NitroAutoPrefetcher: NSObject {
         fileName: p["fileName"] as? String,
         mimeType: p["mimeType"] as? String
       )
-    }
+    } ?? []
+    let formData: [NitroFormDataPart]? = injectFormFields(baseParts, fields: tokens.formFields)
 
     return NitroRequest(
       url: url,
@@ -285,7 +276,14 @@ public final class NitroAutoPrefetcher: NSObject {
 
   // MARK: - Token refresh
 
-  private static func callTokenRefresh(config: [String: Any]) async throws -> [String: String] {
+  struct TokenRefreshResult {
+    var headers: [String: String]
+    var bodyFields: [String: String]
+    var formFields: [String: String]
+    static let empty = TokenRefreshResult(headers: [:], bodyFields: [:], formFields: [:])
+  }
+
+  private static func callTokenRefresh(config: [String: Any]) async throws -> TokenRefreshResult {
     guard let urlStr = config["url"] as? String,
           let url = URL(string: urlStr) else {
       throw NSError(domain: "NitroAutoPrefetcher", code: -1,
@@ -315,18 +313,22 @@ public final class NitroAutoPrefetcher: NSObject {
   private static func parseTokenResponse(
     data: Data,
     config: [String: Any]
-  ) throws -> [String: String] {
+  ) throws -> TokenRefreshResult {
     let responseType = config["responseType"] as? String ?? "json"
-    var result: [String: String] = [:]
+    var headers: [String: String] = [:]
+    var bodyFields: [String: String] = [:]
+    var formFields: [String: String] = [:]
 
     if responseType == "text" {
       let text = String(data: data, encoding: .utf8) ?? ""
       if let textHeader = config["textHeader"] as? String {
-        result[textHeader] = (config["textTemplate"] as? String)
+        headers[textHeader] = (config["textTemplate"] as? String)
           .map { $0.replacingOccurrences(of: "{{value}}", with: text) }
           ?? text
       }
-      return result
+      if let bodyTextPath = config["bodyTextPath"] as? String { bodyFields[bodyTextPath] = text }
+      if let formDataTextField = config["formDataTextField"] as? String { formFields[formDataTextField] = text }
+      return TokenRefreshResult(headers: headers, bodyFields: bodyFields, formFields: formFields)
     }
 
     guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
@@ -334,17 +336,9 @@ public final class NitroAutoPrefetcher: NSObject {
                     userInfo: [NSLocalizedDescriptionKey: "Token refresh: invalid JSON response"])
     }
 
-    if let mappings = config["mappings"] as? [[String: Any]] {
-      for m in mappings {
-        guard let jsonPath = m["jsonPath"] as? String,
-              let header = m["header"] as? String else { continue }
-        if let value = getNestedField(json, dotPath: jsonPath) {
-          result[header] = (m["valueTemplate"] as? String)
-            .map { $0.replacingOccurrences(of: "{{value}}", with: value) }
-            ?? value
-        }
-      }
-    }
+    collectMappings(json, config["mappings"] as? [[String: Any]], destKey: "header", into: &headers)
+    collectMappings(json, config["bodyMappings"] as? [[String: Any]], destKey: "bodyPath", into: &bodyFields)
+    collectMappings(json, config["formDataMappings"] as? [[String: Any]], destKey: "field", into: &formFields)
 
     if let compositeHeaders = config["compositeHeaders"] as? [[String: Any]] {
       for comp in compositeHeaders {
@@ -356,11 +350,29 @@ public final class NitroAutoPrefetcher: NSObject {
           let val = getNestedField(json, dotPath: jsonPath) ?? ""
           built = built.replacingOccurrences(of: "{{\(ph)}}", with: val)
         }
-        result[header] = built
+        headers[header] = built
       }
     }
 
-    return result
+    return TokenRefreshResult(headers: headers, bodyFields: bodyFields, formFields: formFields)
+  }
+
+  // jsonPath -> value (optionally templated), keyed by each mapping's `destKey` field.
+  private static func collectMappings(
+    _ json: [String: Any],
+    _ arr: [[String: Any]]?,
+    destKey: String,
+    into: inout [String: String]
+  ) {
+    guard let arr = arr else { return }
+    for m in arr {
+      guard let jsonPath = m["jsonPath"] as? String,
+            let dest = m[destKey] as? String,
+            let value = getNestedField(json, dotPath: jsonPath) else { continue }
+      into[dest] = (m["valueTemplate"] as? String)
+        .map { $0.replacingOccurrences(of: "{{value}}", with: value) }
+        ?? value
+    }
   }
 
   private static func getNestedField(_ obj: [String: Any], dotPath: String) -> String? {
@@ -374,6 +386,90 @@ public final class NitroAutoPrefetcher: NSObject {
     if let s = current as? String { return s }
     return String(describing: current)
   }
+
+  private static func setNestedField(_ root: inout [String: Any], dotPath: String, value: String) {
+    let parts = dotPath.split(separator: ".").map(String.init)
+    guard !parts.isEmpty else { return }
+    if parts.count == 1 {
+      root[parts[0]] = value
+      return
+    }
+    var child = (root[parts[0]] as? [String: Any]) ?? [:]
+    setNestedField(&child, dotPath: parts.dropFirst().joined(separator: "."), value: value)
+    root[parts[0]] = child
+  }
+
+  // MARK: - Body / form-data injection
+
+  private static func injectBodyFields(_ rawBody: String?, fields: [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.
+    guard let rawBody = rawBody, !rawBody.isEmpty else { return rawBody }
+    guard let data = rawBody.data(using: .utf8),
+          let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+      return rawBody
+    }
+    var root = obj
+    for (path, value) in fields {
+      setNestedField(&root, dotPath: path, value: value)
+    }
+    guard let out = try? JSONSerialization.data(withJSONObject: root),
+          let str = String(data: out, encoding: .utf8) else { return rawBody }
+    return str
+  }
+
+  private static func injectFormFields(
+    _ parts: [NitroFormDataPart],
+    fields: [String: String]
+  ) -> [NitroFormDataPart]? {
+    if fields.isEmpty { return parts.isEmpty ? nil : parts }
+    // Don't synthesize a multipart body where there wasn't one.
+    if parts.isEmpty { return nil }
+    var result = parts
+    for (name, value) in fields {
+      if let idx = result.firstIndex(where: { $0.name == name }) {
+        let old = result[idx]
+        result[idx] = NitroFormDataPart(
+          name: old.name, value: value,
+          fileUri: nil, fileName: old.fileName, mimeType: old.mimeType
+        )
+      } else {
+        result.append(NitroFormDataPart(name: name, value: value, fileUri: nil, fileName: nil, mimeType: nil))
+      }
+    }
+    return result
+  }
+
+  // MARK: - Structured token cache (back-compatible with old flat-header maps)
+
+  private static func serializeCache(_ result: TokenRefreshResult) -> String? {
+    let obj: [String: Any] = [
+      "headers": result.headers,
+      "bodyFields": result.bodyFields,
+      "formFields": result.formFields,
+    ]
+    guard let data = try? JSONSerialization.data(withJSONObject: obj) else { return nil }
+    return String(data: data, encoding: .utf8)
+  }
+
+  private static func deserializeCache(_ raw: String?) -> TokenRefreshResult {
+    guard let raw = raw, !raw.isEmpty,
+          let data = raw.data(using: .utf8),
+          let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+      return .empty
+    }
+    if obj["headers"] == nil && obj["bodyFields"] == nil && obj["formFields"] == nil {
+      // Old flat-header-map cache.
+      let headers = (obj as? [String: String]) ?? [:]
+      return TokenRefreshResult(headers: headers, bodyFields: [:], formFields: [:])
+    }
+    return TokenRefreshResult(
+      headers: (obj["headers"] as? [String: String]) ?? [:],
+      bodyFields: (obj["bodyFields"] as? [String: String]) ?? [:],
+      formFields: (obj["formFields"] as? [String: String]) ?? [:]
+    )
+  }
 }
 
 // Expose a C-ABI symbol the ObjC++ file can call

package/lib/module/CurlGenerator.js.map

@@ -1 +1,2 @@
-{"version":3,"names":["shellEscape","str","test","replace","generateCurl","options","parts","method","push","headers","h","key","toLowerCase","value","body","maxLen","truncated","length","slice","verbose","compressed","url","join"],"sourceRoot":"../../src","sources":["CurlGenerator.js"],"mappings":";;AAAA,SAASA,WAAWA,CAACC,GAAG,EAAE;EACtB,IAAI,0BAA0B,CAACC,IAAI,CAACD,GAAG,CAAC,EACpC,OAAOA,GAAG;EACd,OAAO,GAAG,GAAGA,GAAG,CAACE,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,GAAG;AACjD;AACA,OAAO,SAASC,YAAYA,CAACC,OAAO,EAAE;EAClC,MAAMC,KAAK,GAAG,CAAC,MAAM,CAAC;EACtB,IAAID,OAAO,CAACE,MAAM,IAAIF,OAAO,CAACE,MAAM,KAAK,KAAK,EAAE;IAC5CD,KAAK,CAACE,IAAI,CAAC,IAAI,EAAER,WAAW,CAACK,OAAO,CAACE,MAAM,CAAC,CAAC;EACjD;EACA,IAAIF,OAAO,CAACI,OAAO,EAAE;IACjB,KAAK,MAAMC,CAAC,IAAIL,OAAO,CAACI,OAAO,EAAE;MAC7B,IAAIC,CAAC,CAACC,GAAG,CAACC,WAAW,CAAC,CAAC,KAAK,aAAa,EACrC;MACJN,KAAK,CAACE,IAAI,CAAC,IAAI,EAAER,WAAW,CAAC,GAAGU,CAAC,CAACC,GAAG,KAAKD,CAAC,CAACG,KAAK,EAAE,CAAC,CAAC;IACzD;EACJ;EACA,IAAIR,OAAO,CAACS,IAAI,EAAE;IACd,MAAMC,MAAM,GAAG,MAAM;IACrB,MAAMC,SAAS,GAAGX,OAAO,CAACS,IAAI,CAACG,MAAM,GAAGF,MAAM,GACxCV,OAAO,CAACS,IAAI,CAACI,KAAK,CAAC,CAAC,EAAEH,MAAM,CAAC,GAAG,gBAAgB,GAChDV,OAAO,CAACS,IAAI;IAClBR,KAAK,CAACE,IAAI,CAAC,IAAI,EAAER,WAAW,CAACgB,SAAS,CAAC,CAAC;EAC5C;EACA,IAAIX,OAAO,CAACc,OAAO,EACfb,KAAK,CAACE,IAAI,CAAC,IAAI,CAAC;EACpB,IAAIH,OAAO,CAACe,UAAU,EAClBd,KAAK,CAACE,IAAI,CAAC,cAAc,CAAC;EAC9BF,KAAK,CAACE,IAAI,CAACR,WAAW,CAACK,OAAO,CAACgB,GAAG,CAAC,CAAC;EACpC,OAAOf,KAAK,CAACgB,IAAI,CAAC,GAAG,CAAC;AAC1B","ignoreList":[]}
+{"version":3,"names":["shellEscape","str","test","replace","generateCurl","options","parts","method","push","headers","h","key","toLowerCase","value","body","maxLen","truncated","length","slice","verbose","compressed","url","join"],"sourceRoot":"../../src","sources":["CurlGenerator.js"],"mappings":";;AAAA,SAASA,WAAWA,CAACC,GAAG,EAAE;EACxB,IAAI,0BAA0B,CAACC,IAAI,CAACD,GAAG,CAAC,EAAE,OAAOA,GAAG;EACpD,OAAO,GAAG,GAAGA,GAAG,CAACE,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,GAAG;AAC/C;AACA,OAAO,SAASC,YAAYA,CAACC,OAAO,EAAE;EACpC,MAAMC,KAAK,GAAG,CAAC,MAAM,CAAC;EACtB,IAAID,OAAO,CAACE,MAAM,IAAIF,OAAO,CAACE,MAAM,KAAK,KAAK,EAAE;IAC9CD,KAAK,CAACE,IAAI,CAAC,IAAI,EAAER,WAAW,CAACK,OAAO,CAACE,MAAM,CAAC,CAAC;EAC/C;EACA,IAAIF,OAAO,CAACI,OAAO,EAAE;IACnB,KAAK,MAAMC,CAAC,IAAIL,OAAO,CAACI,OAAO,EAAE;MAC/B,IAAIC,CAAC,CAACC,GAAG,CAACC,WAAW,CAAC,CAAC,KAAK,aAAa,EAAE;MAC3CN,KAAK,CAACE,IAAI,CAAC,IAAI,EAAER,WAAW,CAAC,GAAGU,CAAC,CAACC,GAAG,KAAKD,CAAC,CAACG,KAAK,EAAE,CAAC,CAAC;IACvD;EACF;EACA,IAAIR,OAAO,CAACS,IAAI,EAAE;IAChB,MAAMC,MAAM,GAAG,MAAM;IACrB,MAAMC,SAAS,GACbX,OAAO,CAACS,IAAI,CAACG,MAAM,GAAGF,MAAM,GACxBV,OAAO,CAACS,IAAI,CAACI,KAAK,CAAC,CAAC,EAAEH,MAAM,CAAC,GAAG,gBAAgB,GAChDV,OAAO,CAACS,IAAI;IAClBR,KAAK,CAACE,IAAI,CAAC,IAAI,EAAER,WAAW,CAACgB,SAAS,CAAC,CAAC;EAC1C;EACA,IAAIX,OAAO,CAACc,OAAO,EAAEb,KAAK,CAACE,IAAI,CAAC,IAAI,CAAC;EACrC,IAAIH,OAAO,CAACe,UAAU,EAAEd,KAAK,CAACE,IAAI,CAAC,cAAc,CAAC;EAClDF,KAAK,CAACE,IAAI,CAACR,WAAW,CAACK,OAAO,CAACgB,GAAG,CAAC,CAAC;EACpC,OAAOf,KAAK,CAACgB,IAAI,CAAC,GAAG,CAAC;AACxB","ignoreList":[]}
+