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

package/dist/plugins/rethrow.d.ts

@@ -0,0 +1,33 @@
+import type { ThrowableError } from '@orpc/shared';
+import type { StandardHandlerInterceptorOptions, StandardHandlerOptions, StandardHandlerPlugin } from '../adapters/standard/index.ts';
+import type { Context } from '../context.ts';
+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.js

@@ -0,0 +1,59 @@
+import { toArray } from '@orpc/shared';
+/**
+ * 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),
+            ],
+        };
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { StandardHandlerOptions, StandardHandlerPlugin } from '../adapters/standard/index.ts';
+import type { Context } from '../context.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 declare class SignalSyncHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    name: string;
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/signal-sync.js

@@ -0,0 +1,91 @@
+import { AbortError, anyAbortSignal, AsyncIteratorClass, isAsyncIteratorObject, override, runWithSignal, toArray, } from '@orpc/shared';
+/**
+ * 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);
+}
+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();
+    });
+}
+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 });
+}

package/dist/plugins/timeout.d.ts

@@ -0,0 +1,37 @@
+import type { Value } from '@orpc/shared';
+import type { StandardHandlerInterceptorOptions, StandardHandlerOptions, StandardHandlerPlugin } from '../adapters/standard/index.ts';
+import type { Context } from '../context.ts';
+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.js

@@ -0,0 +1,59 @@
+import { AbortError, anyAbortSignal, isAsyncIteratorObject, override, toArray, value, wrapAsyncIterator, wrapReadableStream, } from '@orpc/shared';
+/**
+ * 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)] };
+    }
+}

package/dist/procedure-client.d.ts

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

package/dist/procedure-client.js

@@ -0,0 +1,175 @@
+import { ORPCError, wrapAsyncIteratorPreservingEventMeta } from '@orpc/client';
+import { createORPCErrorConstructorMap, reconcileORPCError, ValidationError } from '@orpc/contract';
+import { getTracer, intercept, isAsyncIteratorObject, mergeTwoLevels, override, resolveMaybeOptionalOptions, runWithSpan, toArray, traceAsyncIterator, traceReadableStream, value, } from '@orpc/shared';
+import { unlazy } from './lazy.js';
+export function createProcedureClient(lazyableProcedure, ...rest) {
+    const options = resolveMaybeOptionalOptions(rest);
+    return async (...[input, callerOptions]) => {
+        const path = toArray(options.path);
+        const { default: procedure } = await unlazy(lazyableProcedure);
+        // callerOptions.context can be undefined when all field is optional
+        const clientContext = callerOptions?.context ?? {};
+        // options.context can be undefined when all field is optional
+        const context = (await value(options.context, clientContext)) ??
+            {};
+        const errors = createORPCErrorConstructorMap(procedure['~orpc'].errorMap);
+        const reconcileError = async (e) => {
+            if (e instanceof ORPCError) {
+                return await reconcileORPCError(procedure['~orpc'].errorMap, e);
+            }
+            return e;
+        };
+        try {
+            const output = await runWithSpan('call_procedure', (span) => {
+                span?.setAttribute('procedure.path', path);
+                return intercept(options.interceptors, {
+                    context,
+                    // input can be optional if it is undefinable
+                    input: input,
+                    errors,
+                    path,
+                    procedure: procedure,
+                    signal: callerOptions?.signal,
+                    lastEventId: callerOptions?.lastEventId,
+                }, (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions));
+            });
+            if (isAsyncIteratorObject(output)) {
+                /**
+                 * traceAsyncIterator/wrapAsyncIteratorPreservingEventMeta return AsyncIteratorClass
+                 * which is backwards compatible with AsyncIteratorObject.
+                 *
+                 * @warning
+                 * If remove this return, can be breaking change
+                 * because AsyncIteratorClass convert `.throw` to `.return` (rarely used)
+                 *
+                 * @warning
+                 * Remember use `override` for AsyncIteratorObject to remain other special properties
+                 */
+                return override(output, wrapAsyncIteratorPreservingEventMeta(getTracer()
+                    ? traceAsyncIterator('consume_async_iterator_object_output', output)
+                    : output, { mapError: reconcileError }));
+            }
+            else if (getTracer() && output instanceof ReadableStream) {
+                /**
+                 * @warning
+                 * Remember use `override` for ReadableStream to remain other special properties
+                 */
+                return override(output, traceReadableStream('consume_octet_stream_output', output));
+            }
+            return output;
+        }
+        catch (e) {
+            throw await reconcileError(e);
+        }
+    };
+}
+async function validateInput(i, schema, input) {
+    return runWithSpan(`validate_input.${i}`, async (span) => {
+        span?.setAttribute('input_schema.index', i);
+        const result = await schema['~standard'].validate(input);
+        if (result.issues) {
+            throw new ORPCError('BAD_REQUEST', {
+                message: 'Input validation failed',
+                data: {
+                    issues: result.issues,
+                },
+                cause: new ValidationError({
+                    message: 'Input validation failed',
+                    issues: result.issues,
+                    invalidData: input,
+                }),
+            });
+        }
+        return result.value;
+    });
+}
+async function validateOutput(i, schema, output) {
+    return runWithSpan(`validate_output.${i}`, async (span) => {
+        span?.setAttribute('output_schema.index', i);
+        const result = await schema['~standard'].validate(output);
+        if (result.issues) {
+            throw new ORPCError('INTERNAL_SERVER_ERROR', {
+                message: 'Output validation failed',
+                cause: new ValidationError({
+                    message: 'Output validation failed',
+                    issues: result.issues,
+                    invalidData: output,
+                }),
+            });
+        }
+        return result.value;
+    });
+}
+const middlewareDone = (...rest) => {
+    const options = resolveMaybeOptionalOptions(rest);
+    return {
+        output: options.output,
+        // context can be undefined when all field is optional
+        context: options.context ?? {},
+    };
+};
+async function executeProcedureInternal(procedure, options) {
+    const inputSchemas = toArray(procedure['~orpc'].inputSchemas);
+    const outputSchemas = toArray(procedure['~orpc'].outputSchemas);
+    const orderedMiddlewares = procedure['~orpc'].orderedMiddlewares;
+    const next = async (midIndex, context, input, signal) => {
+        let currentInput = input;
+        let middlewareInput = input;
+        const startInputIndex = midIndex === 0 ? 0 : (orderedMiddlewares[midIndex - 1].inputSchemasLengthAtUse ?? 0);
+        const endInputIndex = midIndex === orderedMiddlewares.length
+            ? inputSchemas.length
+            : (orderedMiddlewares[midIndex].inputSchemasLengthAtUse ?? 0);
+        /**
+         * Each schema after the first validates the original input with the results so far applied, then
+         * its result is merged in, so no schema loses a field an earlier one stripped. Values that are not
+         * plain objects stay piped, which keeps schemas like `asyncIteratorObject` wrapping each other.
+         */
+        if (!procedure['~orpc'].disableInputValidation) {
+            for (let i = startInputIndex; i < endInputIndex; i++) {
+                const validated = await validateInput(i, inputSchemas[i], i !== 0 ? mergeTwoLevels(options.input, currentInput) : currentInput);
+                currentInput = i !== 0 ? mergeTwoLevels(currentInput, validated) : validated;
+            }
+            middlewareInput =
+                endInputIndex > 0 && endInputIndex < inputSchemas.length
+                    ? mergeTwoLevels(options.input, currentInput)
+                    : currentInput;
+        }
+        let currentOutput;
+        let currentContext = context;
+        if (midIndex < orderedMiddlewares.length) {
+            const { middleware } = orderedMiddlewares[midIndex];
+            const result = await runWithSpan(`middleware.${middleware.name}`, async (span) => {
+                span?.setAttribute('middleware.index', midIndex);
+                return await middleware({
+                    ...options,
+                    context,
+                    signal,
+                    next: (...rest) => {
+                        const nextOptions = resolveMaybeOptionalOptions(rest);
+                        // context can be undefined when all field is optional
+                        const nextContext = nextOptions.context ?? {};
+                        return next(midIndex + 1, { ...context, ...nextContext }, currentInput, nextOptions.signal ?? signal);
+                    },
+                    lastEventId: options.lastEventId,
+                }, middlewareInput, middlewareDone);
+            });
+            currentOutput = result.output;
+            currentContext = { ...context, ...result.context };
+        }
+        else {
+            currentOutput = await runWithSpan('handler', () => procedure['~orpc'].handler({ ...options, context, input: currentInput, signal }, currentInput));
+        }
+        const startOutputIndex = midIndex === 0 ? 0 : (orderedMiddlewares[midIndex - 1].outputSchemasLengthAtUse ?? 0);
+        const endOutputIndex = midIndex === orderedMiddlewares.length
+            ? outputSchemas.length
+            : (orderedMiddlewares[midIndex].outputSchemasLengthAtUse ?? 0);
+        if (!procedure['~orpc'].disableOutputValidation) {
+            for (let i = endOutputIndex - 1; i >= startOutputIndex; i--) {
+                currentOutput = await validateOutput(i, outputSchemas[i], currentOutput);
+            }
+        }
+        return { output: currentOutput, context: currentContext };
+    };
+    const { output } = await next(0, options.context, options.input, options.signal);
+    return output;
+}

