@orpc/server 0.0.0-next.c7f8b1d → 0.0.0-next.c81407e

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

@@ -1,13 +1,14 @@
-import { C as Context, R as Router } from '../../shared/server.BVHsfJ99.js';
-import { Interceptor, ThrowableError, MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, R as Router } from '../../shared/server.B4BGqy3Y.js';
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
 import { ToFetchResponseOptions } from '@orpc/standard-server-fetch';
-import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, g as StandardHandleOptions, i as StandardHandler } from '../../shared/server.CaWivVk3.js';
-import { F as FriendlyStandardHandleOptions } from '../../shared/server.DMhSfHk1.js';
-import { S as StandardRPCHandlerOptions } from '../../shared/server.D_vpYits.js';
+import { g as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, f as StandardHandler } from '../../shared/server.DPIFWpxG.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.DNtJ-p60.js';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.COL12UTb.js';
 import '@orpc/client';
 import '@orpc/contract';
 import '@orpc/standard-server';
 import '@orpc/client/standard';
+import '../../shared/server.Cb6yD7DZ.js';
 
 interface FetchHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
     initRuntimeAdapter?(options: FetchHandlerOptions<T>): void;
@@ -28,7 +29,7 @@ interface FetchHandlerInterceptorOptions<T extends Context> extends StandardHand
     toFetchResponseOptions: ToFetchResponseOptions;
 }
 interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions {
-    adapterInterceptors?: Interceptor<FetchHandlerInterceptorOptions<T>, FetchHandleResult, ThrowableError>[];
+    adapterInterceptors?: Interceptor<FetchHandlerInterceptorOptions<T>, Promise<FetchHandleResult>>[];
     plugins?: FetchHandlerPlugin<T>[];
 }
 declare class FetchHandler<T extends Context> {
@@ -45,15 +46,79 @@ interface BodyLimitPluginOptions {
      */
     maxBodySize: number;
 }
+/**
+ * The Body Limit Plugin restricts the size of the request body for the Fetch Server.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/body-limit Body Limit Plugin Docs}
+ */
 declare class BodyLimitPlugin<T extends Context> implements FetchHandlerPlugin<T> {
     private readonly maxBodySize;
     constructor(options: BodyLimitPluginOptions);
     initRuntimeAdapter(options: FetchHandlerOptions<T>): void;
 }
 
+/**
+ * This plugin is heavily inspired by the [Hono Compression Plugin](https://github.com/honojs/hono/blob/main/src/middleware/compress/index.ts)
+ */
+
+declare const ORDERED_SUPPORTED_ENCODINGS: readonly ["gzip", "deflate"];
+interface CompressionPluginOptions {
+    /**
+     * The compression schemes to use for response compression.
+     * Schemes are prioritized by their order in this array and
+     * only applied if the client supports them.
+     *
+     * @default ['gzip', 'deflate']
+     */
+    encodings?: readonly (typeof ORDERED_SUPPORTED_ENCODINGS)[number][];
+    /**
+     * The minimum response size in bytes required to trigger compression.
+     * Responses smaller than this threshold will not be compressed to avoid overhead.
+     * If the response size cannot be determined, compression will still be applied.
+     *
+     * @default 1024 (1KB)
+     */
+    threshold?: number;
+    /**
+     * Override the default content-type filter used to determine which responses should be compressed.
+     *
+     * @warning [Event Iterator](https://orpc.unnoq.com/docs/event-iterator) responses are never compressed, regardless of this filter's return value.
+     * @default only responses with compressible content types are compressed.
+     */
+    filter?: (request: Request, response: Response) => boolean;
+}
+/**
+ * The Compression Plugin adds response compression to the Fetch Server.
+ * Build on top of [CompressionStream](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream)
+ * You might need to polyfill it if your environment does not support it.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/compression Compression Plugin Docs}
+ */
+declare class CompressionPlugin<T extends Context> implements FetchHandlerPlugin<T> {
+    private readonly encodings;
+    private readonly threshold;
+    private readonly filter;
+    constructor(options?: CompressionPluginOptions);
+    initRuntimeAdapter(options: FetchHandlerOptions<T>): void;
+}
+
+interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, Omit<StandardRPCHandlerOptions<T>, 'plugins'> {
+    /**
+     * Enables or disables the StrictGetMethodPlugin.
+     *
+     * @default true
+     */
+    strictGetMethodPluginEnabled?: boolean;
+}
+/**
+ * RPC Handler for Fetch Server
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
 declare class RPCHandler<T extends Context> extends FetchHandler<T> {
-    constructor(router: Router<any, T>, options?: NoInfer<FetchHandlerOptions<T> & StandardRPCHandlerOptions<T>>);
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { BodyLimitPlugin, CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
-export type { BodyLimitPluginOptions, FetchHandleResult, FetchHandlerInterceptorOptions, FetchHandlerOptions, FetchHandlerPlugin };
+export { BodyLimitPlugin, CompositeFetchHandlerPlugin, CompressionPlugin, FetchHandler, RPCHandler };
+export type { BodyLimitPluginOptions, CompressionPluginOptions, FetchHandleResult, FetchHandlerInterceptorOptions, FetchHandlerOptions, FetchHandlerPlugin, RPCHandlerOptions };

package/dist/adapters/fetch/index.mjs

@@ -1,13 +1,14 @@
 import { ORPCError } from '@orpc/client';
 import { toArray, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
 import { toStandardLazyRequest, toFetchResponse } from '@orpc/standard-server-fetch';
-import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.BVwwTHyO.mjs';
+import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
+import '@orpc/standard-server';
 import '@orpc/contract';
-import { C as CompositeStandardHandlerPlugin, b as StandardRPCHandler } from '../../shared/server.DFuJLDuo.mjs';
+import { C as CompositeStandardHandlerPlugin, b as StandardRPCHandler } from '../../shared/server.Bxx6tqNe.mjs';
 import '@orpc/client/standard';
 import '@orpc/standard-server/batch';
-import '../../shared/server.BW-nUGgA.mjs';
-import '../../shared/server.C37gDhSZ.mjs';
+import { S as StrictGetMethodPlugin } from '../../shared/server.TEVCLCFC.mjs';
+import '../../shared/server.Ds4HPpvH.mjs';
 
 class BodyLimitPlugin {
   maxBodySize;
@@ -55,6 +56,76 @@ class BodyLimitPlugin {
   }
 }
 
+const ORDERED_SUPPORTED_ENCODINGS = ["gzip", "deflate"];
+class CompressionPlugin {
+  encodings;
+  threshold;
+  filter;
+  constructor(options = {}) {
+    this.encodings = options.encodings ?? ORDERED_SUPPORTED_ENCODINGS;
+    this.threshold = options.threshold ?? 1024;
+    this.filter = (request, response) => {
+      const hasContentDisposition = response.headers.has("content-disposition");
+      const contentType = response.headers.get("content-type");
+      if (!hasContentDisposition && contentType?.startsWith("text/event-stream")) {
+        return false;
+      }
+      return options.filter ? options.filter(request, response) : isCompressibleContentType(contentType);
+    };
+  }
+  initRuntimeAdapter(options) {
+    options.adapterInterceptors ??= [];
+    options.adapterInterceptors.unshift(async (options2) => {
+      const result = await options2.next();
+      if (!result.matched) {
+        return result;
+      }
+      const response = result.response;
+      if (response.headers.has("content-encoding") || response.headers.has("transfer-encoding") || isNoTransformCacheControl(response.headers.get("cache-control"))) {
+        return result;
+      }
+      const contentLength = response.headers.get("content-length");
+      if (contentLength && Number(contentLength) < this.threshold) {
+        return result;
+      }
+      const acceptEncoding = options2.request.headers.get("accept-encoding")?.split(",").map((enc) => enc.trim().split(";")[0]);
+      const encoding = this.encodings.find((enc) => acceptEncoding?.includes(enc));
+      if (!response.body || encoding === void 0) {
+        return result;
+      }
+      if (!this.filter(options2.request, response)) {
+        return result;
+      }
+      const compressedBody = response.body.pipeThrough(new CompressionStream(encoding));
+      const compressedHeaders = new Headers(response.headers);
+      compressedHeaders.delete("content-length");
+      compressedHeaders.set("content-encoding", encoding);
+      return {
+        ...result,
+        response: new Response(compressedBody, {
+          status: response.status,
+          statusText: response.statusText,
+          headers: compressedHeaders
+        })
+      };
+    });
+  }
+}
+const COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/(?!event-stream(?:[;\s]|$))[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
+function isCompressibleContentType(contentType) {
+  if (contentType === null) {
+    return false;
+  }
+  return COMPRESSIBLE_CONTENT_TYPE_REGEX.test(contentType);
+}
+const CACHE_CONTROL_NO_TRANSFORM_REGEX = /(?:^|,)\s*no-transform\s*(?:,|$)/i;
+function isNoTransformCacheControl(cacheControl) {
+  if (cacheControl === null) {
+    return false;
+  }
+  return CACHE_CONTROL_NO_TRANSFORM_REGEX.test(cacheControl);
+}
+
 class CompositeFetchHandlerPlugin extends CompositeStandardHandlerPlugin {
   initRuntimeAdapter(options) {
     for (const plugin of this.plugins) {
@@ -98,8 +169,12 @@ class FetchHandler {
 
 class RPCHandler extends FetchHandler {
   constructor(router, options = {}) {
+    if (options.strictGetMethodPluginEnabled ?? true) {
+      options.plugins ??= [];
+      options.plugins.push(new StrictGetMethodPlugin());
+    }
     super(new StandardRPCHandler(router, options), options);
   }
 }
 
-export { BodyLimitPlugin, CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
+export { BodyLimitPlugin, CompositeFetchHandlerPlugin, CompressionPlugin, FetchHandler, RPCHandler };

package/dist/adapters/message-port/index.d.mts

@@ -0,0 +1,31 @@
+import { SupportedMessagePort } from '@orpc/client/message-port';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, R as Router } from '../../shared/server.B4BGqy3Y.mjs';
+import { f as StandardHandler } from '../../shared/server.DBCUJijK.mjs';
+import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.mjs';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.Ck-gOLzq.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/standard-server-peer';
+import '../../shared/server.CVKCo60T.mjs';
+import '@orpc/client/standard';
+import '../../shared/server.DzV1hr3z.mjs';
+
+declare class MessagePortHandler<T extends Context> {
+    private readonly standardHandler;
+    constructor(standardHandler: StandardHandler<T>);
+    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): void;
+}
+
+/**
+ * RPC Handler for common message port implementations.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/message-port Message Port Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends MessagePortHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { MessagePortHandler, RPCHandler };

package/dist/adapters/message-port/index.d.ts

@@ -0,0 +1,31 @@
+import { SupportedMessagePort } from '@orpc/client/message-port';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, R as Router } from '../../shared/server.B4BGqy3Y.js';
+import { f as StandardHandler } from '../../shared/server.DPIFWpxG.js';
+import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.js';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.COL12UTb.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/standard-server-peer';
+import '../../shared/server.DNtJ-p60.js';
+import '@orpc/client/standard';
+import '../../shared/server.Cb6yD7DZ.js';
+
+declare class MessagePortHandler<T extends Context> {
+    private readonly standardHandler;
+    constructor(standardHandler: StandardHandler<T>);
+    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): void;
+}
+
+/**
+ * RPC Handler for common message port implementations.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/message-port Message Port Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends MessagePortHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { MessagePortHandler, RPCHandler };

package/dist/adapters/message-port/index.mjs

@@ -0,0 +1,39 @@
+import { postMessagePortMessage, onMessagePortMessage, onMessagePortClose } from '@orpc/client/message-port';
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
+import { ServerPeer } from '@orpc/standard-server-peer';
+import { c as createServerPeerHandleRequestFn } from '../../shared/server.UVMTOWrk.mjs';
+import '@orpc/client';
+import '@orpc/standard-server';
+import '@orpc/contract';
+import { b as StandardRPCHandler } from '../../shared/server.Bxx6tqNe.mjs';
+import '@orpc/client/standard';
+import '../../shared/server.DZ5BIITo.mjs';
+import '../../shared/server.Ds4HPpvH.mjs';
+
+class MessagePortHandler {
+  constructor(standardHandler) {
+    this.standardHandler = standardHandler;
+  }
+  upgrade(port, ...rest) {
+    const peer = new ServerPeer((message) => {
+      return postMessagePortMessage(port, message);
+    });
+    onMessagePortMessage(port, async (message) => {
+      await peer.message(
+        message,
+        createServerPeerHandleRequestFn(this.standardHandler, resolveMaybeOptionalOptions(rest))
+      );
+    });
+    onMessagePortClose(port, () => {
+      peer.close();
+    });
+  }
+}
+
+class RPCHandler extends MessagePortHandler {
+  constructor(router, options = {}) {
+    super(new StandardRPCHandler(router, options));
+  }
+}
+
+export { MessagePortHandler, RPCHandler };

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

@@ -1,13 +1,15 @@
-import { C as Context, R as Router } from '../../shared/server.BVHsfJ99.mjs';
-import { Interceptor, ThrowableError, MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, R as Router } from '../../shared/server.B4BGqy3Y.mjs';
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
 import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@orpc/standard-server-node';
-import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, g as StandardHandleOptions, i as StandardHandler } from '../../shared/server.B1oIHH_j.mjs';
-import { F as FriendlyStandardHandleOptions } from '../../shared/server.Dwnm6cSk.mjs';
-import { S as StandardRPCHandlerOptions } from '../../shared/server.BuLPHTX1.mjs';
+import { g as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, f as StandardHandler } from '../../shared/server.DBCUJijK.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.CVKCo60T.mjs';
+import compression from '@orpc/interop/compression';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.Ck-gOLzq.mjs';
 import '@orpc/client';
 import '@orpc/contract';
 import '@orpc/standard-server';
 import '@orpc/client/standard';
+import '../../shared/server.DzV1hr3z.mjs';
 
 interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
     initRuntimeAdapter?(options: NodeHttpHandlerOptions<T>): void;
@@ -27,7 +29,7 @@ interface NodeHttpHandlerInterceptorOptions<T extends Context> extends StandardH
     sendStandardResponseOptions: SendStandardResponseOptions;
 }
 interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions {
-    adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, NodeHttpHandleResult, ThrowableError>[];
+    adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, Promise<NodeHttpHandleResult>>[];
     plugins?: NodeHttpHandlerPlugin<T>[];
 }
 declare class NodeHttpHandler<T extends Context> implements NodeHttpHandler<T> {
@@ -44,15 +46,54 @@ interface BodyLimitPluginOptions {
      */
     maxBodySize: number;
 }
