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

package/dist/plugins/response-compression.mjs

@@ -1,172 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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)]
-		};
-	}
-}

package/dist/plugins/signal-sync.d.mts

@@ -1,13 +0,0 @@
-import type { StandardHandlerOptions, StandardHandlerPlugin } from "../adapters/standard/index.mjs";
-import type { Context } from "../context.mjs";
-/**
-* Keeps the request signal and a streaming output (async iterator object or readable stream) in sync:
-* cancelling the output aborts the signal with an `AbortError`,
-* and aborting the signal ends the output with the abort reason and cancels it.
-*
-* @see {@link https://orpc.dev/docs/plugins/signal-sync | Signal Sync Plugin}
-*/
-export declare class SignalSyncHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-	name: string;
-	init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}

package/dist/plugins/signal-sync.mjs

@@ -1,84 +0,0 @@
-import { AbortError, anyAbortSignal, AsyncIteratorClass, isAsyncIteratorObject, override, runWithSignal, toArray } from "@orpc/shared";
-
-export class SignalSyncHandlerPlugin {
-	name = "~signal-sync";
-	init(options) {
-		const clientInterceptor = async (interceptorOptions) => {
-			const controller = new AbortController();
-			const signal = anyAbortSignal([interceptorOptions.signal, controller.signal]);
-			const cancel = () => controller.abort(new AbortError("The response body was cancelled"));
-			const output = await interceptorOptions.next({
-				...interceptorOptions,
-				signal
-			});
-			if (isAsyncIteratorObject(output)) {
-				return override(output, syncAsyncIterator(output, signal, cancel));
-			}
-			if (output instanceof ReadableStream) {
-				return override(output, syncReadableStream(output, signal, cancel));
-			}
-			return output;
-		};
-		return {
-			...options,
-			clientInterceptors: [clientInterceptor, ...toArray(options.clientInterceptors)]
-		};
-	}
-}
-function listenAbort(signal, onAbort) {
-	if (signal.aborted) {
-		onAbort();
-	} else {
-		signal.addEventListener("abort", onAbort, { once: true });
-	}
-	return () => signal.removeEventListener("abort", onAbort);
-}
-function syncAsyncIterator(iterator, signal, cancel) {
-	let cancelling;
-	const unlisten = listenAbort(signal, () => {
-		cancelling = (async () => iterator.return?.())();
-		cancelling.catch(() => {});
-	});
-	return new AsyncIteratorClass(() => runWithSignal(signal, () => iterator.next()), async ({ kind }) => {
-		if (kind === "cancelled") {
-			cancel();
-			await cancelling;
-		}
-		unlisten();
-	});
-}
-function syncReadableStream(stream, signal, cancel) {
-	const reader = stream.getReader();
-	let cancelling;
-	let unlisten;
-	return new ReadableStream({
-		start(controller) {
-			unlisten = listenAbort(signal, () => {
-				controller.error(signal.reason);
-				cancelling = reader.cancel(signal.reason);
-				cancelling.catch(() => {});
-			});
-		},
-		async pull(controller) {
-			try {
-				const { done, value } = await reader.read();
-				if (signal.aborted) {
-					return;
-				}
-				if (done) {
-					unlisten();
-					controller.close();
-				} else {
-					controller.enqueue(value);
-				}
-			} catch (error) {
-				unlisten();
-				throw error;
-			}
-		},
-		async cancel() {
-			cancel();
-			await cancelling;
-		}
-	}, { highWaterMark: 0 });
-}

package/dist/plugins/timeout.d.mts

@@ -1,37 +0,0 @@
-import type { Value } from "@orpc/shared";
-import type { StandardHandlerInterceptorOptions, StandardHandlerOptions, StandardHandlerPlugin } from "../adapters/standard/index.mjs";
-import type { Context } from "../context.mjs";
-export interface TimeoutHandlerPluginOptions<T extends Context> {
-	/**
-	* Timeout in milliseconds before the request signal is aborted.
-	* This only covers producing the response, use `streamingTimeout`
-	* to limit streaming response bodies.
-	* Use `null` or `undefined` to disable the timeout.
-	*/
-	timeout: Value<number | null | undefined, [options: StandardHandlerInterceptorOptions<T>]>;
-	/**
-	* Timeout in milliseconds for the full duration of a streaming response body
-	* (async iterator object or readable stream), measured from when the response is produced.
-	* When exceeded, the request signal is aborted and the body ends
-	* once its producer honors the signal.
-	* Usually higher than `timeout`.
-	* Use `null` or `undefined` to disable the timeout.
-	*
-	* @default undefined (streaming responses run without limit)
-	*/
-	streamingTimeout?: Value<number | null | undefined, [options: StandardHandlerInterceptorOptions<T>]> | undefined;
-}
-/**
-* The Timeout Handler Plugin aborts the request signal with an `AbortError`
-* when handling exceeds a configured timeout. It only aborts the signal,
-* the procedure must honor it to stop early and produce the response.
-*
-* @see {@link https://orpc.dev/docs/plugins/timeout | Timeout Plugin}
-*/
-export declare class TimeoutHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-	private readonly timeout;
-	private readonly streamingTimeout;
-	name: string;
-	constructor(options: NoInfer<TimeoutHandlerPluginOptions<T>>);
-	init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}

