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

package/dist/procedure-client.js

@@ -0,0 +1,158 @@
+import { unlazy } from "./lazy.js";
+import { ValidationError, createORPCErrorConstructorMap, reconcileORPCError } from "@orpc/contract";
+import { getTracer, intercept, isAsyncIteratorObject, mergeTwoLevels, override, resolveMaybeOptionalOptions, runWithSpan, toArray, traceAsyncIterator, traceReadableStream, value } from "@orpc/shared";
+import { ORPCError, wrapAsyncIteratorPreservingEventMeta } from "@orpc/client";
+// src/procedure-client.ts
+function createProcedureClient(lazyableProcedure, ...rest) {
+	const options = resolveMaybeOptionalOptions(rest);
+	return async (...[input, callerOptions]) => {
+		const path = toArray(options.path);
+		const { default: procedure } = await unlazy(lazyableProcedure);
+		const clientContext = callerOptions?.context ?? {};
+		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,
+					errors,
+					path,
+					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: 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);
+						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;
+}
+export { createProcedureClient };

package/dist/procedure-decorated.d.ts

@@ -0,0 +1,10 @@
+import { Context, MergedContext, MergedInitialContext } from "./context.js";
+import { Middleware } from "./middleware.js";
+import { Procedure } from "./procedure.js";
+import { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, MergedErrorMap, MetaPlugin } from "@orpc/contract";
+import { IntersectPick } from "@orpc/shared";
+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,36 @@
+import { Procedure } from "./procedure.js";
+import { getHiddenMetaPlugins, mergeErrorMap, resolveMetaPlugins } from "@orpc/contract";
+// src/procedure-decorated.ts
+var DecoratedProcedure = 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) {
+		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;
+	}
+};
+export { DecoratedProcedure };

package/dist/procedure-utils.d.ts

@@ -0,0 +1,21 @@
+import { Context } from "./context.js";
+import { Lazyable } from "./lazy.js";
+import { Procedure } from "./procedure.js";
+import { ProcedureClientOptions } from "./procedure-client.js";
+import { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, ORPCErrorFromErrorMap } from "@orpc/contract";
+import { PromiseWithError, ThrowableError as ThrowableError$1 } from "@orpc/shared";
+import { ClientOptions } from "@orpc/client";
+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$1>;

package/dist/procedure-utils.js

@@ -0,0 +1,48 @@
+import { Lazy, unlazy } from "./lazy.js";
+import { Procedure } from "./procedure.js";
+import { createProcedureClient } from "./procedure-client.js";
+// src/procedure-utils.ts
+function createGuardedProcedureLazy(lazy) {
+	return 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 };
+		}
+	});
+}
+/**
+* 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.
+*/
+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}
+*/
+function call(lazyableProcedure, ...[input = void 0, options = {}]) {
+	return createProcedureClient(lazyableProcedure, options)(input, options);
+}
+export { call, createContractProcedure, createGuardedProcedureLazy };

package/dist/procedure.d.ts

