Work

packages/server/src/Services.ts

@@ -2,8 +2,12 @@ import { Layer } from "effect"
 import { TodoRepository } from "./TodoRepository"
 
 
+type TServices =
+    | TodoRepository
+
+export interface Services extends TServices {}
+
+
 export const ServicesLive = Layer.mergeAll(
     TodoRepository.Live
-)
+) satisfies Layer.Layer<Services, never, never>
-
-export interface Services extends Layer.Layer.Success<typeof ServicesLive> {}

packages/server/src/index.ts

@@ -7,6 +7,7 @@ import { TodoRepository, createDefaultTodos } from "./TodoRepository"
 import { ExpressApp } from "./express/ExpressApp"
 import { ExpressHTTPServer } from "./express/ExpressHTTPServer"
 import { RPCPlayground } from "./rpc/RPCPlayground"
+import { RPCRouter } from "./rpc/RPCRouter"
 import { RPCServer } from "./rpc/RPCServer"
 import { RPCProcedureBuilder } from "./rpc/procedures/RPCProcedureBuilder"
 import { TRPCBuilder } from "./trpc/TRPCBuilder"
@@ -16,6 +17,7 @@ import { TRPCContextCreator } from "./trpc/TRPCContextCreator"
 const ServerLive = ExpressHTTPServer.Live.pipe(
     Layer.provide(RPCServer.Live),
     Layer.provide(RPCPlayground.Dev),
+    Layer.provide(RPCRouter.Live),
     Layer.provide(RPCProcedureBuilder.Live),
     Layer.provide(TRPCBuilder.Live),
     Layer.provide(TRPCContextCreator.Live),

packages/server/src/rpc/RPCPlayground.ts

@@ -1,7 +1,8 @@
-import { Config, Effect, Layer } from "effect"
+import { Effect, Layer } from "effect"
 import { expressHandler } from "trpc-playground/handlers/express"
 import { ExpressApp } from "../express/ExpressApp"
-import { appRouter } from "./routers"
+import { RPCRouter } from "./RPCRouter"
+import { rpcPlaygroundRoot, rpcRoot } from "./config"
 
 
 export module RPCPlayground {
@@ -9,17 +10,14 @@ export module RPCPlayground {
 
     export const Dev = Layer.effectDiscard(Effect.gen(function*() {
         const app                = yield* ExpressApp
-        const router             = yield* appRouter
+        const playgroundEndpoint = yield* rpcPlaygroundRoot
 
-        const playgroundEndpoint = yield* Config.string("RPC_PANEL_ROOT").pipe(Config.withDefault("/rpc/playground"))
+        const handler = expressHandler({
-        const trpcApiEndpoint    = yield* Config.string("RPC_ROOT").pipe(Config.withDefault("/rpc"))
+            trpcApiEndpoint: yield* rpcRoot,
+            playgroundEndpoint,
+            router: yield* RPCRouter,
+        })
 
-        app.use(playgroundEndpoint,
+        app.use(playgroundEndpoint, yield* Effect.promise(() => handler))
-            yield* Effect.promise(() => expressHandler({
-                trpcApiEndpoint,
-                playgroundEndpoint,
-                router,
-            }))
-        )
     }))
 }

packages/server/src/rpc/RPCRouter.ts

@@ -0,0 +1,28 @@
+import { Context, Effect, Layer } from "effect"
+import { TRPCBuilder } from "../trpc/TRPCBuilder"
+import { RPCProcedureBuilder } from "./procedures/RPCProcedureBuilder"
+import { todosRouter } from "./routers/todos"
+
+
+export const router = Effect.gen(function*() {
+    const t         = yield* TRPCBuilder
+    const procedure = yield* RPCProcedureBuilder
+
+    return t.router({
+        ping: procedure.query(({ ctx }) =>
+            ctx.run(Effect.succeed("pong"))
+        ),
+
+        todos: yield* todosRouter,
+    })
+})
+
+export class RPCRouter extends Context.Tag("RPCRouter")<RPCRouter,
+    Effect.Effect.Success<typeof router>
+>() {}
+
+export module RPCRouter {
+    export type Router = Context.Tag.Service<RPCRouter>
+
+    export const Live = Layer.effect(RPCRouter, router)
+}

packages/server/src/rpc/RPCServer.ts

@@ -1,19 +1,18 @@
 import { createExpressMiddleware } from "@trpc/server/adapters/express"
-import { Config, Effect, Layer } from "effect"
+import { Effect, Layer } from "effect"
 import { ExpressApp } from "../express/ExpressApp"
 import { TRPCContextCreator } from "../trpc/TRPCContextCreator"
-import { appRouter } from "./routers"
+import { RPCRouter } from "./RPCRouter"
+import { rpcRoot } from "./config"
 
 
 export module RPCServer {
     export const Live = Layer.effectDiscard(Effect.gen(function*() {
         const app = yield* ExpressApp
 
-        app.use(
+        app.use(yield* rpcRoot,
-            yield* Config.string("RPC_ROOT").pipe(Config.withDefault("/rpc")),
-
             createExpressMiddleware({
-                router:         yield* appRouter,
+                router:         yield* RPCRouter,
                 createContext:  yield* TRPCContextCreator,
             }),
         )

packages/server/src/rpc/config.ts

@@ -0,0 +1,5 @@
+import { Config } from "effect"
+
+
+export const rpcRoot           = Config.string("RPC_ROOT").pipe(Config.withDefault("/rpc"))
+export const rpcPlaygroundRoot = Config.string("RPC_PLAYGROUND_ROOT").pipe(Config.withDefault("/rpc/playground"))

packages/server/src/rpc/routers/index.ts

@@ -1,20 +0,0 @@
-import { Effect } from "effect"
-import { TRPCBuilder } from "../../trpc/TRPCBuilder"
-import { RPCProcedureBuilder } from "../procedures/RPCProcedureBuilder"
-import { todosRouter } from "./todos"
-
-
-export const appRouter = Effect.gen(function*() {
-    const t         = yield* TRPCBuilder
-    const procedure = yield* RPCProcedureBuilder
-
-    return t.router({
-        ping: procedure.query(({ ctx }) =>
-            ctx.run(Effect.succeed("pong"))
-        ),
-
-        todos: yield* todosRouter,
-    })
-})
-
-export type AppRouter = Effect.Effect.Success<typeof appRouter>