src/TRPC/TRPCExpressRoute.ts

@@ -1,8 +1,8 @@
-import type { AnyRouter } from "@trpc/server"
+import { Config, Effect, Layer } from "effect"
-import { Config, Context, Effect, Layer } from "effect"
 import { ExpressApp } from "../Express"
 import { ImportError } from "../ImportError"
 import { TRPCUnknownContextCreator } from "./TRPCContextCreator"
+import { TRPCAnyRouter } from "./TRPCRouter"
 
 
 const importTRPCServerExpressAdapter = Effect.tryPromise({
@@ -10,22 +10,17 @@ const importTRPCServerExpressAdapter = Effect.tryPromise({
     catch: cause => new ImportError({ path: "@trpc/server/adapters/express", cause }),
 })
 
-export const TRPCExpressRouteLive = <
+export const TRPCExpressRouteLive = (
-    Tag,
-    TagShape extends AnyRouter,
->(
-    routerTag: Context.TagClass<Tag, "@thilalib/TRCP/TRPCRouter", TagShape>,
-
     config: {
         readonly root: Config.Config<string>
-    },
+    }
 ) => Layer.effectDiscard(Effect.gen(function*() {
     const { createExpressMiddleware } = yield* importTRPCServerExpressAdapter
     const app = yield* ExpressApp.ExpressApp
 
     app.use(yield* config.root,
         createExpressMiddleware({
-            router:         yield* routerTag,
+            router:         yield* TRPCAnyRouter,
             createContext:  (yield* TRPCUnknownContextCreator).createExpressContext,
         })
     )

src/TRPC/TRPCWebSocketServer.ts

@@ -1,10 +1,18 @@
-import type { AnyRouter } from "@trpc/server"
 import type { applyWSSHandler } from "@trpc/server/adapters/ws"
 import { Config, Context, Effect, Layer } from "effect"
 import type ws from "ws"
 import { ExpressNodeHTTPServer } from "../Express"
 import { ImportError } from "../ImportError"
 import { TRPCUnknownContextCreator } from "./TRPCContextCreator"
+import { TRPCAnyRouter } from "./TRPCRouter"
+
+
+export class TRPCWebSocketServer extends Context.Tag("@thilalib/TRPC/TRPCWebSocketServer")<TRPCWebSocketServer, TRPCWebSocketServerService>() {}
+
+export interface TRPCWebSocketServerService {
+    wss:      ws.Server
+    handler:  ReturnType<typeof applyWSSHandler>
+}
 
 
 const importWS = Effect.tryPromise({
@@ -17,57 +25,42 @@ const importTRPCServerWSAdapter = Effect.tryPromise({
     catch: cause => new ImportError({ path: "@trpc/server/adapters/ws", cause }),
 })
 
+export const TRPCWebSocketServerLive = (
+    config: {
+        readonly host: Config.Config<string>
+    }
+) => Layer.effect(TRPCWebSocketServer, Effect.gen(function*() {
+    const { WebSocketServer } = yield* importWS
+    const { applyWSSHandler } = yield* importTRPCServerWSAdapter
 
-export const make = <
+    const host = yield* config.host
-    Tag,
-    TagShape extends AnyRouter,
->(
-    routerTag: Context.TagClass<Tag, "@thilalib/TRCP/TRPCRouter", TagShape>
-) => {
-    class TRPCWebSocketServer extends Context.Tag("@thilalib/TRPC/TRPCWebSocketServer")<TRPCWebSocketServer, {
-        wss:      ws.Server
-        handler:  ReturnType<typeof applyWSSHandler<TagShape>>
-    }>() {}
 
-    const TRPCWebSocketServerLive = (
+    return yield* Effect.acquireRelease(
-        config: {
+        Effect.gen(function*() {
-            readonly host: Config.Config<string>
+            yield* Effect.logInfo(`WebSocket server started on ${ host }`)
-        }
-    ) => Layer.effect(TRPCWebSocketServer, Effect.gen(function*() {
-        const { WebSocketServer } = yield* importWS
-        const { applyWSSHandler } = yield* importTRPCServerWSAdapter
 
-        const host = yield* config.host
+            const wss = new WebSocketServer({
+                server: yield* ExpressNodeHTTPServer.ExpressNodeHTTPServer,
+                host,
+            })
 
-        return yield* Effect.acquireRelease(
+            return {
-            Effect.gen(function*() {
+                wss,
-                yield* Effect.logInfo(`WebSocket server started on ${ host }`)
+                handler: applyWSSHandler({
-
-                const wss = new WebSocketServer({
-                    server: yield* ExpressNodeHTTPServer.ExpressNodeHTTPServer,
-                    host,
-                })
-
-                return {
                     wss,
-                    handler: applyWSSHandler({
+                    router:         yield* TRPCAnyRouter,
-                        wss,
+                    createContext:  (yield* TRPCUnknownContextCreator).createWebSocketContext,
-                        router:         yield* routerTag,
+                }),
-                        createContext:  (yield* TRPCUnknownContextCreator).createWebSocketContext,
+            }
-                    }),
+        }),
-                }
-            }),
 
-            ({ wss, handler }) => Effect.gen(function*() {
+        ({ wss, handler }) => Effect.gen(function*() {
-                yield* Effect.logInfo(`WebSocket server on ${ host } is stopping. Waiting for existing connections to end...`)
+            yield* Effect.logInfo(`WebSocket server on ${ host } is stopping. Waiting for existing connections to end...`)
 
-                handler.broadcastReconnectNotification()
+            handler.broadcastReconnectNotification()
-                yield* Effect.async(resume => {
+            yield* Effect.async(resume => {
-                    wss.close(() => resume(Effect.logInfo("WebSocket server closed")))
+                wss.close(() => resume(Effect.logInfo("WebSocket server closed")))
-                })
+            })
-            }),
+        }),
-        )
+    )
-    }))
+}))
-
-    return { TRPCWebSocketServer, TRPCWebSocketServerLive }
-}

src/TRPC/example.ts

@@ -24,14 +24,11 @@ const router = TRPCBuilder.pipe(Effect.map(t => t.router({
 const { TRPCRouter, TRPCRouterLive } = TRPC.TRPCRouter.make(router)
 
 
-const { TRPCWebSocketServer, TRPCWebSocketServerLive } = TRPC.TRPCWebSocketServer.make(TRPCRouter)
-
-
 const ServerLive = Layer.empty.pipe(
-    Layer.provideMerge(TRPC.TRPCExpressRoute.TRPCExpressRouteLive(TRPCRouter, {
+    Layer.provideMerge(TRPC.TRPCExpressRoute.TRPCExpressRouteLive({
         root: Config.succeed("/rpc")
     })),
-    Layer.provideMerge(TRPCWebSocketServerLive({
+    Layer.provideMerge(TRPC.TRPCWebSocketServer.TRPCWebSocketServerLive({
         host: Config.succeed("/rpc")
     })),