@rest-rpc/nest 0.1.0-beta.14

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 rest-rpc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/decorators.d.ts

@@ -0,0 +1,26 @@
+import type { Contract, HttpRouteDeclaration } from "@rest-rpc/core/contract";
+import "reflect-metadata";
+export declare const REST_RPC_ROUTE_METADATA: unique symbol;
+export type RouteMetadata = {
+    route: HttpRouteDeclaration;
+};
+/**
+ * Binds a Nest controller method to a rest-rpc HTTP contract route.
+ *
+ * @remarks Use this decorator when a controller method returns the
+ * implementation for a single route. The method can still use Nest decorators
+ * and dependency injection before handing off to `route()`.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/nest#single-routes}
+ */
+export declare function Route(route: HttpRouteDeclaration): MethodDecorator;
+/**
+ * Binds one Nest controller method to every HTTP route in a rest-rpc contract router.
+ *
+ * @remarks Use this decorator when one controller method returns a
+ * contract-shaped implementation tree from `router()`. The decorator registers
+ * each HTTP route with Nest while the returned tree provides the handlers.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/nest#usage}
+ */
+export declare function Router(contract: Contract): MethodDecorator;

package/dist/decorators.js

@@ -0,0 +1,84 @@
+import { applyDecorators, RequestMethod } from "@nestjs/common";
+import { METHOD_METADATA, PATH_METADATA } from "@nestjs/common/constants.js";
+import { contractRouteEntries, toColonPath } from "@rest-rpc/core/contract";
+import "reflect-metadata";
+export const REST_RPC_ROUTE_METADATA = Symbol.for("rest-rpc:nest-route");
+const methodMap = {
+    DELETE: RequestMethod.DELETE,
+    GET: RequestMethod.GET,
+    PATCH: RequestMethod.PATCH,
+    POST: RequestMethod.POST,
+    PUT: RequestMethod.PUT,
+};
+const createNestRouteDecorator = (route) => (_target, _propertyKey, descriptor) => {
+    if (!descriptor?.value)
+        return;
+    Reflect.defineMetadata(PATH_METADATA, toColonPath(route.path), descriptor.value);
+    Reflect.defineMetadata(METHOD_METADATA, methodMap[route.method], descriptor.value);
+    Reflect.defineMetadata(REST_RPC_ROUTE_METADATA, { route }, descriptor.value);
+};
+const isHttpRouteDeclaration = (route) => "responses" in route;
+const getImplementationAtPath = (tree, path) => path.reduce((value, key) => value && typeof value === "object"
+    ? value[key]
+    : undefined, tree);
+const copyMetadata = (from, to) => {
+    for (const key of Reflect.getMetadataKeys(from)) {
+        Reflect.defineMetadata(key, Reflect.getMetadata(key, from), to);
+    }
+};
+const copyPropertyMetadata = (target, from, to) => {
+    for (const key of Reflect.getMetadataKeys(target.constructor, from)) {
+        Reflect.defineMetadata(key, Reflect.getMetadata(key, target.constructor, from), target.constructor, to);
+    }
+};
+let routerRouteMethodId = 0;
+const createRouterRouteMethod = (target, propertyKey, descriptor, route, path) => {
+    const original = descriptor.value;
+    if (typeof original !== "function")
+        return;
+    const routeMethodName = `__restRpcRouter_${String(propertyKey)}_${routerRouteMethodId++}`;
+    const routeMethod = async function (...args) {
+        const tree = await original.apply(this, args);
+        return getImplementationAtPath(tree, path);
+    };
+    copyMetadata(original, routeMethod);
+    copyPropertyMetadata(target, propertyKey, routeMethodName);
+    Object.defineProperty(target, routeMethodName, {
+        configurable: true,
+        value: routeMethod,
+    });
+    createNestRouteDecorator(route)(target, routeMethodName, {
+        ...descriptor,
+        value: routeMethod,
+    });
+};
+/**
+ * Binds a Nest controller method to a rest-rpc HTTP contract route.
+ *
+ * @remarks Use this decorator when a controller method returns the
+ * implementation for a single route. The method can still use Nest decorators
+ * and dependency injection before handing off to `route()`.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/nest#single-routes}
+ */
+export function Route(route) {
+    return applyDecorators(createNestRouteDecorator(route));
+}
+/**
+ * Binds one Nest controller method to every HTTP route in a rest-rpc contract router.
+ *
+ * @remarks Use this decorator when one controller method returns a
+ * contract-shaped implementation tree from `router()`. The decorator registers
+ * each HTTP route with Nest while the returned tree provides the handlers.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/nest#usage}
+ */
+export function Router(contract) {
+    return (target, propertyKey, descriptor) => {
+        for (const { route, path } of contractRouteEntries(contract)) {
+            if (!isHttpRouteDeclaration(route))
+                continue;
+            createRouterRouteMethod(target, propertyKey, descriptor, route, path);
+        }
+    };
+}

