effect-start 0.34.0 → 0.35.0

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

@@ -185,6 +185,8 @@ 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 allRoutes = Array.from(routes)
@@ -290,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 })
@@ -304,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
@@ -354,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 })
               }),
             ),
@@ -382,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
+}

package/src/RouteMount.ts

@@ -7,10 +7,7 @@ import type * as RouteBody from "./RouteBody.ts"
 
 const RouteSetTypeId = "~effect-start/RouteSet" as const
 
-// oxlint-disable-next-line import/first, typescript/consistent-type-imports -- typeof import() is not an import statement
-type Module = typeof import("./RouteMount.ts")
-
-export type Self = RouteMount.Builder<any, any> | Omit<RouteMount.Builder<any, any>, "use"> | Module
+export type Self = RouteMount.Builder<any, any> | typeof import("./RouteMount.ts")
 
 export const use = makeMethodDescriber("*")
 export const get = makeMethodDescriber("GET")
@@ -65,7 +62,7 @@ function makeMethodDescriber<M extends RouteMount.Method>(method: M): RouteMount
       const itemDescriptor = Route.descriptor(item)
       const newDescriptor = { method, ...itemDescriptor }
       return Route.make(
-        (item as Route.Route.Route).handler as Route.Route.Handler<any, any, any, any>,
+        (item as Route.Route).handler as Route.Route.Handler<any, any, any, any>,
         newDescriptor,
       )
     })
@@ -75,7 +72,7 @@ function makeMethodDescriber<M extends RouteMount.Method>(method: M): RouteMount
   return describeMethod as RouteMount.Describer<M>
 }
 
