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

package/dist/plugins/response-compression.js

@@ -1,209 +1,157 @@
-import { isAcceptableEncoding, isAsyncIteratorObject, isCompressibleContentType, isNoTransformCacheControl, parseAcceptEncodingQualities, toArray, varyByAcceptEncoding, } from '@orpc/shared';
-import { flattenStandardHeader, generateContentDisposition } from '@standard-server/core';
-import { toFetchBody } from '@standard-server/fetch';
-// Rough UTF-8 estimate. Mostly ASCII text stays close to 1 byte/char;
-// occasional multi-byte characters increase the average.
-const AVG_BYTES_PER_CHAR = 1.2;
+import { estimateCompressibleFormDataSize, estimateUtf8ByteLength, isAcceptableEncoding, isAsyncIteratorObject, isCompressibleContentType, isNoTransformCacheControl, parseAcceptEncodingQualities, toArray, varyByAcceptEncoding } from "@orpc/shared";
+import { flattenStandardHeader, generateContentDisposition } from "@standard-server/core";
+import { toFetchBody } from "@standard-server/fetch";
+// src/plugins/response-compression.ts
 /**
- * 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 class ResponseCompressionHandlerPlugin {
-    name = '~response-compression';
-    /**
-     * 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 = ['~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) {
-                // Adapters only fall back to the blob type when no Content-Type header is set
-                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; // approx bytes for boundary + Content-Disposition/Content-Type headers per part
-                let contentLength = 0;
-                for (const [key, value] of body) {
-                    contentLength += PART_OVERHEAD + key.length;
-                    if (value instanceof Blob) {
-                        if (!Number.isFinite(value.size)) {
-                            // Bun-s3 can use NaN for size
-                            if (!this.isCompressibleContentType(value.type, interceptorOptions)) {
-                                // Unknown non-compressible part size makes the estimate unreliable
-                                contentLength = -Infinity;
-                                break;
-                            }
-                            // Unknown size for compressible content - still apply compression
-                            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),
-                                // An empty hint rather than none, so the adapter does not hint the compressed stream as `octet-stream`
-                                '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)],
-        };
-    }
-}
+* 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}
+*/
+var ResponseCompressionHandlerPlugin = class {
+	name = "~response-compression";
+	/**
+	* 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 = ["~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 === void 0) 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) {
+				if (estimateCompressibleFormDataSize(body, (contentType) => this.isCompressibleContentType(contentType, interceptorOptions)) >= 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 (estimateUtf8ByteLength(string) >= 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 !== void 0 && !isAsyncIteratorObject(body)) {
+				const [string, bodyHeaders] = toFetchBody(body, headers);
+				if (estimateUtf8ByteLength(string) >= 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)]
+		};
+	}
+};
 /**
- * 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 function negotiateResponseCompressionEncoding(response, requestHeaders, encodings) {
-    if (flattenStandardHeader(response.headers['content-encoding']) !== undefined) {
-        // already compressed, do not compress again
-        return undefined;
-    }
-    /**
-     * A partial response body is a byte range of the identity representation, so compressing it
-     * would leave `Content-Range` describing offsets the client never receives.
-     */
-    if (response.status === 206 ||
-        flattenStandardHeader(response.headers['content-range']) !== undefined) {
-        return undefined;
-    }
-    // Cache-Control: no-transform forbids intermediaries (and these plugins) from transforming the body
-    if (isNoTransformCacheControl(flattenStandardHeader(response.headers['cache-control']))) {
-        return undefined;
-    }
-    const acceptEncodings = parseAcceptEncodingQualities(flattenStandardHeader(requestHeaders['accept-encoding']));
-    return encodings.find((encoding) => isAcceptableEncoding(acceptEncodings, encoding));
+* 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.
+*/
+function negotiateResponseCompressionEncoding(response, requestHeaders, encodings) {
+	if (flattenStandardHeader(response.headers["content-encoding"]) !== void 0) return;
+	/**
+	* A partial response body is a byte range of the identity representation, so compressing it
+	* would leave `Content-Range` describing offsets the client never receives.
+	*/
+	if (response.status === 206 || flattenStandardHeader(response.headers["content-range"]) !== void 0) return;
+	if (isNoTransformCacheControl(flattenStandardHeader(response.headers["cache-control"]))) return;
+	const acceptEncodings = parseAcceptEncodingQualities(flattenStandardHeader(requestHeaders["accept-encoding"]));
+	return encodings.find((encoding) => isAcceptableEncoding(acceptEncodings, encoding));
 }
 /**
- * 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 function toCompressedHeaders(headers, encoding) {
-    return {
-        ...headers,
-        'content-length': [],
-        'content-encoding': encoding,
-        'vary': varyByAcceptEncoding(flattenStandardHeader(headers.vary)),
-        /**
-         * A strong tag shared with the identity bytes would let `If-Range` splice them after compressed ones.
-         * A weak tag still revalidates through `If-None-Match`, and the compressed body serves no ranges.
-         *
-         * @see https://www.rfc-editor.org/rfc/rfc9110.html#name-etag
-         */
-        'etag': weakenEtag(flattenStandardHeader(headers.etag)),
-        'accept-ranges': [],
-    };
+* The headers of a response whose body is compressed with `encoding`.
+* Shared by the response compression plugins so compressed responses carry the same headers.
+*/
+function toCompressedHeaders(headers, encoding) {
+	return {
+		...headers,
+		"content-length": [],
+		"content-encoding": encoding,
+		"vary": varyByAcceptEncoding(flattenStandardHeader(headers.vary)),
+		/**
+		* A strong tag shared with the identity bytes would let `If-Range` splice them after compressed ones.
+		* A weak tag still revalidates through `If-None-Match`, and the compressed body serves no ranges.
+		*
+		* @see https://www.rfc-editor.org/rfc/rfc9110.html#name-etag
+		*/
+		"etag": weakenEtag(flattenStandardHeader(headers.etag)),
+		"accept-ranges": []
+	};
 }
 function weakenEtag(etag) {
-    return etag === undefined || etag.startsWith('W/') ? etag : `W/${etag}`;
+	return etag === void 0 || etag.startsWith("W/") ? etag : `W/${etag}`;
 }
