@orpc/server 2.0.0-beta.47 → 2.0.0-beta.48

package/dist/plugins/method-override.d.mts

@@ -0,0 +1,38 @@
+import type { StandardMethod } from "@standard-server/core";
+import type { StandardHandlerOptions, StandardHandlerPlugin } from "../adapters/standard/index.mjs";
+import type { Context } from "../context.mjs";
+export interface MethodOverrideHandlerPluginOptions {
+	/**
+	* The query parameter carrying the override method.
+	*
+	* @default 'method'
+	*/
+	param?: string | undefined;
+	/**
+	* The methods a POST request may be overridden to.
+	*
+	* GET and HEAD are excluded by default because they switch input decoding
+	* from the request body to the query string and widen the CSRF surface.
+	*
+	* @default ['PUT', 'PATCH', 'DELETE']
+	*/
+	methods?: readonly StandardMethod[] | undefined;
+}
+/**
+* Overrides the HTTP method of a POST request based on a query parameter,
+* so HTML forms (which only support GET and POST) can invoke procedures
+* routed as PUT, PATCH, or DELETE.
+*
+* @see {@link https://orpc.dev/docs/plugins/method-override | Method Override Plugin}
+*/
+export declare class MethodOverrideHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+	name: string;
+	/**
+	* Should override batch sub-request methods, not the original batch request.
+	*/
+	before: string[];
+	private readonly param;
+	private readonly methods;
+	constructor(options?: MethodOverrideHandlerPluginOptions);
+	init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/method-override.mjs

@@ -0,0 +1,50 @@
+import { toArray } from "@orpc/shared";
+import { parseStandardUrl } from "@standard-server/core";
+
+export class MethodOverrideHandlerPlugin {
+	name = "~method-override";
+	
+	before = ["~batch"];
+	param;
+	methods;
+	constructor(options = {}) {
+		this.param = options.param ?? "method";
+		this.methods = new Set((options.methods ?? [
+			"PUT",
+			"PATCH",
+			"DELETE"
+		]).map((method) => method.toUpperCase()));
+	}
+	init(options) {
+		const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+			const { request } = interceptorOptions;
+			if (request.method !== "POST") {
+				return next();
+			}
+			const [pathname, search, hash] = parseStandardUrl(request.url);
+			const params = new URLSearchParams(search);
+			const raw = params.getAll(this.param).at(-1);
+			if (raw === undefined) {
+				return next();
+			}
+			const method = raw.toUpperCase();
+			if (!this.methods.has(method)) {
+				return next();
+			}
+			params.delete(this.param);
+			const url = `${pathname}${params.size ? `?${params}` : ""}${hash ?? ""}`;
+			return next({
+				...interceptorOptions,
+				request: {
+					...request,
+					method,
+					url
+				}
+			});
+		};
+		return {
+			...options,
+			routingInterceptors: [routingInterceptor, ...toArray(options.routingInterceptors)]
+		};
+	}
+}

package/dist/plugins/request-compression.d.mts

@@ -0,0 +1,16 @@
+import type { StandardHandlerOptions, StandardHandlerPlugin } from "../adapters/standard/index.mjs";
+import type { Context } from "../context.mjs";
+/**
+* Decompresses incoming request bodies based on the Content-Encoding header,
+* supporting gzip, deflate, and deflate-raw.
+*
+* @see {@link https://orpc.dev/docs/plugins/request-compression | Request Compression Plugin}
+*/
+export declare class RequestCompressionHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+	name: string;
+	/**
+	* Should decompress the original batch request body instead of sub-requests.
+	*/
+	after: string[];
+	init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/request-compression.mjs

