@orpc/server 2.0.0-beta.22 → 2.0.0-beta.24

package/README.md

@@ -44,6 +44,7 @@ You can read the documentation [here](https://orpc.dev).
 
 - [@orpc/publisher](https://www.npmjs.com/package/@orpc/publisher): Pub/Sub with memory, Redis, and Upstash adapters.
 - [@orpc/ratelimit](https://www.npmjs.com/package/@orpc/ratelimit): Rate limiting with memory, Redis, and Upstash adapters.
+- [@orpc/hibernation](https://www.npmjs.com/package/@orpc/hibernation): Leverage Hibernation APIs like [Cloudflare's Hibernation WebSocket](https://developers.cloudflare.com/durable-objects/best-practices/websockets/#durable-objects-hibernation-websocket-api).
 - [@orpc/json-schema](https://www.npmjs.com/package/@orpc/json-schema): Smart coercion for OpenAPI requests.
 
 **Framework & ecosystem integrations**
@@ -114,6 +115,7 @@ Like what we build over at [middleapi](https://github.com/middleapi)? You can he
   </tr>
   <tr>
    <td align="center"><a href="https://github.com/itigoore01?ref=orpc" target="_blank" rel="noopener" title="shota"><img src="https://avatars.githubusercontent.com/u/11831107?u=c976a6dc7e055eb026304c46c99100ed22b0c8e0&amp;v=4" width="139" alt="shota"/><br />shota</a></td>
+   <td align="center"><a href="https://github.com/ellis-driscoll?ref=orpc" target="_blank" rel="noopener" title="Ellis Driscoll"><img src="https://avatars.githubusercontent.com/u/70685966?u=c5f95bc33b5991d9744abe00052542e4a2ed3cb9&amp;v=4" width="139" alt="Ellis Driscoll"/><br />Ellis Driscoll</a></td>
   </tr>
 </table>
 
@@ -139,8 +141,9 @@ Like what we build over at [middleapi](https://github.com/middleapi)? You can he
    <td align="center"><a href="https://github.com/mr-kelly?ref=orpc" target="_blank" rel="noopener" title="Kelly Peilin Chan"><img src="https://avatars.githubusercontent.com/u/520852?u=6b0f7105f694e7b5cacf410a3f04c7044b469dc8&amp;v=4" width="119" alt="Kelly Peilin Chan"/><br />Kelly Peilin Chan</a></td>
   </tr>
   <tr>
+   <td align="center"><a href="https://github.com/guyariely?ref=orpc" target="_blank" rel="noopener" title="Guy Ariely"><img src="https://avatars.githubusercontent.com/u/42813496?u=edb6b7f563bf28e160a290832e7da57c0506f8ca&amp;v=4" width="119" alt="Guy Ariely"/><br />Guy Ariely</a></td>
    <td align="center"><a href="https://github.com/piscis?ref=orpc" target="_blank" rel="noopener" title="Alex"><img src="https://avatars.githubusercontent.com/u/326163?u=b245f368bd940cf51d08c0b6bf55f8257f359437&amp;v=4" width="119" alt="Alex"/><br />Alex</a></td>
-   <td align="center"><a href="https://github.com/finom?ref=orpc" target="_blank" rel="noopener" title="Andrey Gubanov"><img src="https://avatars.githubusercontent.com/u/1082083?u=29e91400dbd4a9c217048a8f59562c4f740498e6&amp;v=4" width="119" alt="Andrey Gubanov"/><br />Andrey Gubanov</a></td>
+   <td align="center"><a href="https://github.com/finom?ref=orpc" target="_blank" rel="noopener" title="Andrey Gubanov"><img src="https://avatars.githubusercontent.com/u/1082083?u=c5f2daf7ebece498e85c83367bb37b4e10e2649d&amp;v=4" width="119" alt="Andrey Gubanov"/><br />Andrey Gubanov</a></td>
   </tr>
 </table>
 

package/dist/adapters/aws-lambda/index.d.mts

@@ -0,0 +1,104 @@
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions, AnyAPIGatewayProxyEvent, HttpResponseStream } from '@standardserver/aws-lambda';
+import { C as Context } from '../../shared/server.CwrYlF72.mjs';
+import { S as StandardHandlerPlugin, b as StandardHandler, c as StandardHandlerHandleOptions, a as StandardHandlerOptions } from '../../shared/server.JbCIPL4P.mjs';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
+import { R as Router } from '../../shared/server.Dm0os-OP.mjs';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.zySQaS-n.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@standardserver/core';
+
+interface AwsLambdaHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
+    /**
+     * Initializes the plugin and returns new AWS Lambda handler options.
+     * Called once per plugin instance during composition.
+     *
+     * This method allows plugins to wrap, extend, or transform AWS Lambda handler options
+     * such as interceptors, or other configuration.
+     *
+     * @param options - The current handler options from previous plugins or base configuration
+     * @returns Transformed handler options with plugin's modifications applied
+     *
+     * @example
+     * ```ts
+     * initAwsLambdaHandlerOptions(options) {
+     *   return {
+     *     ...options,
+     *     awsLambdaInterceptors: [...(options.awsLambdaInterceptors || []), myInterceptor]
+     *   }
+     * }
+     * ```
+     */
+    initAwsLambdaHandlerOptions?(options: AwsLambdaHandlerOptions<T>): AwsLambdaHandlerOptions<T>;
+}
+declare class CompositeAwsLambdaHandlerPlugin<T extends Context> implements AwsLambdaHandlerPlugin<T> {
+    readonly name = "~composite/aws-lambda";
+    protected readonly plugins: AwsLambdaHandlerPlugin<T>[];
+    constructor(plugins?: AwsLambdaHandlerPlugin<T>[]);
+    initAwsLambdaHandlerOptions(options: AwsLambdaHandlerOptions<T>): AwsLambdaHandlerOptions<T>;
+}
+
+type AwsLambdaHandlerHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface AwsLambdaHandlerAwsLambdaInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
+    event: AnyAPIGatewayProxyEvent;
+    responseStream: HttpResponseStream;
+    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
+}
+type AwsLambdaHandlerAwsLambdaInterceptor<T extends Context> = Interceptor<AwsLambdaHandlerAwsLambdaInterceptorOptions<T>, Promise<AwsLambdaHandlerHandleResult>>;
+interface AwsLambdaHandlerOptions<T extends Context> {
+    /**
+     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
+     */
+    sendStandardResponse?: SendStandardResponseOptions | undefined;
+    /**
+     * Interceptors that run before the mapping between the Standard API and AWS Lambda API,
+     * useful for extending the AWS Lambda event/response stream before handling, ...
+     */
+    awsLambdaInterceptors?: AwsLambdaHandlerAwsLambdaInterceptor<T>[] | undefined;
+    plugins?: AwsLambdaHandlerPlugin<T>[] | undefined;
+}
+/**
+ * Requires the AWS Lambda Node.js runtime with response streaming enabled,
+ * handlers should be wrapped with `awslambda.streamifyResponse`.
+ */
+declare class AwsLambdaHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    private readonly awsLambdaInterceptors;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<AwsLambdaHandlerOptions<T>>);
+    handle(event: AnyAPIGatewayProxyEvent, responseStream: HttpResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<AwsLambdaHandlerHandleResult>;
+}
+
+interface RPCHandlerOptions<T extends Context> extends AwsLambdaHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+    /**
+     * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
+     */
+    csrfGuardPlugin?: {
+        /**
+         * If `false`, this plugin is disabled.
+         *
+         * @default true
+         */
+        enabled?: boolean;
+    };
+}
+/**
+ * Serves an oRPC router over the RPC protocol on AWS Lambda,
+ * behind API Gateway or Lambda Function URLs.
+ *
+ * @remarks
+ * **Warning**: Requires the Lambda Node.js runtime with response streaming enabled, so handlers must be wrapped with `awslambda.streamifyResponse`.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/aws-lambda | AWS Lambda Adapter}
+ */
+declare class RPCHandler<T extends Context> extends AwsLambdaHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}
+
+export { AwsLambdaHandler, CompositeAwsLambdaHandlerPlugin, RPCHandler };
+export type { AwsLambdaHandlerAwsLambdaInterceptor, AwsLambdaHandlerAwsLambdaInterceptorOptions, AwsLambdaHandlerHandleResult, AwsLambdaHandlerOptions, AwsLambdaHandlerPlugin, RPCHandlerOptions };

package/dist/adapters/aws-lambda/index.d.ts

@@ -0,0 +1,104 @@
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions, AnyAPIGatewayProxyEvent, HttpResponseStream } from '@standardserver/aws-lambda';
+import { C as Context } from '../../shared/server.CwrYlF72.js';
+import { S as StandardHandlerPlugin, b as StandardHandler, c as StandardHandlerHandleOptions, a as StandardHandlerOptions } from '../../shared/server.DrN1Pj1-.js';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
+import { R as Router } from '../../shared/server.DtfwuV6U.js';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.BUvC0G_8.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@standardserver/core';
+
+interface AwsLambdaHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
+    /**
+     * Initializes the plugin and returns new AWS Lambda handler options.
+     * Called once per plugin instance during composition.
+     *
+     * This method allows plugins to wrap, extend, or transform AWS Lambda handler options
+     * such as interceptors, or other configuration.
+     *
+     * @param options - The current handler options from previous plugins or base configuration
+     * @returns Transformed handler options with plugin's modifications applied
+     *
+     * @example
+     * ```ts
+     * initAwsLambdaHandlerOptions(options) {
+     *   return {
+     *     ...options,
+     *     awsLambdaInterceptors: [...(options.awsLambdaInterceptors || []), myInterceptor]
+     *   }
+     * }
+     * ```
+     */
+    initAwsLambdaHandlerOptions?(options: AwsLambdaHandlerOptions<T>): AwsLambdaHandlerOptions<T>;
+}
+declare class CompositeAwsLambdaHandlerPlugin<T extends Context> implements AwsLambdaHandlerPlugin<T> {
+    readonly name = "~composite/aws-lambda";
+    protected readonly plugins: AwsLambdaHandlerPlugin<T>[];
+    constructor(plugins?: AwsLambdaHandlerPlugin<T>[]);
+    initAwsLambdaHandlerOptions(options: AwsLambdaHandlerOptions<T>): AwsLambdaHandlerOptions<T>;
+}
+
+type AwsLambdaHandlerHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface AwsLambdaHandlerAwsLambdaInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
+    event: AnyAPIGatewayProxyEvent;
+    responseStream: HttpResponseStream;
+    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
+}
+type AwsLambdaHandlerAwsLambdaInterceptor<T extends Context> = Interceptor<AwsLambdaHandlerAwsLambdaInterceptorOptions<T>, Promise<AwsLambdaHandlerHandleResult>>;
+interface AwsLambdaHandlerOptions<T extends Context> {
+    /**
+     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
+     */
+    sendStandardResponse?: SendStandardResponseOptions | undefined;
+    /**
+     * Interceptors that run before the mapping between the Standard API and AWS Lambda API,
+     * useful for extending the AWS Lambda event/response stream before handling, ...
+     */
+    awsLambdaInterceptors?: AwsLambdaHandlerAwsLambdaInterceptor<T>[] | undefined;
+    plugins?: AwsLambdaHandlerPlugin<T>[] | undefined;
+}
+/**
+ * Requires the AWS Lambda Node.js runtime with response streaming enabled,
+ * handlers should be wrapped with `awslambda.streamifyResponse`.
+ */
+declare class AwsLambdaHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    private readonly awsLambdaInterceptors;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<AwsLambdaHandlerOptions<T>>);
+    handle(event: AnyAPIGatewayProxyEvent, responseStream: HttpResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<AwsLambdaHandlerHandleResult>;
+}
+
+interface RPCHandlerOptions<T extends Context> extends AwsLambdaHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+    /**
+     * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
+     */
+    csrfGuardPlugin?: {
+        /**
+         * If `false`, this plugin is disabled.
+         *
+         * @default true
+         */
+        enabled?: boolean;
+    };
+}
+/**
+ * Serves an oRPC router over the RPC protocol on AWS Lambda,
+ * behind API Gateway or Lambda Function URLs.
+ *
+ * @remarks
+ * **Warning**: Requires the Lambda Node.js runtime with response streaming enabled, so handlers must be wrapped with `awslambda.streamifyResponse`.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/aws-lambda | AWS Lambda Adapter}
+ */
+declare class RPCHandler<T extends Context> extends AwsLambdaHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}
+
+export { AwsLambdaHandler, CompositeAwsLambdaHandlerPlugin, RPCHandler };
+export type { AwsLambdaHandlerAwsLambdaInterceptor, AwsLambdaHandlerAwsLambdaInterceptorOptions, AwsLambdaHandlerHandleResult, AwsLambdaHandlerOptions, AwsLambdaHandlerPlugin, RPCHandlerOptions };

