@orpc/server 2.0.0-beta.35 → 2.0.0-beta.37

package/dist/adapters/fastify/index.mjs

@@ -1,57 +1,30 @@
-import { sortPlugins, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
 import { toStandardLazyRequest, sendStandardResponse } from '@standard-server/fastify';
 import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.sNWd6DAG.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.C0lFtoHU.mjs';
 import '@orpc/client';
 import '@standard-server/core';
 import '../../shared/server.Djb_ebJT.mjs';
 import '@orpc/contract';
-import '../../shared/server.BYnwk7Xz.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;
-  }
-}
+import '../../shared/server.BynNaBBA.mjs';
 
 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;
-      }
+    const standardRequest = toStandardLazyRequest(request, reply);
+    const result = await this.standardHandler.handle(
+      standardRequest,
+      resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest))
     );
+    if (!result.matched) {
+      return result;
+    }
+    await sendStandardResponse(reply, result.response, this.sendStandardResponseOptions);
+    return result;
   }
 }
 
@@ -63,4 +36,4 @@ class RPCHandler extends FastifyHandler {
   }
 }
 
-export { CompositeFastifyHandlerPlugin, FastifyHandler, RPCHandler };
+export { FastifyHandler, RPCHandler };

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

@@ -1,8 +1,8 @@
-export { R as BodyLimitPlugin } from '../../shared/server.CAiLRqPf.mjs';
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+export { R as BodyLimitPlugin } from '../../shared/server.C7xllBNN.mjs';
+import { MaybeOptionalOptions } from '@orpc/shared';
 import { ToFetchResponseOptions } from '@standard-server/fetch';
 import { Context } from '../../index.mjs';
