effect-start 0.9.0 → 0.10.0

package/src/bun/BunRoute.test.ts

@@ -0,0 +1,341 @@
+import type { HTMLBundle } from "bun"
+import * as t from "bun:test"
+import * as Effect from "effect/Effect"
+import * as Route from "../Route.ts"
+import type * as Router from "../Router.ts"
+import * as BunRoute from "./BunRoute.ts"
+
+t.describe(`${BunRoute.loadBundle.name}`, () => {
+  t.test("creates BunRoute from HTMLBundle", () => {
+    const mockBundle = { index: "index.html" } as HTMLBundle
+    const bunRoute = BunRoute.loadBundle(() => Promise.resolve(mockBundle))
+
+    t.expect(BunRoute.isBunRoute(bunRoute)).toBe(true)
+    t.expect(Route.isRouteSet(bunRoute)).toBe(true)
+    t.expect(bunRoute.set).toHaveLength(1)
+    t.expect(bunRoute.method as string).toBe("GET")
+    t.expect(bunRoute.media as string).toBe("text/html")
+  })
+
+  t.test("unwraps default export", async () => {
+    const mockBundle = { index: "index.html" } as HTMLBundle
+    const bunRoute = BunRoute.loadBundle(() =>
+      Promise.resolve({ default: mockBundle })
+    )
+
+    const loaded = await bunRoute.load()
+    t.expect(loaded).toBe(mockBundle)
+  })
+
+  t.test("returns bundle directly when no default", async () => {
+    const mockBundle = { index: "index.html" } as HTMLBundle
+    const bunRoute = BunRoute.loadBundle(() => Promise.resolve(mockBundle))
+
+    const loaded = await bunRoute.load()
+    t.expect(loaded).toBe(mockBundle)
+  })
+})
+
+t.describe(`${BunRoute.isBunRoute.name}`, () => {
+  t.test("returns true for BunRoute", () => {
+    const mockBundle = { index: "index.html" } as HTMLBundle
+    const bunRoute = BunRoute.loadBundle(() => Promise.resolve(mockBundle))
+
+    t.expect(BunRoute.isBunRoute(bunRoute)).toBe(true)
+  })
+
+  t.test("returns false for regular Route", () => {
+    const route = Route.text(Effect.succeed("hello"))
+
+    t.expect(BunRoute.isBunRoute(route)).toBe(false)
+  })
+
+  t.test("returns false for non-route values", () => {
+    t.expect(BunRoute.isBunRoute(null)).toBe(false)
+    t.expect(BunRoute.isBunRoute(undefined)).toBe(false)
+    t.expect(BunRoute.isBunRoute({})).toBe(false)
+    t.expect(BunRoute.isBunRoute("string")).toBe(false)
+  })
+})
+
+t.describe(`${BunRoute.routesFromRouter.name}`, () => {
+  t.test("converts text route to fetch handler", async () => {
+    const fetch = await makeFetch(
+      makeRouter([
+        { path: "/hello", routes: Route.text(Effect.succeed("Hello World")) },
+      ]),
+    )
+
+    const response = await fetch("/hello")
+
+    t.expect(response.status).toBe(200)
+    t.expect(await response.text()).toBe("Hello World")
+  })
+
+  t.test("converts json route to fetch handler", async () => {
+    const fetch = await makeFetch(
+      makeRouter([
+        {
+          path: "/api/data",
+          routes: Route.json(Effect.succeed({ message: "ok", count: 42 })),
+        },
+      ]),
+    )
+
+    const response = await fetch("/api/data")
+
+    t.expect(response.status).toBe(200)
+    t.expect(await response.json()).toEqual({ message: "ok", count: 42 })
+  })
+
+  t.test("converts html route to fetch handler", async () => {
+    const fetch = await makeFetch(
+      makeRouter([
+        { path: "/page", routes: Route.html(Effect.succeed("<h1>Title</h1>")) },
+      ]),
+    )
+
+    const response = await fetch("/page")
+
+    t.expect(response.status).toBe(200)
+    t.expect(await response.text()).toBe("<h1>Title</h1>")
+  })
+
+  t.test("handles method-specific routes", async () => {
+    const fetch = await makeFetch(
+      makeRouter([
+        {
+          path: "/users",
+          routes: Route.get(Route.json(Effect.succeed({ users: [] }))).post(
+            Route.json(Effect.succeed({ created: true })),
+          ),
+        },
+      ]),
+    )
+
+    const getResponse = await fetch("/users")
+    t.expect(await getResponse.json()).toEqual({ users: [] })
+
+    const postResponse = await fetch("/users", { method: "POST" })
+    t.expect(await postResponse.json()).toEqual({ created: true })
+  })
+
+  t.test("converts path syntax to Bun format", async () => {
+    const routes = await Effect.runPromise(
+      BunRoute.routesFromRouter(
+        makeRouter([
+          { path: "/users/[id]", routes: Route.text(Effect.succeed("user")) },
+          {
+            path: "/docs/[...path]",
+            routes: Route.text(Effect.succeed("docs")),
+          },
+        ]),
+      ),
+    )
+
+    t.expect(routes["/users/:id"]).toBeDefined()
+    t.expect(routes["/docs/*"]).toBeDefined()
+    t.expect(routes["/users/[id]"]).toBeUndefined()
+    t.expect(routes["/docs/[...path]"]).toBeUndefined()
+  })
+
+  t.test("creates proxy and internal routes for BunRoute", async () => {
+    const mockBundle = { index: "index.html" } as HTMLBundle
+    const bunRoute = BunRoute.loadBundle(() => Promise.resolve(mockBundle))
+
+    const routes = await Effect.runPromise(
+      BunRoute.routesFromRouter(
+        makeRouter([{ path: "/app", routes: bunRoute }]),
+      ),
+    )
+
+    const internalPath = Object.keys(routes).find((k) =>
+      k.includes("~BunRoute-")
+    )
+    t.expect(internalPath).toBeDefined()
+    t.expect(routes[internalPath!]).toBe(mockBundle)
+    t.expect(typeof routes["/app"]).toBe("function")
+  })
+
+  t.test("handles mixed BunRoute and regular routes", async () => {
+    const mockBundle = { index: "index.html" } as HTMLBundle
+    const bunRoute = BunRoute.loadBundle(() => Promise.resolve(mockBundle))
+
+    const routes = await Effect.runPromise(
+      BunRoute.routesFromRouter({
+        routes: [
+          {
+            path: "/app",
+            load: () => Promise.resolve({ default: bunRoute }),
+          },
+          {
+            path: "/api/health",
+            load: () =>
+              Promise.resolve({
+                default: Route.json(Effect.succeed({ ok: true })),
+              }),
+          },
+        ],
+      }),
+    )
+
+    const internalPath = Object.keys(routes).find((k) =>
+      k.includes("~BunRoute-")
+    )
+    t.expect(internalPath).toBeDefined()
+    t.expect(routes[internalPath!]).toBe(mockBundle)
+    t.expect(typeof routes["/app"]).toBe("function")
+    t.expect(routes["/api/health"]).toBeDefined()
+    t.expect(typeof routes["/api/health"]).toBe("object")
+  })
+
+  t.test("groups multiple methods under same path", async () => {
+    const fetch = await makeFetch(
+      makeRouter([
+        {
+          path: "/resource",
+          routes: Route
+            .get(Route.text(Effect.succeed("get")))
+            .post(Route.text(Effect.succeed("post")))
+            .del(Route.text(Effect.succeed("delete"))),
+        },
+      ]),
+    )
+
+    const getRes = await fetch("/resource")
+    const postRes = await fetch("/resource", { method: "POST" })
+    const delRes = await fetch("/resource", { method: "DELETE" })
+
+    t.expect(await getRes.text()).toBe("get")
+    t.expect(await postRes.text()).toBe("post")
+    t.expect(await delRes.text()).toBe("delete")
+  })
+})
+
+t.describe("fetch handler Response", () => {
+  t.test("returns Response instance", async () => {
+    const fetch = await makeFetch(
+      makeRouter([{
+        path: "/test",
+        routes: Route.text(Effect.succeed("test")),
+      }]),
+    )
+
+    const response = await fetch("/test")
+
+    t.expect(response).toBeInstanceOf(Response)
+  })
+
+  t.test("text response has correct content-type", async () => {
+    const fetch = await makeFetch(
+      makeRouter([{
+        path: "/text",
+        routes: Route.text(Effect.succeed("hello")),
+      }]),
+    )
+
+    const response = await fetch("/text")
+
+    t.expect(response.headers.get("content-type")).toContain("text/plain")
+  })
+
+  t.test("json response has correct content-type", async () => {
+    const fetch = await makeFetch(
+      makeRouter([{
+        path: "/json",
+        routes: Route.json(Effect.succeed({ data: 1 })),
+      }]),
+    )
+
+    const response = await fetch("/json")
+
+    t.expect(response.headers.get("content-type")).toContain("application/json")
+  })
+
+  t.test("html response has correct content-type", async () => {
+    const fetch = await makeFetch(
+      makeRouter([{
+        path: "/html",
+        routes: Route.html(Effect.succeed("<p>hi</p>")),
+      }]),
+    )
+
+    const response = await fetch("/html")
+
+    t.expect(response.headers.get("content-type")).toContain("text/html")
+  })
+
+  t.test("response body is readable", async () => {
+    const fetch = await makeFetch(
+      makeRouter([{
+        path: "/body",
+        routes: Route.text(Effect.succeed("readable body")),
+      }]),
+    )
+
+    const response = await fetch("/body")
+
+    t.expect(response.bodyUsed).toBe(false)
+    const text = await response.text()
+    t.expect(text).toBe("readable body")
+    t.expect(response.bodyUsed).toBe(true)
+  })
+
+  t.test("response ok is true for 200 status", async () => {
+    const fetch = await makeFetch(
+      makeRouter([{ path: "/ok", routes: Route.text(Effect.succeed("ok")) }]),
+    )
+
+    const response = await fetch("/ok")
+
+    t.expect(response.ok).toBe(true)
+    t.expect(response.status).toBe(200)
+  })
+})
+
+const makeRouter = (
+  routesList: Array<{
+    path: `/${string}`
+    routes: Route.RouteSet.Default
+  }>,
+): Router.RouterContext => ({
+  routes: routesList.map((m) => ({
+    path: m.path,
+    load: () => Promise.resolve({ default: m.routes }),
+  })),
+})
+
+type FetchFn = (path: string, init?: { method?: string }) => Promise<Response>
+
+type HandlerFn = (
+  req: Request,
+  server: unknown,
+) => Response | Promise<Response>
+
+async function makeFetch(router: Router.RouterContext): Promise<FetchFn> {
+  const routes = await Effect.runPromise(BunRoute.routesFromRouter(router))
+  const mockServer = {} as import("bun").Server<unknown>
+
+  return async (path, init) => {
+    const method = init?.method ?? "GET"
+    const handler = routes[path]
+
+    if (!handler) {
+      throw new Error(`No handler for path: ${path}`)
+    }
+
+    if (typeof handler === "function") {
+      return handler(new Request(`http://localhost${path}`, init), mockServer)
+    }
+
+    const methodHandler = (handler as Record<string, HandlerFn>)[method]
+    if (!methodHandler) {
+      throw new Error(`No handler for ${method} ${path}`)
+    }
+
+    return methodHandler(
+      new Request(`http://localhost${path}`, init),
+      mockServer,
+    )
+  }
+}

