From 80fd959f1b9e9940244488f11e579a84fc5bdd46 Mon Sep 17 00:00:00 2001
From: Alex Dixon <alex.dixon@ei.tech>
Date: Sun, 25 Jun 2023 08:12:29 -0700
Subject: [PATCH 1/2] add provideLayer

---
 packages/rpc/src/Router.ts          | 17 +++++++++
 packages/rpc/src/internal/router.ts | 55 +++++++++++++++++++++++++++++
 packages/rpc/test/Router.test.ts    | 13 +++++++
 3 files changed, 85 insertions(+)

diff --git a/packages/rpc/src/Router.ts b/packages/rpc/src/Router.ts
index 06c049d..d830206 100644
--- a/packages/rpc/src/Router.ts
+++ b/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.Layer<any, any, any>>(layer: T): <
+    Router extends RpcRouter.Base
+  >(
+    self: Router
+  ) => RpcRouter.Provide<Router, Layer.Layer.Success<T>, never, never>
+  <Router extends RpcRouter.Base, T extends Layer.Layer<any, any, any>>(
+    self: Router,
+    layer: T
+  ): RpcRouter.Provide<Router, Layer.Layer.Success<T>, never, never>
+} =
+ internal.provideLayer
+
 /**
  * @category router combinators
  * @since 1.0.0
diff --git a/packages/rpc/src/internal/router.ts b/packages/rpc/src/internal/router.ts
index a09f3e8..d37b2b2 100644
--- a/packages/rpc/src/internal/router.ts
+++ b/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,
+    R,
+    E extends RpcService.Errors<Router['schema']>,
+    A
+  >(
+    self: Router,
+    layer: Layer.Layer<R, E, A>
+  ): RpcRouter.Provide<Router, Layer.Layer.Success<any>, 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>,
diff --git a/packages/rpc/test/Router.test.ts b/packages/rpc/test/Router.test.ts
index e68fcbe..37538d3 100644
--- a/packages/rpc/test/Router.test.ts
+++ b/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]>

From f89ccdea8bded74cc477cddc162df3173e1bf6c6 Mon Sep 17 00:00:00 2001
From: Alex Dixon <alex.dixon@ei.tech>
Date: Sun, 25 Jun 2023 15:37:23 -0700
Subject: [PATCH 2/2] fix layer import

---
 packages/rpc/src/Router.ts          | 10 +++++-----
 packages/rpc/src/internal/router.ts |  6 +++---
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/packages/rpc/src/Router.ts b/packages/rpc/src/Router.ts
index d830206..03f1a19 100644
--- a/packages/rpc/src/Router.ts
+++ b/packages/rpc/src/Router.ts
@@ -300,17 +300,17 @@ export const make: <
  * @since 1.0.0
  */
 export const provideLayer: {
-  <T extends Layer.Layer<any, any, any>>(layer: T): <
+  <T extends Layer<any, any, any>>(layer: T): <
     Router extends RpcRouter.Base
   >(
     self: Router
-  ) => RpcRouter.Provide<Router, Layer.Layer.Success<T>, never, never>
-  <Router extends RpcRouter.Base, T extends Layer.Layer<any, any, any>>(
+  ) => 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.Layer.Success<T>, never, never>
+  ): RpcRouter.Provide<Router, Layer.Success<T>, never, never>
 } =
- internal.provideLayer
+ internal.provideLayer as any
 
 /**
  * @category router combinators
diff --git a/packages/rpc/src/internal/router.ts b/packages/rpc/src/internal/router.ts
index d37b2b2..8d9a83b 100644
--- a/packages/rpc/src/internal/router.ts
+++ b/packages/rpc/src/internal/router.ts
@@ -56,13 +56,13 @@ export const provideLayer: {
   ): (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']>,
-    A
   >(
     self: Router,
-    layer: Layer.Layer<R, E, A>
-  ): RpcRouter.Provide<Router, Layer.Layer.Success<any>, R, E>
+    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>(