fix: offline intitalization using cached config (#238)

jonathannorris · web-flow · commit 9463dd1b0cf6 · 2025-06-19T13:16:20.000-04:00
* fix: offline intitalization using cached config

* chore: cleanup setting userConfig, new updateUserConfig method

* chore: close existing SSE connection

* fix: try increasing test timeout
diff --git a/DevCycle/DevCycleClient.swift b/DevCycle/DevCycleClient.swift
@@ -21,6 +21,7 @@ enum ClientError: Error {
     case InvalidUser
     case MissingUserOrFeatureVariationsMap
     case MissingUser
+    case ConfigFetchFailed
 }
 
 public typealias ClientInitializedHandler = (Error?) -> Void
@@ -43,14 +44,13 @@ public class DevCycleClient {
     var inactivityDelayMS: Double = 120000
 
     private var service: DevCycleServiceProtocol?
-    private var cacheService: CacheServiceProtocol = CacheService()
-    private var cache: Cache?
+    internal var cacheService: CacheServiceProtocol = CacheService()
     var sseConnection: SSEConnectionProtocol?
     private var flushTimer: Timer?
     private var closed: Bool = false
     private var inactivityWorkItem: DispatchWorkItem?
     private var variableInstanceDictonary = [String: NSMapTable<AnyObject, AnyObject>]()
-    private var isConfigCached: Bool = false
+    internal var isConfigCached: Bool = false
     private var disableAutomaticEventLogging: Bool = false
     private var disableCustomEventLogging: Bool = false
 
@@ -152,15 +152,23 @@ public class DevCycleClient {
             user: user, enableEdgeDB: self.enableEdgeDB, extraParams: nil,
             completion: { [weak self] config, error in
                 guard let self = self else { return }
+
+                var finalError: Error? = error
+
                 if let error = error {
                     Log.error("Error getting config: \(error)", tags: ["setup"])
-                    self.cache = self.cacheService.load(user: user)
-                } else {
-                    if let config = config {
-                        Log.debug("Config: \(config)", tags: ["setup"])
+
+                    // If network failed but we have a cached config, don't return error
+                    if self.config?.userConfig != nil {
+                        Log.info("Using cached config due to network error")
+                        finalError = nil
                     }
-                    self.config?.userConfig = config
-                    self.isConfigCached = false
+                } else if let config = config {
+                    Log.debug("Config: \(config)", tags: ["setup"])
+                    self.updateUserConfig(config)
+                } else {
+                    Log.error("No config returned for setup", tags: ["setup"])
+                    finalError = ClientError.ConfigFetchFailed
                 }
 
                 if let config = config,
@@ -181,12 +189,10 @@ public class DevCycleClient {
                     }
                 }
 
-                self.setupSSEConnection()
-
                 for handler in self.configCompletionHandlers {
-                    handler(error)
+                    handler(finalError)
                 }
-                callback?(error)
+                callback?(finalError)
                 self.initialized = true
                 self.configCompletionHandlers = []
             })
@@ -229,14 +235,26 @@ public class DevCycleClient {
                     guard let self = self else { return }
                     if let error = error {
                         Log.error("Error getting config: \(error)", tags: ["refetchConfig"])
+                    } else if let config = config {
+                        self.updateUserConfig(config)
                     } else {
-                        self.config?.userConfig = config
-                        self.isConfigCached = false
+                        Log.error("No config returned for refetchConfig", tags: ["refetchConfig"])
                     }
                 })
         }
     }
 