+export { ResponseCompressionHandlerPlugin, negotiateResponseCompressionEncoding, toCompressedHeaders };

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

@@ -1,15 +1,17 @@
-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 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;
+  /**
+   * 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.
@@ -21,10 +23,10 @@ export interface ResponseHeadersHandlerPluginContext {
  * @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>;
-}
+  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.js

@@ -1,47 +1,44 @@
-import { toArray } from '@orpc/shared';
-import { mergeStandardHeaders } from '@standard-server/core';
-import { toStandardHeaders } from '@standard-server/fetch';
+import { toArray } from "@orpc/shared";
+import { mergeStandardHeaders } from "@standard-server/core";
+import { toStandardHeaders } from "@standard-server/fetch";
+// src/plugins/response-headers.ts
 /**
- * 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 class ResponseHeadersHandlerPlugin {
-    name = '~response-headers';
-    /**
-     * Interceptors should run after batch interceptors so headers are applied to each sub-response.
-     */
-    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),
-            ],
-        };
-    }
-}
+* 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}
+*/
+var ResponseHeadersHandlerPlugin = class {
+	name = "~response-headers";
+	/**
+	* Interceptors should run after batch interceptors so headers are applied to each sub-response.
+	*/
+	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)]
+		};
+	}
+};
+export { ResponseHeadersHandlerPlugin };

package/dist/plugins/rethrow.d.ts

@@ -1,21 +1,23 @@
-import type { ThrowableError } from '@orpc/shared';
-import type { StandardHandlerInterceptorOptions, 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 { StandardHandlerInterceptorOptions, StandardHandlerOptions } from "../adapters/standard/handler.js";
+import { Context } from "../context.js";
+import { ThrowableError } from "@orpc/shared";
 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;
+  /**
+   * 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
@@ -25,9 +27,9 @@ export interface RethrowHandlerPluginOptions<T extends Context> {
  * @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>;
-}
+  name: string;
+  private readonly filter;
+  private readonly CONTEXT_SYMBOL;
+  constructor(options: RethrowHandlerPluginOptions<T>);
+  init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}