effect-start 0.10.0 → 0.11.0

package/src/bun/BunRoute.test.ts

@@ -1,69 +1,119 @@
+import * as HttpMiddleware from "@effect/platform/HttpMiddleware"
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
 import type { HTMLBundle } from "bun"
 import * as t from "bun:test"
 import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
 import * as Route from "../Route.ts"
-import type * as Router from "../Router.ts"
+import * as Router from "../Router.ts"
+import * as BunHttpServer from "./BunHttpServer.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.describe(`${BunRoute.validateBunPattern.name}`, () => {
+  t.test("allows exact paths", () => {
+    const result = BunRoute.validateBunPattern("/users")
+    t.expect(result._tag).toBe("None")
   })
 
-  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("allows full-segment params", () => {
+    const result = BunRoute.validateBunPattern("/users/[id]")
+    t.expect(result._tag).toBe("None")
   })
 
-  t.test("returns bundle directly when no default", async () => {
-    const mockBundle = { index: "index.html" } as HTMLBundle
-    const bunRoute = BunRoute.loadBundle(() => Promise.resolve(mockBundle))
+  t.test("allows rest params", () => {
+    const result = BunRoute.validateBunPattern("/docs/[...path]")
+    t.expect(result._tag).toBe("None")
+  })
 
-    const loaded = await bunRoute.load()
-    t.expect(loaded).toBe(mockBundle)
+  t.test("rejects prefixed params", () => {
+    const result = BunRoute.validateBunPattern("/users/pk_[id]")
+    t.expect(result._tag).toBe("Some")
+    if (result._tag === "Some") {
+      t.expect(result.value.reason).toBe("UnsupportedPattern")
+      t.expect(result.value.pattern).toBe("/users/pk_[id]")
+    }
   })
-})
 
-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.test("rejects suffixed params", () => {
+    const result = BunRoute.validateBunPattern("/users/[id]_details")
+    t.expect(result._tag).toBe("Some")
+    if (result._tag === "Some") {
+      t.expect(result.value.reason).toBe("UnsupportedPattern")
+    }
+  })
 
-    t.expect(BunRoute.isBunRoute(bunRoute)).toBe(true)
+  t.test("rejects dot suffix on params", () => {
+    const result = BunRoute.validateBunPattern("/api/[id].json")
+    t.expect(result._tag).toBe("Some")
+    if (result._tag === "Some") {
+      t.expect(result.value.reason).toBe("UnsupportedPattern")
+    }
   })
 
-  t.test("returns false for regular Route", () => {
-    const route = Route.text(Effect.succeed("hello"))
+  t.test("rejects tilde suffix on params", () => {
+    const result = BunRoute.validateBunPattern("/api/[id]~test")
+    t.expect(result._tag).toBe("Some")
+    if (result._tag === "Some") {
+      t.expect(result.value.reason).toBe("UnsupportedPattern")
+    }
+  })
 
-    t.expect(BunRoute.isBunRoute(route)).toBe(false)
+  t.test("allows optional params (implemented via two patterns)", () => {
+    const result = BunRoute.validateBunPattern("/users/[[id]]")
+    t.expect(result._tag).toBe("None")
   })
 
-  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.test("allows optional rest params (implemented via two patterns)", () => {
+    const result = BunRoute.validateBunPattern("/docs/[[...path]]")
+    t.expect(result._tag).toBe("None")
   })
 })
 
 t.describe(`${BunRoute.routesFromRouter.name}`, () => {
+  t.test("fails with RouterError for unsupported patterns", async () => {
+    const result = await Effect.runPromise(
+      BunRoute
+        .routesFromRouter(
+          Router.mount("/users/pk_[id]", Route.text("user")),
+        )
+        .pipe(
+          Effect.either,
+          Effect.provide(BunHttpServer.layer({ port: 0 })),
+        ),
+    )
+
+    t.expect(result._tag).toBe("Left")
+    if (result._tag === "Left") {
+      t.expect(result.left._tag).toBe("RouterError")
+      t.expect(result.left.reason).toBe("UnsupportedPattern")
+    }
+  })
+
+  t.it(
+    "converts text route to fetch handler",
+    () =>
+      Effect.runPromise(
+        Effect
+          .gen(function*() {
+            const bunServer = yield* BunHttpServer.BunServer
+            return 23
+          })
+          .pipe(
+            Effect.provide(
+              Layer.mergeAll(
+                BunHttpServer.layer({
+                  port: 0,
+                }),
+              ),
+            ),
+          ),
+      ),
+  )
+
   t.test("converts text route to fetch handler", async () => {
     const fetch = await makeFetch(
-      makeRouter([
-        { path: "/hello", routes: Route.text(Effect.succeed("Hello World")) },
-      ]),
+      Router.mount("/hello", Route.text("Hello World")),
     )
 
     const response = await fetch("/hello")
@@ -74,12 +124,7 @@ t.describe(`${BunRoute.routesFromRouter.name}`, () => {
 
   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 })),
-        },
-      ]),
+      Router.mount("/api/data", Route.json({ message: "ok", count: 42 })),
     )
 
     const response = await fetch("/api/data")
