effect-start 0.13.1 → 0.15.0

package/src/RouteBody.test.ts

@@ -0,0 +1,182 @@
+import * as test from "bun:test"
+import * as Effect from "effect/Effect"
+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) =>
+      Effect.gen(function*() {
+        test
+          .expectTypeOf(ctx)
+          .toExtend<{
+            method: "GET"
+            format: "text"
+          }>()
+
+        return "Hello, world!"
+      })
+    ),
+  )
+})
+
+test.it("cannot modify context", () => {
+  text((ctx, next) =>
+    Effect.gen(function*() {
+      test
+        .expectTypeOf(next)
+        .parameters
+        .toEqualTypeOf<[]>()
+
+      return "Hello, world!"
+    })
+  )
+})
+
+test.it("enforces result value", () => {
+  // @ts-expect-error must return string
+  text((ctx, next) =>
+    Effect.gen(function*() {
+      return 1337
+    })
+  )
+})
+
+test.it("accepts value directly", () => {
+  const value = "Hello, world!"
+
+  test
+    .expectTypeOf(text)
+    .toBeCallableWith(value)
+})
+
+test.describe(`${RouteBody.handle.name}()`, () => {
+  const ctx = {}
+  const next = () => Effect.succeed("next" as const)
+
+  test.it("accepts all HandlerInput variants", () => {
+    test
+      .expectTypeOf<
+        RouteBody.HandlerInput<{ foo: string }, string, Error, never>
+      >()
+      .toExtend<Parameters<typeof RouteBody.handle>[0]>()
+  })
+
+  test.it("handles plain value", async () => {
+    const handler = RouteBody.handle("hello")
+
+    test
+      .expectTypeOf(handler)
+      .returns
+      .toEqualTypeOf<
+        Effect.Effect<string, never, never>
+      >()
+
+    const result = await Effect.runPromise(handler(ctx, next))
+    test.expect(result).toBe("hello")
+  })
+
+  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 result = await Effect.runPromise(handler(ctx, next))
+
+    test
+      .expect(result)
+      .toBe("from effect")
+  })
+
+  test.it("handles Effect with error", async () => {
+    const handler = RouteBody.handle(Effect.fail(new Error("oops")))
+
+    test
+      .expectTypeOf(handler)
+      .returns
+      .toEqualTypeOf<
+        Effect.Effect<never, Error, never>
+      >()
+  })
+
+  test.it("handles function", async () => {
+    const handler = RouteBody.handle(
+      (ctx: { id: number }) => Effect.succeed(ctx.id),
+    )
+
+    test
+      .expectTypeOf(handler)
+      .parameters
+      .toEqualTypeOf<
+        [{ id: number }, () => Effect.Effect<number>]
+      >()
+    test
+      .expectTypeOf(handler)
+      .returns
+      .toEqualTypeOf<
+        Effect.Effect<number, never, never>
+      >()
+
+    const result = await Effect.runPromise(
+      handler({ id: 42 }, () => Effect.succeed(23)),
+    )
+
+    test
+      .expect(result)
+      .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
+    })
+
+    test
+      .expectTypeOf(handler)
+      .parameters
+      .toEqualTypeOf<
+        [{ id: number }, () => Effect.Effect<number>]
+      >()
+
+    test
+      .expectTypeOf(handler)
+      .returns
+      .toEqualTypeOf<
+        Effect.Effect<number, never, never>
+      >()
+
+    const result = await Effect.runPromise(
+      // TODO: we should accept Effect.void in next here
+      handler({ id: 21 }, () => Effect.succeed(23)),
+    )
+
+    test
+      .expect(result)
+      .toBe(42)
+  })
+
+  test.it("generator can call next", async () => {
+    const handler = RouteBody.handle(
+      function*(_ctx: {}, next: () => Effect.Effect<string>) {
+        const fromNext = yield* next()
+        return `got: ${fromNext}`
+      },
+    )
+
+    const result = await Effect.runPromise(handler(ctx, next))
+
+    test
+      .expect(result)
+      .toBe("got: next")
+  })
+})

package/src/RouteBody.ts

@@ -0,0 +1,106 @@
+import * as Effect from "effect/Effect"
+import type * as Utils from "effect/Utils"
+import * as Route from "./Route.ts"
+
+export type Format =
+  | "text"
+  | "html"
+  | "json"
+  | "bytes"
+
+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>)
+
+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> {
+  if (typeof handler === "function") {
+    return (
+      context: B,
+      next: () => Effect.Effect<A>,
+    ): Effect.Effect<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>
+    }
+  }
+  if (Effect.isEffect(handler)) {
+    return (_context, _next) => handler
+  }
+  return (_context, _next) => Effect.succeed(handler as A)
+}
+
+export function build<
+  Value,
+  F extends Format,
+>(
+  descriptors: { format: F },
+) {
+  return function<
+    D extends Route.RouteDescriptor.Any,
+    B extends {},
+    I extends Route.Route.Tuple,
+    A extends Value,
+    E = never,
+    R = never,
+  >(
+    handler: HandlerInput<
+      NoInfer<
+        D & B & Route.ExtractBindings<I> & { format: F }
+      >,
+      A,
+      E,
+      R
+    >,
+  ) {
+    return function(
+      self: Route.RouteSet.RouteSet<D, B, I>,
+    ) {
+      const route = Route.make<{ format: F }, {}, A, E, R>(
+        handle(handler) as any,
+        descriptors,
+      )
+
+      const items: [...I, Route.Route.Route<{ format: F }, {}, A, E, R>] = [
+        ...Route.items(self),
+        route,
+      ]
+
+      return Route.set<
+        D,
+        B,
+        [...I, Route.Route.Route<{ format: F }, {}, A, E, R>]
+      >(
+        items,
+        Route.descriptor(self),
+      )
+    }
+  }
+}
+
+// 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

