fix: Fix remote error extensions (#240)

Error extensions from remote execution errors are now correctly
propagated when stitching.

Author: stuebingerb

kgraphql-ktor-stitched/src/main/kotlin/com/apurebase/kgraphql/stitched/schema/execution/AbstractRemoteRequestExecutor.kt

@@ -2,6 +2,7 @@ package com.apurebase.kgraphql.stitched.schema.execution
 
 import com.apurebase.kgraphql.Context
 import com.apurebase.kgraphql.ExperimentalAPI
+import com.apurebase.kgraphql.GraphQLError
 import com.apurebase.kgraphql.GraphqlRequest
 import com.apurebase.kgraphql.request.Variables
 import com.apurebase.kgraphql.schema.execution.Execution
@@ -12,6 +13,7 @@ import com.apurebase.kgraphql.schema.structure.Field
 import com.apurebase.kgraphql.schema.structure.Type
 import com.apurebase.kgraphql.stitched.RemoteExecutionException
 import com.apurebase.kgraphql.stitched.StitchedGraphqlRequest
+import com.fasterxml.jackson.core.type.TypeReference
 import com.fasterxml.jackson.databind.JsonNode
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.databind.node.ArrayNode
@@ -40,11 +42,24 @@ abstract class AbstractRemoteRequestExecutor(private val objectMapper: ObjectMap
             """.trimIndent()
         }
         val responseJson = objectMapper.readTree(response)
+        // TODO: properly transfer errors from the remote execution
         responseJson["errors"]?.let { errors ->
-            // TODO: properly transfer errors from the remote execution
-            val messages = (errors as? ArrayNode)?.map { (it as? ObjectNode)?.get("message")?.textValue() }
-                ?: listOf("Error(s) during remote execution")
-            throw RemoteExecutionException(message = messages.joinToString(", "), node = node)
+            (errors as? ArrayNode)?.forEach { error ->
+                val objectNode = error as? ObjectNode
+                val message = objectNode?.get("message")?.textValue()?.takeIf { it.isNotBlank() }
+                    ?: "Error(s) during remote execution"
+                val extensionsNode = objectNode?.get("extensions") as? ObjectNode
+                val extensions = mapOf("remoteUrl" to node.remoteUrl, "remoteOperation" to node.remoteOperation) +
+                    extensionsNode?.let {
+                        objectMapper.convertValue(it, object : TypeReference<Map<String, Any?>>() {})
+                    }.orEmpty()
+                throw GraphQLError(
+                    message = message,
+                    nodes = listOf(node.selectionNode),
+                    extensions = extensions
+                )
+            }
+            throw RemoteExecutionException(message = "Error(s) during remote execution", node = node)
         }
         return responseJson["data"]?.get(node.remoteOperation)
     }

kgraphql-ktor-stitched/src/test/kotlin/com/apurebase/kgraphql/stitched/schema/execution/StitchedSchemaExecutionTest.kt

@@ -1,7 +1,9 @@
 package com.apurebase.kgraphql.stitched.schema.execution
 
+import com.apurebase.kgraphql.BuiltInErrorCodes
 import com.apurebase.kgraphql.ExperimentalAPI
 import com.apurebase.kgraphql.GraphQL
+import com.apurebase.kgraphql.GraphQLError
 import com.apurebase.kgraphql.GraphqlRequest
 import com.apurebase.kgraphql.schema.dsl.SchemaBuilder
 import com.apurebase.kgraphql.stitched.StitchedGraphQL
@@ -1691,7 +1693,7 @@ class StitchedSchemaExecutionTest {
             {"data":{"remote2":{"bar2":42,"stitchedEnum":"REMOTE1"}}}
         """.trimIndent()
 
-        // Call with *only* stiched fields should work (without complaining about missing selection sets)
+        // Call with *only* stitched fields should work (without complaining about missing selection sets)
         client.post("local") {
             header(HttpHeaders.ContentType, ContentType.Application.Json)
             setBody(
@@ -2721,8 +2723,26 @@ class StitchedSchemaExecutionTest {
 
     @Test
     fun `errors from remote execution should be propagated correctly`() = testApplication {
-        fun SchemaBuilder.remoteSchema() = query("fail") {
-            resolver<String> { throw IllegalArgumentException("don't call me!") }
+        fun SchemaBuilder.remoteSchema() = run {
+            query("failRemote") {
+                resolver<String> {
+                    throw GraphQLError(
+                        message = "don't call me remote!",
+                        extensions = mapOf(
+                            "type" to BuiltInErrorCodes.BAD_USER_INPUT.name,
+                            "remoteErrorKey" to listOf(
+                                "remoteErrorValue1",
+                                "remoteErrorValue2"
+                            )
+                        )
+                    )
+                }
+            }
+            query("failRemote2") {
+                resolver<String> {
+                    throw IllegalStateException()
+                }
+            }
         }
         install(GraphQL.FeatureInstance("KGraphql - Remote")) {
             endpoint = "remote"
@@ -2737,8 +2757,14 @@ class StitchedSchemaExecutionTest {
                     remoteExecutor = TestRemoteRequestExecutor(client, objectMapper)
                 }
                 localSchema {
-                    query("local") {
-                        resolver { -> "local" }
+                    query("failLocal") {
+                        resolver<String> {
+                            throw GraphQLError(
+                                message = "don't call me local!",
+                                extensionsErrorType = BuiltInErrorCodes.INTERNAL_SERVER_ERROR.name,
+                                extensionsErrorDetail = mapOf("localErrorKey" to "localErrorValue")
+                            )
+                        }
                     }
                 }
                 remoteSchema("remote") {
@@ -2761,9 +2787,23 @@ class StitchedSchemaExecutionTest {
         // TODO: should IMHO contain a data key according to https://spec.graphql.org/draft/#sec-Response-Format
         client.post("local") {
             header(HttpHeaders.ContentType, ContentType.Application.Json)
-            setBody(graphqlRequest("{ fail }"))
+            setBody(graphqlRequest("{ failLocal }"))
+        }.bodyAsText() shouldBeEqualTo """
+            {"errors":[{"message":"don't call me local!","locations":[],"path":[],"extensions":{"type":"INTERNAL_SERVER_ERROR","detail":{"localErrorKey":"localErrorValue"}}}]}
+        """.trimIndent()
+
+        client.post("local") {
+            header(HttpHeaders.ContentType, ContentType.Application.Json)
+            setBody(graphqlRequest("{ failRemote }"))
+        }.bodyAsText() shouldBeEqualTo """
+            {"errors":[{"message":"don't call me remote!","locations":[{"line":1,"column":3}],"path":[],"extensions":{"type":"BAD_USER_INPUT","remoteUrl":"remote","remoteOperation":"failRemote","remoteErrorKey":["remoteErrorValue1","remoteErrorValue2"]}}]}
+        """.trimIndent()
+
+        client.post("local") {
+            header(HttpHeaders.ContentType, ContentType.Application.Json)
+            setBody(graphqlRequest("{ failRemote2 }"))
         }.bodyAsText() shouldBeEqualTo """
-            {"errors":[{"message":"don't call me!","locations":[{"line":1,"column":3}],"path":[],"extensions":{"type":"INTERNAL_SERVER_ERROR","detail":{"remoteUrl":"remote","remoteOperation":"fail"}}}]}
+            {"errors":[{"message":"Error(s) during remote execution","locations":[{"line":1,"column":3}],"path":[],"extensions":{"type":"INTERNAL_SERVER_ERROR","remoteUrl":"remote","remoteOperation":"failRemote2"}}]}
         """.trimIndent()
     }