deserialize request body to type class when body is an array/list (#6)

* deserialize request body to type class when body is an array/list

* more generic

Author: ruibritopt

src/main/kotlin/com/github/mduesterhoeft/router/APIGatewayProxyEventExtensions.kt

@@ -32,16 +32,16 @@ fun DELETE(path: String) = DELETE().withPath(path)
  * The port is taken from the x-forwarded-port header. Standard ports are omitted.
  */
 fun APIGatewayProxyRequestEvent.location(path: String): URI {
-    val host = getHeaderCaseInsensitive("host")?:"localhost"
-    val proto = getHeaderCaseInsensitive("x-forwarded-proto")?:"http"
+    val host = getHeaderCaseInsensitive("host") ?: "localhost"
+    val proto = getHeaderCaseInsensitive("x-forwarded-proto") ?: "http"
     val portPart = getHeaderCaseInsensitive("x-forwarded-port")
         ?.let {
             when {
                 proto == "https" && it == "443" -> null
                 proto == "http" && it == "80" -> null
                 else -> ":$it"
             }
-        }?: ""
+        } ?: ""
     return URI("$proto://$host$portPart/${path.removePrefix("/")}")
 }
 

src/main/kotlin/com/github/mduesterhoeft/router/RequestHandler.kt

@@ -4,6 +4,7 @@ import com.amazonaws.services.lambda.runtime.Context
 import com.amazonaws.services.lambda.runtime.RequestHandler
 import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent
 import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent
+import com.fasterxml.jackson.databind.type.TypeFactory
 import com.fasterxml.jackson.module.kotlin.MissingKotlinParameterException
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import com.github.mduesterhoeft.router.ProtoBufUtils.toJsonWithoutWrappers
@@ -13,6 +14,7 @@ import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import java.util.Base64
 import kotlin.reflect.KClass
+import kotlin.reflect.full.isSubclassOf
 import kotlin.reflect.jvm.reflect
 
 abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
@@ -55,9 +57,14 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
         input: APIGatewayProxyRequestEvent
     ): Any {
         val requestType = handler.reflect()!!.parameters.first().type.arguments.first().type?.classifier as KClass<*>
-        return when (requestType) {
-            Unit::class -> Unit
-            String::class -> input.body!!
+        return when {
+            requestType == Unit::class -> Unit
+            requestType == String::class -> input.body!!
+            requestType.isSubclassOf(Collection::class) -> {
+                val kClass = handler.reflect()!!.parameters.first().type.arguments.first().type!!.arguments.first().type!!.classifier as KClass<*>
+                val type = TypeFactory.defaultInstance().constructParametricType(requestType.javaObjectType, kClass.javaObjectType)
+                objectMapper.readValue(input.body, type)
+            }
             else -> objectMapper.readValue(input.body, requestType.java)
         }
     }
@@ -132,7 +139,6 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
                     .withHeaders(mapOf("Content-Type" to "application/json"))
         }
 
-
     open fun <T> createResponse(input: APIGatewayProxyRequestEvent, response: ResponseEntity<T>): APIGatewayProxyResponseEvent {
         val accept = MediaType.parse(input.acceptHeader())
         return when {

src/test/kotlin/com/github/mduesterhoeft/router/RequestHandlerTest.kt

@@ -113,6 +113,22 @@ class RequestHandlerTest {
         assert(response.body).isEqualTo("""{"greeting":"some"}""")
     }
 
+    @Test
+    fun `should handle request with body as a List`() {
+
+        val response = testRequestHandler.handleRequest(
+                POST("/somes")
+                        .withHeaders(mapOf(
+                                "Accept" to "application/json",
+                                "Content-Type" to "application/json"
+                        ))
+                        .withBody("""[{ "greeting": "some" },{ "greeting": "some1" }]""".trimMargin()), mockk()
+        )!!
+
+        assert(response.statusCode).isEqualTo(200)
+        assert(response.body).isEqualTo("""[{"greeting":"some"},{"greeting":"some1"}]""")
+    }
+
     @Test
     fun `should return method not allowed`() {
 
@@ -242,6 +258,8 @@ class RequestHandlerTest {
             POST("/some") { r: Request<TestRequest> ->
                 ResponseEntity.ok(TestResponse(r.body.greeting))
             }
+            POST("/somes") { r: Request<List<TestRequest>> -> ResponseEntity.ok(r.body.map { TestResponse(it.greeting) }.toList())
+            }
         }
     }
 }