package/dist/expressPlatform.d.ts

@@ -0,0 +1,2 @@
+import type { NestHttpPlatform } from "./httpPlatform.ts";
+export declare const createExpressHttpPlatform: (req: unknown, res: unknown) => NestHttpPlatform | undefined;

package/dist/expressPlatform.js

@@ -0,0 +1,120 @@
+import { formatSseEvent } from "@rest-rpc/server";
+import { hasFunction } from "./httpPlatform.js";
+const isExpressLikeResponse = (value) => hasFunction(value, "status") &&
+    hasFunction(value, "send") &&
+    hasFunction(value, "setHeader");
+const createExpressRequestSignal = (req, res) => {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    req.once?.("aborted", abort);
+    res.once?.("close", () => {
+        if (!res.writableFinished)
+            abort();
+    });
+    return controller.signal;
+};
+const writeExpressStreamResponse = async (res, { body, status, contentType, mode, signal }) => {
+    res.status(status);
+    res.setHeader("content-type", contentType);
+    const iterator = body[Symbol.asyncIterator]();
+    let closed = false;
+    let finished = false;
+    const closeIterator = async () => {
+        try {
+            await iterator.return?.();
+        }
+        catch { }
+    };
+    const onClose = () => {
+        if (finished)
+            return;
+        closed = true;
+        void closeIterator();
+    };
+    res.on?.("close", onClose);
+    signal.addEventListener("abort", onClose, { once: true });
+    const waitForDrain = async () => {
+        if (!res.once)
+            return;
+        await new Promise((resolve, reject) => {
+            const cleanup = () => {
+                res.off?.("drain", onDrain);
+                res.off?.("close", onClose);
+                res.off?.("error", onError);
+            };
+            const onDrain = () => {
+                cleanup();
+                resolve();
+            };
+            const onClose = () => {
+                cleanup();
+                resolve();
+            };
+            const onError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            res.once?.("drain", onDrain);
+            res.once?.("close", onClose);
+            res.once?.("error", onError);
+        });
+    };
+    try {
+        while (!closed) {
+            const { done, value: chunk } = await iterator.next();
+            if (done || closed)
+                break;
+            if (mode === "ndjson") {
+                const canContinue = res.write?.(`${JSON.stringify(chunk)}\n`);
+                if (canContinue === false && !closed)
+                    await waitForDrain();
+                continue;
+            }
+            if (mode === "sse") {
+                const canContinue = res.write?.(formatSseEvent(chunk));
+                if (canContinue === false && !closed)
+                    await waitForDrain();
+                continue;
+            }
+            const canContinue = res.write?.(chunk);
+            if (canContinue === false && !closed)
+                await waitForDrain();
+        }
+        finished = true;
+        if (!closed)
+            res.end();
+    }
+    catch (error) {
+        res.destroy?.(error instanceof Error ? error : undefined);
+    }
+    finally {
+        finished = true;
+        signal.removeEventListener("abort", onClose);
+        res.off?.("close", onClose);
+    }
+};
+const createExpressReply = (res) => ({
+    setHeader: (name, value) => res.setHeader(name, value),
+    sendEmpty: (status) => {
+        res.status(status);
+        return undefined;
+    },
+    sendJson: (status, body) => {
+        res.status(status);
+        return body;
+    },
+    sendCustom: (status, body) => {
+        res.status(status);
+        res.send(body);
+        return undefined;
+    },
+    sendStream: (input) => writeExpressStreamResponse(res, input),
+});
+export const createExpressHttpPlatform = (req, res) => {
+    if (!isExpressLikeResponse(res))
+        return undefined;
+    return {
+        signal: createExpressRequestSignal(req, res),
+        reply: createExpressReply(res),
+    };
+};

