@temporary-name/server 1.9.3-alpha.6ef4729e23affbe6454d37025d1dfc4d998b0649 → 1.9.3-alpha.72daecd600ae901064d3c4f8ab780582c1335ffe

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

@@ -1,10 +1,8 @@
 import { MaybeOptionalOptions } from '@temporary-name/shared';
 import { SendStandardResponseOptions, APIGatewayProxyEventV2, ResponseStream } from '@temporary-name/standard-server-aws-lambda';
-import { C as Context } from '../../shared/server.C1YnHvvf.mjs';
-import { S as StandardHandler } from '../../shared/server.Bo94xDTv.mjs';
-import { FriendlyStandardHandleOptions } from '../standard/index.mjs';
-import '@temporary-name/contract';
-import '@temporary-name/standard-server';
+import { C as Context, m as Router } from '../../shared/server.BwcJq6aP.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.hAH-LVh_.mjs';
+import '@temporary-name/zod';
 
 interface AwsLambdaHandlerOptions extends SendStandardResponseOptions {
 }
@@ -13,10 +11,16 @@ type AwsLambdaHandleResult = {
 } | {
     matched: false;
 };
+/**
+ * OpenAPI Handler for AWS Lambda.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-handler OpenAPI Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
 declare class AwsLambdaHandler<T extends Context> {
-    private readonly standardHandler;
     private readonly sendStandardResponseOptions;
-    constructor(standardHandler: StandardHandler<T>, options?: AwsLambdaHandlerOptions);
+    private readonly standardHandler;
+    constructor(router: Router<T>, options?: AwsLambdaHandlerOptions);
     handle(event: APIGatewayProxyEventV2, responseStream: ResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<AwsLambdaHandleResult>;
 }
 

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

@@ -1,10 +1,8 @@
 import { MaybeOptionalOptions } from '@temporary-name/shared';
 import { SendStandardResponseOptions, APIGatewayProxyEventV2, ResponseStream } from '@temporary-name/standard-server-aws-lambda';
-import { C as Context } from '../../shared/server.C1YnHvvf.js';
-import { S as StandardHandler } from '../../shared/server.Btxrgkj5.js';
-import { FriendlyStandardHandleOptions } from '../standard/index.js';
-import '@temporary-name/contract';
-import '@temporary-name/standard-server';
+import { C as Context, m as Router } from '../../shared/server.BwcJq6aP.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.Deg5phAY.js';
+import '@temporary-name/zod';
 
 interface AwsLambdaHandlerOptions extends SendStandardResponseOptions {
 }
@@ -13,10 +11,16 @@ type AwsLambdaHandleResult = {
 } | {
     matched: false;
 };
+/**
+ * OpenAPI Handler for AWS Lambda.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-handler OpenAPI Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
 declare class AwsLambdaHandler<T extends Context> {
-    private readonly standardHandler;
     private readonly sendStandardResponseOptions;
-    constructor(standardHandler: StandardHandler<T>, options?: AwsLambdaHandlerOptions);
+    private readonly standardHandler;
+    constructor(router: Router<T>, options?: AwsLambdaHandlerOptions);
     handle(event: APIGatewayProxyEventV2, responseStream: ResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<AwsLambdaHandleResult>;
 }
 

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

@@ -1,13 +1,20 @@
 import { resolveMaybeOptionalOptions } from '@temporary-name/shared';
 import { toStandardLazyRequest, sendStandardResponse } from '@temporary-name/standard-server-aws-lambda';
-import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
+import { S as StandardHandler, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.H11763QX.mjs';
+import '@temporary-name/server';
+import '@temporary-name/standard-server';
+import '../../shared/server.DEC2sW8B.mjs';
+import 'rou3';
+import '../../shared/server.gSXsB9Bn.mjs';
+import '@temporary-name/zod';
 
 class AwsLambdaHandler {
-  constructor(standardHandler, options = {}) {
-    this.standardHandler = standardHandler;
+  sendStandardResponseOptions;
+  standardHandler;
+  constructor(router, options = {}) {
+    this.standardHandler = new StandardHandler(router);
     this.sendStandardResponseOptions = options;
   }
-  sendStandardResponseOptions;
   async handle(event, responseStream, ...rest) {
     const standardRequest = toStandardLazyRequest(event, responseStream);
     const options = resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest));

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

@@ -1,17 +1,8 @@
-import { C as Context } from '../../shared/server.C1YnHvvf.mjs';
-import { Interceptor, MaybeOptionalOptions } from '@temporary-name/shared';
+import { MaybeOptionalOptions } from '@temporary-name/shared';
 import { ToFetchResponseOptions } from '@temporary-name/standard-server-fetch';
-import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, S as StandardHandler } from '../../shared/server.Bo94xDTv.mjs';
-import { FriendlyStandardHandleOptions } from '../standard/index.mjs';
-import '@temporary-name/contract';
-import '@temporary-name/standard-server';
-
-interface FetchHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    initRuntimeAdapter?(options: FetchHandlerOptions<T>): void;
-}
-declare class CompositeFetchHandlerPlugin<T extends Context, TPlugin extends FetchHandlerPlugin<T>> extends CompositeStandardHandlerPlugin<T, TPlugin> implements FetchHandlerPlugin<T> {
-    initRuntimeAdapter(options: FetchHandlerOptions<T>): void;
-}
+import { C as Context, m as Router } from '../../shared/server.BwcJq6aP.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.hAH-LVh_.mjs';
+import '@temporary-name/zod';
 
 type FetchHandleResult = {
     matched: true;
@@ -20,83 +11,20 @@ type FetchHandleResult = {
     matched: false;
     response: undefined;
 };
-interface FetchHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
-    request: Request;
-    toFetchResponseOptions: ToFetchResponseOptions;
-}
-interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions {
-    adapterInterceptors?: Interceptor<FetchHandlerInterceptorOptions<T>, Promise<FetchHandleResult>>[];
-    plugins?: FetchHandlerPlugin<T>[];
-}
-declare class FetchHandler<T extends Context> {
-    private readonly standardHandler;
-    private readonly toFetchResponseOptions;
-    private readonly adapterInterceptors;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
-    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<FetchHandleResult>;
-}
-
-interface BodyLimitPluginOptions {
-    /**
-     * The maximum size of the body in bytes.
-     */
-    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;
+interface FetchHandlerOptions extends ToFetchResponseOptions {
 }
 /**
- * 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.
+ * OpenAPI Handler for Fetch Server
  *
- * @see {@link https://orpc.unnoq.com/docs/plugins/compression Compression Plugin Docs}
+ * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-handler OpenAPI Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter 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;
+declare class FetchHandler<T extends Context> {
+    private readonly toFetchResponseOptions;
+    private readonly standardHandler;
+    constructor(router: Router<T>, options?: NoInfer<FetchHandlerOptions>);
+    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<FetchHandleResult>;
 }
 
-export { BodyLimitPlugin, CompositeFetchHandlerPlugin, CompressionPlugin, FetchHandler };
-export type { BodyLimitPluginOptions, CompressionPluginOptions, FetchHandleResult, FetchHandlerInterceptorOptions, FetchHandlerOptions, FetchHandlerPlugin };
+export { FetchHandler };
+export type { FetchHandleResult, FetchHandlerOptions };

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

@@ -1,17 +1,8 @@
-import { C as Context } from '../../shared/server.C1YnHvvf.js';
-import { Interceptor, MaybeOptionalOptions } from '@temporary-name/shared';
+import { MaybeOptionalOptions } from '@temporary-name/shared';
 import { ToFetchResponseOptions } from '@temporary-name/standard-server-fetch';
-import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, S as StandardHandler } from '../../shared/server.Btxrgkj5.js';
-import { FriendlyStandardHandleOptions } from '../standard/index.js';
-import '@temporary-name/contract';
-import '@temporary-name/standard-server';
-
-interface FetchHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    initRuntimeAdapter?(options: FetchHandlerOptions<T>): void;
-}
-declare class CompositeFetchHandlerPlugin<T extends Context, TPlugin extends FetchHandlerPlugin<T>> extends CompositeStandardHandlerPlugin<T, TPlugin> implements FetchHandlerPlugin<T> {
-    initRuntimeAdapter(options: FetchHandlerOptions<T>): void;
-}
+import { C as Context, m as Router } from '../../shared/server.BwcJq6aP.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.Deg5phAY.js';
+import '@temporary-name/zod';
 
 type FetchHandleResult = {
     matched: true;
@@ -20,83 +11,20 @@ type FetchHandleResult = {
     matched: false;
     response: undefined;
 };
-interface FetchHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
-    request: Request;
-    toFetchResponseOptions: ToFetchResponseOptions;
-}
-interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions {
-    adapterInterceptors?: Interceptor<FetchHandlerInterceptorOptions<T>, Promise<FetchHandleResult>>[];
-    plugins?: FetchHandlerPlugin<T>[];
-}
-declare class FetchHandler<T extends Context> {
-    private readonly standardHandler;
-    private readonly toFetchResponseOptions;
-    private readonly adapterInterceptors;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
-    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<FetchHandleResult>;
-}
-
-interface BodyLimitPluginOptions {
-    /**
-     * The maximum size of the body in bytes.
-     */
-    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;
+interface FetchHandlerOptions extends ToFetchResponseOptions {
 }
 /**
- * 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.
+ * OpenAPI Handler for Fetch Server
  *
- * @see {@link https://orpc.unnoq.com/docs/plugins/compression Compression Plugin Docs}
+ * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-handler OpenAPI Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter 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;
+declare class FetchHandler<T extends Context> {
+    private readonly toFetchResponseOptions;
+    private readonly standardHandler;
+    constructor(router: Router<T>, options?: NoInfer<FetchHandlerOptions>);
+    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<FetchHandleResult>;
 }
 
-export { BodyLimitPlugin, CompositeFetchHandlerPlugin, CompressionPlugin, FetchHandler };
-export type { BodyLimitPluginOptions, CompressionPluginOptions, FetchHandleResult, FetchHandlerInterceptorOptions, FetchHandlerOptions, FetchHandlerPlugin };
+export { FetchHandler };
+export type { FetchHandleResult, FetchHandlerOptions };

package/dist/adapters/fetch/index.mjs

@@ -1,171 +1,32 @@
-import { ORPCError, toArray, intercept, resolveMaybeOptionalOptions } from '@temporary-name/shared';
+import { resolveMaybeOptionalOptions } from '@temporary-name/shared';
 import { toStandardLazyRequest, toFetchResponse } from '@temporary-name/standard-server-fetch';
-import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
+import { S as StandardHandler, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.H11763QX.mjs';
+import '@temporary-name/server';
 import '@temporary-name/standard-server';
-import '@temporary-name/contract';
-import '../../shared/server.D6K9uoPI.mjs';
-import { C as CompositeStandardHandlerPlugin } from '../../shared/server.X0YaZxSJ.mjs';
-import 'node:async_hooks';
-import 'zod';
-import 'zod/v4/core';
-
-class BodyLimitPlugin {
-  maxBodySize;
-  constructor(options) {
-    this.maxBodySize = options.maxBodySize;
-  }
-  initRuntimeAdapter(options) {
-    options.adapterInterceptors ??= [];
-    options.adapterInterceptors.push(async (options2) => {
-      if (!options2.request.body) {
-        return options2.next();
-      }
-      let currentBodySize = 0;
-      const rawReader = options2.request.body.getReader();
-      const reader = new ReadableStream({
-        start: async (controller) => {
-          try {
-            if (Number(options2.request.headers.get("content-length")) > this.maxBodySize) {
-              controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
-              return;
-            }
-            while (true) {
-              const { done, value } = await rawReader.read();
-              if (done) {
-                break;
-              }
-              currentBodySize += value.length;
-              if (currentBodySize > this.maxBodySize) {
-                controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
-                break;
-              }
-              controller.enqueue(value);
-            }
-          } finally {
-            controller.close();
-          }
-        }
-      });
-      const requestInit = { body: reader, duplex: "half" };
-      return options2.next({
-        ...options2,
-        request: new Request(options2.request, requestInit)
-      });
-    });
-  }
-}
-
-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") || // already encoded
-      response.headers.has("transfer-encoding") || // already encoded or chunked
-      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) {
-      plugin.initRuntimeAdapter?.(options);
-    }
-  }
-}
+import '../../shared/server.DEC2sW8B.mjs';
+import 'rou3';
+import '../../shared/server.gSXsB9Bn.mjs';
+import '@temporary-name/zod';
 
 class FetchHandler {
-  constructor(standardHandler, options = {}) {
-    this.standardHandler = standardHandler;
-    const plugin = new CompositeFetchHandlerPlugin(options.plugins);
-    plugin.initRuntimeAdapter(options);
-    this.adapterInterceptors = toArray(options.adapterInterceptors);
+  toFetchResponseOptions;
+  standardHandler;
+  constructor(router, options = {}) {
+    this.standardHandler = new StandardHandler(router);
     this.toFetchResponseOptions = options;
   }
-  toFetchResponseOptions;
-  adapterInterceptors;
   async handle(request, ...rest) {
-    return intercept(
-      this.adapterInterceptors,
-      {
-        ...resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest)),
-        request,
-        toFetchResponseOptions: this.toFetchResponseOptions
-      },
-      async ({ request: request2, toFetchResponseOptions, ...options }) => {
-        const standardRequest = toStandardLazyRequest(request2);
-        const result = await this.standardHandler.handle(standardRequest, options);
-        if (!result.matched) {
-          return result;
-        }
-        return {
-          matched: true,
-          response: toFetchResponse(result.response, toFetchResponseOptions)
-        };
-      }
-    );
+    const options = resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest));
+    const standardRequest = toStandardLazyRequest(request);
+    const result = await this.standardHandler.handle(standardRequest, options);
+    if (!result.matched) {
+      return result;
+    }
+    return {
+      matched: true,
+      response: toFetchResponse(result.response, this.toFetchResponseOptions)
+    };
   }
 }
 
-export { BodyLimitPlugin, CompositeFetchHandlerPlugin, CompressionPlugin, FetchHandler };
+export { FetchHandler };

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

@@ -1,77 +1,28 @@
-import { C as Context } from '../../shared/server.C1YnHvvf.mjs';
-import { Interceptor, MaybeOptionalOptions } from '@temporary-name/shared';
+import { MaybeOptionalOptions } from '@temporary-name/shared';
 import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@temporary-name/standard-server-node';
-import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, S as StandardHandler } from '../../shared/server.Bo94xDTv.mjs';
-import { FriendlyStandardHandleOptions } from '../standard/index.mjs';
-import compression from '@temporary-name/interop/compression';
-import '@temporary-name/contract';
-import '@temporary-name/standard-server';
-
-interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    initRuntimeAdapter?(options: NodeHttpHandlerOptions<T>): void;
-}
-declare class CompositeNodeHttpHandlerPlugin<T extends Context, TPlugin extends NodeHttpHandlerPlugin<T>> extends CompositeStandardHandlerPlugin<T, TPlugin> implements NodeHttpHandlerPlugin<T> {
-    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
-}
+import { C as Context, m as Router } from '../../shared/server.BwcJq6aP.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.hAH-LVh_.mjs';
+import '@temporary-name/zod';
 
 type NodeHttpHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-interface NodeHttpHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
-    request: NodeHttpRequest;
-    response: NodeHttpResponse;
-    sendStandardResponseOptions: SendStandardResponseOptions;
-}
-interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions {
-    adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, Promise<NodeHttpHandleResult>>[];
-    plugins?: NodeHttpHandlerPlugin<T>[];
-}
-declare class NodeHttpHandler<T extends Context> implements NodeHttpHandler<T> {
-    private readonly standardHandler;
-    private readonly sendStandardResponseOptions;
-    private readonly adapterInterceptors;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
-    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
-}
-
-interface BodyLimitPluginOptions {
-    /**
-     * The maximum size of the body in bytes.
-     */
-    maxBodySize: number;
+interface NodeHttpHandlerOptions extends SendStandardResponseOptions {
 }
 /**
- * The Body Limit Plugin restricts the size of the request body for the Node.js HTTP Server.
+ * OpenAPI Handler for Node Server
  *
- * @see {@link https://orpc.unnoq.com/docs/plugins/body-limit Body Limit Plugin Docs}
+ * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-handler OpenAPI Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter 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;
+declare class NodeHttpHandler<T extends Context> {
+    private readonly sendStandardResponseOptions;
+    private readonly standardHandler;
+    constructor(router: Router<T>, options?: NoInfer<NodeHttpHandlerOptions>);
+    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
 }
 
-export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, CompressionPlugin, NodeHttpHandler };
-export type { BodyLimitPluginOptions, CompressionPluginOptions, NodeHttpHandleResult, NodeHttpHandlerInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin };
+export { NodeHttpHandler };
+export type { NodeHttpHandleResult, NodeHttpHandlerOptions };