effect-start 0.14.0 → 0.16.0

package/src/bun/BunBundle.test.ts

@@ -1,17 +1,17 @@
 import * as HttpRouter from "@effect/platform/HttpRouter"
-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 * as NFS from "node:fs/promises"
 import * as NOS from "node:os"
 import * as NPath from "node:path"
-import * as Bundle from "../Bundle.ts"
-import * as BundleHttp from "../BundleHttp.ts"
+import * as Bundle from "../bundler/Bundle.ts"
+import * as BundleHttp from "../bundler/BundleHttp.ts"
 import * as TestHttpClient from "../testing/TestHttpClient.ts"
 import * as BunBundle from "./BunBundle.ts"
 
-t.describe("BunBundle manifest structure", () => {
-  t.it("should generate manifest with inputs and outputs arrays", async () => {
+test.describe("BunBundle manifest structure", () => {
+  test.it("should generate manifest with inputs and outputs arrays", async () => {
     const tmpDir = await NFS.mkdtemp(
       NPath.join(NOS.tmpdir(), "effect-start-test-"),
     )
@@ -41,43 +41,41 @@ export const greeting = "Hello World";`
         }),
       )
 
-      t
+      test
         .expect(bundle.entrypoints)
         .toBeObject()
-      t
+      test
         .expect(bundle.artifacts)
         .toBeArray()
-
-      t
+      test
         .expect(Object.keys(bundle.entrypoints).length)
         .toBe(1)
-      t
+      test
         .expect(bundle.artifacts.length)
         .toBe(3)
 
       const entrypointKeys = Object.keys(bundle.entrypoints)
       const firstEntrypoint = entrypointKeys[0]
 
-      t
+      test
         .expect(firstEntrypoint)
         .toBeString()
-      t
+      test
         .expect(bundle.entrypoints[firstEntrypoint])
         .toBeString()
 
       const firstArtifact = bundle.artifacts[0]
 
-      t
+      test
         .expect(firstArtifact)
         .toHaveProperty("path")
-      t
+      test
         .expect(firstArtifact)
         .toHaveProperty("type")
-      t
+      test
         .expect(firstArtifact)
         .toHaveProperty("size")
-
-      t
+      test
         .expect(firstArtifact.size)
         .toBeGreaterThan(0)
     } finally {
@@ -88,7 +86,7 @@ export const greeting = "Hello World";`
     }
   })
 
-  t.it("should serve manifest via HTTP with correct structure", async () => {
+  test.it("should serve manifest via HTTP with correct structure", async () => {
     const tmpDir = await NFS.mkdtemp(
       NPath.join(NOS.tmpdir(), "effect-start-test-"),
     )
@@ -136,46 +134,44 @@ export const greeting = "Hello World";`
           ),
       )
 
-      t
+      test
         .expect(result)
         .toHaveProperty("entrypoints")
-      t
+      test
         .expect(result)
         .toHaveProperty("artifacts")
-
-      t
+      test
         .expect(result.entrypoints)
         .toBeObject()
-      t
+      test
         .expect(result.artifacts)
         .toBeArray()
-
-      t
+      test
         .expect(Object.keys(result.entrypoints).length)
         .toBe(1)
-      t
+      test
         .expect(result.artifacts.length)
         .toBe(3)
 
       const entrypointKeys = Object.keys(result.entrypoints)
       const firstKey = entrypointKeys[0]
 
-      t
+      test
         .expect(firstKey)
         .toBeString()
-      t
+      test
         .expect(result.entrypoints[firstKey])
         .toBeString()
 
       const artifact = result.artifacts[0]
 
-      t
+      test
         .expect(artifact)
         .toHaveProperty("path")
-      t
+      test
         .expect(artifact)
         .toHaveProperty("type")
-      t
+      test
         .expect(artifact)
         .toHaveProperty("size")
     } finally {
@@ -186,7 +182,7 @@ export const greeting = "Hello World";`
     }
   })
 
-  t.it("should resolve entrypoints to artifacts correctly", async () => {
+  test.it("should resolve entrypoints to artifacts correctly", async () => {
     const tmpDir = await NFS.mkdtemp(
       NPath.join(NOS.tmpdir(), "effect-start-test-"),
     )
@@ -210,18 +206,17 @@ export const greeting = "Hello World";`
       const expectedOutput = bundle.entrypoints[firstEntrypoint]
       const resolvedOutput = bundle.resolve(firstEntrypoint)
 
-      t
+      test
         .expect(resolvedOutput)
         .toBe(expectedOutput)
 
       const artifact = bundle.getArtifact(resolvedOutput!)
 
-      t
+      test
         .expect(artifact)
         .not
         .toBeNull()
-
-      t
+      test
         .expect(artifact)
         .toBeTruthy()
     } finally {
@@ -232,7 +227,7 @@ export const greeting = "Hello World";`
     }
   })
 
-  t.it("should include all artifact metadata", async () => {
+  test.it("should include all artifact metadata", async () => {
     const tmpDir = await NFS.mkdtemp(
       NPath.join(NOS.tmpdir(), "effect-start-test-"),
     )
@@ -251,17 +246,16 @@ export const greeting = "Hello World";`
 
       const artifact = bundle.artifacts[0]
 
-      t
+      test
         .expect(artifact.path)
         .toBeString()
-      t
+      test
         .expect(artifact.type)
         .toBeString()
-      t
+      test
         .expect(artifact.size)
         .toBeNumber()
-
-      t
+      test
         .expect(artifact.type)
         .toContain("javascript")
     } finally {

package/src/bun/BunBundle.ts

@@ -18,8 +18,8 @@ import * as NPath from "node:path"
 import type {
   BundleContext,
   BundleManifest,
-} from "../Bundle.ts"
-import * as Bundle from "../Bundle.ts"
+} from "../bundler/Bundle.ts"
+import * as Bundle from "../bundler/Bundle.ts"
 import * as FileSystemExtra from "../FileSystemExtra.ts"
 import { BunImportTrackerPlugin } from "./index.ts"
 

package/src/bun/BunBundle_imports.test.ts

@@ -1,11 +1,11 @@
-import * as t from "bun:test"
+import * as test from "bun:test"
 import { effectFn } from "../testing"
 import * as BunBundle from "./BunBundle.ts"
 import * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.ts"
 
 const effect = effectFn()
 
-t.it("imports", () =>
+test.it("imports", () =>
   effect(function*() {
     const importTracker = BunImportTrackerPlugin.make()
     yield* BunBundle.build({
@@ -22,10 +22,8 @@ t.it("imports", () =>
       e0,
     ] = importTracker.state.entries()
 
-    t
-      .expect(
-        e0,
-      )
+    test
+      .expect(e0)
       .toEqual([
         "src/bun/BunBundle_imports.test.ts",
         [

package/src/bun/BunHttpServer.test.ts

@@ -1,11 +1,13 @@
-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 * as Route from "../Route.ts"
 import * as BunHttpServer from "./BunHttpServer.ts"
 
-t.describe("BunHttpServer smart port selection", () => {
+test.describe("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)(
+  test.test.skipIf(process.stdout.isTTY)(
     "uses random port when PORT not set, isTTY=false, CLAUDECODE set",
     async () => {
       const originalPort = process.env.PORT
@@ -24,7 +26,10 @@ t.describe("BunHttpServer smart port selection", () => {
           ),
         )
 
-        t.expect(port).not.toBe(3000)
+        test
+          .expect(port)
+          .not
+          .toBe(3000)
       } finally {
         if (originalPort !== undefined) {
           process.env.PORT = originalPort
@@ -40,7 +45,7 @@ t.describe("BunHttpServer smart port selection", () => {
     },
   )
 
-  t.test("uses explicit PORT even when CLAUDECODE is set", async () => {
+  test.test("uses explicit PORT even when CLAUDECODE is set", async () => {
     const originalPort = process.env.PORT
     const originalClaudeCode = process.env.CLAUDECODE
 
@@ -57,7 +62,9 @@ t.describe("BunHttpServer smart port selection", () => {
         ),
       )
 
-      t.expect(port).toBe(5678)
+      test
+        .expect(port)
+        .toBe(5678)
     } finally {
       if (originalPort !== undefined) {
         process.env.PORT = originalPort
@@ -72,3 +79,173 @@ t.describe("BunHttpServer smart port selection", () => {
     }
   })
 })
+
+const BunHttpServerTest = Layer.scoped(
+  BunHttpServer.BunHttpServer,
+  BunHttpServer.make({ port: 0 }),
+)
+
+const testLayer = (routes: ReturnType<typeof Route.tree>) =>
+  Layer.provideMerge(
+    BunHttpServer.layerRoutes(routes),
+    BunHttpServerTest,
+  )
+
+test.describe("routes", () => {
+  test.test("serves static text route", async () => {
+    const routes = Route.tree({
+      "/": Route.get(Route.text("Hello, World!")),
+    })
+
+    const response = await Effect.runPromise(
+      Effect.scoped(
+        Effect
+          .gen(function*() {
+            const bunServer = yield* BunHttpServer.BunHttpServer
+            return yield* Effect.promise(() =>
+              fetch(`http://localhost:${bunServer.server.port}/`)
+            )
+          })
+          .pipe(Effect.provide(testLayer(routes))),
+      ),
+    )
+
+    test.expect(response.status).toBe(200)
+    test.expect(await response.text()).toBe("Hello, World!")
+  })
+
+  test.test("serves JSON route", async () => {
+    const routes = Route.tree({
+      "/api/data": Route.get(Route.json({ message: "success", value: 42 })),
+    })
+
+    const response = await Effect.runPromise(
+      Effect.scoped(
+        Effect
+          .gen(function*() {
+            const bunServer = yield* BunHttpServer.BunHttpServer
+            return yield* Effect.promise(() =>
+              fetch(`http://localhost:${bunServer.server.port}/api/data`)
+            )
+          })
+          .pipe(Effect.provide(testLayer(routes))),
+      ),
+    )
+
+    test.expect(response.status).toBe(200)
+    test.expect(response.headers.get("Content-Type")).toBe("application/json")
+    test.expect(await response.json()).toEqual({
+      message: "success",
+      value: 42,
+    })
+  })
+
+  test.test("returns 404 for unknown routes", async () => {
+    const routes = Route.tree({
+      "/": Route.get(Route.text("Home")),
+    })
+
+    const response = await Effect.runPromise(
+      Effect.scoped(
+        Effect
+          .gen(function*() {
+            const bunServer = yield* BunHttpServer.BunHttpServer
+            return yield* Effect.promise(() =>
+              fetch(`http://localhost:${bunServer.server.port}/unknown`)
+            )
+          })
+          .pipe(Effect.provide(testLayer(routes))),
+      ),
+    )
+
+    test.expect(response.status).toBe(404)
+  })
+
+  test.test("handles content negotiation", async () => {
+    const routes = Route.tree({
+      "/data": Route
+        .get(Route.json({ type: "json" }))
+        .get(Route.html("<div>html</div>")),
+    })
+
+    const [jsonResponse, htmlResponse] = await Effect.runPromise(
+      Effect.scoped(
+        Effect
+          .gen(function*() {
+            const bunServer = yield* BunHttpServer.BunHttpServer
+            const baseUrl = `http://localhost:${bunServer.server.port}`
+
+            const json = yield* Effect.promise(() =>
+              fetch(`${baseUrl}/data`, {
+                headers: { Accept: "application/json" },
+              })
+            )
+
+            const html = yield* Effect.promise(() =>
+              fetch(`${baseUrl}/data`, {
+                headers: { Accept: "text/html" },
+              })
+            )
+
+            return [json, html] as const
+          })
+          .pipe(Effect.provide(testLayer(routes))),
+      ),
+    )
+
+    test.expect(jsonResponse.headers.get("Content-Type")).toBe(
+      "application/json",
+    )
+    test.expect(await jsonResponse.json()).toEqual({ type: "json" })
+
+    test.expect(htmlResponse.headers.get("Content-Type")).toBe(
+      "text/html; charset=utf-8",
+    )
+    test.expect(await htmlResponse.text()).toBe("<div>html</div>")
+  })
+
+  test.test("returns 406 for unacceptable content type", async () => {
+    const routes = Route.tree({
+      "/data": Route.get(Route.json({ type: "json" })),
+    })
+
+    const response = await Effect.runPromise(
+      Effect.scoped(
+        Effect
+          .gen(function*() {
+            const bunServer = yield* BunHttpServer.BunHttpServer
+            return yield* Effect.promise(() =>
+              fetch(`http://localhost:${bunServer.server.port}/data`, {
+                headers: { Accept: "image/png" },
+              })
+            )
+          })
+          .pipe(Effect.provide(testLayer(routes))),
+      ),
+    )
+
+    test.expect(response.status).toBe(406)
+  })
+
+  test.test("handles parameterized routes", async () => {
+    const routes = Route.tree({
+      "/users/:id": Route.get(Route.text("user")),
+    })
+
+    const response = await Effect.runPromise(
+      Effect.scoped(
+        Effect
+          .gen(function*() {
+            const bunServer = yield* BunHttpServer.BunHttpServer
+            return yield* Effect.promise(() =>
+              fetch(`http://localhost:${bunServer.server.port}/users/123`)
+            )
+          })
+          .pipe(Effect.provide(testLayer(routes))),
+      ),
+    )
+
+    test.expect(response.status).toBe(200)
+    test.expect(await response.text()).toBe("user")
+  })
+})

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,76 @@ 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 ?? {})),
+  )
 
