effect-start 0.15.0 → 0.17.0

package/src/Http.test.ts

@@ -1,24 +1,319 @@
 import * as test from "bun:test"
 import * as Http from "./Http.ts"
 
-test.it("cloneRequest copies request and adds props", () => {
-  const request = new Request("http://localhost/test", {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-  })
-
-  const cloned = Http.cloneRequest(request, { params: { id: "123" } })
-
-  test
-    .expect(cloned.url)
-    .toBe("http://localhost/test")
-  test
-    .expect(cloned.method)
-    .toBe("POST")
-  test
-    .expect(cloned.headers.get("Content-Type"))
-    .toBe("application/json")
-  test
-    .expect(cloned.params)
-    .toEqual({ id: "123" })
+test.describe("mapHeaders", () => {
+  test.it("converts Headers to record with lowercase keys", () => {
+    const headers = new Headers({
+      "Content-Type": "application/json",
+      "X-Custom-Header": "value",
+    })
+
+    const record = Http.mapHeaders(headers)
+
+    test
+      .expect(record)
+      .toEqual({
+        "content-type": "application/json",
+        "x-custom-header": "value",
+      })
+  })
+
+  test.it("returns empty record for empty headers", () => {
+    const headers = new Headers()
+    const record = Http.mapHeaders(headers)
+
+    test
+      .expect(record)
+      .toEqual({})
+  })
+})
+
+test.describe("parseCookies", () => {
+  test.it("parses cookie header string", () => {
+    const cookieHeader = "session=abc123; token=xyz789"
+    const cookies = Http.parseCookies(cookieHeader)
+
+    test
+      .expect(cookies)
+      .toEqual({
+        session: "abc123",
+        token: "xyz789",
+      })
+  })
+
+  test.it("handles cookies with = in value", () => {
+    const cookieHeader = "data=key=value"
+    const cookies = Http.parseCookies(cookieHeader)
+
+    test
+      .expect(cookies)
+      .toEqual({
+        data: "key=value",
+      })
+  })
+
+  test.it("trims whitespace from cookie names and values", () => {
+    const cookieHeader = " session = abc123 ; token = xyz789 "
+    const cookies = Http.parseCookies(cookieHeader)
+
+    test
+      .expect(cookies)
+      .toEqual({
+        session: "abc123",
+        token: "xyz789",
+      })
+  })
+
+  test.it("handles empty cookie values", () => {
+    const cookieHeader = "session=; token=xyz789"
+    const cookies = Http.parseCookies(cookieHeader)
+
+    test
+      .expect(cookies)
+      .toEqual({
+        session: "",
+        token: "xyz789",
+      })
+  })
+
+  test.it("handles cookies without values", () => {
+    const cookieHeader = "flag; session=abc123"
+    const cookies = Http.parseCookies(cookieHeader)
+
+    test
+      .expect(cookies)
+      .toEqual({
+        flag: undefined,
+        session: "abc123",
+      })
+  })
+
+  test.it("ignores empty parts", () => {
+    const cookieHeader = "session=abc123;; ; token=xyz789"
+    const cookies = Http.parseCookies(cookieHeader)
+
+    test
+      .expect(cookies)
+      .toEqual({
+        session: "abc123",
+        token: "xyz789",
+      })
+  })
+
+  test.it("returns empty record for null cookie header", () => {
+    const cookies = Http.parseCookies(null)
+
+    test
+      .expect(cookies)
+      .toEqual({})
+  })
+
+  test.it("returns empty record for empty cookie header", () => {
+    const cookies = Http.parseCookies("")
+
+    test
+      .expect(cookies)
+      .toEqual({})
+  })
+})
+
+test.describe("mapUrlSearchParams", () => {
+  test.it("converts single values to strings", () => {
+    const params = new URLSearchParams("page=1&limit=10")
+    const record = Http.mapUrlSearchParams(params)
+
+    test
+      .expect(record)
+      .toEqual({
+        page: "1",
+        limit: "10",
+      })
+  })
+
+  test.it("converts multiple values to arrays", () => {
+    const params = new URLSearchParams("tags=red&tags=blue&tags=green")
+    const record = Http.mapUrlSearchParams(params)
+
+    test
+      .expect(record)
+      .toEqual({
+        tags: ["red", "blue", "green"],
+      })
+  })
+
+  test.it("handles mixed single and multiple values", () => {
+    const params = new URLSearchParams("page=1&tags=red&tags=blue")
+    const record = Http.mapUrlSearchParams(params)
+
+    test
+      .expect(record)
+      .toEqual({
+        page: "1",
+        tags: ["red", "blue"],
+      })
+  })
+
+  test.it("returns empty record for empty params", () => {
+    const params = new URLSearchParams()
+    const record = Http.mapUrlSearchParams(params)
+
+    test
+      .expect(record)
+      .toEqual({})
+  })
+})
+
+test.describe("parseFormData", () => {
+  function createFormDataRequest(formData: FormData): Request {
+    return new Request("http://localhost/", {
+      method: "POST",
+      body: formData,
+    })
+  }
+
+  test.it("parses single string field", async () => {
+    const formData = new FormData()
+    formData.append("name", "John")
+
+    const request = createFormDataRequest(formData)
+    const result = await Http.parseFormData(request)
+
+    test
+      .expect(result)
+      .toEqual({
+        name: "John",
+      })
+  })
+
+  test.it("parses multiple string fields", async () => {
+    const formData = new FormData()
+    formData.append("name", "John")
+    formData.append("email", "john@example.com")
+
+    const request = createFormDataRequest(formData)
+    const result = await Http.parseFormData(request)
+
+    test
+      .expect(result)
+      .toEqual({
+        name: "John",
+        email: "john@example.com",
+      })
+  })
+
+  test.it("parses multiple values for same key as array", async () => {
+    const formData = new FormData()
+    formData.append("tags", "red")
+    formData.append("tags", "blue")
+    formData.append("tags", "green")
+
+    const request = createFormDataRequest(formData)
+    const result = await Http.parseFormData(request)
+
+    test
+      .expect(result)
+      .toEqual({
+        tags: ["red", "blue", "green"],
+      })
+  })
+
+  test.it("parses single file upload", async () => {
+    const formData = new FormData()
+    const fileContent = new Uint8Array([72, 101, 108, 108, 111]) // "Hello"
+    const file = new File([fileContent], "test.txt", { type: "text/plain" })
+    formData.append("document", file)
+
+    const request = createFormDataRequest(formData)
+    const result = await Http.parseFormData(request)
+
+    test.expect(result.document).toBeDefined()
+    const files = result.document as ReadonlyArray<Http.FilePart>
+    test.expect(files).toHaveLength(1)
+    test.expect(files[0]._tag).toBe("File")
+    test.expect(files[0].key).toBe("document")
+    test.expect(files[0].name).toBe("test.txt")
+    test.expect(files[0].contentType.startsWith("text/plain")).toBe(true)
+    test.expect(files[0].content).toEqual(fileContent)
+  })
+
+  test.it("parses multiple file uploads for same key", async () => {
+    const formData = new FormData()
+    const file1 = new File([new Uint8Array([1, 2, 3])], "file1.bin", {
+      type: "application/octet-stream",
+    })
+    const file2 = new File([new Uint8Array([4, 5, 6])], "file2.bin", {
+      type: "application/octet-stream",
+    })
+    formData.append("files", file1)
+    formData.append("files", file2)
+
+    const request = createFormDataRequest(formData)
+    const result = await Http.parseFormData(request)
+
+    const files = result.files as ReadonlyArray<Http.FilePart>
+    test.expect(files).toHaveLength(2)
+    test.expect(files[0].name).toBe("file1.bin")
+    test.expect(files[0].content).toEqual(new Uint8Array([1, 2, 3]))
+    test.expect(files[1].name).toBe("file2.bin")
+    test.expect(files[1].content).toEqual(new Uint8Array([4, 5, 6]))
+  })
+
+  test.it("uses default content type for files without type", async () => {
+    const formData = new FormData()
+    const file = new File([new Uint8Array([1, 2, 3])], "unknown.dat", {
+      type: "",
+    })
+    formData.append("upload", file)
+
+    const request = createFormDataRequest(formData)
+    const result = await Http.parseFormData(request)
+
+    const files = result.upload as ReadonlyArray<Http.FilePart>
+    test.expect(files[0].contentType).toBe("application/octet-stream")
+  })
+
+  test.it("parses mixed string fields and file uploads", async () => {
+    const formData = new FormData()
+    formData.append("title", "My Document")
+    const file = new File([new Uint8Array([1, 2, 3])], "doc.pdf", {
+      type: "application/pdf",
+    })
+    formData.append("attachment", file)
+    formData.append("description", "A test document")
+
+    const request = createFormDataRequest(formData)
+    const result = await Http.parseFormData(request)
+
+    test.expect(result.title).toBe("My Document")
+    test.expect(result.description).toBe("A test document")
+    const files = result.attachment as ReadonlyArray<Http.FilePart>
+    test.expect(files).toHaveLength(1)
+    test.expect(files[0].name).toBe("doc.pdf")
+  })
+
+  test.it("returns empty record for empty form data", async () => {
+    const formData = new FormData()
+
+    const request = createFormDataRequest(formData)
+    const result = await Http.parseFormData(request)
+
+    test
+      .expect(result)
+      .toEqual({})
+  })
+
+  test.it("parses Blob as file", async () => {
+    const formData = new FormData()
+    const blob = new Blob([new Uint8Array([10, 20, 30])], { type: "image/png" })
+    formData.append("image", blob, "image.png")
+
+    const request = createFormDataRequest(formData)
+    const result = await Http.parseFormData(request)
+
+    const files = result.image as ReadonlyArray<Http.FilePart>
+    test.expect(files).toHaveLength(1)
+    test.expect(files[0].name).toBe("image.png")
+    test.expect(files[0].contentType).toBe("image/png")
+    test.expect(files[0].content).toEqual(new Uint8Array([10, 20, 30]))
+  })
 })

package/src/Http.ts

@@ -1,3 +1,5 @@
+import * as Values from "./Values.ts"
+
 export type Method =
   | "GET"
   | "POST"
@@ -7,19 +9,159 @@ export type Method =
   | "HEAD"
   | "OPTIONS"
 
-export type WebHandler = (request: Request) => Response | Promise<Response>
+type Respondable =
+  | Response
+  | Promise<Response>
+
+export type WebHandler = (request: Request) => Respondable
 
-export function cloneRequest<T extends object>(
+export type WebMiddleware = (
   request: Request,
-  props: T,
-): Request & T {
-  const cloned = new Request(request.url, {
-    method: request.method,
-    headers: request.headers,
-    body: request.body,
+  next: WebHandler,
+) => Respondable
+
+export function fetch(
+  handler: WebHandler,
+  init:
+    & Omit<RequestInit, "body">
+    & (
+      | { url: string }
+      | { path: `/${string}` }
+    )
+    & { body?: RequestInit["body"] | Record<string, unknown> },
+): Promise<Response> {
+  const url = "path" in init
+    ? `http://localhost${init.path}`
+    : init.url
+
+  const isPlain = Values.isPlainObject(init.body)
+
+  const headers = new Headers(init.headers)
+  if (isPlain && !headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json")
+  }
+
+  const body = isPlain ? JSON.stringify(init.body) : init.body
+
+  const request = new Request(url, {
+    ...init,
+    headers,
+    body: body as BodyInit,
   })
-  for (const [key, value] of Object.entries(props)) {
-    ;(cloned as any)[key] = value
+  return Promise.resolve(handler(request))
+}
+
+export function createAbortableRequest(
+  init:
+    & Omit<RequestInit, "signal">
+    & (
+      | { url: string }
+      | { path: `/${string}` }
+    ),
+): { request: Request; abort: () => void } {
+  const url = "path" in init
+    ? `http://localhost${init.path}`
+    : init.url
+  const controller = new AbortController()
+  const request = new Request(url, { ...init, signal: controller.signal })
+  return { request, abort: () => controller.abort() }
+}
+
+export function mapHeaders(
+  headers: Headers,
+): Record<string, string | undefined> {
+  const result: Record<string, string | undefined> = {}
+  headers.forEach((value, key) => {
+    result[key.toLowerCase()] = value
+  })
+  return result
+}
+
+export function parseCookies(
+  cookieHeader: string | null,
+): Record<string, string | undefined> {
+  if (!cookieHeader) return {}
+  const result: Record<string, string | undefined> = {}
+  for (const part of cookieHeader.split(";")) {
+    const idx = part.indexOf("=")
+    if (idx === -1) {
+      // Cookie without value (e.g., "name" or just whitespace)
+      const key = part.trim()
+      if (key) {
+        result[key] = undefined
+      }
+    } else {
+      const key = part.slice(0, idx).trim()
+      const value = part.slice(idx + 1).trim()
+      if (key) {
+        result[key] = value
+      }
+    }
   }
-  return cloned as Request & T
+  return result
+}
+
+export function mapUrlSearchParams(
+  params: URLSearchParams,
+): Record<string, string | ReadonlyArray<string> | undefined> {
+  const result: Record<string, string | ReadonlyArray<string> | undefined> = {}
+  for (const key of new Set(params.keys())) {
+    const values = params.getAll(key)
+    result[key] = values.length === 1 ? values[0] : values
+  }
+  return result
+}
+
+export interface FilePart {
+  readonly _tag: "File"
+  readonly key: string
+  readonly name: string
+  readonly contentType: string
+  readonly content: Uint8Array
+}
+
+export interface FieldPart {
+  readonly _tag: "Field"
+  readonly key: string
+  readonly value: string
+}
+
+export type MultipartPart = FilePart | FieldPart
+
+export async function parseFormData(
+  request: Request,
+): Promise<
+  Record<string, ReadonlyArray<FilePart> | ReadonlyArray<string> | string>
+> {
+  const formData = await request.formData()
+  const result: Record<
+    string,
+    ReadonlyArray<FilePart> | ReadonlyArray<string> | string
+  > = {}
+
+  for (const key of new Set(formData.keys())) {
+    const values = formData.getAll(key)
+    const first = values[0]
+
+    if (typeof first === "string") {
+      result[key] = values.length === 1 ? first : (values as string[])
+    } else {
+      const files: FilePart[] = []
+      for (const value of values) {
+        if (typeof value !== "string") {
+          const content = new Uint8Array(await value.arrayBuffer())
+          files.push({
+            _tag: "File",
+            key,
+            name: value.name,
+            contentType: value.type || "application/octet-stream",
+            content,
+          })
+        }
+      }
+      result[key] = files
+    }
+  }
+
+  return result
 }

package/src/PathPattern.ts

@@ -477,7 +477,9 @@ export function toBun(path: string): PathPattern[] {
     : `:${optionalName}`
 
   const withOptionalSegments = [...before, requiredOptional, ...after]
-  const withOptionalPath: PathPattern = `/${withOptionalSegments.map(formatSegment).join("/")}`
+  const withOptionalPath: PathPattern = `/${
+    withOptionalSegments.map(formatSegment).join("/")
+  }`
 
   return [...toBun(basePath), ...toBun(withOptionalPath)]
 }

package/src/Route.ts

@@ -3,6 +3,7 @@ import type * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Pipeable from "effect/Pipeable"
 import * as Predicate from "effect/Predicate"
+import type * as Entity from "./Entity.ts"
 import * as RouteBody from "./RouteBody.ts"
 import * as RouteTree from "./RouteTree.ts"
 import * as Values from "./Values.ts"
@@ -99,14 +100,8 @@ export namespace Route {
 
   export type Handler<B, A, E, R> = (
     context: B,
-    next: (context: B) => Effect.Effect<A>,
-  ) => Effect.Effect<A, E, R>
-
-  // handler that cannot modify the context
-  export type HandlerImmutable<B, A, E, R> = (
-    context: B,
-    next: () => Effect.Effect<A>,
-  ) => Effect.Effect<A, E, R>
+    next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<A>,
+  ) => Effect.Effect<Entity.Entity<A>, E, R>
 
   /**
    * Extracts only the bindings (B) from routes, excluding descriptors.
@@ -246,8 +241,21 @@ export function descriptor<
   T extends RouteSet.Data<any, any, any>,
 >(
   self: T,
-): T[typeof RouteDescriptor] {
-  return self[RouteDescriptor]
+): T[typeof RouteDescriptor]
+export function descriptor<
+  T extends RouteSet.Data<any, any, any>,
+>(
+  self: Iterable<T>,
+): T[typeof RouteDescriptor][]
+export function descriptor(
+  self:
+    | RouteSet.Data<any, any, any>
+    | Iterable<RouteSet.Data<any, any, any>>,
+): RouteDescriptor.Any | RouteDescriptor.Any[] {
+  if (RouteDescriptor in self) {
+    return self[RouteDescriptor]
+  }
+  return [...self].map((r) => r[RouteDescriptor])
 }
 
 export type ExtractBindings<
@@ -311,6 +319,14 @@ export const bytes = RouteBody.build<Uint8Array, "bytes">({
   format: "bytes",
 })
 
+export {
+  render,
+} from "./RouteBody.ts"
+
+export {
+  sse,
+} from "./RouteSse.ts"
+
 export class Routes extends Context.Tag("effect-start/Routes")<
   Routes,
   RouteTree.RouteTree