package/dist/adapters/aws-lambda/index.mjs

@@ -0,0 +1,73 @@
+import { sortPlugins, intercept, resolveMaybeOptionalOptions, toArray } from '@orpc/shared';
+import { toStandardLazyRequest, sendStandardResponse } from '@standardserver/aws-lambda';
+import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
+import { C as CSRFGuardHandlerPlugin } from '../../shared/server.D_QauotT.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.DEGjTAPW.mjs';
+import '@orpc/client';
+import '@standardserver/core';
+import '../../shared/server.7T18Khvf.mjs';
+import '@orpc/contract';
+import '../../shared/server.DgunZU0v.mjs';
+
+class CompositeAwsLambdaHandlerPlugin {
+  name = "~composite/aws-lambda";
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = sortPlugins(plugins);
+  }
+  initAwsLambdaHandlerOptions(options) {
+    for (const plugin of this.plugins) {
+      if (plugin.initAwsLambdaHandlerOptions) {
+        options = plugin.initAwsLambdaHandlerOptions(options);
+      }
+    }
+    return options;
+  }
+}
+
+class AwsLambdaHandler {
+  constructor(standardHandler, options = {}) {
+    this.standardHandler = standardHandler;
+    options = new CompositeAwsLambdaHandlerPlugin(options.plugins).initAwsLambdaHandlerOptions(options);
+    this.awsLambdaInterceptors = options.awsLambdaInterceptors;
+    this.sendStandardResponseOptions = options.sendStandardResponse;
+  }
+  sendStandardResponseOptions;
+  awsLambdaInterceptors;
+  async handle(event, responseStream, ...rest) {
+    return intercept(
+      this.awsLambdaInterceptors,
+      {
+        ...resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)),
+        event,
+        responseStream,
+        sendStandardResponseOptions: this.sendStandardResponseOptions
+      },
+      async ({ event: event2, responseStream: responseStream2, sendStandardResponseOptions, ...options }) => {
+        const standardRequest = toStandardLazyRequest(event2, responseStream2);
+        const result = await this.standardHandler.handle(standardRequest, options);
+        if (!result.matched) {
+          return result;
+        }
+        await sendStandardResponse(responseStream2, result.response, sendStandardResponseOptions);
+        return result;
+      }
+    );
+  }
+}
+
+class RPCHandler extends AwsLambdaHandler {
+  constructor(router, options = {}) {
+    if (options.csrfGuardPlugin?.enabled !== false) {
+      options = {
+        ...options,
+        plugins: [...toArray(options.plugins), new CSRFGuardHandlerPlugin()]
+      };
+    }
+    const codec = new RPCHandlerCodec(router, options);
+    const handler = new StandardHandler(codec, options);
+    super(handler, options);
+  }
+}
+
+export { AwsLambdaHandler, CompositeAwsLambdaHandlerPlugin, RPCHandler };

