GH-40 Migrate to Javalin 6.0.0-beta.4, release 6.0.0-SNAPSHOT

Author: dzikoysk

README.md

@@ -35,7 +35,7 @@ Each module is distributed as a separate artifact:
 
 ```kotlin
 dependencies {
-    val javalinRoutingExtensions = "5.6.2-RC.1"
+    val javalinRoutingExtensions = "6.0.0-SNAPSHOT"
     implementation("io.javalin.community.routing:routing-core:$javalinRoutingExtensions")
     implementation("io.javalin.community.routing:routing-annotated:$javalinRoutingExtensions")
     implementation("io.javalin.community.routing:routing-dsl:$javalinRoutingExtensions")

build.gradle.kts

@@ -1,8 +1,8 @@
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
-    kotlin("jvm") version "1.9.20"
-    kotlin("kapt") version "1.9.20"
+    kotlin("jvm") version "1.9.22"
+    kotlin("kapt") version "1.9.22"
     jacoco
     signing
     `maven-publish`
@@ -117,12 +117,12 @@ subprojects {
     apply(plugin = "org.jetbrains.kotlin.kapt")
 
     dependencies {
-        val javalin = "6.0.0-SNAPSHOT"
+        val javalin = "6.0.0-beta.4"
         compileOnly("io.javalin:javalin:$javalin")
         testImplementation("io.javalin:javalin:$javalin")
         testImplementation("io.javalin:javalin-testtools:$javalin")
 
-        val openapi = "5.6.3"
+        val openapi = "6.0.0-SNAPSHOT"
         kaptTest("io.javalin.community.openapi:openapi-annotation-processor:$openapi")
         testImplementation("io.javalin.community.openapi:javalin-openapi-plugin:$openapi")
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

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

@@ -2,6 +2,7 @@ package io.javalin.community.routing.annotations
 
 import io.javalin.community.routing.Route
 import io.javalin.community.routing.dsl.DslRoute
+import io.javalin.community.routing.invokeAsSamWithReceiver
 import io.javalin.community.routing.registerRoute
 import io.javalin.community.routing.sortRoutes
 import io.javalin.config.JavalinConfig
@@ -10,7 +11,7 @@ import io.javalin.http.Context
 import io.javalin.http.Handler
 import io.javalin.router.InternalRouter
 import io.javalin.router.RoutingApiInitializer
-import java.util.function.Consumer
+import io.javalin.router.RoutingSetupScope
 
 fun interface HandlerResultConsumer<T> {
     fun handle(ctx: Context, value: T)
@@ -46,9 +47,9 @@ object AnnotatedRouting : RoutingApiInitializer<AnnotatedRoutingConfig> {
 
     private data class RouteIdentifier(val route: Route, val path: String)
 
-    override fun initialize(cfg: JavalinConfig, internalRouter: InternalRouter, setup: Consumer<AnnotatedRoutingConfig>) {
+    override fun initialize(cfg: JavalinConfig, internalRouter: InternalRouter, setup: RoutingSetupScope<AnnotatedRoutingConfig>) {
         val configuration = AnnotatedRoutingConfig()
-        setup.accept(configuration)
+        setup.invokeAsSamWithReceiver(configuration)
 
         val loader = ReflectiveEndpointLoader(configuration.resultHandlers)
         val registeredRoutes = mutableListOf<AnnotatedRoute>()

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

@@ -5,7 +5,7 @@ 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.validation
+import io.javalin.validation.Validation
 import java.lang.reflect.Method
 import java.lang.reflect.Parameter
 import kotlin.reflect.KClass
@@ -198,7 +198,7 @@ internal class ReflectiveEndpointLoader(
                     getAnnotation(Cookie::class.java)
                         .value
                         .ifEmpty { name }
-                        .let { ctx.validation().validator(it, type, ctx.cookie(it)) }
+                        .let { Validation().validator(it, type, ctx.cookie(it)) }
                         .get()
                 }
                 isAnnotationPresent(Body::class.java) -> { ctx, _ ->

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

@@ -41,11 +41,11 @@ class AnnotatedRoutingTest {
 
         assertThat(matcher.findHttpHandlerEntries(HandlerType.GET, "/test/with"))
             .hasSize(1)
-            .allMatch { it.path == "/test/with" }
+            .allMatch { it.endpoint.path == "/test/with" }
 
         assertThat(matcher.findHttpHandlerEntries(HandlerType.GET, "/test/without"))
             .hasSize(1)
-            .allMatch { it.path == "/test/without" }
+            .allMatch { it.endpoint.path == "/test/without" }
     }
 
     @Test

routing-core/src/main/kotlin/io/javalin/community/routing/JavalinRoutingExtensions.kt

@@ -3,7 +3,9 @@ package io.javalin.community.routing
 import io.javalin.Javalin
 import io.javalin.http.Handler
 import io.javalin.http.HandlerType
+import io.javalin.router.Endpoint
 import io.javalin.router.InternalRouter
+import io.javalin.router.RoutingSetupScope
 import io.javalin.security.RouteRole
 
 class JavalinRoutingExtensions(private val javalin: Javalin) {
@@ -41,14 +43,18 @@ fun InternalRouter.registerRoute(handlerEntry: HandlerEntry) =
 
 fun InternalRouter.registerRoute(route: Route, path: String, handler: Handler, vararg roles: RouteRole) {
     when (route) {
-        Route.HEAD -> addHttpHandler(HandlerType.HEAD, path, handler, *roles)
-        Route.PATCH -> addHttpHandler(HandlerType.PATCH, path, handler, *roles)
-        Route.OPTIONS -> addHttpHandler(HandlerType.OPTIONS, path, handler, *roles)
-        Route.GET -> addHttpHandler(HandlerType.GET, path, handler, *roles)
-        Route.PUT -> addHttpHandler(HandlerType.PUT, path, handler, *roles)
-        Route.POST -> addHttpHandler(HandlerType.POST, path, handler, *roles)
-        Route.DELETE -> addHttpHandler(HandlerType.DELETE, path, handler, *roles)
-        Route.AFTER -> addHttpHandler(HandlerType.AFTER, path, handler)
-        Route.BEFORE -> addHttpHandler(HandlerType.BEFORE, path, handler)
+        Route.HEAD -> addHttpEndpoint(Endpoint(method = HandlerType.HEAD, path = path, handler = handler, roles = roles))
+        Route.PATCH -> addHttpEndpoint(Endpoint(method = HandlerType.PATCH, path = path, handler = handler, roles = roles))
+        Route.OPTIONS -> addHttpEndpoint(Endpoint(method = HandlerType.OPTIONS, path = path, handler = handler, roles = roles))
+        Route.GET -> addHttpEndpoint(Endpoint(method = HandlerType.GET, path = path, handler = handler, roles = roles))
+        Route.PUT -> addHttpEndpoint(Endpoint(method = HandlerType.PUT, path = path, handler = handler, roles = roles))
+        Route.POST -> addHttpEndpoint(Endpoint(method = HandlerType.POST, path = path, handler = handler, roles = roles))
+        Route.DELETE -> addHttpEndpoint(Endpoint(method = HandlerType.DELETE, path = path, handler = handler, roles = roles))
+        Route.AFTER -> addHttpEndpoint(Endpoint(method = HandlerType.AFTER, path = path, handler = handler))
+        Route.BEFORE -> addHttpEndpoint(Endpoint(method = HandlerType.BEFORE, path = path, handler = handler))
     }
+}
+
+fun <SETUP> RoutingSetupScope<SETUP>.invokeAsSamWithReceiver(receiver: SETUP) {
+    with(this) { receiver.setup() }
 }

routing-core/src/test/kotlin/io/javalin/community/routing/JavalinRoutesTest.kt

@@ -23,12 +23,15 @@ class JavalinRoutesTest {
 
         // then: all routes are registered by as proper HandlerType
         routes.forEach { (method, handler) ->
-            assertThat(
-                app.unsafeConfig().pvt.internalRouter
+            val endpoint = app.unsafeConfig()
+                    .pvt
+                    .internalRouter
                     .findHttpHandlerEntries(HandlerType.findByName(method.name), "/")
                     .firstOrNull()
-                    ?.handler
-            ).isEqualTo(handler)
+                    ?.endpoint
+
+            assertThat(endpoint?.method?.name).isEqualTo(method.name)
+            assertThat(endpoint?.path).isEqualTo("/")
         }
     }
 

routing-coroutines/src/main/kotlin/io/javalin/community/routing/coroutines/Coroutines.kt

@@ -1,27 +1,37 @@
 package io.javalin.community.routing.coroutines
 
 import io.javalin.community.routing.coroutines.servlet.CoroutinesServlet
+import io.javalin.community.routing.invokeAsSamWithReceiver
 import io.javalin.community.routing.sortRoutes
 import io.javalin.config.JavalinConfig
 import io.javalin.http.Handler
 import io.javalin.http.HandlerType
+import io.javalin.router.Endpoint
 import io.javalin.router.InternalRouter
 import io.javalin.router.RoutingApiInitializer
-import java.util.function.Consumer
+import io.javalin.router.RoutingSetupScope
 
 class Coroutines<ROUTE : SuspendedRoute<CONTEXT, RESPONSE>, CONTEXT, RESPONSE : Any>(
     private val servlet: CoroutinesServlet<CONTEXT, RESPONSE>,
 ) : RoutingApiInitializer<CoroutinesRouting<ROUTE, CONTEXT, RESPONSE>> {
 
-    override fun initialize(cfg: JavalinConfig, internalRouter: InternalRouter, setup: Consumer<CoroutinesRouting<ROUTE, CONTEXT, RESPONSE>>) {
+    override fun initialize(cfg: JavalinConfig, internalRouter: InternalRouter, setup: RoutingSetupScope<CoroutinesRouting<ROUTE, CONTEXT, RESPONSE>>) {
         val coroutinesRouting = CoroutinesRouting<ROUTE, CONTEXT, RESPONSE>()
-        setup.accept(coroutinesRouting)
+        setup.invokeAsSamWithReceiver(coroutinesRouting)
 
         coroutinesRouting
             .routes
             .sortRoutes()
             .map { it to Handler { ctx -> servlet.handle(ctx, it) } }
-            .forEach { (route, handler) -> internalRouter.addHttpHandler(HandlerType.valueOf(route.method.toString()), route.path, handler) }
+            .forEach { (route, handler) ->
+                internalRouter.addHttpEndpoint(
+                    Endpoint(
+                        method = HandlerType.valueOf(route.method.toString()),
+                        path = route.path,
+                        handler = handler
+                    )
+                )
+            }
     }
 
 }

routing-dsl/src/main/kotlin/io/javalin/community/routing/dsl/DslRouting.kt

@@ -4,12 +4,14 @@ import io.javalin.community.routing.dsl.defaults.DefaultDsl
 import io.javalin.community.routing.dsl.defaults.DefaultDsl.DefaultConfiguration
 import io.javalin.community.routing.dsl.defaults.DefaultDsl.DefaultScope
 import io.javalin.community.routing.dsl.defaults.DefaultRoute
+import io.javalin.community.routing.invokeAsSamWithReceiver
 import io.javalin.community.routing.sortRoutes
 import io.javalin.config.JavalinConfig
 import io.javalin.http.HandlerType
+import io.javalin.router.Endpoint
 import io.javalin.router.InternalRouter
 import io.javalin.router.RoutingApiInitializer
-import java.util.function.Consumer
+import io.javalin.router.RoutingSetupScope
 
 open class DslRouting<
     CONFIG : RoutingDslConfiguration<ROUTE, CONTEXT, RESPONSE>,
@@ -24,14 +26,22 @@ open class DslRouting<
         object Dsl : DslRouting<DefaultConfiguration, DefaultRoute, DefaultScope, Unit>(DefaultDsl)
     }
 
-    override fun initialize(cfg: JavalinConfig, internalRouter: InternalRouter, setup: Consumer<CONFIG>) {
+    override fun initialize(cfg: JavalinConfig, internalRouter: InternalRouter, setup: RoutingSetupScope<CONFIG>) {
         val dslConfig = factory.createConfiguration()
-        setup.accept(dslConfig)
+        setup.invokeAsSamWithReceiver(dslConfig)
 
         dslConfig.routes
             .sortRoutes()
             .map { route -> route to factory.createHandler(route) }
-            .forEach { (route, handler) -> internalRouter.addHttpHandler(HandlerType.valueOf(route.method.toString()), route.path, handler) }
+            .forEach { (route, handler) ->
+                internalRouter.addHttpEndpoint(
+                    Endpoint(
+                        method = HandlerType.valueOf(route.method.toString()),
+                        path = route.path,
+                        handler = handler
+                    )
+                )
+            }
 
         dslConfig.exceptionHandlers.forEach { (exceptionClass, handler) ->
             internalRouter.addHttpExceptionHandler(exceptionClass.java, factory.createExceptionHandler(handler))