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

package/dist/procedure.d.ts

@@ -1,72 +1,72 @@
-import type { AnySchema, ErrorMap, ORPCErrorConstructorMap, ProcedureContractDefinition } from '@orpc/contract';
-import type { Promisable } from '@orpc/shared';
-import type { Context } from './context.ts';
-import type { AnyMiddleware } from './middleware.ts';
+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;
+  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>;
+  (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;
+  /**
+   * 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;
+  /**
+   * 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>;
+  __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;
+  "~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>;
+export type AnyProcedure = Procedure<any, any, any, any, any>;

package/dist/procedure.js

@@ -1,24 +1,18 @@
-import { ProcedureContract } from '@orpc/contract';
-import { getConstructor } from '@orpc/shared';
-export 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) {
-            // fallback to default instanceof check if this is extended class
-            return Function.prototype[Symbol.hasInstance].call(this, instance);
-        }
-        const constructor = getConstructor(instance);
-        if (constructor === Procedure) {
-            return true;
-        }
-        return (instance instanceof ProcedureContract &&
-            Array.isArray(instance['~orpc'].orderedMiddlewares) &&
-            typeof instance['~orpc'].handler === 'function');
-    }
-}
+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

@@ -1,23 +1,21 @@
-import type { ClientContext } from '@orpc/client';
-import type { ErrorMap, Schema } from '@orpc/contract';
-import type { MaybeOptionalOptions } from '@orpc/shared';
-import type { Lazyable } from './lazy.ts';
-import type { ProcedureClient, ProcedureClientOptions } from './procedure-client.ts';
-import { Procedure } from './procedure.ts';
-import type { AnyRouter, InferRouterInitialContext } from './router.ts';
+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;
-};
+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>;
+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

@@ -1,43 +1,35 @@
-import { RECURSIVE_CLIENT_UNWRAP_KEYS } from '@orpc/client';
-import { resolveMaybeOptionalOptions, toArray } from '@orpc/shared';
-import { Lazy } from './lazy.js';
-import { createProcedureClient } from './procedure-client.js';
-import { createGuardedProcedureLazy } from './procedure-utils.js';
-import { Procedure } from './procedure.js';
-import { getRouter } from './router-utils.js';
+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}
- */
-export 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 = new Map();
-    const recursive = 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 === undefined) {
-                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;
-        },
-    });
-    return recursive;
+* 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

@@ -1,14 +1,12 @@
-const HIDDEN_ROUTER_CONTRACT_SYMBOL = /* @__PURE__ */ Symbol.for('ORPC_HIDDEN_ROUTER_CONTRACT');
-export function withHiddenRouterContract(router, contract) {
-    return new Proxy(router, {
-        get(target, key) {
-            if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
-                return contract;
-            }
-            return Reflect.get(target, key);
-        },
-    });
+// 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);
+	} });
 }
-export function getHiddenRouterContract(router) {
-    return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
+function getHiddenRouterContract(router) {
+	return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
 }
+export { getHiddenRouterContract, withHiddenRouterContract };

package/dist/router-utils.d.ts

@@ -1,26 +1,12 @@
-import type { AnyProcedureContract, AugmentContractRouterOptions, ErrorMap, MergedErrorMap, RouterContract } from '@orpc/contract';
-import type { Promisable } from '@orpc/shared';
-import type { Context, MergedInitialContext } from './context.ts';
-import type { Lazyable } from './lazy.ts';
-import { Lazy } from './lazy.ts';
-import type { AnyMiddleware } from './middleware.ts';
-import type { AnyProcedure, ProcedureConfig } from './procedure.ts';
-import { Procedure } from './procedure.ts';
-import type { AnyRouter } from './router.ts';
-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;
-};
-interface AugmentRouterOptions<TErrorMap extends ErrorMap> extends AugmentContractRouterOptions<TErrorMap>, ProcedureConfig {
-    middlewares: AnyMiddleware[];
-}
-export declare function augmentRouter<T extends AnyRouter, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap>(router: T, options: AugmentRouterOptions<TErrorMap>): AugmentedRouter<T, TErrorMap> | AugmentedRouterWithMiddlewares<T, TInitialContext, TCurrentContext, TErrorMap>;
-interface AugmentImplementedRouterOptions extends ProcedureConfig {
-    middlewares: AnyMiddleware[];
-}
-export declare function augmentImplementedRouter<T extends AnyRouter, TInitialContext extends Context, TCurrentContext extends Context>(router: T, options: AugmentImplementedRouterOptions): AugmentedRouter<T, object> | AugmentedRouterWithMiddlewares<T, TInitialContext, TCurrentContext, object>;
+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.
@@ -30,19 +16,16 @@ export declare function augmentImplementedRouter<T extends AnyRouter, TInitialCo
 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[];
+  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;
-};
+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>>;
-export {};
+export declare function unlazyRouter<T extends AnyRouter>(router: T): Promise<UnlaziedRouter<T>>;