Merge pull request #11 from GraphQLSwift/feat/data-centric-view

Uses `Data` inputs and outputs

Author: NeedleInAJayStack

README.md

@@ -20,7 +20,7 @@ To use this package, include it in your `Package.swift` dependencies:
 .package(url: "https://github.com/GraphQLSwift/GraphQLTransportWS", from: "<version>")
 ```
 
-Then create a class to implement the `Messenger` protocol. Here's an example using
+Then create a concrete type that conforms to the `Messenger` protocol. Here's an example using
 [`WebSocketKit`](https://github.com/vapor/websocket-kit):
 
 ```swift
@@ -31,12 +31,12 @@ import GraphQLTransportWS
 struct WebSocketMessenger: Messenger {
     let websocket: WebSocket
 
-    func send<S>(_ message: S) where S: Collection, S.Element == Character async throws {
-        try await websocket.send(message)
+    func send(_ message: Data) async throws {
+        try await websocket.send(String(decoding: message, as: UTF8.self))
     }
 
     func error(_ message: String, code: Int) async throws {
-        try await websocket.send("\(code): \(message)")
+        try await websocket.close(code: code)
     }
 
     func close() async throws {
@@ -73,9 +73,9 @@ routes.webSocket(
                 )
             }
         )
-        let incoming = AsyncStream<String> { continuation in
+        let incoming = AsyncStream<Data> { continuation in
             websocket.onText { _, message in
-                continuation.yield(message)
+                continuation.yield(Data(message.utf8))
             }
         }
         try await server.listen(to: incoming)

Sources/GraphQLTransportWS/Client.swift

@@ -39,89 +39,102 @@ public actor Client<InitPayload: Equatable & Codable> {
     /// Listen and react to the provided async sequence of server messages. This function will block until the stream is completed.
     /// - Parameter incoming: The server message sequence that the client should react to.
     public func listen<A: AsyncSequence & Sendable>(to incoming: A) async throws
-    where A.Element == String {
+    where A.Element == Data {
         for try await message in incoming {
-            // Detect and ignore error responses.
-            if message.starts(with: "44") {
-                // TODO: Determine what to do with returned error messages
+            try await respond(to: message)
+        }
+    }
+
+    /// Listen and react to the provided async sequence of server messages. This function will block until the stream is completed.
+    /// - Parameter incoming: The server message sequence that the client should react to.
+    @available(*, deprecated, message: "Use `Data` sequence instead.")
+    public func listen<A: AsyncSequence & Sendable>(to incoming: A) async throws
+    where A.Element == String {
+        for try await stringMessage in incoming {
+            guard let message = stringMessage.data(using: .utf8) else {
+                try await self.error(.invalidEncoding())
                 return
             }
+            try await respond(to: message)
+        }
+    }
+
+    private func respond(to message: Data) async throws {
+        let response: Response
+        do {
+            response = try decoder.decode(Response.self, from: message)
+        } catch {
+            try await self.error(.noType())
+            return
+        }
 
-            guard let json = message.data(using: .utf8) else {
-                try await error(.invalidEncoding())
+        switch response.type {
+        case .connectionAck:
+            guard
+                let connectionAckResponse = try? decoder.decode(
+                    ConnectionAckResponse.self,
+                    from: message
+                )
+            else {
+                try await error(.invalidResponseFormat(messageType: .connectionAck))
                 return
             }
-
-            let response: Response
-            do {
-                response = try decoder.decode(Response.self, from: json)
-            } catch {
-                try await self.error(.noType())
+            try await onConnectionAck(connectionAckResponse, self)
+        case .next:
+            guard let nextResponse = try? decoder.decode(NextResponse.self, from: message) else {
+                try await error(.invalidResponseFormat(messageType: .next))
                 return
             }
-
-            switch response.type {
-            case .connectionAck:
-                guard
-                    let connectionAckResponse = try? decoder.decode(
-                        ConnectionAckResponse.self,
-                        from: json
-                    )
-                else {
-                    try await error(.invalidResponseFormat(messageType: .connectionAck))
-                    return
-                }
-                try await onConnectionAck(connectionAckResponse, self)
-            case .next:
-                guard let nextResponse = try? decoder.decode(NextResponse.self, from: json) else {
-                    try await error(.invalidResponseFormat(messageType: .next))
-                    return
-                }
-                try await onNext(nextResponse, self)
-            case .error:
-                guard let errorResponse = try? decoder.decode(ErrorResponse.self, from: json) else {
-                    try await error(.invalidResponseFormat(messageType: .error))
-                    return
-                }
-                try await onError(errorResponse, self)
-            case .complete:
-                guard let completeResponse = try? decoder.decode(CompleteResponse.self, from: json)
-                else {
-                    try await error(.invalidResponseFormat(messageType: .complete))
-                    return
-                }
-                try await onComplete(completeResponse, self)
-            default:
-                try await error(.invalidType())
+            try await onNext(nextResponse, self)
+        case .error:
+            guard let errorResponse = try? decoder.decode(ErrorResponse.self, from: message) else {
+                try await error(.invalidResponseFormat(messageType: .error))
+                return
+            }
+            try await onError(errorResponse, self)
+        case .complete:
+            guard let completeResponse = try? decoder.decode(CompleteResponse.self, from: message)
+            else {
+                try await error(.invalidResponseFormat(messageType: .complete))
+                return
             }
+            try await onComplete(completeResponse, self)
+        default:
+            try await error(.invalidType())
         }
     }
 
     /// Send a `connection_init` request through the messenger
     public func sendConnectionInit(payload: InitPayload) async throws {
         try await messenger.send(
-            ConnectionInitRequest(
-                payload: payload
-            ).toJSON(encoder)
+            encoder.encode(
+                ConnectionInitRequest(
+                    payload: payload
+                )
+            )
         )
     }
 
     /// Send a `subscribe` request through the messenger
     public func sendStart(payload: GraphQLRequest, id: String) async throws {
         try await messenger.send(
-            SubscribeRequest(
-                payload: payload,
-                id: id
-            ).toJSON(encoder)
+            encoder.encode(
+                SubscribeRequest(
+                    payload: payload,
+                    id: id
+                )
+            )
         )
     }
 
     /// Send a `complete` request through the messenger
     public func sendStop(id: String) async throws {
         try await messenger.send(
-            CompleteRequest(
-                id: id
-            ).toJSON(encoder)
+            encoder.encode(
+                CompleteRequest(
+                    id: id
+                )
+            )
         )
     }
 

Sources/GraphQLTransportWS/GraphqlTransportWSError.swift

@@ -9,105 +9,86 @@ struct GraphQLTransportWSError: Error {
         self.code = code
     }
 
-    static func unauthorized() -> Self {
+    static func forbidden() -> Self {
         return self.init(
-            "Unauthorized",
-            code: .unauthorized
+            "Forbidden",
+            code: .forbidden
         )
     }
 
     static func notInitialized() -> Self {
         return self.init(
             "Connection not initialized",
-            code: .notInitialized
+            code: .unauthorized
         )
     }
 
     static func tooManyInitializations() -> Self {
         return self.init(
             "Too many initialisation requests",
-            code: .tooManyInitializations
+            code: .tooManyRequests
         )
     }
 
     static func subscriberAlreadyExists(id: String) -> Self {
         return self.init(
             "Subscriber for \(id) already exists",
-            code: .subscriberAlreadyExists
+            code: .conflict
         )
     }
 
     static func invalidEncoding() -> Self {
         return self.init(
             "Message was not encoded in UTF8",
-            code: .invalidEncoding
+            code: .miscellaneous
         )
     }
 
     static func noType() -> Self {
         return self.init(
             "Message has no 'type' field",
-            code: .noType
+            code: .miscellaneous
         )
     }
 
     static func invalidType() -> Self {
         return self.init(
             "Message 'type' value does not match supported types",
-            code: .invalidType
+            code: .miscellaneous
         )
     }
 
     static func invalidRequestFormat(messageType: RequestMessageType) -> Self {
         return self.init(
             "Request message doesn't match '\(messageType.type.rawValue)' JSON format",
-            code: .invalidRequestFormat
+            code: .miscellaneous
         )
     }
 
     static func invalidResponseFormat(messageType: ResponseMessageType) -> Self {
         return self.init(
             "Response message doesn't match '\(messageType.type.rawValue)' JSON format",
-            code: .invalidResponseFormat
+            code: .miscellaneous
         )
     }
 
     static func internalAPIStreamIssue(errors: [GraphQLError]) -> Self {
         return self.init(
             "API Response did not result in a stream type, contained errors\n \(errors.map { $0.message }.joined(separator: "\n"))",
-            code: .internalAPIStreamIssue
-        )
-    }
-
-    static func graphQLError(_ error: Error) -> Self {
-        return self.init(
-            "\(error)",
-            code: .graphQLError
+            code: .internalServerError
         )
     }
 }
 
 /// Error codes for miscellaneous issues
-public enum ErrorCode: Int, CustomStringConvertible, Sendable {
+enum ErrorCode: Int, CustomStringConvertible, Sendable {
     /// Miscellaneous
     case miscellaneous = 4400
-
-    // Internal errors
-    case graphQLError = 4401
-    case internalAPIStreamIssue = 4402
-
-    // Message errors
-    case invalidEncoding = 4410
-    case noType = 4411
-    case invalidType = 4412
-    case invalidRequestFormat = 4413
-    case invalidResponseFormat = 4414
-
-    // Initialization errors
-    case unauthorized = 4430
-    case notInitialized = 4431
-    case tooManyInitializations = 4432
-    case subscriberAlreadyExists = 4433
+    case unauthorized = 4401
+    case forbidden = 4403
+    case conflict = 4409
+    case tooManyRequests = 4429
+    case internalServerError = 4500
 
     public var description: String {
         return "\(rawValue)"

Sources/GraphQLTransportWS/JsonEncodable.swift

@@ -4,7 +4,7 @@ import Foundation
 public protocol Messenger: Sendable {
     /// Send a message through this messenger
     /// - Parameter message: The message to send
-    func send<S: Sendable & Collection>(_ message: S) async throws where S.Element == Character
+    func send(_ message: Data) async throws
 
     /// Close the messenger
     func close() async throws

Sources/GraphQLTransportWS/Messenger.swift

@@ -2,12 +2,12 @@ import Foundation
 import GraphQL
 
 /// A general request. This object's type is used to triage to other, more specific request objects.
-public struct Request: Equatable, JsonEncodable {
+public struct Request: Equatable, Codable {
     public let type: RequestMessageType
 }
 
 /// A websocket `connection_init` request from the client to the server
-public struct ConnectionInitRequest<InitPayload: Codable & Equatable>: Equatable, JsonEncodable {
+public struct ConnectionInitRequest<InitPayload: Codable & Equatable>: Equatable, Codable {
     public let type: RequestMessageType = .connectionInit
     public let payload: InitPayload
 
@@ -30,7 +30,7 @@ public struct ConnectionInitRequest<InitPayload: Codable & Equatable>: Equatable
 }
 
 /// A websocket `subscribe` request from the client to the server
-public struct SubscribeRequest: Equatable, JsonEncodable {
+public struct SubscribeRequest: Equatable, Codable {
     public let type = RequestMessageType.subscribe
     public let payload: GraphQLRequest
     public let id: String
@@ -56,7 +56,7 @@ public struct SubscribeRequest: Equatable, JsonEncodable {
 }
 
 /// A websocket `complete` request from the client to the server
-public struct CompleteRequest: Equatable, JsonEncodable {
+public struct CompleteRequest: Equatable, Codable {
     public let type = RequestMessageType.complete
     public let id: String