effect-start 0.14.0 → 0.15.0

package/src/RouteHttp.test.ts

@@ -0,0 +1,443 @@
+import * as test from "bun:test"
+import * as Effect from "effect/Effect"
+import * as Route from "./Route.ts"
+import * as RouteHttp from "./RouteHttp.ts"
+import * as RouteTree from "./RouteTree.ts"
+
+test.it("converts string to text/plain for Route.text", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route.get(Route.text("Hello World")),
+  )
+  const response = await RouteHttp.fetch(handler, { path: "/text" })
+
+  test
+    .expect(response.status)
+    .toBe(200)
+  test
+    .expect(response.headers.get("Content-Type"))
+    .toBe("text/plain; charset=utf-8")
+  test
+    .expect(await response.text())
+    .toBe("Hello World")
+})
+
+test.it("converts string to text/html for Route.html", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route.get(Route.html("<h1>Hello</h1>")),
+  )
+  const response = await RouteHttp.fetch(handler, { path: "/html" })
+
+  test
+    .expect(response.status)
+    .toBe(200)
+  test
+    .expect(response.headers.get("Content-Type"))
+    .toBe("text/html; charset=utf-8")
+  test
+    .expect(await response.text())
+    .toBe("<h1>Hello</h1>")
+})
+
+test.it("converts object to JSON for Route.json", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route.get(Route.json({ message: "hello", count: 42 })),
+  )
+  const response = await RouteHttp.fetch(handler, { path: "/json" })
+
+  test
+    .expect(response.status)
+    .toBe(200)
+  test
+    .expect(response.headers.get("Content-Type"))
+    .toBe("application/json")
+  test
+    .expect(await response.json())
+    .toEqual({ message: "hello", count: 42 })
+})
+
+test.it("converts array to JSON for Route.json", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route.get(Route.json([1, 2, 3])),
+  )
+  const response = await RouteHttp.fetch(handler, { path: "/array" })
+
+  test
+    .expect(response.status)
+    .toBe(200)
+  test
+    .expect(response.headers.get("Content-Type"))
+    .toBe("application/json")
+  test
+    .expect(await response.json())
+    .toEqual([1, 2, 3])
+})
+
+test.it("provides request in context", async () => {
+  let capturedRequest: Request | undefined
+
+  const handler = RouteHttp.toWebHandler(
+    Route.get(Route.text(function*(ctx: any) {
+      capturedRequest = ctx.request
+      return "ok"
+    })),
+  )
+  await RouteHttp.fetch(handler, { path: "/test?foo=bar" })
+
+  test
+    .expect(capturedRequest)
+    .toBeInstanceOf(Request)
+})
+
+test.it("handles method-specific routes", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route
+      .get(Route.text("get resource"))
+      .post(Route.text("post resource")),
+  )
+
+  const getResponse = await RouteHttp.fetch(handler, {
+    path: "/resource",
+    method: "GET",
+  })
+  test
+    .expect(await getResponse.text())
+    .toBe("get resource")
+
+  const postResponse = await RouteHttp.fetch(handler, {
+    path: "/resource",
+    method: "POST",
+  })
+  test
+    .expect(await postResponse.text())
+    .toBe("post resource")
+})
+
+test.it("handles errors by returning 500 response", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route.get(Route.text(function*(): Generator<any, string, any> {
+      return yield* Effect.fail(new Error("Something went wrong"))
+    })),
+  )
+  const response = await RouteHttp.fetch(handler, { path: "/error" })
+
+  test
+    .expect(response.status)
+    .toBe(500)
+
+  const text = await response.text()
+  test
+    .expect(text)
+    .toContain("Something went wrong")
+})
+
+test.it("handles defects by returning 500 response", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route.get(Route.text(function*(): Generator<any, string, any> {
+      return yield* Effect.die("Unexpected error")
+    })),
+  )
+  const response = await RouteHttp.fetch(handler, { path: "/defect" })
+
+  test
+    .expect(response.status)
+    .toBe(500)
+})
+
+test.it("includes descriptor properties in handler context", async () => {
+  let capturedMethod: string | undefined
+
+  const handler = RouteHttp.toWebHandler(
+    Route.get(Route.text(function*(ctx: any) {
+      capturedMethod = ctx.method
+      return "ok"
+    })),
+  )
+  await RouteHttp.fetch(handler, { path: "/test" })
+
+  test
+    .expect(capturedMethod)
+    .toBe("GET")
+})
+
+test.it("returns 405 for wrong method", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route.get(Route.text("users")),
+  )
+  const response = await RouteHttp.fetch(handler, {
+    path: "/users",
+    method: "POST",
+  })
+
+  test
+    .expect(response.status)
+    .toBe(405)
+})
+
+test.it("supports POST method", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route.post(Route.text("created")),
+  )
+  const response = await RouteHttp.fetch(handler, {
+    path: "/users",
+    method: "POST",
+  })
+
+  test
+    .expect(response.status)
+    .toBe(200)
+  test
+    .expect(await response.text())
+    .toBe("created")
+})
+
+test.it("selects json when Accept prefers application/json", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route
+      .get(Route.json({ type: "json" }))
+      .get(Route.html("<div>html</div>")),
+  )
+  const response = await RouteHttp.fetch(handler, {
+    path: "/data",
+    headers: { Accept: "application/json" },
+  })
+
+  test
+    .expect(response.headers.get("Content-Type"))
+    .toBe("application/json")
+  test
+    .expect(await response.json())
+    .toEqual({ type: "json" })
+})
+
+test.it("selects html when Accept prefers text/html", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route
+      .get(Route.json({ type: "json" }))
+      .get(Route.html("<div>html</div>")),
+  )
+  const response = await RouteHttp.fetch(handler, {
+    path: "/data",
+    headers: { Accept: "text/html" },
+  })
+
+  test
+    .expect(response.headers.get("Content-Type"))
+    .toBe("text/html; charset=utf-8")
+  test
+    .expect(await response.text())
+    .toBe("<div>html</div>")
+})
+
+test.it("selects text/plain when Accept prefers it", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route
+      .get(Route.text("plain text"))
+      .get(Route.json({ type: "json" })),
+  )
+  const response = await RouteHttp.fetch(handler, {
+    path: "/data",
+    headers: { Accept: "text/plain" },
+  })
+
+  test
+    .expect(response.headers.get("Content-Type"))
+    .toBe("text/plain; charset=utf-8")
+  test
+    .expect(await response.text())
+    .toBe("plain text")
+})
+
+test.it("returns first candidate when no Accept header", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route
+      .get(Route.json({ type: "json" }))
+      .get(Route.html("<div>html</div>")),
+  )
+  const response = await RouteHttp.fetch(handler, { path: "/data" })
+
+  test
+    .expect(response.headers.get("Content-Type"))
+    .toBe("application/json")
+})
+
+test.it("handles Accept with quality values", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route
+      .get(Route.json({ type: "json" }))
+      .get(Route.html("<div>html</div>")),
+  )
+  const response = await RouteHttp.fetch(handler, {
+    path: "/data",
+    headers: { Accept: "text/html;q=0.9, application/json;q=1.0" },
+  })
+
+  test
+    .expect(response.headers.get("Content-Type"))
+    .toBe("application/json")
+})
+
+test.it("handles Accept: */*", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route
+      .get(Route.json({ type: "json" }))
+      .get(Route.html("<div>html</div>")),
+  )
+  const response = await RouteHttp.fetch(handler, {
+    path: "/data",
+    headers: { Accept: "*/*" },
+  })
+
+  test
+    .expect(response.headers.get("Content-Type"))
+    .toBe("application/json")
+})
+
+test.it("returns 406 when Accept doesn't match available formats", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route.get(Route.json({ type: "json" })),
+  )
+  const response = await RouteHttp.fetch(handler, {
+    path: "/data",
+    headers: { Accept: "text/html" },
+  })
+
+  test
+    .expect(response.status)
+    .toBe(406)
+  test
+    .expect(await response.text())
+    .toBe("Not Acceptable")
+})
+
+test.it("returns 406 when Accept doesn't match any of multiple formats", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route
+      .get(Route.json({ type: "json" }))
+      .get(Route.html("<div>html</div>")),
+  )
+  const response = await RouteHttp.fetch(handler, {
+    path: "/data",
+    headers: { Accept: "image/png" },
+  })
+
+  test
+    .expect(response.status)
+    .toBe(406)
+})
+
+test.it("prefers json over text when no Accept header", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route
+      .get(Route.text("plain"))
+      .get(Route.json({ type: "json" })),
+  )
+  const response = await RouteHttp.fetch(handler, { path: "/data" })
+
+  test
+    .expect(response.headers.get("Content-Type"))
+    .toBe("application/json")
+})
+
+test.it("prefers text over html when no Accept header and no json", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route
+      .get(Route.html("<div>html</div>"))
+      .get(Route.text("plain")),
+  )
+  const response = await RouteHttp.fetch(handler, { path: "/data" })
+
+  test
+    .expect(response.headers.get("Content-Type"))
+    .toBe("text/plain; charset=utf-8")
+})
+
+test.it("falls back to html when no Accept header and no json or text", async () => {
+  const handler = RouteHttp.toWebHandler(
+    Route.get(Route.html("<div>html</div>")),
+  )
+  const response = await RouteHttp.fetch(handler, { path: "/data" })
+
+  test
+    .expect(response.headers.get("Content-Type"))
+    .toBe("text/html; charset=utf-8")
+})
+
+test.describe("walkHandles", () => {
+  test.it("yields handlers for static routes", () => {
+    const tree = RouteTree.make({
+      "/users": Route.get(Route.text("users list")),
+      "/admin": Route.get(Route.text("admin")),
+    })
+
+    const handles = Object.fromEntries(RouteHttp.walkHandles(tree))
+
+    test
+      .expect("/users" in handles)
+      .toBe(true)
+    test
+      .expect("/admin" in handles)
+      .toBe(true)
+  })
+
+  test.it("yields handlers for parameterized routes", () => {
+    const tree = RouteTree.make({
+      "/users/:id": Route.get(Route.text("user detail")),
+    })
+
+    const handles = Object.fromEntries(RouteHttp.walkHandles(tree))
+
+    test
+      .expect("/users/:id" in handles)
+      .toBe(true)
+  })
+
+  test.it("preserves optional param syntax", () => {
+    const tree = RouteTree.make({
+      "/files/:name?": Route.get(Route.text("files")),
+    })
+
+    const handles = Object.fromEntries(RouteHttp.walkHandles(tree))
+
+    test
+      .expect("/files/:name?" in handles)
+      .toBe(true)
+  })
+
+  test.it("preserves wildcard param syntax", () => {
+    const tree = RouteTree.make({
+      "/docs/:path*": Route.get(Route.text("docs")),
+    })
+
+    const handles = Object.fromEntries(RouteHttp.walkHandles(tree))
+
+    test
+      .expect("/docs/:path*" in handles)
+      .toBe(true)
+  })
+})
+
+test.describe("toWebHandler type constraints", () => {
+  test.it("accepts routes with method", () => {
+    RouteHttp.toWebHandler(Route.get(Route.text("hello")))
+  })
+
+  test.it("accepts multiple routes with methods", () => {
+    RouteHttp.toWebHandler(
+      Route.get(Route.text("hello")).post(Route.text("world")),
+    )
+  })
+
+  test.it("rejects routes without method", () => {
+    const noMethod = Route.empty.pipe(Route.text("hello"))
+    // @ts-expect-error
+    RouteHttp.toWebHandler(noMethod)
+  })
+
+  test.it("rejects mixed routes where one has method and one doesn't", () => {
+    const withMethod = Route.get(Route.text("hello"))
+    const withoutMethod = Route.empty.pipe(Route.text("hello"))
+    const mixed = [...withMethod, ...withoutMethod] as const
+    // @ts-expect-error
+    RouteHttp.toWebHandler(mixed)
+  })
+})

