Do not wrap exceptions twice (#1083)

### 📝 Description
Do not wrap the exceptions twice if they are already a `GraphQLError`

This now also deletes the `KotlinGraphQLError` as it was no longer wrapping anything with required logic. We can instead just map a throwable, if it is not already a `GraphQLError` to a `GraphqlErrorException`

graphql-java/graphql-java#1690

### 🔗 Related Issues
Resolves #1062

Author: smyrick

examples/server/spring-server/src/main/kotlin/com/expediagroup/graphql/examples/server/spring/exceptions/CustomDataFetcherExceptionHandler.kt

@@ -16,12 +16,12 @@
 
 package com.expediagroup.graphql.examples.server.spring.exceptions
 
-import com.expediagroup.graphql.server.exception.KotlinGraphQLError
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties
 import graphql.ErrorType
 import graphql.ErrorType.ValidationError
 import graphql.ExceptionWhileDataFetching
 import graphql.GraphQLError
+import graphql.GraphqlErrorException
 import graphql.execution.DataFetcherExceptionHandler
 import graphql.execution.DataFetcherExceptionHandlerParameters
 import graphql.execution.DataFetcherExceptionHandlerResult
@@ -39,9 +39,17 @@ class CustomDataFetcherExceptionHandler : DataFetcherExceptionHandler {
 
         val error: GraphQLError = when (exception) {
             is ValidationException -> ValidationDataFetchingGraphQLError(exception.constraintErrors, path, exception, sourceLocation)
-            else -> KotlinGraphQLError(exception = exception, locations = listOf(sourceLocation), path = path.toList())
+            else ->
+                GraphqlErrorException.newErrorException()
+                    .cause(exception)
+                    .message(exception.message)
+                    .sourceLocation(sourceLocation)
+                    .path(path.toList())
+                    .build()
         }
+
         log.warn(error.message, exception)
+
         return DataFetcherExceptionHandlerResult.newResult().error(error).build()
     }
 }

examples/server/spring-server/src/main/kotlin/com/expediagroup/graphql/examples/server/spring/query/DataAndErrorsQuery.kt

@@ -16,31 +16,33 @@
 
 package com.expediagroup.graphql.examples.server.spring.query
 
-import com.expediagroup.graphql.server.exception.KotlinGraphQLError
 import com.expediagroup.graphql.server.operations.Query
+import graphql.GraphQLError
+import graphql.GraphqlErrorException
 import graphql.execution.DataFetcherResult
-import graphql.execution.ResultPath
-import graphql.language.SourceLocation
 import org.springframework.stereotype.Component
 import java.util.concurrent.CompletableFuture
 
 @Component
 class DataAndErrorsQuery : Query {
 
     fun returnDataAndErrors(): DataFetcherResult<String?> {
-        val error = KotlinGraphQLError(RuntimeException("data and errors"), listOf(SourceLocation(1, 1)), ResultPath.rootPath().toList())
         return DataFetcherResult.newResult<String>()
             .data("Hello from data fetcher")
-            .error(error)
+            .error(getError())
             .build()
     }
 
     fun completableFutureDataAndErrors(): CompletableFuture<DataFetcherResult<String?>> {
-        val error = KotlinGraphQLError(RuntimeException("data and errors"), listOf(SourceLocation(1, 1)), ResultPath.rootPath().toList())
         val dataFetcherResult = DataFetcherResult.newResult<String>()
             .data("Hello from data fetcher")
-            .error(error)
+            .error(getError())
             .build()
         return CompletableFuture.completedFuture(dataFetcherResult)
     }
+
+    private fun getError(): GraphQLError = GraphqlErrorException.newErrorException()
+        .cause(RuntimeException("data and errors"))
+        .message("data and errors")
+        .build()
 }

examples/server/spring-server/src/main/kotlin/com/expediagroup/graphql/examples/server/spring/subscriptions/SimpleSubscription.kt

@@ -18,8 +18,8 @@ package com.expediagroup.graphql.examples.server.spring.subscriptions
 
 import com.expediagroup.graphql.examples.server.spring.context.MySubscriptionGraphQLContext
 import com.expediagroup.graphql.generator.annotations.GraphQLDescription
-import com.expediagroup.graphql.server.exception.KotlinGraphQLError
 import com.expediagroup.graphql.server.operations.Subscription
