@orpc/server 2.0.0-beta.49 → 2.0.0-beta.50

package/dist/plugins/request-compression.js

@@ -1,82 +1,55 @@
-import { ORPCError } from '@orpc/client';
-import { toArray } from '@orpc/shared';
-import { flattenStandardHeader } from '@standard-server/core';
-import { toFetchHeaders, toStandardBody } from '@standard-server/fetch';
+import { isCompressionEncoding, parseContentEncodings, toArray } from "@orpc/shared";
+import { ORPCError } from "@orpc/client";
+import { flattenStandardHeader } from "@standard-server/core";
+import { toFetchHeaders, toStandardBody } from "@standard-server/fetch";
+// src/plugins/request-compression.ts
 /**
- * Each coding adds a decompressor to the chain, so an unbounded list lets a tiny
- * request cost unbounded CPU and memory. Same limit as undici and curl.
- */
+* Each coding adds a decompressor to the chain, so an unbounded list lets a tiny
+* request cost unbounded CPU and memory. Same limit as undici and curl.
+*/
 const MAX_CONTENT_ENCODINGS = 5;
 /**
- * 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 class RequestCompressionHandlerPlugin {
-    name = '~request-compression';
-    /**
-     * Should decompress the original batch request body instead of sub-requests.
-     */
-    after = ['~batch'];
-    init(options) {
-        // oxlint-disable-next-line unicorn/consistent-function-scoping
-        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');
-                        // adapter might not support hint (e.g peer adapter)
-                        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);
-}
-/**
- * Parse Content-Encoding into ordered codings (order applied).
- *
- * @see https://www.rfc-editor.org/rfc/rfc9110.html#name-content-encoding
- */
-function parseContentEncodings(header) {
-    if (header === undefined) {
-        return [];
-    }
-    return header.split(',').map((part) => part.trim().toLowerCase());
-}
+* 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}
+*/
+var RequestCompressionHandlerPlugin = class {
+	name = "~request-compression";
+	/**
+	* Should decompress the original batch request body instead of sub-requests.
+	*/
+	after = ["~batch"];
+	init(options) {
+		const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+			const encodings = parseContentEncodings(flattenStandardHeader(interceptorOptions.request.headers["content-encoding"]));
+			if (encodings.length === 0 || !encodings.every(isCompressionEncoding)) return next();
+			const decompressedHeaders = {
+				...interceptorOptions.request.headers,
+				"content-length": void 0,
+				"content-encoding": void 0
+			};
+			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)]
+		};
+	}
+};
+export { RequestCompressionHandlerPlugin };

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

@@ -1,14 +1,16 @@
-import type { StandardHandlerOptions, StandardHandlerPlugin } from '../adapters/standard/index.ts';
+import { StandardHandlerPlugin } from "../adapters/standard/plugin.js";
+import { StandardHandlerOptions } from "../adapters/standard/handler.js";
+import "../adapters/standard/index.js";
 /**
  * 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;
+  /**
+   * 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,
@@ -17,6 +19,6 @@ export interface RequestHeadersHandlerPluginContext {
  * @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>;
-}
+  name: string;
+  init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/request-headers.js

@@ -1,30 +1,28 @@
-import { toArray } from '@orpc/shared';
-import { toFetchHeaders } from '@standard-server/fetch';
+import { toArray } from "@orpc/shared";
+import { toFetchHeaders } from "@standard-server/fetch";
+// src/plugins/request-headers.ts
 /**
- * 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 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),
-            ],
-        };
-    }
-}
+* 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}
+*/
+var RequestHeadersHandlerPlugin = class {
+	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)]
+		};
+	}
+};
+export { RequestHeadersHandlerPlugin };

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

@@ -1,10 +1,12 @@
-import type { StandardHandlerOptions, StandardHandlerPlugin } from '../adapters/standard/index.ts';
-import type { Context } from '../context.ts';
+import "../adapters/standard/index.js";
+import { StandardHandlerPlugin } from "../adapters/standard/plugin.js";
+import { StandardHandlerOptions } from "../adapters/standard/handler.js";
+import { Context } from "../context.js";
 export interface RequestLimitHandlerPluginOptions {
-    /**
-     * The maximum allowed request body size in bytes.
-     */
-    maxBodySize: number;
+  /**
+   * The maximum allowed request body size in bytes.
+   */
+  maxBodySize: number;
 }
 /**
  * Rejects requests whose body exceeds `maxBodySize`.
@@ -15,16 +17,16 @@ export interface RequestLimitHandlerPluginOptions {
  * @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>;
-}
+  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.js

@@ -1,68 +1,61 @@
-import { ORPCError } from '@orpc/client';
-import { toArray } from '@orpc/shared';
-import { flattenStandardHeader } from '@standard-server/core';
-import { toFetchHeaders, toStandardBody } from '@standard-server/fetch';
+import { toArray } from "@orpc/shared";
+import { ORPCError } from "@orpc/client";
+import { flattenStandardHeader } from "@standard-server/core";
+import { toFetchHeaders, toStandardBody } from "@standard-server/fetch";
+// src/plugins/request-limit.ts
 /**
- * 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 class RequestLimitHandlerPlugin {
-    name = '~request-limit';
-    /**
-     * Should limit the original batch request body instead of sub-requests.
-     */
-    after = ['~batch'];
-    /**
-     * Should limit the final body size instead of the compressed one.
-     */
-    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');
-                        // adapter might not support hint (e.g. peer adapter)
-                        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)],
-        };
-    }
-}
+* 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}
+*/
+var RequestLimitHandlerPlugin = class {
+	name = "~request-limit";
+	/**
+	* Should limit the original batch request body instead of sub-requests.
+	*/
+	after = ["~batch"];
+	/**
+	* Should limit the final body size instead of the compressed one.
+	*/
+	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)]
+		};
+	}
+};
+export { RequestLimitHandlerPlugin };

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

@@ -1,31 +1,34 @@
-import type { StandardHeaders, StandardResponse } from '@standard-server/core';
-import type { StandardHandlerOptions, StandardHandlerPlugin, StandardHandlerRoutingInterceptorOptions } from '../adapters/standard/index.ts';
-import type { Context } from '../context.ts';
+import "../adapters/standard/index.js";
+import { StandardHandlerPlugin } from "../adapters/standard/plugin.js";
+import { StandardHandlerOptions, StandardHandlerRoutingInterceptorOptions } from "../adapters/standard/handler.js";
+import { Context } from "../context.js";
+import { CompressionEncoding } from "@orpc/shared";
+import { StandardHeaders, StandardResponse } from "@standard-server/core";
 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;
+  /**
+   * 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 CompressionEncoding[] | 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.
@@ -34,17 +37,17 @@ export interface ResponseCompressionHandlerPluginOptions<T extends Context> {
  * @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>;
+  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
@@ -56,4 +59,4 @@ export declare function negotiateResponseCompressionEncoding<TEncoding extends s
  * 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;
+export declare function toCompressedHeaders(headers: StandardHeaders, encoding: string): StandardHeaders;