@@ -0,0 +1,72 @@
+import { Context } from "./context.js";
+import { AnyMiddleware } from "./middleware.js";
+import { AnySchema, ErrorMap, ORPCErrorConstructorMap, ProcedureContractDefinition } from "@orpc/contract";
+import { Promisable } from "@orpc/shared";
+export interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+  context: TCurrentContext;
+  input: TInput;
+  path: string[];
+  procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap>;
+  signal?: AbortSignal | undefined;
+  lastEventId?: string | undefined;
+  errors: TErrorConstructorMap;
+}
+export interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+  (opts: ProcedureHandlerOptions<TCurrentContext, TInput, TErrorConstructorMap>, input: TInput): Promisable<THandlerOutput>;
+}
+export interface OrderedMiddleware {
+  /**
+   * Snapshot of `inputSchemas.length`
+   * at the time this middleware was used.
+   *
+   * @default 0
+   */
+  inputSchemasLengthAtUse?: number | undefined;
+  /**
+   * Snapshot of `outputSchemas.length`
+   * at the time this middleware was used.
+   *
+   * @default 0
+   */
+  outputSchemasLengthAtUse?: number | undefined;
+  middleware: AnyMiddleware;
+}
+export interface ProcedureConfig {
+  /**
+   * When enabled, input schemas are not validated at runtime.
+   * Schemas are still used for type inference and OpenAPI generation.
+   *
+   * @remarks
+   * **Warning**: Do not disable validation for schemas that transform values.
+   *
+   * @default false
+   */
+  disableInputValidation?: boolean | undefined;
+  /**
+   * When enabled, output schemas are not validated at runtime.
+   * Schemas are still used for type inference and OpenAPI generation.
+   *
+   * Useful when output schemas exist only for specification generation.
+   *
+   * @remarks
+   * **Warning**: Do not disable validation for schemas that transform values.
+   *
+   * @default false
+   */
+  disableOutputValidation?: boolean | undefined;
+}
+export interface ProcedureDefinition<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> extends ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap>, ProcedureConfig {
+  __TInitialContext?: (type: TInitialContext) => unknown;
+  __TInjectedContext?: (type: TInjectedContext) => unknown;
+  orderedMiddlewares: OrderedMiddleware[];
+  handler: ProcedureHandler<any, any, any, any>;
+}
+export declare class Procedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+  "~orpc": ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
+  "constructor"(def: ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>);
+  /**
+   * Checks if the given instance satisfies the {@link Procedure} class/interface.
+   */
+  static [Symbol.hasInstance](instance: unknown): boolean;
+}
+export type AnyProcedure = Procedure<any, any, any, any, any>;

package/dist/procedure.js

@@ -0,0 +1,18 @@
+import { ProcedureContract } from "@orpc/contract";
+import { getConstructor } from "@orpc/shared";
+// src/procedure.ts
+var Procedure = class Procedure {
+	"~orpc";
+	"constructor"(def) {
+		this["~orpc"] = def;
+	}
+	/**
+	* Checks if the given instance satisfies the {@link Procedure} class/interface.
+	*/
+	static [Symbol.hasInstance](instance) {
+		if (this !== Procedure) return Function.prototype[Symbol.hasInstance].call(this, instance);
+		if (getConstructor(instance) === Procedure) return true;
+		return instance instanceof ProcedureContract && Array.isArray(instance["~orpc"].orderedMiddlewares) && typeof instance["~orpc"].handler === "function";
+	}
+};
+export { Procedure };

package/dist/router-client.d.ts

@@ -0,0 +1,21 @@
+import { Lazyable } from "./lazy.js";
+import { Procedure } from "./procedure.js";
+import { ProcedureClient, ProcedureClientOptions } from "./procedure-client.js";
+import { AnyRouter, InferRouterInitialContext } from "./router.js";
+import { ErrorMap, Schema } from "@orpc/contract";
+import { MaybeOptionalOptions } from "@orpc/shared";
+import { ClientContext } from "@orpc/client";
+/**
+ * The client type derived from a router, exposing every procedure as a callable
+ * function while preserving the router's shape.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#creating-a-client | Client-Side Clients - Creating a Client}
+ */
+export type RouterClient<TRouter extends AnyRouter, TClientContext extends ClientContext = object> = TRouter extends Procedure<any, any, infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? ProcedureClient<TClientContext, $InputSchema, $OutputSchema, $ErrorMap> : { [K in keyof TRouter]: TRouter[K] extends Lazyable<infer U extends AnyRouter> ? RouterClient<U, TClientContext> : never; };
+/**
+ * Creates a server-side client that calls the router's procedures directly,
+ * within the same process, without any network layer.
+ *
+ * @see {@link https://orpc.dev/docs/client/server-side#router-clients | Server-Side Clients - Router Clients}
+ */
+export declare function createRouterClient<T extends AnyRouter, TClientContext extends ClientContext = object>(router: Lazyable<T | undefined>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<InferRouterInitialContext<T>, Schema<unknown>, ErrorMap, TClientContext>>): RouterClient<T, TClientContext>;

package/dist/router-client.js