package/src/RouteHttp.ts

@@ -0,0 +1,219 @@
+import * as Array from "effect/Array"
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as Runtime from "effect/Runtime"
+import * as ContentNegotiation from "./ContentNegotiation.ts"
+import * as Http from "./Http.ts"
+import * as Route from "./Route.ts"
+import * as RouteBody from "./RouteBody.ts"
+import * as RouteMount from "./RouteMount.ts"
+import * as RouteTree from "./RouteTree.ts"
+
+type UnboundedRouteWithMethod = Route.Route.With<{
+  method: RouteMount.RouteMount.Method
+  format?: RouteBody.Format
+}>
+
+const formatToMediaType = {
+  text: "text/plain",
+  html: "text/html",
+  json: "application/json",
+  bytes: "application/octet-stream",
+} as const
+
+const formatToContentType = {
+  text: "text/plain; charset=utf-8",
+  html: "text/html; charset=utf-8",
+  json: "application/json",
+  bytes: "application/octet-stream",
+} as const
+
+function toResponse(result: unknown, format?: string): Response {
+  if (result instanceof Response) {
+    return result
+  }
+
+  const contentType = format && format in formatToContentType
+    ? formatToContentType[format]
+    : typeof result === "string"
+    ? "text/html; charset=utf-8"
+    : "application/json"
+
+  const body = contentType === "application/json"
+    ? JSON.stringify(result)
+    : result
+
+  return new Response(body as BodyInit, {
+    headers: { "Content-Type": contentType },
+  })
+}
+
+function getMediaType(format: string | undefined): string | undefined {
+  return format && format in formatToMediaType
+    ? formatToMediaType[format]
+    : undefined
+}
+
+const defaultFormatPriority = ["json", "text", "html", "bytes"] as const
+
+function negotiateRoute(
+  routes: UnboundedRouteWithMethod[],
+  accept: string | null,
+): UnboundedRouteWithMethod | undefined {
+  if (routes.length === 1) {
+    if (!accept) return routes[0]
+    const format = Route.descriptor(routes[0]).format
+    const mediaType = getMediaType(format)
+    if (!mediaType) return routes[0]
+    const matched = ContentNegotiation.media(accept, [mediaType])
+    return matched.length > 0 ? routes[0] : undefined
+  }
+
+  const formatMap = new Map<string, UnboundedRouteWithMethod>()
+  const available: string[] = []
+  const mediaTypeMap = new Map<string, UnboundedRouteWithMethod>()
+
+  for (const route of routes) {
+    const format = Route.descriptor(route).format
+    if (format && !formatMap.has(format)) {
+      formatMap.set(format, route)
+    }
+    const mediaType = getMediaType(format)
+    if (format && mediaType && !mediaTypeMap.has(mediaType)) {
+      available.push(mediaType)
+      mediaTypeMap.set(mediaType, route)
+    }
+  }
+
+  if (!accept) {
+    for (const format of defaultFormatPriority) {
+      const route = formatMap.get(format)
+      if (route) return route
+    }
+    return routes[0]
+  }
+
+  if (available.length === 0) {
+    return routes[0]
+  }
+
+  const preferred = ContentNegotiation.media(accept, available)
+  if (preferred.length > 0) {
+    const best = mediaTypeMap.get(preferred[0])
+    if (best) {
+      return best
+    }
+  }
+
+  return undefined
+}
+
+export const toWebHandlerRuntime = <R>(
+  runtime: Runtime.Runtime<R>,
+) => {
+  const run = Runtime.runPromise(runtime)
+
+  return (
+    routes: Iterable<
+      UnboundedRouteWithMethod
+    >,
+  ): Http.WebHandler => {
+    const grouped = Array.groupBy(
+      Array.fromIterable(routes),
+      (route) => Route.descriptor(route).method?.toUpperCase() ?? "*",
+    )
+    const wildcards = grouped["*"] ?? []
+    const methodGroups: {
+      [method in Http.Method]?: UnboundedRouteWithMethod[]
+    } = {
+      GET: undefined,
+      POST: undefined,
+      PUT: undefined,
+      PATCH: undefined,
+      DELETE: undefined,
+      HEAD: undefined,
+      OPTIONS: undefined,
+    }
+
+    for (const method in grouped) {
+      if (method !== "*") {
+        methodGroups[method] = [...wildcards, ...grouped[method]]
+      }
+    }
+
+    return (request) => {
+      const method = request.method.toUpperCase()
+      const accept = request.headers.get("accept")
+      const group = methodGroups[method]
+
+      if (!group || group.length === 0) {
+        return Promise.resolve(
+          new Response("Method Not Allowed", { status: 405 }),
+        )
+      }
+
+      const route = negotiateRoute(group, accept)
+      if (!route) {
+        return Promise.resolve(
+          new Response("Not Acceptable", { status: 406 }),
+        )
+      }
+      const descriptor = Route.descriptor(route)
+
+      const context = {
+        ...descriptor,
+        request,
+      }
+
+      const effect = route.handler(
+        context as any,
+        () => Effect.succeed(undefined),
+      )
+
+      return run(
+        effect.pipe(
+          Effect.map((result) => toResponse(result, descriptor.format)),
+          Effect.catchAllCause((cause) =>
+            Effect.succeed(
+              new Response(Cause.pretty(cause), { status: 500 }),
+            )
+          ),
+        ),
+      )
+    }
+  }
+}
+
+export const toWebHandler: (
+  routes: Iterable<UnboundedRouteWithMethod>,
+) => Http.WebHandler = toWebHandlerRuntime(Runtime.defaultRuntime)
+
+export function* walkHandles(
+  tree: RouteTree.RouteTree,
+): Generator<[path: string, handler: Http.WebHandler]> {
+  const pathGroups = new Map<
+    string,
+    Array<Route.Route.With<{ path: string; method: string }>>
+  >()
+
+  for (const route of RouteTree.walk(tree)) {
+    const descriptor = Route.descriptor(route)
+    const path = descriptor.path
+    const routes = pathGroups.get(path) ?? []
+    routes.push(route)
+    pathGroups.set(path, routes)
+  }
+
+  for (const [path, routes] of pathGroups) {
+    yield [path, toWebHandler(routes)]
+  }
+}
+
+export function fetch(
+  handle: Http.WebHandler,
+  init: RequestInit & ({ url: string } | { path: string }),
+): Promise<Response> {
+  const url = "path" in init ? `http://localhost${init.path}` : init.url
+  const request = new Request(url, init)
+  return Promise.resolve(handle(request))
+}