+    private func updateUserConfig(_ config: UserConfig) {
+        let oldSSEURL = self.config?.userConfig?.sse?.url
+        self.config?.userConfig = config
+        self.isConfigCached = false
+
+        let newSSEURL = config.sse?.url
+        if newSSEURL != nil && oldSSEURL != newSSEURL {
+            self.setupSSEConnection()
+        }
+    }
+
     private func setupSSEConnection() {
         if let disableRealtimeUpdates = self.options?.disableRealtimeUpdates, disableRealtimeUpdates
         {
@@ -252,6 +270,13 @@ public class DevCycleClient {
             Log.error("Failed to parse SSE URL in config")
             return
         }
+
+        if self.sseConnection != nil {
+            Log.debug("Closing existing SSE connection")
+            self.sseConnection?.close()
+            self.sseConnection = nil
+        }
+
         if let inactivityDelay = self.config?.userConfig?.sse?.inactivityDelay {
             self.inactivityDelayMS = Double(inactivityDelay)
         }
@@ -418,21 +443,41 @@ public class DevCycleClient {
             user: updateUser, enableEdgeDB: self.enableEdgeDB, extraParams: nil,
             completion: { [weak self] config, error in
                 guard let self = self else { return }
+
                 if let error = error {
                     Log.error(
                         "Error getting config: \(error) for user_id \(String(describing: updateUser.userId))",
                         tags: ["identify"])
-                    self.cache = self.cacheService.load(user: updateUser)
+
+                    // Try to use cached config for the new user
                     self.useCachedConfigForUser(user: updateUser)
-                } else {
-                    if let config = config {
-                        Log.debug("Config: \(config)", tags: ["identify"])
+
+                    // If we have a cached config, proceed without error
+                    if self.config?.userConfig != nil {
+                        Log.info(
+                            "Using cached config for identifyUser due to network error: \(error)",
+                            tags: ["identify"])
+                        self.user = user
+                        callback?(nil, self.config?.userConfig?.variables)
+                        return
+                    } else {
+                        // No cached config available, return error and don't change client state
+                        Log.error(
+                            "Error getting config for identifyUser: \(error)", tags: ["identify"])
+                        callback?(error, nil)
+                        return
                     }
-                    self.config?.userConfig = config
-                    self.isConfigCached = false
                 }
-                self.user = user
-                callback?(error, self.config?.userConfig?.variables)
+
+                if let config = config {
+                    Log.debug("IdentifyUser config: \(config)", tags: ["identify"])
+                    self.updateUserConfig(config)
+                    self.user = user
+                    callback?(nil, self.config?.userConfig?.variables)
+                } else {
+                    Log.error("No config returned for identifyUser", tags: ["identify"])
+                    callback?(ClientError.ConfigFetchFailed, nil)
+                }
             })
     }
 
@@ -457,7 +502,6 @@ public class DevCycleClient {
     }
 
     public func resetUser(callback: IdentifyCompletedHandler? = nil) throws {
-        self.cache = cacheService.load(user: self.user!)
         self.flushEvents()
 
         let cachedAnonUserId = self.cacheService.getAnonUserId()
@@ -470,7 +514,10 @@ public class DevCycleClient {
             user: anonUser, enableEdgeDB: self.enableEdgeDB, extraParams: nil,
             completion: { [weak self] config, error in
                 guard let self = self else { return }
-                guard error == nil else {
+
+                if let error = error {
+                    Log.error("Error getting config for resetUser: \(error)", tags: ["reset"])
+                    // Restore previous anonymous user ID on error and don't change client state
                     if let previousAnonUserId = cachedAnonUserId {
                         self.cacheService.setAnonUserId(anonUserId: previousAnonUserId)
                     }
@@ -479,12 +526,14 @@ public class DevCycleClient {
                 }
 
                 if let config = config {
-                    Log.debug("Config: \(config)", tags: ["reset"])
+                    Log.debug("ResetUser config: \(config)", tags: ["reset"])
+                    self.updateUserConfig(config)
+                    self.user = anonUser
+                    callback?(nil, config.variables)
+                } else {
+                    Log.error("No config returned for resetUser", tags: ["reset"])
+                    callback?(ClientError.ConfigFetchFailed, nil)
                 }
-                self.config?.userConfig = config
-                self.isConfigCached = false
-                self.user = anonUser
-                callback?(error, config?.variables)
             })
     }
 
@@ -676,12 +725,10 @@ public class DevCycleClient {
     }
 
     private func useCachedConfigForUser(user: DevCycleUser) {
-        var cachedConfig: UserConfig?
-        if let disableConfigCache = options?.disableConfigCache, !disableConfigCache {
-            cachedConfig = cacheService.getConfig(user: user)
-        }
-
-        if cachedConfig != nil {
+        // Load cached config by default, unless explicitly disabled
+        if options?.disableConfigCache != true,
+            let cachedConfig = cacheService.getConfig(user: user)
+        {
             self.config?.userConfig = cachedConfig
             self.isConfigCached = true
             Log.debug("Loaded config from cache for user_id \(String(describing: user.userId))")
diff --git a/DevCycle/Models/Cache.swift b/DevCycle/Models/Cache.swift
@@ -7,7 +7,6 @@
 import Foundation
 
 protocol CacheServiceProtocol {
-    func load(user: DevCycleUser) -> Cache
     func setAnonUserId(anonUserId: String)
     func getAnonUserId() -> String?
     func clearAnonUserId()
@@ -17,11 +16,6 @@ protocol CacheServiceProtocol {
     func migrateLegacyCache()
 }
 
-struct Cache {
-    var config: UserConfig?
-    var anonUserId: String?
-}
-
 class CacheService: CacheServiceProtocol {
     struct CacheKeys {
         static let anonUserId = "ANONYMOUS_USER_ID"
@@ -41,12 +35,7 @@ class CacheService: CacheServiceProtocol {
 
     init(configCacheTTL: Int = DEFAULT_CONFIG_CACHE_TTL) {
         self.configCacheTTL = configCacheTTL
-    }
-
-    func load(user: DevCycleUser) -> Cache {
         migrateLegacyCache()
-
-        return Cache(config: getConfig(user: user), anonUserId: getAnonUserId())
     }
 
     func setAnonUserId(anonUserId: String) {
diff --git a/DevCycleTests/Models/DevCycleClientTests.swift b/DevCycleTests/Models/DevCycleClientTests.swift
@@ -161,7 +161,7 @@ class DevCycleClientTest: XCTestCase {
             expectation.fulfill()
         }
 
-        wait(for: [expectation], timeout: 1.0)
+        wait(for: [expectation], timeout: 2.0)
         client.close(callback: nil)
     }
 
@@ -714,6 +714,60 @@ class DevCycleClientTest: XCTestCase {
         wait(for: [expectation], timeout: 1.0)
         client.close(callback: nil)
     }
+
+    func testIdentifyUserWithCacheAvailableDoesNotReturnError() {
+        let expectation = XCTestExpectation(
+            description: "identifyUser with cache available should not return error")
+        let failedService = MockFailedConnectionService()
+
+        // Create a mock cache service that returns a cached config
+        let mockCacheService = MockCacheServiceWithConfig(userConfig: self.userConfig)
+
+        let client = try! self.builder.user(self.user).sdkKey("dvc_mobile_my_sdk_key").service(
+            failedService
+        ).build(onInitialized: nil)
+
+        // Replace the cache service with our mock that has a cached config
+        client.cacheService = mockCacheService
+
+        // Initialize the client's config object
+        client.config = DVCConfig(sdkKey: "dvc_mobile_my_sdk_key", user: self.user)
+
+        client.setup(
+            service: failedService,
+            callback: { error in
+                // Build process should work with cache
+                XCTAssertNil(error, "Build should not return error when cache is available")
+
+                do {
+                    let newUser = try DevCycleUser.builder().userId("new_user").build()
+
+                    // identifyUser should work with cached config even when network fails
+                    try client.identifyUser(
+                        user: newUser,
+                        callback: { error, variables in
+                            XCTAssertNil(
+                                error,
+                                "identifyUser should not return error when cache is available")
+                            XCTAssertNotNil(
+                                variables,
+                                "identifyUser should return variables when cache is available")
+                            XCTAssertTrue(
+                                client.isConfigCached, "Config should be marked as cached")
+                            XCTAssertEqual(
+                                client.user?.userId, newUser.userId,
+                                "User should be updated to new user")
+                            expectation.fulfill()
+                        })
+                } catch {
+                    XCTFail("identifyUser should not throw when cache is available")
+                    expectation.fulfill()
+                }
+            })
+
+        wait(for: [expectation], timeout: 100.0)
+        client.close(callback: nil)
+    }
 }
 
 extension DevCycleClientTest {
@@ -833,4 +887,24 @@ extension DevCycleClientTest {
             self.reopenCalled = true
         }
     }
+
+    private class MockCacheServiceWithConfig: CacheServiceProtocol {
+        private let userConfig: UserConfig
+
+        init(userConfig: UserConfig) {
+            self.userConfig = userConfig
+        }
+
+        func setAnonUserId(anonUserId: String) {}
+        func getAnonUserId() -> String? { return nil }
+        func clearAnonUserId() {}
+        func saveConfig(user: DevCycleUser, configToSave: Data?) {}
+        func getConfig(user: DevCycleUser) -> UserConfig? {
+            return self.userConfig
+        }
+        func getOrCreateAnonUserId() -> String {
+            return "mock-anon-id"
+        }
+        func migrateLegacyCache() {}
+    }
 }
diff --git a/DevCycleTests/Networking/DevCycleServiceTests.swift b/DevCycleTests/Networking/DevCycleServiceTests.swift
@@ -135,12 +135,7 @@ class DevCycleServiceTests: XCTestCase {
 
 extension DevCycleServiceTests {
     class MockCacheService: CacheServiceProtocol {
-        var loadCalled = false
         var saveConfigCalled = false
-        func load(user: DevCycleUser) -> Cache {
-            self.loadCalled = true
-            return Cache(config: nil, anonUserId: nil)
-        }
 
         func setAnonUserId(anonUserId: String) {
             // TODO: update implementation for tests