@@ -90,9 +135,7 @@ t.describe(`${BunRoute.routesFromRouter.name}`, () => {
 
   t.test("converts html route to fetch handler", async () => {
     const fetch = await makeFetch(
-      makeRouter([
-        { path: "/page", routes: Route.html(Effect.succeed("<h1>Title</h1>")) },
-      ]),
+      Router.mount("/page", Route.html(Effect.succeed("<h1>Title</h1>"))),
     )
 
     const response = await fetch("/page")
@@ -103,14 +146,12 @@ t.describe(`${BunRoute.routesFromRouter.name}`, () => {
 
   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 })),
-          ),
-        },
-      ]),
+      Router.mount(
+        "/users",
+        Route.get(Route.json({ users: [] })).post(
+          Route.json({ created: true }),
+        ),
+      ),
     )
 
     const getResponse = await fetch("/users")
@@ -121,16 +162,10 @@ t.describe(`${BunRoute.routesFromRouter.name}`, () => {
   })
 
   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")),
-          },
-        ]),
-      ),
+    const routes = await makeBunRoutes(
+      Router
+        .mount("/users/[id]", Route.text("user"))
+        .mount("/docs/[...path]", Route.text("docs")),
     )
 
     t.expect(routes["/users/:id"]).toBeDefined()