package/dist/adapters/crossws/index.d.mts

@@ -1,11 +1,11 @@
 import { MaybeOptionalOptions } from '@orpc/shared';
 import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
 import { Message, Peer } from 'crossws';
-import { C as Context } from '../../shared/server.CcR4kgje.mjs';
-import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DDFizwfU.mjs';
+import { C as Context } from '../../shared/server.CwrYlF72.mjs';
+import { b as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.JbCIPL4P.mjs';
 import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.mjs';
-import { R as Router } from '../../shared/server.15O7oC1p.mjs';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.omY4cUs0.mjs';
+import { R as Router } from '../../shared/server.Dm0os-OP.mjs';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.zySQaS-n.mjs';
 import '@orpc/client';
 import '@orpc/contract';
 import '@standardserver/core';
@@ -49,6 +49,12 @@ declare class experimental_CrosswsHandler<T extends Context> {
 
 interface experimental_RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, experimental_CrosswsHandlerOptions<T> {
 }
+/**
+ * Serves an oRPC router over the RPC protocol on a WebSocket connection
+ * managed by [crossws](https://github.com/h3js/crossws).
+ *
+ * @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
+ */
 declare class experimental_RPCHandler<T extends Context> extends experimental_CrosswsHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<experimental_RPCHandlerOptions<T>>);
 }

