add Rpc prefix to rpc module names (#3442)

.changeset/healthy-radios-cough.md

@@ -0,0 +1,6 @@
+---
+"@effect/rpc-http": minor
+"@effect/rpc": minor
+---
+
+add Rpc prefix to rpc modules

.changeset/two-sloths-yell.md

@@ -0,0 +1,5 @@
+---
+"@effect/rpc": patch
+---
+
+support backpressure for Rpc streams

packages/cluster-browser/src/RpcBroadcastChannel.ts

@@ -1,9 +1,9 @@
 /**
  * @since 1.0.0
  */
-import * as Resolver from "@effect/rpc/Resolver"
-import * as Router from "@effect/rpc/Router"
 import type * as Rpc from "@effect/rpc/Rpc"
+import * as RpcResolver from "@effect/rpc/RpcResolver"
+import * as RpcRouter from "@effect/rpc/RpcRouter"
 import * as Schema from "@effect/schema/Schema"
 import type * as Serializable from "@effect/schema/Serializable"
 import * as Effect from "effect/Effect"
@@ -27,8 +27,8 @@ const BroadcastMessage = Schema.Union(ClientRequest, ServerResponse)
 /**
  * @since 1.0.0
  */
-export const toBroadcastChannelRouter = <R extends Router.Router<any, any>>(self: R, channelId: string) => {
-  const handler = Router.toHandlerEffect(self)
+export const toBroadcastChannelRouter = <R extends RpcRouter.RpcRouter<any, any>>(self: R, channelId: string) => {
+  const handler = RpcRouter.toHandlerNoStream(self)
 
   return Effect.gen(function*($) {
     const queue = yield* $(Queue.unbounded())
@@ -69,13 +69,13 @@ export const toBroadcastChannelRouter = <R extends Router.Router<any, any>>(self
 /**
  * @since 1.0.0
  */
-export const make = <R extends Router.Router<any, any>>(
+export const make = <R extends RpcRouter.RpcRouter<any, any>>(
   channelId: string
 ): RequestResolver.RequestResolver<
-  Rpc.Request<Router.Router.Request<R>>,
-  Serializable.SerializableWithResult.Context<Router.Router.Request<R>>
-> => {
-  return Resolver.make((requests) => {
+  Rpc.Request<RpcRouter.RpcRouter.Request<R>>,
+  Serializable.SerializableWithResult.Context<RpcRouter.RpcRouter.Request<R>>
+> =>
+  RpcResolver.make((requests) => {
     return Effect.gen(function*($) {
       const queue = yield* $(Queue.unbounded())
       yield* $(Effect.addFinalizer(() => Queue.shutdown(queue)))
@@ -109,4 +109,3 @@ export const make = <R extends Router.Router<any, any>>(
       )
     }).pipe(Effect.scoped)
   })<R>()
-}

packages/cluster-node/examples/sample-connect.ts

@@ -7,8 +7,8 @@ import * as Sharding from "@effect/cluster/Sharding"
 import * as ShardingConfig from "@effect/cluster/ShardingConfig"
 import { HttpClient, HttpClientRequest } from "@effect/platform"
 import { NodeHttpClient, NodeRuntime } from "@effect/platform-node"
-import { Resolver } from "@effect/rpc"
-import { HttpResolver } from "@effect/rpc-http"
+import { RpcResolver } from "@effect/rpc"
+import { HttpRpcResolver } from "@effect/rpc-http"
 import { Effect, Layer, Logger, LogLevel, Ref } from "effect"
 import { CounterEntity, GetCurrent, Increment } from "./sample-common.js"
 
@@ -31,23 +31,23 @@ const liveLayer = Effect.gen(function*() {
   Layer.provide(Sharding.live),
   Layer.provide(StorageFile.storageFile),
   Layer.provide(PodsRpc.podsRpc<never>((podAddress) =>
-    HttpResolver.make<ShardingServiceRpc.ShardingServiceRpc>(
+    HttpRpcResolver.make<ShardingServiceRpc.ShardingServiceRpc>(
       HttpClient.fetchOk.pipe(
         HttpClient.mapRequest(
           HttpClientRequest.prependUrl(`http://${podAddress.host}:${podAddress.port}/api/rest`)
         )
       )
-    ).pipe(Resolver.toClient)
+    ).pipe(RpcResolver.toClient)
   )),
   Layer.provide(ShardManagerClientRpc.shardManagerClientRpc(
     (shardManagerUri) =>
-      HttpResolver.make<ShardingServiceRpc.ShardingServiceRpc>(
+      HttpRpcResolver.make<ShardingServiceRpc.ShardingServiceRpc>(
         HttpClient.fetchOk.pipe(
           HttpClient.mapRequest(
             HttpClientRequest.prependUrl(shardManagerUri)
           )
         )
-      ).pipe(Resolver.toClient)
+      ).pipe(RpcResolver.toClient)
   )),
   Layer.provide(ShardingConfig.withDefaults({ shardingPort: 54322 })),
   Layer.provide(Serialization.json),

packages/cluster-node/examples/sample-manager.ts

@@ -7,16 +7,16 @@ import * as PodsHealth from "@effect/cluster/PodsHealth"
 import * as ShardManager from "@effect/cluster/ShardManager"
 import { HttpClient, HttpClientRequest, HttpMiddleware, HttpRouter, HttpServer } from "@effect/platform"
 import { NodeHttpServer, NodeRuntime } from "@effect/platform-node"
-import { Resolver } from "@effect/rpc"
-import { HttpResolver, HttpRouter as RpcHttpRouter } from "@effect/rpc-http"
+import { RpcResolver } from "@effect/rpc"
+import { HttpRpcResolver, HttpRpcRouter } from "@effect/rpc-http"
 import { Context, Effect, Layer, Logger, LogLevel } from "effect"
 import { createServer } from "node:http"
 
 const HttpLive = Layer.flatMap(
   Layer.effect(ManagerConfig.ManagerConfig, ManagerConfig.ManagerConfig),
   (config) =>
     HttpRouter.empty.pipe(
-      HttpRouter.post("/api/rest", RpcHttpRouter.toHttpApp(ShardManagerServiceRpc.router)),
+      HttpRouter.post("/api/rest", HttpRpcRouter.toHttpApp(ShardManagerServiceRpc.router)),
       HttpServer.serve(HttpMiddleware.logger),
       HttpServer.withLogAddress,
       Layer.provide(
@@ -35,13 +35,13 @@ const liveShardingManager = Effect.never.pipe(
   Layer.provide(StorageFile.storageFile),
   Layer.provide(PodsHealth.local),
   Layer.provide(PodsRpc.podsRpc<never>((podAddress) =>
-    HttpResolver.make<ShardingServiceRpc.ShardingServiceRpc>(
+    HttpRpcResolver.make<ShardingServiceRpc.ShardingServiceRpc>(
       HttpClient.fetchOk.pipe(
         HttpClient.mapRequest(
           HttpClientRequest.prependUrl(`http://${podAddress.host}:${podAddress.port}/api/rest`)
         )
       )
-    ).pipe(Resolver.toClient)
+    ).pipe(RpcResolver.toClient)
   )),
   Layer.provide(ManagerConfig.fromConfig),
   Layer.provide(HttpClient.layer)

packages/cluster-node/examples/sample-shard.ts

@@ -9,8 +9,8 @@ import * as Sharding from "@effect/cluster/Sharding"
 import * as ShardingConfig from "@effect/cluster/ShardingConfig"
 import { HttpClient, HttpClientRequest, HttpMiddleware, HttpRouter, HttpServer } from "@effect/platform"
 import { NodeHttpClient, NodeHttpServer, NodeRuntime } from "@effect/platform-node"
-import { Resolver } from "@effect/rpc"
-import { HttpResolver, HttpRouter as RpcHttpRouter } from "@effect/rpc-http"
+import { RpcResolver } from "@effect/rpc"
+import { HttpRpcResolver, HttpRpcRouter } from "@effect/rpc-http"
 import { Context, Effect, Exit, Layer, Logger, LogLevel, Ref } from "effect"
 import { createServer } from "node:http"
 import { CounterEntity } from "./sample-common.js"
@@ -19,7 +19,7 @@ const HttpLive = Layer.flatMap(
   Layer.effect(ShardingConfig.ShardingConfig, ShardingConfig.ShardingConfig),
   (config) =>
     HttpRouter.empty.pipe(
-      HttpRouter.post("/api/rest", RpcHttpRouter.toHttpApp(ShardingServiceRpc.router)),
+      HttpRouter.post("/api/rest", HttpRpcRouter.toHttpApp(ShardingServiceRpc.router)),
       HttpServer.serve(HttpMiddleware.logger),
       HttpServer.withLogAddress,
       Layer.provide(
@@ -63,23 +63,23 @@ const liveLayer = Sharding.registerEntity(
   Layer.provideMerge(Sharding.live),
   Layer.provide(StorageFile.storageFile),
   Layer.provide(PodsRpc.podsRpc<never>((podAddress) =>
-    HttpResolver.make<ShardingServiceRpc.ShardingServiceRpc>(
+    HttpRpcResolver.make<ShardingServiceRpc.ShardingServiceRpc>(
       HttpClient.fetchOk.pipe(
         HttpClient.mapRequest(
           HttpClientRequest.prependUrl(`http://${podAddress.host}:${podAddress.port}/api/rest`)
         )
       )
-    ).pipe(Resolver.toClient)
+    ).pipe(RpcResolver.toClient)
   )),
   Layer.provide(ShardManagerClientRpc.shardManagerClientRpc(
     (shardManagerUri) =>
-      HttpResolver.make<ShardingServiceRpc.ShardingServiceRpc>(
+      HttpRpcResolver.make<ShardingServiceRpc.ShardingServiceRpc>(
         HttpClient.fetchOk.pipe(
           HttpClient.mapRequest(
             HttpClientRequest.prependUrl(shardManagerUri)
           )
         )
-      ).pipe(Resolver.toClient)
+      ).pipe(RpcResolver.toClient)
   )),
   Layer.provide(Serialization.json),
   Layer.provide(NodeHttpClient.layerUndici),

packages/cluster-node/src/PodsRpc.ts

@@ -6,8 +6,8 @@ import * as Pods from "@effect/cluster/Pods"
 import type * as SerializedEnvelope from "@effect/cluster/SerializedEnvelope"
 import type * as ShardId from "@effect/cluster/ShardId"
 import * as ShardingException from "@effect/cluster/ShardingException"
-import type * as Resolver from "@effect/rpc/Resolver"
 import type * as Rpc from "@effect/rpc/Rpc"
+import type * as RpcResolver from "@effect/rpc/RpcResolver"
 import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
 import type * as HashSet from "effect/HashSet"
@@ -25,7 +25,7 @@ import type * as ShardingServiceRpc from "./ShardingServiceRpc.js"
 export function podsRpc<R>(
   buildClient: (
     podAddress: PodAddress.PodAddress
-  ) => Resolver.Client<
+  ) => RpcResolver.Client<
     RequestResolver.RequestResolver<Rpc.Request<ShardingServiceRpc.ShardingServiceRpcRequest>, never>
   >
 ): Layer.Layer<Pods.Pods, never, R> {

packages/cluster-node/src/ShardManagerClientRpc.ts

@@ -4,8 +4,8 @@
 import * as Pod from "@effect/cluster/Pod"
 import * as ShardingConfig from "@effect/cluster/ShardingConfig"
 import * as ShardManagerClient from "@effect/cluster/ShardManagerClient"
-import type * as Resolver from "@effect/rpc/Resolver"
 import type * as Rpc from "@effect/rpc/Rpc"
+import type * as RpcResolver from "@effect/rpc/RpcResolver"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import type * as RequestResolver from "effect/RequestResolver"
@@ -17,7 +17,7 @@ import type * as ShardManagerServiceRpc from "./ShardManagerServiceRpc.js"
  * @category layer
  */
 export function shardManagerClientRpc(
-  makeClient: (shardManagerUri: string) => Resolver.Client<
+  makeClient: (shardManagerUri: string) => RpcResolver.Client<
     RequestResolver.RequestResolver<Rpc.Request<ShardManagerServiceRpc.ShardManagerServiceRpcRequest>, never>
   >
 ) {

packages/cluster-node/src/ShardManagerServiceRpc.ts

@@ -2,8 +2,8 @@
  * @since 1.0.0
  */
 import * as ShardManager from "@effect/cluster/ShardManager"
-import * as Router from "@effect/rpc/Router"
 import * as Rpc from "@effect/rpc/Rpc"
+import * as RpcRouter from "@effect/rpc/RpcRouter"
 import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
 import * as ShardManagerProtocolHttp from "./ShardManagerProtocol.js"
@@ -12,7 +12,7 @@ import * as ShardManagerProtocolHttp from "./ShardManagerProtocol.js"
  * @since 1.0.0
  * @category rpc
  */
-export const router = Router.make(
+export const router = RpcRouter.make(
   Rpc.effect(ShardManagerProtocolHttp.Register, (request) =>
     pipe(
       ShardManager.ShardManager,
@@ -45,4 +45,4 @@ export type ShardManagerServiceRpc = typeof router
  * @since 1.0.0
  * @category models
  */
-export type ShardManagerServiceRpcRequest = Router.Router.Request<typeof router>
+export type ShardManagerServiceRpcRequest = RpcRouter.RpcRouter.Request<typeof router>

packages/cluster-node/src/ShardingServiceRpc.ts

@@ -2,8 +2,8 @@
  * @since 1.0.0
  */
 import * as Sharding from "@effect/cluster/Sharding"
-import * as Router from "@effect/rpc/Router"
 import * as Rpc from "@effect/rpc/Rpc"
+import * as RpcRouter from "@effect/rpc/RpcRouter"
 import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
 import * as ShardingProtocol from "./ShardingProtocol.js"
@@ -12,7 +12,7 @@ import * as ShardingProtocol from "./ShardingProtocol.js"
  * @since 1.0.0
  * @category rpc
  */
-export const router = Router.make(
+export const router = RpcRouter.make(
   Rpc.effect(ShardingProtocol.AssignShards, (request) =>
     pipe(
       Sharding.Tag,
@@ -41,4 +41,4 @@ export type ShardingServiceRpc = typeof router
  * @since 1.0.0
  * @category models
  */
-export type ShardingServiceRpcRequest = Router.Router.Request<typeof router>
+export type ShardingServiceRpcRequest = RpcRouter.RpcRouter.Request<typeof router>

packages/rpc-http/examples/client.ts

@@ -1,16 +1,16 @@
 import { HttpClient, HttpClientRequest } from "@effect/platform"
-import { Resolver } from "@effect/rpc"
-import { HttpResolver } from "@effect/rpc-http"
+import { RpcResolver } from "@effect/rpc"
+import { HttpRpcResolver } from "@effect/rpc-http"
 import { Console, Effect, Stream } from "effect"
 import type { UserRouter } from "./router.js"
 import { GetUser, GetUserIds } from "./schema.js"
 
 // Create the client
-const client = HttpResolver.make<UserRouter>(
+const client = HttpRpcResolver.make<UserRouter>(
   HttpClient.fetchOk.pipe(
     HttpClient.mapRequest(HttpClientRequest.prependUrl("http://localhost:3000/rpc"))
   )
-).pipe(Resolver.toClient)
+).pipe(RpcResolver.toClient)
 
 // Use the client
 client(new GetUserIds()).pipe(

packages/rpc-http/examples/router.ts

@@ -1,13 +1,13 @@
 import { HttpMiddleware, HttpRouter, HttpServer } from "@effect/platform"
 import { NodeHttpServer, NodeRuntime } from "@effect/platform-node"
-import { Router, Rpc } from "@effect/rpc"
-import { HttpRouter as RpcHttpRouter } from "@effect/rpc-http"
+import { Rpc, RpcRouter } from "@effect/rpc"
+import { HttpRpcRouter } from "@effect/rpc-http"
 import { Array, Effect, Layer, Stream } from "effect"
 import { createServer } from "http"
 import { GetUser, GetUserIds, User, UserId } from "./schema.js"
 
 // Implement the RPC server router
-const router = Router.make(
+const router = RpcRouter.make(
   Rpc.stream(GetUserIds, () => Stream.fromIterable(Array.makeBy(1000, UserId.make))),
   Rpc.effect(GetUser, ({ id }) => Effect.succeed(new User({ id, name: "John Doe" })))
 )
@@ -16,7 +16,7 @@ export type UserRouter = typeof router
 
 // Create the http server
 const HttpLive = HttpRouter.empty.pipe(
-  HttpRouter.post("/rpc", RpcHttpRouter.toHttpApp(router)),
+  HttpRouter.post("/rpc", HttpRpcRouter.toHttpApp(router)),
   HttpServer.serve(HttpMiddleware.logger),
   HttpServer.withLogAddress,
   Layer.provide(NodeHttpServer.layer(createServer, { port: 3000 }))

packages/rpc-http/src/HttpResolver.ts → packages/rpc-http/src/HttpRpcResolver.ts

@@ -4,9 +4,9 @@
 import * as Body from "@effect/platform/HttpBody"
 import * as Client from "@effect/platform/HttpClient"
 import * as ClientRequest from "@effect/platform/HttpClientRequest"
-import * as Resolver from "@effect/rpc/Resolver"
-import type * as Router from "@effect/rpc/Router"
 import type * as Rpc from "@effect/rpc/Rpc"
+import * as Resolver from "@effect/rpc/RpcResolver"
+import type * as Router from "@effect/rpc/RpcRouter"
 import type * as Serializable from "@effect/schema/Serializable"
 import * as Chunk from "effect/Chunk"
 import * as Effect from "effect/Effect"
@@ -18,11 +18,11 @@ import * as Stream from "effect/Stream"
  * @category constructors
  * @since 1.0.0
  */
-export const make = <R extends Router.Router<any, any>>(
+export const make = <R extends Router.RpcRouter<any, any>>(
   client: Client.HttpClient.Default
 ): RequestResolver.RequestResolver<
-  Rpc.Request<Router.Router.Request<R>>,
-  Serializable.SerializableWithResult.Context<Router.Router.Request<R>>
+  Rpc.Request<Router.RpcRouter.Request<R>>,
+  Serializable.SerializableWithResult.Context<Router.RpcRouter.Request<R>>
 > =>
   Resolver.make((requests) =>
     client(ClientRequest.post("", {
@@ -44,11 +44,11 @@ export const make = <R extends Router.Router<any, any>>(
  * @category constructors
  * @since 1.0.0
  */
-export const makeClient = <R extends Router.Router<any, any>>(
+export const makeClient = <R extends Router.RpcRouter<any, any>>(
   baseUrl: string
-): Serializable.SerializableWithResult.Context<Router.Router.Request<R>> extends never ? Resolver.Client<
+): Serializable.SerializableWithResult.Context<Router.RpcRouter.Request<R>> extends never ? Resolver.Client<
     RequestResolver.RequestResolver<
-      Rpc.Request<Router.Router.Request<R>>
+      Rpc.Request<Router.RpcRouter.Request<R>>
     >
   > :
   "HttpResolver.makeClient: request context is not `never`" =>