effect-start 0.9.0 → 0.10.0

package/src/bun/BunHttpServer.ts

@@ -0,0 +1,246 @@
+import * as HttpApp from "@effect/platform/HttpApp"
+import * as HttpServer from "@effect/platform/HttpServer"
+import * as HttpServerError from "@effect/platform/HttpServerError"
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
+import * as Socket from "@effect/platform/Socket"
+import * as Bun from "bun"
+import * as Config from "effect/Config"
+import * as Context from "effect/Context"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as FiberSet from "effect/FiberSet"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import type * as Scope from "effect/Scope"
+import * as Random from "../Random.ts"
+import * as Router from "../Router.ts"
+import EmptyHTML from "./_empty.html"
+import {
+  makeResponse,
+  ServerRequestImpl,
+  WebSocketContext,
+} from "./BunHttpServer_web.ts"
+import * as BunRoute from "./BunRoute.ts"
+
+type FetchHandler = (
+  request: Request,
+  server: Bun.Server<WebSocketContext>,
+) => Response | Promise<Response>
+
+/**
+ * Basically `Omit<Bun.Serve.Options, "fetch" | "error" | "websocket">`
+ * TypeScript 5.9 cannot verify discriminated union types used in
+ * {@link Bun.serve} so we need to define them explicitly.
+ */
+interface ServeOptions {
+  readonly port?: number
+  readonly hostname?: string
+  readonly reusePort?: boolean
+  readonly ipv6Only?: boolean
+  readonly idleTimeout?: number
+  readonly development?: boolean
+}
+
+export type BunServer = {
+  readonly server: Bun.Server<WebSocketContext>
+  readonly addRoutes: (routes: BunRoute.BunRoutes) => void
+  // TODO: we probably don't want to expose these methods publicly
+  readonly pushHandler: (fetch: FetchHandler) => void
+  readonly popHandler: () => void
+}
+
+export const BunServer = Context.GenericTag<BunServer>(
+  "effect-start/BunServer",
+)
+
+export const make = (
+  options: ServeOptions,
+): Effect.Effect<
+  BunServer,
+  never,
+  Scope.Scope
+> =>
+  Effect.gen(function*() {
+    const port = yield* Config.number("PORT").pipe(
+      Effect.catchTag("ConfigError", () => Effect.succeed(3000)),
+    )
+    const hostname = yield* Config.string("HOSTNAME").pipe(
+      Effect.catchTag("ConfigError", () => Effect.succeed(undefined)),
+    )
+
+    const handlerStack: Array<FetchHandler> = [
+      function(_request, _server) {
+        return new Response("not found", { status: 404 })
+      },
+    ]
+
+    let currentRoutes: BunRoute.BunRoutes = {}
+
+    // Bun HMR doesn't work on successive calls to `server.reload` if there are no routes
+    // on server start. We workaround that by passing a dummy HTMLBundle [2025-11-26]
+    // see: https://github.com/oven-sh/bun/issues/23564
+    currentRoutes[`/.BunEmptyHtml-${Random.token(6)}`] = EmptyHTML
+
+    const websocket: Bun.WebSocketHandler<WebSocketContext> = {
+      open(ws) {
+        Deferred.unsafeDone(ws.data.deferred, Exit.succeed(ws))
+      },
+      message(ws, message) {
+        ws.data.run(message)
+      },
+      close(ws, code, closeReason) {
+        Deferred.unsafeDone(
+          ws.data.closeDeferred,
+          Socket.defaultCloseCodeIsError(code)
+            ? Exit.fail(
+              new Socket.SocketCloseError({
+                reason: "Close",
+                code,
+                closeReason,
+              }),
+            )
+            : Exit.void,
+        )
+      },
+    }
+
+    const server = Bun.serve({
+      port,
+      hostname,
+      ...options,
+      routes: currentRoutes,
+      fetch: handlerStack[0],
+      websocket,
+    })
+
+    yield* Effect.addFinalizer(() =>
+      Effect.sync(() => {
+        server.stop()
+      })
+    )
+
+    const reload = () => {
+      server.reload({
+        fetch: handlerStack[handlerStack.length - 1],
+        routes: currentRoutes,
+        websocket,
+      })
+    }
+
+    return BunServer.of({
+      server,
+      pushHandler(fetch) {
+        handlerStack.push(fetch)
+        reload()
+      },
+      popHandler() {
+        handlerStack.pop()
+        reload()
+      },
+      addRoutes(routes) {
+        currentRoutes = {
+          ...currentRoutes,
+          ...routes,
+        }
+        reload()
+      },
+    })
+  })
+
+export const layer = (
+  options?: ServeOptions,
+): Layer.Layer<BunServer> => Layer.scoped(BunServer, make(options ?? {}))
+
+export const makeHttpServer: Effect.Effect<
+  HttpServer.HttpServer,
+  never,
+  Scope.Scope | BunServer
+> = Effect.gen(function*() {
+  const bunServer = yield* BunServer
+
+  return HttpServer.make({
+    address: {
+      _tag: "TcpAddress",
+      port: bunServer.server.port!,
+      hostname: bunServer.server.hostname!,
+    },
+    serve(httpApp, middleware) {
+      return Effect.gen(function*() {
+        const runFork = yield* FiberSet.makeRuntime<never>()
+        const runtime = yield* Effect.runtime<never>()
+        const app = HttpApp.toHandled(
+          httpApp,
+          (request, response) =>
+            Effect.sync(() => {
+              ;(request as ServerRequestImpl).resolve(
+                makeResponse(request, response, runtime),
+              )
+            }),
+          middleware,
+        )
+
+        function handler(
+          request: Request,
+          server: Bun.Server<WebSocketContext>,
+        ) {
+          return new Promise<Response>((resolve, _reject) => {
+            const fiber = runFork(Effect.provideService(
+              app,
+              HttpServerRequest.HttpServerRequest,
+              new ServerRequestImpl(
+                request,
+                resolve,
+                removeHost(request.url),
+                server,
+              ),
+            ))
+            request.signal.addEventListener("abort", () => {
+              runFork(
+                fiber.interruptAsFork(HttpServerError.clientAbortFiberId),
+              )
+            }, { once: true })
+          })
+        }
+
+        yield* Effect.acquireRelease(
+          Effect.sync(() => {
+            bunServer.pushHandler(handler)
+          }),
+          () =>
+            Effect.sync(() => {
+              bunServer.popHandler()
+            }),
+        )
+      })
+    },
+  })
+})
+
+export const layerServer = (
+  options?: ServeOptions,
+): Layer.Layer<HttpServer.HttpServer | BunServer> =>
+  Layer.provideMerge(
+    Layer.scoped(HttpServer.HttpServer, makeHttpServer),
+    layer(options ?? {}),
+  )
+
+export function layerRoutes() {
+  return Layer.effectDiscard(Effect.gen(function*() {
+    const bunServer = yield* BunServer
+    const router = yield* Effect.serviceOption(Router.Router)
+
+    if (Option.isSome(router)) {
+      const bunRoutes = yield* BunRoute.routesFromRouter(router.value)
+      bunServer.addRoutes(bunRoutes)
+    }
+  }))
+}
+
+const removeHost = (url: string) => {
+  if (url[0] === "/") {
+    return url
+  }
+  const index = url.indexOf("/", url.indexOf("//") + 2)
+  return index === -1 ? "/" : url.slice(index)
+}

