feat(client): added structured fields to errors (#304)

Author: stainless-app[bot]

lithic-java-core/src/main/kotlin/com/lithic/api/errors/BadRequestException.kt

@@ -2,12 +2,8 @@ package com.lithic.api.errors
 
 import com.google.common.collect.ListMultimap
 
-class BadRequestException
-constructor(
+class BadRequestException(
     headers: ListMultimap<String, String>,
-    private val error: LithicError,
-) : LithicServiceException(headers, "${error}") {
-    override fun statusCode(): Int = 400
-
-    fun error(): LithicError = error
-}
+    body: String,
+    error: LithicError,
+) : LithicServiceException(400, headers, body, error)

lithic-java-core/src/main/kotlin/com/lithic/api/errors/InternalServerException.kt

@@ -2,13 +2,9 @@ package com.lithic.api.errors
 
 import com.google.common.collect.ListMultimap
 
-class InternalServerException
-constructor(
-    private val statusCode: Int,
+class InternalServerException(
+    statusCode: Int,
     headers: ListMultimap<String, String>,
-    private val error: LithicError,
-) : LithicServiceException(headers, "${error}") {
-    override fun statusCode(): Int = statusCode
-
-    fun error(): LithicError = error
-}
+    body: String,
+    error: LithicError,
+) : LithicServiceException(statusCode, headers, body, error)

lithic-java-core/src/main/kotlin/com/lithic/api/errors/LithicServiceException.kt

@@ -5,11 +5,19 @@ import com.google.common.collect.ListMultimap
 abstract class LithicServiceException
 @JvmOverloads
 constructor(
+    private val statusCode: Int,
     private val headers: ListMultimap<String, String>,
-    message: String? = null,
+    private val body: String,
+    private val error: LithicError,
+    message: String = "$statusCode: $error",
     cause: Throwable? = null
 ) : LithicException(message, cause) {
-    abstract fun statusCode(): Int
+
+    fun statusCode(): Int = statusCode
 
     fun headers(): ListMultimap<String, String> = headers
+
+    fun body(): String = body
+
+    fun error(): LithicError = error
 }

lithic-java-core/src/main/kotlin/com/lithic/api/errors/NotFoundException.kt

@@ -2,12 +2,8 @@ package com.lithic.api.errors
 
 import com.google.common.collect.ListMultimap
 
-class NotFoundException
-constructor(
+class NotFoundException(
     headers: ListMultimap<String, String>,
-    private val error: LithicError,
-) : LithicServiceException(headers, "${error}") {
-    override fun statusCode(): Int = 404
-
-    fun error(): LithicError = error
-}
+    body: String,
+    error: LithicError,
+) : LithicServiceException(404, headers, body, error)

lithic-java-core/src/main/kotlin/com/lithic/api/errors/PermissionDeniedException.kt

@@ -2,12 +2,8 @@ package com.lithic.api.errors
 
 import com.google.common.collect.ListMultimap
 
-class PermissionDeniedException
-constructor(
+class PermissionDeniedException(
     headers: ListMultimap<String, String>,
-    private val error: LithicError,
-) : LithicServiceException(headers, "${error}") {
-    override fun statusCode(): Int = 403
-
-    fun error(): LithicError = error
-}
+    body: String,
+    error: LithicError,
+) : LithicServiceException(403, headers, body, error)

lithic-java-core/src/main/kotlin/com/lithic/api/errors/RateLimitException.kt

@@ -2,12 +2,8 @@ package com.lithic.api.errors
 
 import com.google.common.collect.ListMultimap
 
-class RateLimitException
-constructor(
+class RateLimitException(
     headers: ListMultimap<String, String>,
-    private val error: LithicError,
-) : LithicServiceException(headers, "${error}") {
-    override fun statusCode(): Int = 429
-
-    fun error(): LithicError = error
-}
+    body: String,
+    error: LithicError,
+) : LithicServiceException(429, headers, body, error)

lithic-java-core/src/main/kotlin/com/lithic/api/errors/UnauthorizedException.kt

@@ -2,12 +2,8 @@ package com.lithic.api.errors
 
 import com.google.common.collect.ListMultimap
 
-class UnauthorizedException
-constructor(
+class UnauthorizedException(
     headers: ListMultimap<String, String>,
-    private val error: LithicError,
-) : LithicServiceException(headers, "${error}") {
-    override fun statusCode(): Int = 401
-
-    fun error(): LithicError = error
-}
+    body: String,
+    error: LithicError,
+) : LithicServiceException(401, headers, body, error)

lithic-java-core/src/main/kotlin/com/lithic/api/errors/UnexpectedStatusCodeException.kt

@@ -2,13 +2,9 @@ package com.lithic.api.errors
 
 import com.google.common.collect.ListMultimap
 
-class UnexpectedStatusCodeException
-constructor(
-    private val statusCode: Int,
+class UnexpectedStatusCodeException(
+    statusCode: Int,
     headers: ListMultimap<String, String>,
-    private val body: String
-) : LithicServiceException(headers, "Unexpected status code: ${statusCode}") {
-    override fun statusCode(): Int = statusCode
-
-    fun body() = body
-}
+    body: String,
+    error: LithicError,
+) : LithicServiceException(statusCode, headers, body, error)

lithic-java-core/src/main/kotlin/com/lithic/api/errors/UnprocessableEntityException.kt

@@ -2,12 +2,8 @@ package com.lithic.api.errors
 
 import com.google.common.collect.ListMultimap
 
-class UnprocessableEntityException
-constructor(
+class UnprocessableEntityException(
     headers: ListMultimap<String, String>,
-    private val error: LithicError,
-) : LithicServiceException(headers, "${error}") {
-    override fun statusCode(): Int = 422
-
-    fun error(): LithicError = error
-}
+    body: String,
+    error: LithicError,
+) : LithicServiceException(422, headers, body, error)

lithic-java-core/src/main/kotlin/com/lithic/api/services/Handlers.kt

@@ -4,6 +4,7 @@ package com.lithic.api.services
 
 import com.fasterxml.jackson.databind.json.JsonMapper
 import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.google.common.collect.ListMultimap
 import com.lithic.api.core.http.BinaryResponseContent
 import com.lithic.api.core.http.HttpResponse
 import com.lithic.api.core.http.HttpResponse.Handler
@@ -17,6 +18,7 @@ import com.lithic.api.errors.RateLimitException
 import com.lithic.api.errors.UnauthorizedException
 import com.lithic.api.errors.UnexpectedStatusCodeException
 import com.lithic.api.errors.UnprocessableEntityException
+import java.io.ByteArrayInputStream
 import java.io.InputStream
 import java.io.OutputStream
 import java.util.Optional
@@ -87,35 +89,98 @@ internal fun <T> Handler<T>.withErrorHandler(errorHandler: Handler<LithicError>)
     return object : Handler<T> {
         override fun handle(response: HttpResponse): T {
             when (val statusCode = response.statusCode()) {
-                in 200..299 -> return this@withErrorHandler.handle(response)
-                400 -> throw BadRequestException(response.headers(), errorHandler.handle(response))
-                401 ->
-                    throw UnauthorizedException(response.headers(), errorHandler.handle(response))
-                403 ->
+                in 200..299 -> {
+                    return this@withErrorHandler.handle(response)
+                }
+                400 -> {
+                    val buffered = response.buffered()
+                    throw BadRequestException(
+                        buffered.headers(),
+                        StringHandler.handle(buffered),
+                        errorHandler.handle(buffered),
+                    )
+                }
+                401 -> {
+                    val buffered = response.buffered()
+                    throw UnauthorizedException(
+                        buffered.headers(),
+                        StringHandler.handle(buffered),
+                        errorHandler.handle(buffered),
+                    )
+                }
+                403 -> {
+                    val buffered = response.buffered()
                     throw PermissionDeniedException(
-                        response.headers(),
-                        errorHandler.handle(response)
+                        buffered.headers(),
+                        StringHandler.handle(buffered),
+                        errorHandler.handle(buffered),
                     )
-                404 -> throw NotFoundException(response.headers(), errorHandler.handle(response))
-                422 ->
+                }
+                404 -> {
+                    val buffered = response.buffered()
+                    throw NotFoundException(
+                        buffered.headers(),
+                        StringHandler.handle(buffered),
+                        errorHandler.handle(buffered),
+                    )
+                }
+                422 -> {
+                    val buffered = response.buffered()
                     throw UnprocessableEntityException(
-                        response.headers(),
-                        errorHandler.handle(response)
+                        buffered.headers(),
+                        StringHandler.handle(buffered),
+                        errorHandler.handle(buffered),
+                    )
+                }
+                429 -> {
+                    val buffered = response.buffered()
+                    throw RateLimitException(
+                        buffered.headers(),
+                        StringHandler.handle(buffered),
+                        errorHandler.handle(buffered),
                     )
-                429 -> throw RateLimitException(response.headers(), errorHandler.handle(response))
-                in 500..599 ->
+                }
+                in 500..599 -> {
+                    val buffered = response.buffered()
                     throw InternalServerException(
                         statusCode,
-                        response.headers(),
-                        errorHandler.handle(response)
+                        buffered.headers(),
+                        StringHandler.handle(buffered),
+                        errorHandler.handle(buffered),
                     )
-                else ->
+                }
+                else -> {
+                    val buffered = response.buffered()
                     throw UnexpectedStatusCodeException(
                         statusCode,
-                        response.headers(),
-                        StringHandler.handle(response)
+                        buffered.headers(),
+                        StringHandler.handle(buffered),
+                        errorHandler.handle(buffered),
                     )
+                }
             }
         }
     }
 }
+
+private fun HttpResponse.buffered(): HttpResponse {
+    val body = body().readBytes()
+
+    return object : HttpResponse {
+        override fun statusCode(): Int {
+            return this@buffered.statusCode()
+        }
+
+        override fun headers(): ListMultimap<String, String> {
+            return this@buffered.headers()
+        }
+
+        override fun body(): InputStream {
+            return ByteArrayInputStream(body)
+        }
+
+        override fun close() {
+            this@buffered.close()
+        }
+    }
+}