Change builder API

Author: igor-vovk

conformance/src/main/scala/org/ivovk/connect_rpc_scala/conformance/Main.scala

@@ -5,7 +5,6 @@ import com.comcast.ip4s.{Port, host, port}
 import connectrpc.conformance.v1.{ConformanceServiceFs2GrpcTrailers, ServerCompatRequest, ServerCompatResponse}
 import org.http4s.ember.server.EmberServerBuilder
 import org.ivovk.connect_rpc_scala.ConnectRouteBuilder
-import org.ivovk.connect_rpc_scala.http.codec.JsonMessageCodecBuilder
 
 import java.io.InputStream
 import java.nio.ByteBuffer
@@ -36,19 +35,14 @@ object Main extends IOApp.Simple {
         ConformanceServiceImpl[IO]()
       )
 
-      jsonCodec = JsonMessageCodecBuilder[IO]()
-        // Registering message types in TypeRegistry is required to pass com.google.protobuf.any.Any
-        // JSON-serialization conformance tests
-        .withTypeRegistryConfigurator { tp =>
-          tp
-            .addMessage[connectrpc.conformance.v1.UnaryRequest]
-            .addMessage[connectrpc.conformance.v1.IdempotentUnaryRequest]
-            .addMessage[connectrpc.conformance.v1.ConformancePayload.RequestInfo]
-        }
-        .build
-
       app <- ConnectRouteBuilder.forService[IO](service)
-        .withJsonCodec(jsonCodec)
+        .withJsonCodecConfigurator { 
+          // Registering message types in TypeRegistry is required to pass com.google.protobuf.any.Any
+          // JSON-serialization conformance tests
+          _
+            .registerType[connectrpc.conformance.v1.UnaryRequest]
+            .registerType[connectrpc.conformance.v1.IdempotentUnaryRequest]
+        }
         .build
 
       server <- EmberServerBuilder.default[IO]

core/src/main/scala/org/ivovk/connect_rpc_scala/ConnectRouteBuilder.scala

@@ -18,38 +18,66 @@ import scala.concurrent.duration.*
 object ConnectRouteBuilder {
 
   def forService[F[_] : Async](service: ServerServiceDefinition): ConnectRouteBuilder[F] =
-    ConnectRouteBuilder(Seq(service))
+    forServices(Seq(service))
 
   def forServices[F[_] : Async](service: ServerServiceDefinition, other: ServerServiceDefinition*): ConnectRouteBuilder[F] =
-    ConnectRouteBuilder(service +: other)
+    forServices(service +: other)
 
   def forServices[F[_] : Async](services: Seq[ServerServiceDefinition]): ConnectRouteBuilder[F] =
-    ConnectRouteBuilder(services)
+    new ConnectRouteBuilder(
+      services = services,
+      serverConfigurator = identity,
+      channelConfigurator = identity,
+      customJsonCodec = None,
+      pathPrefix = Uri.Path.Root,
+      executor = ExecutionContext.global,
+      waitForShutdown = 5.seconds,
+      treatTrailersAsHeaders = true,
+    )
 
 }
 
