effect-start 0.14.0 → 0.16.0

package/src/bun/BunRoute.ts

@@ -1,187 +1,169 @@
-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 Data from "effect/Data"
 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 Entity from "../Entity.ts"
+import * as Hyper from "../hyper/Hyper.ts"
+import * as HyperHtml from "../hyper/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.BunHttpServer
-  > = (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.BunHttpServer
-
-      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: [],
-    },
-  )
+export class BunRouteError extends Data.TaggedError("BunRouteError")<{
+  reason: "ProxyError" | "UnsupportedPattern"
+  pattern: string
+  message: string
+}> {}
 
-  bunRoute.set.push(bunRoute)
-
-  return bunRoute
+export type BunDescriptors = {
+  bunPrefix: string
+  bunLoad: () => Promise<Bun.HTMLBundle>
 }
 
-export function isBunRoute(input: unknown): input is BunRoute {
-  return Predicate.hasProperty(input, TypeId)
+export function descriptors(
+  route: Route.Route.Route,
+): BunDescriptors | undefined {
+  const descriptor = Route.descriptor(route) as Partial<BunDescriptors>
+  if (
+    typeof descriptor.bunPrefix === "string"
+    && typeof descriptor.bunLoad === "function"
+  ) {
+    return descriptor as BunDescriptors
+  }
+  return undefined
 }
 
-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
+export function htmlBundle(
+  load: () => Promise<Bun.HTMLBundle | { default: Bun.HTMLBundle }>,
+) {
+  const bunPrefix = `/.BunRoute-${Random.token(6)}`
+  const bunLoad = () => load().then(mod => "default" in mod ? mod.default : mod)
+  const descriptors = { bunPrefix, bunLoad, format: "html" as const }
+
+  return function<
+    D extends Route.RouteDescriptor.Any,
+    B extends {},
+    I extends Route.Route.Tuple,
+  >(
+    self: Route.RouteSet.RouteSet<D, B, I>,
+  ): Route.RouteSet.RouteSet<
+    D,
+    B,
+    [
+      ...I,
+      Route.Route.Route<
+        BunDescriptors & { format: "html" },
+        { request: Request },
+        string,
+        BunRouteError,
+        BunHttpServer.BunHttpServer
+      >,
+    ]
+  > {
+    const handler: Route.Route.Handler<
+      BunDescriptors & { format: "html" } & { request: Request },
+      string,
+      BunRouteError,
+      BunHttpServer.BunHttpServer
+    > = (context, next) =>
+      Effect.gen(function*() {
+        const originalRequest = context.request
+
+        if (
+          originalRequest.headers.get(INTERNAL_FETCH_HEADER) === "true"
+        ) {
+          const url = new URL(originalRequest.url)
+          return yield* Effect.fail(
+            new BunRouteError({
+              reason: "ProxyError",
+              pattern: url.pathname,
+              message:
+                "Request to internal Bun server was caught by BunRoute handler. This should not happen. Please report a bug.",
+            }),
+          )
+        }
 
-    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]
-    }
+        const bunServer = yield* BunHttpServer.BunHttpServer
+        const url = new URL(originalRequest.url)
+
+        const internalPath = `${bunPrefix}${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 BunRouteError({
+              reason: "ProxyError",
+              pattern: internalPath,
+              message: `Failed to fetch internal HTML bundle: ${String(error)}`,
+            }),
+        })
+
+        let html = yield* Effect.tryPromise({
+          try: () => response.text(),
+          catch: (error) =>
+            new BunRouteError({
+              reason: "ProxyError",
+              pattern: internalPath,
+              message: String(error),
+            }),
+        })
+
+        const childEntity = yield* Entity.resolve(next(context))
+        const children = childEntity?.body ?? childEntity
+
+        let childrenHtml = ""
+        if (children != null) {
+          if ((children as unknown) instanceof Response) {
+            childrenHtml = yield* Effect.promise(() =>
+              (children as unknown as Response).text()
+            )
+          } else if (Hyper.isGenericJsxObject(children)) {
+            childrenHtml = HyperHtml.renderToString(children)
+          } else {
+            childrenHtml = String(children)
+          }
+        }
 
-    if (!selectedRoute) {
-      return HttpServerResponse.empty({ status: 406 })
-    }
+        html = html.replace(/%children%/g, childrenHtml)
 
-    const context: Route.RouteContext = {
-      request,
-      get url() {
-        return HttpUtils.makeUrlFromRequest(request)
-      },
-      slots: {},
-      next: () => Effect.void,
-    }
+        return Entity.make(html, {
+          status: response.status,
+          headers: {
+            "content-type": response.headers.get("content-type"),
+          },
+        })
+      })
 
-    return yield* RouteRender.render(selectedRoute, context).pipe(
-      Effect.catchAllCause((cause) => HttpAppExtra.renderError(cause, accept)),
+    const route = Route.make<
+      BunDescriptors & { format: "html" },
+      { request: Request },
+      string,
+      BunRouteError,
+      BunHttpServer.BunHttpServer
+    >(handler, descriptors)
+
+    return Route.set(
+      [...Route.items(self), route] as any,
+      Route.descriptor(self),
     )
-  })
+  }
 }
 
+
+
 type BunServerFetchHandler = (
   request: Request,
   server: Bun.Server<unknown>,
@@ -194,14 +176,6 @@ type BunServerRouteHandler =
 
 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.
  *
@@ -223,7 +197,7 @@ function isMethodHandlers(value: unknown): value is MethodHandlers {
 
 export function validateBunPattern(
   pattern: string,
-): Option.Option<Router.RouterError> {
+): Option.Option<BunRouteError> {
   const segments = RouterPattern.parse(pattern)
 
   const unsupported = Array.findFirst(segments, (seg) => {
@@ -236,7 +210,7 @@ export function validateBunPattern(
 
   if (Option.isSome(unsupported)) {
     return Option.some(
-      new Router.RouterError({
+      new BunRouteError({
         reason: "UnsupportedPattern",
         pattern,
         message:
@@ -249,121 +223,7 @@ export function validateBunPattern(
   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.Router.Any,
-  runtime?: Runtime.Runtime<BunHttpServer.BunHttpServer>,
-): Effect.Effect<BunRoutes, Router.RouterError, BunHttpServer.BunHttpServer> {
-  return Effect.gen(function*() {
-    const rt = runtime ?? (yield* Effect.runtime<BunHttpServer.BunHttpServer>())
-    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) => {
+export const isHtmlBundle = (handle: any) => {
   return (
     typeof handle === "object"
     && handle !== null

package/src/{BundleHttp.test.ts → bundler/BundleHttp.test.ts}

@@ -1,14 +1,14 @@
 import * as HttpRouter from "@effect/platform/HttpRouter"
 import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
-import * as t from "bun:test"
+import * as test from "bun:test"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
-import IndexHtml from "../static/react-dashboard.html" with { type: "file" }
-import * as BunBundle from "./bun/BunBundle.ts"
+import IndexHtml from "../../static/react-dashboard.html" with { type: "file" }
+import * as BunBundle from "../bun/BunBundle.ts"
+import { effectFn } from "../testing"
+import * as TestHttpClient from "../testing/TestHttpClient.ts"
 import * as Bundle from "./Bundle.ts"
 import * as BundleHttp from "./BundleHttp.ts"
-import { effectFn } from "./testing"
-import * as TestHttpClient from "./testing/TestHttpClient.ts"
 
 const effect = effectFn(
   Layer.effect(
@@ -17,7 +17,7 @@ const effect = effectFn(
   ),
 )
 
-t.it("entrypoint with specific uri", () =>
+test.it("entrypoint with specific uri", () =>
   effect(function*() {
     const App = HttpRouter.empty.pipe(
       HttpRouter.get(
@@ -28,19 +28,15 @@ t.it("entrypoint with specific uri", () =>
     const Client = TestHttpClient.make(App)
 
     const dashboardRes = yield* Client.get("/react-dashboard")
-    t
-      .expect(
-        dashboardRes.status,
-      )
+    test
+      .expect(dashboardRes.status)
       .toBe(200)
-    t
-      .expect(
-        yield* dashboardRes.text,
-      )
+    test
+      .expect(yield* dashboardRes.text)
       .toStartWith("<!DOCTYPE html>")
   }))
 
-t.it("entrypoint without uri parameter", () =>
+test.it("entrypoint without uri parameter", () =>
   effect(function*() {
     const App = HttpRouter.empty.pipe(
       HttpRouter.get(
@@ -68,10 +64,8 @@ t.it("entrypoint without uri parameter", () =>
         () => HttpServerResponse.empty({ status: 404 }),
       ),
     )
-    t
-      .expect(
-        indexRes.status,
-      )
+    test
+      .expect(indexRes.status)
       .toBe(404)
 
     const indexPathRes = yield* Client.get("/index").pipe(
@@ -80,22 +74,16 @@ t.it("entrypoint without uri parameter", () =>
         () => HttpServerResponse.empty({ status: 404 }),
       ),
     )
-    t
-      .expect(
-        indexPathRes.status,
-      )
+    test
+      .expect(indexPathRes.status)
       .toBe(404)
 
     const dashboardRes = yield* Client.get("/react-dashboard")
-    t
-      .expect(
-        dashboardRes.status,
-      )
+    test
+      .expect(dashboardRes.status)
       .toBe(200)
-    t
-      .expect(
-        yield* dashboardRes.text,
-      )
+    test
+      .expect(yield* dashboardRes.text)
       .toStartWith("<!DOCTYPE html>")
 
     const nonexistentRes = yield* Client.get("/nonexistent").pipe(
@@ -104,14 +92,12 @@ t.it("entrypoint without uri parameter", () =>
         () => HttpServerResponse.empty({ status: 404 }),
       ),
     )
-    t
-      .expect(
-        nonexistentRes.status,
-      )
+    test
+      .expect(nonexistentRes.status)
       .toBe(404)
   }))
 
-t.it("withEntrypoints middleware", () =>
+test.it("withEntrypoints middleware", () =>
   effect(function*() {
     const fallbackApp = Effect.succeed(
       HttpServerResponse.text("Fallback", { status: 404 }),
@@ -121,38 +107,26 @@ t.it("withEntrypoints middleware", () =>
     const Client = TestHttpClient.make(App)
 
     const rootRes = yield* Client.get("/")
-    t
-      .expect(
-        rootRes.status,
-      )
+    test
+      .expect(rootRes.status)
       .toBe(404)
-    t
-      .expect(
-        yield* rootRes.text,
-      )
+    test
+      .expect(yield* rootRes.text)
       .toBe("Fallback")
 
     const dashboardRes = yield* Client.get("/react-dashboard")
-    t
-      .expect(
-        dashboardRes.status,
-      )
+    test
+      .expect(dashboardRes.status)
       .toBe(200)
-    t
-      .expect(
-        yield* dashboardRes.text,
-      )
+    test
+      .expect(yield* dashboardRes.text)
       .toStartWith("<!DOCTYPE html>")
 
     const nonexistentRes = yield* Client.get("/nonexistent")
-    t
-      .expect(
-        nonexistentRes.status,
-      )
+    test
+      .expect(nonexistentRes.status)
       .toBe(404)
-    t
-      .expect(
-        yield* nonexistentRes.text,
-      )
+    test
+      .expect(yield* nonexistentRes.text)
       .toBe("Fallback")
   }))

package/src/{BundleHttp.ts → bundler/BundleHttp.ts}

@@ -12,9 +12,8 @@ import * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import * as NPath from "node:path"
 import * as NUrl from "node:url"
+import * as SseHttpResponse from "../experimental/SseHttpResponse.ts"
 import * as Bundle from "./Bundle.ts"
-import * as SseHttpResponse from "./experimental/SseHttpResponse.ts"
-
 
 const DefaultBundleEndpoint = "/_bundle"
 

package/src/client/index.ts

@@ -10,7 +10,7 @@
 import type {
   BundleEvent,
   BundleManifest,
-} from "../Bundle.ts"
+} from "../bundler/Bundle.ts"
 import { showBuildError } from "./Overlay.ts"
 import * as ScrollState from "./ScrollState.ts"