package/dist/fastifyPlatform.d.ts

@@ -0,0 +1,2 @@
+import type { NestHttpPlatform } from "./httpPlatform.ts";
+export declare const createFastifyHttpPlatform: (req: unknown, res: unknown) => NestHttpPlatform | undefined;

package/dist/fastifyPlatform.js

@@ -0,0 +1,73 @@
+import { Readable } from "node:stream";
+import { formatSseEvent } from "@rest-rpc/server";
+import { hasFunction } from "./httpPlatform.js";
+const isFastifyLikeResponse = (value) => hasFunction(value, "send") &&
+    (hasFunction(value, "header") || hasFunction(value, "code"));
+const setStatus = (res, statusCode) => {
+    if (res.code) {
+        res.code(statusCode);
+        return;
+    }
+    res.status?.(statusCode);
+};
+const setHeader = (res, name, value) => {
+    if (res.header) {
+        res.header(name, value);
+        return;
+    }
+    res.raw?.setHeader?.(name, value);
+};
+const createFastifyRequestSignal = (req, res) => {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    req.raw?.once?.("aborted", abort);
+    res.raw?.once?.("close", () => {
+        if (!res.raw?.writableFinished)
+            abort();
+    });
+    return controller.signal;
+};
+const toNodeStream = ({ body, mode }) => Readable.from((async function* () {
+    for await (const chunk of body) {
+        if (mode === "ndjson") {
+            yield `${JSON.stringify(chunk)}\n`;
+            continue;
+        }
+        if (mode === "sse") {
+            yield formatSseEvent(chunk);
+            continue;
+        }
+        yield chunk;
+    }
+})());
+const createFastifyReply = (res) => ({
+    setHeader: (name, value) => setHeader(res, name, value),
+    sendEmpty: (status) => {
+        setStatus(res, status);
+        res.send();
+        return undefined;
+    },
+    sendJson: (status, body) => {
+        setStatus(res, status);
+        res.send(body);
+        return undefined;
+    },
+    sendCustom: (status, body) => {
+        setStatus(res, status);
+        res.send(body);
+        return undefined;
+    },
+    sendStream: (input) => {
+        setStatus(res, input.status);
+        setHeader(res, "content-type", input.contentType);
+        return toNodeStream(input);
+    },
+});
+export const createFastifyHttpPlatform = (req, res) => {
+    if (!isFastifyLikeResponse(res))
+        return undefined;
+    return {
+        signal: createFastifyRequestSignal(req, res),
+        reply: createFastifyReply(res),
+    };
+};

package/dist/httpPlatform.d.ts

@@ -0,0 +1,27 @@
+import type { HttpRouteResultStreamMode } from "@rest-rpc/server";
+export type NestHttpRequest = {
+    body?: unknown;
+    query?: unknown;
+    params?: unknown;
+    headers?: unknown;
+};
+export type NestStreamResponseInput = {
+    body: AsyncIterable<unknown>;
+    status: number;
+    contentType: string;
+    mode: HttpRouteResultStreamMode;
+    signal: AbortSignal;
+};
+export type NestHttpReply = {
+    setHeader(name: string, value: unknown): void;
+    sendEmpty(status: number): unknown;
+    sendJson(status: number, body: unknown): unknown;
+    sendCustom(status: number, body: unknown): unknown;
+    sendStream(input: NestStreamResponseInput): unknown;
+};
+export type NestHttpPlatform = {
+    signal: AbortSignal;
+    reply: NestHttpReply;
+};
+export declare const hasFunction: <TName extends string>(value: unknown, name: TName) => value is Record<TName, (...args: never[]) => unknown>;
+export declare const createNestHttpPlatform: (req: unknown, res: unknown) => NestHttpPlatform;