@@ -0,0 +1,35 @@
+import { Lazy } from "./lazy.js";
+import { Procedure } from "./procedure.js";
+import { createProcedureClient } from "./procedure-client.js";
+import { createGuardedProcedureLazy } from "./procedure-utils.js";
+import { getRouter } from "./router-utils.js";
+import { resolveMaybeOptionalOptions, toArray } from "@orpc/shared";
+import { RECURSIVE_CLIENT_UNWRAP_KEYS } from "@orpc/client";
+// src/router-client.ts
+/**
+* Creates a server-side client that calls the router's procedures directly,
+* within the same process, without any network layer.
+*
+* @see {@link https://orpc.dev/docs/client/server-side#router-clients | Server-Side Clients - Router Clients}
+*/
+function createRouterClient(router, ...rest) {
+	const options = resolveMaybeOptionalOptions(rest);
+	if (router instanceof Procedure) return createProcedureClient(router, options);
+	const procedureCaller = router instanceof Lazy ? createProcedureClient(createGuardedProcedureLazy(router), options) : {};
+	const cache = /* @__PURE__ */ new Map();
+	return new Proxy(procedureCaller, { get(target, key) {
+		if (typeof key !== "string" || router instanceof Lazy && RECURSIVE_CLIENT_UNWRAP_KEYS.has(key)) return Reflect.get(target, key);
+		let nextClient = cache.get(key);
+		if (nextClient === void 0) {
+			const next = getRouter(router, [key]);
+			if (!next) return Reflect.get(target, key);
+			nextClient = createRouterClient(next, {
+				...options,
+				path: [...toArray(options.path), key]
+			});
+			cache.set(key, nextClient);
+		}
+		return nextClient;
+	} });
+}
+export { createRouterClient };

package/dist/router-hidden.js

@@ -0,0 +1,12 @@
+// src/router-hidden.ts
+const HIDDEN_ROUTER_CONTRACT_SYMBOL = /* @__PURE__ */ Symbol.for("ORPC_HIDDEN_ROUTER_CONTRACT");
+function withHiddenRouterContract(router, contract) {
+	return new Proxy(router, { get(target, key) {
+		if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) return contract;
+		return Reflect.get(target, key);
+	} });
+}
+function getHiddenRouterContract(router) {
+	return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
+}
+export { getHiddenRouterContract, withHiddenRouterContract };

package/dist/router-utils.d.ts

