react-native-nitro-fetch 0.2.0 → 0.3.0-beta.0

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

@@ -4,13 +4,17 @@ import android.app.Application
 import android.content.Context
 import org.json.JSONArray
 import org.json.JSONObject
+import java.net.HttpURLConnection
+import java.net.URL
 import java.util.concurrent.CompletableFuture
 
 
 object AutoPrefetcher {
   @Volatile private var initialized = false
   private const val KEY_QUEUE = "nitrofetch_autoprefetch_queue"
-  private const val PREFS_NAME = "nitro_fetch_storage"
+  private const val KEY_TOKEN_REFRESH = "nitro_token_refresh_fetch"
+  private const val KEY_TOKEN_CACHE = "nitro_token_refresh_fetch_cache"
+  private const val PREFS_NAME = NitroFetchSecureAtRest.PREFS_NAME
 
   fun prefetchOnStart(app: Application) {
     if (initialized) return
@@ -20,55 +24,209 @@ object AutoPrefetcher {
       val raw = prefs.getString(KEY_QUEUE, null) ?: ""
       if (raw.isEmpty()) return
       val arr = JSONArray(raw)
-      for (i in 0 until arr.length()) {
-        val o = arr.optJSONObject(i) ?: continue
-        val url = o.optString("url", null) ?: continue
-        val prefetchKey = o.optString("prefetchKey", null) ?: continue
-        val headersObj = o.optJSONObject("headers") ?: JSONObject()
-        val headersList = mutableListOf<Pair<String, String>>()
-        headersObj.keys().forEachRemaining { k ->
-          headersList.add(k to headersObj.optString(k, ""))
-        }
-        // Ensure prefetchKey header is present
-        headersList.add("prefetchKey" to prefetchKey)
-
-        val headerObjs = headersList.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
-        )
-
-        // If already pending or fresh, skip starting a new one
-        if (FetchCache.getPending(prefetchKey) != null) continue
-        if (FetchCache.hasFreshResult(prefetchKey, 5_000L)) continue
-
-        val future = CompletableFuture<NitroResponse>()
-        FetchCache.setPending(prefetchKey, future)
-        NitroFetchClient.fetch(req,
-          onSuccess = { res ->
-            try {
-              FetchCache.complete(prefetchKey, res)
-              future.complete(res)
-            } catch (t: Throwable) {
-              FetchCache.completeExceptionally(prefetchKey, t)
-              future.completeExceptionally(t)
+
+      val refreshRaw = NitroFetchSecureAtRest.getDecryptedForPrefs(prefs, KEY_TOKEN_REFRESH)
+
+      if (!refreshRaw.isNullOrEmpty()) {
+        // Token refresh requires a network call — run everything on a background thread
+        Thread {
+          try {
+            val refreshConfig = JSONObject(refreshRaw)
+            val onFailure = refreshConfig.optString("onFailure", "useStoredHeaders")
+            val refreshURL = refreshConfig.optString("url", "(unknown)")
+            android.util.Log.d("NitroFetch", "[TokenRefresh] Calling refresh endpoint: $refreshURL")
+
+            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())
+              refreshed
+            } else {
+              android.util.Log.d("NitroFetch", "[TokenRefresh] ❌ Refresh failed — onFailure: $onFailure")
+              if (onFailure == "skip") {
+                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))")
+              cached
             }
-          },
-          onFail = { err ->
-            FetchCache.completeExceptionally(prefetchKey, err)
-            future.completeExceptionally(err)
+
+            android.util.Log.d("NitroFetch", "[TokenRefresh] Injecting token headers into ${arr.length()} prefetch URL(s)")
+            startPrefetches(arr, tokenHeaders)
+          } catch (_: Throwable) {
+            // Best-effort — never crash the app
           }
-        )
+        }.start()
+      } else {
+        // No token refresh config — proceed on current thread (Cronet is async)
+        startPrefetches(arr, emptyMap())
       }
     } catch (_: Throwable) {
       // ignore – prefetch-on-start is best-effort
     }
   }
