Merge pull request #3894 from jooby-project/3889

tRPC: remove from core

Author: jknack

docs/asciidoc/gRPC.adoc docs/asciidoc/modules/gRPC.adocdocs/asciidoc/gRPC.adoc renamed to docs/asciidoc/modules/gRPC.adoc

@@ -1,30 +1,17 @@
-==== gRPC
+== gRPC
 
 The `jooby-grpc` module provides first-class, native support for https://grpc.io/[gRPC].
 
 Unlike traditional setups that require spinning up a separate gRPC server on a different port (often forcing a specific transport like Netty), this module embeds the `grpc-java` engine directly into Jooby.
 
 By using a custom native bridge, it allows you to run strictly-typed gRPC services alongside your standard REST API routes on the **exact same port**. It bypasses the standard HTTP/1.1 pipeline in favor of a highly optimized, native interceptor tailored for HTTP/2 multiplexing, reactive backpressure, and zero-copy byte framing. It works natively across Undertow, Netty, and Jetty.
 
-===== Usage
+=== Usage
 
 gRPC strictly requires HTTP/2. Before installing the module, ensure your application is configured to use a supported server with HTTP/2 enabled.
 
-[source, xml, role="primary"]
-.Maven
-----
-<dependency>
-  <groupId>io.jooby</groupId>
-  <artifactId>jooby-grpc</artifactId>
-  <version>${jooby.version}</version>
-</dependency>
-----
-
-[source, gradle, role="secondary"]
-.Gradle
-----
-implementation 'io.jooby:jooby-grpc:${jooby.version}'
-----
+[dependency, artifactId="jooby-grpc"]
+.
 
 [source, java, role="primary"]
 .Java
@@ -33,16 +20,10 @@ import io.jooby.Jooby;
 import io.jooby.ServerOptions;
 import io.jooby.grpc.GrpcModule;
 