@@ -0,0 +1,31 @@
+import { Context, MergedInitialContext } from "./context.js";
+import { Lazy, Lazyable } from "./lazy.js";
+import "./middleware.js";
+import { AnyProcedure, Procedure } from "./procedure.js";
+import { AnyRouter } from "./router.js";
+import { AnyProcedureContract, ErrorMap, MergedErrorMap, RouterContract } from "@orpc/contract";
+import { Promisable } from "@orpc/shared";
+export type AugmentedRouter<T extends AnyRouter, TErrorMap extends ErrorMap> = T extends Procedure<infer $InitialContext, infer $CurrentContext, infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<$InitialContext, $CurrentContext, $InputSchema, $OutputSchema, MergedErrorMap<TErrorMap, $ErrorMap>> : { [K in keyof T]: T[K] extends Lazy<infer $ extends AnyRouter> ? Lazy<AugmentedRouter<$, TErrorMap>> : T[K] extends AnyRouter ? AugmentedRouter<T[K], TErrorMap> : never; };
+export type AugmentedRouterWithMiddlewares<T extends AnyRouter, TInitialContext extends Context, TInjectedContext extends Context, TErrorMap extends ErrorMap> = T extends Procedure<infer $InitialContext, infer $CurrentContext, infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<MergedInitialContext<TInitialContext, TInjectedContext, $InitialContext>, $CurrentContext, $InputSchema, $OutputSchema, MergedErrorMap<TErrorMap, $ErrorMap>> : { [K in keyof T]: T[K] extends Lazy<infer $ extends AnyRouter> ? Lazy<AugmentedRouterWithMiddlewares<$, TInitialContext, TInjectedContext, TErrorMap>> : T[K] extends AnyRouter ? AugmentedRouterWithMiddlewares<T[K], TInitialContext, TInjectedContext, TErrorMap> : never; };
+/**
+ * Resolves the procedure of a contract walked from a router: the procedure itself,
+ * or the implementation of a contract-first procedure, looked up by its path.
+ *
+ * @throws {TypeError} If a contract-first procedure has no valid implementation.
+ */
+export declare function resolveContractProcedure(router: AnyRouter, contract: AnyProcedureContract, path: readonly string[]): Promise<AnyProcedure>;
+export declare function getRouter<T extends Lazyable<AnyRouter | undefined>>(router: T, path: readonly string[]): T extends Lazy<any> ? Lazy<AnyRouter | undefined> : Lazyable<AnyRouter | undefined>;
+export interface WalkProcedureContractsLazyResult {
+  router: Lazy<AnyRouter>;
+  path: string[];
+}
+export declare function walkProcedureContractsSync(router: RouterContract | AnyRouter, callback: (contract: AnyProcedureContract | AnyProcedure, path: string[]) => void, path?: string[]): WalkProcedureContractsLazyResult[];
+export declare function walkProcedureContractsAsync(router: RouterContract | AnyRouter, callback: (contract: AnyProcedureContract | AnyProcedure, path: string[]) => Promisable<void>, path?: string[]): Promise<void>;
+export type UnlaziedRouter<T extends AnyRouter> = T extends AnyProcedure ? T : { [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? UnlaziedRouter<U> : never; };
+/**
+ * Fully resolves all lazy routers inside a router, returning a plain router.
+ * Useful for making a router with lazy parts contract-compatible.
+ *
+ * @see {@link https://orpc.dev/docs/contract/router#router-to-contract | Router Contract - Router to Contract}
+ */
+export declare function unlazyRouter<T extends AnyRouter>(router: T): Promise<UnlaziedRouter<T>>;

package/dist/router-utils.js

@@ -0,0 +1,157 @@
+import { Lazy, unlazy } from "./lazy.js";
+import { Procedure } from "./procedure.js";
+import { createContractProcedure } from "./procedure-utils.js";
+import { getHiddenRouterContract } from "./router-hidden.js";
+import { ProcedureContract, mergeErrorMap, resolveMetaPlugins } from "@orpc/contract";
+import { getOwn, isNonPrimitive, omit, setOwn } from "@orpc/shared";
+// src/router-utils.ts
+function augmentRouter(router, options) {
+	if (router instanceof Lazy) {
+		const [meta, metaPlugins] = resolveMetaPlugins(options.meta, options.metaPlugins, router["~orpc"].metaPlugins);
+		return new Lazy({
+			meta,
+			metaPlugins,
+			async loader() {
+				const { default: unlaziedRouter } = await unlazy(router);
+				const enhanced = augmentRouter(unlaziedRouter, options);
+				return unlazy(enhanced);
+			}
+		});
+	}
+	if (router instanceof Procedure) {
+		const [meta, metaPlugins] = resolveMetaPlugins(options.meta, options.metaPlugins, router["~orpc"].metaPlugins);
+		return new Procedure({
+			...omit(options, [
+				"middlewares",
+				"errorMap",
+				"meta",
+				"metaPlugins"
+			]),
+			...router["~orpc"],
+			meta,
+			metaPlugins,
+			errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
+			orderedMiddlewares: [...options.middlewares.map((middleware) => ({
+				middleware,
+				inputSchemasLengthAtUse: 0,
+				outputSchemasLengthAtUse: 0
+			})), ...router["~orpc"].orderedMiddlewares]
+		});
+	}
+	if (!isNonPrimitive(router)) return router;
+	const enhanced = {};
+	for (const [key, child] of Object.entries(router)) setOwn(enhanced, key, augmentRouter(child, options));
+	return enhanced;
+}
+function augmentImplementedRouter(router, options) {
+	if (router instanceof Lazy) return new Lazy({
+		...router["~orpc"],
+		async loader() {
+			const { default: unlaziedRouter } = await unlazy(router);
+			const enhanced = augmentImplementedRouter(unlaziedRouter, options);
+			return unlazy(enhanced);
+		}
+	});
+	if (router instanceof Procedure) return new Procedure({
+		...omit(options, ["middlewares"]),
+		...router["~orpc"],
+		orderedMiddlewares: [...options.middlewares.map((middleware) => ({
+			middleware,
+			inputSchemasLengthAtUse: 0,
+			outputSchemasLengthAtUse: 0
+		})), ...router["~orpc"].orderedMiddlewares]
+	});
+	if (!isNonPrimitive(router)) return router;
+	const enhanced = {};
+	for (const [key, child] of Object.entries(router)) setOwn(enhanced, key, augmentImplementedRouter(child, options));
+	return enhanced;
+}
+/**
+* Resolves the procedure of a contract walked from a router: the procedure itself,
+* or the implementation of a contract-first procedure, looked up by its path.
+*
+* @throws {TypeError} If a contract-first procedure has no valid implementation.
+*/
+async function resolveContractProcedure(router, contract, path) {
+	if (contract instanceof Procedure) return contract;
+	const { default: maybeProcedure } = await unlazy(getRouter(router, path));
+	if (!(maybeProcedure instanceof Procedure)) throw new TypeError(`[Contract-First] Missing or invalid implementation for procedure at path: "${path.join(".")}". Ensure the procedure is correctly implemented and matches its contract.`);
+	return createContractProcedure(maybeProcedure, contract);
+}
+function getRouter(router, path) {
+	let current = router;
+	for (let i = 0; i < path.length; i++) {
+		const segment = path[i];
+		if (!isNonPrimitive(current)) return;
+		if (current instanceof Procedure) return;
+		if (!(current instanceof Lazy)) {
+			current = getOwn(current, segment);
+			continue;
+		}
+		const lazied = current;
+		const rest = path.slice(i);
+		return new Lazy({
+			...lazied["~orpc"],
+			async loader() {
+				const next = getRouter((await unlazy(lazied)).default, rest);
+				return await unlazy(next);
+			}
+		});
+	}
+	if (!isNonPrimitive(current)) return;
+	return current;
+}
+function walkProcedureContractsSync(router, callback, path = []) {
+	const lazyResults = [];
+	walkProcedureContractsSyncInternal(router, callback, path.slice(), lazyResults);
+	return lazyResults;
+}
+function walkProcedureContractsSyncInternal(router, callback, path, lazyResults) {
+	const hiddenContract = getHiddenRouterContract(router);
+	if (hiddenContract !== void 0) router = hiddenContract;
+	if (router instanceof ProcedureContract) {
+		callback(router, path.slice());
+		return;
+	}
+	if (!isNonPrimitive(router)) return;
+	for (const [key, value] of Object.entries(router)) {
+		path.push(key);
+		if (value instanceof Lazy) lazyResults.push({
+			router: value,
+			path: path.slice()
+		});
+		else walkProcedureContractsSyncInternal(value, callback, path, lazyResults);
+		path.pop();
+	}
+}
+async function walkProcedureContractsAsync(router, callback, path = []) {
+	const hiddenContract = getHiddenRouterContract(router);
+	if (hiddenContract !== void 0) router = hiddenContract;
+	if (router instanceof ProcedureContract) {
+		await callback(router, path);
+		return;
+	}
+	if (!isNonPrimitive(router)) return;
+	for (const [key, value] of Object.entries(router)) if (value instanceof Lazy) {
+		const { default: router } = await unlazy(value);
+		await walkProcedureContractsAsync(router, callback, [...path, key]);
+	} else await walkProcedureContractsAsync(value, callback, [...path, key]);
+}
+/**
+* Fully resolves all lazy routers inside a router, returning a plain router.
+* Useful for making a router with lazy parts contract-compatible.
+*
+* @see {@link https://orpc.dev/docs/contract/router#router-to-contract | Router Contract - Router to Contract}
+*/
+async function unlazyRouter(router) {
+	if (router instanceof Procedure) return router;
+	if (!isNonPrimitive(router)) return router;
+	const unlazied = {};
+	for (const key of Object.keys(router)) {
+		const item = router[key];
+		const { default: unlaziedRouter } = await unlazy(item);
+		setOwn(unlazied, key, await unlazyRouter(unlaziedRouter));
+	}
+	return unlazied;
+}
+export { augmentImplementedRouter, augmentRouter, getRouter, resolveContractProcedure, unlazyRouter, walkProcedureContractsAsync, walkProcedureContractsSync };