package/dist/procedure-decorated.d.ts

@@ -0,0 +1,10 @@
+import type { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, MergedErrorMap, MetaPlugin } from '@orpc/contract';
+import type { IntersectPick } from '@orpc/shared';
+import type { Context, MergedContext, MergedInitialContext } from './context.ts';
+import type { Middleware } from './middleware.ts';
+import { Procedure } from './procedure.ts';
+export declare class DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> extends Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap> {
+    meta(...plugins: MetaPlugin<TInputSchema, TOutputSchema, TErrorMap>[]): DecoratedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
+    errors<T extends ErrorMap>(errors: T): DecoratedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, T>>;
+    use<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, InferSchemaOutput<TInputSchema>, InferSchemaInput<TOutputSchema>, $ErrorMap>): DecoratedProcedure<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, TOutputSchema, MergedErrorMap<$ErrorMap, TErrorMap>>;
+}

package/dist/procedure-decorated.js

@@ -0,0 +1,44 @@
+import { getHiddenMetaPlugins, mergeErrorMap, resolveMetaPlugins } from '@orpc/contract';
+import { Procedure } from './procedure.js';
+export class DecoratedProcedure extends Procedure {
+    meta(...plugins) {
+        const [meta, metaPlugins] = resolveMetaPlugins(this['~orpc'].meta, this['~orpc'].metaPlugins, plugins);
+        return new DecoratedProcedure({
+            ...this['~orpc'],
+            meta,
+            metaPlugins,
+        });
+    }
+    errors(errors) {
+        let procedure = new DecoratedProcedure({
+            ...this['~orpc'],
+            errorMap: mergeErrorMap(this['~orpc'].errorMap, errors),
+        });
+        const plugins = getHiddenMetaPlugins(errors);
+        if (plugins) {
+            procedure = procedure.meta(...plugins);
+        }
+        return procedure;
+    }
+    use(middleware) {
+        // Since middleware executes before the handler, we use `IntersectPick` to ensure
+        // that the middleware's output context ($OutContext) is compatible with the
+        // context requirements of the handler, which may have already been defined.
+        let procedure = new DecoratedProcedure({
+            ...this['~orpc'],
+            errorMap: mergeErrorMap(middleware['~orpc']?.errorMap, this['~orpc'].errorMap),
+            orderedMiddlewares: [
+                ...this['~orpc'].orderedMiddlewares,
+                {
+                    middleware,
+                    inputSchemasLengthAtUse: this['~orpc'].inputSchemas?.length,
+                    outputSchemasLengthAtUse: this['~orpc'].outputSchemas?.length,
+                },
+            ],
+        });
+        if (middleware['~orpc']?.metaPlugins) {
+            procedure = procedure.meta(...middleware['~orpc']?.metaPlugins);
+        }
+        return procedure;
+    }
+}

