fix: Encode Router @endpoint case-class returns via Weaver (#537)

`RouterHandler` now pre-computes `Weaver.fromSurface(returnType)` for every route and
passes it to `ResponseConverter.toResponse`, so case-class results from `@Endpoint`
controllers are serialized as proper JSON instead of `value.toString` wrapped in
quotes. The weaver is derived against the inner element surface — peeling `Rx[_]` and
`Option[_]` — so it lines up with `ResponseConverter`'s existing wrapper unwrapping
(Rx → unwrap, Option → 204 noContent on None).

`ResponseConverter.toResponse(result)` keeps its old toString-fallback behavior for
callers that don't supply a weaver; the new weaver-aware overload routes anything that
isn't a shape-special type (Response, null, Unit, String, JSONValue, Array[Byte], Rx,
Option) through the weaver.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: xerial

uni-netty/src/main/scala/wvlet/uni/http/netty/RouterHandler.scala

@@ -17,6 +17,8 @@ import wvlet.uni.http.{Request, Response}
 import wvlet.uni.http.router.*
 import wvlet.uni.log.LogSupport
 import wvlet.uni.rx.Rx
+import wvlet.uni.surface.{OptionSurface, Surface}
+import wvlet.uni.weaver.Weaver
 
 /**
   * An RxHttpHandler implementation that dispatches requests to controller methods based on route
@@ -34,6 +36,17 @@ class RouterHandler(router: Router, controllerProvider: ControllerProvider)
   private val matcher = RouteMatcher(router.routes)
   private val mapper  = HttpRequestMapper()
 
+  // Pre-compute Weavers for each route's return type so case-class results are encoded as JSON.
+  // The weaver is derived against the inner element surface (Rx[A] / Option[A] are peeled) to
+  // match how ResponseConverter unwraps these wrappers before encoding the value.
+  private val returnWeavers: Map[Route, Weaver[?]] =
+    router
+      .routes
+      .map { r =>
+        r -> Weaver.fromSurface(RouterHandler.elementSurface(r.methodSurface.returnType))
+      }
+      .toMap
+
   // Lazily initialized filter instance (thread-safe)
   private lazy val filterInstance: Option[RxHttpFilter] = router
     .filterSurfaceOpt
@@ -61,7 +74,7 @@ class RouterHandler(router: Router, controllerProvider: ControllerProvider)
             Some(controller)
           )
           val result = routeMatch.route.methodSurface.call(controller, args*)
-          ResponseConverter.toResponse(result)
+          ResponseConverter.toResponse(result, returnWeavers(routeMatch.route))
         catch
           case e: HttpRequestMappingException =>
             debug(s"Parameter mapping error: ${e.getMessage}")
@@ -77,6 +90,20 @@ end RouterHandler
 
 object RouterHandler:
 
+  /**
+    * Peel `Rx[_]` and `Option[_]` from a return-type surface, since [[ResponseConverter]] unwraps
+    * these wrappers before encoding the inner value. The weaver derived from the resulting surface
+    * is what eventually handles JSON serialization for case classes, sequences, etc.
+    */
+  private[netty] def elementSurface(surface: Surface): Surface =
+    surface match
+      case opt: OptionSurface =>
+        elementSurface(opt.elementSurface)
+      case s if classOf[Rx[?]].isAssignableFrom(s.rawType) && s.typeArgs.nonEmpty =>
+        elementSurface(s.typeArgs.head)
+      case other =>
+        other
+
   /**
     * Create a RouterHandler with a SimpleControllerProvider.
     */

uni-netty/src/test/scala/wvlet/uni/http/netty/NettyServerTest.scala

@@ -14,6 +14,7 @@
 package wvlet.uni.http.netty
 
 import wvlet.uni.http.{HttpHandler, HttpMethod, Request, Response, ServerSentEvent}
+import wvlet.uni.http.router.{Endpoint, Router}
 import wvlet.uni.rx.Rx
 import wvlet.uni.test.UniTest
 
@@ -333,6 +334,29 @@ class NettyServerTest extends UniTest:
       }
   }
 
+  test("should encode case class returns from @Endpoint controllers as JSON") {
+    NettyServer
+      .withPort(0)
+      .withRxHandler(RouterHandler(Router.of[NettyServerTest.HelloController]))
+      .start { server =>
+        val r = get(s"http://localhost:${server.localPort}/hello")
+        r.statusCode() shouldBe 200
+        r.body() shouldBe """{"message":"world"}"""
+        r.headers().firstValue("Content-Type").orElse("") shouldContain "application/json"
+
+        val rOpt = get(s"http://localhost:${server.localPort}/maybe")
+        rOpt.statusCode() shouldBe 200
+        rOpt.body() shouldBe """{"message":"some"}"""
+
+        val rRx = get(s"http://localhost:${server.localPort}/rx")
+        rRx.statusCode() shouldBe 200
+        rRx.body() shouldBe """{"message":"reactive"}"""
+
+        val rNone = get(s"http://localhost:${server.localPort}/none")
+        rNone.statusCode() shouldBe 204
+      }
+  }
+
   test("should detect benign I/O exceptions") {
     import java.io.IOException
     import java.nio.channels.ClosedChannelException
@@ -358,3 +382,19 @@ class NettyServerTest extends UniTest:
   }
 
 end NettyServerTest