+/**
+ * The Body Limit Plugin restricts the size of the request body for the Node.js HTTP Server.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/body-limit Body Limit Plugin Docs}
+ */
 declare class BodyLimitPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
     private readonly maxBodySize;
     constructor(options: BodyLimitPluginOptions);
     initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
 }
 
+interface CompressionPluginOptions extends compression.CompressionOptions {
+    /**
+     * Override the default content-type filter used to determine which responses should be compressed.
+     *
+     * @warning [Event Iterator](https://orpc.unnoq.com/docs/event-iterator) responses are never compressed, regardless of this filter's return value.
+     * @default only responses with compressible content types are compressed.
+     */
+    filter?: (req: NodeHttpRequest, res: NodeHttpResponse) => boolean;
+}
+/**
+ * The Compression Plugin adds response compression to the Node.js HTTP Server.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/compression Compression Plugin Docs}
+ */
+declare class CompressionPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
+    private readonly compressionHandler;
+    constructor(options?: CompressionPluginOptions);
+    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+}
+
+interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardRPCHandlerOptions<T>, 'plugins'> {
+    /**
+     * Enables or disables the StrictGetMethodPlugin.
+     *
+     * @default true
+     */
+    strictGetMethodPluginEnabled?: boolean;
+}
+/**
+ * RPC Handler for Node.js HTTP Server
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
 declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
-    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T> & NodeHttpHandlerOptions<T>>);
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
-export type { BodyLimitPluginOptions, NodeHttpHandleResult, NodeHttpHandlerInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin };
+export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, CompressionPlugin, NodeHttpHandler, RPCHandler };
+export type { BodyLimitPluginOptions, CompressionPluginOptions, NodeHttpHandleResult, NodeHttpHandlerInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };

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

@@ -1,13 +1,15 @@
-import { C as Context, R as Router } from '../../shared/server.BVHsfJ99.js';
-import { Interceptor, ThrowableError, MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, R as Router } from '../../shared/server.B4BGqy3Y.js';
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
 import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@orpc/standard-server-node';
-import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, g as StandardHandleOptions, i as StandardHandler } from '../../shared/server.CaWivVk3.js';
-import { F as FriendlyStandardHandleOptions } from '../../shared/server.DMhSfHk1.js';
-import { S as StandardRPCHandlerOptions } from '../../shared/server.D_vpYits.js';
+import { g as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, f as StandardHandler } from '../../shared/server.DPIFWpxG.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.DNtJ-p60.js';
+import compression from '@orpc/interop/compression';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.COL12UTb.js';
 import '@orpc/client';
 import '@orpc/contract';
 import '@orpc/standard-server';
 import '@orpc/client/standard';
+import '../../shared/server.Cb6yD7DZ.js';
 
 interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
     initRuntimeAdapter?(options: NodeHttpHandlerOptions<T>): void;
@@ -27,7 +29,7 @@ interface NodeHttpHandlerInterceptorOptions<T extends Context> extends StandardH
     sendStandardResponseOptions: SendStandardResponseOptions;
 }
 interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions {
-    adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, NodeHttpHandleResult, ThrowableError>[];
+    adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, Promise<NodeHttpHandleResult>>[];
     plugins?: NodeHttpHandlerPlugin<T>[];
 }
 declare class NodeHttpHandler<T extends Context> implements NodeHttpHandler<T> {
@@ -44,15 +46,54 @@ interface BodyLimitPluginOptions {
      */
     maxBodySize: number;
 }