package/dist/adapters/crossws/index.d.ts

@@ -1,11 +1,11 @@
 import { MaybeOptionalOptions } from '@orpc/shared';
 import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
 import { Message, Peer } from 'crossws';
-import { C as Context } from '../../shared/server.CcR4kgje.js';
-import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.BhsVw7m7.js';
+import { C as Context } from '../../shared/server.CwrYlF72.js';
+import { b as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DrN1Pj1-.js';
 import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.js';
-import { R as Router } from '../../shared/server.m3szVJGU.js';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.DG9aQpJK.js';
+import { R as Router } from '../../shared/server.DtfwuV6U.js';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.BUvC0G_8.js';
 import '@orpc/client';
 import '@orpc/contract';
 import '@standardserver/core';
@@ -49,6 +49,12 @@ declare class experimental_CrosswsHandler<T extends Context> {
 
 interface experimental_RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, experimental_CrosswsHandlerOptions<T> {
 }
+/**
+ * Serves an oRPC router over the RPC protocol on a WebSocket connection
+ * managed by [crossws](https://github.com/h3js/crossws).
+ *
+ * @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
+ */
 declare class experimental_RPCHandler<T extends Context> extends experimental_CrosswsHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<experimental_RPCHandlerOptions<T>>);
 }

package/dist/adapters/crossws/index.mjs

