GH-33 Replace hard-coded void handlers with preconfigured HandlerResultConsumers

Author: dzikoysk

routing-annotations/routing-annotated/src/main/kotlin/io/javalin/community/routing/annotations/AnnotatedRoutingPlugin.kt

@@ -18,7 +18,12 @@ fun interface HandlerResultConsumer<T> {
 
 class AnnotatedRoutingPluginConfiguration {
     var apiVersionHeader: String = "X-API-Version"
-    var resultHandlers: MutableMap<Class<*>, HandlerResultConsumer<*>> = mutableMapOf()
+    var resultHandlers: MutableMap<Class<*>, HandlerResultConsumer<*>> = mutableMapOf(
+        String::class.java to HandlerResultConsumer<String?> { ctx, value -> value?.also { ctx.result(it) } },
+        Unit::class.java to HandlerResultConsumer<Unit?> { _, _ -> },
+        Void::class.java to HandlerResultConsumer<Void?> { _, _ -> },
+        Void.TYPE to HandlerResultConsumer<Void?> { _, _ -> },
+    )
 
     fun <T> registerResultHandler(type: Class<T>, handler: HandlerResultConsumer<T>): AnnotatedRoutingPluginConfiguration = also {
         this.resultHandlers[type] = handler

routing-annotations/routing-annotated/src/main/kotlin/io/javalin/community/routing/annotations/ReflectiveEndpointLoader.kt

@@ -4,6 +4,7 @@ import io.javalin.community.routing.Route
 import io.javalin.community.routing.dsl.DefaultDslException
 import io.javalin.community.routing.dsl.DefaultDslRoute
 import io.javalin.http.Context
+import io.javalin.http.HttpStatus
 import io.javalin.validation.Validator
 import java.lang.reflect.Method
 import java.lang.reflect.Parameter
@@ -49,6 +50,7 @@ internal class ReflectiveEndpointLoader(
                 createArgumentSupplier<Unit>(it) ?: throw IllegalArgumentException("Unsupported parameter type: $it")
             }
 
+            val status = method.getAnnotation(Status::class.java)
             val resultHandler = findResultHandler(method)
 
             val route = AnnotatedRoute(
@@ -61,8 +63,8 @@ internal class ReflectiveEndpointLoader(
                         .toTypedArray()
 
                     when (async) {
-                        true -> async { invokeAndUnwrapIfErrored(method, endpoint, *arguments, ctx = this, resultHandler = resultHandler) }
-                        else -> invokeAndUnwrapIfErrored(method, endpoint, *arguments, ctx = this, resultHandler = resultHandler)
+                        true -> async { invokeAndUnwrapIfErrored(method, endpoint, arguments, ctx = this, status = status, resultHandler = resultHandler) }
+                        else -> invokeAndUnwrapIfErrored(method, endpoint, arguments, ctx = this, status = status, resultHandler = resultHandler)
                     }
                 }
             )
@@ -89,6 +91,7 @@ internal class ReflectiveEndpointLoader(
                 createArgumentSupplier<Exception>(it) ?: throw IllegalArgumentException("Unsupported parameter type: $it")
             }
 
+            val status = method.getAnnotation(Status::class.java)
             val resultHandler = findResultHandler(method)
 
             val dslException = AnnotatedException(
@@ -102,6 +105,7 @@ internal class ReflectiveEndpointLoader(
                         method = method,
                         instance = endpoint,
                         arguments = arguments,
+                        status = status,
                         ctx = this,
                         resultHandler = resultHandler
                     )
@@ -115,39 +119,39 @@ internal class ReflectiveEndpointLoader(
     }
 
     @Suppress("UNCHECKED_CAST")
-    private fun findResultHandler(method: Method): HandlerResultConsumer<Any?>? =
-        when {
-            method.returnType !in arrayOf(Void.TYPE, Void::class.java, Unit::class.java) -> {
-                resultHandlers.asSequence()
-                    .filter { it.key.isAssignableFrom(method.returnType) }
-                    .sortedWith { a, b ->
-                        when {
-                            a.key.isAssignableFrom(b.key) -> -1
-                            b.key.isAssignableFrom(a.key) -> 1
-                            else -> throw IllegalStateException("Unable to determine handler for type ${method.returnType}. Found two matching handlers: ${a.key} and ${b.key}")
-                        }
-                    }
-                    .toList()
-                    .takeIf { it.isNotEmpty() }
-                    ?.last()
-                    ?.value as HandlerResultConsumer<Any?>?
-                    ?: throw IllegalStateException("Unsupported return type: ${method.returnType}")
+    private fun findResultHandler(method: Method): HandlerResultConsumer<Any?> =
+        resultHandlers.asSequence()
+            .filter { it.key.isAssignableFrom(method.returnType) }
+            .sortedWith { a, b ->
+                when {
+                    a.key.isAssignableFrom(b.key) -> -1
+                    b.key.isAssignableFrom(a.key) -> 1
+                    else -> throw IllegalStateException("Unable to determine handler for type ${method.returnType}. Found two matching handlers: ${a.key} and ${b.key}")
+                }
             }
-            else -> null
-        }
-
+            .toList()
+            .lastOrNull()
+            ?.value as? HandlerResultConsumer<Any?>
+            ?: throw IllegalStateException("Unsupported return type: ${method.returnType}")
 
     private fun invokeAndUnwrapIfErrored(
         method: Method,
         instance: Any,
-        vararg arguments: Any?,
+        arguments: Array<Any?>,
+        status: Status?,
         ctx: Context,
-        resultHandler: HandlerResultConsumer<Any?>?
+        resultHandler: HandlerResultConsumer<Any?>
     ): Any? =
         try {
             val result = method.invoke(instance, *arguments)
-            resultHandler?.handle(ctx, result)
+            status
+                ?.takeIf { it.success != HttpStatus.UNKNOWN }
+                ?.let { ctx.status(it.success) }
+            resultHandler.handle(ctx, result)
         } catch (reflectionException: ReflectiveOperationException) {
+            status
+                ?.takeIf { it.error != HttpStatus.UNKNOWN }
+                ?.let { ctx.status(it.error) }
             throw reflectionException.cause ?: reflectionException
         }
 

routing-annotations/routing-annotated/src/test/java/io/javalin/community/routing/annotations/AnnotatedRoutingTest.kt

@@ -4,7 +4,7 @@ import io.javalin.Javalin
 import io.javalin.community.routing.Route
 import io.javalin.http.Context
 import io.javalin.http.HandlerType
-import io.javalin.openapi.experimental.OpenApiAnnotationProcessorConfiguration
+import io.javalin.http.HttpStatus
 import io.javalin.testtools.JavalinTest
 import kong.unirest.Unirest
 import kong.unirest.Unirest.request
@@ -330,4 +330,20 @@ class AnnotatedRoutingTest {
             .hasMessageContaining("Unable to determine handler for type class")
     }
 
+    @Test
+    fun `should use status code from result handler`() =
+        JavalinTest.test(
+            Javalin.create {
+                it.registerAnnotatedEndpoints(
+                    object {
+                        @Get("/test")
+                        @Status(success = HttpStatus.IM_A_TEAPOT)
+                        fun test(ctx: Context): String = "abc"
+                    }
+                )
+            }
+        ) { _, client ->
+            assertThat(Unirest.get("${client.origin}/test").asString().status).isEqualTo(HttpStatus.IM_A_TEAPOT.code)
+        }
+
 }