pulse-updates 1.0.5 → 1.0.6

package/android/src/main/java/app/pulse/updates/PulseController.kt

@@ -99,6 +99,10 @@ class PulseController private constructor() {
     private var embeddedManifest: EmbeddedManifest? = null
     private val executor = Executors.newSingleThreadExecutor()
 
+    // Cached manifest from last check (to avoid duplicate requests in fetch)
+    // Only valid for the immediate check->fetch sequence, cleared on use or new check
+    private var lastCheckManifest: ManifestModel? = null
+
     // Embedded asset hashes set for download optimization
     internal val embeddedAssetHashes: Set<String>
         get() = embeddedManifest?.assets
@@ -526,11 +530,26 @@ class PulseController private constructor() {
         }
 
         executor.execute {
-            PulseRemoteLoader.checkForUpdate(cfg, launchedUpdate?.updateId, callback)
+            // Clear any previous cached manifest before new check
+            lastCheckManifest = null
+
+            PulseRemoteLoader.checkForUpdate(cfg, launchedUpdate?.updateId) { result ->
+                // Cache the manifest if update is available (for use by fetchUpdate)
+                result.fold(
+                    onSuccess = { checkResult ->
+                        if (checkResult.isAvailable && checkResult.manifest != null) {
+                            lastCheckManifest = checkResult.manifest
+                            pulseLog(TAG, "checkForUpdate: cached manifest for fetch")
+                        }
+                    },
+                    onFailure = { }
+                )
+                callback(result)
+            }
         }
     }
 
