feat: Update cached config logic: 30-day TTL and per-user caching (#226)

* Initial plan for issue

* Implement per-user config caching and update default TTL to 30 days

Co-authored-by: jonathannorris <[email protected]>

* Pull default TTL value into a constant

Co-authored-by: jonathannorris <[email protected]>

* feat: update cache migration logic, update tests

* feat: restructure Cache.swift, remove saving un-used user and config

* feat: cleanup creating CacheService()

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: jonathannorris <[email protected]>
Co-authored-by: Jonathan Norris <[email protected]>

Author: Copilot

DevCycle/DevCycleClient.swift

@@ -65,6 +65,11 @@ public class DevCycleClient {
             return
         }
 
+        // Only create new cache service if configCacheTTL is specified
+        if let configCacheTTL = self.options?.configCacheTTL {
+            self.cacheService = CacheService(configCacheTTL: configCacheTTL)
+        }
+
         self.config = DVCConfig(sdkKey: sdkKey, user: user)
 
         let service = DevCycleService(
@@ -142,10 +147,8 @@ public class DevCycleClient {
         self.service = service
 
         var cachedConfig: UserConfig?
-        if let configCacheTTL = options?.configCacheTTL,
-            let disableConfigCache = options?.disableConfigCache, !disableConfigCache
-        {
-            cachedConfig = cacheService.getConfig(user: user, ttlMs: configCacheTTL)
+        if let disableConfigCache = options?.disableConfigCache, !disableConfigCache {
+            cachedConfig = cacheService.getConfig(user: user)
         }
 
         if cachedConfig != nil {
@@ -160,30 +163,30 @@ public class DevCycleClient {
                 guard let self = self else { return }
                 if let error = error {
                     Log.error("Error getting config: \(error)", tags: ["setup"])
-                    self.cache = self.cacheService.load()
+                    self.cache = self.cacheService.load(user: user)
                 } else {
                     if let config = config {
                         Log.debug("Config: \(config)", tags: ["setup"])
                     }
                     self.config?.userConfig = config
                     self.isConfigCached = false
+                }
 
-                    self.cacheUser(user: user)
-
-                    if self.checkIfEdgeDBEnabled(config: config!, enableEdgeDB: self.enableEdgeDB) {
-                        if !(user.isAnonymous ?? false) {
-                            self.service?.saveEntity(
-                                user: user,
-                                completion: { data, response, error in
-                                    if error != nil {
-                                        Log.error(
-                                            "Error saving user entity for \(user). Error: \(String(describing: error))"
-                                        )
-                                    } else {
-                                        Log.info("Saved user entity")
-                                    }
-                                })
-                        }
+                if let config = config,
+                    self.checkIfEdgeDBEnabled(config: config, enableEdgeDB: self.enableEdgeDB)
+                {
+                    if !(user.isAnonymous ?? false) {
+                        self.service?.saveEntity(
+                            user: user,
+                            completion: { data, response, error in
+                                if error != nil {
+                                    Log.error(
+                                        "Error saving user entity for \(user). Error: \(String(describing: error))"
+                                    )
+                                } else {
+                                    Log.info("Saved user entity")
+                                }
+                            })
                     }
                 }
 
@@ -243,10 +246,6 @@ public class DevCycleClient {
         }
     }
 
-    private func cacheUser(user: DevCycleUser) {
-        self.cacheService.save(user: user)
-    }
-
     private func setupSSEConnection() {
         if let disableRealtimeUpdates = self.options?.disableRealtimeUpdates, disableRealtimeUpdates
         {
@@ -425,7 +424,7 @@ public class DevCycleClient {
                 guard let self = self else { return }
                 if let error = error {
                     Log.error("Error getting config: \(error)", tags: ["identify"])
-                    self.cache = self.cacheService.load()
+                    self.cache = self.cacheService.load(user: updateUser)
                 } else {
                     if let config = config {
                         Log.debug("Config: \(config)", tags: ["identify"])
@@ -434,7 +433,6 @@ public class DevCycleClient {
                     self.isConfigCached = false
                 }
                 self.user = user
-                self.cacheUser(user: user)
                 callback?(error, config?.variables)
             })
     }
@@ -457,7 +455,7 @@ public class DevCycleClient {
     }
 
     public func resetUser(callback: IdentifyCompletedHandler? = nil) throws {
-        self.cache = cacheService.load()
+        self.cache = cacheService.load(user: self.user!)
         self.flushEvents()
 
         let cachedAnonUserId = self.cacheService.getAnonUserId()
@@ -484,7 +482,6 @@ public class DevCycleClient {
                 self.config?.userConfig = config
                 self.isConfigCached = false
                 self.user = anonUser
-                self.cacheUser(user: anonUser)
                 callback?(error, config?.variables)
             })
     }

DevCycle/Models/Cache.swift

@@ -7,139 +7,192 @@
 import Foundation
 
 protocol CacheServiceProtocol {
-    func load() -> Cache
-    func save(user: DevCycleUser)
+    func load(user: DevCycleUser) -> Cache
     func setAnonUserId(anonUserId: String)
     func getAnonUserId() -> String?
     func clearAnonUserId()
-    func saveConfig(user: DevCycleUser, fetchDate: Int, configToSave: Data?)
-    func getConfig(user: DevCycleUser, ttlMs: Int) -> UserConfig?
+    func saveConfig(user: DevCycleUser, configToSave: Data?)
+    func getConfig(user: DevCycleUser) -> UserConfig?
     func getOrCreateAnonUserId() -> String
+    func migrateLegacyCache()
 }
 
 struct Cache {
     var config: UserConfig?
-    var user: DevCycleUser?
     var anonUserId: String?
 }
 
 class CacheService: CacheServiceProtocol {
     struct CacheKeys {
-        static let user = "user"
-        static let config = "config"
         static let anonUserId = "ANONYMOUS_USER_ID"
         static let identifiedConfigKey = "IDENTIFIED_CONFIG"
         static let anonymousConfigKey = "ANONYMOUS_CONFIG"
+        static let userIdSuffix = ".USER_ID"
+        static let expiryDateSuffix = ".EXPIRY_DATE"
+
+        // Legacy keys for cleanup
+        static let legacyUser = "user"
+        static let legacyConfig = "config"
+        static let legacyFetchDateSuffix = ".FETCH_DATE"
     }
 
     private let defaults: UserDefaults = UserDefaults.standard
+    private let configCacheTTL: Int
 
-    func load() -> Cache {
-        var userConfig: UserConfig?
-        var dvcUser: DevCycleUser?
-        if let data = defaults.object(forKey: CacheKeys.config) as? Data,
-            let dictionary = try? JSONSerialization.jsonObject(
-                with: data, options: .fragmentsAllowed) as? [String: Any],
-            let config = try? UserConfig(from: dictionary)
-        {
-            userConfig = config
-        }
-        if let data = defaults.object(forKey: CacheKeys.user) as? Data {
-            dvcUser = try? JSONDecoder().decode(DevCycleUser.self, from: data)
-        }
-        let anonUserId = self.getAnonUserId()
-
-        return Cache(config: userConfig, user: dvcUser, anonUserId: anonUserId)
+    init(configCacheTTL: Int = DEFAULT_CONFIG_CACHE_TTL) {
+        self.configCacheTTL = configCacheTTL
     }
 
-    func save(user: DevCycleUser) {
-        if let data = try? JSONEncoder().encode(user) {
-            defaults.set(data, forKey: CacheKeys.user)
-        }
+    func load(user: DevCycleUser) -> Cache {
+        migrateLegacyCache()
+
+        return Cache(config: getConfig(user: user), anonUserId: getAnonUserId())
     }
 
     func setAnonUserId(anonUserId: String) {
-        self.setString(key: CacheKeys.anonUserId, value: anonUserId)
+        defaults.set(anonUserId, forKey: CacheKeys.anonUserId)
     }
 
     func getAnonUserId() -> String? {
-        return self.getString(key: CacheKeys.anonUserId)
+        return defaults.string(forKey: CacheKeys.anonUserId)
     }
 
     func clearAnonUserId() {
-        self.remove(key: CacheKeys.anonUserId)
+        defaults.removeObject(forKey: CacheKeys.anonUserId)
     }
 
-    func saveConfig(user: DevCycleUser, fetchDate: Int, configToSave: Data?) {
+    func saveConfig(user: DevCycleUser, configToSave: Data?) {
         let key = getConfigKeyPrefix(user: user)
         defaults.set(configToSave, forKey: key)
-        if let data = user.userId {
-            self.setString(key: "\(key).USER_ID", value: data)
-        }
-        self.setInt(key: "\(key).FETCH_DATE", value: fetchDate)
+
+        let expiryDate = currentTimeMs() + configCacheTTL
+        defaults.set(expiryDate, forKey: "\(key)\(CacheKeys.expiryDateSuffix)")
     }
 
-    func getConfig(user: DevCycleUser, ttlMs: Int) -> UserConfig? {
+    func getConfig(user: DevCycleUser) -> UserConfig? {
         let key = getConfigKeyPrefix(user: user)
-        var config: UserConfig?
 
-        let savedUserId = self.getString(key: "\(key).USER_ID")
-        let savedFetchDate = self.getInt(key: "\(key).FETCH_DATE")
-
-        if let userId = user.userId, userId != savedUserId {
-            Log.debug("Skipping cached config: user ID does not match")
-            return nil
-        }
-
-        let oldestValidDateMs = Int(Date().timeIntervalSince1970) - ttlMs
-        if let savedFetchDate = savedFetchDate, savedFetchDate < oldestValidDateMs {
-            Log.debug("Skipping cached config: last fetched date is too old")
+        // Check if cache has expired
+        if let savedExpiryDate = getIntValue(forKey: "\(key)\(CacheKeys.expiryDateSuffix)"),
+            currentTimeMs() > savedExpiryDate
+        {
+            Log.debug("Skipping cached config: config has expired")
+            cleanupCacheEntry(key: key)
             return nil
         }
 
-        if let data = defaults.object(forKey: key) as? Data,
+        // Try to load and parse cached config
+        guard let data = defaults.object(forKey: key) as? Data,
             let dictionary = try? JSONSerialization.jsonObject(
-                with: data, options: .fragmentsAllowed) as? [String: Any]
-        {
-            config = try? UserConfig(from: dictionary)
-        } else {
+                with: data, options: .fragmentsAllowed) as? [String: Any],
+            let config = try? UserConfig(from: dictionary)
+        else {
             Log.debug("Skipping cached config: no config found")
+            return nil
         }
 
         return config
     }
 
     func getOrCreateAnonUserId() -> String {
-        if let anonId = getAnonUserId() {
-            return anonId
+        if let existingId = getAnonUserId() {
+            return existingId
         }
-        let newAnonId = UUID().uuidString
-        setAnonUserId(anonUserId: newAnonId)
-        return newAnonId
-    }
 
-    private func setString(key: String, value: String) {
-        defaults.set(value, forKey: key)
+        let newId = UUID().uuidString
+        setAnonUserId(anonUserId: newId)
+        return newId
     }
 
-    private func getString(key: String) -> String? {
-        return defaults.string(forKey: key)
+    // MARK: - Private Helper Methods
+
+    private func currentTimeMs() -> Int {
+        return Int(Date().timeIntervalSince1970 * 1000)
     }
 
-    private func setInt(key: String, value: Int) {
-        defaults.set(value, forKey: key)
+    private func getIntValue(forKey key: String) -> Int? {
+        return defaults.object(forKey: key) != nil ? defaults.integer(forKey: key) : nil
     }
 
-    private func getInt(key: String) -> Int? {
-        return defaults.integer(forKey: key)
+    private func cleanupCacheEntry(key: String) {
+        defaults.removeObject(forKey: key)
+        defaults.removeObject(forKey: "\(key)\(CacheKeys.expiryDateSuffix)")
     }
 
-    private func remove(key: String) {
+    private func cleanupLegacyCacheEntry(key: String) {
         defaults.removeObject(forKey: key)
+        defaults.removeObject(forKey: "\(key)\(CacheKeys.userIdSuffix)")
+        defaults.removeObject(forKey: "\(key)\(CacheKeys.legacyFetchDateSuffix)")
     }
 
     private func getConfigKeyPrefix(user: DevCycleUser) -> String {
-        return (user.isAnonymous ?? false)
+        let baseKey =
+            (user.isAnonymous ?? false)
             ? CacheKeys.anonymousConfigKey : CacheKeys.identifiedConfigKey
+
+        if let userId = user.userId {
+            return "\(baseKey)_\(userId)"
+        }
+
+        return baseKey
+    }
+
+    // MARK: - Legacy Cache Migration
+
+    func migrateLegacyCache() {
+        // Migrate config cache
+        migrateConfigIfNeeded(oldKey: CacheKeys.identifiedConfigKey, isIdentified: true)
+        migrateConfigIfNeeded(oldKey: CacheKeys.anonymousConfigKey, isIdentified: false)
+
+        // Clean up legacy user cache
+        cleanupLegacyUserCache()
+
+        // Clean up legacy config cache
+        cleanupLegacyConfigCache()
+    }
+
+    private func cleanupLegacyUserCache() {
+        if defaults.object(forKey: CacheKeys.legacyUser) != nil {
+            defaults.removeObject(forKey: CacheKeys.legacyUser)
+            Log.debug("Cleaned up legacy user cache")
+        }
+    }
+
+    private func cleanupLegacyConfigCache() {
+        if defaults.object(forKey: CacheKeys.legacyConfig) != nil {
+            defaults.removeObject(forKey: CacheKeys.legacyConfig)
+            Log.debug("Cleaned up legacy config cache")
+        }
+    }
+
+    private func migrateConfigIfNeeded(oldKey: String, isIdentified: Bool) {
+        guard let oldConfigData = defaults.object(forKey: oldKey) as? Data,
+            let oldUserId = defaults.string(forKey: "\(oldKey)\(CacheKeys.userIdSuffix)")
+        else {
+            return
+        }
+
+        let newKey =
+            isIdentified
+            ? "\(CacheKeys.identifiedConfigKey)_\(oldUserId)"
+            : "\(CacheKeys.anonymousConfigKey)_\(oldUserId)"
+
+        // If new cache already exists, just cleanup legacy cache
+        if defaults.object(forKey: newKey) != nil {
+            Log.debug("New cache key \(newKey) already exists, cleaning up legacy cache \(oldKey)")
+            cleanupLegacyCacheEntry(key: oldKey)
+            return
+        }
+
+        // Migrate data to new format
+        defaults.set(oldConfigData, forKey: newKey)
+
+        let expiryDate = currentTimeMs() + configCacheTTL
+        defaults.set(expiryDate, forKey: "\(newKey)\(CacheKeys.expiryDateSuffix)")
+
+        // Cleanup old cache
+        cleanupLegacyCacheEntry(key: oldKey)
+
+        Log.debug("Migrated config + user cache from \(oldKey) to \(newKey)")
     }
 }