effect-start 0.15.0 → 0.17.0

package/src/RouteBody.test.ts

@@ -1,15 +1,15 @@
 import * as test from "bun:test"
 import * as Effect from "effect/Effect"
+import * as ParseResult from "effect/ParseResult"
+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 +24,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 +38,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
@@ -67,116 +108,107 @@ test.describe(`${RouteBody.handle.name}()`, () => {
   })
 
   test.it("handles plain value", async () => {
-    const handler = RouteBody.handle("hello")
-
-    test
-      .expectTypeOf(handler)
-      .returns
-      .toEqualTypeOf<
-        Effect.Effect<string, never, never>
-      >()
-
+    const handler = RouteBody.handle<{}, string, never, never>("hello")
     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 () => {
-    const handler = RouteBody.handle(Effect.succeed("from effect"))
-
-    test
-      .expectTypeOf(handler)
-      .returns
-      .toEqualTypeOf<
-        Effect.Effect<string, never, never>
-      >()
-
+    const handler = RouteBody.handle<{}, string, never, never>(
+      Effect.succeed("from effect"),
+    )
     const result = await Effect.runPromise(handler(ctx, next))
-
-    test
-      .expect(result)
-      .toBe("from effect")
+    test.expect(result.body).toBe("from effect")
   })
 
   test.it("handles Effect with error", async () => {
-    const handler = RouteBody.handle(Effect.fail(new Error("oops")))
+    const handler = RouteBody.handle<{}, never, Error, never>(
+      Effect.fail(new Error("oops")),
+    )
 
     test
       .expectTypeOf(handler)
       .returns
-      .toEqualTypeOf<
-        Effect.Effect<never, Error, never>
+      .toExtend<
+        Effect.Effect<Entity.Entity<never>, Error, never>
       >()
   })
 
   test.it("handles function", async () => {
-    const handler = RouteBody.handle(
-      (ctx: { id: number }) => Effect.succeed(ctx.id),
+    const handler = RouteBody.handle<{ id: number }, number, never, never>(
+      (ctx) => Effect.succeed(ctx.id),
     )
 
     test
       .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 result = await Effect.runPromise(
-      handler({ id: 42 }, () => Effect.succeed(23)),
-    )
+    const numNext = () => Entity.effect(Effect.succeed(Entity.make(23)))
+    const result = await Effect.runPromise(handler({ id: 42 }, numNext))
 
-    test
-      .expect(result)
-      .toBe(42)
+    test.expect(result.body).toBe(42)
   })
 
   test.it("handles generator", async () => {
-    const handler = RouteBody.handle(function*(ctx: { id: number }) {
-      const n = yield* Effect.succeed(ctx.id)
-      return n * 2
-    })
+    const handler = RouteBody.handle<{ id: number }, number, never, never>(
+      function*(ctx) {
+        const n = yield* Effect.succeed(ctx.id)
+        return n * 2
+      },
+    )
 
     test
       .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 result = await Effect.runPromise(
-      // TODO: we should accept Effect.void in next here
-      handler({ id: 21 }, () => Effect.succeed(23)),
-    )
+    const numNext = () => Entity.effect(Effect.succeed(Entity.make(23)))
+    const result = await Effect.runPromise(handler({ id: 21 }, numNext))
 
-    test
-      .expect(result)
-      .toBe(42)
+    test.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()
+    const handler = RouteBody.handle<{}, string, ParseResult.ParseError, never>(
+      function*(_ctx, next) {
+        const fromNext = yield* next().text
         return `got: ${fromNext}`
       },
     )
 
-    const result = await Effect.runPromise(handler(ctx, next))
+    const result = await Effect.runPromise(Effect.orDie(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,28 @@ 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 +149,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),
+    )
+  }
+}

package/src/RouteHook.ts

@@ -1,5 +1,6 @@
 import * as Effect from "effect/Effect"
 import type * as Utils from "effect/Utils"
+import * as Entity from "./Entity.ts"
 import * as Route from "./Route.ts"
 
 export type FilterResult<BOut, E, R> =
@@ -11,9 +12,9 @@ export type FilterHandlerInput<BIn, BOut, E, R> =
   | ((context: BIn) =>
     | FilterResult<BOut, E, R>
     | Generator<
-      Utils.YieldWrap<Effect.Effect<any, E, R>>,
+      Utils.YieldWrap<Effect.Effect<unknown, E, R>>,
       { context: BOut },
-      any
+      unknown
     >)
 
 export function filter<
@@ -34,26 +35,26 @@ export function filter<
   ): Route.RouteSet.RouteSet<
     D,
     SB,
-    [...P, Route.Route.Route<{}, BOut, void, E, R>]
+    [
+      ...P,
+      Route.Route.Route<{}, BOut, unknown, E, R>,
+    ]
   > {
     const route = Route.make<
       {},
       BOut,
-      void,
+      unknown,
       E,
       R
-    >((context: BOut, next) =>
+    >((context: BOut, next: (ctx?: Partial<BOut>) => Entity.Entity<unknown>) =>
       Effect.gen(function*() {
         const filterResult = yield* normalized(context as unknown as BIn)
 
-        yield* next(
-          filterResult
-            ? {
-              ...context,
-              ...filterResult.context,
-            }
-            : context,
-        )
+        const mergedContext = filterResult
+          ? { ...context, ...filterResult.context }
+          : context
+
+        return yield* Entity.resolve(next(mergedContext as Partial<BOut>))
       })
     )
 
@@ -61,7 +62,7 @@ export function filter<
       [
         ...Route.items(self),
         route,
-      ] as [...P, Route.Route.Route<{}, BOut, void, E, R>],
+      ] as [...P, Route.Route.Route<{}, BOut, unknown, E, R>],
       Route.descriptor(self),
     )
   }