Smaller refactoring

Sources/Common/Http/HttpClient.swift

@@ -34,14 +34,12 @@ public enum HttpClientError: Error {
 }
 
 extension HTTPURLResponse {
-    public func mapStatusToError(error: HttpError?, flag: String = "unknown") -> Error {
+    public func mapStatusToError(error: HttpError?) -> Error {
         let defaultError = ConfidenceError.internalError(
             message: "General error: \(error?.message ?? "Unknown error")")
 
         switch self.status {
-        case .notFound:
-            return ConfidenceError.badRequest(message: flag) // TODO
-        case .badRequest:
+        case .notFound, .badRequest:
             return ConfidenceError.badRequest(message: error?.message ?? "")
         default:
             return defaultError

Sources/Common/Http/NetworkClient.swift

@@ -130,7 +130,6 @@ extension NetworkClient {
             let decoder = JSONDecoder()
             decoder.dateDecodingStrategy = .iso8601
             if response.response.status == .ok {
-                // TODO: Inspect and log errors
                 response.decodedData = try decoder.decode(T.self, from: responseData)
             } else {
                 do {

Sources/Common/Sdk.swift

@@ -0,0 +1,11 @@
+import Foundation
+
+public struct Sdk: Codable {
+    public init(id: String?, version: String?) {
+        self.id = id ?? "SDK_ID_SWIFT_PROVIDER"
+        self.version = version ?? "unknown"
+    }
+
+    var id: String
+    var version: String
+}

Sources/Confidence/Confidence.swift

@@ -28,11 +28,13 @@ public class Confidence: ConfidenceEventSender {
         self.parent = parent
     }
 
-    // TODO: Implement actual event uploading to the backend
     public func send(definition: String, payload: ConfidenceStruct) {
         print("Sending: \"\(definition)\".\nMessage: \(payload)\nContext: \(context)")
         Task {
-            try? await client.send(definition: definition, payload: payload)
+            // TODO: This will be called inside the EventSenderEngine once implemented
+            try? await client.upload(batch: [
+                ConfidenceClientEvent(definition: definition, payload: payload)
+            ])
         }
     }
 
@@ -105,6 +107,7 @@ extension Confidence {
                 client: RemoteConfidenceClient(
                     options: ConfidenceClientOptions(
                         credentials: ConfidenceClientCredentials.clientSecret(secret: clientSecret),
+                        timeout: timeout,
                         region: region),
                     metadata: ConfidenceMetadata(
                         name: "SDK_ID_SWIFT_CONFIDENCE",

Sources/Confidence/ConfidenceClient/ConfidenceClient.swift

@@ -1,5 +1,10 @@
 import Foundation
 
 public protocol ConfidenceClient {
-    func send(definition: String, payload: ConfidenceStruct) async throws
+    func upload(batch: [ConfidenceClientEvent]) async throws
+}
+
+public struct ConfidenceClientEvent {
+    var definition: String
+    var payload: ConfidenceStruct
 }

Sources/Confidence/ConfidenceClient/RemoteConfidenceClient.swift

@@ -26,16 +26,16 @@ public class RemoteConfidenceClient: ConfidenceClient {
         self.metadata = metadata
     }
 
-    public func send(definition: String, payload: ConfidenceStruct) async throws {
+    public func upload(batch: [ConfidenceClientEvent]) async throws {
         let timeString = Date.backport.nowISOString
         let request = PublishEventRequest(
-            events: [
+            events: batch.map { event in
                 Event(
-                    eventDefinition: "eventDefinitions/\(definition)",
-                    payload: payload,
+                    eventDefinition: "eventDefinitions/\(event.definition)",
+                    payload: event.payload,
                     eventTime: timeString
                 )
-            ],
+            },
             clientSecret: options.credentials.getSecret(),
             sendTime: timeString,
             sdk: Sdk(id: metadata.name, version: metadata.version)
@@ -99,14 +99,3 @@ struct EventError: Decodable {
         case unknown
     }
 }
-
-
-struct Sdk: Encodable {
-    init(id: String?, version: String?) {
-        self.id = id ?? "SDK_ID_SWIFT_PROVIDER"
-        self.version = version ?? "unknown"
-    }
-
-    var id: String
-    var version: String
-}

Sources/Confidence/ConfidenceMetadata.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-public struct ConfidenceMetadata {
-    public var name: String? = "SDK_ID_SWIFT_PROVIDER"
-    public var version: String?
+struct ConfidenceMetadata {
+    public var name: String
+    public var version: String
 }

Sources/ConfidenceProvider/Apply/FlagApplierWithRetries.swift

@@ -1,6 +1,6 @@
 import Foundation
-import Confidence
 import Common
+import Confidence
 import OpenFeature
 import os
 

Sources/ConfidenceProvider/Cache/DefaultStorage.swift

@@ -1,6 +1,6 @@
 import Foundation
-import Confidence
 import Common
+import Confidence
 
 public class DefaultStorage: Storage {
     private let storageQueue = DispatchQueue(label: "com.confidence.storage")

Sources/ConfidenceProvider/Cache/InMemoryProviderCache.swift

@@ -1,8 +1,8 @@
 import Foundation
 import Combine
+import Common
 import Confidence
 import OpenFeature
-import Common
 import os
 
 public class InMemoryProviderCache: ProviderCache {

Sources/ConfidenceProvider/ConfidenceClient/LocalStorageResolver.swift

@@ -1,7 +1,7 @@
 import Foundation
+import Common
 import Confidence
 import OpenFeature
-import Common
 
 public class LocalStorageResolver: Resolver {
     private var cache: ProviderCache

Sources/ConfidenceProvider/ConfidenceClient/RemoteConfidenceClient.swift → Sources/ConfidenceProvider/ConfidenceClient/RemoteResolveConfidenceClient.swift

@@ -1,17 +1,16 @@
 import Foundation
+import Common
 import Confidence
 import OpenFeature
-import Common
 
-public class RemoteConfidenceClient: ConfidenceResolveClient {
+public class RemoteConfidenceResolveClient: ConfidenceResolveClient {
     private let targetingKey = "targeting_key"
     private let flagApplier: FlagApplier
     private var options: ConfidenceClientOptions
     private let metadata: ConfidenceMetadata
 
     private var httpClient: HttpClient
     private var applyOnResolve: Bool
-    private var baseUrl: String
 
     init(
         options: ConfidenceClientOptions,
@@ -24,15 +23,9 @@ public class RemoteConfidenceClient: ConfidenceResolveClient {
         self.flagApplier = flagApplier
         self.applyOnResolve = applyOnResolve
         self.metadata = metadata
-        switch options.region {
-        case .global:
-            self.baseUrl = "https://resolver.confidence.dev/v1/flags"
-        case .europe:
-            self.baseUrl = "https://resolver.eu.confidence.dev/v1/flags"
-        case .usa:
-            self.baseUrl = "https://resolver.us.confidence.dev/v1/flags"
-        }
-        self.httpClient = NetworkClient(session: session, baseUrl: baseUrl)
+        self.httpClient = NetworkClient(
+            session: session,
+            baseUrl: BaseUrlMapper.from(region: options.region))
     }
 
     // MARK: Resolver
@@ -172,16 +165,6 @@ struct ApplyFlagsRequest: Codable {
 struct ApplyFlagsResponse: Codable {
 }
 
-struct Sdk: Codable {
-    init(id: String?, version: String?) {
-        self.id = id ?? "SDK_ID_SWIFT_PROVIDER"
-        self.version = version ?? "unknown"
-    }
-
-    var id: String
-    var version: String
-}
-
 private func displayName(resolvedFlag: ResolvedFlag) throws -> String {
     let flagNameComponents = resolvedFlag.flag.components(separatedBy: "/")
     if flagNameComponents.count <= 1 || flagNameComponents[0] != "flags" {

Sources/ConfidenceProvider/ConfidenceFeatureProvider.swift

@@ -1,8 +1,8 @@
 import Foundation
-import Confidence
-import OpenFeature
 import Combine
 import Common
+import Confidence
+import OpenFeature
 import os
 
 /// The implementation of the Confidence Feature Provider. This implementation allows to pre-cache evaluations.
@@ -28,7 +28,7 @@ public class ConfidenceFeatureProvider: FeatureProvider {
     /// Should not be called externally, use `ConfidenceFeatureProvider.Builder`or init with `Confidence` instead.
     init(
         metadata: ProviderMetadata,
-        client: RemoteConfidenceClient,
+        client: RemoteConfidenceResolveClient,
         cache: ProviderCache,
         storage: Storage,
         overrides: [String: LocalOverride] = [:],
@@ -58,21 +58,12 @@ public class ConfidenceFeatureProvider: FeatureProvider {
         self.cache = InMemoryProviderCache.from(storage: DefaultStorage.resolverFlagsCache())
         self.storage = DefaultStorage.resolverFlagsCache()
         self.resolver = LocalStorageResolver(cache: cache)
-        let baseUrl: String
-        switch options.region {
-        case .global:
-            baseUrl = "https://resolver.confidence.dev/v1/flags"
-        case .europe:
-            baseUrl = "https://resolver.eu.confidence.dev/v1/flags"
-        case .usa:
-            baseUrl = "https://resolver.us.confidence.dev/v1/flags"
-        }
         self.flagApplier = FlagApplierWithRetries(
-            httpClient: NetworkClient(baseUrl: baseUrl),
+            httpClient: NetworkClient(baseUrl: BaseUrlMapper.from(region: options.region)),
             storage: DefaultStorage.applierFlagsCache(),
             options: options,
             metadata: metadata)
-        self.client = RemoteConfidenceClient(
+        self.client = RemoteConfidenceResolveClient(
             options: options,
             applyOnResolve: false,
             flagApplier: flagApplier,
@@ -618,27 +609,18 @@ extension ConfidenceFeatureProvider {
 
         /// Creates the `ConfidenceFeatureProvider` according to the settings specified in the builder.
         public func build() -> ConfidenceFeatureProvider {
-            let baseUrl: String
-            switch options.region {
-            case .global:
-                baseUrl = "https://resolver.confidence.dev/v1/flags"
-            case .europe:
-                baseUrl = "https://resolver.eu.confidence.dev/v1/flags"
-            case .usa:
-                baseUrl = "https://resolver.us.confidence.dev/v1/flags"
-            }
             let flagApplier =
             flagApplier
             ?? FlagApplierWithRetries(
-                httpClient: NetworkClient(baseUrl: baseUrl),
+                httpClient: NetworkClient(baseUrl: BaseUrlMapper.from(region: options.region)),
                 storage: DefaultStorage.applierFlagsCache(),
                 options: options,
                 metadata: metadata
             )
 
             let cache = cache ?? InMemoryProviderCache.from(storage: storage)
 
-            let client = RemoteConfidenceClient(
+            let client = RemoteConfidenceResolveClient(
                 options: options,
                 session: self.session,
                 applyOnResolve: false,

Sources/ConfidenceProvider/Utils/File.swift

@@ -0,0 +1,15 @@
+import Foundation
+import Confidence
+
+public enum BaseUrlMapper {
+    static func from(region: ConfidenceRegion) -> String {
+        switch region {
+        case .global:
+            "https://resolver.confidence.dev/v1/flags"
+        case .europe:
+            "https://resolver.eu.confidence.dev/v1/flags"
+        case .usa:
+            "https://resolver.us.confidence.dev/v1/flags"
+        }
+    }
+}

Sources/ConfidenceProvider/Utils/HttpStatusCode+Error.swift

@@ -1,7 +1,7 @@
 import Foundation
+import Common
 import Confidence
 import OpenFeature
-import Common
 
 extension HTTPURLResponse {
     func mapStatusToError(error: HttpError?, flag: String = "unknown") -> Error {

Tests/ConfidenceProviderTests/Helpers/AlwaysFailCache.swift

@@ -1,7 +1,7 @@
 import Foundation
+import Common
 import Confidence
 import OpenFeature
-import Common
 
 @testable import ConfidenceProvider
 

Tests/ConfidenceProviderTests/Helpers/ClientMock.swift

@@ -1,6 +1,6 @@
 import Foundation
-import Confidence
 import Common
+import Confidence
 import OpenFeature
 
 @testable import ConfidenceProvider

Tests/ConfidenceProviderTests/Helpers/HttpClientMock.swift

@@ -1,6 +1,6 @@
 import Foundation
-import Confidence
 import Common
+import Confidence
 import XCTest
 
 final class HttpClientMock: HttpClient {

Tests/ConfidenceProviderTests/Helpers/MockedConfidenceClientURLProtocol.swift

@@ -1,6 +1,6 @@
 import Foundation
-import Confidence
 import Common
+import Confidence
 import OpenFeature
 
 @testable import ConfidenceProvider

Tests/ConfidenceProviderTests/LocalStorageResolverTest.swift

@@ -1,7 +1,7 @@
 import Foundation
+import Common
 import Confidence
 import OpenFeature
-import Common
 import XCTest
 
 @testable import ConfidenceProvider

Tests/ConfidenceProviderTests/RemoteConfidenceClientTest.swift → Tests/ConfidenceProviderTests/RemoteResolveConfidenceClientTest.swift

@@ -4,7 +4,7 @@ import XCTest
 
 @testable import ConfidenceProvider
 
-class RemoteConfidenceClientTest: XCTestCase {
+class RemoteResolveConfidenceClientTest: XCTestCase {
     var flags: [String: MockedConfidenceClientURLProtocol.TestFlag] = [:]
     let resolvedFlag1 = MockedConfidenceClientURLProtocol.ResolvedTestFlag(
         variant: "control", value: .structure(["size": .integer(3)]))
@@ -26,7 +26,7 @@ class RemoteConfidenceClientTest: XCTestCase {
         let session = MockedConfidenceClientURLProtocol.mockedSession(flags: flags)
         let flagApplier = FlagApplierMock()
 
-        let client = RemoteConfidenceClient(
+        let client = RemoteConfidenceResolveClient(
             options: .init(credentials: .clientSecret(secret: "test")),
             session: session,
             applyOnResolve: true,

Tests/ConfidenceTests/Helpers/ConfidenceClientMock.swift

@@ -3,7 +3,7 @@ import Foundation
 @testable import Confidence
 
 class ConfidenceClientMock: ConfidenceClient {
-    func send(definition: String, payload: ConfidenceStruct) async throws {
+    func upload(batch: [ConfidenceClientEvent]) async throws {
         // NO-OP
     }
 }