-    fun fetchUpdate(callback: (Result<FetchResult>) -> Unit) {
+    fun fetchUpdate(cachedManifest: ManifestModel? = null, callback: (Result<FetchResult>) -> Unit) {
         val cfg = config
         val ctx = context
         val dir = directory
@@ -545,8 +564,18 @@ class PulseController private constructor() {
             return
         }
 
+        // Use cached manifest from recent check if available
+        var manifestToUse = cachedManifest
+        if (manifestToUse == null && lastCheckManifest != null) {
+            pulseLog(TAG, "fetchUpdate: using cached manifest from recent check")
+            manifestToUse = lastCheckManifest
+        }
+
+        // Clear the cache after using it
+        lastCheckManifest = null
+
         executor.execute {
-            PulseRemoteLoader.fetchUpdate(cfg, database, dir, callback)
+            PulseRemoteLoader.fetchUpdate(cfg, database, dir, manifestToUse, callback)
         }
     }
 
@@ -1141,8 +1170,22 @@ object PulseRemoteLoader {
         config: PulseUpdatesConfig,
         database: PulseDatabase?,
         directory: File,
+        cachedManifest: ManifestModel? = null,
         callback: (Result<FetchResult>) -> Unit
     ) {
+        // If we already have a manifest from a previous check, use it directly
+        if (cachedManifest != null) {
+            pulseLog(TAG, "fetchUpdate: using cached manifest, skipping check")
+            downloadUpdate(cachedManifest, config, database, directory) { downloadResult ->
+                downloadResult.fold(
+                    onSuccess = { callback(Result.success(FetchResult(isNew = true, manifest = cachedManifest))) },
+                    onFailure = { callback(Result.failure(it)) }
+                )
+            }
+            return
+        }
+
+        // No cached manifest, need to check first
         checkForUpdate(config, PulseController.getInstance().launchedUpdate?.updateId) { result ->
             result.fold(
                 onSuccess = { checkResult ->
@@ -1265,6 +1308,10 @@ object PulseRemoteLoader {
 
         // Download assets and link them to the update
         val embeddedHashes = PulseController.getInstance().embeddedAssetHashes
+        pulseLog(TAG, "downloadUpdate: embeddedHashes count=${embeddedHashes.size}")
+        if (embeddedHashes.isNotEmpty()) {
+            pulseLog(TAG, "downloadUpdate: first few embedded hashes: ${embeddedHashes.take(3).map { it.take(16) }}")
+        }
 
         for (asset in manifest.assets) {
             val assetHash = asset.hash.lowercase()

package/ios/PulseUpdates/AppLauncher/PulseAppLauncher.swift

@@ -473,8 +473,8 @@ struct PulseEmbeddedAsset {
         self.hash = hash
         self.key = json["key"] as? String
         self.type = json["type"] as? String ?? json["contentType"] as? String
-        self.nsBundleDir = json["nsBundleDir"] as? String
-        self.nsBundleFilename = json["nsBundleFilename"] as? String
+        self.nsBundleDir = json["mainBundleDir"] as? String ?? json["nsBundleDir"] as? String
+        self.nsBundleFilename = json["mainBundleFilename"] as? String ?? json["nsBundleFilename"] as? String
     }
 }
 

package/ios/PulseUpdates/PulseController.swift

@@ -66,6 +66,10 @@ public final class PulseController {
     internal var embeddedAssetHashes: [String: URL] = [:]
     private var embeddedBundleHash: String?
 
+    // Cached manifest from last check (to avoid duplicate requests in fetch)
+    // Only valid for the immediate check->fetch sequence, cleared on use or new check
+    private var lastCheckManifest: PulseManifest?
+
     // MARK: - Native Config (from Info.plist, like expo-updates)
 
     /// Load config from Info.plist (called before JS starts)
@@ -475,15 +479,24 @@ public final class PulseController {
             return
         }
 
+        // Clear any previous cached manifest before new check
+        lastCheckManifest = nil
+
         PulseRemoteLoader.checkForUpdate(
             config: config,
-            currentUpdateId: launchedUpdate?.updateId,
-            completion: completion
-        )
+            currentUpdateId: launchedUpdate?.updateId
+        ) { [weak self] result in
+            // Cache the manifest for subsequent fetchUpdate call
+            if case .success(let checkResult) = result, checkResult.isAvailable {
+                self?.lastCheckManifest = checkResult.manifest
+            }
+            completion(result)
+        }
     }
 
     /// Fetch and download an update
-    public func fetchUpdate(completion: @escaping (Result<PulseFetchResult, Error>) -> Void) {
+    /// - Parameter cachedManifest: Optional manifest from a previous checkForUpdate call to avoid duplicate request
+    public func fetchUpdate(cachedManifest: PulseManifest? = nil, completion: @escaping (Result<PulseFetchResult, Error>) -> Void) {
         guard let config = config else {
             completion(.failure(PulseUpdatesError.notConfigured))
             return
@@ -494,10 +507,21 @@ public final class PulseController {
             return
         }
 
+        // Use cached manifest from recent checkForUpdate if available
+        var manifestToUse = cachedManifest
+        if manifestToUse == nil, let cached = lastCheckManifest {
+            pulseLog("fetchUpdate: using cached manifest from recent check")
+            manifestToUse = cached
+        }
+
+        // Clear cache after use
+        lastCheckManifest = nil
+
         PulseRemoteLoader.fetchUpdate(
             config: config,
             database: database,
             directory: directory,
+            cachedManifest: manifestToUse,
             completion: completion
         )
     }
@@ -594,7 +618,7 @@ public final class PulseController {
             }
         }
 
-        pulseLog("Loaded embedded manifest: \(embeddedManifest?.updateId ?? "unknown")")
+        pulseLog("Loaded embedded manifest: \(embeddedManifest?.updateId ?? "unknown"), embeddedAssetHashes count: \(embeddedAssetHashes.count)")
     }
 
     private func seedEmbeddedUpdateIfNeeded() {
@@ -931,9 +955,24 @@ final class PulseRemoteLoader {
         config: PulseUpdatesConfig,
         database: PulseDatabase?,
         directory: URL,
+        cachedManifest: PulseManifest? = nil,
         completion: @escaping (Result<PulseFetchResult, Error>) -> Void
     ) {
-        // First check for update
+        // If we already have a manifest from a previous check, use it directly
+        if let manifest = cachedManifest {
+            pulseLog("fetchUpdate: using cached manifest, skipping check")
+            downloadUpdate(manifest: manifest, config: config, database: database, directory: directory) { downloadResult in
+                switch downloadResult {
+                case .failure(let error):
+                    completion(.failure(error))
+                case .success:
+                    completion(.success(PulseFetchResult(isNew: true, manifest: manifest)))
+                }
+            }
+            return
+        }
+
+        // No cached manifest, need to check first
         checkForUpdate(config: config, currentUpdateId: PulseController.shared.launchedUpdate?.updateId) { result in
             switch result {
             case .failure(let error):
@@ -1123,6 +1162,12 @@ final class PulseRemoteLoader {
         let group = DispatchGroup()
         var downloadError: Error?
 
+        let embeddedHashes = PulseController.shared.embeddedAssetHashes
+        pulseLog("downloadAssets: embeddedAssetHashes count=\(embeddedHashes.count)")
+        if !embeddedHashes.isEmpty {
+            pulseLog("downloadAssets: first few embedded hashes: \(Array(embeddedHashes.keys.prefix(3)).map { String($0.prefix(16)) })")
+        }
+
         for asset in assets {
             group.enter()
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pulse-updates",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "OTA updates for React Native - lightweight alternative to expo-updates",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",