+
+  private fun startPrefetches(arr: JSONArray, tokenHeaders: Map<String, String>) {
+    for (i in 0 until arr.length()) {
+      val o = arr.optJSONObject(i) ?: continue
+      val url = o.optString("url", null) ?: continue
+      val prefetchKey = o.optString("prefetchKey", null) ?: continue
+      val headersObj = o.optJSONObject("headers") ?: JSONObject()
+
+      // Merge: static headers first, token headers override
+      val merged = mutableMapOf<String, String>()
+      headersObj.keys().forEachRemaining { k ->
+        merged[k] = headersObj.optString(k, "")
+      }
+      tokenHeaders.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
+      )
+
+      if (FetchCache.getPending(prefetchKey) != null) continue
+      if (FetchCache.hasFreshResult(prefetchKey, 5_000L)) continue
+
+      val future = CompletableFuture<NitroResponse>()
+      FetchCache.setPending(prefetchKey, future)
+      NitroFetchClient.fetch(req,
+        onSuccess = { res ->
+          try {
+            FetchCache.complete(prefetchKey, res)
+            future.complete(res)
+          } catch (t: Throwable) {
+            FetchCache.completeExceptionally(prefetchKey, t)
+            future.completeExceptionally(t)
+          }
+        },
+        onFail = { err ->
+          FetchCache.completeExceptionally(prefetchKey, err)
+          future.completeExceptionally(err)
+        }
+      )
+    }
+  }
+
+  // MARK: - Token refresh (synchronous, runs on background thread)
+
+  private fun callTokenRefreshSync(config: JSONObject): Map<String, String>? {
+    return try {
+      val urlStr = config.optString("url", null) ?: return null
+      val method = config.optString("method", "POST")
+      val reqHeaders = config.optJSONObject("headers")
+      val body = config.optString("body", null)
+      val responseType = config.optString("responseType", "json")
+
+      val conn = URL(urlStr).openConnection() as HttpURLConnection
+      conn.requestMethod = method
+      conn.connectTimeout = 10_000
+      conn.readTimeout = 10_000
+      conn.doInput = true
+      if (body != null) conn.doOutput = true
+
+      reqHeaders?.keys()?.forEachRemaining { k ->
+        conn.setRequestProperty(k, reqHeaders.optString(k, ""))
+      }
+
+      if (body != null) {
+        conn.outputStream.use { it.write(body.toByteArray(Charsets.UTF_8)) }
+      }
+
+      val status = conn.responseCode
+      if (status !in 200..299) return null
+
+      val responseBody = conn.inputStream.use { it.bufferedReader(Charsets.UTF_8).readText() }
+
+      parseTokenResponse(responseBody, responseType, config)
+    } catch (_: Throwable) {
+      null
+    }
+  }
+
+  private fun parseTokenResponse(
+    body: String,
+    responseType: String,
+    config: JSONObject
+  ): Map<String, String> {
+    val result = 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
+      }
+      return result
+    }
+
+    // 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 compositeHeaders = config.optJSONArray("compositeHeaders")
+    if (compositeHeaders != null) {
+      for (i in 0 until compositeHeaders.length()) {
+        val comp = compositeHeaders.optJSONObject(i) ?: continue
+        val header = comp.optString("header", null) ?: continue
+        val template = comp.optString("template", null) ?: continue
+        val paths = comp.optJSONObject("paths") ?: continue
+        var built = template
+        paths.keys().forEachRemaining { ph ->
+          val val2 = getNestedField(json, paths.optString(ph, ""))
+          built = built.replace("{{$ph}}", val2 ?: "")
+        }
+        result[header] = built
+      }
+    }
+
+    return result
+  }
+
+  private fun getNestedField(obj: JSONObject, dotPath: String): String? {
+    val parts = dotPath.split(".")
+    var current: Any = obj
+    for (part in parts) {
+      if (current !is JSONObject) return null
+      current = current.opt(part) ?: return null
+    }
+    return current.toString()
+  }
 }

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

@@ -1,102 +1,198 @@
 package com.margelo.nitro.nitrofetch
 
-import android.app.Application
 import android.content.Context
 import android.content.SharedPreferences
+import android.security.keystore.KeyGenParameterSpec
+import android.security.keystore.KeyProperties
+import android.util.Base64
 import android.util.Log
 import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.NitroModules
+import java.security.KeyStore
+import javax.crypto.Cipher
+import javax.crypto.KeyGenerator
+import javax.crypto.spec.GCMParameterSpec
 
