fix: Actor executor fixes

Author: plajdo

Sources/GoodNetworking/Logging/NetworkLogger.swift

@@ -19,7 +19,7 @@ public enum LogLevel: String, CaseIterable {
 public protocol NetworkLogger: Sendable {
 
     /// Logs the given message with a specific log level, file name, and line number.
-    nonisolated func logNetworkEvent(
+    func logNetworkEvent(
         message: Any,
         level: LogLevel,
         file: String,

Sources/GoodNetworking/Models/Header.swift

@@ -11,12 +11,12 @@ import Foundation
 
 /// HTTP headers are colon separated name-value pairs used for specifying request
 /// details, authentication and more.
-public struct HTTPHeader: Equatable, Hashable, HeaderConvertible {
+public struct HTTPHeader: Equatable, Hashable, Sendable, HeaderConvertible {
 
     public let name: String
     public let value: String
 
-    /// Try to initialize HTTPHeader from string value. If string value cannot be parsed
+    /// Try to initialize ``HTTPHeader`` from string value. If string value cannot be parsed
     /// as a valid header, initialization fails with `nil`.
     /// - Parameter string: String to parse as a HTTP header
     public init?(from string: String) {
@@ -32,7 +32,7 @@ public struct HTTPHeader: Equatable, Hashable, HeaderConvertible {
         self.value = String(split[1])
     }
 
-    /// Initialize HTTPHeader from string value. String must be a valid header,
+    /// Initialize ``HTTPHeader`` from string value. String must be a valid header,
     /// otherwise the initialization will trip an assertion.
     /// - Parameter string: String representation of a HTTP header
     public init(_ string: String) {
@@ -48,7 +48,7 @@ public struct HTTPHeader: Equatable, Hashable, HeaderConvertible {
         self.value = String(split[1])
     }
 
-    /// Initialize HTTPHeader as a name-value pair.
+    /// Initialize ``HTTPHeader`` as a name-value pair.
     /// - Parameters:
     ///   - name: Name of the header (part before colon)
     ///   - value: Value of the header (part after colon)
@@ -82,14 +82,14 @@ extension HTTPHeader: CustomStringConvertible {
 // MARK: - HTTPHeaders
 
 /// A collection of multiple headers. Can contain any entities convertible to
-/// `HTTPHeader` (`HeaderConvertible`). Final header names
+/// ``HTTPHeader`` (``HeaderConvertible``). Final header names
 /// and values are resolved at the time the request is sent.
 public struct HTTPHeaders: Sendable {
 
     /// List of contained headers
     public var headers: [any HeaderConvertible]
 
-    /// Create collection of `HTTPHeader`-s from key-value dictionary mapped as
+    /// Create collection of ``HTTPHeader``-s from key-value dictionary mapped as
     /// name-value header pairs.
     /// - Parameter headers: Dictionary, where keys are header names
     public init(_ headers: [String: String]) {
@@ -122,7 +122,7 @@ public struct HTTPHeaders: Sendable {
     }
 
     /// Resolve all headers to their final values.
-    /// - Returns: Array of resolved headers as `HTTPHeader`-s
+    /// - Returns: Array of resolved headers as ``HTTPHeader``-s
     public func resolve() -> [HTTPHeader] {
         headers.map { $0.resolveHeader() }
     }
@@ -197,12 +197,16 @@ extension HTTPHeaders: CustomStringConvertible {
 
 // MARK: - HeaderConvertible
 
-/// Allows conforming entities to be converted to HTTPHeader
-/// for subsequent use in HTTP requests.
+/// Allows conforming entities to be converted to ``HTTPHeader``
+/// for use in HTTP requests.
 public protocol HeaderConvertible: Sendable {
 
-    /// Resolves the final name and value of the header
-    /// - Returns: Valid HTTP header name-value pair
+    /// Resolves the final name and value of the header.
+    ///
+    /// This function will be called every time for each header
+    /// before a network request is sent.
+    ///
+    /// - Returns: Valid HTTP header (name-value pair)
     func resolveHeader() -> HTTPHeader
 
 }

Sources/GoodNetworking/Models/URLConvertible.swift

@@ -11,7 +11,7 @@ import Foundation
 
 /// `URLConvertible` defines a function that asynchronously resolves the base URL used for network requests.
 /// Classes or structs that conform to this protocol can implement their own logic for determining and returning the base URL.
-public protocol URLConvertible: Sendable {
+public protocol URLConvertible {
 
     /// Resolves and returns the base URL for network requests asynchronously.
     ///

Sources/GoodNetworking/Session/NetworkSession.swift

@@ -9,7 +9,19 @@ import Foundation
 
 // MARK: - Initialization
 
-@NetworkActor public final class NetworkSession: NSObject, Sendable {
+/// Main network session
+///
+/// Session description
+///
+/// - Base URL: resolved once per request
+/// - Session headers: resolved once per session
+/// - Request headers: resolved once per request
+/// - Interceptor: intercepts every request (adapts, decides if/when to retry)
+/// - Are retried requests intercepted again?
+/// - Describe in more detail how interceptors work
+/// - BaseURL provider pattern
+/// - Name is used for identification only, not used by the network session itself
+@NetworkActor public final class NetworkSession: NSObject {
 
     nonisolated public let name: String
 
@@ -39,19 +51,19 @@ import Foundation
         logger: any NetworkLogger = PrintNetworkLogger(),
         name: String? = nil
     ) {
+        self.name = name ?? "NetworkSession"
+        
         self.baseUrl = baseUrl
         self.sessionHeaders = baseHeaders
         self.interceptor = interceptor
         self.logger = logger
-        self.name = name ?? "NetworkSession"
 
         let operationQueue = OperationQueue()
         operationQueue.name = "NetworkActorSerialExecutorOperationQueue"
         operationQueue.underlyingQueue = NetworkActor.queue
 
         let configuration = URLSessionConfiguration.ephemeral
-        configuration.httpAdditionalHeaders = baseHeaders.map { $0.resolveHeader() }.reduce(into: [:], { $0[$1.name] = $1.value })
-
+        
         self.configuration = configuration
         self.delegateQueue = operationQueue
 

Sources/GoodNetworking/Utilities/NetworkActor.swift

@@ -10,54 +10,69 @@ import Foundation
 // MARK: - Actor
 
 @globalActor public actor NetworkActor {
-
+    
+    // MARK: - Static
+    
     public static let shared: NetworkActor = NetworkActor()
     public static let queue: DispatchQueue = DispatchQueue(label: "goodnetworking.queue")
-
-    private let executor: any SerialExecutor
-
+    
+    private static let executor: NetworkActorExecutor = NetworkActorExecutor()
+    
+    // MARK: - Properties
+    
+    // MARK: - Computed properties
+    
     public nonisolated var unownedExecutor: UnownedSerialExecutor {
-        UnownedSerialExecutor(ordinary: executor)
-    }
-
-    public init() {
-        self.executor = NetworkActorSerialExecutor(queue: NetworkActor.queue)
+        Self.executor.asUnownedSerialExecutor()
     }
-
-    public static func assumeIsolated<T : Sendable>(_ operation: @NetworkActor () throws -> T) rethrows -> T {
-        typealias YesActor = @NetworkActor () throws -> T
-        typealias NoActor = () throws -> T
-
-        dispatchPrecondition(condition: .onQueue(queue))
-
-        // To do the unsafe cast, we have to pretend it's @escaping.
-        return try withoutActuallyEscaping(operation) { (_ fn: @escaping YesActor) throws -> T in
-            let rawFn = unsafeBitCast(fn, to: NoActor.self)
-            return try rawFn()
+    
+    // MARK: - Initialization
+    
+    private init() {}
+    
+    // MARK: - Isolation
+    
+    public static func assumeIsolated<T>(
+        _ block: @NetworkActor () throws -> sending T
+    ) rethrows -> sending T {
+        typealias YesActor = @NetworkActor () throws -> sending T
+        typealias NoActor = () throws -> sending T
+        
+        NetworkActor.preconditionIsolated()
+        
+        return try withoutActuallyEscaping(block) { (_ fn: @escaping YesActor) throws -> sending T in
+            try unsafeBitCast(fn, to: NoActor.self)()
         }
     }
-
+    
 }
 
-// MARK: - Executor
-
-internal final class NetworkActorSerialExecutor: SerialExecutor {
-
-    private let queue: DispatchQueue
-
-    internal init(queue: DispatchQueue) {
-        self.queue = queue
-    }
-
+internal final class NetworkActorExecutor: SerialExecutor {
+    
     internal func enqueue(_ job: UnownedJob) {
-        let executor = self.asUnownedSerialExecutor()
-        queue.async {
-            job.runSynchronously(on: executor)
+        NetworkActor.queue.async {
+            job.runSynchronously(on: NetworkActor.sharedUnownedExecutor)
         }
     }
-
+    
     internal func asUnownedSerialExecutor() -> UnownedSerialExecutor {
         UnownedSerialExecutor(ordinary: self)
     }
-
+    
+    // AVAILABLE: (iOS 26.0, macOS 26.0, *)
+    internal func isIsolatingCurrentContext() -> Bool? {
+        if OperationQueue.current?.underlyingQueue == NetworkActor.queue {
+            return true
+        } else {
+            return nil
+        }
+    }
+    
+    // AVAILABLE: (iOS 18.0, macOS 15.0, *)
+    internal func checkIsolated() {
+        guard isIsolatingCurrentContext() ?? false else {
+            fatalError()
+        }
+    }
+    
 }