-public class App extends Jooby {
-  {
-    setServerOptions(new ServerOptions().setHttp2(true)); // <1>
-
-    install(new GrpcModule( // <2>
-        new GreeterService()
-    ));
+{
+  setServerOptions(new ServerOptions().setHttp2(true)); // <1>
 
-    get("/api/health", ctx -> "OK"); // <3>
-  }
+  install(new GrpcModule(new GreeterService()));        // <2>
 }
 ----
 
@@ -53,22 +34,17 @@ import io.jooby.ServerOptions
 import io.jooby.grpc.GrpcModule
 import io.jooby.kt.Kooby
 
-class App : Kooby({
-  serverOptions = ServerOptions().setHttp2(true) // <1>
-
-  install(GrpcModule( // <2>
-      GreeterService()
-  ))
+{
+  serverOptions = ServerOptions().setHttp2(true)          // <1>
 
-  get("/api/health") { "OK" } // <3>
-})
+  install(GrpcModule(GreeterService()))                   // <2>
+}
 ----
 
 <1> Enable HTTP/2 on your server.
 <2> Install the module and explicitly register your services.
-<3> Standard REST routes still work on the exact same port!
 
-===== Dependency Injection
+=== Dependency Injection
 
 If your gRPC services require external dependencies (like database repositories), you can register the service classes instead of pre-instantiated objects. The module will automatically provision them using your active Dependency Injection framework (e.g., Guice, Spring).
 
@@ -79,14 +55,10 @@ import io.jooby.Jooby;
 import io.jooby.di.GuiceModule;
 import io.jooby.grpc.GrpcModule;
 
-public class App extends Jooby {
-  {
-    install(new GuiceModule());
+{
+  install(new GuiceModule());
 
-    install(new GrpcModule(
-        GreeterService.class // <1>
-    ));
-  }
+  install(new GrpcModule(GreeterService.class));  // <1>
 }
 ----
 
@@ -97,19 +69,17 @@ import io.jooby.di.GuiceModule
 import io.jooby.grpc.GrpcModule
 import io.jooby.kt.Kooby
 
-class App : Kooby({
+{
   install(GuiceModule())
 
-  install(GrpcModule(
-      GreeterService::class.java // <1>
-  ))
-})
+  install(GrpcModule(GreeterService::class.java)) // <1>
+}
 ----
 <1> Pass the class references. The DI framework will instantiate them.
 
 WARNING: gRPC services are registered as **Singletons**. Ensure your service implementations are thread-safe and do not hold request-scoped state in instance variables. Heavy blocking operations will safely run on background workers, protecting the native server's I/O event loops.
 
-===== Server Reflection
+=== Server Reflection
 
 If you want to use tools like `grpcurl` or Postman to interact with your services without providing the `.proto` files, you can easily enable gRPC Server Reflection.
 
@@ -122,13 +92,11 @@ import io.grpc.protobuf.services.ProtoReflectionServiceV1;
 import io.jooby.Jooby;
 import io.jooby.grpc.GrpcModule;
 
-public class App extends Jooby {
-  {
-    install(new GrpcModule(
-        new GreeterService(),
-        ProtoReflectionServiceV1.newInstance() // <1>
-    ));
-  }
+{
+  install(new GrpcModule(
+      new GreeterService(),
+      ProtoReflectionServiceV1.newInstance() // <1>
+  ));
 }
 ----
 
@@ -139,16 +107,16 @@ import io.grpc.protobuf.services.ProtoReflectionServiceV1
 import io.jooby.grpc.GrpcModule
 import io.jooby.kt.Kooby
 
-class App : Kooby({
+{
   install(GrpcModule(
       GreeterService(),
       ProtoReflectionServiceV1.newInstance() // <1>
   ))
-})
+}
 ----
 <1> Enables the modern `v1` reflection protocol for maximum compatibility with gRPC clients.
 
-===== Routing & Fallbacks
+=== Routing & Fallbacks
 
 The gRPC module intercepts requests natively before they reach Jooby's standard router.
 

docs/asciidoc/json-rpc.adoc docs/asciidoc/modules/json-rpc.adocdocs/asciidoc/json-rpc.adoc renamed to docs/asciidoc/modules/json-rpc.adoc

@@ -1,10 +1,15 @@
-==== JSON-RPC
+== JSON-RPC
 
 Jooby provides full support for the JSON-RPC 2.0 specification, allowing you to build robust RPC APIs using standard Java and Kotlin controllers.
 
 The implementation leverages Jooby's Annotation Processing Tool (APT) to generate highly optimized, reflection-free dispatchers at compile time.
 
-===== Usage
+=== Usage
+
+Add dependencies:
+
+[dependency, artifactId="jooby-jackson3:Jackson module, jooby-jsonrpc-jackson3:Jackson JSON-RPC implementation, jooby-jsonrpc:JSON-RPC Module"]
+.
 
 To expose a JSON-RPC endpoint, annotate your controller or service with `@JsonRpc`. You can optionally provide a namespace to the annotation, which will prefix all generated method names for that class.
 
@@ -50,61 +55,57 @@ The annotation dictates how the protocol methods are named and exposed:
 
 **Mixing Annotations:** You can freely mix standard REST annotations (like `@GET`, `@POST`) and `@JsonRpc` on the same class. The APT handles this by generating two entirely separate dispatchers: one standard MVC extension (e.g., `MovieService_`) and one JSON-RPC service (e.g., `MovieServiceRpc_`). They do not interfere with each other, allowing you to expose the exact same business logic over both REST and JSON-RPC simultaneously.
 
-===== Registration
+=== Registration
 
 Register the generated `JsonRpcService` in your application using the `jsonrpc` method. You must also install a supported JSON engine.
 
 .JSON-RPC
 [source,java,role="primary"]
 ----
 import io.jooby.Jooby;
-import io.jooby.jackson.JacksonModule;
+import io.jooby.jackson.Jackson3Module;
 
-public class App extends Jooby {
-  {
-    install(new JacksonModule());      // <1>
+{
+  install(new Jackson3Module());                      // <1>
 
-    jsonrpc(new MovieServiceRpc_());   // <2>
+  install(new JsonRpcJackson3Module());               // <2>
 
-    // Alternatively, you can override the default path:
-    // jsonrpc("/json-rpc", new MovieServiceRpc_());
-  }
+  install(new JsonRpcModule(new MovieServiceRpc_())); // <3>
 }
 ----
 
 .Kotlin
 [source,kotlin,role="secondary"]
 ----
 import io.jooby.kt.Kooby
-import io.jooby.jackson.JacksonModule
+import io.jooby.jackson.Jackson3Module
 
-class App : Kooby({
-  
-  install(JacksonModule())             // <1>
+{
+  install(Jackson3Module())                           // <1>
 
-  jsonrpc(MovieServiceRpc_())          // <2>
+  install(JsonRpcJackson3Module())                    // <2>
 
-  // Custom endpoint:
-  // jsonrpc("/json-rpc", MovieServiceRpc_())
-})
+  install(JsonRpcModule(MovieServiceRpc_()))          // <3>
+}
 ----
 
 1. Install a JSON engine
-2. Register the generated JSON-RPC service
+2. Install a JSON-RPC implementation
+3. Register the generated JSON-RPC service
 
-===== JSON Engine Support
+=== JSON Engine Support
 
 The JSON-RPC extension delegates payload parsing and serialization to Jooby's standard JSON modules while enforcing strict JSON-RPC 2.0 compliance (such as the mutual exclusivity of `result` and `error` fields).
 
 Supported engines include:
 
-* **Jackson 2** (`JacksonModule`)
-* **Jackson 3** (`Jackson3Module`)
-* **Avaje JSON-B** (`AvajeJsonbModule`)
+* **Jackson 2**: `JacksonModule`, `JsonRpcJackson2Module`
+* **Jackson 3**: `Jackson3Module`, `JsonRpcJackson3Module`
+* **Avaje JSON-B**: `AvajeJsonbModule`, `JsonRpcAvajeJsonbModule`
 
 No additional configuration is required. The generated dispatcher automatically hooks into the installed engine using the `JsonRpcParser` and `JsonRpcDecoder` interfaces, ensuring primitive types are strictly validated and parsed.
 
-===== Error Mapping
+=== Error Mapping
 
 Jooby seamlessly bridges standard Java application exceptions and HTTP status codes into the JSON-RPC 2.0 format using the `JsonRpcErrorCode` mapping. You do not need to throw custom protocol exceptions for standard failures.
 
@@ -123,7 +124,7 @@ When an application exception is thrown (like a `NotFoundException` with an HTTP
 }
 ----
 
-====== Standard Protocol Errors
+==== Standard Protocol Errors
 
 The engine handles core JSON-RPC 2.0 protocol errors automatically, returning HTTP 200 OK with the corresponding error payload:
 
@@ -135,7 +136,7 @@ The engine handles core JSON-RPC 2.0 protocol errors automatically, returning HT
 
 Application-defined errors map standard HTTP status codes to the `-32000` to `-32099` range (e.g., an HTTP 404 maps to `-32004`, an HTTP 401 maps to `-32001`).
 
-===== Batch Processing
+=== Batch Processing
 
 Batch processing is natively supported. Clients can send an array of JSON-RPC request objects, and the dispatcher will process them and return an array of corresponding response objects.
 

docs/asciidoc/modules/modules.adoc

@@ -62,6 +62,11 @@ Modules are distributed as separate dependencies. Below is the catalog of offici
   * link:{uiVersion}/modules/rocker[Rocker]: Rocker template engine.
   * link:{uiVersion}/modules/thymeleaf[Thymeleaf]: Thymeleaf template engine.
 
+==== Remote Procedure Calls (RPC)
+  * link:{uiVersion}/modules/gRPC[gRPC]: A high-performance, strictly-typed protocol utilizing Protocol Buffers and HTTP/2 multiplexing. Ideal for backend-to-backend communication and polyglot microservices.
+  * link:{uiVersion}/modules/json-rpc[json-rpc]: A lightweight, stateless, and simple JSON-encoded protocol. Excellent for rapid integrations and environments where standard JSON is preferred.
+  * link:{uiVersion}/modules/tRPC[tRPC]: A RPC implementation that provides end-to-end type safety directly between your Java backend and TypeScript clients, without requiring intermediate build steps or code generation.
+
 ==== Security
   * link:{uiVersion}/modules/jasypt[Jasypt]: Encrypted configuration files.
   * link:{uiVersion}/modules/pac4j[Pac4j]: Security engine module.