feat: [wip] Adopt newer OF SDK

Author: fabriziodemaria

Package.resolved

@@ -5,9 +5,9 @@
         "package": "OpenFeature",
         "repositoryURL": "[email protected]:open-feature/swift-sdk.git",
         "state": {
-          "branch": null,
-          "revision": "02b033c954766e86d5706bfc8ee5248244c11e77",
-          "version": "0.1.0"
+          "branch": "fatal-state",
+          "revision": "ac150987ad2ff7657e7d976cd304880bc6d33784",
+          "version": null
         }
       }
     ]

Package.swift

@@ -18,7 +18,7 @@ let package = Package(
             targets: ["Confidence"])
     ],
     dependencies: [
-        .package(url: "[email protected]:open-feature/swift-sdk.git", from: "0.1.0"),
+        .package(url: "[email protected]:open-feature/swift-sdk.git", branch: "fatal-state"),
     ],
     targets: [
         .target(

Sources/ConfidenceProvider/ConfidenceFeatureProvider.swift

@@ -15,7 +15,7 @@ public class ConfidenceFeatureProvider: FeatureProvider {
     public var hooks: [any Hook] = []
     private let lock = UnfairLock()
     private let initializationStrategy: InitializationStrategy
-    private let eventHandler = EventHandler(ProviderEvent.notReady)
+    private let eventHandler = EventHandler()
     private let confidence: Confidence
     private let confidenceFeatureProviderQueue = DispatchQueue(label: "com.provider.queue")
     private var cancellables = Set<AnyCancellable>()
@@ -26,7 +26,7 @@ public class ConfidenceFeatureProvider: FeatureProvider {
     The `initializationStrategy` defines when the Provider is ready to read flags, before or after a refresh of the flag evaluation fata.
     */
     public convenience init(confidence: Confidence, initializationStrategy: InitializationStrategy = .fetchAndActivate) {
-        self.init(confidence: confidence, session: nil)
+        self.init(confidence: confidence, initializationStrategy: initializationStrategy, session: nil)
     }
 
     internal init(
@@ -39,28 +39,16 @@ public class ConfidenceFeatureProvider: FeatureProvider {
         self.confidence = confidence
     }
 
-    public func initialize(initialContext: OpenFeature.EvaluationContext?) {
+    public func initialize(initialContext: OpenFeature.EvaluationContext?) async throws {
         let context = ConfidenceTypeMapper.from(ctx: initialContext ?? MutableContext(attributes: [:]))
         confidence.putContextLocal(context: context)
-        do {
-            if initializationStrategy == .activateAndFetchAsync {
-                try confidence.activate()
-                eventHandler.send(.ready)
-                Task {
-                    await confidence.asyncFetch()
-                }
-            } else {
-                Task {
-                    do {
-                        try await confidence.fetchAndActivate()
-                        eventHandler.send(.ready)
-                    } catch {
-                        eventHandler.send(.error)
-                    }
-                }
+        if initializationStrategy == .activateAndFetchAsync {
+            try confidence.activate()
+            Task {
+                await confidence.asyncFetch()
             }
-        } catch {
-            eventHandler.send(.error)
+        } else {
+            try await confidence.fetchAndActivate()
         }
     }
 
@@ -75,14 +63,13 @@ public class ConfidenceFeatureProvider: FeatureProvider {
     public func onContextSet(
         oldContext: OpenFeature.EvaluationContext?,
         newContext: OpenFeature.EvaluationContext
-    ) {
+    ) async {
         let removedKeys: [String] = oldContext.map {
             Array($0.asMap().filter { key, _ in !newContext.asMap().keys.contains(key) }.keys)
         } ?? []
-
-        Task {
-            confidence.putContext(context: ConfidenceTypeMapper.from(ctx: newContext), removedKeys: removedKeys)
-        }
+        await confidence.putContextAndWait(
+            context: ConfidenceTypeMapper.from(ctx: newContext),
+            removedKeys: removedKeys)
     }
 
     public func getBooleanEvaluation(key: String, defaultValue: Bool, context: EvaluationContext?) throws
@@ -115,7 +102,7 @@ public class ConfidenceFeatureProvider: FeatureProvider {
         try confidence.getEvaluation(key: key, defaultValue: defaultValue).toProviderEvaluation()
     }
 
-    public func observe() -> AnyPublisher<OpenFeature.ProviderEvent, Never> {
+    public func observe() -> AnyPublisher<OpenFeature.ProviderEvent?, Never> {
         return eventHandler.observe()
     }
 

Tests/ConfidenceProviderTests/ConfidenceProviderTest.swift

@@ -21,16 +21,17 @@ class ConfidenceProviderTest: XCTestCase {
             .withFlagResolverClient(flagResolver: client)
             .build()
 
-        let provider = ConfidenceFeatureProvider(confidence: confidence, initializationStrategy: .activateAndFetchAsync)
-        OpenFeatureAPI.shared.setProvider(provider: provider)
-
         let cancellable = OpenFeatureAPI.shared.observe().sink { event in
             if event == .ready {
                 readyExpectation.fulfill()
             } else {
-                print(event)
+                print(event.debugDescription)
             }
         }
+
+        let provider = ConfidenceFeatureProvider(confidence: confidence, initializationStrategy: .activateAndFetchAsync)
+        OpenFeatureAPI.shared.setProvider(provider: provider)
+
         await fulfillment(of: [readyExpectation], timeout: 5.0)
         cancellable.cancel()
     }
@@ -60,16 +61,19 @@ class ConfidenceProviderTest: XCTestCase {
             .withStorage(storage: FakeStorage())
             .build()
 
-        let provider = ConfidenceFeatureProvider(confidence: confidence, initializationStrategy: .activateAndFetchAsync)
-        OpenFeatureAPI.shared.setProvider(provider: provider)
-
         let cancellable = OpenFeatureAPI.shared.observe().sink { event in
-            if event == .error {
-                errorExpectation.fulfill()
-            } else {
-                print(event)
+            if let event = event {
+                if case .error = event {
+                    errorExpectation.fulfill()
+                } else {
+                    // no-op
+                }
             }
         }
+
+        let provider = ConfidenceFeatureProvider(confidence: confidence, initializationStrategy: .activateAndFetchAsync)
+        OpenFeatureAPI.shared.setProvider(provider: provider)
+
         await fulfillment(of: [errorExpectation], timeout: 5.0)
         cancellable.cancel()
     }
@@ -103,7 +107,7 @@ class ConfidenceProviderTest: XCTestCase {
             if event == .ready {
                 readyExpectation.fulfill()
             } else {
-                print(event)
+                print(event.debugDescription)
             }
         }
         await fulfillment(of: [readyExpectation], timeout: 1.0)