@@ -0,0 +1,67 @@
+import { ORPCError } from "@orpc/client";
+import { toArray } from "@orpc/shared";
+import { flattenStandardHeader } from "@standard-server/core";
+import { toFetchHeaders, toStandardBody } from "@standard-server/fetch";
+
+const MAX_CONTENT_ENCODINGS = 5;
+
+export class RequestCompressionHandlerPlugin {
+	name = "~request-compression";
+	
+	after = ["~batch"];
+	init(options) {
+		const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+			const encodings = parseContentEncodings(flattenStandardHeader(interceptorOptions.request.headers["content-encoding"]));
+			if (encodings.length === 0 || !encodings.every(isSupportedEncoding)) {
+				return next();
+			}
+			const decompressedHeaders = {
+				...interceptorOptions.request.headers,
+				"content-length": undefined,
+				"content-encoding": undefined
+			};
+			return next({
+				...interceptorOptions,
+				request: {
+					...interceptorOptions.request,
+					headers: decompressedHeaders,
+					async resolveBody(hint) {
+						const stream = await interceptorOptions.request.resolveBody("octet-stream");
+						
+						if (!(stream instanceof ReadableStream)) {
+							return stream;
+						}
+						if (encodings.length > MAX_CONTENT_ENCODINGS) {
+							throw new ORPCError("UNSUPPORTED_MEDIA_TYPE", { message: "Too many content encodings." });
+						}
+						let decompressedStream = stream;
+						for (let i = encodings.length - 1; i >= 0; i--) {
+							decompressedStream = decompressedStream.pipeThrough(new DecompressionStream(encodings[i]));
+						}
+						const response = new Response(decompressedStream, { headers: toFetchHeaders(decompressedHeaders) });
+						return toStandardBody(response, { hint });
+					}
+				}
+			});
+		};
+		return {
+			...options,
+			routingInterceptors: [routingInterceptor, ...toArray(options.routingInterceptors)]
+		};
+	}
+}
+const SUPPORTED_ENCODINGS = [
+	"gzip",
+	"deflate",
+	"deflate-raw"
+];
+function isSupportedEncoding(encoding) {
+	return SUPPORTED_ENCODINGS.includes(encoding);
+}
+
+function parseContentEncodings(header) {
+	if (header === undefined) {
+		return [];
+	}
+	return header.split(",").map((part) => part.trim().toLowerCase());
+}

package/dist/plugins/request-headers.d.mts

