feat!: Actor conversion and Swift Testing

Client and Server became actors to ensure sendability, and Messenger was marked sendable

Author: NeedleInAJayStack

Sources/GraphQLTransportWS/Client.swift

@@ -2,14 +2,14 @@ import Foundation
 import GraphQL
 
 /// Client is an open-ended implementation of the client side of the protocol. It parses and adds callbacks for each type of server respose.
-public class Client<InitPayload: Equatable & Codable>: @unchecked Sendable {
+public actor Client<InitPayload: Equatable & Codable> {
     let messenger: Messenger
 
-    var onConnectionAck: (ConnectionAckResponse, Client) async throws -> Void = { _, _ in }
-    var onNext: (NextResponse, Client) async throws -> Void = { _, _ in }
-    var onError: (ErrorResponse, Client) async throws -> Void = { _, _ in }
-    var onComplete: (CompleteResponse, Client) async throws -> Void = { _, _ in }
-    var onMessage: (String, Client) async throws -> Void = { _, _ in }
+    let onConnectionAck: (ConnectionAckResponse, Client) async throws -> Void
+    let onNext: (NextResponse, Client) async throws -> Void
+    let onError: (ErrorResponse, Client) async throws -> Void
+    let onComplete: (CompleteResponse, Client) async throws -> Void
+    let onMessage: (String, Client) async throws -> Void
 
     let encoder = GraphQLJSONEncoder()
     let decoder = JSONDecoder()
@@ -19,9 +19,19 @@ public class Client<InitPayload: Equatable & Codable>: @unchecked Sendable {
     /// - Parameters:
     ///   - messenger: The messenger to bind the client to.
     public init(
-        messenger: Messenger
+        messenger: Messenger,
+        onConnectionAck: @escaping (ConnectionAckResponse, Client) async throws -> Void = { _, _ in },
+        onNext: @escaping (NextResponse, Client) async throws -> Void = { _, _ in },
+        onError: @escaping (ErrorResponse, Client) async throws -> Void = { _, _ in },
+        onComplete: @escaping (CompleteResponse, Client) async throws -> Void = { _, _ in },
+        onMessage: @escaping (String, Client) async throws -> Void = { _, _ in }
     ) {
         self.messenger = messenger
+        self.onConnectionAck = onConnectionAck
+        self.onNext = onNext
+        self.onError = onError
+        self.onComplete = onComplete
+        self.onMessage = onMessage
     }
 
     /// Listen and react to the provided async sequence of server messages. This function will block until the stream is completed.
@@ -80,36 +90,6 @@ public class Client<InitPayload: Equatable & Codable>: @unchecked Sendable {
         }
     }
 
-    /// Define the callback run on receipt of a `connection_ack` message
-    /// - Parameter callback: The callback to assign
-    public func onConnectionAck(_ callback: @escaping (ConnectionAckResponse, Client) async throws -> Void) {
-        onConnectionAck = callback
-    }
-
-    /// Define the callback run on receipt of a `next` message
-    /// - Parameter callback: The callback to assign
-    public func onNext(_ callback: @escaping (NextResponse, Client) async throws -> Void) {
-        onNext = callback
-    }
-
-    /// Define the callback run on receipt of an `error` message
-    /// - Parameter callback: The callback to assign
-    public func onError(_ callback: @escaping (ErrorResponse, Client) async throws -> Void) {
-        onError = callback
-    }
-
-    /// Define the callback run on receipt of a `complete` message
-    /// - Parameter callback: The callback to assign
-    public func onComplete(_ callback: @escaping (CompleteResponse, Client) async throws -> Void) {
-        onComplete = callback
-    }
-
-    /// Define the callback run on receipt of any message
-    /// - Parameter callback: The callback to assign
-    public func onMessage(_ callback: @escaping (String, Client) async throws -> Void) {
-        onMessage = callback
-    }
-
     /// Send a `connection_init` request through the messenger
     public func sendConnectionInit(payload: InitPayload) async throws {
         try await messenger.send(

Sources/GraphQLTransportWS/Messenger.swift

@@ -1,7 +1,7 @@
 import Foundation
 
-/// Protocol for an object that can send messages. This allows mocking in tests
-public protocol Messenger {
+/// Protocol for an object that can send messages. This allows mocking in tests.
+public protocol Messenger: Sendable {
     /// Send a message through this messenger
     /// - Parameter message: The message to send
     func send<S: Sendable>(_ message: S) async throws -> Void where S: Collection, S.Element == Character

Sources/GraphQLTransportWS/Server.swift

@@ -4,31 +4,28 @@ import GraphQL
 /// Server implements the server-side portion of the protocol, allowing a few callbacks for customization.
 ///
 /// By default, there are no authorization checks
-public class Server<
+public actor Server<
     InitPayload: Equatable & Codable & Sendable,
     InitPayloadResult: Sendable,
     SubscriptionSequenceType: AsyncSequence & Sendable
->: @unchecked Sendable where
+> where
     SubscriptionSequenceType.Element == GraphQLResult
 {
-    // We keep this weak because we strongly inject this object into the messenger callback
     let messenger: Messenger
 
     let onInit: (InitPayload) async throws -> InitPayloadResult
     let onExecute: (GraphQLRequest, InitPayloadResult) async throws -> GraphQLResult
     let onSubscribe: (GraphQLRequest, InitPayloadResult) async throws -> SubscriptionSequenceType
-
-    var onExit: () async throws -> Void = {}
-    var onMessage: (String) async throws -> Void = { _ in }
-    var onOperationComplete: (String) async throws -> Void = { _ in }
-    var onOperationError: (String, [Error]) async throws -> Void = { _, _ in }
-
-    var initialized = false
-    var initResult: InitPayloadResult?
+    
+    let onMessage: (String) async throws -> Void
+    let onOperationComplete: (String) async throws -> Void
+    let onOperationError: (String, [Error]) async throws -> Void
 
     let decoder = JSONDecoder()
     let encoder = GraphQLJSONEncoder()
 
+    private var initialized = false
+    private var initResult: InitPayloadResult?
     private var subscriptionTasks = [String: Task<Void, any Error>]()
 
     /// Create a new server
@@ -37,16 +34,25 @@ public class Server<
     ///   - messenger: The messenger to bind the server to.
     ///   - onExecute: Callback run during `start` resolution for non-streaming queries. Typically this is `API.execute`.
     ///   - onSubscribe: Callback run during `start` resolution for streaming queries. Typically this is `API.subscribe`.
+    ///   - onMessage: Optional callback run on every message event
+    ///   - onOperationComplete: Optional callback run when an operation completes
+    ///   - onOperationError: Optional callback run when an operation errors
     public init(
         messenger: Messenger,
         onInit: @escaping (InitPayload) async throws -> InitPayloadResult,
         onExecute: @escaping (GraphQLRequest, InitPayloadResult) async throws -> GraphQLResult,
-        onSubscribe: @escaping (GraphQLRequest, InitPayloadResult) async throws -> SubscriptionSequenceType
+        onSubscribe: @escaping (GraphQLRequest, InitPayloadResult) async throws -> SubscriptionSequenceType,
+        onMessage: @escaping (String) async throws -> Void = { _ in },
+        onOperationComplete: @escaping (String) async throws -> Void = { _ in },
+        onOperationError: @escaping (String, [Error]) async throws -> Void = { _, _ in },
     ) {
         self.messenger = messenger
         self.onInit = onInit
         self.onExecute = onExecute
         self.onSubscribe = onSubscribe
+        self.onMessage = onMessage
+        self.onOperationComplete = onOperationComplete
+        self.onOperationError = onOperationError
     }
 
     /// Listen and react to the provided async sequence of client messages. This function will block until the stream is completed.
@@ -104,30 +110,6 @@ public class Server<
         subscriptionTasks.values.forEach { $0.cancel() }
     }
 
-    /// Define the callback run when the communication is shut down, either by the client or server
-    /// - Parameter callback: The callback to assign
-    public func onExit(_ callback: @escaping () -> Void) {
-        onExit = callback
-    }
-
-    /// Define the callback run on receipt of any message
-    /// - Parameter callback: The callback to assign
-    public func onMessage(_ callback: @escaping (String) -> Void) {
-        onMessage = callback
-    }
-
-    /// Define the callback run on the completion a full operation (query/mutation, end of subscription)
-    /// - Parameter callback: The callback to assign
-    public func onOperationComplete(_ callback: @escaping (String) -> Void) {
-        onOperationComplete = callback
-    }
-
-    /// Define the callback to run on error of any full operation (failed query, interrupted subscription)
-    /// - Parameter callback: The callback to assign
-    public func onOperationError(_ callback: @escaping (String, [Error]) -> Void) {
-        onOperationError = callback
-    }
-
     private func onConnectionInit(_ connectionInitRequest: ConnectionInitRequest<InitPayload>, _: Messenger) async throws {
         guard !initialized else {
             try await error(.tooManyInitializations())