RPC work

packages/common/src/webrpc/WebRpcSerialization.ts

@@ -0,0 +1,5 @@
+import { RpcSerialization } from "@effect/rpc"
+
+
+export const WebRpcSerializationDevelopment = RpcSerialization.layerJson
+export const WebRpcSerializationProduction = RpcSerialization.layerNdjson

packages/common/src/webrpc/index.ts

@@ -1,2 +1,3 @@
 export * as WebRpc from "./WebRpc"
+export * as WebRpcSerialization from "./WebRpcSerialization"
 export * as WebRpcTest from "./WebRpcTest"

packages/server/package.json

@@ -6,6 +6,7 @@
   "dependencies": {
     "@effect/platform": "^0.90.8",
     "@effect/platform-bun": "^0.79.0",
+    "@effect/rpc": "^0.69.2",
     "@website/common": "workspace:*",
     "effect": "^3.17.13"
   }

packages/server/src/entrypoint.bun.ts

@@ -5,10 +5,13 @@ import { Server } from "./server"
 
 
 Layer.launch(Server).pipe(
-    Effect.provide(ServerConfig.httpPort.pipe(
-        Effect.map(port => BunHttpServer.layer({ port })),
-        Layer.unwrapEffect,
+    Effect.provide(Layer.empty.pipe(
+        Layer.provideMerge(ServerConfig.httpPort.pipe(
+            Effect.map(port => BunHttpServer.layer({ port })),
+            Layer.unwrapEffect,
+        )),
+        Layer.provideMerge(BunContext.layer),
     )),
-    Effect.provide(BunContext.layer),
+
     BunRuntime.runMain,
 )

packages/server/src/http.ts

@@ -1,39 +1,66 @@
 import { FileSystem, HttpMiddleware, HttpRouter, HttpServer, HttpServerRequest, HttpServerResponse, Path } from "@effect/platform"
-import { Duration, Effect, flow } from "effect"
+import { RpcServer } from "@effect/rpc"
+import { CommonConfig } from "@website/common/config"
+import { WebRpc, WebRpcSerialization } from "@website/common/webrpc"
+import { Duration, Effect, flow, Layer } from "effect"
+import { WebRpcLive } from "./webrpc"
 
 
 const router = HttpRouter.empty
 
-export const HttpAppDevelopment = router.pipe(
-    HttpServer.serve(flow(
-        HttpMiddleware.logger,
-        HttpMiddleware.xForwardedHeaders,
-    )),
-    HttpServer.withLogAddress,
+const makeWebRpcRoute = Effect.all([
+    CommonConfig.webRpcHttpPath,
+    RpcServer.toHttpApp(WebRpc.WebRpc),
+]).pipe(
+    Effect.map(([path, app]) => HttpRouter.mountApp(path, app)),
+    Effect.provide(WebRpcLive.WebRpcLive),
 )
 
-
-const serveProductionWebapp = HttpMiddleware.make(() => Effect.gen(function*() {
+const makeProductionWebappMiddleware = Effect.gen(function*() {
     const path = yield* Path.Path
     const fs = yield* FileSystem.FileSystem
-    const req = yield* HttpServerRequest.HttpServerRequest
-
     const dist = path.join(yield* path.fromFileUrl(new URL(".", import.meta.resolve("@website/webapp"))), "dist")
-    const source = path.join(dist, req.url)
-    const isValid = yield* fs.stat(source).pipe(
-        Effect.andThen(stat => stat.type === "File"),
-        Effect.catchAll(() => Effect.succeed(false)),
-    )
 
-    return yield* HttpServerResponse.setHeader(
-        yield* HttpServerResponse.file(isValid ? source : path.join(dist, "index.html")),
-        "Cache-Control",
-        `public, max-age=${Duration.toSeconds("365 days")}, immutable`
-    )
-}))
+    return () => Effect.gen(function*() {
+        const req = yield* HttpServerRequest.HttpServerRequest
+        const source = path.join(dist, req.url)
+        const isValid = yield* fs.stat(source).pipe(
+            Effect.andThen(stat => stat.type === "File"),
+            Effect.catchAll(() => Effect.succeed(false)),
+        )
 
-export const HttpAppProduction = router.pipe(
-    serveProductionWebapp,
-    HttpServer.serve(HttpMiddleware.xForwardedHeaders),
-    HttpServer.withLogAddress,
+        return yield* HttpServerResponse.setHeader(
+            yield* HttpServerResponse.file(isValid ? source : path.join(dist, "index.html")),
+            "Cache-Control",
+            `public, max-age=${Duration.toSeconds("365 days")}, immutable`
+        )
+    })
+})
+
+
+export const HttpAppDevelopment = Effect.provide(makeWebRpcRoute, WebRpcSerialization.WebRpcSerializationDevelopment).pipe(
+    Effect.map(serveWebRpc => router.pipe(
+        serveWebRpc,
+        HttpServer.serve(flow(
+            HttpMiddleware.logger,
+            HttpMiddleware.xForwardedHeaders,
+        )),
+        HttpServer.withLogAddress,
+    )),
+
+    Layer.unwrapScoped,
+)
+
+export const HttpAppProduction = Effect.all([
+    Effect.provide(makeWebRpcRoute, WebRpcSerialization.WebRpcSerializationProduction),
+    makeProductionWebappMiddleware,
+]).pipe(
+    Effect.map(([serveWebRpc, serveProductionWebapp]) => router.pipe(
+        serveWebRpc,
+        serveProductionWebapp,
+        HttpServer.serve(HttpMiddleware.xForwardedHeaders),
+        HttpServer.withLogAddress,
+    )),
+
+    Layer.unwrapScoped,
 )