@@ -0,0 +1,22 @@
+import type { StandardHandlerOptions, StandardHandlerPlugin } from "../adapters/standard/index.mjs";
+/**
+* The context shape into which the Request Headers Plugin injects `reqHeaders`.
+*
+* @see {@link https://orpc.dev/docs/plugins/request-headers | Request Headers Plugin}
+*/
+export interface RequestHeadersHandlerPluginContext {
+	/**
+	* Request headers as a Headers instance. This is injected by the Request Headers Plugin.
+	*/
+	reqHeaders?: Headers | undefined;
+}
+/**
+* The Request Headers Plugin injects a `reqHeaders` instance into the context,
+* allowing access to request headers in oRPC.
+*
+* @see {@link https://orpc.dev/docs/plugins/request-headers | Request Headers Plugin}
+*/
+export declare class RequestHeadersHandlerPlugin<T extends RequestHeadersHandlerPluginContext> implements StandardHandlerPlugin<T> {
+	name: string;
+	init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/request-headers.mjs

@@ -0,0 +1,21 @@
+import { toArray } from "@orpc/shared";
+import { toFetchHeaders } from "@standard-server/fetch";
+
+export class RequestHeadersHandlerPlugin {
+	name = "~request-headers";
+	init(options) {
+		return {
+			...options,
+			interceptors: [(interceptorOptions) => {
+				const reqHeaders = interceptorOptions.context.reqHeaders ?? toFetchHeaders(interceptorOptions.request.headers);
+				return interceptorOptions.next({
+					...interceptorOptions,
+					context: {
+						...interceptorOptions.context,
+						reqHeaders
+					}
+				});
+			}, ...toArray(options.interceptors)]
+		};
+	}
+}

package/dist/plugins/request-limit.d.mts

@@ -0,0 +1,30 @@
+import type { StandardHandlerOptions, StandardHandlerPlugin } from "../adapters/standard/index.mjs";
+import type { Context } from "../context.mjs";
+export interface RequestLimitHandlerPluginOptions {
+	/**
+	* The maximum allowed request body size in bytes.
+	*/
+	maxBodySize: number;
+}
+/**
+* Rejects requests whose body exceeds `maxBodySize`.
+*
+* When used with the request compression plugin, the limit applies to the
+* decompressed payload rather than the compressed wire size.
+*
+* @see {@link https://orpc.dev/docs/plugins/request-limit | Request Limit Plugin}
+*/
+export declare class RequestLimitHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+	name: string;
+	/**
+	* Should limit the original batch request body instead of sub-requests.
+	*/
+	after: string[];
+	/**
+	* Should limit the final body size instead of the compressed one.
+	*/
+	before: string[];
+	private readonly maxBodySize;
+	constructor(options: RequestLimitHandlerPluginOptions);
+	init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/request-limit.mjs

@@ -0,0 +1,53 @@
+import { ORPCError } from "@orpc/client";
+import { toArray } from "@orpc/shared";
+import { flattenStandardHeader } from "@standard-server/core";
+import { toFetchHeaders, toStandardBody } from "@standard-server/fetch";
+
+export class RequestLimitHandlerPlugin {
+	name = "~request-limit";
+	
+	after = ["~batch"];
+	
+	before = ["~request-compression"];
+	maxBodySize;
+	constructor(options) {
+		this.maxBodySize = options.maxBodySize;
+	}
+	init(options) {
+		const maxBodySize = this.maxBodySize;
+		const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+			return next({
+				...interceptorOptions,
+				request: {
+					...interceptorOptions.request,
+					async resolveBody(hint) {
+						const contentLength = Number(flattenStandardHeader(interceptorOptions.request.headers["content-length"]));
+						if (Number.isFinite(contentLength) && contentLength > maxBodySize) {
+							throw new ORPCError("PAYLOAD_TOO_LARGE");
+						}
+						const stream = await interceptorOptions.request.resolveBody("octet-stream");
+						
+						if (!(stream instanceof ReadableStream)) {
+							return stream;
+						}
+						let currentBodySize = 0;
+						const limitedStream = stream.pipeThrough(new TransformStream({ transform(chunk, controller) {
+							currentBodySize += chunk.byteLength;
+							if (currentBodySize > maxBodySize) {
+								controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
+								return;
+							}
+							controller.enqueue(chunk);
+						} }));
+						const response = new Response(limitedStream, { headers: toFetchHeaders(interceptorOptions.request.headers) });
+						return toStandardBody(response, { hint });
+					}
+				}
+			});
+		};
+		return {
+			...options,
+			routingInterceptors: [routingInterceptor, ...toArray(options.routingInterceptors)]
+		};
+	}
+}

package/dist/plugins/response-compression.d.mts

@@ -0,0 +1,59 @@
+import type { StandardHeaders, StandardResponse } from "@standard-server/core";
+import type { StandardHandlerOptions, StandardHandlerPlugin, StandardHandlerRoutingInterceptorOptions } from "../adapters/standard/index.mjs";
+import type { Context } from "../context.mjs";
+export interface ResponseCompressionHandlerPluginOptions<T extends Context> {
+	/**
+	* 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 (via Accept-Encoding).
+	*
+	* @default ['gzip', 'deflate']
+	*/
+	encodings?: readonly ("gzip" | "deflate" | "deflate-raw")[] | undefined;
+	/**
+	* 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 | undefined;
+	/**
+	* Determines whether a response with the given Content-Type should be compressed.
+	* Only consulted for binary transfers (streams, files, and file form-data parts).
+	* Also receives the routing interceptor options for per-request decisions.
+	*
+	* @default isCompressibleContentType (covers common text-based formats)
+	*/
+	isCompressibleContentType?: ((contentType: string | null | undefined, options: StandardHandlerRoutingInterceptorOptions<T>) => boolean) | undefined;
+}
+/**
+* Compresses response bodies based on the client's Accept-Encoding header.
+* Works at the standard handler level, so it supports all adapters.
+*
+* @see {@link https://orpc.dev/docs/plugins/response-compression | Response Compression Plugin}
+*/
+export declare class ResponseCompressionHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+	name: string;
+	/**
+	* Compression should be done after batching, to compress the final response.
+	* Compression should also be done after response headers are set, to access final headers like Content-Type and Cache-Control.
+	*/
+	after: string[];
+	private readonly encodings;
+	private readonly threshold;
+	private readonly isCompressibleContentType;
+	constructor(options?: ResponseCompressionHandlerPluginOptions<T>);
+	init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}
+/**
+* Picks the first of `encodings` the client accepts, or `undefined` when the response
+* must be sent as is because it is already encoded, partial, or forbids transforms.
+* Shared by the response compression plugins so they agree on when to compress.
+*/
+export declare function negotiateResponseCompressionEncoding<TEncoding extends string>(response: StandardResponse, requestHeaders: StandardHeaders, encodings: readonly TEncoding[]): TEncoding | undefined;
+/**
+* The headers of a response whose body is compressed with `encoding`.
+* Shared by the response compression plugins so compressed responses carry the same headers.
+*/
+export declare function toCompressedHeaders(headers: StandardHeaders, encoding: string): StandardHeaders;

