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

package/dist/router-client.d.mts

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

@@ -0,0 +1,35 @@
+import { RECURSIVE_CLIENT_UNWRAP_KEYS } from "@orpc/client";
+import { resolveMaybeOptionalOptions, toArray } from "@orpc/shared";
+import { Lazy } from "./lazy.mjs";
+import { Procedure } from "./procedure.mjs";
+import { createProcedureClient } from "./procedure-client.mjs";
+import { createGuardedProcedureLazy } from "./procedure-utils.mjs";
+import { getRouter } from "./router-utils.mjs";
+
+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;
+}

package/dist/router-hidden.d.mts

@@ -0,0 +1,5 @@
+import type { RouterContract } from "@orpc/contract";
+import type { Lazyable } from "./lazy.mjs";
+import type { AnyRouter } from "./router.mjs";
+export declare function withHiddenRouterContract<T extends Lazyable<AnyRouter>>(router: T, contract: RouterContract): T;
+export declare function getHiddenRouterContract(router: Lazyable<AnyRouter | RouterContract>): RouterContract | undefined;

package/dist/router-hidden.mjs

@@ -0,0 +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);
+	} });
+}
+export function getHiddenRouterContract(router) {
+	return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
+}

package/dist/router-utils.d.mts

@@ -0,0 +1,59 @@
+import type { AnyProcedureContract, AugmentContractRouterOptions, ErrorMap, MergedErrorMap, RouterContract } from "@orpc/contract";
+import type { Promisable } from "@orpc/shared";
+import type { Context, MergedInitialContext } from "./context.mjs";
+import type { Lazyable } from "./lazy.mjs";
+import type { AnyMiddleware } from "./middleware.mjs";
+import type { AnyProcedure, ProcedureConfig } from "./procedure.mjs";
+import type { AnyRouter } from "./router.mjs";
+import { Lazy } from "./lazy.mjs";
+import { Procedure } from "./procedure.mjs";
+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>;
+/**
+* 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>>;
+export {};

package/dist/router-utils.mjs

@@ -0,0 +1,191 @@
+import { mergeErrorMap, ProcedureContract, resolveMetaPlugins } from "@orpc/contract";
+import { getOwn, isTypescriptObject, omit } from "@orpc/shared";
+import { Lazy, unlazy } from "./lazy.mjs";
+import { Procedure } from "./procedure.mjs";
+import { createContractProcedure } from "./procedure-utils.mjs";
+import { getHiddenRouterContract } from "./router-hidden.mjs";
+export function augmentRouter(router, options) {
+	if (router instanceof Lazy) {
+		const [meta, metaPlugins] = resolveMetaPlugins(options.meta, options.metaPlugins, router["~orpc"].metaPlugins);
+		const enhanced = new Lazy({
+			meta,
+			metaPlugins,
+			async loader() {
+				const { default: unlaziedRouter } = await unlazy(router);
+				const enhanced = augmentRouter(unlaziedRouter, options);
+				return unlazy(enhanced);
+			}
+		});
+		return enhanced;
+	}
+	if (router instanceof Procedure) {
+		const [meta, metaPlugins] = resolveMetaPlugins(options.meta, options.metaPlugins, router["~orpc"].metaPlugins);
+		const enhanced = 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]
+		});
+		return enhanced;
+	}
+	if (!isTypescriptObject(router)) {
+		return router;
+	}
+	const enhanced = {};
+	for (const [key, child] of Object.entries(router)) {
+		enhanced[key] = augmentRouter(child, options);
+	}
+	return enhanced;
+}
+export function augmentImplementedRouter(router, options) {
+	if (router instanceof Lazy) {
+		const enhanced = new Lazy({
+			...router["~orpc"],
+			async loader() {
+				const { default: unlaziedRouter } = await unlazy(router);
+				const enhanced = augmentImplementedRouter(unlaziedRouter, options);
+				return unlazy(enhanced);
+			}
+		});
+		return enhanced;
+	}
+	if (router instanceof Procedure) {
+		const enhanced = new Procedure({
+			...omit(options, ["middlewares"]),
+			...router["~orpc"],
+			orderedMiddlewares: [...options.middlewares.map((middleware) => ({
+				middleware,
+				inputSchemasLengthAtUse: 0,
+				outputSchemasLengthAtUse: 0
+			})), ...router["~orpc"].orderedMiddlewares]
+		});
+		return enhanced;
+	}
+	if (!isTypescriptObject(router)) {
+		return router;
+	}
+	const enhanced = {};
+	for (const [key, child] of Object.entries(router)) {
+		enhanced[key] = augmentImplementedRouter(child, options);
+	}
+	return enhanced;
+}
+
+export 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);
+}
+export function getRouter(router, path) {
+	let current = router;
+	for (let i = 0; i < path.length; i++) {
+		const segment = path[i];
+		if (!isTypescriptObject(current)) {
+			return undefined;
+		}
+		if (current instanceof Procedure) {
+			return undefined;
+		}
+		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 unwrapped = await unlazy(lazied);
+				const next = getRouter(unwrapped.default, rest);
+				return await unlazy(next);
+			}
+		});
+	}
+	if (!isTypescriptObject(current)) {
+		return undefined;
+	}
+	return current;
+}
+export 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 !== undefined) {
+		router = hiddenContract;
+	}
+	if (router instanceof ProcedureContract) {
+		callback(router, path.slice());
+		return;
+	}
+	if (!isTypescriptObject(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();
+	}
+}
+export async function walkProcedureContractsAsync(router, callback, path = []) {
+	const hiddenContract = getHiddenRouterContract(router);
+	if (hiddenContract !== undefined) {
+		router = hiddenContract;
+	}
+	if (router instanceof ProcedureContract) {
+		await callback(router, path);
+		return;
+	}
+	if (!isTypescriptObject(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]);
+		}
+	}
+}
+
+export async function unlazyRouter(router) {
+	if (router instanceof Procedure) {
+		return router;
+	}
+	if (!isTypescriptObject(router)) {
+		return router;
+	}
+	const unlazied = {};
+	for (const key of Object.keys(router)) {
+		const item = router[key];
+		const { default: unlaziedRouter } = await unlazy(item);
+		unlazied[key] = await unlazyRouter(unlaziedRouter);
+	}
+	return unlazied;
+}

package/dist/router.d.mts

@@ -0,0 +1,61 @@
+import type { InferSchemaInput, InferSchemaOutput, ORPCErrorFromErrorMap, ProcedureContract, RouterContract, ThrowableError } from "@orpc/contract";
+import type { Context, MergedContext } from "./context.mjs";
+import type { Lazyable } from "./lazy.mjs";
+import type { Procedure } from "./procedure.mjs";
+export type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any> | {
+	[k: string]: Lazyable<Router<TInitialContext>>;
+};
+export type ContractedRouter<
+	T extends RouterContract,
+	TInitialContext extends Context
+> = T extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<TInitialContext, any, $InputSchema, $OutputSchema, $ErrorMap> : { [K in keyof T]: T[K] extends RouterContract ? Lazyable<ContractedRouter<T[K], TInitialContext>> : never };
+export type AnyRouter = Router<any>;
+export type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer $> ? $ : never;
+/**
+* Infer all initial context of the router.
+*
+* @remarks
+* **Note**: A procedure is a router too.
+*
+* @see {@link https://orpc.dev/docs/router#infer-router-initial-contexts | Router - Infer Router Initial Contexts}
+*/
+export type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any> ? UInitialContext : { [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never };
+/**
+* Infer all current context of the router.
+*
+* @remarks
+* **Note**: A procedure is a router too.
+*
+* @see {@link https://orpc.dev/docs/router#infer-router-final-contexts | Router - Infer Router Final Contexts}
+*/
+export type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, infer UInjectedContext, any, any, any> ? MergedContext<UInitialContext, UInjectedContext> : { [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterFinalContexts<U> : never };
+/**
+* Infer all router inputs.
+*
+* @remarks
+* **Note**: A procedure is a router too.
+*
+* @see {@link https://orpc.dev/docs/router#infer-router-inputs | Router - Infer Router Inputs}
+*/
+export type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any> ? InferSchemaInput<UInputSchema> : { [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never };
+/**
+* Infer all router outputs.
+*
+* @remarks
+* **Note**: A procedure is a router too.
+*
+* @see {@link https://orpc.dev/docs/router#infer-router-outputs | Router - Infer Router Outputs}
+*/
+export type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any> ? InferSchemaOutput<UOutputSchema> : { [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never };
+/**
+* Infer the union of throwable errors for entire router.
+*
+* @see {@link https://orpc.dev/docs/router#infer-router-error | Router - Infer Router Error}
+*/
+export type InferRouterError<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : { [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterError<U> : never }[keyof T];
+/**
+* Infer throwable errors for each procedure, preserving the router shape.
+*
+* @see {@link https://orpc.dev/docs/router#infer-router-errors | Router - Infer Router Errors}
+*/
+export type InferRouterErrors<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : { [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterErrors<U> : never };

package/dist/router.mjs

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "2.0.0-beta.46",
+  "version": "2.0.0-beta.48",
   "description": "Build typesafe APIs with oRPC: RPC and OpenAPI support, middleware, and adapters for Node.js, Bun, Deno, Fetch, Fastify, WebSocket, AWS Lambda, and more",
   "license": "MIT",
   "funding": [
@@ -117,19 +117,19 @@
     }
   },
   "dependencies": {
-    "@orpc/client": "2.0.0-beta.46",
-    "@orpc/contract": "2.0.0-beta.46",
-    "@orpc/shared": "2.0.0-beta.46",
-    "@standard-server/aws-lambda": "~0.11.0",
-    "@standard-server/core": "~0.11.0",
-    "@standard-server/fastify": "~0.11.0",
-    "@standard-server/fetch": "~0.11.0",
-    "@standard-server/node": "~0.11.0",
-    "@standard-server/peer": "~0.11.0",
+    "@orpc/client": "2.0.0-beta.48",
+    "@orpc/contract": "2.0.0-beta.48",
+    "@orpc/shared": "2.0.0-beta.48",
+    "@standard-server/aws-lambda": "~0.14.0",
+    "@standard-server/core": "~0.14.0",
+    "@standard-server/fastify": "~0.14.0",
+    "@standard-server/fetch": "~0.14.0",
+    "@standard-server/node": "~0.14.0",
+    "@standard-server/peer": "~0.14.0",
     "cookie": "^2.0.1"
   },
   "devDependencies": {
-    "crossws": "^0.4.15",
+    "crossws": "^0.4.17",
     "fastify": "^5.12.7",
     "supertest": "^7.3.1",
     "ws": "^8.22.0",

package/dist/adapters/aws-lambda/index.d.ts

@@ -1,51 +0,0 @@
-import { MaybeOptionalOptions } from '@orpc/shared';
-import { SendStandardResponseOptions, AnyAPIGatewayProxyEvent, HttpResponseStream } from '@standard-server/aws-lambda';
-export { APIGatewayProxyEvent, APIGatewayProxyEventV2, AnyAPIGatewayProxyEvent, AwsLambdaGlobal, HttpResponseStream } from '@standard-server/aws-lambda';
-import { Context } from '../../index.js';
-import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
-import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-import { Router } from '../../index.js';
-import { RPCHandlerCodecOptions } from '../standard/index.js';
-import '@orpc/client';
-import '@orpc/contract';
-import '@standard-server/core';
-
-type AwsLambdaHandlerHandleResult = {
-    matched: true;
-} | {
-    matched: false;
-};
-interface AwsLambdaHandlerOptions<_T extends Context> {
-    /**
-     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
-     */
-    sendStandardResponse?: SendStandardResponseOptions | undefined;
-}
-/**
- * Requires the AWS Lambda Node.js runtime with response streaming enabled,
- * handlers should be wrapped with `awslambda.streamifyResponse`.
- */
-declare class AwsLambdaHandler<T extends Context> {
-    private readonly standardHandler;
-    private readonly sendStandardResponseOptions;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<AwsLambdaHandlerOptions<T>>);
-    handle(event: AnyAPIGatewayProxyEvent, responseStream: HttpResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<AwsLambdaHandlerHandleResult>;
-}
-
-interface RPCHandlerOptions<T extends Context> extends AwsLambdaHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
-}
-/**
- * Serves an oRPC router over the RPC protocol on AWS Lambda,
- * behind API Gateway or Lambda Function URLs.
- *
- * @remarks
- * **Warning**: Requires the Lambda Node.js runtime with response streaming enabled, so handlers must be wrapped with `awslambda.streamifyResponse`.
- *
- * @see {@link https://orpc.dev/docs/adapters/aws-lambda | AWS Lambda Adapter}
- */
-declare class RPCHandler<T extends Context> extends AwsLambdaHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
-
-export { AwsLambdaHandler, RPCHandler };
-export type { AwsLambdaHandlerHandleResult, AwsLambdaHandlerOptions, RPCHandlerOptions };

package/dist/adapters/crossws/index.d.ts

@@ -1,63 +0,0 @@
-import { MaybeOptionalOptions } from '@orpc/shared';
-import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standard-server/peer';
-import { Message, Peer } from 'crossws';
-import { Context } from '../../index.js';
-import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
-import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-import { Router } from '../../index.js';
-import { RPCHandlerCodecOptions } from '../standard/index.js';
-import '@orpc/client';
-import '@orpc/contract';
-import '@standard-server/core';
-
-type CrosswsPeerLike = Pick<Peer, 'send'>;
-type CrosswsMessageLike = Pick<Message, 'rawData' | 'uint8Array'>;
-interface experimental_CrosswsHandlerOptions<_T extends Context> {
-    /**
-     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    encodePeerMessage?: EncodePeerMessageOptions | undefined;
-    /**
-     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    decodePeerMessage?: DecodePeerMessageOptions | undefined;
-}
-declare class experimental_CrosswsHandler<T extends Context> {
-    private readonly handler;
-    private readonly peers;
-    private readonly encodePeerMessageOptions;
-    private readonly decodePeerMessageOptions;
-    constructor(handler: StandardHandler<T>, options?: NoInfer<experimental_CrosswsHandlerOptions<T>>);
-    /**
-     * Handles a single WebSocket message.
-     *
-     * Message order matters. Call this immediately after receiving a message,
-     * before any other async work, to preserve ordering.
-     *
-     * @param ws The crossws peer instance. Use the same instance for all messages.
-     */
-    message(ws: CrosswsPeerLike, message: CrosswsMessageLike, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
-        matched: boolean;
-    }>;
-    /**
-     * Cleans up peer state for a closed WebSocket.
-     *
-     * @param ws The same crossws peer instance passed to `.message()`.
-     */
-    close(ws: CrosswsPeerLike): Promise<void>;
-}
-
-interface experimental_RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, experimental_CrosswsHandlerOptions<T> {
-}
-/**
- * Serves an oRPC router over the RPC protocol on a WebSocket connection
- * managed by [crossws](https://github.com/h3js/crossws).
- *
- * @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
- */
-declare class experimental_RPCHandler<T extends Context> extends experimental_CrosswsHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<experimental_RPCHandlerOptions<T>>);
-}
-
-export { experimental_CrosswsHandler, experimental_RPCHandler };
-export type { CrosswsMessageLike, CrosswsPeerLike, experimental_CrosswsHandlerOptions, experimental_RPCHandlerOptions };

package/dist/adapters/fastify/index.d.ts

@@ -1,42 +0,0 @@
-import { MaybeOptionalOptions } from '@orpc/shared';
-import { SendStandardResponseOptions, AnyFastifyRequest, AnyFastifyReply } from '@standard-server/fastify';
-import { Context } from '../../index.js';
-import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
-import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-import { Router } from '../../index.js';
-import { RPCHandlerCodecOptions } from '../standard/index.js';
-import '@orpc/client';
-import '@orpc/contract';
-import '@standard-server/core';
-
-type FastifyHandlerHandleResult = {
-    matched: true;
-} | {
-    matched: false;
-};
-interface FastifyHandlerOptions<_T extends Context> {
-    /**
-     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
-     */
-    sendStandardResponse?: SendStandardResponseOptions | undefined;
-}
-declare class FastifyHandler<T extends Context> {
-    private readonly standardHandler;
-    private readonly sendStandardResponseOptions;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FastifyHandlerOptions<T>>);
-    handle(request: AnyFastifyRequest, reply: AnyFastifyReply, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FastifyHandlerHandleResult>;
-}
-
-interface RPCHandlerOptions<T extends Context> extends FastifyHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
-}
-/**
- * Serves an oRPC router over the RPC protocol inside a Fastify server.
- *
- * @see {@link https://orpc.dev/docs/adapters/fastify | Fastify Adapter}
- */
-declare class RPCHandler<T extends Context> extends FastifyHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
-
-export { FastifyHandler, RPCHandler };
-export type { FastifyHandlerHandleResult, FastifyHandlerOptions, RPCHandlerOptions };

package/dist/adapters/fetch/index.d.ts

@@ -1,47 +0,0 @@
-export { R as BodyLimitPlugin } from '../../shared/server.CgBF3Vj1.js';
-import { MaybeOptionalOptions } from '@orpc/shared';
-import { ToFetchResponseOptions } from '@standard-server/fetch';
-import { Context } from '../../index.js';
-import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
-import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-import { Router } from '../../index.js';
-import { RPCHandlerCodecOptions } from '../standard/index.js';
-import '@orpc/client';
-import '@orpc/contract';
-import '@standard-server/core';
-
-type FetchHandlerHandleResult = {
-    matched: true;
-    response: Response;
-} | {
-    matched: false;
-    response?: undefined;
-};
-interface FetchHandlerOptions<_T extends Context> {
-    /**
-     * Options for how to convert the Fetch Response to a Standard Response, like event stream options, etc.
-     */
-    toFetchResponse?: ToFetchResponseOptions | undefined;
-}
-declare class FetchHandler<T extends Context> {
-    private readonly standardHandler;
-    private readonly toFetchResponseOptions;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
-    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FetchHandlerHandleResult>;
-}
-
-interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
-}
-/**
- * Serves an oRPC router over the RPC protocol using the Fetch API
- * (Request/Response), supported by modern runtimes like Deno, Bun,
- * Cloudflare Workers, and browsers.
- *
- * @see {@link https://orpc.dev/docs/adapters/fetch-api | Fetch API Adapter}
- */
-declare class RPCHandler<T extends Context> extends FetchHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
-
-export { FetchHandler, RPCHandler };
-export type { FetchHandlerHandleResult, FetchHandlerOptions, RPCHandlerOptions };