@getsoda/core 0.2.2 → 0.3.0

package/src/app/app.ts

@@ -22,13 +22,15 @@
 import { createContainer, provide } from '../di/index.ts'
 import type { Container, ContainerOptions, ModuleImport } from '../di/index.ts'
 import { destroyAll, initializeAll } from '../di/lifecycle.ts'
-import { buildRoutes } from '../http/index.ts'
+import { buildRoutes, ControllerError, ROUTES } from '../http/index.ts'
 import type { ControllerRoutesOptions, MappedController, Middleware } from '../http/index.ts'
 import { errorResponse } from '../http/exceptions.ts'
 import { applyMiddleware, resolveMiddleware } from '../http/middleware.ts'
 import { ConsoleLogger, Logger, SilentLogger } from '../logger/index.ts'
 import { compileRoutes } from '../routing/index.ts'
-import type { CompiledRoutes, CompileOptions } from '../routing/index.ts'
+import type { CompiledRoutes, CompileOptions, NativeHandler } from '../routing/index.ts'
+import { websocketHandler } from '../websocket/gateway.ts'
+import type { BuiltGateway, GatewaySocketData } from '../websocket/gateway.ts'
 import { release, takeOver } from './hot.ts'
 
 /**
@@ -68,16 +70,16 @@ const DEFAULT_SIGNALS: readonly NodeJS.Signals[] = ['SIGTERM', 'SIGINT']
  */
 export interface App {
   readonly container: Container
-  /** Routes for `Bun.serve()`, when serving them yourself instead of calling `listen()`. */
-  readonly routes: CompiledRoutes
+  /** Routes (and WebSocket handlers) for `Bun.serve()`, when serving them yourself instead of calling `listen()`. */
+  readonly routes: ServeRoutes
   /** The server once `listen()` resolved. */
-  readonly server: Bun.Server<undefined> | undefined
+  readonly server: Bun.Server<GatewaySocketData> | undefined
   /**
    * Starts serving. Under `bun --hot`, a new version of the application
    * listening on the same port takes the server over from the previous one,
    * which is then destroyed (its server is not stopped: it is shared).
    */
-  listen(options?: number | ListenOptions): Promise<Bun.Server<undefined>>
+  listen(options?: number | ListenOptions): Promise<Bun.Server<GatewaySocketData>>
   /**
    * Graceful shutdown: refuses new requests, waits for those in flight, then
    * runs `onDestroy` hooks. Safe to call more than once, even from a hook.
@@ -92,27 +94,35 @@ export interface App {
 
 class Application implements App {
   readonly container: Container
-  readonly routes: CompiledRoutes
-  #server: Bun.Server<undefined> | undefined
+  readonly routes: ServeRoutes
+  #server: Bun.Server<GatewaySocketData> | undefined
   /** Set when a new version took the server over: it must not be stopped. */
   #handedOver = false
   #closing: Promise<void> | undefined
   readonly #enhancers: readonly unknown[]
   readonly #signals = new Map<NodeJS.Signals, () => void>()
   readonly #logger: Logger
-
-  constructor(container: Container, routes: CompiledRoutes, enhancers: readonly unknown[], logger: Logger) {
+  readonly #gateways: readonly BuiltGateway[]
+
+  constructor(
+    container: Container,
+    routes: ServeRoutes,
+    gateways: readonly BuiltGateway[],
+    enhancers: readonly unknown[],
+    logger: Logger
+  ) {
     this.container = container
     this.routes = routes
+    this.#gateways = gateways
     this.#enhancers = enhancers
     this.#logger = logger
   }
 
-  get server(): Bun.Server<undefined> | undefined {
+  get server(): Bun.Server<GatewaySocketData> | undefined {
     return this.#server
   }
 
-  async listen(options: number | ListenOptions = {}): Promise<Bun.Server<undefined>> {
+  async listen(options: number | ListenOptions = {}): Promise<Bun.Server<GatewaySocketData>> {
     if (this.#closing !== undefined) {
       throw new Error('Cannot listen: the application is closed')
     }
@@ -191,6 +201,11 @@ class Application implements App {
     const server = this.#server
 
     try {
+      // Open sockets would keep stop() waiting; under --hot, clients reconnect to the new version.
+      for (const gateway of this.#gateways) {
+        gateway.runtime.closeAll()
+      }
+
       if (server !== undefined && !this.#handedOver) {
         await server.stop()
       }
@@ -245,8 +260,37 @@ const destroyEverything = async (enhancers: readonly unknown[], container: Conta
   }
 }
 
+/**
+ * Routes and WebSocket handlers for `Bun.serve()`: the handshakes of gateways
+ * are native routes of their own, outside middleware, as an upgrade returns no response.
+ */
+export interface ServeRoutes {
+  readonly routes: Record<string, NativeHandler | BuiltGateway['handle']>
+  readonly fetch: CompiledRoutes['fetch']
+  readonly websocket: Bun.WebSocketHandler<GatewaySocketData>
+}
+
+const withGateways = (compiled: CompiledRoutes, gateways: readonly BuiltGateway[]): ServeRoutes => {
+  const routes: ServeRoutes['routes'] = { ...compiled.routes }
+
+  for (const gateway of gateways) {
+    if (Object.hasOwn(routes, gateway.path)) {
+      throw new ControllerError('DUPLICATE_ROUTE', `The WebSocket gateway on ${gateway.path} has the path of another gateway or route`)
+    }
+
+    routes[gateway.path] = gateway.handle
+  }
+
+  return { routes, fetch: compiled.fetch, websocket: websocketHandler }
+}
+
 /** What Nest logs at startup: the modules, then each controller and its routes. */
-const logStartup = (logger: Logger, container: Container, controllers: readonly MappedController[]): void => {
+const logStartup = (
+  logger: Logger,
+  container: Container,
+  controllers: readonly MappedController[],
+  gateways: readonly BuiltGateway[]
+): void => {
   const modules = logger.child('Container')
   const routes = logger.child('Routes')
 
@@ -257,10 +301,14 @@ const logStartup = (logger: Logger, container: Container, controllers: readonly
   for (const { controller, path, routes: mapped } of controllers) {
     routes.log(`${controller.name} {${path}}:`)
 
-    for (const route of mapped) {
-      routes.log(`Mapped {${route.path}, ${route.method}} route`)
+    for (const { info } of mapped) {
+      routes.log(`Mapped {${info.path}, ${info.method}} route`)
     }
   }
+
+  for (const gateway of gateways) {
+    routes.log(`WebSocket gateway {${gateway.path}}, events: ${gateway.runtime.events.join(', ') || 'none'}`)
+  }
 }
 
 /**
@@ -280,9 +328,11 @@ export const createApp = async (root: ModuleImport, options: AppOptions = {}): P
 
   own.log('Starting application')
 
+  // Filled once the routes are built; read by what describes them (OpenAPI).
+  const registry: { controllers: readonly MappedController[] } = { controllers: [] }
   const container = await createContainer(root, {
     ...options,
-    providers: [...(options.providers ?? []), provide(Logger, { useValue: logger })],
+    providers: [...(options.providers ?? []), provide(Logger, { useValue: logger }), provide(ROUTES, { useValue: registry })],
   })
   const enhancers: unknown[] = []
 
@@ -293,7 +343,8 @@ export const createApp = async (root: ModuleImport, options: AppOptions = {}): P
     })
     const built = buildRoutes(container, { ...options, onError })
 
-    logStartup(logger, container, built.controllers)
+    registry.controllers = built.controllers
+    logStartup(logger, container, built.controllers, built.gateways)
     enhancers.push(...built.enhancers)
     await initializeAll(enhancers)
     own.log('Application started')
@@ -303,7 +354,7 @@ export const createApp = async (root: ModuleImport, options: AppOptions = {}): P
       errorResponse(error, (unknown) => onError(unknown, req))
     )
 
-    return new Application(container, routes, enhancers, own)
+    return new Application(container, withGateways(routes, built.gateways), built.gateways, enhancers, own)
   } catch (error) {
     try {
       await destroyEverything(enhancers, container)

package/src/app/index.ts

@@ -4,4 +4,4 @@
  */
 
 export { createApp } from './app.ts'
-export type { App, AppOptions, ListenOptions } from './app.ts'
+export type { App, AppOptions, ListenOptions, ServeRoutes } from './app.ts'

package/src/config/config.ts

@@ -24,6 +24,7 @@
 import { InjectionToken } from '../di/token.ts'
 import { formatIssues } from '../http/schema.ts'
 import type { InferOutput, StandardSchemaV1 } from '../http/schema.ts'
+import { hideFrameworkFrames } from '../utils/errors.ts'
 
 /** Environment variables, as in `process.env`. */
 export type Environment = Readonly<Record<string, string | undefined>>
@@ -37,6 +38,7 @@ export class ConfigError extends Error {
     readonly issues: readonly string[]
   ) {
     super(`Invalid configuration "${config}":\n  ${issues.join('\n  ')}`)
+    hideFrameworkFrames(this)
   }
 }
 

package/src/di/errors.ts

@@ -3,6 +3,8 @@
  * Errors raised by the dependency injection container.
  */
 
+import { hideFrameworkFrames } from '../utils/errors.ts'
+
 /**
  * Reason of a `DiError`.
  *
@@ -42,5 +44,6 @@ export class DiError extends Error {
     message: string
   ) {
     super(message)
+    hideFrameworkFrames(this)
   }
 }

package/src/http/arguments.ts

@@ -18,7 +18,7 @@
 
 import type { FormFields, FormLimits } from './body.ts'
 import type { ContextKey } from './context-key.ts'
-import type { Context, ParamNameOf } from './context.ts'
+import type { Context, ContextParams, ParamNameOf } from './context.ts'
 import type { Parsed, ValueParser } from './parsers.ts'
 import { isStandardSchema } from './schema.ts'
 import type { InferOutput, StandardSchemaV1 } from './schema.ts'
@@ -33,6 +33,10 @@ export interface Argument<T, K extends ArgumentKind = ArgumentKind, N extends st
   /** Parameter, query, header or cookie name; the key description for `value`; empty for `body` and `context`. */
   readonly name: N
   readonly read: (ctx: Context) => T | Promise<T>
+  /** The parser or schema the value goes through, for API descriptions such as OpenAPI. */
+  readonly source?: ValueParser<unknown> | StandardSchemaV1
+  /** Set by `form()`: the body is a form, not JSON. */
+  readonly multipart?: true
 }
 
 /** Arguments accepted by a route with path `P`: `param()` names must exist in it. */
@@ -40,13 +44,27 @@ export type ArgumentFor<P extends string> =
   | Argument<unknown, 'param', ParamNameOf<P>>
   | Argument<unknown, Exclude<ArgumentKind, 'param'>>
 
-/** Values a method receives for an argument list. */
-export type ArgumentValues<A extends readonly Argument<unknown>[]> = {
-  -readonly [K in keyof A]: A[K] extends Argument<infer T> ? T : never
+declare const RAW_PARAM: unique symbol
+
+/**
+ * Value of `param(name)` without parser, typed by the route path:
+ * `string` for `:id`, `string | undefined` for `:id?`.
+ */
+export interface RawParam {
+  readonly [RAW_PARAM]: true
+}
+
+/** Values a method receives for an argument list on a route with path `P`. */
+export type ArgumentValues<A extends readonly Argument<unknown>[], P extends string = string> = {
+  -readonly [K in keyof A]: A[K] extends Argument<infer T, ArgumentKind, infer N>
+    ? [T] extends [RawParam]
+      ? ContextParams<P>[N]
+      : T
+    : never
 }
 
-/** Path parameter. Like `@Param('id', ParseIntPipe)`. */
-export function param<const N extends string>(name: N): Argument<string | undefined, 'param', N>
+/** Path parameter, typed by the route path, or by `parser`. Like `@Param('id', ParseIntPipe)`. */
+export function param<const N extends string>(name: N): Argument<RawParam, 'param', N>
 export function param<const N extends string, V extends ValueParser<unknown>>(
   name: N,
   parser: V
@@ -55,6 +73,7 @@ export function param(name: string, parser?: ValueParser<unknown>): Argument<unk
   return {
     kind: 'param',
     name,
+    source: parser,
     read: parser === undefined ? (ctx) => ctx.param(name) : (ctx) => ctx.param(name, parser),
   }
 }
@@ -66,6 +85,7 @@ export function query(name: string, parser?: ValueParser<unknown>): Argument<unk
   return {
     kind: 'query',
     name,
+    source: parser,
     read: parser === undefined ? (ctx) => ctx.query(name) : (ctx) => ctx.query(name, parser),
   }
 }
@@ -77,6 +97,7 @@ export function header(name: string, parser?: ValueParser<unknown>): Argument<un
   return {
     kind: 'header',
     name,
+    source: parser,
     read: parser === undefined ? (ctx) => ctx.header(name) : (ctx) => ctx.header(name, parser),
   }
 }
@@ -88,6 +109,7 @@ export function cookie(name: string, parser?: ValueParser<unknown>): Argument<un
   return {
     kind: 'cookie',
     name,
+    source: parser,
     read: parser === undefined ? (ctx) => ctx.cookie(name) : (ctx) => ctx.cookie(name, parser),
   }
 }
@@ -99,6 +121,7 @@ export function body(schema?: StandardSchemaV1): Argument<unknown, 'body'> {
   return {
     kind: 'body',
     name: '',
+    source: schema,
     read: schema === undefined ? (ctx) => ctx.body() : (ctx) => ctx.body(schema),
   }
 }
@@ -128,6 +151,8 @@ export function form(schemaOrLimits?: StandardSchemaV1 | FormLimits, limits?: Fo
   return {
     kind: 'body',
     name: '',
+    source: isStandardSchema(schemaOrLimits) ? schemaOrLimits : undefined,
+    multipart: true,
     read: isStandardSchema(schemaOrLimits) ? (ctx) => ctx.form(schemaOrLimits, limits) : (ctx) => ctx.form(schemaOrLimits),
   }
 }

package/src/http/cookies.ts

@@ -84,6 +84,8 @@ type Result<O extends ParserOptions> = O extends { readonly optional: true } ? s
  * forged cookie is no better than none.
  */
 export const signed = <const O extends ParserOptions = {}>(signer: CookieSigner, options?: O): Parser<Result<O>> => ({
+  jsonSchema: { type: 'string' },
+  optional: options?.optional === true,
   parse: (value, name) => {
     const unsigned = value === undefined ? undefined : signer.unsign(value)
 

package/src/http/decorators.ts

@@ -41,6 +41,8 @@ export interface RouteMetadata {
   readonly path: string
   /** Declared arguments; `undefined` when the method receives the context. */
   readonly args: readonly Argument<unknown>[] | undefined
+  /** Declared with `@Sse()`: the result is streamed as server-sent events. */
+  readonly sse: boolean
 }
 
 /**
@@ -81,9 +83,9 @@ export type RouteHandlerHint<P extends string> =
  * Decorator of a route with an argument list: `@Get(':id', [param('id', int())])`.
  * The method must accept the values of the arguments, in order.
  */
-export type ArgumentsRouteDecorator<A extends readonly Argument<unknown>[]> = <
+export type ArgumentsRouteDecorator<A extends readonly Argument<unknown>[], P extends string = string> = <
   This,
-  M extends (this: This, ...args: ArgumentValues<A>) => unknown,
+  M extends (this: This, ...args: ArgumentValues<A, P>) => unknown,
 >(
   method: M,
   context: ClassMethodDecoratorContext<This, M>
@@ -101,8 +103,8 @@ export type ArgumentsRouteDecorator<A extends readonly Argument<unknown>[]> = <
  */
 export interface RouteDecoratorFactory {
   <const P extends string = '/'>(path?: P): RouteDecorator<P>
-  <const P extends string, const A extends readonly ArgumentFor<P>[]>(path: P, args: A): ArgumentsRouteDecorator<A>
-  <const A extends readonly ArgumentFor<'/'>[]>(args: A): ArgumentsRouteDecorator<A>
+  <const P extends string, const A extends readonly ArgumentFor<P>[]>(path: P, args: A): ArgumentsRouteDecorator<A, P>
+  <const A extends readonly ArgumentFor<'/'>[]>(args: A): ArgumentsRouteDecorator<A, '/'>
 }
 
 /**
@@ -170,7 +172,7 @@ export const Controller =
 /**
  * Creates the route decorator factory of one HTTP method (any method name, extensions included).
  */
-const routeFactory = (method: string, decorator: string): RouteDecoratorFactory =>
+const routeFactory = (method: string, decorator: string, sse = false): RouteDecoratorFactory =>
   ((pathOrArgs?: string | readonly Argument<unknown>[], args?: readonly Argument<unknown>[]) =>
     (target: object, context: MethodContext) => {
       assertPublicMethod(decorator, context)
@@ -179,7 +181,7 @@ const routeFactory = (method: string, decorator: string): RouteDecoratorFactory
       const list = typeof pathOrArgs === 'string' ? args : pathOrArgs
 
       // Decorators run bottom-up: unshift keeps the source order.
-      metadataOf(target).routes.unshift({ method, path, args: list })
+      metadataOf(target).routes.unshift({ method, path, args: list, sse })
     }) as RouteDecoratorFactory
 
 /**
@@ -191,8 +193,8 @@ export interface MethodRouteDecoratorFactory {
     method: string,
     path: P,
     args: A
-  ): ArgumentsRouteDecorator<A>
-  <const A extends readonly ArgumentFor<'/'>[]>(method: string, args: A): ArgumentsRouteDecorator<A>
+  ): ArgumentsRouteDecorator<A, P>
+  <const A extends readonly ArgumentFor<'/'>[]>(method: string, args: A): ArgumentsRouteDecorator<A, '/'>
 }
 
 /**
@@ -222,6 +224,12 @@ export const Head = routeFactory('HEAD', 'Head')
 /** Route for every method; a route for a concrete method on the same path wins. */
 export const All = routeFactory('ALL', 'All')
 
+/**
+ * `GET` route streaming server-sent events: the method returns an async
+ * iterable of `SseMessage`, such as an `async function*`. Like Nest's `@Sse()`.
+ */
+export const Sse = routeFactory('GET', 'Sse', true)
+
 /**
  * Status of the responses built from the returned value (not of a returned `Response`).
  * Defaults to `201` for `POST` and `200` otherwise, as in Nest.

package/src/http/errors.ts

@@ -3,6 +3,8 @@
  * Errors raised while declaring and collecting controllers.
  */
 
+import { hideFrameworkFrames } from '../utils/errors.ts'
+
 /**
  * Reason of a `ControllerError`.
  *
@@ -11,6 +13,8 @@
  * - `INVALID_STATUS`: `@HttpCode()` with a status a `Response` cannot have, or twice on one method.
  * - `INVALID_HEADER`: `@Header()` with a name or value `Headers` rejects.
  * - `UNKNOWN_PARAM`: `param('x')` in an argument list names no parameter of the route path.
+ * - `INVALID_PATH`: a WebSocket gateway path that is not static.
+ * - `DUPLICATE_ROUTE`: a gateway on the path of another gateway or route.
  */
 export type ControllerErrorCode =
   | 'NOT_A_CONTROLLER'
@@ -18,6 +22,8 @@ export type ControllerErrorCode =
   | 'INVALID_STATUS'
   | 'INVALID_HEADER'
   | 'UNKNOWN_PARAM'
+  | 'INVALID_PATH'
+  | 'DUPLICATE_ROUTE'
 
 /**
  * Error thrown by the controller decorators (when the class is defined) and by
@@ -31,5 +37,6 @@ export class ControllerError extends Error {
     message: string
   ) {
     super(message)
+    hideFrameworkFrames(this)
   }
 }

package/src/http/index.ts

@@ -4,12 +4,14 @@
  */
 
 export { body, context, cookie, form, header, param, query, value } from './arguments.ts'
-export type { Argument, ArgumentFor, ArgumentKind, ArgumentValues } from './arguments.ts'
+export type { Argument, ArgumentFor, ArgumentKind, ArgumentValues, RawParam } from './arguments.ts'
 export { Context } from './context.ts'
 export { CookieSigner, signed } from './cookies.ts'
 export { ContextKey } from './context-key.ts'
 export type { ContextParams, ParamNameOf } from './context.ts'
-export { All, Controller, Delete, Get, Head, Header, HttpCode, Options, Patch, Post, Put, Route } from './decorators.ts'
+export { All, Controller, Delete, Get, Head, Header, HttpCode, Options, Patch, Post, Put, Route, Sse } from './decorators.ts'
+export { formatSseMessage } from './sse.ts'
+export type { SseMessage } from './sse.ts'
 export type {
   ArgumentsRouteDecorator,
   MethodMetadataDecorator,
@@ -38,8 +40,8 @@ export {
 export type { HttpExceptionBody, HttpExceptionOptions } from './exceptions.ts'
 export { boolean, int, number, uuid } from './parsers.ts'
 export type { Parsed, Parser, ParserOptions, ValueParser } from './parsers.ts'
-export { buildRoutes, controllerRoutes } from './routes.ts'
-export type { BuiltRoutes, ControllerRoutesOptions, MappedController } from './routes.ts'
+export { buildRoutes, controllerRoutes, ROUTES } from './routes.ts'
+export type { BuiltRoutes, ControllerRoutesOptions, MappedController, MappedRoute, RouteRegistry } from './routes.ts'
 export type { InferOutput, StandardSchemaV1 } from './schema.ts'
 export type { AnyParams, PathParams } from './types.ts'
 export { Catch, createDecorator, UseFilters, UseGuards, UseInterceptors } from './enhancers.ts'

package/src/http/parsers.ts

@@ -20,6 +20,10 @@ import type { InferOutput, StandardSchemaV1 } from './schema.ts'
  */
 export interface Parser<T> {
   readonly parse: (value: string | undefined, name: string) => T
+  /** JSON Schema of the accepted strings, for API descriptions such as OpenAPI. */
+  readonly jsonSchema?: Readonly<Record<string, unknown>>
+  /** `true` when a missing value is accepted. */
+  readonly optional?: boolean
 }
 
 /** What `param()`, `query()` and `header()` accept to convert a value. */
@@ -46,8 +50,11 @@ export const failure = (name: string, expected: string): BadRequestException =>
 const createParser = <T>(
   expected: string,
   convert: (value: string) => T | undefined,
-  options: ParserOptions
+  options: ParserOptions,
+  jsonSchema: Readonly<Record<string, unknown>>
 ): Parser<T | undefined> => ({
+  jsonSchema,
+  optional: options.optional === true,
   parse: (value, name) => {
     if (value === undefined) {
       if (options.optional === true) {
@@ -79,7 +86,8 @@ export const int = <const O extends ParserOptions = {}>(options?: O): Parser<Res
 
       return Number.isSafeInteger(number) ? number : undefined
     },
-    options ?? {}
+    options ?? {},
+    { type: 'integer' }
   ) as Parser<Result<number, O>>
 
 /** Finite decimal number: `'1.5'`, `'-2'`, `'1e3'`. */
@@ -91,18 +99,21 @@ export const number = <const O extends ParserOptions = {}>(options?: O): Parser<
 
       return Number.isFinite(parsed) ? parsed : undefined
     },
-    options ?? {}
+    options ?? {},
+    { type: 'number' }
   ) as Parser<Result<number, O>>
 
 /** `'true'` or `'false'`. */
 export const boolean = <const O extends ParserOptions = {}>(options?: O): Parser<Result<boolean, O>> =>
-  createParser('boolean string', (value) => (value === 'true' ? true : value === 'false' ? false : undefined), options ?? {}) as Parser<
-    Result<boolean, O>
-  >
+  createParser('boolean string', (value) => (value === 'true' ? true : value === 'false' ? false : undefined), options ?? {}, {
+    type: 'boolean',
+  }) as Parser<Result<boolean, O>>
 
 /** UUID of any version, case-insensitive. */
 export const uuid = <const O extends ParserOptions = {}>(options?: O): Parser<Result<string, O>> =>
-  createParser('UUID string', (value) => (UUID.test(value) ? value : undefined), options ?? {}) as Parser<Result<string, O>>
+  createParser('UUID string', (value) => (UUID.test(value) ? value : undefined), options ?? {}, { type: 'string', format: 'uuid' }) as Parser<
+    Result<string, O>
+  >
 
 /**
  * Applies a parser or a synchronous Standard Schema to a raw value.

package/src/http/pipeline.ts

@@ -21,10 +21,10 @@ import { getCaughtExceptions } from './enhancers.ts'
 import type { CallHandler, CanActivate, ExceptionFilter, FilterLike, Guard, Interceptor, InterceptorLike } from './enhancers.ts'
 import { errorResponse, ForbiddenException } from './exceptions.ts'
 
-type GuardStep = (ctx: Context) => unknown
-type InterceptorStep = (ctx: Context, next: CallHandler) => unknown
+export type GuardStep = (ctx: Context) => unknown
+export type InterceptorStep = (ctx: Context, next: CallHandler) => unknown
 
-interface FilterStep {
+export interface FilterStep {
   /** Empty: catches everything. */
   readonly types: readonly ClassToken<unknown>[]
   readonly handle: (error: unknown, ctx: Context) => Response | Promise<Response>
@@ -174,7 +174,7 @@ export interface PipelineParts {
   /** In the order they are tried: method, class, global. */
   readonly filters: readonly FilterStep[]
   readonly invoke: (ctx: Context) => unknown
-  readonly respond: (value: unknown) => Response
+  readonly respond: (value: unknown, ctx: Context) => Response
   readonly onError: (error: unknown, req: Request) => void
 }
 
@@ -230,11 +230,11 @@ export const createPipeline = (parts: PipelineParts): Handler => {
 
       if (isThenable(result)) {
         return Promise.resolve(result)
-          .then(respond)
+          .then((value) => respond(value, ctx))
           .catch((error: unknown) => fail(error, ctx))
       }
 
-      return respond(result)
+      return respond(result, ctx)
     } catch (error) {
       return fail(error, ctx)
     }