package/dist/plugins/response-compression.mjs

@@ -0,0 +1,172 @@
+import { isAcceptableEncoding, isAsyncIteratorObject, isCompressibleContentType, isNoTransformCacheControl, parseAcceptEncodingQualities, toArray, varyByAcceptEncoding } from "@orpc/shared";
+import { flattenStandardHeader, generateContentDisposition } from "@standard-server/core";
+import { toFetchBody } from "@standard-server/fetch";
+
+
+const AVG_BYTES_PER_CHAR = 1.2;
+
+export class ResponseCompressionHandlerPlugin {
+	name = "~response-compression";
+	
+	after = ["~batch", "~response-headers"];
+	encodings;
+	threshold;
+	isCompressibleContentType;
+	constructor(options = {}) {
+		this.encodings = options.encodings ?? ["gzip", "deflate"];
+		this.threshold = options.threshold ?? 1024;
+		this.isCompressibleContentType = options.isCompressibleContentType ?? isCompressibleContentType;
+	}
+	init(options) {
+		const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+			const result = await next();
+			if (!result.matched) {
+				return result;
+			}
+			const response = result.response;
+			const encoding = negotiateResponseCompressionEncoding(response, interceptorOptions.request.headers, this.encodings);
+			if (encoding === undefined) {
+				return result;
+			}
+			const body = response.body;
+			const headers = response.headers;
+			if (body instanceof ReadableStream) {
+				const contentLength = Number(flattenStandardHeader(headers["content-length"]));
+				if ((!Number.isFinite(contentLength) || contentLength >= this.threshold) && this.isCompressibleContentType(flattenStandardHeader(headers["content-type"]), interceptorOptions)) {
+					return {
+						...result,
+						response: {
+							...response,
+							body: body.pipeThrough(new CompressionStream(encoding)),
+							headers: toCompressedHeaders(headers, encoding)
+						}
+					};
+				}
+			} else if (body instanceof Blob) {
+				
+				const contentType = headers["content-type"] ?? body.type;
+				if ((!Number.isFinite(body.size) || body.size >= this.threshold) && this.isCompressibleContentType(flattenStandardHeader(contentType), interceptorOptions)) {
+					const contentDisposition = headers["content-disposition"] ?? generateContentDisposition(body instanceof File ? body.name : "blob");
+					return {
+						...result,
+						response: {
+							...response,
+							body: body.stream().pipeThrough(new CompressionStream(encoding)),
+							headers: {
+								...toCompressedHeaders(headers, encoding),
+								"standard-server": headers["standard-server"] ?? "file",
+								"content-type": contentType,
+								"content-disposition": contentDisposition
+							}
+						}
+					};
+				}
+			} else if (body instanceof FormData) {
+				const PART_OVERHEAD = 64;
+				let contentLength = 0;
+				for (const [key, value] of body) {
+					contentLength += PART_OVERHEAD + key.length;
+					if (value instanceof Blob) {
+						if (!Number.isFinite(value.size)) {
+							if (!this.isCompressibleContentType(value.type, interceptorOptions)) {
+								
+								contentLength = -Infinity;
+								break;
+							}
+							
+							contentLength = Infinity;
+						} else {
+							contentLength += this.isCompressibleContentType(value.type, interceptorOptions) ? value.size : -value.size;
+						}
+					} else {
+						contentLength += value.length * AVG_BYTES_PER_CHAR;
+					}
+				}
+				if (contentLength >= this.threshold) {
+					const res = new Response(body);
+					const compressedStream = res.body.pipeThrough(new CompressionStream(encoding));
+					return {
+						...result,
+						response: {
+							...response,
+							body: compressedStream,
+							headers: {
+								...toCompressedHeaders(headers, encoding),
+								"standard-server": [],
+								"content-type": res.headers.get("content-type")
+							}
+						}
+					};
+				}
+			} else if (body instanceof URLSearchParams) {
+				const string = body.toString();
+				if (string.length * AVG_BYTES_PER_CHAR >= this.threshold) {
+					const [, bodyHeaders] = toFetchBody(body, headers);
+					return {
+						...result,
+						response: {
+							...response,
+							body: new Blob([string]).stream().pipeThrough(new CompressionStream(encoding)),
+							headers: {
+								...toCompressedHeaders(bodyHeaders, encoding),
+								
+								"standard-server": bodyHeaders["standard-server"] ?? []
+							}
+						}
+					};
+				}
+			} else if (body !== undefined && !isAsyncIteratorObject(body)) {
+				const [string, bodyHeaders] = toFetchBody(body, headers);
+				if (string.length * AVG_BYTES_PER_CHAR >= this.threshold) {
+					return {
+						...result,
+						response: {
+							...response,
+							body: new Blob([string]).stream().pipeThrough(new CompressionStream(encoding)),
+							headers: {
+								...toCompressedHeaders(bodyHeaders, encoding),
+								"standard-server": bodyHeaders["standard-server"] ?? []
+							}
+						}
+					};
+				}
+			}
+			return result;
+		};
+		return {
+			...options,
+			routingInterceptors: [routingInterceptor, ...toArray(options.routingInterceptors)]
+		};
+	}
+}
+
+export function negotiateResponseCompressionEncoding(response, requestHeaders, encodings) {
+	if (flattenStandardHeader(response.headers["content-encoding"]) !== undefined) {
+		return undefined;
+	}
+	
+	if (response.status === 206 || flattenStandardHeader(response.headers["content-range"]) !== undefined) {
+		return undefined;
+	}
+	
+	if (isNoTransformCacheControl(flattenStandardHeader(response.headers["cache-control"]))) {
+		return undefined;
+	}
+	const acceptEncodings = parseAcceptEncodingQualities(flattenStandardHeader(requestHeaders["accept-encoding"]));
+	return encodings.find((encoding) => isAcceptableEncoding(acceptEncodings, encoding));
+}
+
+export function toCompressedHeaders(headers, encoding) {
+	return {
+		...headers,
+		"content-length": [],
+		"content-encoding": encoding,
+		"vary": varyByAcceptEncoding(flattenStandardHeader(headers.vary)),
+		
+		"etag": weakenEtag(flattenStandardHeader(headers.etag)),
+		"accept-ranges": []
+	};
+}
+function weakenEtag(etag) {
+	return etag === undefined || etag.startsWith("W/") ? etag : `W/${etag}`;
+}

