effect-start 0.9.0 → 0.11.0

package/src/bun/BunRoute.ts

@@ -0,0 +1,427 @@
+import * as HttpApp from "@effect/platform/HttpApp"
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
+import type * as Bun from "bun"
+import * as Array from "effect/Array"
+import * as Effect from "effect/Effect"
+import * as Function from "effect/Function"
+import * as Option from "effect/Option"
+import * as Predicate from "effect/Predicate"
+import type * as Runtime from "effect/Runtime"
+import * as HttpAppExtra from "../HttpAppExtra.ts"
+import * as HttpUtils from "../HttpUtils.ts"
+import * as HyperHtml from "../HyperHtml.ts"
+import * as Random from "../Random.ts"
+import * as Route from "../Route.ts"
+import * as Router from "../Router.ts"
+import * as RouteRender from "../RouteRender.ts"
+import * as RouterPattern from "../RouterPattern.ts"
+import * as BunHttpServer from "./BunHttpServer.ts"
+
+const TypeId: unique symbol = Symbol.for("effect-start/BunRoute")
+
+const INTERNAL_FETCH_HEADER = "x-effect-start-internal-fetch"
+
+export type BunRoute =
+  & Route.Route
+  & {
+    [TypeId]: typeof TypeId
+    // Prefix because Bun.serve routes ignore everything after `*` in wildcard patterns.
+    // A suffix like `/*~internal` would match the same as `/*`, shadowing the internal route.
+    internalPathPrefix: string
+    load: () => Promise<Bun.HTMLBundle>
+  }
+
+export function html(
+  load: () => Promise<Bun.HTMLBundle | { default: Bun.HTMLBundle }>,
+): BunRoute {
+  const internalPathPrefix = `/.BunRoute-${Random.token(6)}`
+
+  const handler: Route.RouteHandler<
+    HttpServerResponse.HttpServerResponse,
+    Router.RouterError,
+    BunHttpServer.BunServer
+  > = (context) =>
+    Effect.gen(function*() {
+      const originalRequest = context.request.source as Request
+
+      if (
+        originalRequest.headers.get(INTERNAL_FETCH_HEADER) === "true"
+      ) {
+        return yield* Effect.fail(
+          new Router.RouterError({
+            reason: "ProxyError",
+            pattern: context.url.pathname,
+            message:
+              "Request to internal Bun server was caught by BunRoute handler. This should not happen. Please report a bug.",
+          }),
+        )
+      }
+
+      const bunServer = yield* BunHttpServer.BunServer
+      const internalPath = `${internalPathPrefix}${context.url.pathname}`
+      const internalUrl = new URL(internalPath, bunServer.server.url)
+
+      const headers = new Headers(originalRequest.headers)
+      headers.set(INTERNAL_FETCH_HEADER, "true")
+
+      const proxyRequest = new Request(internalUrl, {
+        method: originalRequest.method,
+        headers,
+      })
+
+      const response = yield* Effect.tryPromise({
+        try: () => fetch(proxyRequest),
+        catch: (error) =>
+          new Router.RouterError({
+            reason: "ProxyError",
+            pattern: internalPath,
+            message: `Failed to fetch internal HTML bundle: ${String(error)}`,
+          }),
+      })
+
+      let html = yield* Effect.tryPromise({
+        try: () => response.text(),
+        catch: (error) =>
+          new Router.RouterError({
+            reason: "ProxyError",
+            pattern: internalPath,
+            message: String(error),
+          }),
+      })
+
+      const children = yield* context.next<Router.RouterError, never>()
+      let childrenHtml = ""
+      if (children != null) {
+        if (HttpServerResponse.isServerResponse(children)) {
+          const webResponse = HttpServerResponse.toWeb(children)
+          childrenHtml = yield* Effect.promise(() => webResponse.text())
+        } else if (Route.isGenericJsxObject(children)) {
+          childrenHtml = HyperHtml.renderToString(children)
+        } else {
+          childrenHtml = String(children)
+        }
+      }
+
+      html = html.replace(/%yield%/g, childrenHtml)
+      html = html.replace(/%slots\.(\w+)%/g, (_, name) =>
+        context.slots[name] ?? "")
+
+      return HttpServerResponse
+        .html(html)
+    })
+
+  const route = Route.make({
+    method: "*",
+    media: "text/html",
+    handler,
+    schemas: {},
+  })
+
+  const bunRoute: BunRoute = Object.assign(
+    Object.create(route),
+    {
+      [TypeId]: TypeId,
+      internalPathPrefix,
+      load: () => load().then(mod => "default" in mod ? mod.default : mod),
+      set: [],
+    },
+  )
+
+  bunRoute.set.push(bunRoute)
+
+  return bunRoute
+}
+
+export function isBunRoute(input: unknown): input is BunRoute {
+  return Predicate.hasProperty(input, TypeId)
+}
+
+function makeHandler(routes: Route.Route.Default[]) {
+  return Effect.gen(function*() {
+    const request = yield* HttpServerRequest.HttpServerRequest
+    const accept = request.headers.accept ?? ""
+
+    let selectedRoute: Route.Route.Default | undefined
+
+    if (accept.includes("application/json")) {
+      selectedRoute = routes.find((r) => r.media === "application/json")
+    }
+    if (!selectedRoute && accept.includes("text/plain")) {
+      selectedRoute = routes.find((r) => r.media === "text/plain")
+    }
+    if (
+      !selectedRoute
+      && (accept.includes("text/html")
+        || accept.includes("*/*")
+        || !accept)
+    ) {
+      selectedRoute = routes.find((r) => r.media === "text/html")
+    }
+    if (!selectedRoute) {
+      selectedRoute = routes[0]
+    }
+
+    if (!selectedRoute) {
+      return HttpServerResponse.empty({ status: 406 })
+    }
+
+    const context: Route.RouteContext = {
+      request,
+      get url() {
+        return HttpUtils.makeUrlFromRequest(request)
+      },
+      slots: {},
+      next: () => Effect.void,
+    }
+
+    return yield* RouteRender.render(selectedRoute, context).pipe(
+      Effect.catchAllCause((cause) => HttpAppExtra.renderError(cause, accept)),
+    )
+  })
+}
+
+/**
+ * Finds BunRoutes in the Router and returns
+ * a mapping of paths to their bundles that can be passed
+ * to Bun's `serve` function.
+ */
+export function bundlesFromRouter(
+  router: Router.RouterContext,
+): Effect.Effect<Record<string, Bun.HTMLBundle>> {
+  return Function.pipe(
+    Effect.forEach(
+      router.routes,
+      (mod) =>
+        Effect.promise(() =>
+          mod.load().then((m) => ({ path: mod.path, exported: m.default }))
+        ),
+    ),
+    Effect.map((modules) =>
+      modules.flatMap(({ path, exported }) => {
+        if (Route.isRouteSet(exported)) {
+          return [...exported.set]
+            .filter(isBunRoute)
+            .map((route) =>
+              [
+                path,
+                route,
+              ] as const
+            )
+        }
+
+        return []
+      })
+    ),
+    Effect.flatMap((bunRoutes) =>
+      Effect.forEach(
+        bunRoutes,
+        ([path, route]) =>
+          Effect.promise(() =>
+            route.load().then((bundle) => {
+              const httpPath = RouterPattern.toBun(path)
+
+              return [
+                httpPath,
+                bundle,
+              ] as const
+            })
+          ),
+        { concurrency: "unbounded" },
+      )
+    ),
+    Effect.map((entries) =>
+      Object.fromEntries(entries) as Record<string, Bun.HTMLBundle>
+    ),
+  )
+}
+
+type BunServerFetchHandler = (
+  request: Request,
+  server: Bun.Server<unknown>,
+) => Response | Promise<Response>
+
+type BunServerRouteHandler =
+  | Bun.HTMLBundle
+  | BunServerFetchHandler
+  | Partial<Record<Bun.Serve.HTTPMethod, BunServerFetchHandler>>
+
+export type BunRoutes = Record<string, BunServerRouteHandler>
+
+type MethodHandlers = Partial<
+  Record<Bun.Serve.HTTPMethod, BunServerFetchHandler>
+>
+
+function isMethodHandlers(value: unknown): value is MethodHandlers {
+  return typeof value === "object" && value !== null && !("index" in value)
+}
+
+/**
+ * Validates that a route pattern can be implemented with Bun.serve routes.
+ *
+ * Supported patterns (native or via multiple routes):
+ * - /exact        - Exact match
+ * - /users/:id    - Full-segment named param
+ * - /path/*       - Directory wildcard
+ * - /*            - Catch-all
+ * - /[[id]]       - Optional param (implemented via `/` and `/:id`)
+ * - /[[...rest]]  - Optional rest param (implemented via `/` and `/*`)
+ *
+ * Unsupported patterns (cannot be implemented in Bun):
+ * - /pk_[id]   - Prefix before param
+ * - /[id]_sfx  - Suffix after param
+ * - /[id].json - Suffix with dot
+ * - /[id]~test - Suffix with tilde
+ * - /hello-*   - Inline prefix wildcard
+ */
+
+export function validateBunPattern(
+  pattern: string,
+): Option.Option<Router.RouterError> {
+  const segments = RouterPattern.parse(pattern)
+
+  const unsupported = Array.findFirst(segments, (seg) => {
+    if (seg._tag === "ParamSegment") {
+      return seg.prefix !== undefined || seg.suffix !== undefined
+    }
+
+    return false
+  })
+
+  if (Option.isSome(unsupported)) {
+    return Option.some(
+      new Router.RouterError({
+        reason: "UnsupportedPattern",
+        pattern,
+        message:
+          `Pattern "${pattern}" uses prefixed/suffixed params (prefix_[param] or [param]_suffix) `
+          + `which cannot be implemented in Bun.serve.`,
+      }),
+    )
+  }
+
+  return Option.none()
+}
+
+/**
+ * Converts a RouterBuilder into Bun-compatible routes passed to {@link Bun.serve}.
+ *
+ * For BunRoutes (HtmlBundle), creates two routes:
+ * - An internal route at `${path}~BunRoute-${nonce}:${path}` holding the actual HtmlBundle
+ * - A proxy route at the original path that forwards requests to the internal route
+ *
+ * This allows middleware to be attached to the proxy route while Bun handles
+ * the HtmlBundle natively on the internal route.
+ */
+export function routesFromRouter(
+  router: Router.RouterBuilder.Any,
+  runtime?: Runtime.Runtime<BunHttpServer.BunServer>,
+): Effect.Effect<BunRoutes, Router.RouterError, BunHttpServer.BunServer> {
+  return Effect.gen(function*() {
+    const rt = runtime ?? (yield* Effect.runtime<BunHttpServer.BunServer>())
+    const result: BunRoutes = {}
+
+    for (const entry of router.entries) {
+      const { path, route: routeSet, layers } = entry
+
+      const validationError = validateBunPattern(path)
+      if (Option.isSome(validationError)) {
+        return yield* Effect.fail(validationError.value)
+      }
+
+      for (const route of routeSet.set) {
+        if (isBunRoute(route)) {
+          const bundle = yield* Effect.promise(() => route.load())
+          const bunPaths = RouterPattern.toBun(path)
+          for (const bunPath of bunPaths) {
+            const internalPath = `${route.internalPathPrefix}${bunPath}`
+            result[internalPath] = bundle
+          }
+        }
+      }
+
+      for (const layer of layers) {
+        for (const route of layer.set) {
+          if (isBunRoute(route)) {
+            const bundle = yield* Effect.promise(() => route.load())
+            const bunPaths = RouterPattern.toBun(path)
+            for (const bunPath of bunPaths) {
+              const internalPath = `${route.internalPathPrefix}${bunPath}`
+              result[internalPath] = bundle
+            }
+          }
+        }
+      }
+    }
+
+    for (const path of Object.keys(router.mounts)) {
+      const routeSet = router.mounts[path]
+
+      const validationError = validateBunPattern(path)
+      if (Option.isSome(validationError)) {
+        continue
+      }
+
+      const httpPaths = RouterPattern.toBun(path as Route.RoutePattern)
+
+      const byMethod = new Map<Route.RouteMethod, Route.Route.Default[]>()
+      for (const route of routeSet.set) {
+        const existing = byMethod.get(route.method) ?? []
+        existing.push(route)
+        byMethod.set(route.method, existing)
+      }
+
+      const entry = router.entries.find((e) => e.path === path)
+      const allMiddleware = (entry?.layers ?? [])
+        .map((layer) => layer.httpMiddleware)
+        .filter((m): m is Route.HttpMiddlewareFunction => m !== undefined)
+
+      for (const [method, routes] of byMethod) {
+        let httpApp: HttpApp.Default<any, any> = makeHandler(routes)
+
+        for (const middleware of allMiddleware) {
+          httpApp = middleware(httpApp)
+        }
+
+        const webHandler = HttpApp.toWebHandlerRuntime(rt)(httpApp)
+        const handler: BunServerFetchHandler = (request) => {
+          const url = new URL(request.url)
+          if (url.pathname.startsWith("/.BunRoute-")) {
+            return new Response(
+              "Internal routing error: BunRoute internal path was not matched. "
+                + "This indicates the HTMLBundle route was not registered. Please report a bug.",
+              { status: 500 },
+            )
+          }
+          return webHandler(request)
+        }
+
+        for (const httpPath of httpPaths) {
+          if (method === "*") {
+            if (!(httpPath in result)) {
+              result[httpPath] = handler
+            }
+          } else {
+            const existing = result[httpPath]
+            if (isMethodHandlers(existing)) {
+              existing[method] = handler
+            } else if (!(httpPath in result)) {
+              result[httpPath] = { [method]: handler }
+            }
+          }
+        }
+      }
+    }
+
+    return result
+  })
+}
+
+export const isHTMLBundle = (handle: any) => {
+  return (
+    typeof handle === "object"
+    && handle !== null
+    && (handle.toString() === "[object HTMLBundle]"
+      || typeof handle.index === "string")
+  )
+}

