react-native-nitro-fetch 0.1.3 → 0.1.5

package/android/build.gradle

@@ -117,11 +117,11 @@ dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation project(":react-native-nitro-modules")
-  implementation("com.tencent:mmkv:1.3.14")// or latest
   // Provide org.chromium.net Java API for CronetEngine in Kotlin
   // Cronet
   api "org.chromium.net:cronet-embedded:${cronetVersion}"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0"
+
 }
 
 configurations {

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

@@ -1,21 +1,23 @@
 package com.margelo.nitro.nitrofetch
 
 import android.app.Application
+import android.content.Context
 import org.json.JSONArray
 import org.json.JSONObject
 import java.util.concurrent.CompletableFuture
-import com.tencent.mmkv.MMKV;
 
 
 object AutoPrefetcher {
   @Volatile private var initialized = false
+  private const val KEY_QUEUE = "nitrofetch_autoprefetch_queue"
+  private const val PREFS_NAME = "nitro_fetch_storage"
 
   fun prefetchOnStart(app: Application) {
     if (initialized) return
     initialized = true
     try {
-      val mmkv = getMMKV(app) ?: return
-      val raw = invokeMMKVDecodeString(mmkv, KEY_QUEUE) ?: return
+      val prefs = app.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+      val raw = prefs.getString(KEY_QUEUE, null) ?: ""
       if (raw.isEmpty()) return
       val arr = JSONArray(raw)
       for (i in 0 until arr.length()) {
@@ -42,12 +44,8 @@ object AutoPrefetcher {
         )
 
         // If already pending or fresh, skip starting a new one
-        if (FetchCache.getPending(prefetchKey) != null) {
-          continue
-        }
-        if (FetchCache.getResultIfFresh(prefetchKey, 5_000L) != null) {
-          continue
-        }
+        if (FetchCache.getPending(prefetchKey) != null) continue
+        if (FetchCache.hasFreshResult(prefetchKey, 5_000L)) continue
 
         val future = CompletableFuture<NitroResponse>()
         FetchCache.setPending(prefetchKey, future)
@@ -71,23 +69,4 @@ object AutoPrefetcher {
       // ignore – prefetch-on-start is best-effort
     }
   }
-
-  private const val KEY_QUEUE = "nitrofetch_autoprefetch_queue"
-
-  private fun getMMKV(app: Application): Any? {
-    return try {
-      MMKV.initialize(app);
-
-      return MMKV.defaultMMKV()
-    } catch (_: Throwable) {
-      null
-    }
-  }
-
-  private fun invokeMMKVDecodeString(mmkv: Any, key: String): String? {
-    return try {
-      val m = mmkv.javaClass.getMethod("decodeString", String::class.java, String::class.java)
-      m.invoke(mmkv, key, null) as? String
-    } catch (_: Throwable) { null }
-  }
 }

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

@@ -41,8 +41,18 @@ object FetchCache {
     return if (age <= maxAgeMs) entry.response else null
   }
 
+  /**
+   * Check if a fresh result exists WITHOUT consuming it.
+   * Used to check if we should skip starting a new prefetch.
+   */
+  fun hasFreshResult(key: String, maxAgeMs: Long): Boolean {
+    val entry = results[key] ?: return false
+    val age = System.currentTimeMillis() - entry.timestampMs
+    return age <= maxAgeMs
+  }
+
   fun clear() {
     pending.clear()
     results.clear()
   }
-}
+}

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

@@ -0,0 +1,102 @@
+package com.margelo.nitro.nitrofetch
+
+import android.app.Application
+import android.content.Context
+import android.content.SharedPreferences
+import android.util.Log
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.NitroModules
+
+
+
+@DoNotStrip
+class NativeStorage : HybridNativeStorageSpec() {
+
+    companion object {
+        private const val TAG = "HybridNativeStorage"
+        private const val PREFS_NAME = "nitro_fetch_storage"
+
+       
+        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)
+        }
+
+
+    }
+
+    /**
+     * 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)
+        }
+    }
+
+    /**
+     * 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)
+        }
+    }
+
+    /**
+     * 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)
+        }
+    }
+}
+
+

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

@@ -155,6 +155,56 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
     }
   }
 
+  // Helper function to add prefetch header to response (reused by both sync/async)
+  private fun withPrefetchedHeader(res: NitroResponse): NitroResponse {
+    val newHeaders = (res.headers?.toMutableList() ?: mutableListOf())
+    newHeaders.add(NitroHeader("nitroPrefetched", "true"))
+    return NitroResponse(
+      url = res.url,
+      status = res.status,
+      statusText = res.statusText,
+      ok = res.ok,
+      redirected = res.redirected,
+      headers = newHeaders.toTypedArray(),
+      bodyString = res.bodyString,
+      bodyBytes = res.bodyBytes
+    )
+  }
+
+  override fun requestSync(req: NitroRequest): NitroResponse {
+    val key = findPrefetchKey(req)
+    if (key != null) {
+      FetchCache.getPending(key)?.let { fut ->
+        return try {
+          withPrefetchedHeader(fut.get()) // blocks until complete
+        } catch (e: Exception) {
+          throw e.cause ?: e
+        }
+      }
+      FetchCache.getResultIfFresh(key, 5_000L)?.let { cached ->
+        return withPrefetchedHeader(cached)
+      }
+    }
+    val latch = java.util.concurrent.CountDownLatch(1)
+    var result: NitroResponse? = null
+    var error: Throwable? = null
+    
+    fetch(
+      req,
+      onSuccess = { 
+        result = it
+        latch.countDown()
+      },
+      onFail = { 
+        error = it
+        latch.countDown()
+      }
+    )
+    latch.await()
+    error?.let { throw it }
+    return result!!
+  }
+
   override fun request(req: NitroRequest): Promise<NitroResponse> {
     val promise = Promise<NitroResponse>()
     // Try to serve from prefetch cache/pending first
@@ -162,20 +212,6 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
     if (key != null) {
       // If a prefetch is currently pending, wait for it
       FetchCache.getPending(key)?.let { fut ->
-        fun withPrefetchedHeader(res: NitroResponse): NitroResponse {
-          val newHeaders = (res.headers?.toMutableList() ?: mutableListOf())
-          newHeaders.add(NitroHeader("nitroPrefetched", "true"))
-          return NitroResponse(
-            url = res.url,
-            status = res.status,
-            statusText = res.statusText,
-            ok = res.ok,
-            redirected = res.redirected,
-            headers = newHeaders.toTypedArray(),
-            bodyString = res.bodyString,
-            bodyBytes = res.bodyBytes
-          )
-        }
         fut.whenComplete { res, err ->
           if (err != null) {
             promise.reject(err)
@@ -189,19 +225,7 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
       }
       // If a fresh prefetched result exists (<=5s old), return it immediately
       FetchCache.getResultIfFresh(key, 5_000L)?.let { cached ->
-        val newHeaders = (cached.headers?.toMutableList() ?: mutableListOf())
-        newHeaders.add(NitroHeader("nitroPrefetched", "true"))
-        val wrapped = NitroResponse(
-          url = cached.url,
-          status = cached.status,
-          statusText = cached.statusText,
-          ok = cached.ok,
-          redirected = cached.redirected,
-          headers = newHeaders.toTypedArray(),
-          bodyString = cached.bodyString,
-          bodyBytes = cached.bodyBytes
-        )
-        promise.resolve(wrapped)
+        promise.resolve(withPrefetchedHeader(cached))
         return promise
       }
     }
@@ -220,8 +244,8 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
       promise.reject(IllegalArgumentException("prefetch: missing 'prefetchKey' header"))
       return promise
     }
-    // If already have a fresh result, resolve immediately
-    FetchCache.getResultIfFresh(key, 5_000L)?.let {
+    // If already have a fresh result, resolve immediately (NON-DESTRUCTIVE CHECK)
+    if (FetchCache.hasFreshResult(key, 5_000L)) {
       promise.resolve(Unit)
       return promise
     }

package/ios/NativeStorage.swift

@@ -0,0 +1,61 @@
+//
+//  NativeStorage.swift
+//  Pods
+//
+//  Created by Ritesh Shukla on 08/11/25.
+//
+
+import Foundation
+
+
+final class NativeStorage: HybridNativeStorageSpec {
+  
+  private static let suiteName = "nitro_fetch_storage"
+  
+  private let userDefaults: UserDefaults
+  
+  public override init() {
+    // Use a named suite for better isolation, fallback to standard if creation fails
+    if let suite = UserDefaults(suiteName: NativeStorage.suiteName) {
+      self.userDefaults = suite
+    } else {
+      self.userDefaults = UserDefaults.standard
+    }
+    super.init()
+  }
+  
+  /// Retrieves a string value for the given key.
+  ///
+  /// - Parameter key: The key to look up in storage
+  /// - Returns: The stored string value, or empty string if key doesn't exist
+  /// - Throws: RuntimeError if the operation fails
+  func getString(key: String) throws -> String {
+    guard let value = userDefaults.string(forKey: key) else {
+      return ""
+    }
+    return value
+  }
+  
+  /// Stores a string value with the given key.
+  ///
+  /// - Parameters:
+  ///   - key: The key to store the value under
+  ///   - value: The string value to store
+  /// - Throws: RuntimeError if the write operation fails
+  func setString(key: String, value: String) throws {
+    userDefaults.set(value, forKey: key)
+    // Synchronize to ensure immediate persistence
+    userDefaults.synchronize()
+  }
+  
+  /// Deletes the value associated with the given key.
+  /// If the key doesn't exist, this is a no-op.
+  ///
+  /// - Parameter key: The key to delete from storage
+  /// - Throws: RuntimeError if the delete operation fails
+  func removeString(key: String) throws {
+    userDefaults.removeObject(forKey: key)
+    // Synchronize to ensure immediate persistence
+    userDefaults.synchronize()
+  }
+}

package/ios/NitroAutoPrefetcher.swift

@@ -4,12 +4,16 @@ import Foundation
 public final class NitroAutoPrefetcher: NSObject {
   private static var initialized = false
   private static let queueKey = "nitrofetch_autoprefetch_queue"
+  private static let suiteName = "nitro_fetch_storage"
 
   @objc
   public static func prefetchOnStart() {
     if initialized { return }
     initialized = true
-    guard let raw = readMMKVString(forKey: queueKey), !raw.isEmpty else { return }
+    
+    // Read from UserDefaults
+    let userDefaults = UserDefaults(suiteName: suiteName) ?? UserDefaults.standard
+    guard let raw = userDefaults.string(forKey: queueKey), !raw.isEmpty else { return }
     guard let data = raw.data(using: .utf8) else { return }
     guard let arr = try? JSONSerialization.jsonObject(with: data, options: []) as? [Any] else { return }
 
@@ -32,46 +36,6 @@ public final class NitroAutoPrefetcher: NSObject {
       }
     }
   }
-
-  // MARK: - MMKV dynamic access (optional)
-
-  private static func readMMKVString(forKey key: String) -> String? {
-    guard let mmkvClass = NSClassFromString("MMKV") as? NSObject.Type else { return nil }
-    // Try to initialize if needed (ignore failures)
-    let initSelectors = [
-      NSSelectorFromString("initializeMMKV:"),
-      NSSelectorFromString("initialize:")
-    ]
-    for sel in initSelectors where mmkvClass.responds(to: sel) {
-      _ = mmkvClass.perform(sel, with: nil)
-      break
-    }
-    guard let mmkvObjUnretained = mmkvClass.perform(NSSelectorFromString("defaultMMKV"))?.takeUnretainedValue() else { return nil }
-    let mmkv = mmkvObjUnretained as AnyObject
-    // Try common selectors
-    let candidates = [
-      NSSelectorFromString("decodeStringForKey:"),
-      NSSelectorFromString("stringForKey:"),
-      NSSelectorFromString("getStringForKey:"),
-    ]
-    for sel in candidates where mmkv.responds(to: sel) {
-      if let val = mmkv.perform(sel, with: key)?.takeUnretainedValue() as? String {
-        return val
-      }
-    }
-    // Some APIs have (forKey: defaultValue:) signatures
-    let twoArgCandidates = [
-      NSSelectorFromString("decodeStringForKey:defaultValue:"),
-      NSSelectorFromString("stringForKey:defaultValue:"),
-      NSSelectorFromString("getStringForKey:defaultValue:"),
-    ]
-    for sel in twoArgCandidates where mmkv.responds(to: sel) {
-      // NSInvocation is cumbersome in Swift; best-effort fallthrough without it
-      // Prefer single-arg variants above.
-      break
-    }
-    return nil
-  }
 }
 
 // Expose a C-ABI symbol the ObjC++ file can call

package/ios/NitroFetchClient.swift

@@ -2,6 +2,31 @@ import Foundation
 import NitroModules
 
 final class NitroFetchClient: HybridNitroFetchClientSpec {
+  func requestSync(req: NitroRequest) throws -> NitroResponse {
+    let semaphore = DispatchSemaphore(value: 0)
+    var result: Result<NitroResponse, Error>?
+    
+    Task {
+      do {
+        let response = try await NitroFetchClient.requestStatic(req)
+        result = .success(response)
+      } catch {
+        result = .failure(error)
+      }
+      semaphore.signal()
+    }
+    
+    semaphore.wait()
+    
+    switch result! {
+    case .success(let response):
+      return response
+    case .failure(let error):
+      throw error
+    }
+  }
+  
+  // Async version - returns Promise<NitroResponse>
   func request(req: NitroRequest) throws -> Promise<NitroResponse> {
     let promise = Promise<NitroResponse>.init()
     Task {

package/lib/module/NitroFetch.nitro.js

@@ -1,7 +1,4 @@
 "use strict";
 
-// Minimal request/response types to model WHATWG fetch without streaming.
-
-;
 export {};
 //# sourceMappingURL=NitroFetch.nitro.js.map

package/lib/module/NitroFetch.nitro.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sourceRoot":"../../src","sources":["NitroFetch.nitro.ts"],"mappings":";;AAEA;;AAaC;AAAC","ignoreList":[]}
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["NitroFetch.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/NitroInstances.js

@@ -3,4 +3,6 @@
 import { NitroModules } from 'react-native-nitro-modules';
 // Create singletons once per JS runtime
 export const NitroFetch = NitroModules.createHybridObject('NitroFetch');
+export const NativeStorage = NitroModules.createHybridObject('NativeStorage');
+export const boxedNitroFetch = NitroModules.box(NitroFetch);
 //# sourceMappingURL=NitroInstances.js.map

package/lib/module/NitroInstances.js.map

@@ -1 +1 @@
-{"version":3,"names":["NitroModules","NitroFetch","createHybridObject"],"sourceRoot":"../../src","sources":["NitroInstances.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD;AACA,OAAO,MAAMC,UAA0B,GACrCD,YAAY,CAACE,kBAAkB,CAAiB,YAAY,CAAC","ignoreList":[]}
+{"version":3,"names":["NitroModules","NitroFetch","createHybridObject","NativeStorage","boxedNitroFetch","box"],"sourceRoot":"../../src","sources":["NitroInstances.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAMzD;AACA,OAAO,MAAMC,UAA0B,GACrCD,YAAY,CAACE,kBAAkB,CAAiB,YAAY,CAAC;AAE/D,OAAO,MAAMC,aAAgC,GAC3CH,YAAY,CAACE,kBAAkB,CAAoB,eAAe,CAAC;AAErE,OAAO,MAAME,eAAe,GAAGJ,YAAY,CAACK,GAAG,CAACJ,UAAU,CAAC","ignoreList":[]}