+
+object NettyServerTest:
+  case class Greeting(message: String)
+
+  class HelloController:
+    @Endpoint(HttpMethod.GET, "/hello")
+    def hello: Greeting = Greeting("world")
+
+    @Endpoint(HttpMethod.GET, "/maybe")
+    def maybe: Option[Greeting] = Some(Greeting("some"))
+
+    @Endpoint(HttpMethod.GET, "/none")
+    def none: Option[Greeting] = None
+
+    @Endpoint(HttpMethod.GET, "/rx")
+    def rx: Rx[Greeting] = Rx.single(Greeting("reactive"))

uni/src/main/scala/wvlet/uni/http/router/ResponseConverter.scala

@@ -16,6 +16,7 @@ package wvlet.uni.http.router
 import wvlet.uni.http.{HttpContent, Response}
 import wvlet.uni.json.JSON.JSONValue
 import wvlet.uni.rx.Rx
+import wvlet.uni.weaver.Weaver
 
 /**
   * Converts controller method return values to HTTP responses.
@@ -39,19 +40,40 @@ object ResponseConverter:
     * @return
     *   An Rx that emits the HTTP response
     */
-  def toResponse(result: Any): Rx[Response] =
+  def toResponse(result: Any): Rx[Response] = toResponse(result, None)
+
+  /**
+    * Convert a method return value to an Rx[Response] using the given Weaver to encode case classes
+    * and other complex types as JSON.
+    *
+    * The weaver is expected to be derived for the inner element type, after peeling [[Rx]] and
+    * [[Option]] from the controller method's declared return type.
+    *
+    * @param result
+    *   The return value from a controller method
+    * @param returnWeaver
+    *   Weaver for the inner element type
+    * @return
+    *   An Rx that emits the HTTP response
+    */
+  def toResponse(result: Any, returnWeaver: Weaver[?]): Rx[Response] = toResponse(
+    result,
+    Some(returnWeaver)
+  )
+
+  private def toResponse(result: Any, weaverOpt: Option[Weaver[?]]): Rx[Response] =
     result match
       case r: Response =>
         Rx.single(r)
       case rx: Rx[?] =>
-        rx.map(convertToResponse)
+        rx.map(convertToResponse(_, weaverOpt))
       case other =>
-        Rx.single(convertToResponse(other))
+        Rx.single(convertToResponse(other, weaverOpt))
 
   /**
     * Convert a single value to an HTTP response.
     */
-  private def convertToResponse(value: Any): Response =
+  private def convertToResponse(value: Any, weaverOpt: Option[Weaver[?]]): Response =
     value match
       case r: Response =>
         r
@@ -65,27 +87,34 @@ object ResponseConverter:
         Response.ok.withContent(HttpContent.json(json))
       case bytes: Array[Byte] =>
         Response.ok.withBytesContent(bytes)
-      case seq: Seq[?] =>
-        // Convert sequences to JSON arrays
-        Response.ok.withContent(HttpContent.json(seqToJson(seq)))
-      case map: Map[?, ?] =>
-        // Convert maps to JSON objects
-        Response.ok.withContent(HttpContent.json(mapToJson(map)))
       case opt: Option[?] =>
         opt match
           case Some(v) =>
-            convertToResponse(v)
+            convertToResponse(v, weaverOpt)
           case None =>
             Response.noContent
       case other =>
-        // Try to serialize as JSON
-        try
-          val jsonStr = toJsonString(other)
-          Response.ok.withJsonContent(jsonStr)
-        catch
-          case e: Exception =>
-            // Fall back to toString
-            Response.ok.withTextContent(other.toString)
+        weaverOpt match
+          case Some(weaver) =>
+            try
+              val jsonStr = weaver.asInstanceOf[Weaver[Any]].toJson(other)
+              Response.ok.withJsonContent(jsonStr)
+            catch
+              case e: Exception =>
+                Response.ok.withTextContent(other.toString)
+          case None =>
+            other match
+              case seq: Seq[?] =>
+                Response.ok.withContent(HttpContent.json(seqToJson(seq)))
+              case map: Map[?, ?] =>
+                Response.ok.withContent(HttpContent.json(mapToJson(map)))
+              case _ =>
+                try
+                  val jsonStr = toJsonString(other)
+                  Response.ok.withJsonContent(jsonStr)
+                catch
+                  case e: Exception =>
+                    Response.ok.withTextContent(other.toString)
 
   /**
     * Convert a sequence to a JSON array string.