@@ -1,12 +1,12 @@
 import { resolveMaybeOptionalOptions } from '@orpc/shared';
 import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage } from '@standardserver/peer';
 import { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.A8J9H8OE.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.DEGjTAPW.mjs';
 import '@orpc/client';
 import '@standardserver/core';
-import '../../shared/server.DofEOwf-.mjs';
+import '../../shared/server.7T18Khvf.mjs';
 import '@orpc/contract';
-import '../../shared/server.D4cnq66J.mjs';
+import '../../shared/server.DgunZU0v.mjs';
 
 class experimental_CrosswsHandler {
   constructor(handler, options = {}) {

package/dist/adapters/fastify/index.d.mts

@@ -0,0 +1,96 @@
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions, AnyFastifyRequest, AnyFastifyReply } from '@standardserver/fastify';
+import { C as Context } from '../../shared/server.CwrYlF72.mjs';
+import { S as StandardHandlerPlugin, c as StandardHandlerHandleOptions, b as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.JbCIPL4P.mjs';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
+import { R as Router } from '../../shared/server.Dm0os-OP.mjs';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.zySQaS-n.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@standardserver/core';
+
+interface FastifyHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
+    /**
+     * Initializes the plugin and returns new Fastify handler options.
+     * Called once per plugin instance during composition.
+     *
+     * This method allows plugins to wrap, extend, or transform Fastify handler options
+     * such as interceptors, or other configuration.
+     *
+     * @param options - The current handler options from previous plugins or base configuration
+     * @returns Transformed handler options with plugin's modifications applied
+     *
+     * @example
+     * ```ts
+     * initFastifyHandlerOptions(options) {
+     *   return {
+     *     ...options,
+     *     fastifyInterceptors: [...(options.fastifyInterceptors || []), myInterceptor]
+     *   }
+     * }
+     * ```
+     */
+    initFastifyHandlerOptions?(options: FastifyHandlerOptions<T>): FastifyHandlerOptions<T>;
+}
+declare class CompositeFastifyHandlerPlugin<T extends Context> implements FastifyHandlerPlugin<T> {
+    readonly name = "~composite/fastify";
+    protected readonly plugins: FastifyHandlerPlugin<T>[];
+    constructor(plugins?: FastifyHandlerPlugin<T>[]);
+    initFastifyHandlerOptions(options: FastifyHandlerOptions<T>): FastifyHandlerOptions<T>;
+}
+
+type FastifyHandlerHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface FastifyHandlerFastifyInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
+    request: AnyFastifyRequest;
+    reply: AnyFastifyReply;
+    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
+}
+type FastifyHandlerFastifyInterceptor<T extends Context> = Interceptor<FastifyHandlerFastifyInterceptorOptions<T>, Promise<FastifyHandlerHandleResult>>;
+interface FastifyHandlerOptions<T extends Context> {
+    /**
+     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
+     */
+    sendStandardResponse?: SendStandardResponseOptions | undefined;
+    /**
+     * Interceptors that run before the mapping between the Standard API and Fastify API,
+     * useful for extending the Fastify request/reply before handling, ...
+     */
+    fastifyInterceptors?: FastifyHandlerFastifyInterceptor<T>[] | undefined;
+    plugins?: FastifyHandlerPlugin<T>[] | undefined;
+}
+declare class FastifyHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    private readonly fastifyInterceptors;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FastifyHandlerOptions<T>>);
+    handle(request: AnyFastifyRequest, reply: AnyFastifyReply, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FastifyHandlerHandleResult>;
+}
+
+interface RPCHandlerOptions<T extends Context> extends FastifyHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+    /**
+     * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
+     */
+    csrfGuardPlugin?: {
+        /**
+         * If `false`, this plugin is disabled.
+         *
+         * @default true
+         */
+        enabled?: boolean;
+    };
+}
+/**
+ * Serves an oRPC router over the RPC protocol inside a Fastify server.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/fastify | Fastify Adapter}
+ */
+declare class RPCHandler<T extends Context> extends FastifyHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}
+
+export { CompositeFastifyHandlerPlugin, FastifyHandler, RPCHandler };
+export type { FastifyHandlerFastifyInterceptor, FastifyHandlerFastifyInterceptorOptions, FastifyHandlerHandleResult, FastifyHandlerOptions, FastifyHandlerPlugin, RPCHandlerOptions };

