- redo code generation for @trpc

  - it uses a cool parser which allow to provide custom implemantation of it (Jackson/Avajeb)
  - remove hardcode dependency to Jackson
  - implement Java/Kotlin code generation
  - implement success, void/empty and error reponses
  - add protocol integration test
  - ref #3863

Author: jknack

jooby/src/main/java/io/jooby/trpc/TrpcDecoder.java

@@ -0,0 +1,13 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.trpc;
+
+/** A pre-resolved decoder used at RUNTIME for single-argument methods. */
+public interface TrpcDecoder<T> {
+  T decode(String name, byte[] payload);
+
+  T decode(String name, String payload);
+}

jooby/src/main/java/io/jooby/trpc/TrpcError.java

@@ -8,8 +8,8 @@
 import io.jooby.StatusCode;
 
 public enum TrpcErrorCode {
-  PARSE_ERROR(-32700, StatusCode.BAD_REQUEST),
   BAD_REQUEST(-32600, StatusCode.BAD_REQUEST),
+  PARSE_ERROR(-32700, StatusCode.BAD_REQUEST),
   INTERNAL_SERVER_ERROR(-32603, StatusCode.SERVER_ERROR),
   UNAUTHORIZED(-32001, StatusCode.UNAUTHORIZED),
   FORBIDDEN(-32003, StatusCode.FORBIDDEN),

jooby/src/main/java/io/jooby/trpc/TrpcErrorCode.java

@@ -6,30 +6,39 @@
 package io.jooby.trpc;
 
 import java.util.Map;
+import java.util.Optional;
 
 import edu.umd.cs.findbugs.annotations.NonNull;
 import io.jooby.Context;
 import io.jooby.ErrorHandler;
+import io.jooby.Reified;
 import io.jooby.StatusCode;
 
 public class TrpcErrorHandler implements ErrorHandler {
   @Override
   public void apply(@NonNull Context ctx, @NonNull Throwable cause, @NonNull StatusCode code) {
     if (ctx.getRequestPath().startsWith("/trpc/")) {
+      TrpcException trpcError;
+      if (cause instanceof TrpcException) {
+        trpcError = (TrpcException) cause;
+      } else {
+        Map<Class<?>, TrpcErrorCode> customMapping =
+            ctx.require(Reified.map(Class.class, TrpcErrorCode.class));
+        var procedure = ctx.getRequestPath().replace("/trpc/", "");
+        trpcError =
+            new TrpcException(
+                procedure, errorCode(customMapping, cause).orElse(TrpcErrorCode.of(code)), cause);
+      }
+      ctx.setResponseCode(trpcError.getStatusCode()).render(trpcError.toMap());
+    }
+  }
 
-      var trpcCode = TrpcErrorCode.of(code);
-
-      Map<String, Object> errorData =
-          Map.of(
-              "code", trpcCode.name(),
-              "httpStatus", code.value(),
-              "path", ctx.getRequestPath().replace("/trpc/", ""));
-
-      var errorDetail =
-          new TrpcError.ErrorDetail(cause.getMessage(), trpcCode.getRpcCode(), errorData);
-      var trpcResponse = new TrpcError(errorDetail);
-
-      ctx.setResponseCode(code).render(trpcResponse);
+  private Optional<TrpcErrorCode> errorCode(Map<Class<?>, TrpcErrorCode> mappings, Throwable x) {
+    for (var mapping : mappings.entrySet()) {
+      if (mapping.getKey().isInstance(x)) {
+        return Optional.of(mapping.getValue());
+      }
     }
+    return Optional.empty();
   }
 }

jooby/src/main/java/io/jooby/trpc/TrpcErrorHandler.java

@@ -0,0 +1,64 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.trpc;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+
+import io.jooby.StatusCode;
+
+public class TrpcException extends RuntimeException {
+  private final String procedure;
+  private final TrpcErrorCode errorCode;
+
+  public TrpcException(String procedure, StatusCode code, Throwable cause) {
+    this(procedure, TrpcErrorCode.of(code), cause);
+  }
+
+  public TrpcException(String procedure, TrpcErrorCode code, Throwable cause) {
+    super(procedure + ": " + code.name(), cause);
+    this.procedure = procedure;
+    this.errorCode = code;
+  }
+
+  public TrpcException(String procedure, TrpcErrorCode code) {
+    super(procedure + ": " + code.name());
+    this.procedure = procedure;
+    this.errorCode = code;
+  }
+
+  public TrpcException(String procedure, StatusCode code) {
+    this(procedure, TrpcErrorCode.of(code));
+  }
+
+  public StatusCode getStatusCode() {
+    return errorCode.getStatusCode();
+  }
+
+  public String getProcedure() {
+    return procedure;
+  }
+
+  public Map<String, Object> toMap() {
+    Map<String, Object> data = new LinkedHashMap<>();
+    data.put("code", errorCode.name());
+    data.put("httpStatus", errorCode.getStatusCode().value());
+    data.put("path", procedure);
+
+    Map<String, Object> error = new LinkedHashMap<>();
+    error.put(
+        "message",
+        Optional.ofNullable(getCause())
+            .map(Throwable::getMessage)
+            .filter(Objects::nonNull)
+            .orElse(errorCode.name()));
+    error.put("code", errorCode.getRpcCode());
+    error.put("data", data);
+    return Map.of("error", error);
+  }
+}

jooby/src/main/java/io/jooby/trpc/TrpcException.java

@@ -11,7 +11,13 @@
 
 public class TrpcModule implements Extension {
   @Override
-  public void install(@NonNull Jooby application) throws Exception {
-    application.error(new TrpcErrorHandler());
+  public void install(@NonNull Jooby app) throws Exception {
+    var services = app.getServices();
+
+    services.require(TrpcParser.class);
+    // Custom mapping for TrpcErrorCode
+    services.mapOf(Class.class, TrpcErrorCode.class);
+
+    app.error(new TrpcErrorHandler());
   }
 }

jooby/src/main/java/io/jooby/trpc/TrpcModule.java

@@ -0,0 +1,34 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.trpc;
+
+import java.lang.reflect.Type;
+
+/**
+ * Factory provided by the JSON module (Jackson or Avaje). Used by the APT-generated routes AT
+ * STARTUP to cache deserializers.
+ */
+public interface TrpcParser {
+
+  /** Resolves and caches the deserializer for a specific type during route initialization. */
+  <T> TrpcDecoder<T> decoder(Type type);
+
+  /**
+   * Creates a sequential reader for parsing tRPC arguments from a JSON array.
+   *
+   * @param payload A JSON array containing the method arguments.
+   * @return A reader for sequential argument extraction.
+   */
+  TrpcReader reader(byte[] payload);
+
+  /**
+   * Creates a sequential reader for parsing tRPC arguments from a JSON array.
+   *
+   * @param payload A JSON array containing the method arguments.
+   * @return A reader for sequential argument extraction.
+   */
+  TrpcReader reader(String payload);
+}

jooby/src/main/java/io/jooby/trpc/TrpcParser.java

@@ -0,0 +1,27 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.trpc;
+
+/**
+ * A sequential reader used at RUNTIME for multi-argument methods. Allows the APT code to extract
+ * arguments one by one, preserving primitives.
+ */
+public interface TrpcReader extends AutoCloseable {
+
+  // Primitive extractors to avoid autoboxing
+  int nextInt(String name);
+
+  long nextLong(String name);
+
+  boolean nextBoolean(String name);
+
+  double nextDouble(String name);
+
+  String nextString(String name);
+
+  // Object extractor using a pre-resolved decoder
+  <T> T nextObject(String name, TrpcDecoder<T> decoder);
+}

jooby/src/main/java/io/jooby/trpc/TrpcReader.java

@@ -5,9 +5,16 @@
  */
 package io.jooby.trpc;
 
-public record TrpcResponse<T>(TrpcResult<T> result) {
+import edu.umd.cs.findbugs.annotations.NonNull;
+import edu.umd.cs.findbugs.annotations.Nullable;
 
-  public static <T> TrpcResponse<T> success(T data) {
-    return new TrpcResponse<>(new TrpcResult<>(data));
+public record TrpcResponse<T>(@Nullable T data) {
+
+  public static @NonNull <T> TrpcResponse<T> of(@NonNull T data) {
+    return new TrpcResponse<>(data);
+  }
+
+  public static @NonNull <T> TrpcResponse<T> empty() {
+    return new TrpcResponse<>(null);
   }
 }

jooby/src/main/java/io/jooby/trpc/TrpcResponse.java

@@ -14,6 +14,7 @@
   exports io.jooby.problem;
   exports io.jooby.value;
   exports io.jooby.output;
+  exports io.jooby.trpc;
 
   uses io.jooby.Server;
   uses io.jooby.SslProvider;