+/**
+ * Keystore-backed AES-GCM strings stored in [PREFS_NAME] with prefix [ENC_PREFIX].
+ * Keep [KEYSTORE_ALIAS] and [ENC_PREFIX] in sync with `NitroWebSocketAutoPrewarmer.kt`.
+ */
+internal object NitroFetchSecureAtRest {
+  internal const val PREFS_NAME = "nitro_fetch_storage"
+  private const val KEYSTORE_ALIAS = "nitro_fetch_aes_gcm_v1"
+  private const val ANDROID_KEYSTORE = "AndroidKeyStore"
+  private const val TRANSFORMATION = "AES/GCM/NoPadding"
+  private const val GCM_IV_LENGTH = 12
+  private const val GCM_TAG_BITS = 128
+  const val ENC_PREFIX = "nfc1:"
 
+  private fun keyStore(): KeyStore =
+    KeyStore.getInstance(ANDROID_KEYSTORE).apply { load(null) }
+
+  private fun getOrCreateSecretKey(): javax.crypto.SecretKey {
+    val ks = keyStore()
+    if (ks.containsAlias(KEYSTORE_ALIAS)) {
+      return (ks.getEntry(KEYSTORE_ALIAS, null) as KeyStore.SecretKeyEntry).secretKey
+    }
+    val keyGenerator =
+      KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, ANDROID_KEYSTORE)
+    val spec =
+      KeyGenParameterSpec.Builder(
+        KEYSTORE_ALIAS,
+        KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
+      )
+        .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
+        .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
+        .setKeySize(256)
+        .build()
+    keyGenerator.init(spec)
+    return keyGenerator.generateKey()
+  }
+
+  private fun encrypt(plaintext: String): String {
+    val key = getOrCreateSecretKey()
+    val cipher = Cipher.getInstance(TRANSFORMATION)
+    cipher.init(Cipher.ENCRYPT_MODE, key)
+    val iv = cipher.iv
+    val ciphertext = cipher.doFinal(plaintext.toByteArray(Charsets.UTF_8))
+    val combined = ByteArray(iv.size + ciphertext.size)
+    System.arraycopy(iv, 0, combined, 0, iv.size)
+    System.arraycopy(ciphertext, 0, combined, iv.size, ciphertext.size)
+    return Base64.encodeToString(combined, Base64.NO_WRAP)
+  }
+
+  private fun decrypt(b64: String): String {
+    val combined = Base64.decode(b64, Base64.NO_WRAP)
+    if (combined.size < GCM_IV_LENGTH + 16) {
+      throw IllegalArgumentException("truncated")
+    }
+    val iv = combined.copyOfRange(0, GCM_IV_LENGTH)
+    val ciphertext = combined.copyOfRange(GCM_IV_LENGTH, combined.size)
+    val key = getOrCreateSecretKey()
+    val cipher = Cipher.getInstance(TRANSFORMATION)
+    cipher.init(Cipher.DECRYPT_MODE, key, GCMParameterSpec(GCM_TAG_BITS, iv))
+    return String(cipher.doFinal(ciphertext), Charsets.UTF_8)
+  }
+
+  /** Plaintext for JSON parsing, or null if key absent. Migrates legacy plaintext to encrypted. */
+  fun getDecryptedForPrefs(prefs: SharedPreferences, key: String): String? {
+    val raw = prefs.getString(key, null) ?: return null
+    if (raw.isEmpty()) return ""
+    return if (raw.startsWith(ENC_PREFIX)) {
+      try {
+        decrypt(raw.substring(ENC_PREFIX.length))
+      } catch (_: Throwable) {
+        raw
+      }
+    } else {
+      try {
+        putEncrypted(prefs, key, raw)
+      } catch (_: Throwable) {}
+      raw
+    }
+  }
+
+  fun putEncrypted(prefs: SharedPreferences, key: String, plain: String): Boolean {
+    val enc = ENC_PREFIX + encrypt(plain)
+    return prefs.edit().putString(key, enc).commit()
+  }
+
+  fun removeFromPrefs(prefs: SharedPreferences, key: String): Boolean {
+    return prefs.edit().remove(key).commit()
+  }
+}
 
 @DoNotStrip
 class NativeStorage : HybridNativeStorageSpec() {
 
-    companion object {
-        private const val TAG = "HybridNativeStorage"
-        private const val PREFS_NAME = "nitro_fetch_storage"
+  companion object {
+    private const val TAG = "HybridNativeStorage"
 
-       
-        private val sharedPreferences: SharedPreferences by lazy {
-            val context = NitroModules.applicationContext ?: throw Error("Cannot get Android Context - No Context available!")
-            context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
-        }
+    private val sharedPreferences: SharedPreferences by lazy {
+      val context =
+        NitroModules.applicationContext
+          ?: throw Error("Cannot get Android Context - No Context available!")
+      context.getSharedPreferences(NitroFetchSecureAtRest.PREFS_NAME, Context.MODE_PRIVATE)
+    }
 
+  }
 
+  override fun getString(key: String): String {
+    return try {
+      val value = sharedPreferences.getString(key, null)
+      if (value != null) {
+        Log.d(TAG, "Retrieved value for key: $key")
+        value
+      } else {
+        Log.d(TAG, "Key not found: $key, returning empty string")
+        ""
+      }
+    } catch (t: Throwable) {
+      Log.e(TAG, "Error getting string for key: $key", t)
+      throw RuntimeException("Failed to get string for key: $key", t)
     }
+  }
 
-    /**
-     * Retrieves a string value for the given key.
-     *
-     * @param key The key to look up in storage
-     * @return The stored string value, or empty string if key doesn't exist
-     * @throws IllegalStateException if SharedPreferences is not available
-     */
-    override fun getString(key: String): String {
-        return try {
-            val value = sharedPreferences.getString(key, null)
-            if (value != null) {
-                Log.d(TAG, "Retrieved value for key: $key")
-                value
-            } else {
-                Log.d(TAG, "Key not found: $key, returning empty string")
-                ""
-            }
-        } catch (t: Throwable) {
-            Log.e(TAG, "Error getting string for key: $key", t)
-            throw RuntimeException("Failed to get string for key: $key", t)
-        }
+  override fun setString(key: String, value: String) {
+    try {
+      val editor = sharedPreferences.edit()
+      editor.putString(key, value)
+      val success = editor.commit()
+      if (success) {
+        Log.d(TAG, "Successfully stored value for key: $key")
+      } else {
+        Log.e(TAG, "Failed to commit value for key: $key")
+        throw RuntimeException("Failed to store value for key: $key")
+      }
+    } catch (t: Throwable) {
+      Log.e(TAG, "Error setting string for key: $key", t)
+      throw RuntimeException("Failed to set string for key: $key", t)
     }
+  }
 
-    /**
-     * Stores a string value with the given key.
-     *
-     * @param key The key to store the value under
-     * @param value The string value to store
-     * @throws IllegalStateException if SharedPreferences is not available
-     * @throws RuntimeException if the write operation fails
-     */
-    override fun setString(key: String, value: String) {
-        try {
-            val editor = sharedPreferences.edit()
-            editor.putString(key, value)
-            val success = editor.commit() // commit() is synchronous and returns boolean
-            if (success) {
-                Log.d(TAG, "Successfully stored value for key: $key")
-            } else {
-                Log.e(TAG, "Failed to commit value for key: $key")
-                throw RuntimeException("Failed to store value for key: $key")
-            }
-        } catch (t: Throwable) {
-            Log.e(TAG, "Error setting string for key: $key", t)
-            throw RuntimeException("Failed to set string for key: $key", t)
-        }
+  override fun removeString(key: String) {
+    try {
+      val editor = sharedPreferences.edit()
+      editor.remove(key)
+      val success = editor.commit()
+      if (success) {
+        Log.d(TAG, "Successfully deleted key: $key")
+      } else {
+        Log.e(TAG, "Failed to commit deletion for key: $key")
+        throw RuntimeException("Failed to delete key: $key")
+      }
+    } catch (t: Throwable) {
+      Log.e(TAG, "Error deleting key: $key", t)
+      throw RuntimeException("Failed to delete key: $key", t)
     }
+  }
 
-    /**
-     * Deletes the value associated with the given key.
-     * If the key doesn't exist, this is a no-op.
-     *
-     * @param key The key to delete from storage
-     * @throws IllegalStateException if SharedPreferences is not available
-     * @throws RuntimeException if the delete operation fails
-     */
-    override fun removeString(key: String) {
-        try {
-            val editor = sharedPreferences.edit()
-            editor.remove(key)
-            val success = editor.commit() // commit() is synchronous and returns boolean
-            if (success) {
-                Log.d(TAG, "Successfully deleted key: $key")
-            } else {
-                Log.e(TAG, "Failed to commit deletion for key: $key")
-                throw RuntimeException("Failed to delete key: $key")
-            }
-        } catch (t: Throwable) {
-            Log.e(TAG, "Error deleting key: $key", t)
-            throw RuntimeException("Failed to delete key: $key", t)
-        }
+  override fun getSecureString(key: String): String {
+    return try {
+      NitroFetchSecureAtRest.getDecryptedForPrefs(sharedPreferences, key) ?: ""
+    } catch (t: Throwable) {
+      Log.e(TAG, "Error getSecureString for key: $key", t)
+      throw RuntimeException("Failed to get secure string for key: $key", t)
     }
-}
+  }
 
+  override fun setSecureString(key: String, value: String) {
+    try {
+      val ok = NitroFetchSecureAtRest.putEncrypted(sharedPreferences, key, value)
+      if (!ok) throw RuntimeException("commit failed")
+    } catch (t: Throwable) {
+      Log.e(TAG, "Error setSecureString for key: $key", t)
+      throw RuntimeException("Failed to set secure string for key: $key", t)
+    }
+  }
 
+  override fun removeSecureString(key: String) {
+    try {
+      val ok = NitroFetchSecureAtRest.removeFromPrefs(sharedPreferences, key)
+      if (!ok) throw RuntimeException("commit failed")
+    } catch (t: Throwable) {
+      Log.e(TAG, "Error removeSecureString for key: $key", t)
+      throw RuntimeException("Failed to remove secure string for key: $key", t)
+    }
+  }
+}