refactoring of logging, async plugin prepare

Author: NikSativa

Source/Plugin/Plugins.Basic.swift

@@ -28,10 +28,10 @@ public extension Plugins {
     #endif
 
     /// The plugin that adds the basic authentication token to the header.
-    static func AuthBasic(with tokenProvider: @escaping AuthBasicTokenProvider) -> Plugin {
+    static func AuthBasic(overrideExisting: Bool = true, with tokenProvider: @escaping AuthBasicTokenProvider) -> Plugin {
         return TokenPlugin(id: "AuthBasic",
                            priority: .authBasic,
-                           type: .header(.set("Authorization")),
+                           type: .header(overrideExisting ? .set("Authorization") : .trySet("Authorization")),
                            tokenProvider: {
                                return tokenProvider().map { token in
                                    let token = Data("\(token.username):\(token.password)".utf8).base64EncodedString()

Source/Plugin/Plugins.Bearer.swift

@@ -2,12 +2,12 @@ import Foundation
 
 public extension Plugins {
     /// The plugin that adds the `bearer` authentication token to the header.
-    static func AuthBearer(with tokenProvider: @escaping TokenProvider) -> Plugin {
+    static func AuthBearer(overrideExisting: Bool = true, with tokenProvider: @escaping TokenProvider) -> Plugin {
         return TokenPlugin(id: "AuthBearer",
                            priority: .authBearer,
-                           type: .header(.set("Authorization")),
+                           type: .header(overrideExisting ? .set("Authorization") : .trySet("Authorization")),
                            tokenProvider: {
-                               return tokenProvider().map { token in
+                               return await tokenProvider().map { token in
                                    return "Bearer " + token
                                }
                            })

Source/Plugin/Plugins.Log.swift

@@ -177,23 +177,32 @@ public extension Plugins.Log {
     /// The `curl` component of the log.
     struct Component: Hashable, RawRepresentable, ExpressibleByStringLiteral, CustomDebugStringConvertible, SmartSendable {
         public let rawValue: String
+        /// The value is indicating the index the ``Component`` will iterated.
+        public let sortingOrder: Int
 
         public init(rawValue: String) {
             self.rawValue = rawValue
+            self.sortingOrder = -1
         }
 
         public init(stringLiteral value: String) {
             self.rawValue = value
+            self.sortingOrder = -1
         }
 
+        init(rawValue: String, sortingOrder: Int) {
+            self.rawValue = rawValue
+            self.sortingOrder = sortingOrder
+        }
+
+        public static let phase: Self = .init(rawValue: "phase", sortingOrder: 0)
+        public static let url: Self = .init(rawValue: "url", sortingOrder: 10)
+        public static let curl: Self = .init(rawValue: "curl", sortingOrder: 20)
+        public static let error: Self = .init(rawValue: "error", sortingOrder: 30)
+        public static let requestError: Self = .init(rawValue: "requestError", sortingOrder: 40)
+        public static let body: Self = .init(rawValue: "body", sortingOrder: 50)
         public static let id: Self = "id"
-        public static let url: Self = "url"
-        public static let phase: Self = "phase"
-        public static let curl: Self = "curl"
         public static let headers: Self = "headers"
-        public static let error: Self = "error"
-        public static let requestError: Self = "requestError"
-        public static let body: Self = "body"
         public static let userInfo: Self = "userInfo"
         public static let parameters: Self = "parameters"
         public static let request: Self = "request"
@@ -246,28 +255,28 @@ public extension Plugins.Log {
         public static let all: Self = [.willSend, .didFinish, .didReceive, .wasCancelled]
     }
 
-    struct DataCollection: Sequence {
-        public typealias Getter = () -> Any
+    struct DataCollection: Sequence, CustomDebugStringConvertible {
+        public typealias Getter<T> = () -> T
 
-        public let data: [Component: Getter]
+        public let data: [Component: Getter<Any>]
 
-        public init(data: [Component: Getter] = [:]) {
+        public init(data: [Component: Getter<Any>] = [:]) {
             self.data = data
         }
 
-        public func add(_ key: Component, _ value: @autoclosure @escaping Getter) -> Self {
+        public func add(_ key: Component, _ value: @autoclosure @escaping Getter<Any>) -> Self {
             var data = data
             data[key] = value
             return .init(data: data)
         }
 
-        public func add(_ key: Component, _ value: @escaping Getter) -> Self {
+        public func add(_ key: Component, _ value: @escaping Getter<Any>) -> Self {
             var data = data
             data[key] = value
             return .init(data: data)
         }
 
-        public func add(_ key: Component, if condition: Bool, _ value: @escaping Getter) -> Self {
+        public func add(_ key: Component, if condition: Bool, _ value: @escaping Getter<Any>) -> Self {
             guard condition else {
                 return self
             }
@@ -277,51 +286,75 @@ public extension Plugins.Log {
             return .init(data: data)
         }
 
-        public func getClosure(safe key: Component) -> (() -> Any)? {
+        public func getClosure(safe key: Component) -> Getter<Any>? {
             return data[key]
         }
 
-        public func getClosure(_ key: Component) -> () -> Any {
+        public func getClosure(_ key: Component) -> Getter<Any> {
             return data[key]!
         }
 
-        public func getAny(safe key: Component) -> Any? {
+        public func getClosure<T>(safe key: Component, ofType: T.Type) -> Getter<T>? {
+            if let value = data[key]?() as? T {
+                return { [value] in
+                    return value
+                }
+            }
+            return nil
+        }
+
+        public func getClosure<T>(_ key: Component, ofType: T.Type) -> Getter<T> {
+            return { [data] in
+                return data[key]!() as! T
+            }
+        }
+
+        public func get(safe key: Component) -> Any? {
             return data[key]?()
         }
 
-        public func getAny(_ key: Component) -> Any {
+        public func get(_ key: Component) -> Any {
             return data[key]!()
         }
 
-        public func get<T>(safe key: Component, ofType: T.Type = T.self) -> T? {
+        public func get<T>(safe key: Component, ofType: T.Type) -> T? {
             return data[key]?() as? T
         }
 
-        public func get<T>(_ key: Component, ofType: T.Type = T.self) -> T {
+        public func get<T>(_ key: Component, ofType: T.Type) -> T {
             return data[key]?() as! T
         }
 
-        public subscript<T>(safe key: Component) -> T? {
-            return get(safe: key)
+        public subscript<T>(safe key: Component, ofType type: T.Type) -> T? {
+            return get(safe: key, ofType: type)
         }
 
-        public subscript<T>(_ key: Component) -> T {
-            return get(key)
+        public subscript<T>(_ key: Component, ofType type: T.Type) -> T {
+            return get(key, ofType: type)
         }
 
         public func makeIterator() -> Iterator {
             return .init(data: self)
         }
 
         public struct Iterator: IteratorProtocol {
-            public typealias Element = (key: Component, value: Getter)
+            public typealias Element = (key: Component, value: Getter<Any>)
 
             private let data: [Element]
             private var index: Int
 
             init(data: DataCollection) {
                 self.data = data.data.sorted(by: { a, b in
-                    return a.key.rawValue < b.key.rawValue
+                    switch (a.key.sortingOrder, b.key.sortingOrder) {
+                    case (-1, -1):
+                        return a.key.rawValue < b.key.rawValue
+                    case (-1, _):
+                        return false
+                    case (_, -1):
+                        return true
+                    default:
+                        return a.key.sortingOrder < b.key.sortingOrder
+                    }
                 })
                 self.index = 0
             }
@@ -336,5 +369,11 @@ public extension Plugins.Log {
                 }
             }
         }
+
+        public var debugDescription: String {
+            return data.mapValues {
+                return $0()
+            }.debugDescription
+        }
     }
 }

Source/Plugin/Plugins.LogOS.swift

@@ -8,15 +8,15 @@ public extension Plugins {
     /// A type that maps the ID and URL to a loggable strings.
     ///
     /// - Important: If returning `nil`, it will not be logged.
-    typealias CurlOSMapper = @Sendable (_ id: String, _ url: () -> String) -> String?
+    typealias CurlOSMapper = @Sendable (_ id: String, _ url: String) -> String?
 
     /// Logger generator
     typealias LoggerGenerator = @Sendable (_ data: Plugins.Log.DataCollection) -> os.Logger
     #else
     /// A type that maps the ID and URL to a loggable strings.
     ///
     /// - Important: If returning `nil`, it will not be logged.
-    typealias CurlOSMapper = (_ id: String, _ url: () -> String) -> String?
+    typealias CurlOSMapper = (_ id: String, _ url: String) -> String?
 
     /// Logger generator
     typealias LoggerGenerator = (_ data: Plugins.Log.DataCollection) -> os.Logger
@@ -44,24 +44,18 @@ public extension Plugins {
                       options: Plugins.Log.Options = .all,
                       mapID: CurlOSMapper? = nil) -> Plugins.Log {
         return .init(id: Plugins.Log.makeHash(withAdditionalHash: "OS"),
-                     priority: priority) { data in
+                     priority: priority,
+                     options: options) { [mapID, shouldPrintBody] data in
             let logger = logger.get(data)
 
-            let id: String
-            if let mapID {
-                guard let uuid: UUID = data[safe: .id],
-                      let url: () -> String = data[safe: .url],
-                      let str = mapID(uuid.uuidString, url) else {
-                    logger.log(level: .error, "CurlOS: No ID mapping")
-                    return
-                }
+            let id: String?
+            if let mapID,
+               let uuid = data.get(safe: .id, ofType: UUID.self)?.uuidString,
+               let url = data.get(safe: .url, ofType: String.self),
+               let str = mapID(uuid, url) {
                 id = str
             } else {
-                guard let str: UUID = data[safe: .id] else {
-                    logger.log(level: .error, "CurlOS: No ID mapping")
-                    return
-                }
-                id = str.uuidString
+                id = nil
             }
 
             for (component, value) in data {
@@ -75,7 +69,15 @@ public extension Plugins {
                     continue
                 }
 
-                logger.log(level: component == .error ? .error : .info, "\(text) - \(id)")
+                if component == .body, shouldPrintBody {
+                    #if DEBUG
+                    print(text)
+                    #endif
+                } else if let id {
+                    logger.log(level: component == .error ? .error : .info, "\(text) - \(id)")
+                } else {
+                    logger.log(level: component == .error ? .error : .info, "\(text)")
+                }
             }
         }
     }
@@ -99,14 +101,19 @@ public extension Plugins.LoggerProvider {
         case .generator(let generator):
             return generator(data)
         case .identifiable:
-            let url: String = data[.url]
-            let uuid: UUID = data[.id]
-            let path: String = ((try? AddressDetails(string: url))?.path).map { $0.isEmpty ? "< root >" : $0.joined(separator: "/") } ?? "< unknown path >"
-            let id: String = uuid.uuidString.components(separatedBy: "-").first ?? uuid.uuidString
-            let identity = path + " " + id
-
+            let url = data[.url, ofType: String.self]
+            let uuid = data[.id, ofType: UUID.self].uuidString
+            let identity = PluginsLogIdentity(uuid, url)
             return .init(subsystem: Bundle.main.bundleIdentifier ?? "SmartNetwork", category: "Plugins.LogOS.\(identity)")
         }
     }
 }
+
+@inline(__always)
+public func PluginsLogIdentity(_ uuid: String, _ url: String) -> String {
+    let path: String = ((try? AddressDetails(string: url))?.path).map { $0.isEmpty ? "< root >" : $0.joined(separator: "/") } ?? "< unknown path >"
+    let id: String = uuid.components(separatedBy: "-").first ?? uuid
+    let identity = path + " " + id
+    return identity
+}
 #endif

Source/Plugin/Plugins.TokenPlugin.swift

@@ -3,17 +3,19 @@ import Foundation
 public extension Plugins {
     #if swift(>=6.0)
     /// The token provider.
-    typealias TokenProvider = @Sendable () -> String?
+    typealias TokenProvider = @Sendable () async -> String?
     #else
     /// The token provider.
-    typealias TokenProvider = () -> String?
+    typealias TokenProvider = () async -> String?
     #endif
 
     /// The type of the plugin where the token will be applied.
     enum TokenType: SmartSendable {
         public enum Operation: SmartSendable {
             /// Set token to the request. The previous value will be rewriten.
             case set(String)
+            /// Set token to the request only if no value for key.
+            case trySet(String)
             /// Add token to the request. The new value will be added to the existing one.
             case add(String)
         }
@@ -45,13 +47,17 @@ public extension Plugins {
         }
 
         public func prepare(parameters: Parameters, userInfo: UserInfo, request: inout URLRequestRepresentation, session: SmartURLSession) async {
-            let value = tokenProvider()
+            let value = await tokenProvider()
 
             switch type {
             case .header(let operation):
                 switch operation {
                 case .set(let key):
                     request.setValue(value, forHTTPHeaderField: key)
+                case .trySet(let key):
+                    if request.value(forHTTPHeaderField: key) == nil {
+                        request.setValue(value, forHTTPHeaderField: key)
+                    }
                 case .add(let key):
                     if let value {
                         request.addValue(value, forHTTPHeaderField: key)
@@ -65,6 +71,10 @@ public extension Plugins {
                     case .set(let key):
                         queryItems = queryItems.filter { $0.name != key }
                         queryItems.append(URLQueryItem(name: key, value: value))
+                    case .trySet(let key):
+                        if !queryItems.contains(where: { $0.name == key }) {
+                            queryItems.append(URLQueryItem(name: key, value: value))
+                        }
                     case .add(let key):
                         queryItems.append(URLQueryItem(name: key, value: value))
                     }

Source/Retrier/AnyErrorRetrier.swift …rce/Retrier/ConnectionErrorRetrier.swiftSource/Retrier/AnyErrorRetrier.swift renamed to Source/Retrier/ConnectionErrorRetrier.swift Source/Retrier/AnyErrorRetrier.swift renamed to Source/Retrier/ConnectionErrorRetrier.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-public struct AnyErrorRetrier: SmartRetrier {
+public struct ConnectionErrorRetrier: SmartRetrier {
     public let result: RetryResult
     public let attemptsCount: Int
 
@@ -10,7 +10,8 @@ public struct AnyErrorRetrier: SmartRetrier {
     }
 
     public func retryOrFinish(result: SmartResponse, address: Address, parameters: Parameters, userInfo: UserInfo) -> RetryResult {
-        if userInfo.attemptsCount < attemptsCount {
+        if case .connection = result.error?.requestError,
+           userInfo.attemptsCount < attemptsCount {
             return .retry
         }
         return self.result

Source/Stub/HTTPStubCondition.swift

@@ -223,8 +223,8 @@ private extension String {
 }
 
 #if swift(>=6.0)
-extension HTTPStubCondition: @unchecked Sendable {
-    public typealias TestClosure = (_ request: URLRequestRepresentation) -> Bool
+extension HTTPStubCondition: Sendable {
+    public typealias TestClosure = @Sendable (_ request: URLRequestRepresentation) -> Bool
 }
 #else
 public extension HTTPStubCondition {