Add URITemplate and use it to match request paths

Author: mduesterhoeft

build.gradle.kts

@@ -1,7 +1,9 @@
+
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import com.github.jengelman.gradle.plugins.shadow.transformers.Log4j2PluginsCacheFileTransformer
-import com.google.protobuf.gradle.*
+import com.google.protobuf.gradle.protobuf
+import com.google.protobuf.gradle.protoc
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 buildscript {
     repositories {
@@ -32,6 +34,7 @@ dependencies {
     compile("com.amazonaws:aws-lambda-java-core:1.2.0")
     compile("com.amazonaws:aws-lambda-java-events:2.2.5")
 
+
     compile("org.slf4j:slf4j-api:1.7.26")
     compile("com.fasterxml.jackson.core:jackson-databind:2.9.8")
     compile("com.fasterxml.jackson.module:jackson-module-kotlin:2.9.8")
@@ -41,6 +44,7 @@ dependencies {
 
     testImplementation("org.junit.jupiter:junit-jupiter-engine:5.4.0")
     testImplementation("com.willowtreeapps.assertk:assertk-jvm:0.12")
+    testImplementation("org.assertj:assertj-core:3.11.1")
     testImplementation("io.mockk:mockk:1.8.13.kotlin13")
     testImplementation("org.slf4j:slf4j-simple:1.7.26")
 }

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

@@ -22,15 +22,14 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
     override fun handleRequest(input: APIGatewayProxyRequestEvent, context: Context): APIGatewayProxyResponseEvent? {
         log.info("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<MatchResult> = routes.map { routerFunction: RouterFunction<Any, Any> ->
+        val matchResults: List<RequestMatchResult> = routes.map { routerFunction: RouterFunction<Any, Any> ->
             val matchResult = routerFunction.requestPredicate.match(input)
             log.info("match result for route '$routerFunction' is '$matchResult'")
             if (matchResult.match) {
                 val handler: HandlerFunction<Any, Any> = routerFunction.handler
                 val requestBody = deserializeRequest(handler, input)
                 val request = Request(input, requestBody)
-                router.requestPreprocessor(request)
-                val response = handler(request)
+                val response = router.filter.then(handler as HandlerFunction<*, *>).invoke(request)
                 return createResponse(input, response)
             }
 
@@ -51,7 +50,7 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
         }
     }
 
-    private fun handleNonDirectMatch(matchResults: List<MatchResult>, input: APIGatewayProxyRequestEvent): APIGatewayProxyResponseEvent {
+    private fun handleNonDirectMatch(matchResults: List<RequestMatchResult>, input: APIGatewayProxyRequestEvent): APIGatewayProxyResponseEvent {
         // no direct match
         if (matchResults.any { it.matchPath && it.matchMethod && !it.matchContentType }) {
             return createErrorResponse(

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

@@ -20,14 +20,14 @@ data class RequestPredicate(
     }
 
     internal fun match(request: APIGatewayProxyRequestEvent) =
-        MatchResult(
+        RequestMatchResult(
             matchPath = pathMatches(request),
             matchMethod = methodMatches(request),
             matchAcceptType = contentTypeMatches(request.acceptHeader(), produces),
             matchContentType = contentTypeMatches(request.contentType(), consumes)
         )
 
-    private fun pathMatches(request: APIGatewayProxyRequestEvent) = request.path == pathPattern
+    private fun pathMatches(request: APIGatewayProxyRequestEvent) = UriTemplate.from(pathPattern).matches(request.path)
     private fun methodMatches(request: APIGatewayProxyRequestEvent) = method.equals(request.httpMethod, true)
     private fun contentTypeMatches(contentType: String?, accepted: Set<String>) =
         if (accepted.isEmpty() && contentType == null) true
@@ -37,7 +37,7 @@ data class RequestPredicate(
     companion object
 }
 
-internal data class MatchResult(
+internal data class RequestMatchResult(
     val matchPath: Boolean = false,
     val matchMethod: Boolean = false,
     val matchAcceptType: Boolean = false,

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

@@ -9,7 +9,7 @@ class Router {
     var defaultConsuming = setOf("application/json", "application/x-protobuf")
     var defaultProducing = setOf("application/json", "application/x-protobuf")
 
-    var requestPreprocessor: (Request<*>) -> Unit = { _ -> Unit }
+    var filter: Filter = Filter.NoOp
 
     fun <I, T> GET(pattern: String, handlerFunction: HandlerFunction<I, T>) =
         RequestPredicate(
@@ -59,19 +59,25 @@ class Router {
             routes += RouterFunction(it, handlerFunction)
         }
 
-    // the default content types the HandlerFunctions of this router can produce
-    fun defaultProducing(contentTypes: Set<String>): Router = this.also { defaultProducing = contentTypes }
-
-    // the default content types the HandlerFunctions of this router can handle
-    fun defaultConsuming(contentTypes: Set<String>): Router = this.also { defaultConsuming = contentTypes }
-
-    fun withPreprocessor(preprocessorFunction: (Request<*>) -> Unit): Router = this.also { requestPreprocessor = preprocessorFunction }
-
     companion object {
         fun router(routes: Router.() -> Unit) = Router().apply(routes)
     }
 }
 
+interface Filter : (HandlerFunction<*, *>) -> HandlerFunction<*,*> {
+    companion object {
+        operator fun invoke(fn: (HandlerFunction<*, *>) -> HandlerFunction<*, *>): Filter = object : Filter {
+            override operator fun invoke(next: HandlerFunction<*, *>): HandlerFunction<*, *> = 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) }
+
 typealias HandlerFunction<I, T> = (request: Request<I>) -> ResponseEntity<T>
 
 data class RouterFunction<I, T>(

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

@@ -0,0 +1,49 @@
+package com.github.mduesterhoeft.router
+
+import java.net.URLDecoder
+import java.util.regex.Pattern
+
+class UriTemplate private constructor(private val template: String) {
+    private val templateRegex: Regex
+    private val matches: Sequence<MatchResult>
+    private val parameterNames: List<String>
+
+    init {
+        matches = URI_TEMPLATE_FORMAT.findAll(template)
+        parameterNames = matches.map { it.groupValues[1] }.toList()
+        templateRegex = template.replace(URI_TEMPLATE_FORMAT,
+            { notMatched -> Pattern.quote(notMatched) },
+            { matched -> if (matched.groupValues[2].isBlank()) "([^/]+)" else "(${matched.groupValues[2]})" }).toRegex()
+    }
+
+    companion object {
+        private val URI_TEMPLATE_FORMAT = "\\{([^}]+?)(?::([^}]+))?\\}".toRegex()
+        fun from(template: String) = UriTemplate(template.trimSlashes())
+
+        fun String.trimSlashes() = "^(/)?(.*?)(/)?$".toRegex().replace(this) { result -> result.groupValues[2] }
+    }
+
+    fun matches(uri: String): Boolean = templateRegex.matches(uri.trimSlashes())
+
+    fun extract(uri: String): Map<String, String> = parameterNames.zip(templateRegex.findParameterValues(uri.trimSlashes())).toMap()
+
+    private fun Regex.findParameterValues(uri: String): List<String> =
+        findAll(uri).first().groupValues.drop(1).map { URLDecoder.decode(it, "UTF-8") }
+
+    private fun String.replace(regex: Regex, notMatched: (String) -> String, matched: (MatchResult) -> String): String {
+        val matches = regex.findAll(this)
+        val builder = StringBuilder()
+        var position = 0
+        for (matchResult in matches) {
+            val before = substring(position, matchResult.range.start)
+            if (before.isNotEmpty()) builder.append(notMatched(before))
+            builder.append(matched(matchResult))
+            position = matchResult.range.endInclusive + 1
+        }
+        val after = substring(position, length)
+        if (after.isNotEmpty()) builder.append(notMatched(after))
+        return builder.toString()
+    }
+
+    override fun toString(): String = template
+}

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

@@ -26,6 +26,20 @@ class RequestHandlerTest {
         assert(response.body).isEqualTo("""{"greeting":"Hello"}""")
     }
 
+    @Test
+    fun `should match request with path parameter`() {
+
+        val response = testRequestHandler.handleRequest(
+            APIGatewayProxyRequestEvent()
+                .withPath("/some/me")
+                .withHttpMethod("GET")
+                .withHeaders(mapOf("Accept" to "application/json")), mockk()
+        )!!
+
+        assert(response.statusCode).isEqualTo(200)
+        assert(response.body).isEqualTo("""{"greeting":"Hello me"}""")
+    }
+
     @Test
     fun `should match request to proto handler and return json`() {
 
@@ -130,6 +144,40 @@ class RequestHandlerTest {
         assert(response.statusCode).isEqualTo(404)
     }
 
+    @Test
+    fun `should invoke filter chain`() {
+
+        val handler = TestRequestHandlerWithFilter()
+        val response = handler.handleRequest(
+            APIGatewayProxyRequestEvent()
+                .withPath("/some")
+                .withHttpMethod("GET")
+                .withHeaders(mapOf("Accept" to "application/json")), mockk()
+        )!!
+
+        assert(response.statusCode).isEqualTo(200)
+        assert(handler.filterInvocations).isEqualTo(2)
+    }
+
+    class TestRequestHandlerWithFilter : RequestHandler() {
+
+        var filterInvocations = 0
+
+        private val incrementingFilter = Filter {
+            next -> {
+                request ->
+                    filterInvocations += 1
+                    next(request)
+            }
+        }
+        override val router = router {
+            filter = incrementingFilter.then(incrementingFilter)
+
+            GET("/some") { _: Request<Unit> ->
+                ResponseEntity.ok("hello")
+            }
+        }
+    }
     class TestRequestHandler : RequestHandler() {
 
         data class TestResponse(val greeting: String)
@@ -139,6 +187,9 @@ class RequestHandlerTest {
             GET("/some") { _: Request<Unit> ->
                 ResponseEntity.ok(TestResponse("Hello"))
             }
+            GET("/some/{id}") { r: Request<Unit> ->
+                ResponseEntity.ok(TestResponse("Hello ${UriTemplate.from("/some/{id}").extract(r.apiRequest.path)["id"]}"))
+            }
             GET("/some-proto") { _: Request<Unit> ->
                 ResponseEntity.ok(Sample.newBuilder().setHello("Hello").build())
             }

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

@@ -0,0 +1,38 @@
+package com.github.mduesterhoeft.router
+
+import org.assertj.core.api.BDDAssertions.then
+import org.junit.jupiter.api.Test
+import java.util.UUID
+
+class UriTemplateTest {
+
+    @Test
+    fun `should match without parameter`() {
+        then(UriTemplate.from("/some").matches("/some")).isTrue()
+    }
+
+    @Test
+    fun `should not match simple`() {
+        then(UriTemplate.from("/some").matches("/some-other")).isFalse()
+    }
+
+    @Test
+    fun `should match with parameter`() {
+        then(UriTemplate.from("/some/{id}").matches("/some/${UUID.randomUUID()}")).isTrue()
+        then(UriTemplate.from("/some/{id}/other").matches("/some/${UUID.randomUUID()}/other")).isTrue()
+    }
+
+    @Test
+    fun `should not match with parameter`() {
+        then(UriTemplate.from("/some/{id}").matches("/some-other/${UUID.randomUUID()}")).isFalse()
+        then(UriTemplate.from("/some/{id}/other").matches("/some/${UUID.randomUUID()}/other-test")).isFalse()
+    }
+
+    @Test
+    fun `should extract parameters`() {
+        then(UriTemplate.from("/some/{first}/other/{second}").extract("/some/first-value/other/second-value"))
+            .isEqualTo(mapOf("first" to "first-value", "second" to "second-value"))
+        then(UriTemplate.from("/some").extract("/some")).isEmpty()
+    }
+
+}