+/**
+ * The Body Limit Plugin restricts the size of the request body for the Node.js HTTP Server.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/body-limit Body Limit Plugin Docs}
+ */
 declare class BodyLimitPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
     private readonly maxBodySize;
     constructor(options: BodyLimitPluginOptions);
     initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
 }
 
+interface CompressionPluginOptions extends compression.CompressionOptions {
+    /**
+     * Override the default content-type filter used to determine which responses should be compressed.
+     *
+     * @warning [Event Iterator](https://orpc.unnoq.com/docs/event-iterator) responses are never compressed, regardless of this filter's return value.
+     * @default only responses with compressible content types are compressed.
+     */
+    filter?: (req: NodeHttpRequest, res: NodeHttpResponse) => boolean;
+}
+/**
+ * The Compression Plugin adds response compression to the Node.js HTTP Server.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/compression Compression Plugin Docs}
+ */
+declare class CompressionPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
+    private readonly compressionHandler;
+    constructor(options?: CompressionPluginOptions);
+    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+}
+
+interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardRPCHandlerOptions<T>, 'plugins'> {
+    /**
+     * Enables or disables the StrictGetMethodPlugin.
+     *
+     * @default true
+     */
+    strictGetMethodPluginEnabled?: boolean;
+}
+/**
+ * RPC Handler for Node.js HTTP Server
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
 declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
-    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T> & NodeHttpHandlerOptions<T>>);
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
-export type { BodyLimitPluginOptions, NodeHttpHandleResult, NodeHttpHandlerInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin };
+export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, CompressionPlugin, NodeHttpHandler, RPCHandler };
+export type { BodyLimitPluginOptions, CompressionPluginOptions, NodeHttpHandleResult, NodeHttpHandlerInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };

package/dist/adapters/node/index.mjs

@@ -1,13 +1,16 @@
 import { ORPCError } from '@orpc/client';
-import { toArray, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { once, toArray, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import compression from '@orpc/interop/compression';
 import { toStandardLazyRequest, sendStandardResponse } from '@orpc/standard-server-node';
-import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.BVwwTHyO.mjs';
+import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
+import '@orpc/standard-server';
 import '@orpc/contract';
-import { C as CompositeStandardHandlerPlugin, b as StandardRPCHandler } from '../../shared/server.DFuJLDuo.mjs';
+import { C as CompositeStandardHandlerPlugin, b as StandardRPCHandler } from '../../shared/server.Bxx6tqNe.mjs';
 import '@orpc/client/standard';
 import '@orpc/standard-server/batch';
-import '../../shared/server.BW-nUGgA.mjs';
-import '../../shared/server.C37gDhSZ.mjs';
+import '@orpc/standard-server-fetch';
+import { S as StrictGetMethodPlugin } from '../../shared/server.TEVCLCFC.mjs';
+import '../../shared/server.Ds4HPpvH.mjs';
 
 class BodyLimitPlugin {
   maxBodySize;
@@ -17,14 +20,12 @@ class BodyLimitPlugin {
   initRuntimeAdapter(options) {
     options.adapterInterceptors ??= [];
     options.adapterInterceptors.push(async (options2) => {
-      let isHeaderChecked = false;
-      const checkHeader = () => {
-        if (!isHeaderChecked && Number(options2.request.headers["content-length"]) > this.maxBodySize) {
+      const checkHeader = once(() => {
+        if (Number(options2.request.headers["content-length"]) > this.maxBodySize) {
           throw new ORPCError("PAYLOAD_TOO_LARGE");
         }
-        isHeaderChecked = true;
-      };
-      const originalEmit = options2.request.emit.bind(options2.request);
+      });
+      const originalEmit = options2.request.emit;
       let currentBodySize = 0;
       options2.request.emit = (event, ...args) => {
         if (event === "data") {
@@ -34,9 +35,66 @@ class BodyLimitPlugin {
             throw new ORPCError("PAYLOAD_TOO_LARGE");
           }
         }
-        return originalEmit(event, ...args);
+        return originalEmit.call(options2.request, event, ...args);
       };
-      return options2.next();
+      try {
+        return await options2.next(options2);
+      } finally {
+        options2.request.emit = originalEmit;
+      }
+    });
+  }
+}
+
+class CompressionPlugin {
+  compressionHandler;
+  constructor(options = {}) {
+    this.compressionHandler = compression({
+      ...options,
+      filter: (req, res) => {
+        const hasContentDisposition = res.hasHeader("content-disposition");
+        const contentType = res.getHeader("content-type")?.toString();
+        if (!hasContentDisposition && contentType?.startsWith("text/event-stream")) {
+          return false;
+        }
+        return options.filter ? options.filter(req, res) : compression.filter(req, res);
+      }
+    });
+  }
+  initRuntimeAdapter(options) {
+    options.adapterInterceptors ??= [];
+    options.adapterInterceptors.unshift(async (options2) => {
+      let resolve;
+      let reject;
+      const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      const originalWrite = options2.response.write;
+      const originalEnd = options2.response.end;
+      const originalOn = options2.response.on;
+      this.compressionHandler(
+        options2.request,
+        options2.response,
+        async (err) => {
+          if (err) {
+            reject(err);
+          } else {
+            try {
+              resolve(await options2.next());
+            } catch (error) {
+              reject(error);
+            }
+          }
+        }
+      );
+      try {
+        return await promise;
+      } finally {
+        options2.response.write = originalWrite;
+        options2.response.end = originalEnd;
+        options2.response.on = originalOn;
+      }
     });
   }
 }
@@ -83,8 +141,12 @@ class NodeHttpHandler {
 
 class RPCHandler extends NodeHttpHandler {
   constructor(router, options = {}) {
+    if (options.strictGetMethodPluginEnabled ?? true) {
+      options.plugins ??= [];
+      options.plugins.push(new StrictGetMethodPlugin());
+    }
     super(new StandardRPCHandler(router, options), options);
   }
 }
 
-export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
+export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, CompressionPlugin, NodeHttpHandler, RPCHandler };

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

@@ -1,12 +1,14 @@
-import { c as StandardCodec, d as StandardParams, e as StandardMatcher, f as StandardMatchResult } from '../../shared/server.B1oIHH_j.mjs';
-export { C as CompositeStandardHandlerPlugin, g as StandardHandleOptions, h as StandardHandleResult, i as StandardHandler, S as StandardHandlerInterceptorOptions, b as StandardHandlerOptions, a as StandardHandlerPlugin } from '../../shared/server.B1oIHH_j.mjs';
-import { ORPCError, HTTPPath } from '@orpc/client';
+import { S as StandardCodec, a as StandardParams } from '../../shared/server.DBCUJijK.mjs';
+export { C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, c as StandardHandleResult, f as StandardHandler, d as StandardHandlerInterceptorOptions, e as StandardHandlerOptions, g as StandardHandlerPlugin, h as StandardMatchResult, i as StandardMatcher } from '../../shared/server.DBCUJijK.mjs';
+import { ORPCError } from '@orpc/client';
 import { StandardRPCSerializer } from '@orpc/client/standard';
 import { StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
-import { h as AnyProcedure, f as AnyRouter } from '../../shared/server.BVHsfJ99.mjs';
-export { a as StandardRPCHandler, S as StandardRPCHandlerOptions } from '../../shared/server.BuLPHTX1.mjs';
+import { A as AnyProcedure } from '../../shared/server.B4BGqy3Y.mjs';
+export { a as StandardRPCHandler, S as StandardRPCHandlerOptions, c as StandardRPCMatcher, b as StandardRPCMatcherOptions } from '../../shared/server.Ck-gOLzq.mjs';
+export { F as FriendlyStandardHandleOptions, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.CVKCo60T.mjs';
 import '@orpc/contract';
 import '@orpc/shared';
+import '../../shared/server.DzV1hr3z.mjs';
 
 declare class StandardRPCCodec implements StandardCodec {
     private readonly serializer;
@@ -16,11 +18,4 @@ declare class StandardRPCCodec implements StandardCodec {
     encodeError(error: ORPCError<any, any>): StandardResponse;
 }
 
-declare class StandardRPCMatcher implements StandardMatcher {
-    private readonly tree;
-    private pendingRouters;
-    init(router: AnyRouter, path?: readonly string[]): void;
-    match(_method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
-}
-
-export { StandardCodec, StandardMatchResult, StandardMatcher, StandardParams, StandardRPCCodec, StandardRPCMatcher };
+export { StandardCodec, StandardParams, StandardRPCCodec };