Filters work on APIGatewayProxyRequestEvent and APIGatewayProxyRespon… (#22)

* Filters work on APIGatewayProxyRequestEvent and APIGatewayProxyResponseEvent

This makes it easier to run the filters also in error scenarios.

* Update router/src/main/kotlin/io/moia/router/RequestHandler.kt

Co-Authored-By: moia-sven-ole <[email protected]>

* Fix lint error

Author: mduesterhoeft

router/src/main/kotlin/io/moia/router/RequestHandler.kt

@@ -25,8 +25,13 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
     private val serializationHandlerChain by lazy { SerializationHandlerChain(serializationHandlers()) }
     private val deserializationHandlerChain by lazy { DeserializationHandlerChain(deserializationHandlers()) }
 
+    override fun handleRequest(input: APIGatewayProxyRequestEvent, context: Context): APIGatewayProxyResponseEvent =
+        input
+            .apply { headers = headers.mapKeys { it.key.toLowerCase() } }
+            .let { router.filter.then(this::handleRequest)(it) }
+
     @Suppress("UNCHECKED_CAST")
-    override fun handleRequest(input: APIGatewayProxyRequestEvent, context: Context): APIGatewayProxyResponseEvent {
+    private fun handleRequest(input: APIGatewayProxyRequestEvent): APIGatewayProxyResponseEvent {
         log.debug("handling request with method '${input.httpMethod}' and path '${input.path}' - Accept:${input.acceptHeader()} Content-Type:${input.contentType()} $input")
         val routes = router.routes as List<RouterFunction<Any, Any>>
         val matchResults: List<RequestMatchResult> = routes.map { routerFunction: RouterFunction<Any, Any> ->
@@ -37,19 +42,12 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
                 val matchedAcceptType = routerFunction.requestPredicate.matchedAcceptType(input.acceptedMediaTypes())
                     ?: MediaType.parse(router.defaultContentType)
 
-                // Phase 1: Deserialization
-                // TODO: find a way to also invoke the filter chain on failed deserialization
                 val handler: HandlerFunction<Any, Any> = routerFunction.handler
-                val requestBody = try {
-                    deserializeRequest(handler, input)
-                } catch (e: Exception) {
-                    return createResponse(matchedAcceptType, exceptionToResponseEntity(e))
-                }
 
-                // Phase 2: Content Handling
-                val request = Request(input, requestBody, routerFunction.requestPredicate.pathPattern)
-                return createResponse(matchedAcceptType, router.filter.then {
+                val response =
                     try {
+                        val requestBody = deserializeRequest(handler, input)
+                        val request = Request(input, requestBody, routerFunction.requestPredicate.pathPattern)
                         when {
                             missingPermissions(input, routerFunction) ->
                                 ResponseEntity(403, ApiError("missing permissions", "MISSING_PERMISSIONS"))
@@ -58,7 +56,7 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
                     } catch (e: Exception) {
                         exceptionToResponseEntity(e, input)
                     }
-                }(request))
+                return createResponse(matchedAcceptType, response)
             }
             matchResult
         }
@@ -106,22 +104,22 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
             when {
                 matchResults.any { it.matchPath && it.matchMethod && !it.matchContentType } ->
                     ApiException(
-                            httpResponseStatus = 415,
-                            message = "Unsupported Media Type",
-                            code = "UNSUPPORTED_MEDIA_TYPE"
-                        )
+                        httpResponseStatus = 415,
+                        message = "Unsupported Media Type",
+                        code = "UNSUPPORTED_MEDIA_TYPE"
+                    )
                 matchResults.any { it.matchPath && it.matchMethod && !it.matchAcceptType } ->
                     ApiException(
-                            httpResponseStatus = 406,
-                            message = "Not Acceptable",
-                            code = "NOT_ACCEPTABLE"
-                        )
+                        httpResponseStatus = 406,
+                        message = "Not Acceptable",
+                        code = "NOT_ACCEPTABLE"
+                    )
                 matchResults.any { it.matchPath && !it.matchMethod } ->
                     ApiException(
                         httpResponseStatus = 405,
                         message = "Method Not Allowed",
                         code = "METHOD_NOT_ALLOWED"
-                )
+                    )
                 else -> ApiException(
                     httpResponseStatus = 404,
                     message = "Not found",
@@ -215,4 +213,4 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
     companion object {
         val log: Logger = LoggerFactory.getLogger(RequestHandler::class.java)
     }
-}
+}

router/src/main/kotlin/io/moia/router/Router.kt

@@ -1,6 +1,7 @@
 package io.moia.router
 
 import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent
+import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent
 
 class Router {
 
@@ -46,22 +47,21 @@ class Router {
     }
 }
 
-interface Filter : (HandlerFunction<*, *>) -> HandlerFunction<*, *> {
+interface Filter : (APIGatewayRequestHandlerFunction) -> APIGatewayRequestHandlerFunction {
     companion object {
-        operator fun invoke(fn: (HandlerFunction<*, *>) -> HandlerFunction<*, *>): Filter = object :
+        operator fun invoke(fn: (APIGatewayRequestHandlerFunction) -> APIGatewayRequestHandlerFunction): Filter = object :
             Filter {
-            override operator fun invoke(next: HandlerFunction<*, *>): HandlerFunction<*, *> = fn(next)
+            override operator fun invoke(next: APIGatewayRequestHandlerFunction): APIGatewayRequestHandlerFunction = fn(next)
         }
     }
 }
 
 val Filter.Companion.NoOp: Filter get() = Filter { next -> { next(it) } }
 
-fun Filter.then(next: Filter): Filter =
-    Filter { this(next(it)) }
-
-fun Filter.then(next: HandlerFunction<*, *>): HandlerFunction<*, *> = { this(next)(it) }
+fun Filter.then(next: Filter): Filter = Filter { this(next(it)) }
+fun Filter.then(next: APIGatewayRequestHandlerFunction): APIGatewayRequestHandlerFunction = { this(next)(it) }
 
+typealias APIGatewayRequestHandlerFunction = (APIGatewayProxyRequestEvent) -> APIGatewayProxyResponseEvent
 typealias HandlerFunction<I, T> = (request: Request<I>) -> ResponseEntity<T>
 
 class RouterFunction<I, T>(

router/src/test/kotlin/io/moia/router/RequestHandlerTest.kt

@@ -479,6 +479,27 @@ class RequestHandlerTest {
         assertEquals("[CustomObject(text=foo, number=1), CustomObject(text=bar, number=2)]", plainTextResponse.body)
     }
 
+    @Test
+    fun `headers should be case insensitive`() {
+        val request = APIGatewayProxyRequestEvent()
+            .withPath("/some")
+            .withHttpMethod("GET")
+            .withHeaders(
+                mapOf(
+                    "Accept" to "Application/Json",
+                    "User-Agent" to "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0"
+                )
+            )
+        val response = testRequestHandler.handleRequest(request, mockk())
+
+        assert(request.headers["accept"].toString()).isEqualTo("Application/Json")
+        assert(request.headers["user-agent"].toString())
+            .isEqualTo(
+                "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0"
+            )
+        assert(response.statusCode).isEqualTo(200)
+    }
+
     class TestRequestHandlerAuthorization : RequestHandler() {
         override val router = router {
             GET("/some") { _: Request<Unit> ->
@@ -518,7 +539,7 @@ class RequestHandlerTest {
         private val incrementingFilter = Filter { next ->
             { request ->
                 filterInvocations += 1
-                next(request).copy(headers = mapOf("header" to "value"))
+                next(request).apply { headers = headers + ("header" to "value") }
             }
         }
         override val router = router {