package/dist/httpPlatform.js

@@ -0,0 +1,12 @@
+import { createExpressHttpPlatform } from "./expressPlatform.js";
+import { createFastifyHttpPlatform } from "./fastifyPlatform.js";
+export const hasFunction = (value, name) => typeof value === "object" &&
+    value !== null &&
+    typeof value[name] === "function";
+export const createNestHttpPlatform = (req, res) => {
+    const platform = createExpressHttpPlatform(req, res) ?? createFastifyHttpPlatform(req, res);
+    if (!platform) {
+        throw new Error("Unsupported Nest HTTP platform. @rest-rpc/nest supports the Nest Express and Fastify adapters.");
+    }
+    return platform;
+};

package/dist/index.d.ts

@@ -0,0 +1,93 @@
+import type { HttpRouteDeclaration } from "@rest-rpc/core/contract";
+import { type Contract, type ImplementationTreeFor, type RouteImplementation, type RouteHandler as ServerRouteHandler, type RouteRequest as ServerRouteRequest } from "@rest-rpc/server";
+import type { DefaultNestContext, NestHandlerContext } from "./module.ts";
+export type { ClearCookieOptions, RouteErrors, RouteResponse, RouteResponseShorthand, SetCookieOptions, SseEvent, } from "@rest-rpc/server";
+export { clearCookie, RouteResponseError, setCookie, sseEvent, } from "@rest-rpc/server";
+export { Route, Router } from "./decorators.ts";
+export type { DefaultNestContext, NestHandlerContext, RestRpcModuleOptions, } from "./module.ts";
+export { RestRpcModule } from "./module.ts";
+/**
+ * A contract tree containing only HTTP routes for the Nest adapter.
+ *
+ * @remarks The Nest adapter currently registers HTTP routes through Nest
+ * controllers. Use this helper to constrain router contracts passed to
+ * `router()` and `RouteHandlers`.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/nest}
+ */
+export type NestContract = Contract<HttpRouteDeclaration>;
+type AdditionalNestContext<TContext extends Record<string, unknown>> = DefaultNestContext & TContext;
+/**
+ * Infers the Nest route handler request type for a given route declaration.
+ *
+ * @remarks The inferred request includes the route input fields and a
+ * Nest-specific `context` property. Pass the second generic argument for
+ * controller-local context values added by `router(..., { context })`.
+ *
+ * @see {@link https://rest-rpc.dev/docs/type-helpers#server}
+ * @see {@link https://rest-rpc.dev/docs/server/nest#controller-local-context}
+ */
+export type RouteRequest<E extends HttpRouteDeclaration, TAdditionalContext extends Record<string, unknown> = Record<never, never>> = ServerRouteRequest<E, NestHandlerContext<AdditionalNestContext<TAdditionalContext>>>;
+/**
+ * Infers the Nest route handler type for a given route declaration.
+ *
+ * @remarks Use this type when annotating reusable handler functions for a
+ * single route. The handler receives the same context shape used by
+ * `RouteRequest`.
+ *
+ * @see {@link https://rest-rpc.dev/docs/type-helpers#server}
+ * @see {@link https://rest-rpc.dev/docs/server/nest#framework-context}
+ */
+export type RouteHandler<E extends HttpRouteDeclaration, TAdditionalContext extends Record<string, unknown> = Record<never, never>> = ServerRouteHandler<E, NestHandlerContext<AdditionalNestContext<TAdditionalContext>>>;
+type BivariantRouteHandler<E extends HttpRouteDeclaration> = {
+    handler(...args: Parameters<RouteHandler<E>>): ReturnType<RouteHandler<E>>;
+}["handler"];
+/**
+ * Handler tree accepted by `router()` when building a Nest implementation tree.
+ *
+ * @remarks Use this type with `implements` to check injectable Nest provider
+ * classes against a contract tree.
+ *
+ * @example
+ * ```ts
+ * @Injectable()
+ * class TodoHandlers implements RouteHandlers<typeof api.todos> {
+ *   get(request: RouteRequest<typeof api.todos.get>) {
+ *     return { id: request.id };
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/nest#usage}
+ */
+export type RouteHandlers<TContract extends NestContract> = TContract extends HttpRouteDeclaration ? BivariantRouteHandler<TContract> | RouteImplementation<TContract> : {
+    [K in keyof TContract]: TContract[K] extends NestContract ? RouteHandlers<TContract[K]> : never;
+};
+/**
+ * Builds a Nest route implementation for a single contract route.
+ *
+ * @remarks Return this from a controller method decorated with `@Route()`. The
+ * optional `context` value is merged into the runtime handler context for that
+ * route.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/nest#single-routes}
+ * @see {@link https://rest-rpc.dev/docs/server/nest#controller-local-context}
+ */
+export declare function route<const TRoute extends HttpRouteDeclaration, TContext extends Record<string, unknown> = Record<never, never>>(contract: TRoute, handler: RouteHandler<TRoute, TContext>, options?: {
+    context?: Record<string, unknown>;
+}): RouteImplementation<TRoute> & {
+    context?: Record<string, unknown>;
+};
+/**
+ * Builds a Nest router implementation for a contract.
+ *
+ * @remarks Return this from a controller method decorated with `@Router()`. The
+ * optional `context` value is merged into the runtime handler context for every
+ * route in the returned implementation tree.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/nest#usage}
+ * @see {@link https://rest-rpc.dev/docs/server/nest#controller-local-context}
+ */
+export declare function router<const TContract extends NestContract>(contract: TContract, handlers: RouteHandlers<TContract>, options?: {
+    context?: Record<string, unknown>;
+}): ImplementationTreeFor<TContract, HttpRouteDeclaration>;

