effect-start 0.21.0 → 0.22.0

package/src/RouteSchema.ts

@@ -1,19 +1,15 @@
 import * as Effect from "effect/Effect"
-import * as ParseResult from "effect/ParseResult"
+import type * as ParseResult from "effect/ParseResult"
 import * as Schema from "effect/Schema"
 import type * as Scope from "effect/Scope"
 import * as Http from "./Http.ts"
 import * as PathPattern from "./PathPattern.ts"
-import * as Route from "./Route.ts"
+import type * as Route from "./Route.ts"
 import * as RouteHook from "./RouteHook.ts"
 
 export interface RequestBodyError {
   readonly _tag: "RequestBodyError"
-  readonly reason:
-    | "JsonError"
-    | "UrlParamsError"
-    | "MultipartError"
-    | "FormDataError"
+  readonly reason: "JsonError" | "UrlParamsError" | "MultipartError" | "FormDataError"
   readonly cause: unknown
 }
 
@@ -29,211 +25,114 @@ export const File = Schema.TaggedStruct("File", {
   content: Schema.Uint8ArrayFromSelf,
 })
 
-export function schemaHeaders<
-  A,
-  I extends Readonly<Record<string, string | undefined>>,
-  R,
->(
+export function schemaHeaders<A, I extends Readonly<Record<string, string | undefined>>, R>(
   fields: Schema.Schema<A, I, R>,
-): <
-  D extends Route.RouteDescriptor.Any,
-  SB extends {},
-  P extends Route.Route.Tuple,
->(
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
   self: Route.RouteSet.RouteSet<D, SB, P>,
 ) => Route.RouteSet.RouteSet<
   D,
   SB,
-  [
-    ...P,
-    Route.Route.Route<
-      {},
-      { headers: A },
-      unknown,
-      ParseResult.ParseError,
-      R
-    >,
-  ]
+  [...P, Route.Route.Route<{}, { headers: A }, unknown, ParseResult.ParseError, R>]
 > {
   const decode = Schema.decodeUnknown(fields)
   return RouteHook.filter((ctx: { request: Request; headers?: {} }) =>
-    Effect.map(
-      decode(Http.mapHeaders(ctx.request.headers)),
-      (parsed) => ({
-        context: {
-          headers: {
-            ...ctx.headers,
-            ...parsed,
-          },
+    Effect.map(decode(Http.mapHeaders(ctx.request.headers)), (parsed) => ({
+      context: {
+        headers: {
+          ...ctx.headers,
+          ...parsed,
         },
-      }),
-    )
+      },
+    })),
   )
 }
 
-export function schemaCookies<
-  A,
-  I extends Readonly<Record<string, string | undefined>>,
-  R,
->(
+export function schemaCookies<A, I extends Readonly<Record<string, string | undefined>>, R>(
   fields: Schema.Schema<A, I, R>,
-): <
-  D extends Route.RouteDescriptor.Any,
-  SB extends {},
-  P extends Route.Route.Tuple,
->(
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
   self: Route.RouteSet.RouteSet<D, SB, P>,
 ) => Route.RouteSet.RouteSet<
   D,
   SB,
-  [
-    ...P,
-    Route.Route.Route<
-      {},
-      { cookies: A },
-      unknown,
-      ParseResult.ParseError,
-      R
-    >,
-  ]
+  [...P, Route.Route.Route<{}, { cookies: A }, unknown, ParseResult.ParseError, R>]
 > {
   const decode = Schema.decodeUnknown(fields)
   return RouteHook.filter((ctx: { request: Request; cookies?: {} }) =>
-    Effect.map(
-      decode(Http.parseCookies(ctx.request.headers.get("cookie"))),
-      (parsed) => ({
-        context: {
-          cookies: {
-            ...ctx.cookies,
-            ...parsed,
-          },
+    Effect.map(decode(Http.parseCookies(ctx.request.headers.get("cookie"))), (parsed) => ({
+      context: {
+        cookies: {
+          ...ctx.cookies,
+          ...parsed,
         },
-      }),
-    )
+      },
+    })),
   )
 }
 
 export function schemaSearchParams<
   A,
-  I extends Readonly<
-    Record<string, string | ReadonlyArray<string> | undefined>
-  >,
+  I extends Readonly<Record<string, string | ReadonlyArray<string> | undefined>>,
   R,
 >(
   fields: Schema.Schema<A, I, R>,
-): <
-  D extends Route.RouteDescriptor.Any,
-  SB extends {},
-  P extends Route.Route.Tuple,
->(
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
   self: Route.RouteSet.RouteSet<D, SB, P>,
 ) => Route.RouteSet.RouteSet<
   D,
   SB,
-  [
-    ...P,
-    Route.Route.Route<
-      {},
-      { searchParams: A },
-      unknown,
-      ParseResult.ParseError,
-      R
-    >,
-  ]
+  [...P, Route.Route.Route<{}, { searchParams: A }, unknown, ParseResult.ParseError, R>]
 > {
   const decode = Schema.decodeUnknown(fields)
   return RouteHook.filter((ctx: { request: Request; searchParams?: {} }) => {
     const url = new URL(ctx.request.url)
-    return Effect.map(
-      decode(Http.mapUrlSearchParams(url.searchParams)),
-      (parsed) => ({
-        context: {
-          searchParams: {
-            ...ctx.searchParams,
-            ...parsed,
-          },
+    return Effect.map(decode(Http.mapUrlSearchParams(url.searchParams)), (parsed) => ({
+      context: {
+        searchParams: {
+          ...ctx.searchParams,
+          ...parsed,
         },
-      }),
-    )
+      },
+    }))
   })
 }
 
-export function schemaPathParams<
-  A,
-  I extends Readonly<Record<string, string | undefined>>,
-  R,
->(
+export function schemaPathParams<A, I extends Readonly<Record<string, string | undefined>>, R>(
   fields: Schema.Schema<A, I, R>,
-): <
-  D extends Route.RouteDescriptor.Any,
-  SB extends {},
-  P extends Route.Route.Tuple,
->(
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
   self: Route.RouteSet.RouteSet<D, SB, P>,
 ) => Route.RouteSet.RouteSet<
   D,
   SB,
-  [
-    ...P,
-    Route.Route.Route<
-      {},
-      { pathParams: A },
-      unknown,
-      ParseResult.ParseError,
-      R
-    >,
-  ]
+  [...P, Route.Route.Route<{}, { pathParams: A }, unknown, ParseResult.ParseError, R>]
 > {
   const decode = Schema.decodeUnknown(fields)
-  return RouteHook.filter(
-    (ctx: { request: Request; path?: string; pathParams?: {} }) => {
-      const url = new URL(ctx.request.url)
-      const pattern = ctx.path ?? "/"
-      const params = PathPattern.match(pattern, url.pathname) ?? {}
-      return Effect.map(
-        decode(params),
-        (parsed) => ({
-          context: {
-            pathParams: {
-              ...ctx.pathParams,
-              ...parsed,
-            },
-          },
-        }),
-      )
-    },
-  )
+  return RouteHook.filter((ctx: { request: Request; path?: string; pathParams?: {} }) => {
+    const url = new URL(ctx.request.url)
+    const pattern = ctx.path ?? "/"
+    const params = PathPattern.match(pattern, url.pathname) ?? {}
+    return Effect.map(decode(params), (parsed) => ({
+      context: {
+        pathParams: {
+          ...ctx.pathParams,
+          ...parsed,
+        },
+      },
+    }))
+  })
 }
 
-export function schemaBodyJson<
-  A,
-  I,
-  R,
->(
+export function schemaBodyJson<A, I, R>(
   fields: Schema.Schema<A, I, R>,
-): <
-  D extends Route.RouteDescriptor.Any,
-  SB extends {},
-  P extends Route.Route.Tuple,
->(
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
   self: Route.RouteSet.RouteSet<D, SB, P>,
 ) => Route.RouteSet.RouteSet<
   D,
   SB,
-  [
-    ...P,
-    Route.Route.Route<
-      {},
-      { body: A },
-      unknown,
-      RequestBodyError | ParseResult.ParseError,
-      R
-    >,
-  ]
+  [...P, Route.Route.Route<{}, { body: A }, unknown, RequestBodyError | ParseResult.ParseError, R>]
 > {
   const decode = Schema.decodeUnknown(fields)
   return RouteHook.filter((ctx: { request: Request; body?: {} }) =>
-    Effect.gen(function*() {
+    Effect.gen(function* () {
       const json = yield* Effect.tryPromise({
         try: () => ctx.request.json(),
         catch: (error) => RequestBodyError("JsonError", error),
@@ -247,41 +146,26 @@ export function schemaBodyJson<
           },
         },
       }
-    })
+    }),
   )
 }
 
 export function schemaBodyUrlParams<
   A,
-  I extends Readonly<
-    Record<string, string | ReadonlyArray<string> | undefined>
-  >,
+  I extends Readonly<Record<string, string | ReadonlyArray<string> | undefined>>,
   R,
 >(
   fields: Schema.Schema<A, I, R>,
-): <
-  D extends Route.RouteDescriptor.Any,
-  SB extends {},
-  P extends Route.Route.Tuple,
->(
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
   self: Route.RouteSet.RouteSet<D, SB, P>,
 ) => Route.RouteSet.RouteSet<
   D,
   SB,
-  [
-    ...P,
-    Route.Route.Route<
-      {},
-      { body: A },
-      unknown,
-      RequestBodyError | ParseResult.ParseError,
-      R
-    >,
-  ]
+  [...P, Route.Route.Route<{}, { body: A }, unknown, RequestBodyError | ParseResult.ParseError, R>]
 > {
   const decode = Schema.decodeUnknown(fields)
   return RouteHook.filter((ctx: { request: Request; body?: {} }) =>
-    Effect.gen(function*() {
+    Effect.gen(function* () {
       const text = yield* Effect.tryPromise({
         try: () => ctx.request.text(),
         catch: (error) => RequestBodyError("UrlParamsError", error),
@@ -296,26 +180,17 @@ export function schemaBodyUrlParams<
           },
         },
       }
-    })
+    }),
   )
 }
 
 export function schemaBodyMultipart<
   A,
-  I extends Partial<
-    Record<
-      string,
-      ReadonlyArray<Http.FilePart> | ReadonlyArray<string> | string
-    >
-  >,
+  I extends Partial<Record<string, ReadonlyArray<Http.FilePart> | ReadonlyArray<string> | string>>,
   R,
 >(
   fields: Schema.Schema<A, I, R>,
-): <
-  D extends Route.RouteDescriptor.Any,
-  SB extends {},
-  P extends Route.Route.Tuple,
->(
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
   self: Route.RouteSet.RouteSet<D, SB, P>,
 ) => Route.RouteSet.RouteSet<
   D,
@@ -333,7 +208,7 @@ export function schemaBodyMultipart<
 > {
   const decode = Schema.decodeUnknown(fields)
   return RouteHook.filter((ctx: { request: Request; body?: {} }) =>
-    Effect.gen(function*() {
+    Effect.gen(function* () {
       const record = yield* Effect.tryPromise({
         try: () => Http.parseFormData(ctx.request),
         catch: (error) => RequestBodyError("MultipartError", error),
@@ -347,26 +222,17 @@ export function schemaBodyMultipart<
           },
         },
       }
-    })
+    }),
   )
 }
 
 export function schemaBodyForm<
   A,
-  I extends Partial<
-    Record<
-      string,
-      ReadonlyArray<Http.FilePart> | ReadonlyArray<string> | string
-    >
-  >,
+  I extends Partial<Record<string, ReadonlyArray<Http.FilePart> | ReadonlyArray<string> | string>>,
   R,
 >(
   fields: Schema.Schema<A, I, R>,
-): <
-  D extends Route.RouteDescriptor.Any,
-  SB extends {},
-  P extends Route.Route.Tuple,
->(
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
   self: Route.RouteSet.RouteSet<D, SB, P>,
 ) => Route.RouteSet.RouteSet<
   D,
@@ -384,7 +250,7 @@ export function schemaBodyForm<
 > {
   const decode = Schema.decodeUnknown(fields)
   return RouteHook.filter((ctx: { request: Request; body?: {} }) =>
-    Effect.gen(function*() {
+    Effect.gen(function* () {
       const contentType = ctx.request.headers.get("content-type") ?? ""
 
       if (contentType.includes("application/x-www-form-urlencoded")) {
@@ -418,6 +284,6 @@ export function schemaBodyForm<
           },
         },
       }
-    })
+    }),
   )
 }

package/src/RouteSse.ts

@@ -21,13 +21,10 @@ export type SseTaggedEvent = {
   readonly _tag: string
 }
 
-export type SseEventInput =
-  | SseEvent
-  | SseTaggedEvent
+export type SseEventInput = SseEvent | SseTaggedEvent
 
 function isTaggedEvent(event: SseEventInput): event is SseTaggedEvent {
-  return Object.hasOwn(event, "_tag")
-    && typeof event["_tag"] === "string"
+  return Object.hasOwn(event, "_tag") && typeof event["_tag"] === "string"
 }
 
 function formatSseEvent(event: SseEventInput): string {
@@ -59,18 +56,16 @@ export type SseHandlerInput<B, E, R> =
   | Stream.Stream<SseEventInput, E, R>
   | Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
   | ((
-    context: Values.Simplify<B>,
-    next: (
-      context?: Partial<B> & Record<string, unknown>,
-    ) => Entity.Entity<string>,
-  ) =>
-    | Stream.Stream<SseEventInput, E, R>
-    | Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
-    | Generator<
-      Utils.YieldWrap<Effect.Effect<unknown, E, R>>,
-      Stream.Stream<SseEventInput, E, R>,
-      unknown
-    >)
+      context: Values.Simplify<B>,
+      next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<string>,
+    ) =>
+      | Stream.Stream<SseEventInput, E, R>
+      | Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
+      | Generator<
+          Utils.YieldWrap<Effect.Effect<unknown, E, R>>,
+          Stream.Stream<SseEventInput, E, R>,
+          unknown
+        >)
 
 export function sse<
   D extends Route.RouteDescriptor.Any,
@@ -78,40 +73,24 @@ export function sse<
   I extends Route.Route.Tuple,
   E = never,
   R = never,
->(
-  handler: SseHandlerInput<
-    NoInfer<D & B & Route.ExtractBindings<I> & { format: "text" }>,
-    E,
-    R
-  >,
-) {
-  return function(
-    self: Route.RouteSet.RouteSet<D, B, I>,
-  ) {
+>(handler: SseHandlerInput<NoInfer<D & B & Route.ExtractBindings<I> & { format: "text" }>, E, R>) {
+  return function (self: Route.RouteSet.RouteSet<D, B, I>) {
     const sseHandler: Route.Route.Handler<
       D & B & Route.ExtractBindings<I> & { format: "text" },
       Stream.Stream<string, E, R>,
       E,
       R
     > = (ctx, _next) => {
-      const getStream = (): Effect.Effect<
-        Stream.Stream<SseEventInput, E, R>,
-        E,
-        R
-      > => {
+      const getStream = (): Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R> => {
         if (typeof handler === "function") {
           const result = (handler as Function)(ctx, _next)
           if (StreamExtra.isStream(result)) {
             return Effect.succeed(result as Stream.Stream<SseEventInput, E, R>)
           }
           if (Effect.isEffect(result)) {
-            return result as Effect.Effect<
-              Stream.Stream<SseEventInput, E, R>,
-              E,
-              R
-            >
+            return result as Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
           }
-          return Effect.gen(function*() {
+          return Effect.gen(function* () {
             return yield* result
           }) as Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
         }
@@ -119,23 +98,17 @@ export function sse<
           return Effect.succeed(handler as Stream.Stream<SseEventInput, E, R>)
         }
         if (Effect.isEffect(handler)) {
-          return handler as Effect.Effect<
-            Stream.Stream<SseEventInput, E, R>,
-            E,
-            R
-          >
+          return handler as Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
         }
         return Effect.succeed(Stream.empty)
       }
 
       return Effect.map(getStream(), (eventStream) => {
         const formattedStream = Stream.map(eventStream, formatSseEvent)
-        const heartbeat = Stream
-          .repeat(
-            Stream.succeed(HEARTBEAT),
-            Schedule.spaced(HEARTBEAT_INTERVAL),
-          )
-          .pipe(Stream.drop(1))
+        const heartbeat = Stream.repeat(
+          Stream.succeed(HEARTBEAT),
+          Schedule.spaced(HEARTBEAT_INTERVAL),
+        ).pipe(Stream.drop(1))
         const merged = Stream.merge(formattedStream, heartbeat, {
           haltStrategy: "left",
         })
@@ -143,53 +116,26 @@ export function sse<
           headers: {
             "content-type": "text/event-stream",
             "cache-control": "no-cache",
-            "connection": "keep-alive",
+            connection: "keep-alive",
           },
         })
       })
     }
 
-    const route = Route.make<
-      { format: "text" },
-      {},
-      Stream.Stream<string, E, R>,
-      E,
-      R
-    >(
+    const route = Route.make<{ format: "text" }, {}, Stream.Stream<string, E, R>, E, R>(
       sseHandler as any,
       { format: "text" },
     )
 
     const items: [
       ...I,
-      Route.Route.Route<
-        { format: "text" },
-        {},
-        Stream.Stream<string, E, R>,
-        E,
-        R
-      >,
-    ] = [
-      ...Route.items(self),
-      route,
-    ]
+      Route.Route.Route<{ format: "text" }, {}, Stream.Stream<string, E, R>, E, R>,
+    ] = [...Route.items(self), route]
 
     return Route.set<
       D,
       B,
-      [
-        ...I,
-        Route.Route.Route<
-          { format: "text" },
-          {},
-          Stream.Stream<string, E, R>,
-          E,
-          R
-        >,
-      ]
-    >(
-      items,
-      Route.descriptor(self),
-    )
+      [...I, Route.Route.Route<{ format: "text" }, {}, Stream.Stream<string, E, R>, E, R>]
+    >(items, Route.descriptor(self))
   }
 }