package/src/bun/BunRoute_bundles.test.ts

@@ -0,0 +1,218 @@
+import * as t from "bun:test"
+import * as Effect from "effect/Effect"
+import * as Route from "../Route.ts"
+import * as Router from "../Router.ts"
+import * as TestHttpClient from "../TestHttpClient.ts"
+import * as BunHttpServer from "./BunHttpServer.ts"
+import * as BunRoute from "./BunRoute.ts"
+
+t.describe("BunRoute proxy with Bun.serve", () => {
+  t.test("BunRoute proxy returns same content as direct bundle access", async () => {
+    const bunRoute = BunRoute.html(() => import("../../static/TestPage.html"))
+
+    const router = Router.mount("/test", bunRoute)
+
+    await Effect.runPromise(
+      Effect
+        .gen(function*() {
+          const bunServer = yield* BunHttpServer.BunServer
+          const routes = yield* BunRoute.routesFromRouter(router)
+          bunServer.addRoutes(routes)
+
+          const internalPath = Object.keys(routes).find((k) =>
+            k.includes(".BunRoute-")
+
+          )
+          t.expect(internalPath).toBeDefined()
+
+          const proxyHandler = routes["/test"]
+          t.expect(typeof proxyHandler).toBe("function")
+
+          const internalBundle = routes[internalPath!]
+          t.expect(internalBundle).toHaveProperty("index")
+
+          const baseUrl =
+            `http://${bunServer.server.hostname}:${bunServer.server.port}`
+          const client = TestHttpClient.make<never, never>(
+            (req) => fetch(req),
+            {
+              baseUrl,
+            },
+          )
+
+          const directResponse = yield* client.get(internalPath!)
+          const proxyResponse = yield* client.get("/test")
+
+          t.expect(proxyResponse.status).toBe(directResponse.status)
+
+          const directText = yield* directResponse.text
+          const proxyText = yield* proxyResponse.text
+
+          t.expect(proxyText).toBe(directText)
+          t.expect(proxyText).toContain("Test Page Content")
+        })
+        .pipe(
+          Effect.scoped,
+          Effect.provide(BunHttpServer.layer({ port: 0 })),
+        ),
+    )
+  })
+
+  t.test("multiple BunRoutes each get unique internal paths", async () => {
+    const bunRoute1 = BunRoute.html(() => import("../../static/TestPage.html"))
+    const bunRoute2 = BunRoute.html(() =>
+      import("../../static/AnotherPage.html")
+    )
+
+    const router = Router
+      .mount("/page1", bunRoute1)
+      .mount("/page2", bunRoute2)
+
+    await Effect.runPromise(
+      Effect
+        .gen(function*() {
+          const bunServer = yield* BunHttpServer.BunServer
+          const routes = yield* BunRoute.routesFromRouter(router)
+          bunServer.addRoutes(routes)
+
+          const internalPaths = Object.keys(routes).filter((k) =>
+            k.includes(".BunRoute-")
+          )
+          t.expect(internalPaths).toHaveLength(2)
+
+          const nonces = internalPaths.map((p) => {
+            const match = p.match(/\.BunRoute-([a-z0-9]+)/)
+            return match?.[1]
+          })
+          t.expect(nonces[0]).not.toBe(nonces[1])
+
+          const baseUrl =
+            `http://${bunServer.server.hostname}:${bunServer.server.port}`
+          const client = TestHttpClient.make<never, never>(
+            (req) => fetch(req),
+            {
+              baseUrl,
+            },
+          )
+
+          const response1 = yield* client.get("/page1")
+          const response2 = yield* client.get("/page2")
+
+          const text1 = yield* response1.text
+          const text2 = yield* response2.text
+
+          t.expect(text1).toContain("Test Page Content")
+          t.expect(text2).toContain("Another Page Content")
+        })
+        .pipe(
+          Effect.scoped,
+          Effect.provide(BunHttpServer.layer({ port: 0 })),
+        ),
+    )
+  })
+
+  t.test("proxy preserves request headers", async () => {
+    const bunRoute = BunRoute.html(() => import("../../static/TestPage.html"))
+
+    const router = Router.mount("/headers-test", bunRoute)
+
+    await Effect.runPromise(
+      Effect
+        .gen(function*() {
+          const bunServer = yield* BunHttpServer.BunServer
+          const routes = yield* BunRoute.routesFromRouter(router)
+          bunServer.addRoutes(routes)
+
+          const baseUrl =
+            `http://${bunServer.server.hostname}:${bunServer.server.port}`
+          const client = TestHttpClient.make<never, never>(
+            (req) => fetch(req),
+            {
+              baseUrl,
+            },
+          )
+
+          const response = yield* client.get("/headers-test", {
+            headers: {
+              "Accept": "text/html",
+              "X-Custom-Header": "test-value",
+            },
+          })
+
+          t.expect(response.status).toBe(200)
+          const text = yield* response.text
+          t.expect(text).toContain("Test Page Content")
+        })
+        .pipe(
+          Effect.scoped,
+          Effect.provide(BunHttpServer.layer({ port: 0 })),
+        ),
+    )
+  })
+
+  t.test("mixed BunRoute and regular routes work together", async () => {
+    const bunRoute = BunRoute.html(() => import("../../static/TestPage.html"))
+
+    const router = Router
+      .mount("/html", bunRoute)
+      .mount("/api", Route.text("Hello from text route"))
+
+    await Effect.runPromise(
+      Effect
+        .gen(function*() {
+          const bunServer = yield* BunHttpServer.BunServer
+          const routes = yield* BunRoute.routesFromRouter(router)
+          bunServer.addRoutes(routes)
+
+          const baseUrl =
+            `http://${bunServer.server.hostname}:${bunServer.server.port}`
+          const client = TestHttpClient.make<never, never>(
+            (req) => fetch(req),
+            {
+              baseUrl,
+            },
+          )
+
+          const htmlResponse = yield* client.get("/html")
+          const apiResponse = yield* client.get("/api")
+
+          const htmlText = yield* htmlResponse.text
+          const apiText = yield* apiResponse.text
+
+          t.expect(htmlText).toContain("Test Page Content")
+          t.expect(apiText).toBe("Hello from text route")
+        })
+        .pipe(
+          Effect.scoped,
+          Effect.provide(BunHttpServer.layer({ port: 0 })),
+        ),
+    )
+  })
+
+  t.test("nonce is different across separate BunRoute instances", async () => {
+    const bunRoute1 = BunRoute.html(() => import("../../static/TestPage.html"))
+    const bunRoute2 = BunRoute.html(() => import("../../static/TestPage.html"))
+
+    const router = Router
+      .mount("/test1", bunRoute1)
+      .mount("/test2", bunRoute2)
+
+    await Effect.runPromise(
+      Effect
+        .gen(function*() {
+          const routes = yield* BunRoute.routesFromRouter(router)
+
+          const internalPaths = Object.keys(routes).filter((k) =>
+            k.includes(".BunRoute-")
+          )
+
+          t.expect(internalPaths).toHaveLength(2)
+          t.expect(internalPaths[0]).not.toBe(internalPaths[1])
+        })
+        .pipe(
+          Effect.scoped,
+          Effect.provide(BunHttpServer.layer({ port: 0 })),
+        ),
+    )
+  })
+})