-case class ConnectRouteBuilder[F[_] : Async] private(
+final class ConnectRouteBuilder[F[_] : Async] private(
   services: Seq[ServerServiceDefinition],
-  serverConfigurator: Endo[ServerBuilder[_]] = identity,
-  channelConfigurator: Endo[ManagedChannelBuilder[_]] = identity,
-  customJsonCodec: Option[JsonMessageCodec[F]] = None,
-  pathPrefix: Uri.Path = Uri.Path.Root,
-  executor: Executor = ExecutionContext.global,
-  waitForShutdown: Duration = 5.seconds,
-  treatTrailersAsHeaders: Boolean = true,
+  serverConfigurator: Endo[ServerBuilder[_]],
+  channelConfigurator: Endo[ManagedChannelBuilder[_]],
+  customJsonCodec: Option[JsonMessageCodec[F]],
+  pathPrefix: Uri.Path,
+  executor: Executor,
+  waitForShutdown: Duration,
+  treatTrailersAsHeaders: Boolean,
 ) {
 
-  import Mappings.*
-
-  def withJsonCodec(codec: JsonMessageCodec[F]): ConnectRouteBuilder[F] =
-    copy(customJsonCodec = Some(codec))
+  private def copy(
+    services: Seq[ServerServiceDefinition] = services,
+    serverConfigurator: Endo[ServerBuilder[_]] = serverConfigurator,
+    channelConfigurator: Endo[ManagedChannelBuilder[_]] = channelConfigurator,
+    customJsonCodec: Option[JsonMessageCodec[F]] = customJsonCodec,
+    pathPrefix: Uri.Path = pathPrefix,
+    executor: Executor = executor,
+    waitForShutdown: Duration = waitForShutdown,
+    treatTrailersAsHeaders: Boolean = treatTrailersAsHeaders,
+  ): ConnectRouteBuilder[F] =
+    new ConnectRouteBuilder(
+      services,
+      serverConfigurator,
+      channelConfigurator,
+      customJsonCodec,
+      pathPrefix,
+      executor,
+      waitForShutdown,
+      treatTrailersAsHeaders,
+    )
 
   def withServerConfigurator(method: Endo[ServerBuilder[_]]): ConnectRouteBuilder[F] =
     copy(serverConfigurator = method)
 
   def withChannelConfigurator(method: Endo[ManagedChannelBuilder[_]]): ConnectRouteBuilder[F] =
     copy(channelConfigurator = method)
 
+  def withJsonCodecConfigurator(method: Endo[JsonMessageCodecBuilder[F]]): ConnectRouteBuilder[F] =
+    copy(customJsonCodec = Some(method(JsonMessageCodecBuilder[F]()).build))
+
   def withPathPrefix(path: Uri.Path): ConnectRouteBuilder[F] =
     copy(pathPrefix = path)
 
@@ -60,19 +88,20 @@ case class ConnectRouteBuilder[F[_] : Async] private(
     copy(waitForShutdown = duration)
 
   /**
-   * If enabled, trailers will be treated as headers (no "trailer-" prefix).
+   * When enabled, response trailers are treated as headers (no "trailer-" prefix added).
    *
    * Both `fs2-grpc` and `zio-grpc` support trailing headers only, so enabling this option is a single way to
-   * send headers from the server to the client.
+   * send headers from the server to a client.
    *
    * Enabled by default.
    */
   def withTreatTrailersAsHeaders(enabled: Boolean): ConnectRouteBuilder[F] =
     copy(treatTrailersAsHeaders = enabled)
 
   /**
-   * Method can be used if you want to add additional routes to the server.
-   * Otherwise, it is preferred to use the [[build]] method.
+   * Use this method only if you want to add additional routes to the server.
+   *
+   * Otherwise, [[build]] method should be preferred.
    */
   def buildRoutes: Resource[F, HttpRoutes[F]] = {
     val httpDsl = Http4sDsl[F]

core/src/main/scala/org/ivovk/connect_rpc_scala/http/codec/JsonMessageCodecBuilder.scala

@@ -1,37 +1,36 @@
 package org.ivovk.connect_rpc_scala.http.codec
 
-import cats.Endo
 import cats.effect.Sync
 import org.ivovk.connect_rpc_scala.http.json.ErrorDetailsAnyFormat
-import scalapb.json4s
+import scalapb.json4s.{FormatRegistry, JsonFormat, TypeRegistry}
+import scalapb.{GeneratedMessage, GeneratedMessageCompanion, json4s}
 
 import scala.util.chaining.*
 
 object JsonMessageCodecBuilder {
-  def apply[F[_] : Sync](): JsonMessageCodecBuilder[F] = new JsonMessageCodecBuilder()
+  def apply[F[_] : Sync](): JsonMessageCodecBuilder[F] =
+    new JsonMessageCodecBuilder(
+      typeRegistry = TypeRegistry.default,
+      formatRegistry = JsonFormat.DefaultRegistry,
+    )
 }
 
 case class JsonMessageCodecBuilder[F[_] : Sync] private(
-  typeRegistryConfigurator: Endo[json4s.TypeRegistry] = identity,
-  formatRegistryConfigurator: Endo[json4s.FormatRegistry] = identity,
+  typeRegistry: TypeRegistry,
+  formatRegistry: FormatRegistry,
 ) {
 
-  def withTypeRegistryConfigurator(method: Endo[json4s.TypeRegistry]): JsonMessageCodecBuilder[F] =
-    copy(typeRegistryConfigurator = method)
-
-  def withFormatRegistryConfigurator(method: Endo[json4s.FormatRegistry]): JsonMessageCodecBuilder[F] =
-    copy(formatRegistryConfigurator = method)
+  def registerType[T <: GeneratedMessage](using cmp: GeneratedMessageCompanion[T]): JsonMessageCodecBuilder[F] =
+    copy(
+      typeRegistry = typeRegistry.addMessageByCompanion(cmp),
+    )
 
   def build: JsonMessageCodec[F] = {
-    val typeRegistry = json4s.TypeRegistry.default
-      .pipe(typeRegistryConfigurator)
-
-    val formatRegistry = json4s.JsonFormat.DefaultRegistry
+    val formatRegistry = this.formatRegistry
       .registerMessageFormatter[connectrpc.ErrorDetailsAny](
         ErrorDetailsAnyFormat.writer,
         ErrorDetailsAnyFormat.printer
       )
-      .pipe(formatRegistryConfigurator)
 
     val parser = new json4s.Parser()
       .withTypeRegistry(typeRegistry)

core/src/test/scala/org/ivovk/connect_rpc_scala/http/json/JsonSerializationTest.scala

@@ -6,7 +6,7 @@ import scalapb.json4s
 
 class JsonSerializationTest extends AnyFunSuite {
 
-  test("ErrorDetailsAny serialization/deserialization") {
+  test("ErrorDetailsAny serialization") {
     val formatRegistry = json4s.JsonFormat.DefaultRegistry
       .registerMessageFormatter[connectrpc.ErrorDetailsAny](
         ErrorDetailsAnyFormat.writer,