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

package/dist/plugins/rethrow.js

@@ -1,59 +1,47 @@
-import { toArray } from '@orpc/shared';
+import { toArray } from "@orpc/shared";
+// src/plugins/rethrow.ts
 /**
- * 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 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 {
-                // await is important here to catch both sync and async errors
-                return await options.next();
-            }
-            catch (error) {
-                if (this.filter(error, options)) {
-                    pluginContext.error = { value: error };
-                }
-                throw error;
-            }
-        };
-        return {
-            ...options,
-            routingInterceptors: [
-                ...toArray(options.routingInterceptors),
-                routingInterceptor, // rethrow as early as possible and keep it close to `interceptor` to avoid a corrupted or modified context
-            ],
-            interceptors: [
-                interceptor, // catch as many errors as possible
-                ...toArray(options.interceptors),
-            ],
-        };
-    }
-}
+* 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}
+*/
+var RethrowHandlerPlugin = class {
+	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)]
+		};
+	}
+};
+export { RethrowHandlerPlugin };

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

@@ -1,5 +1,7 @@
-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";
 /**
  * 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`,
@@ -8,6 +10,6 @@ import type { Context } from '../context.ts';
  * @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>;
-}
+  name: string;
+  init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/signal-sync.js

@@ -1,91 +1,76 @@
-import { AbortError, anyAbortSignal, AsyncIteratorClass, isAsyncIteratorObject, override, runWithSignal, toArray, } from '@orpc/shared';
+import { AbortError, AsyncIteratorClass, anyAbortSignal, isAsyncIteratorObject, listenAbort, override, runWithSignal, toArray } from "@orpc/shared";
+// src/plugins/signal-sync.ts
 /**
- * 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 class SignalSyncHandlerPlugin {
-    name = '~signal-sync';
-    init(options) {
-        // oxlint-disable-next-line unicorn/consistent-function-scoping
-        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);
-}
+* 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}
+*/
+var SignalSyncHandlerPlugin = class {
+	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 syncAsyncIterator(iterator, signal, cancel) {
-    let cancelling;
-    const unlisten = listenAbort(signal, () => {
-        cancelling = (async () => iterator.return?.())();
-        cancelling.catch(() => { }); // only awaited when the consumer cancels
-    });
-    return new AsyncIteratorClass(() => runWithSignal(signal, () => iterator.next()), async ({ kind }) => {
-        if (kind === 'cancelled') {
-            cancel();
-            await cancelling;
-        }
-        unlisten();
-    });
+	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(() => { }); // only awaited when the consumer cancels
-            });
-        },
-        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 });
+	const reader = stream.getReader();
+	let cancelling;
+	let unlisten;
+	return new ReadableStream({
+		start(controller) {
+			unlisten = listenAbort(signal, (reason) => {
+				controller.error(reason);
+				cancelling = reader.cancel(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 });
 }
+export { SignalSyncHandlerPlugin };

package/dist/plugins/timeout.d.ts

@@ -1,25 +1,27 @@
-import type { Value } 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 { Value } from "@orpc/shared";
 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;
+  /**
+   * 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`
@@ -29,9 +31,9 @@ export interface TimeoutHandlerPluginOptions<T extends Context> {
  * @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>;
-}
+  private readonly timeout;
+  private readonly streamingTimeout;
+  name: string;
+  constructor(options: NoInfer<TimeoutHandlerPluginOptions<T>>);
+  init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/timeout.js

@@ -1,59 +1,62 @@
-import { AbortError, anyAbortSignal, isAsyncIteratorObject, override, toArray, value, wrapAsyncIterator, wrapReadableStream, } from '@orpc/shared';
+import { AbortError, anyAbortSignal, isAsyncIteratorObject, override, toArray, value, wrapAsyncIterator, wrapReadableStream } from "@orpc/shared";
+// src/plugins/timeout.ts
 /**
- * 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 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)] };
-    }
-}
+* 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}
+*/
+var TimeoutHandlerPlugin = class {
+	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 !== void 0;
+			const hasStreamingTimeout = streamingTimeoutMs !== null && streamingTimeoutMs !== void 0;
+			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) : void 0;
+			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)]
+		};
+	}
+};
+export { TimeoutHandlerPlugin };

package/dist/procedure-client.d.ts

@@ -1,19 +1,18 @@
-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.ts';
-import type { Lazyable } from './lazy.ts';
-import type { Procedure, ProcedureHandlerOptions } from './procedure.ts';
-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>>;
+import { Context } from "./context.js";
+import { Lazyable } from "./lazy.js";
+import { Procedure, ProcedureHandlerOptions } from "./procedure.js";
+import { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, ORPCErrorConstructorMap, ORPCErrorFromErrorMap } from "@orpc/contract";
+import { Interceptor, MaybeOptionalOptions, Promisable, PromiseWithError, ThrowableError as ThrowableError$1, Value } from "@orpc/shared";
+import { Client, ClientContext } from "@orpc/client";
+export type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError$1>;
+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$1>>;
 export type ProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TClientContext extends ClientContext> = {
-    path?: string[] | undefined;
-    interceptors?: ProcedureClientInterceptor<TInitialContext, TOutputSchema, TErrorMap>[] | undefined;
+  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]> | undefined;
 } : {
-    context: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
+  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>;
+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>;