package/src/bun/BunRuntime.ts

@@ -0,0 +1,33 @@
+import { makeRunMain } from "@effect/platform/Runtime"
+import { constVoid } from "effect/Function"
+
+export const runMain = makeRunMain(({
+  fiber,
+  teardown,
+}) => {
+  const keepAlive = setInterval(constVoid, 2 ** 31 - 1)
+  let receivedSignal = false
+
+  fiber.addObserver((exit) => {
+    if (!receivedSignal) {
+      process.removeListener("SIGINT", onSigint)
+      process.removeListener("SIGTERM", onSigint)
+    }
+    clearInterval(keepAlive)
+    teardown(exit, (code) => {
+      if (receivedSignal || code !== 0) {
+        process.exit(code)
+      }
+    })
+  })
+
+  function onSigint() {
+    receivedSignal = true
+    process.removeListener("SIGINT", onSigint)
+    process.removeListener("SIGTERM", onSigint)
+    fiber.unsafeInterruptAsFork(fiber.id())
+  }
+
+  process.on("SIGINT", onSigint)
+  process.on("SIGTERM", onSigint)
+})

package/src/bun/BunTailwindPlugin.test.ts

@@ -17,7 +17,7 @@ function extractClassNamesBroad(source: string): Set<string> {
   )
 }
 
-t.describe("extractClassNames", () => {
+t.describe(`${extractClassNames.name}`, () => {
   t.test("Basic HTML class attributes", () => {
     const source = `<div class="bg-red-500 text-white">Hello</div>`
     const result = extractClassNames(source)

package/src/bun/_empty.html

@@ -0,0 +1 @@
+

package/src/bun/index.ts

@@ -1,4 +1,5 @@
 export * as BunBundle from "./BunBundle.ts"
-export * as BunFullstackServer from "./BunFullstackServer.ts"
+export * as BunHttpServer from "./BunHttpServer.ts"
 export * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.ts"
+export * as BunRoute from "./BunRoute.ts"
 export * as BunTailwindPlugin from "./BunTailwindPlugin.ts"