package/dist/plugins/timeout.mjs

@@ -1,56 +0,0 @@
-import { AbortError, anyAbortSignal, isAsyncIteratorObject, override, toArray, value, wrapAsyncIterator, wrapReadableStream } from "@orpc/shared";
-
-export class TimeoutHandlerPlugin {
-	timeout;
-	streamingTimeout;
-	name = "~timeout";
-	constructor(options) {
-		this.timeout = options.timeout;
-		this.streamingTimeout = options.streamingTimeout;
-	}
-	init(options) {
-		const interceptor = async (interceptorOptions) => {
-			const timeoutMs = value(this.timeout, interceptorOptions);
-			const streamingTimeoutMs = value(this.streamingTimeout, interceptorOptions);
-			const hasTimeout = timeoutMs !== null && timeoutMs !== undefined;
-			const hasStreamingTimeout = streamingTimeoutMs !== null && streamingTimeoutMs !== undefined;
-			if (!hasTimeout && !hasStreamingTimeout) {
-				return interceptorOptions.next();
-			}
-			const controller = new AbortController();
-			const abortWithTimeout = (ms) => {
-				controller.abort(new AbortError(`Request timed out after ${ms}ms`));
-			};
-			const timeoutId = hasTimeout ? setTimeout(abortWithTimeout, timeoutMs, timeoutMs) : undefined;
-			const signal = anyAbortSignal([interceptorOptions.request.signal, controller.signal]);
-			try {
-				const response = await interceptorOptions.next({
-					...interceptorOptions,
-					request: {
-						...interceptorOptions.request,
-						signal
-					}
-				});
-				if (hasStreamingTimeout) {
-					const body = response.body;
-					const isIterator = isAsyncIteratorObject(body);
-					if (isIterator || body instanceof ReadableStream) {
-						const streamingTimeoutId = setTimeout(abortWithTimeout, streamingTimeoutMs, streamingTimeoutMs);
-						const onFinish = () => clearTimeout(streamingTimeoutId);
-						return {
-							...response,
-							body: isIterator ? override(body, wrapAsyncIterator(body, { onFinish })) : override(body, wrapReadableStream(body, { onFinish }))
-						};
-					}
-				}
-				return response;
-			} finally {
-				clearTimeout(timeoutId);
-			}
-		};
-		return {
-			...options,
-			interceptors: [interceptor, ...toArray(options.interceptors)]
-		};
-	}
-}

package/dist/procedure-client.d.mts

@@ -1,41 +0,0 @@
-import type { Client, ClientContext } from "@orpc/client";
-import type { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, ORPCErrorConstructorMap, ORPCErrorFromErrorMap } from "@orpc/contract";
-import type { Interceptor, MaybeOptionalOptions, Promisable, PromiseWithError, ThrowableError, Value } from "@orpc/shared";
-import type { Context } from "./context.mjs";
-import type { Lazyable } from "./lazy.mjs";
-import type { Procedure, ProcedureHandlerOptions } from "./procedure.mjs";
-export type ProcedureClient<
-	TClientContext extends ClientContext,
-	TInputSchema extends AnySchema,
-	TOutputSchema extends AnySchema,
-	TErrorMap extends ErrorMap
-> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError>;
-export interface ProcedureClientInterceptorOptions<
-	TInitialContext extends Context,
-	TErrorMap extends ErrorMap
-> extends ProcedureHandlerOptions<TInitialContext, unknown, ORPCErrorConstructorMap<TErrorMap>> {}
-export type ProcedureClientInterceptor<
-	TInitialContext extends Context,
-	TOutputSchema extends AnySchema,
-	TErrorMap extends ErrorMap
-> = Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError>>;
-export type ProcedureClientOptions<
-	TInitialContext extends Context,
-	TOutputSchema extends AnySchema,
-	TErrorMap extends ErrorMap,
-	TClientContext extends ClientContext
-> = {
-	path?: string[] | undefined;
-	interceptors?: ProcedureClientInterceptor<TInitialContext, TOutputSchema, TErrorMap>[] | undefined;
-} & (object extends TInitialContext ? {
-	context?: Value<Promisable<TInitialContext>, [clientContext: TClientContext]> | undefined;
-} : {
-	context: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
-});
-export declare function createProcedureClient<
-	TInitialContext extends Context,
-	TInputSchema extends AnySchema,
-	TOutputSchema extends AnySchema,
-	TErrorMap extends ErrorMap,
-	TClientContext extends ClientContext = object
->(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap>>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;