-export const makeHttpServer: Effect.Effect<
+/**
+ * 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
+      }
+    }),
+  )
+}
+
+/**
+ * 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 runtime = yield* Effect.runtime<BunHttpServer>()
+      const toWebHandler = RouteHttp.toWebHandlerRuntime(runtime)
+
+      const bunRoutes: BunRoute.BunRoutes = {}
+      const pathGroups = new Map<string, RouteMount.MountedRoute[]>()
+
+      for (const route of RouteTree.walk(tree)) {
+        const bunDescriptors = BunRoute.descriptors(route)
+        if (bunDescriptors) {
+          const htmlBundle = yield* Effect.promise(bunDescriptors.bunLoad)
+          bunRoutes[`${bunDescriptors.bunPrefix}/*`] = htmlBundle
+        }
+
+        const path = Route.descriptor(route).path
+        const group = pathGroups.get(path) ?? []
+        group.push(route)
+        pathGroups.set(path, group)
+      }
+
+      for (const [path, routes] of pathGroups) {
+        const handler = toWebHandler(routes)
+        for (const bunPath of PathPattern.toBun(path)) {
+          bunRoutes[bunPath] = handler
+        }
+      }
+
+      bunServer.addRoutes(bunRoutes)
+    }),
+  )
+}
+
+const makeBunServer: Effect.Effect<
   HttpServer.HttpServer,
   never,
   Scope.Scope | BunHttpServer
@@ -228,35 +297,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()],
     )