effect-start 0.14.0 → 0.15.0

package/src/bun/BunHttpServer.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import * as HttpApp from "@effect/platform/HttpApp"
 import * as HttpServer from "@effect/platform/HttpServer"
 import * as HttpServerError from "@effect/platform/HttpServerError"
@@ -14,7 +15,11 @@ import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import type * as Scope from "effect/Scope"
 import * as FileRouter from "../FileRouter.ts"
+import * as PathPattern from "../PathPattern.ts"
 import * as Random from "../Random.ts"
+import * as Route from "../Route.ts"
+import * as RouteHttp from "../RouteHttp.ts"
+import * as RouteTree from "../RouteTree.ts"
 import EmptyHTML from "./_empty.html"
 import {
   makeResponse,
@@ -158,12 +163,60 @@ export const make = (
     })
   })
 
+/**
+ * Provides HttpServer using BunHttpServer under the hood.
+ */
 export const layer = (
   options?: ServeOptions,
-): Layer.Layer<BunHttpServer> =>
-  Layer.scoped(BunHttpServer, make(options ?? {}))
+): Layer.Layer<HttpServer.HttpServer | BunHttpServer> =>
+  Layer.provideMerge(
+    Layer.scoped(HttpServer.HttpServer, makeBunServer),
+    Layer.scoped(BunHttpServer, make(options ?? {})),
+  )
+
+/**
+ * Registers routes provided via {@link Route.layer}
+ */
+export function layerAuto() {
+  return Layer.unwrapEffect(
+    Effect.gen(function*() {
+      const bunServer = yield* BunHttpServer
+      const routes = yield* Effect.serviceOption(Route.Routes)
+
+      if (Option.isSome(routes)) {
+        return layerRoutes(routes.value)
+      } else {
+        return Layer.empty
+      }
+    }),
+  )
+}
 
-export const makeHttpServer: Effect.Effect<
+/**
+ * Register routes in Bun.serve.
+ */
+export function layerRoutes(
+  tree: RouteTree.RouteTree,
+): Layer.Layer<never, never, BunHttpServer> {
+  return Layer.effectDiscard(
+    Effect.gen(function*() {
+      const bunServer = yield* BunHttpServer
+      const routes: BunRoute.BunRoutes = {}
+      for (const [path, handler] of RouteHttp.walkHandles(tree)) {
+        for (const bunPath of PathPattern.toBun(path)) {
+          routes[bunPath] = handler
+        }
+      }
+
+      // TODO: think how can we define routes upfront rather
+      // than add them after startup?
+      // now that we have Rooutes.Route thats should be possible
+      bunServer.addRoutes(routes)
+    }),
+  )
+}
+
+const makeBunServer: Effect.Effect<
   HttpServer.HttpServer,
   never,
   Scope.Scope | BunHttpServer
@@ -228,35 +281,6 @@ export const makeHttpServer: Effect.Effect<
   })
 })
 
