effect-start 0.9.0 → 0.11.0

package/src/TestHttpClient.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import * as HttpApp from "@effect/platform/HttpApp"
 import * as HttpClient from "@effect/platform/HttpClient"
 import * as HttpClientError from "@effect/platform/HttpClientError"
@@ -7,15 +6,38 @@ import * as HttpClientResponse from "@effect/platform/HttpClientResponse"
 import { RouteNotFound } from "@effect/platform/HttpServerError"
 import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
 import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
+import * as UrlParams from "@effect/platform/UrlParams"
 import * as Effect from "effect/Effect"
+import * as Either from "effect/Either"
 import * as Function from "effect/Function"
 import * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 
 const WebHeaders = globalThis.Headers
 
-export const make = <E = any, R = any>(
-  httpApp: HttpApp.Default<E, R>,
+export type FetchHandler = (req: Request) => Response | Promise<Response>
+
+export const isFetchHandler = (
+  app: unknown,
+): app is FetchHandler => typeof app === "function" && !Effect.isEffect(app)
+
+const fromFetchHandler = (
+  handler: FetchHandler,
+): HttpApp.Default<never, never> =>
+  Effect.gen(function*() {
+    const serverRequest = yield* HttpServerRequest.HttpServerRequest
+    const webRequest = serverRequest.source as Request
+    const response = yield* Effect.promise(async () => handler(webRequest))
+    const body = yield* Effect.promise(() => response.arrayBuffer())
+    return HttpServerResponse.raw(new Uint8Array(body), {
+      status: response.status,
+      statusText: response.statusText,
+      headers: Object.fromEntries(response.headers.entries()),
+    })
+  })
+
+export const make = <E, R>(
+  appOrHandler: HttpApp.Default<E, R> | FetchHandler,
   opts?: {
     baseUrl?: string | null
     handleRouteNotFound?: (
@@ -24,77 +46,104 @@ export const make = <E = any, R = any>(
   },
 ): HttpClient.HttpClient.With<
   HttpClientError.HttpClientError | E,
-  Exclude<
-    Scope.Scope | R,
-    HttpServerRequest.HttpServerRequest
-  >
-> =>
-  HttpClient
-    .make(
-      (request, url, signal) => {
-        const send = (
-          body: BodyInit | undefined,
-        ) => {
-          const app = httpApp
-          const serverRequest = HttpServerRequest.fromWeb(
-            new Request(url.toString(), {
-              method: request.method,
-              headers: new WebHeaders(request.headers),
-              body,
-              duplex: request.body._tag === "Stream" ? "half" : undefined,
-              signal,
-            } as any),
-          )
+  Exclude<R, HttpServerRequest.HttpServerRequest>
+> => {
+  const httpApp: HttpApp.Default<E, R> = isFetchHandler(appOrHandler)
+    ? fromFetchHandler(appOrHandler) as HttpApp.Default<E, R>
+    : appOrHandler
 
-          return Function.pipe(
-            app,
-            Effect.provideService(
-              HttpServerRequest.HttpServerRequest,
-              serverRequest,
-            ),
-            Effect.andThen(HttpServerResponse.toWeb),
-            Effect.andThen(res => HttpClientResponse.fromWeb(request, res)),
-            opts?.handleRouteNotFound === null
-              ? Function.identity
-              : Effect.catchTag("RouteNotFound", e =>
-                Effect
-                  .succeed(HttpClientResponse.fromWeb(
-                    e.request,
-                    new Response("Failed with RouteNotFound", {
-                      status: 404,
-                    }),
-                  ))),
-          )
-        }
+  const execute = (
+    request: HttpClientRequest.HttpClientRequest,
+  ): Effect.Effect<
+    HttpClientResponse.HttpClientResponse,
+    HttpClientError.HttpClientError | E,
+    Exclude<R, HttpServerRequest.HttpServerRequest>
+  > => {
+    const urlResult = UrlParams.makeUrl(
+      request.url,
+      request.urlParams,
+      request.hash,
+    )
+    if (Either.isLeft(urlResult)) {
+      return Effect.die(urlResult.left)
+    }
+    const url = urlResult.right
+    const controller = new AbortController()
+    const signal = controller.signal
 
-        switch (
-          request
-            .body
-            ._tag
-        ) {
-          case "Raw":
-          case "Uint8Array":
-            return send(
-              request
-                .body
-                .body as any,
-            )
-          case "FormData":
-            return send(request.body.formData)
-          case "Stream":
-            return Effect.flatMap(
-              Stream.toReadableStreamEffect(request.body.stream),
-              send,
-            )
-        }
+    const send = (
+      body: BodyInit | undefined,
+    ): Effect.Effect<
+      HttpClientResponse.HttpClientResponse,
+      E,
+      Exclude<R, HttpServerRequest.HttpServerRequest>
+    > => {
+      const serverRequest = HttpServerRequest.fromWeb(
+        new Request(url.toString(), {
+          method: request.method,
+          headers: new WebHeaders(request.headers),
+          body,
+          duplex: request.body._tag === "Stream" ? "half" : undefined,
+          signal,
+        } as RequestInit),
+      )
 
-        return send(undefined)
-      },
-    )
-    .pipe(
-      opts?.baseUrl === null
-        ? Function.identity
-        : HttpClient.mapRequest(
-          HttpClientRequest.prependUrl(opts?.baseUrl ?? "http://localhost"),
+      return Function.pipe(
+        httpApp,
+        Effect.provideService(
+          HttpServerRequest.HttpServerRequest,
+          serverRequest,
         ),
-    )
+        Effect.andThen(HttpServerResponse.toWeb),
+        Effect.andThen(res => HttpClientResponse.fromWeb(request, res)),
+        opts?.handleRouteNotFound === null
+          ? Function.identity
+          : Effect.catchAll((e) =>
+            e instanceof RouteNotFound
+              ? Effect.succeed(HttpClientResponse.fromWeb(
+                request,
+                new Response("Failed with RouteNotFound", {
+                  status: 404,
+                }),
+              ))
+              : Effect.fail(e)
+          ),
+      ) as Effect.Effect<
+        HttpClientResponse.HttpClientResponse,
+        E,
+        Exclude<R, HttpServerRequest.HttpServerRequest>
+      >
+    }
+
+    switch (request.body._tag) {
+      case "Raw":
+      case "Uint8Array":
+        return send(request.body.body as BodyInit)
+      case "FormData":
+        return send(request.body.formData)
+      case "Stream":
+        return Effect.flatMap(
+          Stream.toReadableStreamEffect(request.body.stream),
+          send,
+        )
+    }
+
+    return send(undefined)
+  }
+
+  const client = HttpClient.makeWith(
+    (requestEffect) => Effect.flatMap(requestEffect, execute),
+    (request) => Effect.succeed(request),
+  )
+
+  return client.pipe(
+    opts?.baseUrl === null
+      ? Function.identity
+      : HttpClient.mapRequest(
+        HttpClientRequest.prependUrl(opts?.baseUrl ?? "http://localhost"),
+      ),
+  ) as HttpClient.HttpClient.With<
+    HttpClientError.HttpClientError | E,
+    Exclude<R, HttpServerRequest.HttpServerRequest>
+  >
+}

package/src/assets.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Allow importing static assets as modules.
+ * Bun/Vite resolves these to file paths.
+ * For WASM you're better of
+ */
+
+declare module "*.png"
+declare module "*.gif"
+declare module "*.webp"
+declare module "*.avif"
+declare module "*.ico"
+declare module "*.bmp"
+declare module "*.tiff"
+declare module "*.svg"
+declare module "*.jpeg"
+declare module "*.jpg"
+
+declare module "*.woff"
+declare module "*.woff2"
+declare module "*.ttf"
+declare module "*.otf"
+declare module "*.eot"
+
+declare module "*.mp4"
+declare module "*.webm"
+declare module "*.ogg"
+declare module "*.mov"
+declare module "*.mp3"
+declare module "*.wav"
+declare module "*.flac"
+declare module "*.aac"
+
+declare module "*.pdf"
+declare module "*.xml"
+declare module "*.csv"
+declare module "*.txt"
+declare module "*.md"
+
+declare module "*.css"

package/src/bun/BunBundle.test.ts

@@ -1,7 +1,4 @@
-import * as BunContext from "@effect/platform-bun/BunContext"
-import * as BunHttpServer from "@effect/platform-bun/BunHttpServer"
 import * as HttpRouter from "@effect/platform/HttpRouter"
-import * as HttpServer from "@effect/platform/HttpServer"
 import * as t from "bun:test"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"

package/src/bun/BunHttpServer.test.ts

@@ -0,0 +1,74 @@
+import * as t from "bun:test"
+import * as Effect from "effect/Effect"
+import * as BunHttpServer from "./BunHttpServer.ts"
+
+t.describe("BunHttpServer smart port selection", () => {
+  // Skip when running in TTY because the random port logic requires !isTTY && CLAUDECODE,
+  // and process.stdout.isTTY cannot be mocked
+  t.test.skipIf(process.stdout.isTTY)(
+    "uses random port when PORT not set, isTTY=false, CLAUDECODE set",
+    async () => {
+      const originalPort = process.env.PORT
+      const originalClaudeCode = process.env.CLAUDECODE
+
+      try {
+        delete process.env.PORT
+        process.env.CLAUDECODE = "1"
+
+        const port = await Effect.runPromise(
+          Effect.scoped(
+            Effect.gen(function*() {
+              const bunServer = yield* BunHttpServer.make({})
+              return bunServer.server.port
+            }),
+          ),
+        )
+
+        t.expect(port).not.toBe(3000)
+      } finally {
+        if (originalPort !== undefined) {
+          process.env.PORT = originalPort
+        } else {
+          delete process.env.PORT
+        }
+        if (originalClaudeCode !== undefined) {
+          process.env.CLAUDECODE = originalClaudeCode
+        } else {
+          delete process.env.CLAUDECODE
+        }
+      }
+    },
+  )
+
+  t.test("uses explicit PORT even when CLAUDECODE is set", async () => {
+    const originalPort = process.env.PORT
+    const originalClaudeCode = process.env.CLAUDECODE
+
+    try {
+      process.env.PORT = "5678"
+      process.env.CLAUDECODE = "1"
+
+      const port = await Effect.runPromise(
+        Effect.scoped(
+          Effect.gen(function*() {
+            const bunServer = yield* BunHttpServer.make({})
+            return bunServer.server.port
+          }),
+        ),
+      )
+
+      t.expect(port).toBe(5678)
+    } finally {
+      if (originalPort !== undefined) {
+        process.env.PORT = originalPort
+      } else {
+        delete process.env.PORT
+      }
+      if (originalClaudeCode !== undefined) {
+        process.env.CLAUDECODE = originalClaudeCode
+      } else {
+        delete process.env.CLAUDECODE
+      }
+    }
+  })
+})

package/src/bun/BunHttpServer.ts

@@ -0,0 +1,259 @@
+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", () => {
+        if (
+          typeof process !== "undefined"
+          && !process.stdout.isTTY
+          && process.env.CLAUDECODE
+        ) {
+          return Effect.succeed(0)
+        }
+
+        return 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 routerContext = yield* Effect.serviceOption(Router.Router)
+
+      if (Option.isSome(routerContext)) {
+        const router = yield* Router.fromManifest(routerContext.value)
+        const bunRoutes = yield* BunRoute.routesFromRouter(router)
+        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)
+}