effect-start 0.14.0 → 0.16.0

package/src/FileSystemExtra.test.ts

@@ -1,5 +1,5 @@
 import * as FileSystem from "@effect/platform/FileSystem"
-import * as t from "bun:test"
+import * as test from "bun:test"
 import { MemoryFileSystem } from "effect-memfs"
 import * as Chunk from "effect/Chunk"
 import * as Effect from "effect/Effect"
@@ -8,8 +8,8 @@ import * as Function from "effect/Function"
 import * as Stream from "effect/Stream"
 import * as FileSystemExtra from "./FileSystemExtra.ts"
 
-t.describe(`${FileSystemExtra.watchSource.name}`, () => {
-  t.it("emits events for file creation", () =>
+test.describe(`${FileSystemExtra.watchSource.name}`, () => {
+  test.it("emits events for file creation", () =>
     Effect
       .gen(function*() {
         const fs = yield* FileSystem.FileSystem
@@ -28,11 +28,19 @@ t.describe(`${FileSystemExtra.watchSource.name}`, () => {
 
         const events = yield* Fiber.join(fiber)
 
-        t.expect(Chunk.size(events)).toBeGreaterThan(0)
+        test
+          .expect(Chunk.size(events))
+          .toBeGreaterThan(0)
         const first = Chunk.unsafeGet(events, 0)
-        t.expect(first.path).toContain("test.ts")
-        t.expect(["rename", "change"]).toContain(first.eventType)
-        t.expect(first.filename).toBe("test.ts")
+        test
+          .expect(first.path)
+          .toContain("test.ts")
+        test
+          .expect(["rename", "change"])
+          .toContain(first.eventType)
+        test
+          .expect(first.filename)
+          .toBe("test.ts")
       })
       .pipe(
         Effect.scoped,
@@ -42,7 +50,7 @@ t.describe(`${FileSystemExtra.watchSource.name}`, () => {
         Effect.runPromise,
       ))
 
-  t.it(
+  test.it(
     "emits change event for file modification",
     () =>
       Effect
@@ -63,8 +71,12 @@ t.describe(`${FileSystemExtra.watchSource.name}`, () => {
 
           const events = yield* Fiber.join(fiber)
 
-          t.expect(Chunk.size(events)).toBeGreaterThan(0)
-          t.expect(Chunk.unsafeGet(events, 0).eventType).toBe("change")
+          test
+            .expect(Chunk.size(events))
+            .toBeGreaterThan(0)
+          test
+            .expect(Chunk.unsafeGet(events, 0).eventType)
+            .toBe("change")
         })
         .pipe(
           Effect.scoped,
@@ -75,7 +87,7 @@ t.describe(`${FileSystemExtra.watchSource.name}`, () => {
         ),
   )
 
-  t.it("applies custom filter", () =>
+  test.it("applies custom filter", () =>
     Effect
       .gen(function*() {
         const fs = yield* FileSystem.FileSystem
@@ -98,8 +110,12 @@ t.describe(`${FileSystemExtra.watchSource.name}`, () => {
 
         const events = yield* Fiber.join(fiber)
 
-        t.expect(Chunk.size(events)).toBe(1)
-        t.expect(Chunk.unsafeGet(events, 0).path).toContain("included.ts")
+        test
+          .expect(Chunk.size(events))
+          .toBe(1)
+        test
+          .expect(Chunk.unsafeGet(events, 0).path)
+          .toContain("included.ts")
       })
       .pipe(
         Effect.scoped,
@@ -110,9 +126,9 @@ t.describe(`${FileSystemExtra.watchSource.name}`, () => {
       ))
 })
 
-t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
-  t.it("matches source file extensions", () => {
-    t
+test.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
+  test.it("matches source file extensions", () => {
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -121,7 +137,7 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
         }),
       )
       .toBe(true)
-    t
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -130,7 +146,7 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
         }),
       )
       .toBe(true)
-    t
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -139,7 +155,7 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
         }),
       )
       .toBe(true)
-    t
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -148,7 +164,7 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
         }),
       )
       .toBe(true)
-    t
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -157,7 +173,7 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
         }),
       )
       .toBe(true)
-    t
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -166,7 +182,7 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
         }),
       )
       .toBe(true)
-    t
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -177,8 +193,8 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
       .toBe(true)
   })
 
-  t.it("rejects non-source files", () => {
-    t
+  test.it("rejects non-source files", () => {
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -187,7 +203,7 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
         }),
       )
       .toBe(false)
-    t
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -199,9 +215,9 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
   })
 })
 
-t.describe(`${FileSystemExtra.filterDirectory.name}`, () => {
-  t.it("matches directories", () => {
-    t
+test.describe(`${FileSystemExtra.filterDirectory.name}`, () => {
+  test.it("matches directories", () => {
+    test
       .expect(
         FileSystemExtra.filterDirectory({
           eventType: "change",
@@ -212,8 +228,8 @@ t.describe(`${FileSystemExtra.filterDirectory.name}`, () => {
       .toBe(true)
   })
 
-  t.it("rejects files", () => {
-    t
+  test.it("rejects files", () => {
+    test
       .expect(
         FileSystemExtra.filterDirectory({
           eventType: "change",

package/src/Http.test.ts

@@ -0,0 +1,319 @@
+import * as test from "bun:test"
+import * as Http from "./Http.ts"
+
+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

@@ -0,0 +1,167 @@
+import * as Values from "./Values.ts"
+
+export type Method =
+  | "GET"
+  | "POST"
+  | "PUT"
+  | "DELETE"
+  | "PATCH"
+  | "HEAD"
+  | "OPTIONS"
+
+type Respondable =
+  | Response
+  | Promise<Response>
+
+export type WebHandler = (request: Request) => Respondable
+
+export type WebMiddleware = (
+  request: Request,
+  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,
+  })
+  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 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
+}