package/dist/adapters/fastify/index.d.ts

@@ -0,0 +1,96 @@
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions, AnyFastifyRequest, AnyFastifyReply } from '@standardserver/fastify';
+import { C as Context } from '../../shared/server.CwrYlF72.js';
+import { S as StandardHandlerPlugin, c as StandardHandlerHandleOptions, b as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DrN1Pj1-.js';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
+import { R as Router } from '../../shared/server.DtfwuV6U.js';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.BUvC0G_8.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@standardserver/core';
+
+interface FastifyHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
+    /**
+     * Initializes the plugin and returns new Fastify handler options.
+     * Called once per plugin instance during composition.
+     *
+     * This method allows plugins to wrap, extend, or transform Fastify handler options
+     * such as interceptors, or other configuration.
+     *
+     * @param options - The current handler options from previous plugins or base configuration
+     * @returns Transformed handler options with plugin's modifications applied
+     *
+     * @example
+     * ```ts
+     * initFastifyHandlerOptions(options) {
+     *   return {
+     *     ...options,
+     *     fastifyInterceptors: [...(options.fastifyInterceptors || []), myInterceptor]
+     *   }
+     * }
+     * ```
+     */
+    initFastifyHandlerOptions?(options: FastifyHandlerOptions<T>): FastifyHandlerOptions<T>;
+}
+declare class CompositeFastifyHandlerPlugin<T extends Context> implements FastifyHandlerPlugin<T> {
+    readonly name = "~composite/fastify";
+    protected readonly plugins: FastifyHandlerPlugin<T>[];
+    constructor(plugins?: FastifyHandlerPlugin<T>[]);
+    initFastifyHandlerOptions(options: FastifyHandlerOptions<T>): FastifyHandlerOptions<T>;
+}
+
+type FastifyHandlerHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface FastifyHandlerFastifyInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
+    request: AnyFastifyRequest;
+    reply: AnyFastifyReply;
+    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
+}
+type FastifyHandlerFastifyInterceptor<T extends Context> = Interceptor<FastifyHandlerFastifyInterceptorOptions<T>, Promise<FastifyHandlerHandleResult>>;
+interface FastifyHandlerOptions<T extends Context> {
+    /**
+     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
+     */
+    sendStandardResponse?: SendStandardResponseOptions | undefined;
+    /**
+     * Interceptors that run before the mapping between the Standard API and Fastify API,
+     * useful for extending the Fastify request/reply before handling, ...
+     */
+    fastifyInterceptors?: FastifyHandlerFastifyInterceptor<T>[] | undefined;
+    plugins?: FastifyHandlerPlugin<T>[] | undefined;
+}
+declare class FastifyHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    private readonly fastifyInterceptors;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FastifyHandlerOptions<T>>);
+    handle(request: AnyFastifyRequest, reply: AnyFastifyReply, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FastifyHandlerHandleResult>;
+}
+
+interface RPCHandlerOptions<T extends Context> extends FastifyHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+    /**
+     * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
+     */
+    csrfGuardPlugin?: {
+        /**
+         * If `false`, this plugin is disabled.
+         *
+         * @default true
+         */
+        enabled?: boolean;
+    };
+}
+/**
+ * Serves an oRPC router over the RPC protocol inside a Fastify server.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/fastify | Fastify Adapter}
+ */
+declare class RPCHandler<T extends Context> extends FastifyHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}
+
+export { CompositeFastifyHandlerPlugin, FastifyHandler, RPCHandler };
+export type { FastifyHandlerFastifyInterceptor, FastifyHandlerFastifyInterceptorOptions, FastifyHandlerHandleResult, FastifyHandlerOptions, FastifyHandlerPlugin, RPCHandlerOptions };

