feat!: Converts to Swift Concurrency

This adopts GraphQL v4, Graphiti v3, and removes the RxSwift and NIO dependencies.

Author: NeedleInAJayStack

Package.resolved

@@ -4,29 +4,25 @@ import PackageDescription
 
 let package = Package(
     name: "GraphQLTransportWS",
+    platforms: [.macOS(.v10_15)],
     products: [
         .library(
             name: "GraphQLTransportWS",
             targets: ["GraphQLTransportWS"]
         ),
     ],
     dependencies: [
-        .package(name: "Graphiti", url: "https://github.com/GraphQLSwift/Graphiti.git", from: "1.0.0"),
-        .package(name: "GraphQL", url: "https://github.com/GraphQLSwift/GraphQL.git", from: "2.2.1"),
-        .package(name: "GraphQLRxSwift", url: "https://github.com/GraphQLSwift/GraphQLRxSwift.git", from: "0.0.4"),
-        .package(name: "RxSwift", url: "https://github.com/ReactiveX/RxSwift.git", from: "6.1.0"),
-        .package(name: "swift-nio", url: "https://github.com/apple/swift-nio.git", from: "2.33.0"),
+        .package(url: "https://github.com/GraphQLSwift/Graphiti.git", from: "3.0.0"),
+        .package(url: "https://github.com/GraphQLSwift/GraphQL.git", from: "4.0.0"),
     ],
     targets: [
         .target(
             name: "GraphQLTransportWS",
             dependencies: [
                 .product(name: "Graphiti", package: "Graphiti"),
-                .product(name: "GraphQLRxSwift", package: "GraphQLRxSwift"),
                 .product(name: "GraphQL", package: "GraphQL"),
-                .product(name: "NIO", package: "swift-nio"),
-                .product(name: "RxSwift", package: "RxSwift")
-            ]),
+            ]
+        ),
         .testTarget(
             name: "GraphQLTransportWSTests",
             dependencies: ["GraphQLTransportWS"]

Package.swift

@@ -27,32 +27,32 @@ import GraphQLTransportWS
 /// Messenger wrapper for WebSockets
 class WebSocketMessenger: Messenger {
     private weak var websocket: WebSocket?
-    private var onReceive: (String) -> Void = { _ in }
-    
+    private var onReceive: (String) async throws -> Void = { _ in }
+
     init(websocket: WebSocket) {
         self.websocket = websocket
         websocket.onText { _, message in
-            self.onReceive(message)
+            try await self.onReceive(message)
         }
     }
-    
-    func send<S>(_ message: S) where S: Collection, S.Element == Character {
+
+    func send<S>(_ message: S) where S: Collection, S.Element == Character async throws {
         guard let websocket = websocket else { return }
-        websocket.send(message)
+        try await websocket.send(message)
     }
-    
-    func onReceive(callback: @escaping (String) -> Void) {
+
+    func onReceive(callback: @escaping (String) async throws -> Void) {
         self.onReceive = callback
     }
-    
-    func error(_ message: String, code: Int) {
+
+    func error(_ message: String, code: Int) async throws {
         guard let websocket = websocket else { return }
-        websocket.send("\(code): \(message)")
+        try await websocket.send("\(code): \(message)")
     }
-    
-    func close() {
+
+    func close() async throws {
         guard let websocket = websocket else { return }
-        _ = websocket.close()
+        try await websocket.close()
     }
 }
 ```
@@ -67,7 +67,7 @@ routes.webSocket(
         let server = GraphQLTransportWS.Server<EmptyInitPayload?>(
             messenger: messenger,
             onExecute: { graphQLRequest in
-                api.execute(
+                try await api.execute(
                     request: graphQLRequest.query,
                     context: context,
                     on: self.eventLoop,
@@ -76,7 +76,7 @@ routes.webSocket(
                 )
             },
             onSubscribe: { graphQLRequest in
-                api.subscribe(
+                try await api.subscribe(
                     request: graphQLRequest.query,
                     context: context,
                     on: self.eventLoop,
@@ -128,8 +128,8 @@ If the `payload` field is not required on your server, you may make Server's gen
 
 ## Memory Management
 
-Memory ownership among the Server, Client, and Messenger may seem a little backwards. This is because the Swift/Vapor WebSocket 
-implementation persists WebSocket objects long after their callback and they are expected to retain strong memory references to the 
+Memory ownership among the Server, Client, and Messenger may seem a little backwards. This is because the Swift/Vapor WebSocket
+implementation persists WebSocket objects long after their callback and they are expected to retain strong memory references to the
 objects required for responses. In order to align cleanly and avoid memory cycles, Server and Client are injected strongly into Messenger
 callbacks, and only hold weak references to their Messenger. This means that Messenger objects (or their enclosing WebSocket) must
 be persisted to have the connected Server or Client objects function. That is, if a Server's Messenger falls out of scope and deinitializes,

README.md

@@ -5,16 +5,16 @@ import GraphQL
 public class Client<InitPayload: Equatable & Codable> {
     // We keep this weak because we strongly inject this object into the messenger callback
     weak var messenger: Messenger?
-    
-    var onConnectionAck: (ConnectionAckResponse, Client) -> Void = { _, _ in }
-    var onNext: (NextResponse, Client) -> Void = { _, _ in }
-    var onError: (ErrorResponse, Client) -> Void = { _, _ in }
-    var onComplete: (CompleteResponse, Client) -> Void = { _, _ in }
-    var onMessage: (String, Client) -> Void = { _, _ in }
-    
+
+    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 encoder = GraphQLJSONEncoder()
     let decoder = JSONDecoder()
-    
+
     /// Create a new client.
     ///
     /// - Parameters:
@@ -24,123 +24,122 @@ public class Client<InitPayload: Equatable & Codable> {
     ) {
         self.messenger = messenger
         messenger.onReceive { message in
-            self.onMessage(message, self)
-            
+            try await self.onMessage(message, self)
+
             // Detect and ignore error responses.
             if message.starts(with: "44") {
                 // TODO: Determine what to do with returned error messages
                 return
             }
-            
+
             guard let json = message.data(using: .utf8) else {
-                self.error(.invalidEncoding())
+                try await self.error(.invalidEncoding())
                 return
             }
-            
+
             let response: Response
             do {
                 response = try self.decoder.decode(Response.self, from: json)
-            }
-            catch {
-                self.error(.noType())
+            } catch {
+                try await self.error(.noType())
                 return
             }
-            
+
             switch response.type {
-                case .connectionAck:
-                    guard let connectionAckResponse = try? self.decoder.decode(ConnectionAckResponse.self, from: json) else {
-                        self.error(.invalidResponseFormat(messageType: .connectionAck))
-                        return
-                    }
-                    self.onConnectionAck(connectionAckResponse, self)
-                case .next:
-                    guard let nextResponse = try? self.decoder.decode(NextResponse.self, from: json) else {
-                        self.error(.invalidResponseFormat(messageType: .next))
-                        return
-                    }
-                    self.onNext(nextResponse, self)
-                case .error:
-                    guard let errorResponse = try? self.decoder.decode(ErrorResponse.self, from: json) else {
-                        self.error(.invalidResponseFormat(messageType: .error))
-                        return
-                    }
-                    self.onError(errorResponse, self)
-                case .complete:
-                    guard let completeResponse = try? self.decoder.decode(CompleteResponse.self, from: json) else {
-                        self.error(.invalidResponseFormat(messageType: .complete))
-                        return
-                    }
-                    self.onComplete(completeResponse, self)
-                case .unknown:
-                    self.error(.invalidType())
+            case .connectionAck:
+                guard let connectionAckResponse = try? self.decoder.decode(ConnectionAckResponse.self, from: json) else {
+                    try await self.error(.invalidResponseFormat(messageType: .connectionAck))
+                    return
+                }
+                try await self.onConnectionAck(connectionAckResponse, self)
+            case .next:
+                guard let nextResponse = try? self.decoder.decode(NextResponse.self, from: json) else {
+                    try await self.error(.invalidResponseFormat(messageType: .next))
+                    return
+                }
+                try await self.onNext(nextResponse, self)
+            case .error:
+                guard let errorResponse = try? self.decoder.decode(ErrorResponse.self, from: json) else {
+                    try await self.error(.invalidResponseFormat(messageType: .error))
+                    return
+                }
+                try await self.onError(errorResponse, self)
+            case .complete:
+                guard let completeResponse = try? self.decoder.decode(CompleteResponse.self, from: json) else {
+                    try await self.error(.invalidResponseFormat(messageType: .complete))
+                    return
+                }
+                try await self.onComplete(completeResponse, self)
+            case .unknown:
+                try await self.error(.invalidType())
             }
         }
     }
-    
+
     /// Define the callback run on receipt of a `connection_ack` message
     /// - Parameter callback: The callback to assign
-    public func onConnectionAck(_ callback: @escaping (ConnectionAckResponse, Client) -> Void) {
-        self.onConnectionAck = callback
+    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) -> Void) {
-        self.onNext = callback
+    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) -> Void) {
-        self.onError = callback
+    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) -> Void) {
-        self.onComplete = callback
+    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) -> Void) {
-        self.onMessage = callback
+    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) {
+    public func sendConnectionInit(payload: InitPayload) async throws {
         guard let messenger = messenger else { return }
-        messenger.send(
+        try await messenger.send(
             ConnectionInitRequest(
                 payload: payload
             ).toJSON(encoder)
         )
     }
-    
+
     /// Send a `subscribe` request through the messenger
-    public func sendStart(payload: GraphQLRequest, id: String) {
+    public func sendStart(payload: GraphQLRequest, id: String) async throws {
         guard let messenger = messenger else { return }
-        messenger.send(
+        try await messenger.send(
             SubscribeRequest(
                 payload: payload,
                 id: id
             ).toJSON(encoder)
         )
     }
-    
+
     /// Send a `complete` request through the messenger
-    public func sendStop(id: String) {
+    public func sendStop(id: String) async throws {
         guard let messenger = messenger else { return }
-        messenger.send(
+        try await messenger.send(
             CompleteRequest(
                 id: id
             ).toJSON(encoder)
         )
     }
-    
+
     /// Send an error through the messenger and close the connection
-    private func error(_ error: GraphQLTransportWSError) {
+    private func error(_ error: GraphQLTransportWSError) async throws {
         guard let messenger = messenger else { return }
-        messenger.error(error.message, code: error.code.rawValue)
+        try await messenger.error(error.message, code: error.code.rawValue)
     }
 }