package/dist/index.js

@@ -0,0 +1,48 @@
+import { route as serverRoute, router as serverRouter, } from "@rest-rpc/server";
+export { clearCookie, RouteResponseError, setCookie, sseEvent, } from "@rest-rpc/server";
+export { Route, Router } from "./decorators.js";
+export { RestRpcModule } from "./module.js";
+const isNestRouteImplementation = (value) => typeof value === "object" &&
+    value !== null &&
+    "route" in value &&
+    "handler" in value;
+const attachNestRouteContext = (implementation, context) => {
+    if (context === undefined)
+        return implementation;
+    if (isNestRouteImplementation(implementation)) {
+        return {
+            ...implementation,
+            context,
+        };
+    }
+    return Object.fromEntries(Object.entries(implementation).map(([key, child]) => [
+        key,
+        attachNestRouteContext(child, context),
+    ]));
+};
+/**
+ * Builds a Nest route implementation for a single contract route.
+ *
+ * @remarks Return this from a controller method decorated with `@Route()`. The
+ * optional `context` value is merged into the runtime handler context for that
+ * route.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/nest#single-routes}
+ * @see {@link https://rest-rpc.dev/docs/server/nest#controller-local-context}
+ */
+export function route(contract, handler, options = {}) {
+    return attachNestRouteContext(serverRoute(contract, handler), options.context);
+}
+/**
+ * Builds a Nest router implementation for a contract.
+ *
+ * @remarks Return this from a controller method decorated with `@Router()`. The
+ * optional `context` value is merged into the runtime handler context for every
+ * route in the returned implementation tree.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/nest#usage}
+ * @see {@link https://rest-rpc.dev/docs/server/nest#controller-local-context}
+ */
+export function router(contract, handlers, options = {}) {
+    return attachNestRouteContext(serverRouter(contract, handlers), options.context);
+}

package/dist/module.d.ts

