effect-start 0.20.1 → 0.22.0

package/src/RouteBody.ts

@@ -5,12 +5,7 @@ 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"
-  | "*"
+export type Format = "text" | "html" | "json" | "bytes" | "*"
 
 const formatToContentType: Record<Format, string | undefined> = {
   text: "text/plain; charset=utf-8",
@@ -22,19 +17,13 @@ const formatToContentType: Record<Format, string | undefined> = {
 
 type UnwrapStream<T> = T extends Stream.Stream<infer V, any, any> ? V : T
 
-type YieldError<T> = T extends Utils.YieldWrap<Effect.Effect<any, infer E, any>>
-  ? E
-  : never
+type YieldError<T> = T extends Utils.YieldWrap<Effect.Effect<any, infer E, any>> ? E : never
 
-type YieldContext<T> = T extends
-  Utils.YieldWrap<Effect.Effect<any, any, infer R>> ? R
-  : never
+type YieldContext<T> = T extends Utils.YieldWrap<Effect.Effect<any, any, infer R>> ? R : never
 
 export type GeneratorHandler<B, A, Y> = (
   context: Values.Simplify<B>,
-  next: (
-    context?: Partial<B> & Record<string, unknown>,
-  ) => Entity.Entity<UnwrapStream<A>>,
+  next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<UnwrapStream<A>>,
 ) => Generator<Y, A | Entity.Entity<A>, never>
 
 export type HandlerInput<B, A, E, R> =
@@ -42,23 +31,13 @@ export type HandlerInput<B, A, E, R> =
   | 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
-    >)
+      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,
-  Y extends Utils.YieldWrap<Effect.Effect<any, any, any>>,
->(
+export function handle<B, A, Y extends Utils.YieldWrap<Effect.Effect<any, any, any>>>(
   handler: GeneratorHandler<B, A, Y>,
 ): Route.Route.Handler<B, A, YieldError<Y>, YieldContext<Y>>
 export function handle<B, A, E, R>(
@@ -70,32 +49,25 @@ export function handle<B, A, E, R>(
   if (typeof handler === "function") {
     return (
       context: B,
-      next: (
-        context?: Partial<B> & Record<string, unknown>,
-      ) => Entity.Entity<A>,
+      next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<A>,
     ): Effect.Effect<Entity.Entity<A>, E, R> => {
       const result = (handler as Function)(context, next)
       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>
+        ? (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) =>
-      Effect.map(handler, normalizeToEntity) as Effect.Effect<
-        Entity.Entity<A>,
-        E,
-        R
-      >
+      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(normalizeToEntity(handler as A) as Entity.Entity<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> {
@@ -105,87 +77,47 @@ function normalizeToEntity<A>(value: A | Entity.Entity<A>): Entity.Entity<A> {
   return Entity.make(value as A, { status: 200 })
 }
 
-export interface BuildReturn<
-  Value,
-  F extends Format,
-> {
+export interface BuildReturn<Value, F extends Format> {
   <
     D extends Route.RouteDescriptor.Any,
     B,
     I extends Route.Route.Tuple,
-    A extends F extends "json" ? Value
-      : Value | Stream.Stream<Value, any, any>,
+    A extends F extends "json" ? Value : Value | Stream.Stream<Value, any, any>,
     Y extends Utils.YieldWrap<Effect.Effect<any, any, any>>,
   >(
-    handler: GeneratorHandler<
-      NoInfer<D & B & Route.ExtractBindings<I> & { format: F }>,
-      A,
-      Y
-    >,
+    handler: GeneratorHandler<NoInfer<D & B & Route.ExtractBindings<I> & { format: F }>, A, Y>,
   ): (
     self: Route.RouteSet.RouteSet<D, B, I>,
   ) => Route.RouteSet.RouteSet<
     D,
     B,
-    [
-      ...I,
-      Route.Route.Route<{ format: F }, {}, A, YieldError<Y>, YieldContext<Y>>,
-    ]
+    [...I, Route.Route.Route<{ format: F }, {}, A, YieldError<Y>, YieldContext<Y>>]
   >
 
   <
     D extends Route.RouteDescriptor.Any,
     B,
     I extends Route.Route.Tuple,
-    A extends F extends "json" ? Value
-      : Value | Stream.Stream<Value, any, any>,
+    A extends F extends "json" ? Value : Value | Stream.Stream<Value, any, any>,
     E = never,
     R = never,
   >(
-    handler: HandlerInput<
-      NoInfer<
-        D & B & Route.ExtractBindings<I> & { format: F }
-      >,
-      A,
-      E,
-      R
-    >,
+    handler: HandlerInput<NoInfer<D & B & Route.ExtractBindings<I> & { format: F }>, A, E, R>,
   ): (
     self: Route.RouteSet.RouteSet<D, B, I>,
-  ) => Route.RouteSet.RouteSet<
-    D,
-    B,
-    [...I, Route.Route.Route<{ format: F }, {}, A, E, R>]
-  >
+  ) => Route.RouteSet.RouteSet<D, B, [...I, Route.Route.Route<{ format: F }, {}, A, E, R>]>
 }
 
-export function build<
-  Value,
-  F extends Format,
->(
-  descriptors: { format: F },
-) {
-  return (function<
+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 F extends "json" ? Value
-      : Value | Stream.Stream<Value, any, any>,
+    A extends F extends "json" ? Value : Value | Stream.Stream<Value, any, any>,
     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>,
-    ) {
+  >(handler: HandlerInput<NoInfer<D & B & Route.ExtractBindings<I> & { format: F }>, A, E, R>) {
+    return function (self: Route.RouteSet.RouteSet<D, B, I>) {
       const contentType = formatToContentType[descriptors.format]
       const baseHandler = handle(handler)
       const wrappedHandler: Route.Route.Handler<
@@ -194,44 +126,32 @@ export function build<
         E,
         R
       > = (ctx, next) =>
-        Effect.map(
-          baseHandler(ctx as any, next as any),
-          (entity) =>
-            entity.headers["content-type"]
-              ? entity
-              : Entity.make(entity.body, {
+        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>(
-        wrappedHandler as any,
-        descriptors,
-      )
+      const route = Route.make<{ format: F }, {}, A, E, R>(wrappedHandler 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>]
-      >(
+      return Route.set<D, B, [...I, Route.Route.Route<{ format: F }, {}, A, E, R>]>(
         items,
         Route.descriptor(self),
       )
     }
-  }) as unknown as BuildReturn<Value, F>
+  } as unknown as BuildReturn<Value, F>
 }
 
-export type RenderValue =
-  | string
-  | Uint8Array
-  | Stream.Stream<string | Uint8Array, any, any>
+export type RenderValue = string | Uint8Array | Stream.Stream<string | Uint8Array, any, any>
 
 export function render<
   D extends Route.RouteDescriptor.Any,
@@ -240,20 +160,13 @@ export function render<
   A extends RenderValue,
   Y extends Utils.YieldWrap<Effect.Effect<any, any, any>>,
 >(
-  handler: GeneratorHandler<
-    NoInfer<D & B & Route.ExtractBindings<I> & { format: "*" }>,
-    A,
-    Y
-  >,
+  handler: GeneratorHandler<NoInfer<D & B & Route.ExtractBindings<I> & { format: "*" }>, A, Y>,
 ): (
   self: Route.RouteSet.RouteSet<D, B, I>,
 ) => Route.RouteSet.RouteSet<
   D,
   B,
-  [
-    ...I,
-    Route.Route.Route<{ format: "*" }, {}, A, YieldError<Y>, YieldContext<Y>>,
-  ]
+  [...I, Route.Route.Route<{ format: "*" }, {}, A, YieldError<Y>, YieldContext<Y>>]
 >
 export function render<
   D extends Route.RouteDescriptor.Any,
@@ -263,21 +176,10 @@ export function render<
   E = never,
   R = never,
 >(
-  handler: HandlerInput<
-    NoInfer<
-      D & B & Route.ExtractBindings<I> & { format: "*" }
-    >,
-    A,
-    E,
-    R
-  >,
+  handler: HandlerInput<NoInfer<D & B & Route.ExtractBindings<I> & { format: "*" }>, A, E, R>,
 ): (
   self: Route.RouteSet.RouteSet<D, B, I>,
-) => Route.RouteSet.RouteSet<
-  D,
-  B,
-  [...I, Route.Route.Route<{ format: "*" }, {}, A, E, R>]
->
+) => Route.RouteSet.RouteSet<D, B, [...I, Route.Route.Route<{ format: "*" }, {}, A, E, R>]>
 export function render<
   D extends Route.RouteDescriptor.Any,
   B extends {},
@@ -285,34 +187,16 @@ export function render<
   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: "*" },
-    )
+>(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>]
-    >(
+    return Route.set<D, B, [...I, Route.Route.Route<{ format: "*" }, {}, A, E, R>]>(
       items,
       Route.descriptor(self),
     )

package/src/RouteHook.ts

@@ -3,19 +3,15 @@ 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> =
-  | { context: BOut }
-  | Effect.Effect<{ context: BOut }, E, R>
+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<unknown, E, R>>,
-      { context: BOut },
-      unknown
-    >)
+  | ((
+      context: BIn,
+    ) =>
+      | FilterResult<BOut, E, R>
+      | Generator<Utils.YieldWrap<Effect.Effect<unknown, E, R>>, { context: BOut }, unknown>)
 
 export function filter<
   D extends Route.RouteDescriptor.Any,
@@ -25,44 +21,25 @@ export function filter<
   E = never,
   R = never,
   BIn = D & SB & Route.ExtractBindings<P>,
->(
-  filterHandler: FilterHandlerInput<BIn, BOut, E, R>,
-) {
+>(filterHandler: FilterHandlerInput<BIn, BOut, E, R>) {
   const normalized = normalizeFilterHandler(filterHandler)
 
-  return function(
+  return function (
     self: Route.RouteSet.RouteSet<D, SB, P>,
-  ): Route.RouteSet.RouteSet<
-    D,
-    SB,
-    [
-      ...P,
-      Route.Route.Route<{}, BOut, unknown, E, R>,
-    ]
-  > {
-    const route = Route.make<
-      {},
-      BOut,
-      unknown,
-      E,
-      R
-    >((context: BOut, next: (ctx?: Partial<BOut>) => Entity.Entity<unknown>) =>
-      Effect.gen(function*() {
-        const filterResult = yield* normalized(context as unknown as BIn)
+  ): Route.RouteSet.RouteSet<D, SB, [...P, Route.Route.Route<{}, BOut, unknown, E, R>]> {
+    const route = Route.make<{}, BOut, unknown, E, R>(
+      (context: BOut, next: (ctx?: Partial<BOut>) => Entity.Entity<unknown>) =>
+        Effect.gen(function* () {
+          const filterResult = yield* normalized(context as unknown as BIn)
 
-        const mergedContext = filterResult
-          ? { ...context, ...filterResult.context }
-          : context
+          const mergedContext = filterResult ? { ...context, ...filterResult.context } : context
 
-        return yield* Entity.resolve(next(mergedContext as Partial<BOut>))
-      })
+          return yield* Entity.resolve(next(mergedContext as Partial<BOut>))
+        }),
     )
 
     return Route.set(
-      [
-        ...Route.items(self),
-        route,
-      ] as [...P, Route.Route.Route<{}, BOut, unknown, E, R>],
+      [...Route.items(self), route] as [...P, Route.Route.Route<{}, BOut, unknown, E, R>],
       Route.descriptor(self),
     )
   }
@@ -70,10 +47,10 @@ export function filter<
 
 function isGenerator(value: unknown): value is Generator {
   return (
-    typeof value === "object"
-    && value !== null
-    && Symbol.iterator in value
-    && typeof (value as Generator).next === "function"
+    typeof value === "object" &&
+    value !== null &&
+    Symbol.iterator in value &&
+    typeof (value as Generator).next === "function"
   )
 }
 
@@ -89,7 +66,7 @@ function normalizeFilterHandler<BIn, BOut, E, R>(
       }
 
       if (isGenerator(result)) {
-        return Effect.gen(function*() {
+        return Effect.gen(function* () {
           return yield* result
         }) as Effect.Effect<{ context: BOut }, E, R>
       }