airframe-http: Scala 3 support

airframe-http-router/src/main/scala-2/wvlet/airframe/http/router/RouterBase.scala

@@ -27,3 +27,8 @@ trait RouterBase {
   def andThen[Controller]: Router = macro RouterMacros.andThen[Controller]
 
 }
+
+trait RouterObjectBase {
+  def of[Controller]: Router = macro RouterMacros.of[Controller]
+  def add[Controller]: Router = macro RouterMacros.of[Controller]
+}

airframe-http-router/src/main/scala-3/wvlet/airframe/http/router/RouterBase.scala

@@ -14,12 +14,36 @@
 package wvlet.airframe.http.router
 
 import wvlet.airframe.http.Router
+import wvlet.airframe.http.HttpFilterType
+import wvlet.airframe.surface.Surface
 
-trait RouterBase {
+trait RouterBase { self: Router =>
+  inline def add[Controller]: Router = {
+    self.addInternal(Surface.of[Controller], Surface.methodsOf[Controller])
+  }
 
-  /**
-    * Add methods annotated with @Endpoint to the routing table
-    */
-  def add[Controller]: Router     = ???
-  def andThen[Controller]: Router = ???
+  inline def andThen[Controller]: Router = {
+    self.andThen(Router.add[Controller])
+  }
+}
+
+trait RouterObjectBase {
+  inline def of[Controller]: Router = ${ RouterObjectMacros.routerOf[Controller] }
+
+  inline def add[Controller]: Router = ${ RouterObjectMacros.routerOf[Controller] }
+}
+
+private[router] object RouterObjectMacros {
+  import scala.quoted._
+
+  def routerOf[Controller: Type](using quotes: Quotes): Expr[Router] = {
+    import quotes._
+    import quotes.reflect._
+
+    if (TypeRepr.of[Controller] <:< TypeRepr.of[HttpFilterType]) {
+      '{ Router(filterSurface = Some(Surface.of[Controller])) }
+    } else {
+      '{ Router.empty.add[Controller] }
+    }
+  }
 }

airframe-http-router/src/main/scala/wvlet/airframe/http/Router.scala

@@ -203,7 +203,7 @@ case class Router(
   }
 }
 
-object Router extends LogSupport {
+object Router extends RouterObjectBase with LogSupport {
   val empty: Router   = new Router()
   def apply(): Router = empty
 
@@ -237,9 +237,6 @@ object Router extends LogSupport {
     loop(routes.head, routes.tail)
   }
 
-  def of[Controller]: Router = macro RouterMacros.of[Controller]
-  def add[Controller]: Router = macro RouterMacros.of[Controller]
-
   def add(filter: HttpFilterType) = {
     new Router(filterInstance = Some(filter))
   }

airframe-http-router/src/main/scala/wvlet/airframe/http/router/Automaton.scala

@@ -16,14 +16,14 @@ package wvlet.airframe.http.router
 /**
   */
 object Automaton {
-  def empty[Node, Token]: Automaton[Node, Token] = new Automaton(Set.empty, Set.empty)
+  def empty[Node, Token]: AutomatonGraph[Node, Token] = new AutomatonGraph(Set.empty, Set.empty)
 
   case class Edge[Node, Token](src: Node, token: Token, dest: Node)
 
   /**
     * Immutable Automaton implementation. Adding nodes or edges will create a new Automaton instance
     */
-  class Automaton[Node, Token](val nodes: Set[Node], val edges: Set[Edge[Node, Token]]) {
+  class AutomatonGraph[Node, Token](val nodes: Set[Node], val edges: Set[Edge[Node, Token]]) {
     type NodeSet = Set[Node]
 
     override def toString: String = {
@@ -35,12 +35,12 @@ object Automaton {
          |""".stripMargin
     }
 
-    def addNode(n: Node): Automaton[Node, Token] = {
-      new Automaton(nodes + n, edges)
+    def addNode(n: Node): AutomatonGraph[Node, Token] = {
+      new AutomatonGraph(nodes + n, edges)
     }
 
-    def addEdge(src: Node, token: Token, dest: Node): Automaton[Node, Token] = {
-      new Automaton(nodes ++ Seq(src, dest), edges + (Edge(src, token, dest)))
+    def addEdge(src: Node, token: Token, dest: Node): AutomatonGraph[Node, Token] = {
+      new AutomatonGraph(nodes ++ Seq(src, dest), edges + (Edge(src, token, dest)))
     }
 
     def outEdgesFrom(n: Node): Set[Edge[Node, Token]] = {

airframe-http-router/src/main/scala/wvlet/airframe/http/router/HttpEndpointExecutionContext.scala

@@ -62,7 +62,7 @@ class HttpEndpointExecutionContext[Req: HttpRequestAdapter, Resp, F[_]](
           case other =>
             // If X is other type, convert X into an HttpResponse
             backend.mapF(
-              result.asInstanceOf[F[_]],
+              result.asInstanceOf[F[Resp]],
               { (x: Any) => responseHandler.toHttpResponse(route, request, futureValueSurface, x) }
             )
         }

build.sbt

@@ -261,7 +261,8 @@ lazy val projectDotty =
       // codec uses Scala reflection
       codecJVM,
       // fluentd,
-      // httpJVM,
+      httpJVM,
+      httpRouter,
       // // Finagle isn't supporting Scala 3
       // httpFinagle,
       // grpc,