effect-start 0.15.0 → 0.16.0

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,10 @@ export const bytes = RouteBody.build<Uint8Array, "bytes">({
   format: "bytes",
 })
 
+export {
+  render,
+} from "./RouteBody.ts"
+
 export class Routes extends Context.Tag("effect-start/Routes")<
   Routes,
   RouteTree.RouteTree

package/src/RouteBody.test.ts

@@ -1,15 +1,14 @@
 import * as test from "bun:test"
 import * as Effect from "effect/Effect"
+import * as Stream from "effect/Stream"
+import * as Entity from "./Entity.ts"
+import * as Route from "./Route.ts"
 import * as RouteBody from "./RouteBody.ts"
 import * as RouteMount from "./RouteMount.ts"
 
-const text = RouteBody.build<string, "text">({
-  format: "text",
-})
-
 test.it("infers parent descriptions", () => {
   RouteMount.get(
-    text((ctx) =>
+    Route.text((ctx) =>
       Effect.gen(function*() {
         test
           .expectTypeOf(ctx)
@@ -24,13 +23,12 @@ test.it("infers parent descriptions", () => {
   )
 })
 
-test.it("cannot modify context", () => {
-  text((ctx, next) =>
+test.it("next is function returning Entity", () => {
+  Route.text((ctx, next) =>
     Effect.gen(function*() {
       test
         .expectTypeOf(next)
-        .parameters
-        .toEqualTypeOf<[]>()
+        .toExtend<() => Entity.Entity<string>>()
 
       return "Hello, world!"
     })
@@ -39,24 +37,66 @@ test.it("cannot modify context", () => {
 
 test.it("enforces result value", () => {
   // @ts-expect-error must return string
-  text((ctx, next) =>
+  Route.text((ctx, next) =>
     Effect.gen(function*() {
       return 1337
     })
   )
 })
 
+test.it("accepts text stream", () => {
+  RouteMount.get(
+    Route.text((ctx) =>
+      Effect.gen(function*() {
+        test
+          .expectTypeOf(ctx)
+          .toExtend<{
+            method: "GET"
+            format: "text"
+          }>()
+
+        return Stream.make("Hello", " ", "world!")
+      })
+    ),
+  )
+})
+
+test.it("accepts Effect<Stream<string>> for html format", () => {
+  RouteMount.get(
+    Route.html(function*() {
+      return Stream.make("<div>", "content", "</div>")
+    }),
+  )
+})
+
+test.it("accepts Effect<Stream<Uint8Array>> for bytes format", () => {
+  const encoder = new TextEncoder()
+
+  RouteMount.get(
+    Route.bytes(function*() {
+      return Stream.make(encoder.encode("chunk"))
+    }),
+  )
+})
+
+test.it("rejects Stream for json format", () => {
+  // @ts-expect-error Stream not allowed for json format
+  Route.json(function*() {
+    return Stream.make({ msg: "hello" })
+  })
+})
+
 test.it("accepts value directly", () => {
   const value = "Hello, world!"
 
   test
-    .expectTypeOf(text)
+    .expectTypeOf(Route.text)
     .toBeCallableWith(value)
 })
 
 test.describe(`${RouteBody.handle.name}()`, () => {
   const ctx = {}
-  const next = () => Effect.succeed("next" as const)
+  const next = () => Entity.effect(Effect.succeed(Entity.make("next")))
 
   test.it("accepts all HandlerInput variants", () => {
     test
@@ -73,11 +113,12 @@ test.describe(`${RouteBody.handle.name}()`, () => {
       .expectTypeOf(handler)
       .returns
       .toEqualTypeOf<
-        Effect.Effect<string, never, never>
+        Effect.Effect<Entity.Entity<string>, never, never>
       >()
 
     const result = await Effect.runPromise(handler(ctx, next))
-    test.expect(result).toBe("hello")
+    test.expect(result.body).toBe("hello")
+    test.expect(result.status).toBe(200)
   })
 
   test.it("handles Effect directly", async () => {
@@ -87,13 +128,13 @@ test.describe(`${RouteBody.handle.name}()`, () => {
       .expectTypeOf(handler)
       .returns
       .toEqualTypeOf<
-        Effect.Effect<string, never, never>
+        Effect.Effect<Entity.Entity<string>, never, never>
       >()
 
     const result = await Effect.runPromise(handler(ctx, next))
 
     test
-      .expect(result)
+      .expect(result.body)
       .toBe("from effect")
   })
 
@@ -104,7 +145,7 @@ test.describe(`${RouteBody.handle.name}()`, () => {
       .expectTypeOf(handler)
       .returns
       .toEqualTypeOf<
-        Effect.Effect<never, Error, never>
+        Effect.Effect<Entity.Entity<never>, Error, never>
       >()
   })
 
@@ -117,21 +158,27 @@ test.describe(`${RouteBody.handle.name}()`, () => {
       .expectTypeOf(handler)
       .parameters
       .toEqualTypeOf<
-        [{ id: number }, () => Effect.Effect<number>]
+        [
+          { id: number },
+          (
+            context?: Partial<{ id: number }> & Record<string, unknown>,
+          ) => Entity.Entity<number>,
+        ]
       >()
     test
       .expectTypeOf(handler)
       .returns
       .toEqualTypeOf<
-        Effect.Effect<number, never, never>
+        Effect.Effect<Entity.Entity<number>, never, never>
       >()
 
+    const numNext = () => Entity.effect(Effect.succeed(Entity.make(23)))
     const result = await Effect.runPromise(
-      handler({ id: 42 }, () => Effect.succeed(23)),
+      handler({ id: 42 }, numNext),
     )
 
     test
-      .expect(result)
+      .expect(result.body)
       .toBe(42)
   })
 
@@ -145,30 +192,35 @@ test.describe(`${RouteBody.handle.name}()`, () => {
       .expectTypeOf(handler)
       .parameters
       .toEqualTypeOf<
-        [{ id: number }, () => Effect.Effect<number>]
+        [
+          { id: number },
+          (
+            context?: Partial<{ id: number }> & Record<string, unknown>,
+          ) => Entity.Entity<number>,
+        ]
       >()
 
     test
       .expectTypeOf(handler)
       .returns
       .toEqualTypeOf<
-        Effect.Effect<number, never, never>
+        Effect.Effect<Entity.Entity<number>, never, never>
       >()
 
+    const numNext = () => Entity.effect(Effect.succeed(Entity.make(23)))
     const result = await Effect.runPromise(
-      // TODO: we should accept Effect.void in next here
-      handler({ id: 21 }, () => Effect.succeed(23)),
+      handler({ id: 21 }, numNext),
     )
 
     test
-      .expect(result)
+      .expect(result.body)
       .toBe(42)
   })
 
   test.it("generator can call next", async () => {
     const handler = RouteBody.handle(
-      function*(_ctx: {}, next: () => Effect.Effect<string>) {
-        const fromNext = yield* next()
+      function*(_ctx: {}, next: () => Entity.Entity<string>) {
+        const fromNext = yield* next().text
         return `got: ${fromNext}`
       },
     )
@@ -176,7 +228,7 @@ test.describe(`${RouteBody.handle.name}()`, () => {
     const result = await Effect.runPromise(handler(ctx, next))
 
     test
-      .expect(result)
+      .expect(result.body)
       .toBe("got: next")
   })
 })

package/src/RouteBody.ts

@@ -1,52 +1,83 @@
 import * as Effect from "effect/Effect"
+import type * as Stream from "effect/Stream"
 import type * as Utils from "effect/Utils"
+import * as Entity from "./Entity.ts"
 import * as Route from "./Route.ts"
+import type * as Values from "./Values.ts"
 
 export type Format =
   | "text"
   | "html"
   | "json"
   | "bytes"
+  | "*"
+
+const formatToContentType: Record<Format, string | undefined> = {
+  text: "text/plain; charset=utf-8",
+  html: "text/html; charset=utf-8",
+  json: "application/json",
+  bytes: "application/octet-stream",
+  "*": undefined,
+}
+
+type UnwrapStream<T> = T extends Stream.Stream<infer V, any, any> ? V : T
 
 export type HandlerInput<B, A, E, R> =
   | A
-  | Effect.Effect<A, E, R>
-  | ((context: _Simplify<B>, next: () => Effect.Effect<A>) =>
-    | Effect.Effect<A, E, R>
-    | Generator<Utils.YieldWrap<Effect.Effect<any, E, R>>, A, any>)
+  | Entity.Entity<A>
+  | Effect.Effect<A | Entity.Entity<A>, E, R>
+  | ((
+    context: Values.Simplify<B>,
+    next: (
+      context?: Partial<B> & Record<string, unknown>,
+    ) => Entity.Entity<UnwrapStream<A>>,
+  ) =>
+    | Effect.Effect<A | Entity.Entity<A>, E, R>
+    | Generator<
+      Utils.YieldWrap<Effect.Effect<unknown, E, R>>,
+      A | Entity.Entity<A>,
+      unknown
+    >)
 
-export function handle<B, A, E, R>(
-  handler: (context: B, next: () => Effect.Effect<A>) =>
-    | Effect.Effect<A, E, R>
-    | Generator<Utils.YieldWrap<Effect.Effect<any, E, R>>, A, any>,
-): Route.Route.HandlerImmutable<B, A, E, R>
-export function handle<A, E, R>(
-  handler: Effect.Effect<A, E, R>,
-): Route.Route.HandlerImmutable<{}, A, E, R>
-export function handle<A>(
-  handler: A,
-): Route.Route.HandlerImmutable<{}, A, never, never>
 export function handle<B, A, E, R>(
   handler: HandlerInput<B, A, E, R>,
-): Route.Route.HandlerImmutable<B, A, E, R> {
+): Route.Route.Handler<B, A, E, R> {
   if (typeof handler === "function") {
     return (
       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> => {
       const result = (handler as Function)(context, next)
-      if (Effect.isEffect(result)) {
-        return result as Effect.Effect<A, E, R>
-      }
-      return Effect.gen(function*() {
-        return yield* result
-      }) as Effect.Effect<A, E, R>
+      const effect = Effect.isEffect(result)
+        ? result as Effect.Effect<A | Entity.Entity<A>, E, R>
+        : Effect.gen(function*() {
+          return yield* result
+        }) as Effect.Effect<A | Entity.Entity<A>, E, R>
+      return Effect.map(effect, normalizeToEntity)
     }
   }
   if (Effect.isEffect(handler)) {
-    return (_context, _next) => handler
+    return (_context, _next) =>
+      Effect.map(handler, normalizeToEntity) as Effect.Effect<
+        Entity.Entity<A>,
+        E,
+        R
+      >
+  }
+  if (Entity.isEntity(handler)) {
+    return (_context, _next) => Effect.succeed(handler as Entity.Entity<A>)
   }
-  return (_context, _next) => Effect.succeed(handler as A)
+  return (_context, _next) =>
+    Effect.succeed(normalizeToEntity(handler as A) as Entity.Entity<A>)
+}
+
+function normalizeToEntity<A>(value: A | Entity.Entity<A>): Entity.Entity<A> {
+  if (Entity.isEntity(value)) {
+    return value as Entity.Entity<A>
+  }
+  return Entity.make(value as A, { status: 200 })
 }
 
 export function build<
@@ -59,7 +90,8 @@ export function build<
     D extends Route.RouteDescriptor.Any,
     B extends {},
     I extends Route.Route.Tuple,
-    A extends Value,
+    A extends F extends "json" ? Value
+      : Value | Stream.Stream<Value, any, any>,
     E = never,
     R = never,
   >(
@@ -75,8 +107,25 @@ export function build<
     return function(
       self: Route.RouteSet.RouteSet<D, B, I>,
     ) {
+      const contentType = formatToContentType[descriptors.format]
+      const baseHandler = handle(handler)
+      const wrappedHandler: Route.Route.Handler<
+        D & B & Route.ExtractBindings<I> & { format: F },
+        A,
+        E,
+        R
+      > = (ctx, next) =>
+        Effect.map(baseHandler(ctx as any, next as any), (entity) =>
+          entity.headers["content-type"]
+            ? entity
+            : Entity.make(entity.body, {
+              status: entity.status,
+              url: entity.url,
+              headers: { ...entity.headers, "content-type": contentType },
+            }))
+
       const route = Route.make<{ format: F }, {}, A, E, R>(
-        handle(handler) as any,
+        wrappedHandler as any,
         descriptors,
       )
 
@@ -97,10 +146,48 @@ export function build<
   }
 }
 
-// used to simplify the context type passed to route handlers
-// for those who prefer to write code by hand :)
-type _Simplify<T> = {
-  -readonly [K in keyof T]: T[K] extends object
-    ? { -readonly [P in keyof T[K]]: T[K][P] }
-    : T[K]
-} extends infer U ? { [K in keyof U]: U[K] } : never
+export type RenderValue =
+  | string
+  | Uint8Array
+  | Stream.Stream<string | Uint8Array, any, any>
+
+export function render<
+  D extends Route.RouteDescriptor.Any,
+  B extends {},
+  I extends Route.Route.Tuple,
+  A extends RenderValue,
+  E = never,
+  R = never,
+>(
+  handler: HandlerInput<
+    NoInfer<
+      D & B & Route.ExtractBindings<I> & { format: "*" }
+    >,
+    A,
+    E,
+    R
+  >,
+) {
+  return function(
+    self: Route.RouteSet.RouteSet<D, B, I>,
+  ) {
+    const route = Route.make<{ format: "*" }, {}, A, E, R>(
+      handle(handler) as any,
+      { format: "*" },
+    )
+
+    const items: [...I, Route.Route.Route<{ format: "*" }, {}, A, E, R>] = [
+      ...Route.items(self),
+      route,
+    ]
+
+    return Route.set<
+      D,
+      B,
+      [...I, Route.Route.Route<{ format: "*" }, {}, A, E, R>]
+    >(
+      items,
+      Route.descriptor(self),
+    )
+  }
+}