package/src/bun/BunRoute.ts

@@ -0,0 +1,326 @@
+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 Effect from "effect/Effect"
+
+import * as Function from "effect/Function"
+import * as Predicate from "effect/Predicate"
+import type * as Runtime from "effect/Runtime"
+import * as HttpUtils from "../HttpUtils.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"
+
+const TypeId: unique symbol = Symbol.for("effect-start/BunRoute")
+
+export type BunRoute =
+  & Route.Route
+  & {
+    [TypeId]: typeof TypeId
+    load: () => Promise<Bun.HTMLBundle>
+  }
+
+export function loadBundle(
+  load: () => Promise<Bun.HTMLBundle | { default: Bun.HTMLBundle }>,
+): BunRoute {
+  const route = Route.make({
+    method: "GET",
+    media: "text/html",
+    handler: () => HttpServerResponse.text("Empty BunRoute"),
+    schemas: {},
+  })
+
+  const bunRoute: BunRoute = Object.assign(
+    Object.create(route),
+    {
+      [TypeId]: TypeId,
+      load: () => load().then(mod => "default" in mod ? mod.default : mod),
+    },
+  )
+
+  bunRoute.set = [bunRoute]
+
+  return bunRoute
+}
+
+export function isBunRoute(input: unknown): input is BunRoute {
+  return Predicate.hasProperty(input, TypeId)
+}
+
+function findMatchingLayerRoutes(
+  route: Route.Route.Default,
+  layers: Route.RouteLayer[],
+): Route.Route.Default[] {
+  const matchingRoutes: Route.Route.Default[] = []
+  for (const layer of layers) {
+    for (const layerRoute of layer.set) {
+      if (Route.matches(layerRoute, route)) {
+        matchingRoutes.push(layerRoute)
+      }
+    }
+  }
+  return matchingRoutes
+}
+
+function wrapWithLayerRoute(
+  innerRoute: Route.Route.Default,
+  layerRoute: Route.Route.Default,
+): Route.Route.Default {
+  const handler: Route.RouteHandler = (context) => {
+    const innerNext = () => innerRoute.handler(context)
+
+    const contextWithNext: Route.RouteContext = {
+      ...context,
+      next: innerNext,
+    }
+
+    return layerRoute.handler(contextWithNext)
+  }
+
+  return Route.make({
+    method: layerRoute.method,
+    media: layerRoute.media,
+    handler,
+    schemas: {},
+  })
+}
+
+/**
+ * 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.toHttpPath(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)
+}
+
+/**
+ * Converts a Router 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.RouterContext,
+  runtime?: Runtime.Runtime<never>,
+): Effect.Effect<BunRoutes> {
+  return Effect.gen(function*() {
+    const rt = runtime ?? (yield* Effect.runtime<never>())
+    const nonce = Random.token(6)
+
+    const loadedRoutes = yield* Effect.forEach(
+      router.routes,
+      (mod) =>
+        Effect.gen(function*() {
+          const routeModule = yield* Effect.promise(() => mod.load())
+
+          const layerModules = mod.layers
+            ? yield* Effect.forEach(
+              mod.layers,
+              (layerLoad) => Effect.promise(() => layerLoad()),
+            )
+            : []
+
+          const layers = layerModules
+            .map((m: any) => m.default)
+            .filter(Route.isRouteLayer)
+
+          return {
+            path: mod.path,
+            exported: routeModule.default,
+            layers,
+          }
+        }),
+    )
+
+    const result: BunRoutes = {}
+
+    for (const { path, exported, layers } of loadedRoutes) {
+      const httpPaths = RouterPattern.toBun(path)
+
+      const byMethod = new Map<Route.RouteMethod, Route.Route.Default[]>()
+      for (const route of exported.set) {
+        if (isBunRoute(route)) {
+          const bundle = yield* Effect.promise(() => route.load())
+          const internalPath = `${path}~BunRoute-${nonce}`
+
+          result[internalPath] = bundle
+
+          const proxyHandler: BunServerFetchHandler = (request) => {
+            const url = new URL(internalPath, request.url)
+            return fetch(new Request(url, request))
+          }
+
+          for (const httpPath of httpPaths) {
+            if (!(httpPath in result)) {
+              result[httpPath] = proxyHandler
+            }
+          }
+        } else {
+          const existing = byMethod.get(route.method) ?? []
+          existing.push(route)
+          byMethod.set(route.method, existing)
+        }
+      }
+
+      for (const [method, routes] of byMethod) {
+        const httpApp = 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 matchingLayerRoutes = findMatchingLayerRoutes(
+            selectedRoute,
+            layers,
+          )
+          let wrappedRoute = selectedRoute
+          for (const layerRoute of matchingLayerRoutes.reverse()) {
+            wrappedRoute = wrapWithLayerRoute(wrappedRoute, layerRoute)
+          }
+
+          const context: Route.RouteContext = {
+            request,
+            get url() {
+              return HttpUtils.makeUrlFromRequest(request)
+            },
+            slots: {},
+            next: () => Effect.void,
+          }
+
+          return yield* RouteRender.render(wrappedRoute, context)
+        })
+
+        const allMiddleware = layers
+          .map((layer) => layer.httpMiddleware)
+          .filter((m): m is Route.HttpMiddlewareFunction => m !== undefined)
+
+        let finalHandler = httpApp
+        for (const middleware of allMiddleware) {
+          finalHandler = middleware(finalHandler)
+        }
+
+        const webHandler = HttpApp.toWebHandlerRuntime(rt)(finalHandler)
+        const handler: BunServerFetchHandler = (request) => 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")
+  )
+}