package/src/bun/BunHttpServer_web.ts

@@ -0,0 +1,384 @@
+import * as Cookies from "@effect/platform/Cookies"
+import type * as FileSystem from "@effect/platform/FileSystem"
+import * as Headers from "@effect/platform/Headers"
+import * as HttpApp from "@effect/platform/HttpApp"
+import * as HttpIncomingMessage from "@effect/platform/HttpIncomingMessage"
+import type { HttpMethod } from "@effect/platform/HttpMethod"
+import * as HttpServerError from "@effect/platform/HttpServerError"
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
+import type * as Multipart from "@effect/platform/Multipart"
+import type * as Path from "@effect/platform/Path"
+import * as Socket from "@effect/platform/Socket"
+import * as UrlParams from "@effect/platform/UrlParams"
+import type {
+  Server as BunServerInstance,
+  ServerWebSocket,
+} from "bun"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as FiberSet from "effect/FiberSet"
+import * as Inspectable from "effect/Inspectable"
+import * as Option from "effect/Option"
+import type { ReadonlyRecord } from "effect/Record"
+import * as Runtime from "effect/Runtime"
+import type * as Scope from "effect/Scope"
+import * as Stream from "effect/Stream"
+
+export interface WebSocketContext {
+  readonly deferred: Deferred.Deferred<ServerWebSocket<WebSocketContext>>
+  readonly closeDeferred: Deferred.Deferred<void, Socket.SocketError>
+  readonly buffer: Array<Uint8Array | string>
+  run: (_: Uint8Array | string) => void
+}
+
+export class ServerRequestImpl extends Inspectable.Class
+  implements HttpServerRequest.HttpServerRequest
+{
+  readonly [HttpServerRequest.TypeId]: HttpServerRequest.TypeId
+  readonly [HttpIncomingMessage.TypeId]: HttpIncomingMessage.TypeId
+
+  constructor(
+    readonly source: Request,
+    public resolve: (response: Response) => void,
+    readonly url: string,
+    private bunServer: BunServerInstance<WebSocketContext>,
+    public headersOverride?: Headers.Headers,
+    private remoteAddressOverride?: string,
+  ) {
+    super()
+    this[HttpServerRequest.TypeId] = HttpServerRequest.TypeId
+    this[HttpIncomingMessage.TypeId] = HttpIncomingMessage.TypeId
+  }
+
+  toJSON(): unknown {
+    return HttpIncomingMessage.inspect(this, {
+      _id: "@effect/platform/HttpServerRequest",
+      method: this.method,
+      url: this.originalUrl,
+    })
+  }
+
+  modify(
+    options: {
+      readonly url?: string | undefined
+      readonly headers?: Headers.Headers | undefined
+      readonly remoteAddress?: string | undefined
+    },
+  ) {
+    return new ServerRequestImpl(
+      this.source,
+      this.resolve,
+      options.url ?? this.url,
+      this.bunServer,
+      options.headers ?? this.headersOverride,
+      options.remoteAddress ?? this.remoteAddressOverride,
+    )
+  }
+
+  get method(): HttpMethod {
+    return this.source.method.toUpperCase() as HttpMethod
+  }
+
+  get originalUrl() {
+    return this.source.url
+  }
+
+  get remoteAddress(): Option.Option<string> {
+    return this.remoteAddressOverride
+      ? Option.some(this.remoteAddressOverride)
+      : Option.fromNullable(this.bunServer.requestIP(this.source)?.address)
+  }
+
+  get headers(): Headers.Headers {
+    this.headersOverride ??= Headers.fromInput(this.source.headers)
+    return this.headersOverride
+  }
+
+  private cachedCookies: ReadonlyRecord<string, string> | undefined
+  get cookies() {
+    if (this.cachedCookies) {
+      return this.cachedCookies
+    }
+    return this.cachedCookies = Cookies.parseHeader(this.headers.cookie ?? "")
+  }
+
+  get stream(): Stream.Stream<Uint8Array, HttpServerError.RequestError> {
+    return this.source.body
+      ? Stream.fromReadableStream(
+        () => this.source.body as ReadableStream<Uint8Array>,
+        (cause) =>
+          new HttpServerError.RequestError({
+            request: this,
+            reason: "Decode",
+            cause,
+          }),
+      )
+      : Stream.fail(
+        new HttpServerError.RequestError({
+          request: this,
+          reason: "Decode",
+          description: "can not create stream from empty body",
+        }),
+      )
+  }
+
+  private textEffect:
+    | Effect.Effect<string, HttpServerError.RequestError>
+    | undefined
+
+  get text(): Effect.Effect<string, HttpServerError.RequestError> {
+    if (this.textEffect) {
+      return this.textEffect
+    }
+    this.textEffect = Effect.runSync(Effect.cached(
+      Effect.tryPromise({
+        try: () => this.source.text(),
+        catch: (cause) =>
+          new HttpServerError.RequestError({
+            request: this,
+            reason: "Decode",
+            cause,
+          }),
+      }),
+    ))
+    return this.textEffect
+  }
+
+  get json(): Effect.Effect<unknown, HttpServerError.RequestError> {
+    return Effect.tryMap(this.text, {
+      try: (_) => JSON.parse(_) as unknown,
+      catch: (cause) =>
+        new HttpServerError.RequestError({
+          request: this,
+          reason: "Decode",
+          cause,
+        }),
+    })
+  }
+
+  get urlParamsBody(): Effect.Effect<
+    UrlParams.UrlParams,
+    HttpServerError.RequestError
+  > {
+    return Effect.flatMap(this.text, (_) =>
+      Effect.try({
+        try: () => UrlParams.fromInput(new URLSearchParams(_)),
+        catch: (cause) =>
+          new HttpServerError.RequestError({
+            request: this,
+            reason: "Decode",
+            cause,
+          }),
+      }))
+  }
+
+  private multipartEffect:
+    | Effect.Effect<
+      Multipart.Persisted,
+      Multipart.MultipartError,
+      Scope.Scope | FileSystem.FileSystem | Path.Path
+    >
+    | undefined
+
+  get multipart(): Effect.Effect<
+    Multipart.Persisted,
+    Multipart.MultipartError,
+    Scope.Scope | FileSystem.FileSystem | Path.Path
+  > {
+    if (this.multipartEffect) {
+      return this.multipartEffect
+    }
+    this.multipartEffect = Effect.runSync(Effect.cached(
+      Effect.die("Multipart not implemented"),
+    ))
+    return this.multipartEffect
+  }
+
+  get multipartStream(): Stream.Stream<
+    Multipart.Part,
+    Multipart.MultipartError
+  > {
+    return Stream.die("Multipart stream not implemented")
+  }
+
+  private arrayBufferEffect:
+    | Effect.Effect<ArrayBuffer, HttpServerError.RequestError>
+    | undefined
+  get arrayBuffer(): Effect.Effect<ArrayBuffer, HttpServerError.RequestError> {
+    if (this.arrayBufferEffect) {
+      return this.arrayBufferEffect
+    }
+    this.arrayBufferEffect = Effect.runSync(Effect.cached(
+      Effect.tryPromise({
+        try: () => this.source.arrayBuffer(),
+        catch: (cause) =>
+          new HttpServerError.RequestError({
+            request: this,
+            reason: "Decode",
+            cause,
+          }),
+      }),
+    ))
+    return this.arrayBufferEffect
+  }
+
+  get upgrade(): Effect.Effect<Socket.Socket, HttpServerError.RequestError> {
+    return Effect.flatMap(
+      Effect.all([
+        Deferred.make<ServerWebSocket<WebSocketContext>>(),
+        Deferred.make<void, Socket.SocketError>(),
+        Effect.makeSemaphore(1),
+      ]),
+      ([deferred, closeDeferred, semaphore]) =>
+        Effect.async<Socket.Socket, HttpServerError.RequestError>((resume) => {
+          const success = this.bunServer.upgrade(
+            this.source,
+            {
+              data: {
+                deferred,
+                closeDeferred,
+                buffer: [],
+                run: wsDefaultRun,
+              },
+            },
+          )
+          if (!success) {
+            resume(Effect.fail(
+              new HttpServerError.RequestError({
+                request: this,
+                reason: "Decode",
+                description: "Not an upgradeable ServerRequest",
+              }),
+            ))
+            return
+          }
+          resume(Effect.map(Deferred.await(deferred), (ws) => {
+            const write = (chunk: Uint8Array | string | Socket.CloseEvent) =>
+              Effect.sync(() => {
+                if (typeof chunk === "string") {
+                  ws.sendText(chunk)
+                } else if (Socket.isCloseEvent(chunk)) {
+                  ws.close(chunk.code, chunk.reason)
+                } else {
+                  ws.sendBinary(chunk)
+                }
+
+                return true
+              })
+            const writer = Effect.succeed(write)
+            const runRaw = Effect.fnUntraced(
+              function*<RR, EE, _>(
+                handler: (
+                  _: Uint8Array | string,
+                ) => Effect.Effect<_, EE, RR> | void,
+                opts?: { readonly onOpen?: Effect.Effect<void> | undefined },
+              ) {
+                const set = yield* FiberSet.make<unknown, EE>()
+                const run = yield* FiberSet.runtime(set)<RR>()
+                function runRawInner(data: Uint8Array | string) {
+                  const result = handler(data)
+                  if (Effect.isEffect(result)) {
+                    run(result)
+                  }
+                }
+                ws.data.run = runRawInner
+                ws.data.buffer.forEach(runRawInner)
+                ws.data.buffer.length = 0
+                if (opts?.onOpen) yield* opts.onOpen
+                return yield* FiberSet.join(set)
+              },
+              Effect.scoped,
+              Effect.onExit((exit) => {
+                ws.close(exit._tag === "Success" ? 1000 : 1011)
+                return Effect.void
+              }),
+              Effect.raceFirst(Deferred.await(closeDeferred)),
+              semaphore.withPermits(1),
+            )
+
+            const encoder = new TextEncoder()
+            const run = <RR, EE, _>(
+              handler: (_: Uint8Array) => Effect.Effect<_, EE, RR> | void,
+              opts?: {
+                readonly onOpen?: Effect.Effect<void> | undefined
+              },
+            ) =>
+              runRaw(
+                (data) =>
+                  typeof data === "string"
+                    ? handler(encoder.encode(data))
+                    : handler(data),
+                opts,
+              )
+
+            return Socket.Socket.of({
+              [Socket.TypeId]: Socket.TypeId,
+              run,
+              runRaw,
+              writer,
+            })
+          }))
+        }),
+    )
+  }
+}
+
+function wsDefaultRun(this: WebSocketContext, _: Uint8Array | string) {
+  this.buffer.push(_)
+}
+
+export function makeResponse(
+  request: HttpServerRequest.HttpServerRequest,
+  response: HttpServerResponse.HttpServerResponse,
+  runtime: Runtime.Runtime<never>,
+): Response {
+  const fields: {
+    headers: globalThis.Headers
+    status?: number
+    statusText?: string
+  } = {
+    headers: new globalThis.Headers(response.headers),
+    status: response.status,
+  }
+
+  if (!Cookies.isEmpty(response.cookies)) {
+    for (const header of Cookies.toSetCookieHeaders(response.cookies)) {
+      fields.headers.append("set-cookie", header)
+    }
+  }
+
+  if (response.statusText !== undefined) {
+    fields.statusText = response.statusText
+  }
+
+  if (request.method === "HEAD") {
+    return new Response(undefined, fields)
+  }
+  const ejectedResponse = HttpApp.unsafeEjectStreamScope(response)
+  const body = ejectedResponse.body
+  switch (body._tag) {
+    case "Empty": {
+      return new Response(undefined, fields)
+    }
+    case "Uint8Array":
+    case "Raw": {
+      if (body.body instanceof Response) {
+        for (const [key, value] of fields.headers.entries()) {
+          body.body.headers.set(key, value)
+        }
+        return body.body
+      }
+      return new Response(body.body as BodyInit, fields)
+    }
+    case "FormData": {
+      return new Response(body.formData as FormData, fields)
+    }
+    case "Stream": {
+      return new Response(
+        Stream.toReadableStreamRuntime(body.stream, runtime),
+        fields,
+      )
+    }
+  }
+}