@@ -0,0 +1,60 @@
+import type { DynamicModule, ExecutionContext } from "@nestjs/common";
+import type { ServerErrorHandlers } from "@rest-rpc/server";
+/**
+ * Default application context passed to Nest route handlers.
+ *
+ * @remarks Augment this interface to set the route handler context across a
+ * project. The augmented shape is used by `RouteRequest`, `RouteHandler`,
+ * `RouteHandlers`, `route()`, and `router()`.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/nest#global-context}
+ */
+export interface DefaultNestContext {
+}
+interface ContextShape {
+    [key: string]: any;
+}
+type Merge<T> = {
+    [K in keyof T]: T[K];
+};
+/**
+ * The context object passed to Nest adapter route handlers.
+ *
+ * @remarks This combines the application context returned by `createContext`
+ * with the adapter-supplied `AbortSignal`.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/nest#framework-context}
+ */
+export type NestHandlerContext<TContext extends ContextShape = DefaultNestContext> = Merge<TContext & {
+    signal: AbortSignal;
+}>;
+/**
+ * Options for configuring the rest-rpc Nest adapter.
+ *
+ * @remarks Use `createContext` for request-scoped values shared by all
+ * rest-rpc Nest handlers, and `errorHandlers` to customize validation and
+ * unhandled error responses.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/nest#options}
+ */
+export type RestRpcModuleOptions<TContext extends ContextShape = DefaultNestContext> = {
+    createContext?: (context: ExecutionContext) => TContext | Promise<TContext>;
+    errorHandlers?: ServerErrorHandlers<NestHandlerContext<TContext>>;
+};
+/**
+ * Configures rest-rpc route handling for Nest controllers.
+ *
+ * @remarks Import `RestRpcModule.forRoot()` once in a Nest module to register
+ * the global interceptor used by `@Route()` and `@Router()`.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/nest#usage}
+ */
+export declare class RestRpcModule {
+    /**
+     * Registers the global interceptor used by rest-rpc Nest route decorators.
+     *
+     * @see {@link https://rest-rpc.dev/docs/server/nest#options}
+     */
+    static forRoot<TContext extends ContextShape = DefaultNestContext>(options?: RestRpcModuleOptions<TContext>): DynamicModule;
+}
+export {};

package/dist/module.js

@@ -0,0 +1,51 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var RestRpcModule_1;
+import { Module } from "@nestjs/common";
+import { APP_INTERCEPTOR } from "@nestjs/core";
+import { RestRpcRouteInterceptor } from "./routeInterceptor.js";
+/**
+ * Configures rest-rpc route handling for Nest controllers.
+ *
+ * @remarks Import `RestRpcModule.forRoot()` once in a Nest module to register
+ * the global interceptor used by `@Route()` and `@Router()`.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/nest#usage}
+ */
+let RestRpcModule = RestRpcModule_1 = class RestRpcModule {
+    /**
+     * Registers the global interceptor used by rest-rpc Nest route decorators.
+     *
+     * @see {@link https://rest-rpc.dev/docs/server/nest#options}
+     */
+    static forRoot(options = {}) {
+        const restRpcModuleOptions = Symbol.for("rest-rpc:nest-options");
+        return {
+            module: RestRpcModule_1,
+            providers: [
+                {
+                    provide: restRpcModuleOptions,
+                    useValue: options,
+                },
+                {
+                    provide: RestRpcRouteInterceptor,
+                    inject: [restRpcModuleOptions],
+                    useFactory: (moduleOptions) => new RestRpcRouteInterceptor(moduleOptions),
+                },
+                {
+                    provide: APP_INTERCEPTOR,
+                    useExisting: RestRpcRouteInterceptor,
+                },
+            ],
+            exports: [RestRpcRouteInterceptor],
+        };
+    }
+};
+RestRpcModule = RestRpcModule_1 = __decorate([
+    Module({})
+], RestRpcModule);
+export { RestRpcModule };

package/dist/routeInterceptor.d.ts

@@ -0,0 +1,9 @@
+import { type CallHandler, type ExecutionContext, type NestInterceptor } from "@nestjs/common";
+import type { Observable } from "rxjs";
+import type { RestRpcModuleOptions } from "./module.ts";
+export declare class RestRpcRouteInterceptor implements NestInterceptor {
+    constructor(options?: RestRpcModuleOptions<Record<string, unknown>>);
+    private readonly options?;
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+    private handle;
+}

package/dist/routeInterceptor.js