-export type MountedRoute = Route.Route.Route<
+export type MountedRoute = Route.Route<
   {
     method: RouteMount.Method
     path: PathPattern.PathPattern
@@ -90,34 +87,43 @@ export type MountedRoute = Route.Route.Route<
 export namespace RouteMount {
   export type Method = "*" | Http.Method
 
-  export type MountSet = Route.RouteSet.RouteSet<{ method: Method }, {}, Route.Route.Tuple>
+  export type MountSet = Route.RouteSet<{ method: Method }, {}, Route.Route.Tuple>
 
-  export interface Builder<D extends {} = {}, I extends Route.Route.Tuple = []>
-    extends Route.RouteSet.RouteSet<D, {}, I> {
-    use: Describer<"*">
-    get: Describer<"GET">
-    post: Describer<"POST">
-    put: Describer<"PUT">
-    del: Describer<"DELETE">
-    patch: Describer<"PATCH">
-    head: Describer<"HEAD">
-    options: Describer<"OPTIONS">
-  }
+  export type Builder<D extends {} = {}, I extends Route.Route.Tuple = []> = Route.RouteSet<
+    D,
+    {},
+    I
+  > &
+    (HasMethod<I> extends true ? {} : { use: Describer<"*"> }) & {
+      get: Describer<"GET">
+      post: Describer<"POST">
+      put: Describer<"PUT">
+      del: Describer<"DELETE">
+      patch: Describer<"PATCH">
+      head: Describer<"HEAD">
+      options: Describer<"OPTIONS">
+    }
 
-  export type BuilderAfter<M extends Method, I extends Route.Route.Tuple> =
-    M extends "*" ? Builder<{}, I> : Omit<Builder<{}, I>, "use">
+  type HasMethod<I extends Route.Route.Tuple> = I extends [
+    infer Head,
+    ...infer Tail extends Route.Route.Tuple,
+  ]
+    ? Head extends Route.Route<{ method: infer M }, any, any, any, any>
+      ? M extends Http.Method
+        ? true
+        : HasMethod<Tail>
+      : HasMethod<Tail>
+    : false
 
-  export type EmptySet<M extends Method, B = {}> = Route.RouteSet.RouteSet<{ method: M }, B, []>
+  export type EmptySet<M extends Method, B = {}> = Route.RouteSet<{ method: M }, B, []>
 
   export type Items<S> = S extends Builder<any, infer I> ? I : []
 
   export type BuilderBindings<S> =
-    S extends Builder<any, infer I>
-      ? Types.Simplify<WildcardBindings<I>> & { request: Request }
-      : { request: Request }
+    S extends Builder<any, infer I> ? Types.Simplify<WildcardBindings<I>> : {}
 
   type WildcardBindingsItem<T> =
-    T extends Route.Route.Route<{ method: "*" }, infer B, any, any, any> ? B : {}
+    T extends Route.Route<{ method: "*" }, infer B, any, any, any> ? B : {}
 
   type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
     k: infer I,
@@ -131,35 +137,24 @@ export namespace RouteMount {
     }[number]
   >
 
-  // Flatten items: merge method into descriptor and accumulate bindings through the chain
-  // `request` is omitted from bindings since it's implicit (always available)
-  export type FlattenItems<M extends Method, B, I extends Route.Route.Tuple> = I extends [
-    Route.Route.Route<infer D, infer RB, infer A, infer E, infer R>,
+  export type FlattenItems<M extends Method, I extends Route.Route.Tuple> = I extends [
+    Route.Route<infer D, infer RB, infer A, infer E, infer R>,
     ...infer Tail extends Route.Route.Tuple,
   ]
-    ? [
-        Route.Route.Route<
-          Types.Simplify<{ method: M } & D> & {},
-          Types.Simplify<Omit<B & RB, "request">>,
-          A,
-          E,
-          R
-        >,
-        ...FlattenItems<M, Types.Simplify<B & RB>, Tail>,
-      ]
+    ? [Route.Route<Types.Simplify<{ method: M } & D> & {}, RB, A, E, R>, ...FlattenItems<M, Tail>]
     : []
 
   export interface Describer<M extends Method> {
     <S extends Self, A extends Route.RouteSet.Any>(
       this: S,
       ab: (a: EmptySet<M, BuilderBindings<S>>) => A,
-    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<A>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<A>>]>
 
     <S extends Self, A extends Route.RouteSet.Any, B extends Route.RouteSet.Any>(
       this: S,
       ab: (a: EmptySet<M, BuilderBindings<S>>) => A,
       bc: (b: A) => B,
-    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<B>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<B>>]>
 
     <
       S extends Self,
@@ -171,7 +166,7 @@ export namespace RouteMount {
       ab: (a: EmptySet<M, BuilderBindings<S>>) => A,
       bc: (b: A) => B,
       cd: (c: B) => C,
-    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<C>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<C>>]>
 
     <
       S extends Self,
@@ -185,7 +180,7 @@ export namespace RouteMount {
       bc: (b: A) => B,
       cd: (c: B) => C,
       de: (d: C) => D,
-    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<D>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<D>>]>
 
     <
       S extends Self,
@@ -201,7 +196,7 @@ export namespace RouteMount {
       cd: (c: B) => C,
       de: (d: C) => D,
       ef: (e: D) => E,
-    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<E>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<E>>]>
 
     <
       S extends Self,
@@ -219,7 +214,7 @@ export namespace RouteMount {
       de: (d: C) => D,
       ef: (e: D) => E,
       fg: (f: E) => F,
-    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<F>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<F>>]>
 
     <
       S extends Self,
@@ -239,7 +234,7 @@ export namespace RouteMount {
       ef: (e: D) => E,
       fg: (f: E) => F,
       gh: (g: F) => G,
-    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<G>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<G>>]>
 
     <
       S extends Self,
@@ -261,7 +256,7 @@ export namespace RouteMount {
       fg: (f: E) => F,
       gh: (g: F) => G,
       hi: (h: G) => H,
-    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<H>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<H>>]>
 
     <
       S extends Self,
@@ -285,6 +280,6 @@ export namespace RouteMount {
       gh: (g: F) => G,
       hi: (h: G) => H,
       ij: (i: H) => I,
-    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<I>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<I>>]>
   }
 }