feat: Improve formatting error reporting

Author: NeedleInAJayStack

Sources/GraphQLTransportWS/Client.swift

@@ -56,32 +56,41 @@ public actor Client<InitPayload: Equatable & Codable> {
 
         switch response.type {
         case .connectionAck:
-            guard
-                let connectionAckResponse = try? decoder.decode(
+            let connectionAckResponse: ConnectionAckResponse
+            do {
+                connectionAckResponse = try decoder.decode(
                     ConnectionAckResponse.self,
                     from: message
                 )
-            else {
-                try await messenger.error(.invalidResponseFormat(messageType: .connectionAck))
+            } catch {
+                try await messenger.error(.invalidResponseFormat(messageType: .connectionAck, error: error))
                 return
             }
             try await onConnectionAck(connectionAckResponse, self)
         case .next:
-            guard let nextResponse = try? decoder.decode(NextResponse.self, from: message) else {
-                try await messenger.error(.invalidResponseFormat(messageType: .next))
+            let nextResponse: NextResponse
+            do {
+                nextResponse = try decoder.decode(NextResponse.self, from: message)
+            } catch {
+                try await messenger.error(.invalidResponseFormat(messageType: .next, error: error))
                 return
             }
             try await onNext(nextResponse, self)
         case .error:
-            guard let errorResponse = try? decoder.decode(ErrorResponse.self, from: message) else {
-                try await messenger.error(.invalidResponseFormat(messageType: .error))
+            let errorResponse: ErrorResponse
+            do {
+                errorResponse = try decoder.decode(ErrorResponse.self, from: message)
+            } catch {
+                try await messenger.error(.invalidResponseFormat(messageType: .error, error: error))
                 return
             }
             try await onError(errorResponse, self)
         case .complete:
-            guard let completeResponse = try? decoder.decode(CompleteResponse.self, from: message)
-            else {
-                try await messenger.error(.invalidResponseFormat(messageType: .complete))
+            let completeResponse: CompleteResponse
+            do {
+                completeResponse = try decoder.decode(CompleteResponse.self, from: message)
+            } catch {
+                try await messenger.error(.invalidResponseFormat(messageType: .complete, error: error))
                 return
             }
             try await onComplete(completeResponse, self)

Sources/GraphQLTransportWS/GraphqlTransportWSError.swift

@@ -58,16 +58,16 @@ struct GraphQLTransportWSError: Error {
         )
     }
 
-    static func invalidRequestFormat(messageType: RequestMessageType) -> Self {
+    static func invalidRequestFormat(messageType: RequestMessageType, error: Error) -> Self {
         return self.init(
-            "Request message doesn't match '\(messageType.type.rawValue)' JSON format",
+            "Request message doesn't match '\(messageType.type.rawValue)' JSON format: \(error)",
             code: .miscellaneous
         )
     }
 
-    static func invalidResponseFormat(messageType: ResponseMessageType) -> Self {
+    static func invalidResponseFormat(messageType: ResponseMessageType, error: Error) -> Self {
         return self.init(
-            "Response message doesn't match '\(messageType.type.rawValue)' JSON format",
+            "Response message doesn't match '\(messageType.type.rawValue)' JSON format: \(error)",
             code: .miscellaneous
         )
     }

Sources/GraphQLTransportWS/Server.swift

@@ -77,27 +77,32 @@ where
         // handle incoming message
         switch request.type {
         case .connectionInit:
-            guard
-                let connectionInitRequest = try? decoder.decode(
+            let connectionInitRequest: ConnectionInitRequest<InitPayload>
+            do {
+                connectionInitRequest = try decoder.decode(
                     ConnectionInitRequest<InitPayload>.self,
                     from: message
                 )
-            else {
-                try await messenger.error(.invalidRequestFormat(messageType: .connectionInit))
+            } catch {
+                try await messenger.error(.invalidRequestFormat(messageType: .connectionInit, error: error))
                 return
             }
             try await onConnectionInit(connectionInitRequest, messenger)
         case .subscribe:
-            guard let subscribeRequest = try? decoder.decode(SubscribeRequest.self, from: message)
-            else {
-                try await messenger.error(.invalidRequestFormat(messageType: .subscribe))
+            let subscribeRequest: SubscribeRequest
+            do {
+                subscribeRequest = try decoder.decode(SubscribeRequest.self, from: message)
+            } catch {
+                try await messenger.error(.invalidRequestFormat(messageType: .subscribe, error: error))
                 return
             }
             try await onSubscribe(subscribeRequest)
         case .complete:
-            guard let completeRequest = try? decoder.decode(CompleteRequest.self, from: message)
-            else {
-                try await messenger.error(.invalidRequestFormat(messageType: .complete))
+            let completeRequest: CompleteRequest
+            do {
+                completeRequest = try decoder.decode(CompleteRequest.self, from: message)
+            } catch {
+                try await messenger.error(.invalidRequestFormat(messageType: .complete, error: error))
                 return
             }
             try await onOperationComplete(completeRequest)

Tests/GraphQLTransportWSTests/GraphQLTransportWSTests.swift

@@ -268,6 +268,62 @@ struct GraphqlTransportWSTests {
         )
     }
 
+    /// Tests malformed requests include decoder details in the transport error
+    @Test func malformedRequestIncludesDecodingDetails() async throws {
+        let api = TestAPI()
+        let context = TestContext()
+        let server = Server<TokenInitPayload, Void, AsyncThrowingStream<GraphQLResult, Error>>(
+            messenger: serverMessenger,
+            onInit: { _ in },
+            onExecute: { graphQLRequest, _ in
+                try await api.execute(
+                    request: graphQLRequest.query,
+                    context: context
+                )
+            },
+            onSubscribe: { graphQLRequest, _ in
+                try await api.subscribe(
+                    request: graphQLRequest.query,
+                    context: context
+                ).get()
+            }
+        )
+        let (incoming, continuation) = AsyncThrowingStream<Data, any Error>.makeStream()
+
+        continuation.yield(Data(#"{"type":"complete"}"#.utf8))
+        continuation.finish()
+
+        try await server.listen(to: incoming)
+
+        let error = await #expect(throws: TestMessengerError.self) {
+            for try await _ in serverMessenger.stream {}
+        }
+        #expect(error?.code == 4400)
+        #expect(error?.message.contains("Request message doesn't match 'complete' JSON format") == true)
+        #expect(error?.message.contains("keyNotFound") == true)
+        #expect(error?.message.contains(#""id""#) == true)
+    }
+
+    /// Tests malformed responses include decoder details in the transport error
+    @Test func malformedResponseIncludesDecodingDetails() async throws {
+        let messenger = TestMessenger()
+        let client = Client<TokenInitPayload>(messenger: messenger)
+        let (incoming, continuation) = AsyncThrowingStream<Data, any Error>.makeStream()
+
+        continuation.yield(Data(#"{"type":"next"}"#.utf8))
+        continuation.finish()
+
+        try await client.listen(to: incoming)
+
+        let error = await #expect(throws: TestMessengerError.self) {
+            for try await _ in messenger.stream {}
+        }
+        #expect(error?.code == 4400)
+        #expect(error?.message.contains("Response message doesn't match 'next' JSON format") == true)
+        #expect(error?.message.contains("keyNotFound") == true)
+        #expect(error?.message.contains(#""id""#) == true)
+    }
+
     enum TestError: Error {
         case couldBeAnything
     }