package/dist/adapters/fastify/index.mjs

@@ -0,0 +1,73 @@
+import { sortPlugins, intercept, resolveMaybeOptionalOptions, toArray } from '@orpc/shared';
+import { toStandardLazyRequest, sendStandardResponse } from '@standardserver/fastify';
+import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
+import { C as CSRFGuardHandlerPlugin } from '../../shared/server.D_QauotT.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.DEGjTAPW.mjs';
+import '@orpc/client';
+import '@standardserver/core';
+import '../../shared/server.7T18Khvf.mjs';
+import '@orpc/contract';
+import '../../shared/server.DgunZU0v.mjs';
+
+class CompositeFastifyHandlerPlugin {
+  name = "~composite/fastify";
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = sortPlugins(plugins);
+  }
+  initFastifyHandlerOptions(options) {
+    for (const plugin of this.plugins) {
+      if (plugin.initFastifyHandlerOptions) {
+        options = plugin.initFastifyHandlerOptions(options);
+      }
+    }
+    return options;
+  }
+}
+
+class FastifyHandler {
+  constructor(standardHandler, options = {}) {
+    this.standardHandler = standardHandler;
+    options = new CompositeFastifyHandlerPlugin(options.plugins).initFastifyHandlerOptions(options);
+    this.fastifyInterceptors = options.fastifyInterceptors;
+    this.sendStandardResponseOptions = options.sendStandardResponse;
+  }
+  sendStandardResponseOptions;
+  fastifyInterceptors;
+  async handle(request, reply, ...rest) {
+    return intercept(
+      this.fastifyInterceptors,
+      {
+        ...resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)),
+        request,
+        reply,
+        sendStandardResponseOptions: this.sendStandardResponseOptions
+      },
+      async ({ request: request2, reply: reply2, sendStandardResponseOptions, ...options }) => {
+        const standardRequest = toStandardLazyRequest(request2, reply2);
+        const result = await this.standardHandler.handle(standardRequest, options);
+        if (!result.matched) {
+          return result;
+        }
+        await sendStandardResponse(reply2, result.response, sendStandardResponseOptions);
+        return result;
+      }
+    );
+  }
+}
+
+class RPCHandler extends FastifyHandler {
+  constructor(router, options = {}) {
+    if (options.csrfGuardPlugin?.enabled !== false) {
+      options = {
+        ...options,
+        plugins: [...toArray(options.plugins), new CSRFGuardHandlerPlugin()]
+      };
+    }
+    const codec = new RPCHandlerCodec(router, options);
+    const handler = new StandardHandler(codec, options);
+    super(handler, options);
+  }
+}
+
+export { CompositeFastifyHandlerPlugin, FastifyHandler, RPCHandler };