-export const layerServer = (
-  options?: ServeOptions,
-): Layer.Layer<HttpServer.HttpServer | BunHttpServer> =>
-  Layer.provideMerge(
-    Layer.scoped(HttpServer.HttpServer, makeHttpServer),
-    layer(options ?? {}),
-  )
-
-/**
- * Adds routes from {@like FileRouter.FileRouter} to Bun Server.
- *
- * It ain't clean but it works until we figure out interfaces
- * for other servers.
- */
-export function layerFileRouter() {
-  return Layer.effectDiscard(
-    Effect.gen(function*() {
-      const bunServer = yield* BunHttpServer
-      const manifest = yield* Effect.serviceOption(FileRouter.FileRouter)
-
-      if (Option.isSome(manifest)) {
-        const router = yield* FileRouter.fromManifest(manifest.value)
-        const bunRoutes = yield* BunRoute.routesFromRouter(router)
-        bunServer.addRoutes(bunRoutes)
-      }
-    }),
-  )
-}
-
 const removeHost = (url: string) => {
   if (url[0] === "/") {
     return url

package/src/bun/BunHttpServer_web.ts

@@ -37,18 +37,30 @@ export class ServerRequestImpl extends Inspectable.Class
 {
   readonly [HttpServerRequest.TypeId]: HttpServerRequest.TypeId
   readonly [HttpIncomingMessage.TypeId]: HttpIncomingMessage.TypeId
+  readonly source: Request
+  resolve: (response: Response) => void
+  readonly url: string
+  private bunServer: BunServerInstance<WebSocketContext>
+  headersOverride?: Headers.Headers
+  private remoteAddressOverride?: string
 
   constructor(
-    readonly source: Request,
-    public resolve: (response: Response) => void,
-    readonly url: string,
-    private bunServer: BunServerInstance<WebSocketContext>,
-    public headersOverride?: Headers.Headers,
-    private remoteAddressOverride?: string,
+    source: Request,
+    resolve: (response: Response) => void,
+    url: string,
+    bunServer: BunServerInstance<WebSocketContext>,
+    headersOverride?: Headers.Headers,
+    remoteAddressOverride?: string,
   ) {
     super()
     this[HttpServerRequest.TypeId] = HttpServerRequest.TypeId
     this[HttpIncomingMessage.TypeId] = HttpIncomingMessage.TypeId
+    this.source = source
+    this.resolve = resolve
+    this.url = url
+    this.bunServer = bunServer
+    this.headersOverride = headersOverride
+    this.remoteAddressOverride = remoteAddressOverride
   }
 
   toJSON(): unknown {

package/src/bun/BunImportTrackerPlugin.test.ts

@@ -1,4 +1,4 @@
-import * as t from "bun:test"
+import * as test from "bun:test"
 import * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.ts"
 import * as BunVirtualFilesPlugin from "./BunVirtualFilesPlugin.ts"
 
@@ -27,7 +27,7 @@ export const message = "Hello, World!"
 `,
 }
 
-t.it("virtual import", async () => {
+test.it("virtual import", async () => {
   const trackerPlugin = BunImportTrackerPlugin.make({
     baseDir: Bun.fileURLToPath(import.meta.resolve("../..")),
   })
@@ -42,7 +42,7 @@ t.it("virtual import", async () => {
     ],
   })
 
-  t
+  test
     .expect(
       [...trackerPlugin.state.entries()],
     )

package/src/bun/BunRoute.ts

@@ -1,49 +1,44 @@
-import * as HttpApp from "@effect/platform/HttpApp"
+// @ts-nocheck
 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 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 BunHandlerTypeId: unique symbol = Symbol.for("effect-start/BunHandler")
 
 const INTERNAL_FETCH_HEADER = "x-effect-start-internal-fetch"
 
-export type BunRoute =
-  & Route.Route
+export type BunHandler =
+  & Route.RouteHandler<string, Router.RouterError, BunHttpServer.BunHttpServer>
   & {
-    [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.
+    [BunHandlerTypeId]: typeof BunHandlerTypeId
     internalPathPrefix: string
     load: () => Promise<Bun.HTMLBundle>
   }
 
-export function html(
+export function isBunHandler(input: unknown): input is BunHandler {
+  return typeof input === "function"
+    && Predicate.hasProperty(input, BunHandlerTypeId)
+}
+
+export function bundle(
   load: () => Promise<Bun.HTMLBundle | { default: Bun.HTMLBundle }>,
-): BunRoute {
+): BunHandler {
   const internalPathPrefix = `/.BunRoute-${Random.token(6)}`
 
-  const handler: Route.RouteHandler<
-    HttpServerResponse.HttpServerResponse,
-    Router.RouterError,
-    BunHttpServer.BunHttpServer
-  > = (context) =>
+  const handler = (context: Route.RouteContext, next: Route.RouteNext) =>
     Effect.gen(function*() {
-      const originalRequest = context.request.source as Request
+      const request = yield* HttpServerRequest.HttpServerRequest
+      const originalRequest = request.source as Request
 
       if (
         originalRequest.headers.get(INTERNAL_FETCH_HEADER) === "true"
@@ -91,13 +86,13 @@ export function html(
           }),
       })
 
-      const children = yield* context.next<Router.RouterError, never>()
+      const children = yield* next()
       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)) {
+        } else if (Hyper.isGenericJsxObject(children)) {
           childrenHtml = HyperHtml.renderToString(children)
         } else {
           childrenHtml = String(children)
@@ -105,81 +100,19 @@ export function html(
       }
 
       html = html.replace(/%yield%/g, childrenHtml)
-      html = html.replace(/%slots\.(\w+)%/g, (_, name) =>
-        context.slots[name] ?? "")
+      html = html.replace(
+        /%slots\.(\w+)%/g,
+        (_, name) => context.slots[name] ?? "",
+      )
 
-      return HttpServerResponse
-        .html(html)
+      return 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)),
-    )
-  })
+  return Object.assign(handler, {
+    [BunHandlerTypeId]: BunHandlerTypeId,
+    internalPathPrefix,
+    load: () => load().then(mod => "default" in mod ? mod.default : mod),
+  }) as BunHandler
 }
 
 type BunServerFetchHandler = (
@@ -249,120 +182,6 @@ 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) => {
   return (
     typeof handle === "object"

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"