feat: First Confidence Scaffolding

ConfidenceDemoApp/ConfidenceDemoApp/ConfidenceDemoApp.swift

@@ -1,6 +1,7 @@
 import ConfidenceProvider
 import OpenFeature
 import SwiftUI
+import Confidence
 
 @main
 struct ConfidenceDemoApp: App {
@@ -26,10 +27,13 @@ extension ConfidenceDemoApp {
             initializationStratgey = .fetchAndActivate
         }
 
-        let provider = ConfidenceFeatureProvider
-            .Builder(credentials: .clientSecret(secret: secret))
-            .with(initializationStrategy: initializationStratgey)
+        // TODO: Remove Builder pattern
+        let confidence = Confidence.Builder(clientSecret: secret)
+            .withOptions(options: ConfidenceClientOptions(initializationStrategy: initializationStratgey))
             .build()
+        // TODO: Remove Builder pattern
+        let provider = ConfidenceFeatureProvider.Builder(confidence: confidence).build()
+
         // NOTE: Using a random UUID for each app start is not advised and can result in getting stale values.
         let ctx = MutableContext(targetingKey: UUID.init().uuidString, structure: MutableStructure())
         OpenFeatureAPI.shared.setProvider(provider: provider, initialContext: ctx)

Package.swift

@@ -4,15 +4,18 @@
 import PackageDescription
 
 let package = Package(
-    name: "ConfidenceProvider",
+    name: "Confidence",
     platforms: [
         .iOS(.v14),
         .macOS(.v12)
     ],
     products: [
         .library(
             name: "ConfidenceProvider",
-            targets: ["ConfidenceProvider"])
+            targets: ["ConfidenceProvider"]),
+        .library(
+            name: "Confidence",
+            targets: ["Confidence"])
     ],
     dependencies: [
         .package(url: "[email protected]:open-feature/swift-sdk.git", from: "0.1.0"),
@@ -22,9 +25,15 @@ let package = Package(
             name: "ConfidenceProvider",
             dependencies: [
                 .product(name: "OpenFeature", package: "swift-sdk"),
+                "Confidence"
             ],
             plugins: []
         ),
+        .target(
+            name: "Confidence",
+            dependencies: [],
+            plugins: []
+        ),
         .testTarget(
             name: "ConfidenceProviderTests",
             dependencies: [

Sources/Confidence/Confidence.swift

@@ -0,0 +1,63 @@
+import Foundation
+
+public class Confidence: ConfidenceEventSender {
+    public var context: [String: String]
+    public let clientSecret: String
+    public let options: ConfidenceClientOptions
+
+    init(clientSecret: String, options: ConfidenceClientOptions) {
+        self.clientSecret = clientSecret
+        self.options = options
+        self.context = [:]
+    }
+
+    public func send(eventName: String) {
+        print("Sending \(eventName)")
+    }
+
+    public func updateContextEntry(key: String, value: String) {
+        context[key] = value
+    }
+
+    public func removeContextEntry(key: String) {
+        context.removeValue(forKey: key)
+    }
+
+    public func clearContext() {
+        context = [:]
+    }
+
+    public func withContext(_ context: [String: String]) -> Self {
+        // TODO
+        return self
+    }
+}
+
+extension Confidence {
+    public struct Builder {
+        let clientSecret: String
+        var options: ConfidenceClientOptions
+
+        public init(clientSecret: String) {
+            self.clientSecret = clientSecret
+            self.options = ConfidenceClientOptions(
+                credentials: ConfidenceClientCredentials.clientSecret(secret: (clientSecret)))
+        }
+
+        init(clientSecret: String, options: ConfidenceClientOptions) {
+            self.clientSecret = clientSecret
+            self.options = options
+        }
+
+        public func withOptions(options: ConfidenceClientOptions) -> Builder {
+            return Builder(
+                clientSecret: clientSecret,
+                options: options
+            )
+        }
+
+        public func build() -> Confidence {
+            return Confidence(clientSecret: clientSecret, options: ConfidenceClientOptions())
+        }
+    }
+}

Sources/Confidence/ConfidenceClientOptions.swift

@@ -0,0 +1,41 @@
+import Foundation
+
+public struct ConfidenceClientOptions {
+    public var credentials: ConfidenceClientCredentials // DEPRECATED
+    public var timeout: TimeInterval
+    public var region: ConfidenceRegion
+    public var initializationStrategy: InitializationStrategy
+
+    public init(
+        credentials: ConfidenceClientCredentials? = nil,
+        timeout: TimeInterval? = nil,
+        region: ConfidenceRegion? = nil,
+        initializationStrategy: InitializationStrategy = .fetchAndActivate
+    ) {
+        self.credentials = credentials ?? ConfidenceClientCredentials.clientSecret(secret: "")
+        self.timeout = timeout ?? 10.0
+        self.region = region ?? .global
+        self.initializationStrategy = initializationStrategy
+    }
+}
+
+public enum ConfidenceClientCredentials {
+    case clientSecret(secret: String)
+
+    public func getSecret() -> String {
+        switch self {
+        case .clientSecret(let secret):
+            return secret
+        }
+    }
+}
+
+public enum ConfidenceRegion {
+    case global
+    case europe
+    case usa
+}
+
+public enum InitializationStrategy {
+    case fetchAndActivate, activateAndFetchAsync
+}

Sources/Confidence/ConfidenceEventSender.swift

@@ -0,0 +1,5 @@
+import Foundation
+
+public protocol ConfidenceEventSender: Contextual {
+    func send(eventName: String)
+}

Sources/Confidence/Contextual.swift

@@ -0,0 +1,11 @@
+import Foundation
+
+public protocol Contextual {
+    var context: [String: String] { get set } // TODO Introdue complex types
+
+    func updateContextEntry(key: String, value: String)
+    func removeContextEntry(key: String)
+    func clearContext()
+
+    func withContext(_ context: [String: String]) -> Self
+}

Sources/ConfidenceProvider/Apply/FlagApplierWithRetries.swift

@@ -1,5 +1,6 @@
 import Foundation
 import OpenFeature
+import Confidence
 import os
 
 typealias ApplyFlagHTTPResponse = HttpClientResponse<ApplyFlagsResponse>

Sources/ConfidenceProvider/ConfidenceClient/RemoteConfidenceClient.swift

@@ -1,5 +1,7 @@
 import Foundation
 import OpenFeature
+import Confidence
+
 
 public class RemoteConfidenceClient: ConfidenceClient {
     private let targetingKey = "targeting_key"
@@ -161,37 +163,6 @@ struct ApplyFlagsRequest: Codable {
 struct ApplyFlagsResponse: Codable {
 }
 
-public struct ConfidenceClientOptions {
-    public var credentials: ConfidenceClientCredentials
-    public var timeout: TimeInterval
-    public var region: ConfidenceRegion
-
-    public init(
-        credentials: ConfidenceClientCredentials, timeout: TimeInterval? = nil, region: ConfidenceRegion? = nil
-    ) {
-        self.credentials = credentials
-        self.timeout = timeout ?? 10.0
-        self.region = region ?? .global
-    }
-}
-
-public enum ConfidenceClientCredentials {
-    case clientSecret(secret: String)
-
-    public func getSecret() -> String {
-        switch self {
-        case .clientSecret(let secret):
-            return secret
-        }
-    }
-}
-
-public enum ConfidenceRegion {
-    case global
-    case europe
-    case usa
-}
-
 struct Sdk: Codable {
     init(id: String?, version: String?) {
         self.id = id ?? "SDK_ID_SWIFT_PROVIDER"

Sources/ConfidenceProvider/ConfidenceFeatureProvider.swift

@@ -1,6 +1,7 @@
 import Foundation
 import OpenFeature
 import Combine
+import Confidence
 import os
 
 /// The implementation of the Confidence Feature Provider. This implementation allows to pre-cache evaluations.
@@ -21,6 +22,7 @@ public class ConfidenceFeatureProvider: FeatureProvider {
     private let initializationStrategy: InitializationStrategy
     private let storage: Storage
     private let eventHandler = EventHandler(ProviderEvent.notReady)
+    private let confidence: Confidence?
 
     /// Should not be called externally, use `ConfidenceFeatureProvider.Builder` instead.
     init(
@@ -31,7 +33,8 @@ public class ConfidenceFeatureProvider: FeatureProvider {
         overrides: [String: LocalOverride] = [:],
         flagApplier: FlagApplier,
         applyStorage: Storage,
-        initializationStrategy: InitializationStrategy
+        initializationStrategy: InitializationStrategy,
+        confidence: Confidence?
     ) {
         self.client = client
         self.metadata = metadata
@@ -40,6 +43,7 @@ public class ConfidenceFeatureProvider: FeatureProvider {
         self.flagApplier = flagApplier
         self.initializationStrategy = initializationStrategy
         self.storage = storage
+        self.confidence = confidence
 
         resolver = LocalStorageResolver(cache: cache)
     }
@@ -251,12 +255,12 @@ public class ConfidenceFeatureProvider: FeatureProvider {
             )
             return evaluationResult
         } catch ConfidenceError.cachedValueExpired {
-            return ProviderEvaluation(value: defaultValue,
-                                      variant: nil, 
-                                      reason: Reason.error.rawValue,
-                                      errorCode: ErrorCode.providerNotReady
-            )}
-        catch {
+            return ProviderEvaluation(
+                value: defaultValue,
+                variant: nil,
+                reason: Reason.error.rawValue,
+                errorCode: ErrorCode.providerNotReady)
+        } catch {
             throw error
         }
     }
@@ -410,8 +414,9 @@ extension ConfidenceFeatureProvider {
         var flagApplier: (any FlagApplier)?
         var initializationStrategy: InitializationStrategy = .fetchAndActivate
         var applyStorage: Storage = DefaultStorage.resolverApplyCache()
+        var confidence: Confidence?
 
-        /// Initializes the builder with the given credentails.
+        /// Initializes the builder with the given credentails. DEPRECATED
         ///
         ///     OpenFeatureAPI.shared.setProvider(provider:
         ///     ConfidenceFeatureProvider.Builder(credentials: .clientSecret(secret: "mysecret"))
@@ -420,6 +425,14 @@ extension ConfidenceFeatureProvider {
             self.options = ConfidenceClientOptions(credentials: credentials)
         }
 
+        /// TODO
+        public init(confidence: Confidence) {
+            self.options = ConfidenceClientOptions(credentials: ConfidenceClientCredentials
+                .clientSecret(secret: confidence.clientSecret))
+            self.initializationStrategy = confidence.options.initializationStrategy
+            self.confidence = confidence
+        }
+
         init(
             options: ConfidenceClientOptions,
             session: URLSession? = nil,
@@ -606,7 +619,8 @@ extension ConfidenceFeatureProvider {
                 overrides: localOverrides,
                 flagApplier: flagApplier,
                 applyStorage: applyStorage,
-                initializationStrategy: initializationStrategy
+                initializationStrategy: initializationStrategy,
+                confidence: confidence
             )
         }
     }

Sources/ConfidenceProvider/Http/NetworkClient.swift

@@ -1,4 +1,5 @@
 import Foundation
+import Confidence
 
 final class NetworkClient: HttpClient {
     private let headers: [String: String]

Tests/ConfidenceProviderTests/FlagApplierWithRetriesTest.swift

@@ -2,6 +2,7 @@
 // swiftlint:disable file_length
 import Foundation
 import OpenFeature
+import Confidence
 import XCTest
 
 @testable import ConfidenceProvider