feat: Cache configuration for a given ClientSession

Sources/PrimerSDK/Classes/Core/Analytics/AnalyticsEvent.swift

@@ -537,19 +537,27 @@ struct TimerEventProperties: AnalyticsEventProperties {
     var momentType: Analytics.Event.Property.TimerType
     var id: String?
     var params: [String: AnyCodable]?
+    var duration: TimeInterval?
+    var context: [String: Any]?
 
     private enum CodingKeys: String, CodingKey {
         case momentType
         case id
         case params
+        case duration
+        case context
     }
 
     fileprivate init(
         momentType: Analytics.Event.Property.TimerType,
-        id: String?
+        id: String?,
+        duration: TimeInterval? = nil,
+        context: [String: Any]? = nil
     ) {
         self.momentType = momentType
         self.id = id
+        self.duration = duration
+        self.context = context
 
         let sdkProperties = SDKProperties()
         if let sdkPropertiesDict = try? sdkProperties.asDictionary(),
@@ -568,13 +576,17 @@ struct TimerEventProperties: AnalyticsEventProperties {
         self.momentType = try container.decode(Analytics.Event.Property.TimerType.self, forKey: .momentType)
         self.id = try container.decodeIfPresent(String.self, forKey: .id)
         self.params = try container.decodeIfPresent([String: AnyCodable].self, forKey: .params)
+        self.duration = try container.decodeIfPresent(TimeInterval.self, forKey: .duration)
+        self.context = try container.decodeIfPresent([String: Any].self, forKey: .context)
     }
 
     func encode(to encoder: Encoder) throws {
         var container = encoder.container(keyedBy: CodingKeys.self)
         try container.encode(momentType, forKey: .momentType)
         try container.encodeIfPresent(id, forKey: .id)
         try container.encodeIfPresent(params, forKey: .params)
+        try container.encodeIfPresent(duration, forKey: .duration)
+        try container.encodeIfPresent(context, forKey: .context)
     }
 }
 
@@ -661,6 +673,7 @@ struct SDKProperties: Codable {
     let sdkSettings: [String: AnyCodable]?
     let sdkType: String?
     let sdkVersion: String?
+    let context: [String: AnyCodable]?
 
     private enum CodingKeys: String, CodingKey {
         case clientToken
@@ -673,6 +686,7 @@ struct SDKProperties: Codable {
         case sdkSettings
         case sdkType
         case sdkVersion
+        case context
     }
 
     fileprivate init() {
@@ -690,6 +704,7 @@ struct SDKProperties: Codable {
 
         self.sdkType = Primer.shared.integrationOptions?.reactNativeVersion == nil ? "IOS_NATIVE" : "RN_IOS"
         self.sdkVersion = VersionUtils.releaseVersionNumber
+        self.context = nil
 
         if let settingsData = try? JSONEncoder().encode(PrimerSettings.current) {
             let decoder = JSONDecoder()
@@ -714,6 +729,8 @@ struct SDKProperties: Codable {
         self.sdkSettings = try container.decodeIfPresent([String: AnyCodable].self, forKey: .sdkSettings)
         self.sdkType = try container.decodeIfPresent(String.self, forKey: .sdkType)
         self.sdkVersion = try container.decodeIfPresent(String.self, forKey: .sdkVersion)
+        self.context = try container.decodeIfPresent([String: AnyCodable].self, forKey: .context)
+
     }
 
     func encode(to encoder: Encoder) throws {
@@ -728,6 +745,7 @@ struct SDKProperties: Codable {
         try container.encodeIfPresent(sdkSettings, forKey: .sdkSettings)
         try container.encodeIfPresent(sdkType, forKey: .sdkType)
         try container.encodeIfPresent(sdkVersion, forKey: .sdkVersion)
+        try container.encodeIfPresent(context, forKey: .context)
     }
 }
 
@@ -809,16 +827,51 @@ extension Analytics.Event {
     }
 
     static func timer(momentType: Property.TimerType,
-                      id: String?) -> Self {
+                      id: String?,
+                      duration: TimeInterval? = nil,
+                      context: [String: Any]? = nil) -> Self {
         return .init(
             eventType: .timerEvent,
             properties: TimerEventProperties(
                 momentType: momentType,
-                id: id
+                id: id,
+                duration: duration,
+                context: context
             )
         )
     }
 
+    enum DropInLoadingSource: String {
+        case universalCheckout = "UNIVERSAL_CHECKOUT"
+        case showPaymentMethod = "SHOW_PAYMENT_METHOD"
+        case vaultManager = "VAULT_MANAGER"
+    }
+
+    static func dropInLoading(duration: Int,
+                              source: DropInLoadingSource) -> Self {
+        .timer(momentType: .end, 
+               id: "DROP_IN_LOADING",
+               duration: TimeInterval(duration),
+               context: ["source": source.rawValue])
+    }
+
+    static func headlessLoading(duration: Int) -> Self {
+        .timer(momentType: .end, id: "HEADLESS_LOADING", duration: TimeInterval(duration))
+    }
+
+    enum ConfigurationLoadingSource: String {
+        case cache = "CACHE"
+        case network = "NETWORK"
+    }
+
+    static func configurationLoading(duration: Int, 
+                                     source: ConfigurationLoadingSource) -> Self {
+        .timer(momentType: .end, id: "CONFIGURATION_LOADING",
+               duration: TimeInterval(duration),
+               context: ["source": source.rawValue])
+    }
+
+
     static func allImagesLoading(momentType: Property.TimerType,
                                  id: String?) -> Self {
         return .init(

Sources/PrimerSDK/Classes/Core/Cache/Cache.swift

@@ -0,0 +1,50 @@
+//
+//  Cache.swift
+//  PrimerSDK
+//
+//  Created by Niall Quinn on 31/07/24.
+//
+
+import Foundation
+
+class Cache<Key: Hashable, Value> {
+    private let cache = NSCache<WrappedKey, Entry>()
+
+    func insert(_ value: Value, forKey key: Key) {
+        cache.setObject(Entry(value: value), forKey: WrappedKey(key))
+    }
+
+    func value(forKey key: Key) -> Value? {
+        guard let entry = cache.object(forKey: WrappedKey(key)) else {
+            return nil
+        }
+        return entry.value
+    }
+
+    func removeValue(forKey key: Key) {
+        cache.removeObject(forKey: WrappedKey(key))
+    }
+}
+
+private extension Cache {
+    final class WrappedKey: NSObject {
+        let key: Key
+        init(_ key: Key) { self.key = key }
+
+        override var hash: Int { return key.hashValue }
+
+        override func isEqual(_ object: Any?) -> Bool {
+            guard let value = object as? WrappedKey else {
+                return false
+            }
+            return value.key == key
+        }
+    }
+}
+
+private extension Cache {
+    final class Entry {
+        let value: Value
+        init(value: Value) { self.value = value }
+    }
+}

Sources/PrimerSDK/Classes/Core/Cache/ConfigurationCache/ConfigurationCache.swift

@@ -0,0 +1,88 @@
+//
+//  ConfigurationCache.swift
+//  PrimerSDK
+//
+//  Created by Niall Quinn on 31/07/24.
+//
+
+import Foundation
+
+protocol ConfigurationCaching {
+    func clearCache()
+    func setData(_ data: ConfigurationCachedData, forKey key: String)
+    func data(forKey key: String) -> ConfigurationCachedData?
+}
+
+class ConfigurationCache: ConfigurationCaching {
+    static let shared = ConfigurationCache()
+    private var cache = Cache<String, ConfigurationCachedData>()
+
+    func clearCache() {
+        cache = Cache<String, ConfigurationCachedData>()
+    }
+
+    func data(forKey key: String) -> ConfigurationCachedData? {
+        guard cachingEnabled else {
+            return nil
+        }
+        if let cachedData = cache.value(forKey: key) {
+            if validateCachedConfig(key: key, cachedData: cachedData) == false {
+                cache.removeValue(forKey: key)
+                return nil
+            }
+            return cachedData
+        }
+        return nil
+    }
+
+    func setData(_ data: ConfigurationCachedData, forKey key: String) {
+        guard cachingEnabled else {
+            return
+        }
+        // Cache includes at most one cached configuration
+        clearCache()
+        cache.insert(data, forKey: key)
+    }
+
+    private func validateCachedConfig(key: String, cachedData: ConfigurationCachedData) -> Bool {
+        let timestamp = cachedData.timestamp
+        let now = Date().timeIntervalSince1970
+        let timeInterval = now - timestamp
+
+        if timeInterval > cachedData.ttl {
+            return false
+        }
+
+        return true
+    }
+
+    private var cachingEnabled: Bool {
+        PrimerSettings.current.clientSessionCachingEnabled
+    }
+}
+
+class ConfigurationCachedData {
+
+    let config: PrimerAPIConfiguration
+    let timestamp: TimeInterval
+    let ttl: TimeInterval
+
+    init(config: PrimerAPIConfiguration, headers: [String: String]? = nil) {
+        // Extract ttl from headers
+        self.config = config
+        self.timestamp = Date().timeIntervalSince1970
+        self.ttl = Self.extractTtlFromHeaders(headers)
+    }
+
+    static let FallbackCacheExpiration: TimeInterval = 0
+    static let CacheHeaderKey = "x-primer-session-cache-ttl"
+
+    private static func extractTtlFromHeaders(_ headers: [String: String]?) -> TimeInterval {
+        guard let headers,
+              let ttlHeaderValue = headers[Self.CacheHeaderKey],
+              let ttlInt = Int(ttlHeaderValue) else {
+            return Self.FallbackCacheExpiration
+        }
+        return TimeInterval(ttlInt)
+    }
+}