package/dist/procedure-utils.d.ts

@@ -0,0 +1,41 @@
+import type { ClientOptions } from '@orpc/client';
+import type { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, ORPCErrorFromErrorMap, ProcedureContract } from '@orpc/contract';
+import type { PromiseWithError, ThrowableError } from '@orpc/shared';
+import type { Context } from './context.ts';
+import type { Lazyable } from './lazy.ts';
+import { Lazy } from './lazy.ts';
+import type { ProcedureClientOptions } from './procedure-client.ts';
+import type { AnyProcedure } from './procedure.ts';
+import { Procedure } from './procedure.ts';
+export declare function createGuardedProcedureLazy(lazy: Lazy<unknown>): Lazy<AnyProcedure>;
+/**
+ * Create a new procedure that ensure the contract is applied to the procedure.
+ *
+ * .input/.output/.handler mismatches are already caught by the `implementer.router`,
+ * but .errors (in case implemented procedure error map is more than enough) and .meta cannot be
+ * validated that way - so they must be overridden here to ensure the client always sees what the contract defines.
+ */
+export declare function createContractProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap>(procedure: Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, any>, contract: ProcedureContract<any, any, TErrorMap>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
+export type CallOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, object> & Omit<ClientOptions<object>, 'context'>;
+export type CallRest<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = object extends CallOptions<TInitialContext, TOutputSchema, TErrorMap> ? undefined extends InferSchemaInput<TInputSchema> ? [
+    input?: InferSchemaInput<TInputSchema>,
+    options?: CallOptions<TInitialContext, TOutputSchema, TErrorMap>
+] : [
+    input: InferSchemaInput<TInputSchema>,
+    options?: CallOptions<TInitialContext, TOutputSchema, TErrorMap>
+] : [
+    input: InferSchemaInput<TInputSchema>,
+    options: CallOptions<TInitialContext, TOutputSchema, TErrorMap>
+];
+/**
+ * Quickly call a procedure without creating a client.
+ *
+ * @example
+ * ```ts
+ * const output = await call(getting, 'input')
+ * const output = await call(getting, 'input', { context: { db: 'postgres' } })
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/client/server-side#one-off-calls | Server-Side Clients - One-Off Calls}
+ */
+export declare function call<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap>>, ...[input, options,]: CallRest<TInitialContext, TInputSchema, TOutputSchema, TErrorMap>): PromiseWithError<InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError>;

