src/Layers/trpc/TRPCExpressRoute.ts

@@ -12,13 +12,13 @@ const importTRPCServerExpressAdapter = Effect.tryPromise({
 
 export const TRPCExpressRouteLive = (
     config: {
-        readonly path: Config.Config<string>
+        readonly root: Config.Config<string>
     }
 ) => Layer.effectDiscard(Effect.gen(function*() {
     const { createExpressMiddleware } = yield* importTRPCServerExpressAdapter
     const app = yield* ExpressApp.ExpressApp
 
-    app.use(yield* config.path,
+    app.use(yield* config.root,
         createExpressMiddleware({
             router:         yield* TRPCAnyRouter,
             createContext:  (yield* TRPCUnknownContextCreator).createExpressContext,

src/Layers/trpc/tests.ts

@@ -1,18 +1,39 @@
-import { Console, Effect, identity } from "effect"
+import { Config, Effect, Layer } from "effect"
+import * as TRPC from "."
+import { ExpressApp, ExpressNodeHTTPServer } from "../express"
 
 
-const expansiveComputation = Effect.gen(function*() {
+type Services = never
-    yield* Console.log("executing")
+
-    return "value"
+const { TRPCContextCreator, TRPCContextCreatorLive } = TRPC.TRPCContextCreator.make<Services>()
-}).pipe(
+const { TRPCBuilder, TRPCBuilderLive } = TRPC.TRPCBuilder.make<Services>()
-    Effect.cached,
+
+
+const router = TRPCBuilder.pipe(Effect.map(t => t.router({
+    ping: t.procedure.query(({ ctx }) => ctx.run(
+        Effect.succeed("pong")
+    )),
+})))
+
+const { TRPCRouter, TRPCRouterLive } = TRPC.TRPCRouter.make(router)
+
+
+const ServerLive = Layer.empty.pipe(
+    Layer.provideMerge(TRPC.TRPCExpressRoute.TRPCExpressRouteLive({
+        root: Config.succeed("/rpc")
+    })),
+
+    Layer.provideMerge(TRPCRouterLive),
+    Layer.provideMerge(TRPCBuilderLive),
+    Layer.provideMerge(TRPCContextCreatorLive),
+
+    Layer.provideMerge(ExpressNodeHTTPServer.ExpressNodeHTTPServerLive({
+        port: Config.succeed(3000)
+    })),
+    Layer.provideMerge(ExpressApp.ExpressAppLive())
 )
 
-await Effect.gen(function*() {
+await Layer.launch(ServerLive).pipe(
-    const cached = yield* expansiveComputation
+    Effect.scoped,
-    yield* Console.log(yield* cached)
+    Effect.runPromise,
-    yield* Console.log(yield* cached)
-    yield* Console.log(yield* cached)
-}).pipe(
-    Effect.runPromise
 )