@@ -141,17 +176,16 @@ t.describe(`${BunRoute.routesFromRouter.name}`, () => {
 
   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 bunRoute = BunRoute.html(() => Promise.resolve(mockBundle))
 
-    const routes = await Effect.runPromise(
-      BunRoute.routesFromRouter(
-        makeRouter([{ path: "/app", routes: bunRoute }]),
-      ),
+    const routes = await makeBunRoutes(
+      Router.mount("/app", bunRoute),
     )
 
     const internalPath = Object.keys(routes).find((k) =>
-      k.includes("~BunRoute-")
+      k.includes(".BunRoute-")
     )
+
     t.expect(internalPath).toBeDefined()
     t.expect(routes[internalPath!]).toBe(mockBundle)
     t.expect(typeof routes["/app"]).toBe("function")
@@ -159,29 +193,18 @@ t.describe(`${BunRoute.routesFromRouter.name}`, () => {
 
   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 bunRoute = BunRoute.html(() => Promise.resolve(mockBundle))
+
+    const routes = await makeBunRoutes(
+      Router
+        .mount("/app", bunRoute)
+        .mount("/api/health", Route.json({ ok: true })),
     )
 
     const internalPath = Object.keys(routes).find((k) =>
-      k.includes("~BunRoute-")
+      k.includes(".BunRoute-")
     )
+
     t.expect(internalPath).toBeDefined()
     t.expect(routes[internalPath!]).toBe(mockBundle)
     t.expect(typeof routes["/app"]).toBe("function")
@@ -191,15 +214,13 @@ t.describe(`${BunRoute.routesFromRouter.name}`, () => {
 
   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"))),
-        },
-      ]),
+      Router.mount(
+        "/resource",
+        Route
+          .get(Route.text("get"))
+          .post(Route.text("post"))
+          .delete(Route.text("delete")),
+      ),
     )
 
     const getRes = await fetch("/resource")
@@ -215,10 +236,7 @@ t.describe(`${BunRoute.routesFromRouter.name}`, () => {
 t.describe("fetch handler Response", () => {
   t.test("returns Response instance", async () => {
     const fetch = await makeFetch(
-      makeRouter([{
-        path: "/test",
-        routes: Route.text(Effect.succeed("test")),
-      }]),
+      Router.mount("/test", Route.text("test")),
     )
 
     const response = await fetch("/test")
@@ -228,10 +246,7 @@ t.describe("fetch handler Response", () => {
 
   t.test("text response has correct content-type", async () => {
     const fetch = await makeFetch(
-      makeRouter([{
-        path: "/text",
-        routes: Route.text(Effect.succeed("hello")),
-      }]),
+      Router.mount("/text", Route.text("hello")),
     )
 
     const response = await fetch("/text")
@@ -241,10 +256,7 @@ t.describe("fetch handler Response", () => {
 
   t.test("json response has correct content-type", async () => {
     const fetch = await makeFetch(
-      makeRouter([{
-        path: "/json",
-        routes: Route.json(Effect.succeed({ data: 1 })),
-      }]),
+      Router.mount("/json", Route.json({ data: 1 })),
     )
 
     const response = await fetch("/json")
@@ -254,10 +266,7 @@ t.describe("fetch handler Response", () => {
 
   t.test("html response has correct content-type", async () => {
     const fetch = await makeFetch(
-      makeRouter([{
-        path: "/html",
-        routes: Route.html(Effect.succeed("<p>hi</p>")),
-      }]),
+      Router.mount("/html", Route.html(Effect.succeed("<p>hi</p>"))),
     )
 
     const response = await fetch("/html")
@@ -267,10 +276,7 @@ t.describe("fetch handler Response", () => {
 
   t.test("response body is readable", async () => {
     const fetch = await makeFetch(
-      makeRouter([{
-        path: "/body",
-        routes: Route.text(Effect.succeed("readable body")),
-      }]),
+      Router.mount("/body", Route.text("readable body")),
     )
 
     const response = await fetch("/body")
@@ -283,7 +289,7 @@ t.describe("fetch handler Response", () => {
 
   t.test("response ok is true for 200 status", async () => {
     const fetch = await makeFetch(
-      makeRouter([{ path: "/ok", routes: Route.text(Effect.succeed("ok")) }]),
+      Router.mount("/ok", Route.text("ok")),
     )
 
     const response = await fetch("/ok")
@@ -293,18 +299,174 @@ t.describe("fetch handler Response", () => {
   })
 })
 
-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 }),
-  })),
+t.describe("Route.layer httpMiddleware", () => {
+  t.test("applies middleware headers to child routes", async () => {
+    const addHeader = HttpMiddleware.make((app) =>
+      Effect.gen(function*() {
+        const response = yield* app
+        return HttpServerResponse.setHeader(response, "X-Layer-Applied", "true")
+      })
+    ) as Route.HttpMiddlewareFunction
+
+    const router = Router
+      .use(Route.layer(Route.http(addHeader)))
+      .mount("/child", Route.text("child content"))
+
+    const fetch = await makeFetch(router)
+    const response = await fetch("/child")
+
+    t.expect(response.headers.get("X-Layer-Applied")).toBe("true")
+    t.expect(await response.text()).toBe("child content")
+  })
+
+  t.test("middleware only applies to children, not siblings", async () => {
+    const addHeader = HttpMiddleware.make((app) =>
+      Effect.gen(function*() {
+        const response = yield* app
+        return HttpServerResponse.setHeader(response, "X-Layer-Applied", "true")
+      })
+    ) as Route.HttpMiddlewareFunction
+
+    const router = Router
+      .mount("/outside", Route.text("outside content"))
+      .use(Route.layer(Route.http(addHeader)))
+      .mount("/inside", Route.text("inside content"))
+
+    const fetch = await makeFetch(router)
+
+    const insideResponse = await fetch("/inside")
+    t.expect(insideResponse.headers.get("X-Layer-Applied")).toBe("true")
+
+    const outsideResponse = await fetch("/outside")
+    t.expect(outsideResponse.headers.get("X-Layer-Applied")).toBeNull()
+  })
+
+  t.test("multiple middleware are applied in order", async () => {
+    const addHeader1 = HttpMiddleware.make((app) =>
+      Effect.gen(function*() {
+        const response = yield* app
+        return HttpServerResponse.setHeader(response, "X-First", "1")
+      })
+    ) as Route.HttpMiddlewareFunction
+
+    const addHeader2 = HttpMiddleware.make((app) =>
+      Effect.gen(function*() {
+        const response = yield* app
+        return HttpServerResponse.setHeader(response, "X-Second", "2")
+      })
+    ) as Route.HttpMiddlewareFunction
+
+    const router = Router
+      .use(Route.layer(Route.http(addHeader1), Route.http(addHeader2)))
+      .mount("/test", Route.text("test"))
+
+    const fetch = await makeFetch(router)
+    const response = await fetch("/test")
+
+    t.expect(response.headers.get("X-First")).toBe("1")
+    t.expect(response.headers.get("X-Second")).toBe("2")
+  })
+
+  t.test("nested layers apply all middleware", async () => {
+    const outerHeader = HttpMiddleware.make((app) =>
+      Effect.gen(function*() {
+        const response = yield* app
+        return HttpServerResponse.setHeader(response, "X-Outer", "outer")
+      })
+    ) as Route.HttpMiddlewareFunction
+
+    const innerHeader = HttpMiddleware.make((app) =>
+      Effect.gen(function*() {
+        const response = yield* app
+        return HttpServerResponse.setHeader(response, "X-Inner", "inner")
+      })
+    ) as Route.HttpMiddlewareFunction
+
+    const router = Router
+      .use(Route.layer(Route.http(outerHeader)))
+      .use(Route.layer(Route.http(innerHeader)))
+      .mount("/nested", Route.text("nested"))
+
+    const fetch = await makeFetch(router)
+    const response = await fetch("/nested")
+
+    t.expect(response.headers.get("X-Outer")).toBe("outer")
+    t.expect(response.headers.get("X-Inner")).toBe("inner")
+  })
+})
+
+t.describe("BunRoute placeholder replacement", () => {
+  t.test("%yield% is replaced with nested route content via layer", async () => {
+    const layoutBundle = BunRoute.html(() =>
+      import("../../static/LayoutSlots.html")
+    )
+
+    const router = Router
+      .use(Route.layer(layoutBundle))
+      .mount("/page", Route.html(Effect.succeed("<p>Child Content</p>")))
+
+    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 response = yield* Effect.promise(() => fetch(`${baseUrl}/page`))
+
+          const html = yield* Effect.promise(() => response.text())
+
+          t.expect(html).toContain("<body>")
+          t.expect(html).toContain("<p>Child Content</p>")
+          t.expect(html).not.toContain("%yield%")
+          t.expect(html).not.toContain("%slots.")
+        })
+        .pipe(
+          Effect.scoped,
+          Effect.provide(BunHttpServer.layer({ port: 0 })),
+        ),
+    )
+  })
+
+  t.test("%yield% and %slots% are replaced with empty when no nested content", async () => {
+    const layoutBundle = BunRoute.html(() =>
+      import("../../static/LayoutSlots.html")
+    )
+
+    const router = Router.mount("/layout", layoutBundle)
+
+    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 response = yield* Effect.promise(() =>
+            fetch(`${baseUrl}/layout`)
+          )
+
+          const html = yield* Effect.promise(() => response.text())
+
+          t.expect(html).toContain("<title></title>")
+          t.expect(html).toContain("<body>")
+          t.expect(html).not.toContain("%yield%")
+          t.expect(html).not.toContain("%slots.")
+        })
+        .pipe(
+          Effect.scoped,
+          Effect.provide(BunHttpServer.layer({ port: 0 })),
+        ),
+    )
+  })
 })
 
+
+
 type FetchFn = (path: string, init?: { method?: string }) => Promise<Response>
 
 type HandlerFn = (
@@ -312,8 +474,19 @@ type HandlerFn = (
   server: unknown,
 ) => Response | Promise<Response>
 
-async function makeFetch(router: Router.RouterContext): Promise<FetchFn> {
-  const routes = await Effect.runPromise(BunRoute.routesFromRouter(router))
+
+async function makeBunRoutes(
+  router: Router.RouterBuilder.Any,
+): Promise<BunRoute.BunRoutes> {
+  return Effect.runPromise(
+    BunRoute.routesFromRouter(router).pipe(
+      Effect.provide(BunHttpServer.layer({ port: 0 })),
+    ),
+  )
+}
+
+async function makeFetch(router: Router.RouterBuilder.Any): Promise<FetchFn> {
+  const routes = await makeBunRoutes(router)
   const mockServer = {} as import("bun").Server<unknown>
 
   return async (path, init) => {