effect-start 0.15.0 → 0.16.0

package/src/Entity.ts

@@ -0,0 +1,362 @@
+import * as Effect from "effect/Effect"
+import * as ParseResult from "effect/ParseResult"
+import * as Pipeable from "effect/Pipeable"
+import * as Predicate from "effect/Predicate"
+import * as Schema from "effect/Schema"
+import * as Stream from "effect/Stream"
+import * as StreamExtra from "./StreamExtra.ts"
+import * as Values from "./Values.ts"
+
+export const TypeId: unique symbol = Symbol.for("effect-start/Entity")
+export type TypeId = typeof TypeId
+
+const textDecoder = new TextDecoder()
+const textEncoder = new TextEncoder()
+
+function isBinary(v: unknown): v is Uint8Array | ArrayBuffer {
+  return v instanceof Uint8Array || v instanceof ArrayBuffer
+}
+
+/**
+ * Header keys are guaranteed to be lowercase.
+ */
+export type Headers = {
+  [header: string]: string | null | undefined
+}
+
+export interface Entity<
+  T = unknown,
+  E = never,
+> extends Pipeable.Pipeable {
+  readonly [TypeId]: TypeId
+  readonly body: T
+  readonly headers: Headers
+  /**
+   * Accepts any valid URI (Uniform Resource Identifier), including URLs
+   * (http://, https://, file://), URNs (urn:isbn:...), S3 URIs (s3://bucket/key),
+   * data URIs, and other schemes. While commonly called "URL" in many APIs,
+   * this property handles URIs as the correct superset term per RFC 3986.
+   */
+  readonly url: string | undefined
+  readonly status: number | undefined
+  readonly text: T extends string
+    ? Effect.Effect<T, ParseResult.ParseError | E>
+    : Effect.Effect<string, ParseResult.ParseError | E>
+  readonly json: [T] extends [Effect.Effect<infer A, any, any>]
+    ? Effect.Effect<
+      A extends string | Uint8Array | ArrayBuffer ? unknown : A,
+      ParseResult.ParseError | E
+    >
+    : [T] extends [Stream.Stream<any, any, any>]
+      ? Effect.Effect<unknown, ParseResult.ParseError | E>
+    : [T] extends [string | Uint8Array | ArrayBuffer]
+      ? Effect.Effect<unknown, ParseResult.ParseError | E>
+    : [T] extends [Values.Json]
+      ? Effect.Effect<T, ParseResult.ParseError | E>
+    : Effect.Effect<unknown, ParseResult.ParseError | E>
+  readonly bytes: Effect.Effect<Uint8Array, ParseResult.ParseError | E>
+  readonly stream: T extends Stream.Stream<infer A, infer E1, any>
+    ? Stream.Stream<A, ParseResult.ParseError | E | E1>
+    : Stream.Stream<Uint8Array, ParseResult.ParseError | E>
+}
+
+export interface Proto extends Pipeable.Pipeable {
+  readonly [TypeId]: TypeId
+}
+
+function parseJson(s: string): Effect.Effect<unknown, ParseResult.ParseError> {
+  try {
+    return Effect.succeed(JSON.parse(s))
+  } catch (e) {
+    return Effect.fail(
+      new ParseResult.ParseError({
+        issue: new ParseResult.Type(
+          Schema.Unknown.ast,
+          s,
+          e instanceof Error ? e.message : "Failed to parse JSON",
+        ),
+      }),
+    )
+  }
+}
+
+function getText(
+  self: Entity<unknown, unknown>,
+): Effect.Effect<string, ParseResult.ParseError | unknown> {
+  const v = self.body
+  if (StreamExtra.isStream(v)) {
+    return Stream.mkString(
+      Stream.decodeText(v as Stream.Stream<Uint8Array, unknown, never>),
+    )
+  }
+  if (Effect.isEffect(v)) {
+    return Effect.flatMap(
+      v as Effect.Effect<unknown, unknown, never>,
+      (inner): Effect.Effect<string, ParseResult.ParseError | unknown> => {
+        if (isEntity(inner)) {
+          return inner.text
+        }
+        if (typeof inner === "string") {
+          return Effect.succeed(inner)
+        }
+        if (isBinary(inner)) {
+          return Effect.succeed(textDecoder.decode(inner))
+        }
+        return Effect.fail(mismatch(Schema.String, inner))
+      },
+    )
+  }
+  if (typeof v === "string") {
+    return Effect.succeed(v)
+  }
+  if (isBinary(v)) {
+    return Effect.succeed(textDecoder.decode(v))
+  }
+  return Effect.fail(mismatch(Schema.String, v))
+}
+
+function getJson(
+  self: Entity<unknown, unknown>,
+): Effect.Effect<unknown, ParseResult.ParseError | unknown> {
+  const v = self.body
+  if (StreamExtra.isStream(v)) {
+    return Effect.flatMap(getText(self), parseJson)
+  }
+  if (Effect.isEffect(v)) {
+    return Effect.flatMap(
+      v as Effect.Effect<unknown, unknown, never>,
+      (inner): Effect.Effect<unknown, ParseResult.ParseError | unknown> => {
+        if (isEntity(inner)) {
+          return inner.json
+        }
+        if (typeof inner === "object" && inner !== null && !isBinary(inner)) {
+          return Effect.succeed(inner)
+        }
+        if (typeof inner === "string") {
+          return parseJson(inner)
+        }
+        if (isBinary(inner)) {
+          return parseJson(textDecoder.decode(inner))
+        }
+        return Effect.fail(mismatch(Schema.Unknown, inner))
+      },
+    )
+  }
+  if (typeof v === "object" && v !== null && !isBinary(v)) {
+    return Effect.succeed(v)
+  }
+  if (typeof v === "string") {
+    return parseJson(v)
+  }
+  if (isBinary(v)) {
+    return parseJson(textDecoder.decode(v))
+  }
+  return Effect.fail(mismatch(Schema.Unknown, v))
+}
+
+function getBytes(
+  self: Entity<unknown, unknown>,
+): Effect.Effect<Uint8Array, ParseResult.ParseError | unknown> {
+  const v = self.body
+  if (StreamExtra.isStream(v)) {
+    return Stream.runFold(
+      v as Stream.Stream<Uint8Array, unknown, never>,
+      new Uint8Array(0),
+      Values.concatBytes,
+    )
+  }
+  if (Effect.isEffect(v)) {
+    return Effect.flatMap(
+      v as Effect.Effect<unknown, unknown, never>,
+      (inner): Effect.Effect<Uint8Array, ParseResult.ParseError | unknown> => {
+        if (isEntity(inner)) {
+          return inner.bytes
+        }
+        if (inner instanceof Uint8Array) {
+          return Effect.succeed(inner)
+        }
+        if (inner instanceof ArrayBuffer) {
+          return Effect.succeed(new Uint8Array(inner))
+        }
+        if (typeof inner === "string") {
+          return Effect.succeed(textEncoder.encode(inner))
+        }
+        return Effect.fail(mismatch(Schema.Uint8ArrayFromSelf, inner))
+      },
+    )
+  }
+  if (v instanceof Uint8Array) {
+    return Effect.succeed(v)
+  }
+  if (v instanceof ArrayBuffer) {
+    return Effect.succeed(new Uint8Array(v))
+  }
+  if (typeof v === "string") {
+    return Effect.succeed(textEncoder.encode(v))
+  }
+  // Allows entity.stream to work when body is a JSON object
+  if (typeof v === "object" && v !== null && !isBinary(v)) {
+    return Effect.succeed(textEncoder.encode(JSON.stringify(v)))
+  }
+  return Effect.fail(mismatch(Schema.Uint8ArrayFromSelf, v))
+}
+
+function getStream<A, E1, E2>(
+  self: Entity<Stream.Stream<A, E1, never>, E2>,
+): Stream.Stream<A, ParseResult.ParseError | E1 | E2>
+function getStream<T, E>(
+  self: Entity<T, E>,
+): Stream.Stream<Uint8Array, ParseResult.ParseError | E>
+function getStream(
+  self: Entity<unknown, unknown>,
+): Stream.Stream<unknown, unknown> {
+  const v = self.body
+  if (StreamExtra.isStream(v)) {
+    return v as Stream.Stream<unknown, unknown, never>
+  }
+  if (Effect.isEffect(v)) {
+    return Stream.unwrap(
+      Effect.map(
+        v as Effect.Effect<unknown, unknown, never>,
+        (inner) => {
+          if (isEntity(inner)) {
+            return inner.stream
+          }
+          return Stream.fromEffect(getBytes(make(inner)))
+        },
+      ),
+    )
+  }
+  return Stream.fromEffect(getBytes(self))
+}
+
+const Proto: Proto = Object.defineProperties(
+  Object.create(null),
+  {
+    [TypeId]: { value: TypeId },
+    pipe: {
+      value: function(this: Entity) {
+        return Pipeable.pipeArguments(this, arguments)
+      },
+    },
+    text: {
+      get(this: Entity<unknown, unknown>) {
+        return getText(this)
+      },
+    },
+    json: {
+      get(this: Entity<unknown, unknown>) {
+        return getJson(this)
+      },
+    },
+    bytes: {
+      get(this: Entity<unknown, unknown>) {
+        return getBytes(this)
+      },
+    },
+    stream: {
+      get(this: Entity<unknown, unknown>) {
+        return getStream(this)
+      },
+    },
+  },
+)
+
+export function isEntity(input: unknown): input is Entity {
+  return Predicate.hasProperty(input, TypeId)
+}
+
+interface Options {
+  readonly headers?: Headers
+  readonly url?: string
+  readonly status?: number
+}
+
+export function make<A, E>(
+  body: Effect.Effect<A, E, never>,
+  options?: Options,
+): Entity<Effect.Effect<A, E, never>, E>
+export function make<A extends Uint8Array | string, E>(
+  body: Stream.Stream<A, E, never>,
+  options?: Options,
+): Entity<Stream.Stream<A, E, never>, E>
+export function make<T>(body: T, options?: Options): Entity<T, never>
+export function make(
+  body: unknown,
+  options?: Options,
+): Entity<unknown, unknown> {
+  return Object.assign(
+    Object.create(Proto),
+    {
+      body,
+      headers: options?.headers ?? {},
+      url: options?.url,
+      status: options?.status,
+    },
+  )
+}
+
+export function effect<A, E, R>(
+  body: Effect.Effect<Entity<A> | A, E, R>,
+): Entity<A, E> {
+  return make(body) as unknown as Entity<A, E>
+}
+
+export function resolve<A, E>(
+  entity: Entity<A, E>,
+): Effect.Effect<Entity<A, E>, E, never> {
+  const body = entity.body
+  if (Effect.isEffect(body)) {
+    return Effect.map(
+      body as Effect.Effect<Entity<A> | A, E, never>,
+      (inner) =>
+        isEntity(inner)
+          ? inner as Entity<A, E>
+          : make(inner as A, {
+            status: entity.status,
+            headers: entity.headers,
+            url: entity.url,
+          }) as Entity<A, E>,
+    )
+  }
+  return Effect.succeed(entity)
+}
+
+export function type(self: Entity): string {
+  const h = self.headers
+  if (h["content-type"]) {
+    return h["content-type"]
+  }
+  const v = self.body
+  if (typeof v === "string") {
+    return "text/plain"
+  }
+  if (typeof v === "object" && v !== null && !isBinary(v)) {
+    return "application/json"
+  }
+  return "application/octet-stream"
+}
+
+export function length(self: Entity): number | undefined {
+  const h = self.headers
+  if (h["content-length"]) {
+    return parseInt(h["content-length"], 10)
+  }
+  const v = self.body
+  if (typeof v === "string") {
+    return textEncoder.encode(v).byteLength
+  }
+  if (isBinary(v)) {
+    return v.byteLength
+  }
+  return undefined
+}
+
+function mismatch(
+  expected: Schema.Schema.Any,
+  actual: unknown,
+): ParseResult.ParseError {
+  return new ParseResult.ParseError({
+    issue: new ParseResult.Type(expected.ast, actual),
+  })
+}

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]))
+  })
 })