effect-start 0.17.2 → 0.19.0

package/src/Http.test.ts

@@ -1,319 +0,0 @@
-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/HttpAppExtra.test.ts

@@ -1,103 +0,0 @@
-import { HttpServerRequest } from "@effect/platform"
-import { RouteNotFound } from "@effect/platform/HttpServerError"
-import * as test from "bun:test"
-import {
-  Layer,
-  Logger,
-} from "effect"
-import * as Cause from "effect/Cause"
-import * as LogLevel from "effect/LogLevel"
-import * as HttpAppExtra from "./HttpAppExtra.ts"
-import { effectFn } from "./testing"
-
-const mockRequest = HttpServerRequest.HttpServerRequest.of({
-  url: "http://localhost:3000/test",
-  method: "GET",
-  headers: {
-    "accept": "application/json",
-    "user-agent": "test",
-  },
-} as any)
-
-const mockRequestLayer = Layer.mergeAll(
-  Layer.succeed(HttpServerRequest.HttpServerRequest, mockRequest),
-  Logger.minimumLogLevel(LogLevel.None),
-)
-
-const effect = effectFn(mockRequestLayer)
-
-test.describe("renderError", () => {
-  const routeNotFoundCause = Cause.fail(
-    new RouteNotFound({ request: {} as any }),
-  )
-
-  test.it("returns JSON for Accept: application/json", () =>
-    effect(function*() {
-      const response = yield* HttpAppExtra.renderError(
-        routeNotFoundCause,
-        "application/json",
-      )
-
-      test
-        .expect(response.status)
-        .toEqual(404)
-      test
-        .expect(response.headers["content-type"])
-        .toContain("application/json")
-    }))
-
-  test.it("returns HTML for Accept: text/html", () =>
-    effect(function*() {
-      const response = yield* HttpAppExtra.renderError(
-        routeNotFoundCause,
-        "text/html",
-      )
-
-      test
-        .expect(response.status)
-        .toEqual(404)
-      test
-        .expect(response.headers["content-type"])
-        .toContain("text/html")
-    }))
-
-  test.it("returns plain text for Accept: text/plain", () =>
-    effect(function*() {
-      const response = yield* HttpAppExtra.renderError(
-        routeNotFoundCause,
-        "text/plain",
-      )
-
-      test
-        .expect(response.status)
-        .toEqual(404)
-      test
-        .expect(response.headers["content-type"])
-        .toContain("text/plain")
-    }))
-
-  test.it("returns JSON by default (no Accept header)", () =>
-    effect(function*() {
-      const response = yield* HttpAppExtra.renderError(routeNotFoundCause, "")
-
-      test
-        .expect(response.status)
-        .toEqual(404)
-      test
-        .expect(response.headers["content-type"])
-        .toContain("application/json")
-    }))
-
-  test.it("returns 500 for unexpected errors", () =>
-    effect(function*() {
-      const unexpectedCause = Cause.fail({ message: "Something went wrong" })
-      const response = yield* HttpAppExtra.renderError(
-        unexpectedCause,
-        "application/json",
-      )
-
-      test
-        .expect(response.status)
-        .toEqual(500)
-    }))
-})

package/src/HttpUtils.test.ts

@@ -1,85 +0,0 @@
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
-import * as test from "bun:test"
-import * as HttpUtils from "./HttpUtils.ts"
-
-const makeRequest = (url: string, headers: Record<string, string> = {}) =>
-  HttpServerRequest.fromWeb(
-    new Request(`http://test${url}`, { headers }),
-  )
-
-test.describe("makeUrlFromRequest", () => {
-  test.it("uses Host header for relative URL", () => {
-    const request = makeRequest("/api/users", {
-      host: "example.com",
-    })
-    const url = HttpUtils.makeUrlFromRequest(request)
-
-    test
-      .expect(url.href)
-      .toBe("http://example.com/api/users")
-  })
-
-  test.it("uses Origin header when present (takes precedence over Host)", () => {
-    const request = makeRequest("/api/users", {
-      origin: "https://app.example.com",
-      host: "example.com",
-    })
-    const url = HttpUtils.makeUrlFromRequest(request)
-
-    test
-      .expect(url.href)
-      .toBe("https://app.example.com/api/users")
-  })
-
-  test.it("uses X-Forwarded-Proto for protocol behind reverse proxy", () => {
-    const request = makeRequest("/api/users", {
-      host: "example.com",
-      "x-forwarded-proto": "https",
-    })
-    const url = HttpUtils.makeUrlFromRequest(request)
-
-    test
-      .expect(url.href)
-      .toBe("https://example.com/api/users")
-  })
-
-  test.it("falls back to http://localhost when no headers", () => {
-    const request = makeRequest("/api/users", {})
-    const url = HttpUtils.makeUrlFromRequest(request)
-
-    test
-      .expect(url.href)
-      .toBe("http://localhost/api/users")
-  })
-
-  test.it("handles URL with query parameters", () => {
-    const request = makeRequest("/search?q=test&page=1", {
-      host: "example.com",
-    })
-    const url = HttpUtils.makeUrlFromRequest(request)
-
-    test
-      .expect(url.href)
-      .toBe("http://example.com/search?q=test&page=1")
-    test
-      .expect(url.searchParams.get("q"))
-      .toBe("test")
-    test
-      .expect(url.searchParams.get("page"))
-      .toBe("1")
-  })
-
-  test.it("handles root path", () => {
-    const request = makeRequest("/", {
-      host: "example.com",
-    })
-    const url = HttpUtils.makeUrlFromRequest(request)
-
-    test
-      .expect(url.href)
-      .toBe("http://example.com/")
-    test
-      .expect(url.pathname)
-      .toBe("/")
-  })
-})