add provideLayer

packages/rpc/src/Router.ts

@@ -295,6 +295,23 @@ export const make: <
   options?: Partial<RpcRouter.Options>,
 ) => RpcRouter<S, H> = internal.make
 
+/**
+ * @category router combinators
+ * @since 1.0.0
+ */
+export const provideLayer: {
+  <T extends Layer<any, any, any>>(layer: T): <
+    Router extends RpcRouter.Base
+  >(
+    self: Router
+  ) => RpcRouter.Provide<Router, Layer.Success<T>, never, never>
+  <Router extends RpcRouter.Base, T extends Layer<any, any, any>>(
+    self: Router,
+    layer: T
+  ): RpcRouter.Provide<Router, Layer.Success<T>, never, never>
+} =
+ internal.provideLayer as any
+
 /**
  * @category router combinators
  * @since 1.0.0

packages/rpc/src/internal/router.ts

@@ -27,6 +27,61 @@ export const make = <
   }
 }
 
+const provideHandlerLayer = (
+  handler: RpcHandler.Any,
+  layer: Layer.Layer<any, any, any>
+) =>
+  Effect.isEffect(handler)
+    ? Effect.provideLayer(handler, layer)
+    : (input: any) => {
+      const effectOrLayer = (handler as Function)(input)
+      return Effect.provideLayer(
+        Layer.isLayer(effectOrLayer)
+          ? Layer.build(effectOrLayer)
+          : effectOrLayer,
+        layer
+      )
+    }
+
+
+/** @internal */
+export const provideLayer: {
+  <
+    Router extends RpcRouter.Base,
+    T extends Layer.Layer<any, any, any>,
+    R,
+    E extends RpcService.Errors<Router['schema']>
+  >(
+    layer: T
+  ): (self: Router) => RpcRouter.Provide<Router, Layer.Layer.Success<T>, R, E>
+  <
+    Router extends RpcRouter.Base,
+    T extends Layer.Layer<any, any, any>,
+    R,
+    E extends RpcService.Errors<Router['schema']>,
+  >(
+    self: Router,
+    layer: T
+  ): RpcRouter.Provide<Router, Layer.Layer.Success<T>, R, E>
+} = dual(
+  2,
+  <Router extends RpcRouter.Base, T extends Layer.Layer<any, any, any>, R, E>(
+    self: Router,
+    layer: T
+  ): RpcRouter.Provide<Router, Layer.Layer.Success<T>, R, E> => {
+    return {
+      ...self,
+      handlers: Object.fromEntries(
+        Object.entries(self.handlers).map(([method, handler]) =>
+          'handlers' in handler
+            ? [method, provideLayer(handler as any, layer)]
+            : [method, provideHandlerLayer(handler, layer)]
+        )
+      ),
+    } as any
+  }
+)
+
 const provideHandlerEffect = (
   handler: RpcHandler.Any,
   tag: Tag<any, any>,

packages/rpc/test/Router.test.ts

@@ -6,6 +6,7 @@ import * as RS from "@effect/rpc/Schema"
 import { typeEquals } from "@effect/rpc/test/utils"
 import * as S from "@effect/schema/Schema"
 import { describe, it } from "vitest"
+import * as  Layer  from "@effect/io/Layer"
 
 const makeCounter = () => {
   let count = 0
@@ -52,6 +53,18 @@ const router = _.make(schema, {
 })
 
 describe("Router", () => {
+  it("provideLayer/", () => {
+    typeEquals(router.handlers.getCount)<
+      Effect.Effect<Counter, never, readonly [number, number]>
+    >() satisfies true
+
+    const provided = _.provideLayer(router, Layer.sync(Counter, makeCounter))
+    typeEquals(provided.handlers.getCount)<
+      Effect.Effect<never, never, readonly [number, number]>
+    >() satisfies true
+
+    expect(Effect.runSync(provided.handlers.getCount)).toEqual([0, 1])
+  })
   it("provideServiceSync/", () => {
     typeEquals(router.handlers.getCount)<
       Effect.Effect<Counter, never, readonly [number, number]>