+import graphql.GraphqlErrorException
 import graphql.execution.DataFetcherResult
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.reactive.asPublisher
@@ -74,7 +74,7 @@ class SimpleSubscription : Subscription {
     fun flowOfErrors(): Publisher<DataFetcherResult<String?>> {
         val dfr: DataFetcherResult<String?> = DataFetcherResult.newResult<String?>()
             .data(null)
-            .error(KotlinGraphQLError(Exception("error thrown")))
+            .error(GraphqlErrorException.newErrorException().cause(Exception("error thrown")).build())
             .build()
 
         return flowOf(dfr, dfr).asPublisher()

examples/server/spring-server/src/test/kotlin/com/expediagroup/graphql/examples/server/spring/query/CustomDirectiveQueryIT.kt

@@ -84,8 +84,7 @@ class CustomDirectiveQueryIT(@Autowired private val testClient: WebTestClient) {
     @MethodSource("specificValueOnlyQueries")
     fun `verify specific value only queries with another value`(query: String, expectedValue: String) {
         val anotherValue = "hello"
-        val expectedError = "Exception while fetching data ($query) : " +
-            "Unsupported value, expected=$expectedValue actual=$anotherValue"
+        val expectedError = "Unsupported value, expected=$expectedValue actual=$anotherValue"
 
         testClient.post()
             .uri(GRAPHQL_ENDPOINT)

examples/server/spring-server/src/test/kotlin/com/expediagroup/graphql/examples/server/spring/query/DataAndErrorsQueryIT.kt

@@ -40,7 +40,7 @@ class DataAndErrorsQueryIT(@Autowired private val testClient: WebTestClient) {
     @ValueSource(strings = ["returnDataAndErrors", "completableFutureDataAndErrors"])
     fun `verify data and errors queries`(query: String) {
         val expectedData = "Hello from data fetcher"
-        val expectedError = "Exception while fetching data () : data and errors"
+        val expectedError = "data and errors"
 
         testClient.post()
             .uri(GRAPHQL_ENDPOINT)

examples/server/spring-server/src/test/kotlin/com/expediagroup/graphql/examples/server/spring/query/ValidatedQueryIT.kt

@@ -54,8 +54,7 @@ class ValidatedQueryIT(@Autowired private val testClient: WebTestClient) {
     @ValueSource(strings = ["", " ", "Hello", "1234", "!@#$"])
     fun `verify argumentWithValidation query when argument is not valid`(argument: String) {
         val query = "argumentWithValidation"
-        val expectedError = "Exception while fetching data (argumentWithValidation) : " +
-            "argumentWithValidation.arg.lowerCaseOnly: Argument must be lowercase"
+        val expectedError = "argumentWithValidation.arg.lowerCaseOnly: Argument must be lowercase"
 
         testClient.post()
             .uri(GRAPHQL_ENDPOINT)

servers/graphql-kotlin-server/src/main/kotlin/com/expediagroup/graphql/server/exception/KotlinGraphQLError.kt

@@ -17,8 +17,8 @@
 package com.expediagroup.graphql.server.execution
 
 import com.expediagroup.graphql.generator.execution.GraphQLContext
-import com.expediagroup.graphql.server.exception.KotlinGraphQLError
 import com.expediagroup.graphql.server.extensions.toExecutionInput
+import com.expediagroup.graphql.server.extensions.toGraphQLError
 import com.expediagroup.graphql.server.extensions.toGraphQLKotlinType
 import com.expediagroup.graphql.server.extensions.toGraphQLResponse
 import com.expediagroup.graphql.server.types.GraphQLRequest
@@ -44,8 +44,8 @@ open class GraphQLRequestHandler(
         return try {
             graphQL.executeAsync(executionInput).await().toGraphQLResponse()
         } catch (exception: Exception) {
-            val graphKotlinQLError = KotlinGraphQLError(exception)
-            GraphQLResponse<Any?>(errors = listOf(graphKotlinQLError.toGraphQLKotlinType()))
+            val error = exception.toGraphQLError()
+            GraphQLResponse<Any?>(errors = listOf(error.toGraphQLKotlinType()))
         }
     }
 }

servers/graphql-kotlin-server/src/main/kotlin/com/expediagroup/graphql/server/execution/GraphQLRequestHandler.kt

@@ -16,11 +16,12 @@
 
 package com.expediagroup.graphql.server.extensions
 
-import com.expediagroup.graphql.server.types.GraphQLServerError
 import com.expediagroup.graphql.server.types.GraphQLResponse
+import com.expediagroup.graphql.server.types.GraphQLServerError
 import com.expediagroup.graphql.server.types.GraphQLSourceLocation
 import graphql.ExecutionResult
-import graphql.GraphQLError as GraphQLJavaError
+import graphql.GraphQLError
+import graphql.GraphqlErrorException
 import graphql.language.SourceLocation
 
 /**
@@ -33,14 +34,27 @@ fun ExecutionResult.toGraphQLResponse(): GraphQLResponse<*> {
     return GraphQLResponse(data, filteredErrors, filteredExtensions)
 }
 
+/**
+ * Turn a thrown exception into a graphql-java [GraphQLError] that we can return in the response
+ */
+fun Throwable.toGraphQLError(): GraphQLError =
+    if (this is GraphQLError) {
+        this
+    } else {
+        GraphqlErrorException.newErrorException()
+            .cause(this)
+            .message(this.message)
+            .build()
+    }
+
 /**
  * Convert the graphql-java type to the common serializable type [GraphQLServerError]
  */
-fun GraphQLJavaError.toGraphQLKotlinType() = GraphQLServerError(
-    message.orEmpty(),
-    locations?.map { it.toGraphQLKotlinType() },
-    path,
-    extensions
+fun GraphQLError.toGraphQLKotlinType() = GraphQLServerError(
+    this.message.orEmpty(),
+    this.locations?.map { it.toGraphQLKotlinType() },
+    this.path,
+    this.extensions
 )
 
 /**