-import { StandardHandlerPlugin, StandardHandlerHandleOptions, StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
 import { Router } from '../../index.mjs';
 import { RPCHandlerCodecOptions } from '../standard/index.mjs';
@@ -10,36 +10,6 @@ import '@orpc/client';
 import '@orpc/contract';
 import '@standard-server/core';
 
-interface FetchHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    /**
-     * Initializes the plugin and returns new fetch handler options.
-     * Called once per plugin instance during composition.
-     *
-     * This method allows plugins to wrap, extend, or transform fetch handler options
-     * such as fetch interceptors, or fetch configuration.
-     *
-     * @param options - The current handler options from previous plugins or base configuration
-     * @returns Transformed handler options with plugin's modifications applied
-     *
-     * @example
-     * ```ts
-     * initFetchHandlerOptions(options) {
-     *   return {
-     *     ...options,
-     *     interceptors: [...(options.interceptors || []), myInterceptor]
-     *   }
-     * }
-     * ```
-     */
-    initFetchHandlerOptions?(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
-declare class CompositeFetchHandlerPlugin<T extends Context> implements FetchHandlerPlugin<T> {
-    readonly name = "~composite/fetch";
-    protected readonly plugins: FetchHandlerPlugin<T>[];
-    constructor(plugins?: FetchHandlerPlugin<T>[]);
-    initFetchHandlerOptions(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
-
 type FetchHandlerHandleResult = {
     matched: true;
     response: Response;
@@ -47,32 +17,20 @@ type FetchHandlerHandleResult = {
     matched: false;
     response?: undefined;
 };
-interface FetchHandlerFetchInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
-    request: Request;
-    toFetchResponseOptions: ToFetchResponseOptions | undefined;
-}
-type FetchHandlerFetchInterceptor<T extends Context> = Interceptor<FetchHandlerFetchInterceptorOptions<T>, Promise<FetchHandlerHandleResult>>;
-interface FetchHandlerOptions<T extends Context> {
+interface FetchHandlerOptions<_T extends Context> {
     /**
      * Options for how to convert the Fetch Response to a Standard Response, like event stream options, etc.
      */
     toFetchResponse?: undefined | ToFetchResponseOptions;
-    /**
-     * Interceptors that run before the mapping between the Standard API and Fetch API,
-     * useful for customizing the mapping behavior (e.g. extending the body parser).
-     */
-    fetchInterceptors?: FetchHandlerFetchInterceptor<T>[] | undefined;
-    plugins?: FetchHandlerPlugin<T>[] | undefined;
 }
 declare class FetchHandler<T extends Context> {
     private readonly standardHandler;
     private readonly toFetchResponseOptions;
-    private readonly fetchInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
     handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FetchHandlerHandleResult>;
 }
 
-interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
 }
 /**
  * Serves an oRPC router over the RPC protocol using the Fetch API
@@ -85,5 +43,5 @@ declare class RPCHandler<T extends Context> extends FetchHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
-export type { FetchHandlerFetchInterceptor, FetchHandlerFetchInterceptorOptions, FetchHandlerHandleResult, FetchHandlerOptions, FetchHandlerPlugin, RPCHandlerOptions };
+export { FetchHandler, RPCHandler };
+export type { FetchHandlerHandleResult, FetchHandlerOptions, RPCHandlerOptions };

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

@@ -1,8 +1,8 @@
-export { R as BodyLimitPlugin } from '../../shared/server.b2-J4t6T.js';
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+export { R as BodyLimitPlugin } from '../../shared/server.D0dr-F8u.js';
+import { MaybeOptionalOptions } from '@orpc/shared';
 import { ToFetchResponseOptions } from '@standard-server/fetch';
 import { Context } from '../../index.js';
-import { StandardHandlerPlugin, StandardHandlerHandleOptions, StandardHandler, StandardHandlerOptions } from '../standard/index.js';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
 import { Router } from '../../index.js';
 import { RPCHandlerCodecOptions } from '../standard/index.js';
@@ -10,36 +10,6 @@ import '@orpc/client';
 import '@orpc/contract';
 import '@standard-server/core';
 
-interface FetchHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    /**
-     * Initializes the plugin and returns new fetch handler options.
-     * Called once per plugin instance during composition.
-     *
-     * This method allows plugins to wrap, extend, or transform fetch handler options
-     * such as fetch interceptors, or fetch configuration.
-     *
-     * @param options - The current handler options from previous plugins or base configuration
-     * @returns Transformed handler options with plugin's modifications applied
-     *
-     * @example
-     * ```ts
-     * initFetchHandlerOptions(options) {
-     *   return {
-     *     ...options,
-     *     interceptors: [...(options.interceptors || []), myInterceptor]
-     *   }
-     * }
-     * ```
-     */
-    initFetchHandlerOptions?(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
-declare class CompositeFetchHandlerPlugin<T extends Context> implements FetchHandlerPlugin<T> {
-    readonly name = "~composite/fetch";
-    protected readonly plugins: FetchHandlerPlugin<T>[];
-    constructor(plugins?: FetchHandlerPlugin<T>[]);
-    initFetchHandlerOptions(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
-
 type FetchHandlerHandleResult = {
     matched: true;
     response: Response;
@@ -47,32 +17,20 @@ type FetchHandlerHandleResult = {
     matched: false;
     response?: undefined;
 };
-interface FetchHandlerFetchInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
-    request: Request;
-    toFetchResponseOptions: ToFetchResponseOptions | undefined;
-}
-type FetchHandlerFetchInterceptor<T extends Context> = Interceptor<FetchHandlerFetchInterceptorOptions<T>, Promise<FetchHandlerHandleResult>>;
-interface FetchHandlerOptions<T extends Context> {
+interface FetchHandlerOptions<_T extends Context> {
     /**
      * Options for how to convert the Fetch Response to a Standard Response, like event stream options, etc.
      */
     toFetchResponse?: undefined | ToFetchResponseOptions;
-    /**
-     * Interceptors that run before the mapping between the Standard API and Fetch API,
-     * useful for customizing the mapping behavior (e.g. extending the body parser).
-     */
-    fetchInterceptors?: FetchHandlerFetchInterceptor<T>[] | undefined;
-    plugins?: FetchHandlerPlugin<T>[] | undefined;
 }
 declare class FetchHandler<T extends Context> {
     private readonly standardHandler;
     private readonly toFetchResponseOptions;
-    private readonly fetchInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
     handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FetchHandlerHandleResult>;
 }
 
-interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
 }
 /**
  * Serves an oRPC router over the RPC protocol using the Fetch API
@@ -85,5 +43,5 @@ declare class RPCHandler<T extends Context> extends FetchHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
-export type { FetchHandlerFetchInterceptor, FetchHandlerFetchInterceptorOptions, FetchHandlerHandleResult, FetchHandlerOptions, FetchHandlerPlugin, RPCHandlerOptions };
+export { FetchHandler, RPCHandler };
+export type { FetchHandlerHandleResult, FetchHandlerOptions, RPCHandlerOptions };

package/dist/adapters/fetch/index.mjs

@@ -1,59 +1,33 @@
 export { R as BodyLimitPlugin } from '../../shared/server.1ExWFMze.mjs';
-import { sortPlugins, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
 import { toStandardLazyRequest, toFetchResponse } from '@standard-server/fetch';
 import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.sNWd6DAG.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.C0lFtoHU.mjs';
 import '@orpc/client';
 import '@standard-server/core';
 import '../../shared/server.Djb_ebJT.mjs';
 import '@orpc/contract';
-import '../../shared/server.BYnwk7Xz.mjs';
-
-class CompositeFetchHandlerPlugin {
-  name = "~composite/fetch";
-  plugins;
-  constructor(plugins = []) {
-    this.plugins = sortPlugins(plugins);
-  }
-  initFetchHandlerOptions(options) {
-    for (const plugin of this.plugins) {
-      if (plugin.initFetchHandlerOptions) {
-        options = plugin.initFetchHandlerOptions(options);
-      }
-    }
-    return options;
-  }
-}
+import '../../shared/server.BynNaBBA.mjs';
 
 class FetchHandler {
   constructor(standardHandler, options = {}) {
     this.standardHandler = standardHandler;
-    options = new CompositeFetchHandlerPlugin(options.plugins).initFetchHandlerOptions(options);
-    this.fetchInterceptors = options.fetchInterceptors;
     this.toFetchResponseOptions = options.toFetchResponse;
   }
   toFetchResponseOptions;
-  fetchInterceptors;
   async handle(request, ...rest) {
-    return intercept(
-      this.fetchInterceptors,
-      {
-        ...resolveFriendlyStandardHandlerHandleOptions(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 standardRequest = toStandardLazyRequest(request);
+    const result = await this.standardHandler.handle(
+      standardRequest,
+      resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest))
     );
+    if (!result.matched) {
+      return result;
+    }
+    return {
+      matched: true,
+      response: toFetchResponse(result.response, this.toFetchResponseOptions)
+    };
   }
 }
 
@@ -65,4 +39,4 @@ class RPCHandler extends FetchHandler {
   }
 }
 
-export { CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
+export { FetchHandler, RPCHandler };

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

@@ -3,7 +3,7 @@ import { Value, Promisable, MaybeOptionalOptions } from '@orpc/shared';
 import { ServerPeer, EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standard-server/peer';
 import { Context } from '../../index.mjs';
 import { StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
-import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.mjs';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
 import { Router } from '../../index.mjs';
 import { RPCHandlerCodecOptions } from '../standard/index.mjs';
 import '@orpc/client';
@@ -44,13 +44,13 @@ declare class MessagePortHandler<T extends Context> {
      *
      * Prefer this over calling `.message()` and `.close()` manually.
      */
-    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
+    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
     /**
      * Handles a single message received from a message port.
      *
      * @param port The message port instance. Use the same instance for all messages.
      */
-    message(port: SupportedMessagePort, data: unknown, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(port: SupportedMessagePort, data: unknown, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**

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

@@ -3,7 +3,7 @@ import { Value, Promisable, MaybeOptionalOptions } from '@orpc/shared';
 import { ServerPeer, EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standard-server/peer';
 import { Context } from '../../index.js';
 import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
-import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.js';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
 import { Router } from '../../index.js';
 import { RPCHandlerCodecOptions } from '../standard/index.js';
 import '@orpc/client';
@@ -44,13 +44,13 @@ declare class MessagePortHandler<T extends Context> {
      *
      * Prefer this over calling `.message()` and `.close()` manually.
      */
-    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
+    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
     /**
      * Handles a single message received from a message port.
      *
      * @param port The message port instance. Use the same instance for all messages.
      */
-    message(port: SupportedMessagePort, data: unknown, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(port: SupportedMessagePort, data: unknown, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**

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

@@ -1,13 +1,14 @@
 import { onMessagePortMessage, onMessagePortClose, postMessagePortMessage } from '@orpc/client/message-port';
 import { value, resolveMaybeOptionalOptions } from '@orpc/shared';
 import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage, isPeerMessage } from '@standard-server/peer';
-import { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.sNWd6DAG.mjs';
+import { createStandardPeerRequestHandler } from '../standard-peer/index.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.C0lFtoHU.mjs';
+import '../../shared/server.W91HSRkE.mjs';
 import '@orpc/client';
 import '@standard-server/core';
 import '../../shared/server.Djb_ebJT.mjs';
 import '@orpc/contract';
-import '../../shared/server.BYnwk7Xz.mjs';
+import '../../shared/server.BynNaBBA.mjs';
 
 class MessagePortHandler {
   constructor(handler, options = {}) {

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

@@ -1,8 +1,8 @@
-export { R as BodyLimitPlugin } from '../../shared/server.CAiLRqPf.mjs';
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+export { R as BodyLimitPlugin } from '../../shared/server.C7xllBNN.mjs';
+import { MaybeOptionalOptions } from '@orpc/shared';
 import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standard-server/node';
 import { Context } from '../../index.mjs';
-import { StandardHandlerPlugin, StandardHandlerHandleOptions, StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
 import { Router } from '../../index.mjs';
 import { RPCHandlerCodecOptions } from '../standard/index.mjs';
@@ -10,68 +10,25 @@ import '@orpc/client';
 import '@orpc/contract';
 import '@standard-server/core';
 
-interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    /**
-     * Initializes the plugin and returns new node HTTP handler options.
-     * Called once per plugin instance during composition.
-     *
-     * This method allows plugins to wrap, extend, or transform node HTTP 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
-     * initNodeHttpHandlerOptions(options) {
-     *   return {
-     *     ...options,
-     *     nodeHttpInterceptors: [...(options.nodeHttpInterceptors || []), myInterceptor]
-     *   }
-     * }
-     * ```
-     */
-    initNodeHttpHandlerOptions?(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-declare class CompositeNodeHttpHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    readonly name = "~composite/node-http";
-    protected readonly plugins: NodeHttpHandlerPlugin<T>[];
-    constructor(plugins?: NodeHttpHandlerPlugin<T>[]);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-
 type NodeHttpHandlerHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-interface NodeHttpHandlerNodeHttpInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
-    request: NodeHttpRequest;
-    response: NodeHttpResponse;
-    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
-}
-type NodeHttpHandlerNodeHttpInterceptor<T extends Context> = Interceptor<NodeHttpHandlerNodeHttpInterceptorOptions<T>, Promise<NodeHttpHandlerHandleResult>>;
-interface NodeHttpHandlerOptions<T extends Context> {
+interface NodeHttpHandlerOptions<_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 Node HTTP API,
-     * useful for extending Node HTTP request/response before handling, ...
-     */
-    nodeHttpInterceptors?: NodeHttpHandlerNodeHttpInterceptor<T>[] | undefined;
-    plugins?: NodeHttpHandlerPlugin<T>[] | undefined;
 }
 declare class NodeHttpHandler<T extends Context> {
     private readonly standardHandler;
     private readonly sendStandardResponseOptions;
-    private readonly nodeHttpInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
     handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
 }
 
-interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
 }
 /**
  * Serves an oRPC router over the RPC protocol using Node.js built-in
@@ -83,5 +40,5 @@ declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
-export type { NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };
+export { NodeHttpHandler, RPCHandler };
+export type { NodeHttpHandlerHandleResult, NodeHttpHandlerOptions, RPCHandlerOptions };

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

@@ -1,8 +1,8 @@
-export { R as BodyLimitPlugin } from '../../shared/server.b2-J4t6T.js';
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+export { R as BodyLimitPlugin } from '../../shared/server.D0dr-F8u.js';
+import { MaybeOptionalOptions } from '@orpc/shared';
 import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standard-server/node';
 import { Context } from '../../index.js';
-import { StandardHandlerPlugin, StandardHandlerHandleOptions, StandardHandler, StandardHandlerOptions } from '../standard/index.js';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
 import { Router } from '../../index.js';
 import { RPCHandlerCodecOptions } from '../standard/index.js';
@@ -10,68 +10,25 @@ import '@orpc/client';
 import '@orpc/contract';
 import '@standard-server/core';
 
-interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    /**
-     * Initializes the plugin and returns new node HTTP handler options.
-     * Called once per plugin instance during composition.
-     *
-     * This method allows plugins to wrap, extend, or transform node HTTP 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
-     * initNodeHttpHandlerOptions(options) {
-     *   return {
-     *     ...options,
-     *     nodeHttpInterceptors: [...(options.nodeHttpInterceptors || []), myInterceptor]
-     *   }
-     * }
-     * ```
-     */
-    initNodeHttpHandlerOptions?(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-declare class CompositeNodeHttpHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    readonly name = "~composite/node-http";
-    protected readonly plugins: NodeHttpHandlerPlugin<T>[];
-    constructor(plugins?: NodeHttpHandlerPlugin<T>[]);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-
 type NodeHttpHandlerHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-interface NodeHttpHandlerNodeHttpInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
-    request: NodeHttpRequest;
-    response: NodeHttpResponse;
-    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
-}
-type NodeHttpHandlerNodeHttpInterceptor<T extends Context> = Interceptor<NodeHttpHandlerNodeHttpInterceptorOptions<T>, Promise<NodeHttpHandlerHandleResult>>;
-interface NodeHttpHandlerOptions<T extends Context> {
+interface NodeHttpHandlerOptions<_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 Node HTTP API,
-     * useful for extending Node HTTP request/response before handling, ...
-     */
-    nodeHttpInterceptors?: NodeHttpHandlerNodeHttpInterceptor<T>[] | undefined;
-    plugins?: NodeHttpHandlerPlugin<T>[] | undefined;
 }
 declare class NodeHttpHandler<T extends Context> {
     private readonly standardHandler;
     private readonly sendStandardResponseOptions;
-    private readonly nodeHttpInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
     handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
 }
 
-interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
 }
 /**
  * Serves an oRPC router over the RPC protocol using Node.js built-in
@@ -83,5 +40,5 @@ declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
-export type { NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };
+export { NodeHttpHandler, RPCHandler };
+export type { NodeHttpHandlerHandleResult, NodeHttpHandlerOptions, RPCHandlerOptions };