package/src/RouteHook.test.ts

@@ -0,0 +1,40 @@
+import * as test from "bun:test"
+import { Effect } from "effect"
+import * as Route from "./Route.ts"
+
+test.it("passes bindings", () => {
+  const headers = {
+    "origin": "nounder.org",
+  }
+  const filterResult = {
+    context: {
+      headers,
+    },
+  }
+
+  const routes = Route.empty.pipe(
+    Route.filter(() => Effect.succeed(filterResult)),
+    Route.text(context => {
+      test
+        .expectTypeOf(context)
+        .toExtend<typeof filterResult.context>()
+
+      return Effect.succeed(
+        `Origin: ${context.headers.origin}`,
+      )
+    }),
+  )
+
+  test
+    .expectTypeOf(routes)
+    .toExtend<
+      Route.RouteSet.RouteSet<{}, {}, [
+        Route.Route.Route<{}, typeof filterResult.context, any>,
+        Route.Route.Route<{ format: "text" }, {}, string>,
+      ]>
+    >()
+
+  test
+    .expect(Route.items(routes))
+    .toHaveLength(2)
+})

package/src/RouteHook.ts

@@ -0,0 +1,105 @@
+import * as Effect from "effect/Effect"
+import type * as Utils from "effect/Utils"
+import * as Route from "./Route.ts"
+
+export type FilterResult<BOut, E, R> =
+  | { context: BOut }
+  | Effect.Effect<{ context: BOut }, E, R>
+
+export type FilterHandlerInput<BIn, BOut, E, R> =
+  | FilterResult<BOut, E, R>
+  | ((context: BIn) =>
+    | FilterResult<BOut, E, R>
+    | Generator<
+      Utils.YieldWrap<Effect.Effect<any, E, R>>,
+      { context: BOut },
+      any
+    >)
+
+export function filter<
+  D extends Route.RouteDescriptor.Any,
+  SB extends {},
+  P extends Route.Route.Tuple,
+  BOut extends {},
+  E = never,
+  R = never,
+  BIn = D & SB & Route.ExtractBindings<P>,
+>(
+  filterHandler: FilterHandlerInput<BIn, BOut, E, R>,
+) {
+  const normalized = normalizeFilterHandler(filterHandler)
+
+  return function(
+    self: Route.RouteSet.RouteSet<D, SB, P>,
+  ): Route.RouteSet.RouteSet<
+    D,
+    SB,
+    [...P, Route.Route.Route<{}, BOut, void, E, R>]
+  > {
+    const route = Route.make<
+      {},
+      BOut,
+      void,
+      E,
+      R
+    >((context: BOut, next) =>
+      Effect.gen(function*() {
+        const filterResult = yield* normalized(context as unknown as BIn)
+
+        yield* next(
+          filterResult
+            ? {
+              ...context,
+              ...filterResult.context,
+            }
+            : context,
+        )
+      })
+    )
+
+    return Route.set(
+      [
+        ...Route.items(self),
+        route,
+      ] as [...P, Route.Route.Route<{}, BOut, void, E, R>],
+      Route.descriptor(self),
+    )
+  }
+}
+
+function isGenerator(value: unknown): value is Generator {
+  return (
+    typeof value === "object"
+    && value !== null
+    && Symbol.iterator in value
+    && typeof (value as Generator).next === "function"
+  )
+}
+
+function normalizeFilterHandler<BIn, BOut, E, R>(
+  handler: FilterHandlerInput<BIn, BOut, E, R>,
+): (context: BIn) => Effect.Effect<{ context: BOut }, E, R> {
+  if (typeof handler === "function") {
+    return (context: BIn): Effect.Effect<{ context: BOut }, E, R> => {
+      const result = handler(context)
+
+      if (Effect.isEffect(result)) {
+        return result as Effect.Effect<{ context: BOut }, E, R>
+      }
+
+      if (isGenerator(result)) {
+        return Effect.gen(function*() {
+          return yield* result
+        }) as Effect.Effect<{ context: BOut }, E, R>
+      }
+
+      return Effect.succeed(result)
+    }
+  }
+
+  if (Effect.isEffect(handler)) {
+    return (_context) => handler as Effect.Effect<{ context: BOut }, E, R>
+  }
+
+  return (_context) => Effect.succeed(handler as { context: BOut })
+}