package/dist/plugins/response-headers.d.mts

@@ -0,0 +1,30 @@
+import type { StandardHandlerOptions, StandardHandlerPlugin } from "../adapters/standard/index.mjs";
+/**
+* The context shape into which the Response Headers Plugin injects `resHeaders`.
+*
+* @see {@link https://orpc.dev/docs/plugins/response-headers | Response Headers Plugin}
+*/
+export interface ResponseHeadersHandlerPluginContext {
+	/**
+	* Response headers as a Headers instance. This is injected by the Response Headers Plugin.
+	* When set before the response is sent, these headers will be included in the response. If not set, no additional headers will be added.
+	*/
+	resHeaders?: Headers | undefined;
+}
+/**
+* The Response Headers Plugin allows you to set response headers in oRPC.
+* It injects a resHeaders instance into the context, enabling you to modify response headers easily.
+*
+* @remarks
+* **Warning**: In a `streaming` batch, only the cookies of the first procedure to respond reach the client.
+*
+* @see {@link https://orpc.dev/docs/plugins/response-headers | Response Headers Plugin}
+*/
+export declare class ResponseHeadersHandlerPlugin<T extends ResponseHeadersHandlerPluginContext> implements StandardHandlerPlugin<T> {
+	name: string;
+	/**
+	* Interceptors should run after batch interceptors so headers are applied to each sub-response.
+	*/
+	before: string[];
+	init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/response-headers.mjs

@@ -0,0 +1,34 @@
+import { toArray } from "@orpc/shared";
+import { mergeStandardHeaders } from "@standard-server/core";
+import { toStandardHeaders } from "@standard-server/fetch";
+
+export class ResponseHeadersHandlerPlugin {
+	name = "~response-headers";
+	
+	before = ["~batch"];
+	init(options) {
+		return {
+			...options,
+			routingInterceptors: [async (interceptorOptions) => {
+				const resHeaders = new Headers(interceptorOptions.context.resHeaders);
+				const result = await interceptorOptions.next({
+					...interceptorOptions,
+					context: {
+						...interceptorOptions.context,
+						resHeaders
+					}
+				});
+				if (!result.response) {
+					return result;
+				}
+				return {
+					...result,
+					response: {
+						...result.response,
+						headers: mergeStandardHeaders(result.response.headers, toStandardHeaders(resHeaders))
+					}
+				};
+			}, ...toArray(options.routingInterceptors)]
+		};
+	}
+}

package/dist/plugins/rethrow.d.mts

@@ -0,0 +1,33 @@
+import type { ThrowableError } from "@orpc/shared";
+import type { StandardHandlerInterceptorOptions, StandardHandlerOptions, StandardHandlerPlugin } from "../adapters/standard/index.mjs";
+import type { Context } from "../context.mjs";
+export interface RethrowHandlerPluginOptions<T extends Context> {
+	/**
+	* Decide which errors should be rethrown.
+	*
+	* @example
+	* ```ts
+	* const rethrowPlugin = new RethrowHandlerPlugin({
+	*   filter: (error) => {
+	*     // Rethrow all non-ORPCError errors
+	*     return !(error instanceof ORPCError)
+	*   }
+	* })
+	* ```
+	*/
+	filter: (error: ThrowableError, options: StandardHandlerInterceptorOptions<T>) => boolean;
+}
+/**
+* The plugin can bypass oRPC's built-in error handling
+* and rethrow matching errors directly to your framework's error handling mechanism
+* (e.g., NestJS exception filters, Express error middleware).
+*
+* @see {@link https://orpc.dev/docs/plugins/rethrow | Rethrow Handler Plugin}
+*/
+export declare class RethrowHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+	name: string;
+	private readonly filter;
+	private readonly CONTEXT_SYMBOL;
+	constructor(options: RethrowHandlerPluginOptions<T>);
+	init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/rethrow.mjs

@@ -0,0 +1,46 @@
+import { toArray } from "@orpc/shared";
+
+export class RethrowHandlerPlugin {
+	name = "~rethrow";
+	filter;
+	CONTEXT_SYMBOL = Symbol("ORPC_RETHROW_HANDLER_PLUGIN_CONTEXT");
+	constructor(options) {
+		this.filter = options.filter;
+	}
+	init(options) {
+		const routingInterceptor = async (options) => {
+			const pluginContext = {};
+			const result = await options.next({
+				...options,
+				context: {
+					...options.context,
+					[this.CONTEXT_SYMBOL]: pluginContext
+				}
+			});
+			if (pluginContext.error) {
+				throw pluginContext.error.value;
+			}
+			return result;
+		};
+		const interceptor = async (options) => {
+			const pluginContext = options.context[this.CONTEXT_SYMBOL];
+			if (!pluginContext) {
+				throw new TypeError("[RethrowHandlerPlugin] Rethrow handler context has been corrupted or modified by another plugin or interceptor");
+			}
+			try {
+				
+				return await options.next();
+			} catch (error) {
+				if (this.filter(error, options)) {
+					pluginContext.error = { value: error };
+				}
+				throw error;
+			}
+		};
+		return {
+			...options,
+			routingInterceptors: [...toArray(options.routingInterceptors), routingInterceptor],
+			interceptors: [interceptor, ...toArray(options.interceptors)]
+		};
+	}
+}