package/dist/procedure-utils.js

@@ -0,0 +1,49 @@
+import { Lazy, unlazy } from './lazy.js';
+import { createProcedureClient } from './procedure-client.js';
+import { Procedure } from './procedure.js';
+export function createGuardedProcedureLazy(lazy) {
+    const guarded = new Lazy({
+        ...lazy['~orpc'],
+        async loader() {
+            const { default: maybeProcedure } = await unlazy(lazy);
+            if (!(maybeProcedure instanceof Procedure)) {
+                throw new TypeError(`
+          Expected a lazy<procedure> but got lazy<unknown>.
+          This should be caught by TypeScript compilation.
+          Please report this issue if you think this is a bug.
+        `);
+            }
+            return { default: maybeProcedure };
+        },
+    });
+    return guarded;
+}
+/**
+ * Create a new procedure that ensure the contract is applied to the procedure.
+ *
+ * .input/.output/.handler mismatches are already caught by the `implementer.router`,
+ * but .errors (in case implemented procedure error map is more than enough) and .meta cannot be
+ * validated that way - so they must be overridden here to ensure the client always sees what the contract defines.
+ */
+export function createContractProcedure(procedure, contract) {
+    return new Procedure({
+        ...procedure['~orpc'],
+        errorMap: contract['~orpc'].errorMap,
+        meta: contract['~orpc'].meta,
+        metaPlugins: contract['~orpc'].metaPlugins,
+    });
+}
+/**
+ * Quickly call a procedure without creating a client.
+ *
+ * @example
+ * ```ts
+ * const output = await call(getting, 'input')
+ * const output = await call(getting, 'input', { context: { db: 'postgres' } })
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/client/server-side#one-off-calls | Server-Side Clients - One-Off Calls}
+ */
+export function call(lazyableProcedure, ...[input = undefined, options = {},]) {
+    return createProcedureClient(lazyableProcedure, options)(input, options);
+}