From 2eda6f23ebd7abefd666bd3d2c8fdd94cbc4bd0c Mon Sep 17 00:00:00 2001
From: Patrick Roza <contact@patrickroza.com>
Date: Wed, 13 Aug 2025 23:21:39 +0200
Subject: [PATCH 1/5] prepare

---
 api/src/lib/routing.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/api/src/lib/routing.ts b/api/src/lib/routing.ts
index 29e18dc5..b574bba3 100644
--- a/api/src/lib/routing.ts
+++ b/api/src/lib/routing.ts
@@ -81,7 +81,7 @@ const RequireRolesLive = Layer.effect(
   })
 )
 
-const middleware = Object.assign(RpcMiddleware, {
+export const middleware = Object.assign(RpcMiddleware, {
   Default: RpcMiddleware.layer.pipe(Layer.provide([
     AllowAnonymousLive,
     RequireRolesLive,

From f9e5bbd0f39c5a75d8b6138484579730d5f93e21 Mon Sep 17 00:00:00 2001
From: Patrick Roza <contact@patrickroza.com>
Date: Wed, 13 Aug 2025 23:22:04 +0200
Subject: [PATCH 2/5] add alt resource and controller

---
 api/src/HelloWorld.alt.controllers.ts | 48 +++++++++++++++++++++++++++
 api/src/controllers.ts                |  3 +-
 api/src/resources/HelloWorld.alt.ts   | 31 +++++++++++++++++
 3 files changed, 81 insertions(+), 1 deletion(-)
 create mode 100644 api/src/HelloWorld.alt.controllers.ts
 create mode 100644 api/src/resources/HelloWorld.alt.ts

diff --git a/api/src/HelloWorld.alt.controllers.ts b/api/src/HelloWorld.alt.controllers.ts
new file mode 100644
index 00000000..df943557
--- /dev/null
+++ b/api/src/HelloWorld.alt.controllers.ts
@@ -0,0 +1,48 @@
+import { middleware } from "#lib/routing"
+import { User } from "#models/User"
+import { GetHelloWorld, HelloWorldRpc, meta } from "#resources/HelloWorld.alt"
+import { UserRepo } from "#services"
+import { getRequestContext } from "@effect-app/infra/api/setupRequest"
+import { generate } from "@effect-app/infra/test"
+import { RpcServer } from "@effect/rpc"
+import { Effect, Layer, S } from "effect-app"
+
+// TODO: make this simpler in one go, similar to effect-app Router?
+const server = RpcServer
+  .layerHttpRouter({
+    spanPrefix: "RpcServer." + meta.moduleName,
+    group: HelloWorldRpc,
+    path: ("/rpc/" + meta.moduleName) as `/${typeof meta.moduleName}`,
+    protocol: "http"
+  })
+export default Layer
+  .provide(
+    server,
+    HelloWorldRpc
+      .toLayerDynamic(Effect.gen(function*() {
+        const userRepo = yield* UserRepo
+        return {
+          // TODO: generator support? *Get({ echo }) { - but then need to handle the span stacktrace, like in effect-app Router
+          Get: Effect.fn(function*({ echo }) {
+            const context = yield* getRequestContext
+            const user = yield* userRepo
+              .tryGetCurrentUser
+              .pipe(
+                Effect.catchTags({
+                  "NotLoggedInError": () => Effect.succeed(null),
+                  "NotFoundError": () => Effect.succeed(null)
+                })
+              )
+
+            return new GetHelloWorld.success({
+              context,
+              echo,
+              currentUser: user,
+              randomUser: generate(S.A.make(User)).value
+            })
+          })
+        }
+      }))
+  )
+  // would be kind of nice if we could just pass { effect, dependencies } to toLayerDynamic call, just like Effect.Service?
+  .pipe(Layer.provide([UserRepo.Default, middleware.Default]))
diff --git a/api/src/controllers.ts b/api/src/controllers.ts
index 21be5610..bf38e565 100644
--- a/api/src/controllers.ts
+++ b/api/src/controllers.ts
@@ -1,7 +1,8 @@
 // codegen:start {preset: barrel, include: ./*.controllers.ts, import: default}
 import accountsControllers from "./Accounts.controllers.js"
+import helloWorldAltControllers from "./HelloWorld.alt.controllers.js"
 import helloWorldControllers from "./HelloWorld.controllers.js"
 import operationsControllers from "./Operations.controllers.js"
 
-export { accountsControllers, helloWorldControllers, operationsControllers }
+export { accountsControllers, helloWorldAltControllers, helloWorldControllers, operationsControllers }
 // codegen:end
diff --git a/api/src/resources/HelloWorld.alt.ts b/api/src/resources/HelloWorld.alt.ts
new file mode 100644
index 00000000..37d301d7
--- /dev/null
+++ b/api/src/resources/HelloWorld.alt.ts
@@ -0,0 +1,31 @@
+import { RequestContext } from "@effect-app/infra/RequestContext"
+import { RpcGroup } from "@effect/rpc"
+import { middlewareGroup } from "effect-app/rpc"
+import { RpcMiddleware, S } from "./lib.js"
+import { UserView } from "./views.js"
+
+class Response extends S.Class<Response>("Response")({
+  now: S.Date.withDefault,
+  echo: S.String,
+  context: RequestContext,
+  currentUser: S.NullOr(UserView),
+  randomUser: UserView
+}) {}
+
+export class GetHelloWorld extends S.Req<GetHelloWorld>()("GetHelloWorld", {
+  echo: S.String
+}, { allowAnonymous: true, allowRoles: ["user"], success: Response }) {}
+
+export const HelloWorldRpc = middlewareGroup(RpcMiddleware)(RpcGroup
+  .make(
+    RpcMiddleware.rpc("Get", {
+      payload: GetHelloWorld.fields,
+      // TODO: add fromTaggedRequeset with config support instead
+      success: GetHelloWorld.success,
+      config: GetHelloWorld.config
+    })
+  ))
+
+// codegen:start {preset: meta, sourcePrefix: src/resources/}
+export const meta = { moduleName: "HelloWorld.alt" } as const
+// codegen:end

From e99fc614603ca4a874b6a5512235d6e3a1e9e851 Mon Sep 17 00:00:00 2001
From: Patrick Roza <contact@patrickroza.com>
Date: Wed, 13 Aug 2025 23:22:36 +0200
Subject: [PATCH 3/5] play with atom and rpc client and native rpc controller.

---
 frontend/pages/index.vue | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/frontend/pages/index.vue b/frontend/pages/index.vue
index f3721575..1a0e9dad 100644
--- a/frontend/pages/index.vue
+++ b/frontend/pages/index.vue
@@ -1,6 +1,8 @@
 <script setup lang="ts">
-import { HelloWorldRsc } from "#resources"
+import { HelloWorldRpc } from "#resources/HelloWorld.alt"
 import { buildFormFromSchema } from "@effect-app/vue/form"
+import { Atom, AtomRpc } from "@effect-atom/atom"
+import { useAtomValue } from "@effect-atom/atom-vue"
 import { S } from "effect-app"
 
 class Input extends S.Class<Input>("Input")({
@@ -27,8 +29,18 @@ const makeReq = () => ({
 
 const req = ref(makeReq())
 
-const helloWorldClient = clientFor(HelloWorldRsc)
-const [result] = useSafeQuery(helloWorldClient.GetHelloWorld, req)
+class HelloWorldClient extends AtomRpc.Tag<HelloWorldClient>()(
+  "HelloWorldClient",
+  {
+    protocol: RpcClientProtocolLayers("/HelloWorld.alt"),
+    group: HelloWorldRpc,
+  },
+) {}
+
+const result = useAtomValue(() => {
+  console.log("Computing Atom:", req.value)
+  return Atom.refreshOnWindowFocus(HelloWorldClient.query("Get", req.value))
+})
 
 // onMounted(() => {
 //   setInterval(() => {

From 9a5318903904128e73de6ee39af0917e842b0bb5 Mon Sep 17 00:00:00 2001
From: Patrick Roza <contact@patrickroza.com>
Date: Wed, 13 Aug 2025 23:24:34 +0200
Subject: [PATCH 4/5] add note

---
 api/src/HelloWorld.alt.controllers.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/api/src/HelloWorld.alt.controllers.ts b/api/src/HelloWorld.alt.controllers.ts
index df943557..4f5ce0fa 100644
--- a/api/src/HelloWorld.alt.controllers.ts
+++ b/api/src/HelloWorld.alt.controllers.ts
@@ -8,6 +8,7 @@ import { RpcServer } from "@effect/rpc"
 import { Effect, Layer, S } from "effect-app"
 
 // TODO: make this simpler in one go, similar to effect-app Router?
+// probably just make one global RpcServer and endpoint, but use prefixes on the RpcGroups instead...
 const server = RpcServer
   .layerHttpRouter({
     spanPrefix: "RpcServer." + meta.moduleName,
@@ -44,5 +45,5 @@ export default Layer
         }
       }))
   )
-  // would be kind of nice if we could just pass { effect, dependencies } to toLayerDynamic call, just like Effect.Service?
+  // would be kind of nice if we could just pass { effect, dependencies } to toLayerDynamic call, just like Effect.Service and effect-app Router?
   .pipe(Layer.provide([UserRepo.Default, middleware.Default]))

From 46cc8fdb8f291e9c9b9a0875b81ada9c43bdebf4 Mon Sep 17 00:00:00 2001
From: Patrick Roza <contact@patrickroza.com>
Date: Fri, 15 Aug 2025 13:35:38 +0200
Subject: [PATCH 5/5] and we're basically at effect-app Router ;)

---
 api/src/HelloWorld.alt.controllers.ts | 71 ++++++++-----------
 api/src/lib/routing.ts                | 98 ++++++++++++++++++++++++---
 api/src/resources/HelloWorld.alt.ts   | 23 ++++---
 3 files changed, 132 insertions(+), 60 deletions(-)

diff --git a/api/src/HelloWorld.alt.controllers.ts b/api/src/HelloWorld.alt.controllers.ts
index 4f5ce0fa..4c9db139 100644
--- a/api/src/HelloWorld.alt.controllers.ts
+++ b/api/src/HelloWorld.alt.controllers.ts
@@ -1,49 +1,36 @@
 import { middleware } from "#lib/routing"
 import { User } from "#models/User"
-import { GetHelloWorld, HelloWorldRpc, meta } from "#resources/HelloWorld.alt"
+import { GetHelloWorld, HelloWorldRpc } from "#resources/HelloWorld.alt"
 import { UserRepo } from "#services"
 import { getRequestContext } from "@effect-app/infra/api/setupRequest"
 import { generate } from "@effect-app/infra/test"
-import { RpcServer } from "@effect/rpc"
-import { Effect, Layer, S } from "effect-app"
+import { Effect, S } from "effect-app"
 
-// TODO: make this simpler in one go, similar to effect-app Router?
-// probably just make one global RpcServer and endpoint, but use prefixes on the RpcGroups instead...
-const server = RpcServer
-  .layerHttpRouter({
-    spanPrefix: "RpcServer." + meta.moduleName,
-    group: HelloWorldRpc,
-    path: ("/rpc/" + meta.moduleName) as `/${typeof meta.moduleName}`,
-    protocol: "http"
-  })
-export default Layer
-  .provide(
-    server,
-    HelloWorldRpc
-      .toLayerDynamic(Effect.gen(function*() {
-        const userRepo = yield* UserRepo
-        return {
-          // TODO: generator support? *Get({ echo }) { - but then need to handle the span stacktrace, like in effect-app Router
-          Get: Effect.fn(function*({ echo }) {
-            const context = yield* getRequestContext
-            const user = yield* userRepo
-              .tryGetCurrentUser
-              .pipe(
-                Effect.catchTags({
-                  "NotLoggedInError": () => Effect.succeed(null),
-                  "NotFoundError": () => Effect.succeed(null)
-                })
-              )
-
-            return new GetHelloWorld.success({
-              context,
-              echo,
-              currentUser: user,
-              randomUser: generate(S.A.make(User)).value
+export default middleware.Router(HelloWorldRpc)({
+  dependencies: [UserRepo.Default],
+  effect: Effect.gen(function*() {
+    const userRepo = yield* UserRepo
+    return {
+      // TODO: generator support? *Get({ echo }) { - but then need to handle the span stacktrace, like in effect-app Router
+      Get: Effect.fn(function*({ echo }) {
+        const context = yield* getRequestContext
+        // yield* Effect.context<"not provided">()
+        const user = yield* userRepo
+          .tryGetCurrentUser
+          .pipe(
+            Effect.catchTags({
+              "NotLoggedInError": () => Effect.succeed(null),
+              "NotFoundError": () => Effect.succeed(null)
             })
-          })
-        }
-      }))
-  )
-  // would be kind of nice if we could just pass { effect, dependencies } to toLayerDynamic call, just like Effect.Service and effect-app Router?
-  .pipe(Layer.provide([UserRepo.Default, middleware.Default]))
+          )
+
+        return new GetHelloWorld.success({
+          context,
+          echo,
+          currentUser: user,
+          randomUser: generate(S.A.make(User)).value
+        })
+      })
+    }
+  })
+})
diff --git a/api/src/lib/routing.ts b/api/src/lib/routing.ts
index b574bba3..b2376f08 100644
--- a/api/src/lib/routing.ts
+++ b/api/src/lib/routing.ts
@@ -4,11 +4,16 @@
 import { BaseConfig } from "#config"
 import { AllowAnonymous, getConf, RequireRoles, RpcMiddleware } from "#resources/lib"
 import { makeUserProfileFromAuthorizationHeader, makeUserProfileFromUserHeader, UserProfile } from "#services"
+import { type LayerUtils } from "@effect-app/infra/api/layerUtils"
 import { DefaultGenericMiddlewaresLive, makeRouter } from "@effect-app/infra/api/routing"
-import { Effect, Exit, Layer } from "effect"
-import { Option } from "effect-app"
+import { type Rpc, type RpcGroup, RpcServer } from "@effect/rpc"
+import { type HandlersFrom } from "@effect/rpc/RpcGroup"
+import { type RpcSerialization } from "@effect/rpc/RpcSerialization"
+import { Effect, Exit, Layer, type NonEmptyReadonlyArray, Option, type Scope } from "effect-app"
 import { NotLoggedInError, UnauthorizedError } from "effect-app/client"
-import { type HttpHeaders } from "effect-app/http"
+import { type HttpHeaders, type HttpLayerRouter } from "effect-app/http"
+import { type HandlersContext, type MiddlewareMakerId } from "effect-app/rpc"
+import { type Service } from "effect/Effect"
 import { basicRuntime } from "./basicRuntime.js"
 import { AppLogger } from "./logger.js"
 
@@ -81,12 +86,89 @@ const RequireRolesLive = Layer.effect(
   })
 )
 
+// todo
+export const mergeOptionalDependencies = <T extends { readonly dependencies?: ReadonlyArray<Layer.Layer.Any> }>(
+  a: T
+): T extends { dependencies: NonEmptyReadonlyArray<Layer.Layer.Any> } ? Layer<
+    LayerUtils.GetLayersSuccess<T["dependencies"]>,
+    LayerUtils.GetLayersError<T["dependencies"]>,
+    LayerUtils.GetLayersContext<T["dependencies"]>
+  >
+  : Layer.Layer<never> => Layer.mergeAll(...(a.dependencies as any ?? [])) as any
+
+// TODO; nicer to make one global RpcServer and endpoint, but use prefixes on the RpcGroups instead...
+// but it's not currently supported; https://discord.com/channels/795981131316985866/1270891146213589074/1405494953186033774
+export const makeServer = <R extends Rpc.Any>(group: RpcGroup.RpcGroup<R> & { meta: { moduleName: string } }) =>
+  RpcServer
+    .layerHttpRouter({
+      spanPrefix: "RpcServer." + group.meta.moduleName,
+      group,
+      path: ("/rpc/" + group.meta.moduleName) as `/${typeof group.meta.moduleName}`,
+      protocol: "http"
+    })
+
+const MiddlewareDefault = RpcMiddleware.layer.pipe(Layer.provide([
+  AllowAnonymousLive,
+  RequireRolesLive,
+  DefaultGenericMiddlewaresLive
+]))
+
 export const middleware = Object.assign(RpcMiddleware, {
-  Default: RpcMiddleware.layer.pipe(Layer.provide([
-    AllowAnonymousLive,
-    RequireRolesLive,
-    DefaultGenericMiddlewaresLive
-  ]))
+  Default: MiddlewareDefault,
+  Router: <R extends Rpc.Any>(
+    group: RpcGroup.RpcGroup<R> & {
+      meta: { moduleName: string }
+      toLayerDynamic: <
+        Handlers extends HandlersFrom<R>,
+        EX = never,
+        RX = never
+      >(
+        build:
+          | Handlers
+          | Effect.Effect<Handlers, EX, RX>
+      ) => Layer.Layer<
+        Rpc.ToHandler<R>,
+        EX,
+        | Exclude<RX, Scope>
+        | HandlersContext<R, Handlers>
+      >
+    }
+  ) =>
+  <
+    LayerOpts extends {
+      effect: Effect.Effect<
+        HandlersFrom<R>,
+        any,
+        any
+      >
+      dependencies?: ReadonlyArray<Layer.Layer.Any>
+    }
+  >(
+    layerOpts: LayerOpts
+  ): Layer.Layer<
+    never,
+    Effect.Effect.Error<LayerOpts["effect"]>,
+    | Exclude<Effect.Effect.Context<LayerOpts["effect"]>, Service.MakeDepsOut<LayerOpts>>
+    | Service.MakeDepsIn<LayerOpts>
+    | Exclude<Rpc.Middleware<R>, MiddlewareMakerId>
+    | HandlersContext<R, Effect.Effect.Success<LayerOpts["effect"]>>
+    | RpcSerialization
+    | HttpLayerRouter.HttpRouter
+  > =>
+    makeServer(group).pipe(
+      Layer.provide(MiddlewareDefault),
+      Layer.provide(
+        group
+          .toLayerDynamic(
+            layerOpts.effect as Effect<
+              HandlersFrom<R>,
+              Effect.Error<LayerOpts["effect"]>,
+              Effect.Context<LayerOpts["effect"]>
+            >
+          )
+          .pipe(Layer.provide(mergeOptionalDependencies(layerOpts)))
+      )
+    ) as any
 })
 
 const baseConfig = basicRuntime.runSync(BaseConfig)
diff --git a/api/src/resources/HelloWorld.alt.ts b/api/src/resources/HelloWorld.alt.ts
index 37d301d7..95a8a195 100644
--- a/api/src/resources/HelloWorld.alt.ts
+++ b/api/src/resources/HelloWorld.alt.ts
@@ -16,16 +16,19 @@ export class GetHelloWorld extends S.Req<GetHelloWorld>()("GetHelloWorld", {
   echo: S.String
 }, { allowAnonymous: true, allowRoles: ["user"], success: Response }) {}
 
-export const HelloWorldRpc = middlewareGroup(RpcMiddleware)(RpcGroup
-  .make(
-    RpcMiddleware.rpc("Get", {
-      payload: GetHelloWorld.fields,
-      // TODO: add fromTaggedRequeset with config support instead
-      success: GetHelloWorld.success,
-      config: GetHelloWorld.config
-    })
-  ))
-
 // codegen:start {preset: meta, sourcePrefix: src/resources/}
 export const meta = { moduleName: "HelloWorld.alt" } as const
 // codegen:end
+
+export const HelloWorldRpc = Object.assign(
+  middlewareGroup(RpcMiddleware)(RpcGroup
+    .make(
+      RpcMiddleware.rpc("Get", {
+        payload: GetHelloWorld.fields,
+        // TODO: add fromTaggedRequeset with config support instead
+        success: GetHelloWorld.success,
+        config: GetHelloWorld.config
+      })
+    )),
+  { meta } // todo; auto
+)