@@ -0,0 +1,71 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Injectable, } from "@nestjs/common";
+import { handleHttpRoute, handleHttpRouteResult, isHttpRouteImplementation, } from "@rest-rpc/server";
+import { from, lastValueFrom } from "rxjs";
+import { REST_RPC_ROUTE_METADATA } from "./decorators.js";
+import { createNestHttpPlatform, } from "./httpPlatform.js";
+const assertRouteImplementation = (value, route) => {
+    if (!isHttpRouteImplementation(value)) {
+        throw new Error(`Controller method for "${route.method} ${route.path}" must return a rest-rpc route implementation.`);
+    }
+    const implementation = value;
+    if (implementation.route.method !== route.method ||
+        implementation.route.path !== route.path) {
+        throw new Error(`Controller method for "${route.method} ${route.path}" returned an implementation for "${implementation.route.method} ${implementation.route.path}".`);
+    }
+    return implementation;
+};
+let RestRpcRouteInterceptor = class RestRpcRouteInterceptor {
+    constructor(options) {
+        this.options = options;
+    }
+    options;
+    intercept(context, next) {
+        const metadata = Reflect.getMetadata(REST_RPC_ROUTE_METADATA, context.getHandler());
+        if (!metadata)
+            return next.handle();
+        return from(this.handle(context, next, metadata));
+    }
+    async handle(context, next, metadata) {
+        const http = context.switchToHttp();
+        const req = http.getRequest();
+        const res = http.getResponse();
+        const { signal, reply } = createNestHttpPlatform(req, res);
+        const userContext = await this.options?.createContext?.(context);
+        const implementation = assertRouteImplementation(await lastValueFrom(next.handle()), metadata.route);
+        const routeContext = {
+            ...userContext,
+            ...implementation.context,
+            signal,
+        };
+        const result = await handleHttpRoute(metadata.route, implementation.handler, {
+            request: {
+                body: req.body,
+                query: req.query,
+                pathParams: req.params,
+                headers: req.headers,
+            },
+            context: routeContext,
+            errorHandlers: this.options?.errorHandlers,
+        });
+        return handleHttpRouteResult(result, {
+            setHeader: (name, value) => {
+                if (value !== undefined)
+                    reply.setHeader(name, value);
+            },
+            sendEmpty: (status) => reply.sendEmpty(status),
+            sendJson: (status, body) => reply.sendJson(status, body),
+            sendCustom: (status, body) => reply.sendCustom(status, body),
+            sendStream: ({ body, status, contentType, mode }) => reply.sendStream({ body, status, contentType, mode, signal }),
+        });
+    }
+};
+RestRpcRouteInterceptor = __decorate([
+    Injectable()
+], RestRpcRouteInterceptor);
+export { RestRpcRouteInterceptor };

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@rest-rpc/nest",
+  "version": "0.1.0-beta.14",
+  "description": "NestJS adapter for serving rest-rpc contracts with typed HTTP routes.",
+  "keywords": [
+    "api-contract",
+    "contract-first",
+    "http",
+    "nest",
+    "nestjs",
+    "rest",
+    "rest-rpc",
+    "rpc",
+    "server",
+    "type-safe-api",
+    "typescript"
+  ],
+  "homepage": "https://github.com/rest-rpc/rest-rpc#readme",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rest-rpc/rest-rpc.git",
+    "directory": "packages/nest"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@rest-rpc/core": "0.1.0-beta.14",
+    "@rest-rpc/server": "0.1.0-beta.14"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/core": "^11.0.0",
+    "@nestjs/platform-express": "^11.0.0",
+    "@nestjs/platform-fastify": "^11.2.3",
+    "@types/express": "^5.0.1",
+    "@types/node": "^26.3.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.0"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/core": "^11.0.0",
+    "@nestjs/platform-express": "^11.0.0",
+    "@nestjs/platform-fastify": "^11.0.0",
+    "reflect-metadata": "^0.2.0",
+    "rxjs": "^7.8.0"
+  },
+  "peerDependenciesMeta": {
+    "@nestjs/platform-express": {
+      "optional": true
+    },
+    "@nestjs/platform-fastify": {
+      "optional": true
+    }
+  },
+  "tsd": {
+    "directory": "test-d"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "pnpm run build && tsc -p tsconfig.json && tsd"
+  }
+}