Refactor APT to unify tRPC generation and fully support reactive types

This major refactor unifies the tRPC route generation with the standard
MVC routing flow, eliminating code duplication and properly integrating
tRPC endpoints with Jooby's native reactive pipeline.

Key changes:
* Unify Code Generation: Merged `generateTrpcMethod` into `generateHandlerCall`
  in `MvcRoute.java` to use a single, robust parameter extraction and
  method invocation flow.
* Reactive Pipeline Support: Fixed an architectural issue where reactive types
  (CompletableFuture, Mono, Uni, etc.) were incorrectly wrapped in a synchronous
  TrpcResponse. The APT now generates `Publisher<TrpcResponse<T>>`, injecting
  the proper `.map(TrpcResponse::of)` operator natively based on the library.
* Hybrid Route Support: `MvcRouter.java` now correctly splits dual-purpose
  methods. If a method is annotated with both a standard HTTP method (e.g., `@GET`)
  and `@Trpc`, the processor generates two separate mappings and handlers (one
  traditional MVC, one strict tRPC).
* tRPC Precedence & Validation: Enforced strict rules for tRPC annotations.
  `@Trpc.Query`/`@Trpc.Mutation` take precedence. A bare `@Trpc` annotation
  now requires an accompanying `@GET` or `@POST` annotation, otherwise it fails
  the build with a descriptive error.
* Kotlin Codegen Fixes: Fixed Return type mismatches for generic parameterized
  types (adding `as Type` casts), fixed missing non-null assertions (`!!`),
  and ensured `Void`/`Unit` methods correctly emit `TrpcResponse.empty()`.
* Cleanup: Removed dead `trpcPath` resolution methods from `MvcContext`
  and `HttpPath`, as well as the obsolete `TrpcMethod` record.

Author: jknack

modules/jooby-apt/src/main/java/io/jooby/internal/apt/MvcRoute.java

@@ -938,6 +938,12 @@ public MvcRoute addHttpMethod(TypeElement annotation) {
         ofNullable(findAnnotationByName(this.method, annotation.getQualifiedName().toString()))
             .orElseThrow(() -> new IllegalArgumentException("Annotation not found: " + annotation));
     annotationMap.put(annotation, annotationMirror);
+
+    // Eagerly flag as tRPC so equals/hashCode can differentiate hybrid methods early
+    if (HttpMethod.findByAnnotationName(annotation.getQualifiedName().toString())
+        == HttpMethod.tRPC) {
+      this.isTrpc = true;
+    }
     return this;
   }
 
@@ -984,13 +990,13 @@ public String getMethodName() {
 
   @Override
   public int hashCode() {
-    return method.toString().hashCode();
+    return Objects.hash(method.toString(), isTrpc);
   }
 
   @Override
   public boolean equals(Object obj) {
     if (obj instanceof MvcRoute that) {
-      return this.method.toString().equals(that.method.toString());
+      return this.method.toString().equals(that.method.toString()) && this.isTrpc == that.isTrpc;
     }
     return false;
   }
@@ -1071,6 +1077,16 @@ public boolean hasBeanValidation() {
   }
 
   private HttpMethod trpcMethod(Element element) {
+    // 1. High Precedence: Explicit tRPC procedure annotations
+    if (AnnotationSupport.findAnnotationByName(element, "io.jooby.annotation.Trpc.Query") != null) {
+      return HttpMethod.GET;
+    }
+    if (AnnotationSupport.findAnnotationByName(element, "io.jooby.annotation.Trpc.Mutation")
+        != null) {
+      return HttpMethod.POST;
+    }
+
+    // 2. Base Precedence: @Trpc combined with standard HTTP annotations
     var trpc = AnnotationSupport.findAnnotationByName(element, "io.jooby.annotation.Trpc");
     if (trpc != null) {
       if (HttpMethod.GET.matches(element)) {
@@ -1079,14 +1095,15 @@ private HttpMethod trpcMethod(Element element) {
       if (HttpMethod.POST.matches(element)) {
         return HttpMethod.POST;
       }
-      return null;
-    }
-    if (AnnotationSupport.findAnnotationByName(element, "io.jooby.annotation.Trpc.Query") != null) {
-      return HttpMethod.GET;
-    }
-    if (AnnotationSupport.findAnnotationByName(element, "io.jooby.annotation.Trpc.Mutation")
-        != null) {
-      return HttpMethod.POST;
+
+      // 3. Fallback: Missing HTTP Method -> Compilation Error
+      throw new IllegalArgumentException(
+          "tRPC procedure missing HTTP mapping. Method "
+              + element.getSimpleName()
+              + "() in "
+              + element.getEnclosingElement().getSimpleName()
+              + " is annotated with @Trpc but lacks @GET or @POST. Please annotate the method with"
+              + " @Trpc.Query, @Trpc.Mutation, or combine @Trpc with @GET or @POST.");
     }
     return null;
   }

modules/jooby-apt/src/main/java/io/jooby/internal/apt/MvcRouter.java

@@ -66,8 +66,12 @@ public String getGeneratedFilename() {
   }
 
   public MvcRouter put(TypeElement httpMethod, ExecutableElement route) {
-    var routeKey = route.toString();
+    var isTrpc =
+        HttpMethod.findByAnnotationName(httpMethod.getQualifiedName().toString())
+            == HttpMethod.tRPC;
+    var routeKey = (isTrpc ? "trpc" : "") + route.toString();
     var existing = routes.get(routeKey);
+
     if (existing == null) {
       routes.put(routeKey, new MvcRoute(context, this, route).addHttpMethod(httpMethod));
     } else {

tests/src/test/java/io/jooby/i3863/MovieService.java

@@ -9,17 +9,19 @@
 import java.util.Map;
 import java.util.stream.Collectors;
 
-import io.jooby.annotation.Trpc;
+import io.jooby.annotation.*;
 import reactor.core.publisher.Mono;
 
 @Trpc("movies")
+@Path("/api/movies")
 public class MovieService {
 
   private final List<Movie> database =
       List.of(new Movie(1, "The Godfather", 1972), new Movie(2, "Pulp Fiction", 1994));
 
   /** Procedure: movies.create Takes a single complex object. */
   @Trpc.Mutation
+  @POST("/create")
   public Movie create(Movie movie) {
     // In a real app, save to DB. For now, just return it.
     return movie;
@@ -33,6 +35,7 @@ public Mono<Movie> createMono(Movie movie) {
   }
 
   @Trpc.Mutation
+  @PUT
   public void resetIndex() {}
 
   /** Procedure: movies.bulkCreate Takes a List of complex objects. */
@@ -49,7 +52,8 @@ public String ping() {
 
   /** Procedure: movies.getById Single primitive argument */
   @Trpc.Query
-  public Movie getById(int id) {
+  @GET("/{id}")
+  public Movie getById(@PathParam int id) {
     return database.stream().filter(m -> m.id() == id).findFirst().orElse(null);
   }