Upgrade to Effect v4

packages/server/package.json

@@ -15,11 +15,9 @@
     "clean:modules": "rm -rf node_modules"
   },
   "dependencies": {
-    "@effect/opentelemetry": "^0.63.0",
-    "@effect/platform": "^0.96.1",
-    "@effect/platform-bun": "^0.89.0",
-    "@effect/platform-node": "^0.106.0",
-    "@effect/rpc": "^0.75.1",
+    "@effect/opentelemetry": "4.0.0-beta.101",
+    "@effect/platform-bun": "4.0.0-beta.101",
+    "@effect/platform-node": "4.0.0-beta.101",
     "@opentelemetry/exporter-trace-otlp-http": "^0.218.0",
     "@opentelemetry/sdk-metrics": "^2.7.1",
     "@opentelemetry/sdk-trace-base": "^2.7.1",
@@ -27,7 +25,7 @@
     "@opentelemetry/sdk-trace-web": "^2.7.1",
     "@website/common": "workspace:*",
     "@website/webapp": "workspace:*",
-    "effect": "^3.21.2"
+    "effect": "4.0.0-beta.101"
   },
   "devDependencies": {
     "@rollup/plugin-node-resolve": "^16.0.3",

packages/server/src/config/ServerConfig.ts

@@ -1,9 +1,7 @@
-import { Config, Schema } from "effect"
+import { Config } from "effect"
 
 
-export const mode = Schema.Config("NODE_ENV",
-    Schema.compose(Schema.String, Schema.Literal("development", "production"))
-).pipe(
+export const mode = Config.literals(["development", "production"], "NODE_ENV").pipe(
     Config.withDefault("development")
 )
 

packages/server/src/entrypoint.bun.ts

@@ -1,17 +1,10 @@
-import { BunContext, BunHttpServer, BunRuntime } from "@effect/platform-bun"
+import { BunHttpServer, BunRuntime } from "@effect/platform-bun"
 import { Effect, Layer } from "effect"
 import { ServerConfig } from "./config"
 import { Server } from "./server"
 
 
 Layer.launch(Server).pipe(
-    Effect.provide(Layer.empty.pipe(
-        Layer.provideMerge(ServerConfig.httpPort.pipe(
-            Effect.map(port => BunHttpServer.layer({ port })),
-            Layer.unwrapEffect,
-        )),
-        Layer.provideMerge(BunContext.layer),
-    )),
-
+    Effect.provide(BunHttpServer.layerConfig({ port: ServerConfig.httpPort })),
     BunRuntime.runMain,
 )

packages/server/src/entrypoint.node.ts

@@ -1,18 +1,11 @@
 import { createServer } from "node:http"
-import { NodeContext, NodeHttpServer, NodeRuntime } from "@effect/platform-node"
+import { NodeHttpServer, NodeRuntime } from "@effect/platform-node"
 import { Effect, Layer } from "effect"
 import { ServerConfig } from "./config"
 import { Server } from "./server"
 
 
 Layer.launch(Server).pipe(
-    Effect.provide(Layer.empty.pipe(
-        Layer.provideMerge(ServerConfig.httpPort.pipe(
-            Effect.map(port => NodeHttpServer.layer(createServer, { port })),
-            Layer.unwrapEffect,
-        )),
-        Layer.provideMerge(NodeContext.layer),
-    )),
-
+    Effect.provide(NodeHttpServer.layerConfig(createServer, { port: ServerConfig.httpPort })),
     NodeRuntime.runMain,
 )

packages/server/src/http.ts

@@ -1,56 +1,57 @@
-import { FileSystem, HttpMiddleware, HttpRouter, HttpServer, HttpServerRequest, HttpServerResponse, Path } from "@effect/platform"
-import { RpcServer } from "@effect/rpc"
 import { CommonConfig } from "@website/common/config"
 import { WebRpc, WebRpcSerializationDevelopment, WebRpcSerializationProduction } from "@website/common/webrpc"
-import { Duration, Effect, flow, Layer } from "effect"
+import { Duration, Effect, FileSystem, Layer, Path } from "effect"
+import { HttpMiddleware, HttpRouter, HttpServer, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
+import { RpcServer } from "effect/unstable/rpc"
 import { WebRpcLive } from "./webrpc"
 
 
-const router = HttpRouter.empty
-
-const makeWebRpcRoute = Effect.all([
-    CommonConfig.webRpcHttpPath,
-    RpcServer.toHttpApp(WebRpc),
-]).pipe(
-    Effect.map(([path, app]) => HttpRouter.mountApp(path, app)),
-    Effect.provide(WebRpcLive),
+const WebRpcRoute = CommonConfig.webRpcHttpPath.pipe(
+    Effect.map(path => RpcServer.layerHttp({
+        group: WebRpc,
+        path,
+        protocol: "http",
+    })),
+    Layer.unwrap,
+    Layer.provide(WebRpcLive),
 )
 
-const makeProductionWebappRoute = Effect.fnUntraced(function*(route: HttpRouter.PathInput) {
+const ProductionWebappRoute = HttpRouter.add("*", "*", Effect.gen(function*() {
     const path = yield* Path.Path
     const fs = yield* FileSystem.FileSystem
+    const request = yield* HttpServerRequest.HttpServerRequest
     const dist = path.join(yield* path.fromFileUrl(new URL(".", import.meta.resolve("@website/webapp"))), "dist")
+    const source = path.join(dist, decodeURI(new URL(request.url, "http://localhost").pathname))
+    const exists = yield* fs.stat(source).pipe(
+        Effect.map(stat => stat.type === "File"),
+        Effect.catch(() => Effect.succeed(false)),
+    )
 
-    return HttpRouter.all(route, Effect.gen(function*() {
-        const req = yield* HttpServerRequest.HttpServerRequest
-        const source = path.join(dist, decodeURI(new URL(req.url, "http://localhost").pathname))
-        const exists = yield* fs.stat(source).pipe(
-            Effect.andThen(stat => stat.type === "File"),
-            Effect.catchAll(() => Effect.succeed(false)),
-        )
-
-        return yield* HttpServerResponse.setHeader(
-            yield* HttpServerResponse.file(exists ? source : path.join(dist, "index.html")),
+    return yield* HttpServerResponse.file(exists ? source : path.join(dist, "index.html")).pipe(
+        Effect.map(HttpServerResponse.setHeader(
             "Cache-Control",
             `public, max-age=${Duration.toSeconds("6 hours")}, immutable`,
-        )
-    }))
-})
-
-
-export const HttpAppDevelopment = Layer.unwrapScoped(Effect.gen(function*() {
-    return router.pipe(
-        yield* Effect.provide(makeWebRpcRoute, WebRpcSerializationDevelopment),
-        HttpServer.serve(flow(HttpMiddleware.logger, HttpMiddleware.xForwardedHeaders)),
-        HttpServer.withLogAddress,
+        )),
     )
 }))
 
-export const HttpAppProduction = Layer.unwrapScoped(Effect.gen(function*() {
-    return router.pipe(
-        yield* Effect.provide(makeWebRpcRoute, WebRpcSerializationProduction),
-        yield* makeProductionWebappRoute("*"),
-        HttpServer.serve(HttpMiddleware.xForwardedHeaders),
-        HttpServer.withLogAddress,
-    )
-}))
+
+export const HttpAppDevelopment = WebRpcRoute.pipe(
+    Layer.provide(WebRpcSerializationDevelopment),
+    HttpRouter.toHttpEffect,
+    Effect.map(app => HttpServer.withLogAddress(HttpServer.serve(
+        HttpMiddleware.xForwardedHeaders(HttpMiddleware.logger(app)),
+    ))),
+    Layer.unwrap,
+)
+
+export const HttpAppProduction = Layer.mergeAll(
+    WebRpcRoute.pipe(Layer.provide(WebRpcSerializationProduction)),
+    ProductionWebappRoute,
+).pipe(
+    HttpRouter.toHttpEffect,
+    Effect.map(app => HttpServer.withLogAddress(HttpServer.serve(
+        HttpMiddleware.xForwardedHeaders(app),
+    ))),
+    Layer.unwrap,
+)

packages/server/src/server.ts

@@ -26,6 +26,6 @@ export const Server = ServerConfig.mode.pipe(
         Match.exhaustive,
     )),
 
-    Layer.unwrapEffect,
-    Layer.provideMerge(Logger.pretty),
+    Layer.unwrap,
+    Layer.provideMerge(Logger.layer([Logger.consolePretty()])),
 )