effect-start 0.33.0 → 0.35.0

package/src/Route.ts

@@ -27,16 +27,16 @@ export namespace RouteDescriptor {
   }
 }
 
-export namespace RouteSet {
-  export type RouteSet<
-    D extends RouteDescriptor.Any = {},
-    B = {},
-    M extends Route.Tuple = [],
-  > = Data<D, B, M> & {
-    [TypeId]: typeof TypeId
-  } & Pipeable.Pipeable &
-    Iterable<M[number]>
+export type RouteSet<
+  D extends RouteDescriptor.Any = {},
+  B = {},
+  M extends Route.Tuple = [],
+> = RouteSet.Data<D, B, M> & {
+  [TypeId]: typeof TypeId
+} & Pipeable.Pipeable &
+  Iterable<M[number]>
 
+export namespace RouteSet {
   export type Data<D extends RouteDescriptor.Any = {}, B = {}, M extends Route.Tuple = []> = {
     [RouteItems]: M
     [RouteDescriptor]: D
@@ -44,7 +44,7 @@ export namespace RouteSet {
   }
 
   export type Proto = Pipeable.Pipeable &
-    Iterable<Route.Route<any, any, any, any, any>> & {
+    Iterable<Route<any, any, any, any, any>> & {
       [TypeId]: typeof TypeId
     }
 
@@ -58,17 +58,17 @@ export namespace RouteSet {
     T extends Data<infer D, any, any> ? D : never
 }
 
-export namespace Route {
-  export interface Route<
-    D extends RouteDescriptor.Any = {},
-    B = {},
-    A = any,
-    E = never,
-    R = never,
-  > extends RouteSet.RouteSet<D, {}, [Route<D, B, A, E, R>]> {
-    readonly handler: Handler<B & D, A, E, R>
-  }
+export interface Route<
+  D extends RouteDescriptor.Any = {},
+  B = {},
+  A = any,
+  E = never,
+  R = never,
+> extends RouteSet<D, {}, [Route<D, B, A, E, R>]> {
+  readonly handler: Route.Handler<B & D, A, E, R>
+}
 
+export namespace Route {
   export type With<D extends RouteDescriptor.Any> = Route<any, any, any, any, any> & {
     [RouteDescriptor]: D
   }
@@ -125,26 +125,26 @@ export function isRouteSet(input: unknown): input is RouteSet.Any {
   return Predicate.hasProperty(input, TypeId)
 }
 
-export function isRoute(input: unknown): input is Route.Route {
+export function isRoute(input: unknown): input is Route {
   return isRouteSet(input) && Predicate.hasProperty(input, "handler")
 }
 
 export function set<D extends RouteDescriptor.Any = {}, B = {}, I extends Route.Tuple = []>(
   items: I = [] as unknown as I,
   descriptor: D = {} as D,
-): RouteSet.RouteSet<D, B, I> {
+): RouteSet<D, B, I> {
   return Object.assign(Object.create(Proto), {
     [RouteItems]: items,
     [RouteDescriptor]: descriptor,
-  }) as RouteSet.RouteSet<D, B, I>
+  }) as RouteSet<D, B, I>
 }
 
 export function make<D extends RouteDescriptor.Any, B, A, E = never, R = never>(
   handler: Route.Handler<B & D, A, E, R>,
   descriptor?: D,
-): Route.Route<D, B, A, E, R> {
+): Route<D, B, A, E, R> {
   const items: any = []
-  const route: Route.Route<D, B, A, E, R> = Object.assign(Object.create(Proto), {
+  const route: Route<D, B, A, E, R> = Object.assign(Object.create(Proto), {
     [RouteItems]: items,
     [RouteDescriptor]: descriptor,
     handler,
@@ -185,7 +185,7 @@ export type ExtractBindings<M extends Route.Tuple> = M extends [
   infer Head,
   ...infer Tail extends Route.Tuple,
 ]
-  ? Head extends Route.Route<any, infer B, any, any, any>
+  ? Head extends Route<any, infer B, any, any, any>
     ? ShallowMerge<B, ExtractBindings<Tail>>
     : ExtractBindings<Tail>
   : {}
@@ -206,6 +206,11 @@ export * from "./RouteSchema.ts"
 
 export { del, get, head, options, patch, post, put, use } from "./RouteMount.ts"
 
+export class Request extends Context.Tag("effect-start/Route/Request")<
+  Request,
+  globalThis.Request
+>() {}
+
 export const text = RouteBody.build<string, "text">({
   format: "text",
 })
@@ -229,8 +234,8 @@ export function redirect<D extends RouteDescriptor.Any, B, I extends Route.Tuple
   url: string | URL,
   options?: { status?: 301 | 302 | 303 | 307 | 308 },
 ): (
-  self: RouteSet.RouteSet<D, B, I>,
-) => RouteSet.RouteSet<D, B, [...I, Route.Route<{}, {}, "", never, never>]> {
+  self: RouteSet<D, B, I>,
+) => RouteSet<D, B, [...I, Route<{}, {}, "", never, never>]> {
   const route = make<{}, {}, "">(() =>
     Effect.succeed(
       Entity.make("", {
@@ -243,7 +248,7 @@ export function redirect<D extends RouteDescriptor.Any, B, I extends Route.Tuple
   )
 
   return (self) =>
-    set<D, B, [...I, Route.Route<{}, {}, "", never, never>]>(
+    set<D, B, [...I, Route<{}, {}, "", never, never>]>(
       [...items(self), route],
       descriptor(self),
     )
@@ -255,6 +260,20 @@ export function layer(routes: RouteTree.RouteMap | RouteTree.RouteTree) {
   return Layer.sync(Routes, () => (RouteTree.isRouteTree(routes) ? routes : RouteTree.make(routes)))
 }
 
+export function layerMerge(routes: RouteTree.InputRouteMap | RouteTree.RouteTree) {
+  return Layer.effect(
+    Routes,
+    Effect.gen(function* () {
+      const existing = yield* Effect.serviceOption(Routes).pipe(
+        Effect.andThen(Option.getOrUndefined),
+      )
+      const tree = RouteTree.isRouteTree(routes) ? routes : RouteTree.make(routes)
+      if (!existing) return tree
+      return RouteTree.merge(existing, tree)
+    }),
+  )
+}
+
 /**
  * Creates a route that short-curcits in development.
  *
@@ -262,9 +281,9 @@ export function layer(routes: RouteTree.RouteMap | RouteTree.RouteTree) {
  * we exclude them altogeteher in development.
  */
 export function devOnly<D extends RouteDescriptor.Any, B, I extends Route.Tuple>(
-  self: RouteSet.RouteSet<D, B, I>,
-): RouteSet.RouteSet<D, B, [...I, Route.Route<{ dev: true }, { dev: true }, unknown, any, any>]> {
-  const route: Route.Route<{ dev: true }, { dev: true }, unknown, any, any> = make<
+  self: RouteSet<D, B, I>,
+): RouteSet<D, B, [...I, Route<{ dev: true }, { dev: true }, unknown, any, any>]> {
+  const route: Route<{ dev: true }, { dev: true }, unknown, any, any> = make<
     { dev: true },
     { dev: true },
     unknown,
@@ -280,12 +299,12 @@ export function devOnly<D extends RouteDescriptor.Any, B, I extends Route.Tuple>
     { dev: true },
   )
 
-  const nextItems: [...I, Route.Route<{ dev: true }, { dev: true }, unknown, any, any>] = [
+  const nextItems: [...I, Route<{ dev: true }, { dev: true }, unknown, any, any>] = [
     ...items(self),
     route,
   ]
 
-  return set<D, B, [...I, Route.Route<{ dev: true }, { dev: true }, unknown, any, any>]>(
+  return set<D, B, [...I, Route<{ dev: true }, { dev: true }, unknown, any, any>]>(
     nextItems,
     descriptor(self),
   )
@@ -309,3 +328,5 @@ export function lazy<T extends RouteSet.Any>(
     )
   })
 }
+
+export { link } from "./RouteLink.ts"

package/src/RouteBody.ts

@@ -111,13 +111,13 @@ export interface BuildReturn<Value, F extends Format, Body = never> {
   >(
     handler: GeneratorHandler<NoInfer<D & B & Route.ExtractBindings<I> & { format: F }>, A, Y>,
   ): (
-    self: Route.RouteSet.RouteSet<D, B, I>,
-  ) => Route.RouteSet.RouteSet<
+    self: Route.RouteSet<D, B, I>,
+  ) => Route.RouteSet<
     D,
     B,
     [
       ...I,
-      Route.Route.Route<
+      Route.Route<
         { format: F },
         {},
         [Body] extends [never] ? A : Body,
@@ -137,11 +137,11 @@ export interface BuildReturn<Value, F extends Format, Body = never> {
   >(
     handler: HandlerInput<NoInfer<D & B & Route.ExtractBindings<I> & { format: F }>, A, E, R>,
   ): (
-    self: Route.RouteSet.RouteSet<D, B, I>,
-  ) => Route.RouteSet.RouteSet<
+    self: Route.RouteSet<D, B, I>,
+  ) => Route.RouteSet<
     D,
     B,
-    [...I, Route.Route.Route<{ format: F }, {}, [Body] extends [never] ? A : Body, E, R>]
+    [...I, Route.Route<{ format: F }, {}, [Body] extends [never] ? A : Body, E, R>]
   >
 }
 
@@ -163,7 +163,7 @@ export function build<Value, F extends Format>(options: {
     E = never,
     R = never,
   >(handler: HandlerInput<NoInfer<D & B & Route.ExtractBindings<I> & { format: F }>, A, E, R>) {
-    return (self: Route.RouteSet.RouteSet<D, B, I>) => {
+    return (self: Route.RouteSet<D, B, I>) => {
       const contentType = formatToContentType[descriptors.format]
       const baseHandler = handle(handler)
       const wrappedHandler: Route.Route.Handler<{ format: F }, A, E, R> = (ctx, next) =>
@@ -191,7 +191,7 @@ export function build<Value, F extends Format>(options: {
 
       const route = Route.make<{ format: F }, {}, A, E, R>(wrappedHandler, descriptors)
 
-      return Route.set<D, B, [...I, Route.Route.Route<{ format: F }, {}, A, E, R>]>(
+      return Route.set<D, B, [...I, Route.Route<{ format: F }, {}, A, E, R>]>(
         [...Route.items(self), route],
         Route.descriptor(self),
       )
@@ -210,11 +210,11 @@ export function render<
 >(
   handler: GeneratorHandler<NoInfer<D & B & Route.ExtractBindings<I> & { format: "*" }>, A, Y>,
 ): (
-  self: Route.RouteSet.RouteSet<D, B, I>,
-) => Route.RouteSet.RouteSet<
+  self: Route.RouteSet<D, B, I>,
+) => Route.RouteSet<
   D,
   B,
-  [...I, Route.Route.Route<{ format: "*" }, {}, A, YieldError<Y>, YieldContext<Y>>]
+  [...I, Route.Route<{ format: "*" }, {}, A, YieldError<Y>, YieldContext<Y>>]
 >
 export function render<
   D extends Route.RouteDescriptor.Any,
@@ -226,8 +226,8 @@ export function render<
 >(
   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>]>
+  self: Route.RouteSet<D, B, I>,
+) => Route.RouteSet<D, B, [...I, Route.Route<{ format: "*" }, {}, A, E, R>]>
 export function render<
   D extends Route.RouteDescriptor.Any,
   B extends {},
@@ -236,14 +236,14 @@ export function render<
   E = never,
   R = never,
 >(handler: HandlerInput<NoInfer<D & B & Route.ExtractBindings<I> & { format: "*" }>, A, E, R>) {
-  return (self: Route.RouteSet.RouteSet<D, B, I>) => {
+  return (self: Route.RouteSet<D, B, I>) => {
     const baseHandler = handle(handler)
     const route = Route.make<{ format: "*" }, {}, A, E, R>(
       (ctx, next) => baseHandler(ctx as D & B & Route.ExtractBindings<I> & { format: "*" }, next),
       { format: "*" },
     )
 
-    return Route.set<D, B, [...I, Route.Route.Route<{ format: "*" }, {}, A, E, R>]>(
+    return Route.set<D, B, [...I, Route.Route<{ format: "*" }, {}, A, E, R>]>(
       [...Route.items(self), route],
       Route.descriptor(self),
     )

package/src/RouteHook.ts

@@ -25,8 +25,8 @@ export function filter<
   const normalized = normalizeFilterHandler(filterHandler)
 
   return function (
-    self: Route.RouteSet.RouteSet<D, SB, P>,
-  ): Route.RouteSet.RouteSet<D, SB, [...P, Route.Route.Route<{}, BOut, unknown, E, R>]> {
+    self: Route.RouteSet<D, SB, P>,
+  ): Route.RouteSet<D, SB, [...P, 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* () {
@@ -39,7 +39,7 @@ export function filter<
     )
 
     return Route.set(
-      [...Route.items(self), route] as [...P, Route.Route.Route<{}, BOut, unknown, E, R>],
+      [...Route.items(self), route] as [...P, Route.Route<{}, BOut, unknown, E, R>],
       Route.descriptor(self),
     )
   }

package/src/RouteHttp.ts

@@ -76,7 +76,7 @@ const respondError = (
 
 function streamResponse(
   stream: Stream.Stream<unknown, unknown, unknown>,
-  headers: Record<string, string | null | undefined>,
+  headers: globalThis.Headers,
   status: number,
   runtime: Runtime.Runtime<any>,
 ): Response {
@@ -92,10 +92,27 @@ function streamResponse(
   )
   return new Response(Stream.toReadableStreamRuntime(byteStream, runtime), {
     status,
-    headers: headers as Record<string, string>,
+    headers,
   })
 }
 
+function toHeaders(entityHeaders: Entity.Headers, contentType: string): globalThis.Headers {
+  const headers = new Headers()
+  for (const key in entityHeaders) {
+    const value = entityHeaders[key]
+    if (value == null) continue
+    if (typeof value === "string") {
+      headers.set(key, value)
+    } else {
+      for (const v of value) headers.append(key, v)
+    }
+  }
+  if (!headers.has("content-type")) {
+    headers.set("content-type", contentType)
+  }
+  return headers
+}
+
 function toResponse(
   entity: Entity.Entity<any>,
   format: string | undefined,
@@ -103,7 +120,7 @@ function toResponse(
 ): Effect.Effect<Response, ParseResult.ParseError> {
   const contentType = Entity.type(entity)
   const status = entity.status ?? 200
-  const headers = { ...entity.headers, "content-type": contentType }
+  const headers = toHeaders(entity.headers, contentType)
 
   if (StreamExtra.isStream(entity.body)) {
     return Effect.succeed(streamResponse(entity.body, headers, status, runtime))
@@ -168,66 +185,49 @@ function determineSelectedFormat(
 
 export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
   const runFork = Runtime.runFork(runtime)
+  const runSync = Runtime.runSync(runtime)
+  const inDevelopment = Option.isSome(runSync(Development.option))
 
   return (routes: Iterable<UnboundedRouteWithMethod>): Http.WebHandler => {
-    const grouped = Object.groupBy(
-      routes,
-      (route) => Route.descriptor(route).method?.toUpperCase() ?? "*",
-    )
-    const wildcards = grouped["*"] ?? []
-    const methodGroups: {
-      [method in Http.Method]?: Array<UnboundedRouteWithMethod>
-    } = {
-      GET: undefined,
-      POST: undefined,
-      PUT: undefined,
-      PATCH: undefined,
-      DELETE: undefined,
-      HEAD: undefined,
-      OPTIONS: undefined,
+    const allRoutes = Array.from(routes)
+    const methods = new Set<string>()
+    for (const route of allRoutes) {
+      const m = Route.descriptor(route).method?.toUpperCase()
+      if (m && m !== "*") methods.add(m)
     }
-
-    for (const method in grouped) {
-      if (method !== "*") {
-        methodGroups[method] = grouped[method]
-      }
+    if (methods.has("GET") && !methods.has("HEAD")) {
+      methods.add("HEAD")
     }
-
-    if (methodGroups["GET"] !== undefined && methodGroups["HEAD"] === undefined) {
-      methodGroups["HEAD"] = methodGroups["GET"]
-    }
-
-    const allowedMethods = Object.keys(methodGroups)
-      .filter((m) => methodGroups[m] !== undefined && methodGroups[m]!.length > 0)
-      .join(", ")
+    const allowedMethods = Array.from(methods).join(", ")
 
     return (request) =>
       new Promise((resolve) => {
         const method = request.method.toUpperCase()
         const accept = request.headers.get("accept")
-        const methodRoutes = methodGroups[method] ?? []
+        const matchingRoutes = allRoutes.filter((route) => {
+          const m = Route.descriptor(route).method?.toUpperCase()
+          return m === "*" || m === method || (method === "HEAD" && m === "GET")
+        })
 
-        if (method === "OPTIONS" && methodRoutes.length === 0 && wildcards.length === 0) {
-          return resolve(
-            new Response(null, {
-              status: 204,
-              headers: { allow: allowedMethods },
-            }),
-          )
-        }
+        if (matchingRoutes.length === 0) {
+          if (method === "OPTIONS" || methods.size === 0) {
+            return resolve(
+              new Response(null, {
+                status: 204,
+                headers: { allow: allowedMethods },
+              }),
+            )
+          }
 
-        if (methodRoutes.length === 0 && wildcards.length === 0) {
           return resolve(
             respondError({ status: 405, message: "method not allowed" }, { allow: allowedMethods }),
           )
         }
-
-        const allRoutes = [...wildcards, ...methodRoutes]
-        const selectedFormat = determineSelectedFormat(accept, allRoutes)
+        const selectedFormat = determineSelectedFormat(accept, matchingRoutes)
 
         const specificFormats = new Set<string>()
         let hasWildcardFormatRoutes = false
-        for (const r of allRoutes) {
+        for (const r of matchingRoutes) {
           const format = Route.descriptor(r).format
           if (format === "*") hasWildcardFormatRoutes = true
           else if (format) specificFormats.add(format)
@@ -249,13 +249,13 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
               currentContext = passedContext
             }
 
-            if (index >= allRoutes.length) {
+            if (index >= matchingRoutes.length) {
               return Effect.succeed(
                 Entity.make({ status: 404, message: "route not found" }, { status: 404 }),
               )
             }
 
-            const route = allRoutes[index++]
+            const route = matchingRoutes[index++]
             const descriptor = Route.descriptor(route)
             const format = descriptor.format
             const handler = route.handler as unknown as Handler
@@ -292,7 +292,7 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
 
           const url = new URL(request.url)
 
-          const innerEffect = Effect.gen(function* () {
+          const innerEffect = Effect.provideService(Effect.gen(function* () {
             const result = yield* createChain({ request, selectedFormat })
 
             const entity = Entity.isEntity(result) ? result : Entity.make(result, { status: 200 })
@@ -306,7 +306,7 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
               response.headers.set("vary", "Accept")
             }
             return response
-          })
+          }), Route.Request, request)
 
           if (tracerDisabled) {
             return innerEffect
@@ -356,7 +356,9 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
               Effect.gen(function* () {
                 yield* Effect.logError(cause)
                 const status = getStatusFromCause(cause)
-                const message = Cause.pretty(cause, { renderErrorCause: true })
+                const message = inDevelopment
+                  ? Cause.pretty(cause, { renderErrorCause: true })
+                  : "Internal Server Error"
                 return respondError({ status, message })
               }),
             ),
@@ -384,7 +386,9 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
             resolve(respondError({ status: 499, message: "client closed request" }))
           } else {
             const status = getStatusFromCause(exit.cause)
-            const message = Cause.pretty(exit.cause, { renderErrorCause: true })
+            const message = inDevelopment
+              ? Cause.pretty(exit.cause, { renderErrorCause: true })
+              : "Internal Server Error"
             resolve(respondError({ status, message }))
           }
         })

package/src/RouteLink.ts

@@ -0,0 +1,56 @@
+import type * as PathPattern from "./_PathPattern.ts"
+import type * as Route from "./Route.ts"
+import type { Routes as DevRoutes } from "effect-start/dev"
+
+export type LinkParams<
+  Routes,
+  P extends string,
+  B = P extends keyof Routes
+    ? Routes[P] extends [...any[], infer L] // last route
+      ? L extends () => Promise<{ default: infer R extends Route.RouteSet.Any }>
+        ? Route.Route.Bindings<R>
+        : {}
+      : {}
+    : {},
+> = {
+  [K in keyof PathPattern.Params<P>]: B extends { pathParams: infer S }
+    ? K extends keyof S
+      ? S[K]
+      : string | number
+    : string | number
+} & (B extends { searchParams: infer S } ? { [K in keyof S]?: S[K] } : {})
+
+export function link<
+  Routes = DevRoutes,
+  P extends keyof Routes extends never
+    ? // Falls back to any string when no routes are registered
+      string
+    : keyof Routes & string = keyof Routes extends never ? string : keyof Routes & string,
+>(
+  ...args: {} extends LinkParams<Routes, P>
+    ? [path: P, params?: LinkParams<Routes, P>]
+    : [path: P, params: LinkParams<Routes, P>]
+): string {
+  const path = args[0] as string
+  // Substitute path params, deleting used keys so the rest become search params
+  const remaining = { ...args[1] } as Record<string, string | number | undefined>
+  const result = path.replace(
+    /\/:(\w+)([?*+])?/g,
+    (_, name: string, modifier: string | undefined) => {
+      const value = remaining[name]
+      delete remaining[name]
+      if (value == null) {
+        if (modifier === "?" || modifier === "*") return ""
+        return "/"
+      }
+      return "/" + encodeURIComponent(String(value))
+    },
+  )
+
+  const search = new URLSearchParams()
+  for (const key in remaining) {
+    if (remaining[key] != null) search.set(key, String(remaining[key]))
+  }
+  const qs = search.toString()
+  return qs ? result + "?" + qs : result
+}