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

package/dist/router-utils.js

@@ -1,202 +1,157 @@
-import { mergeErrorMap, ProcedureContract, resolveMetaPlugins } from '@orpc/contract';
-import { getOwn, isNonPrimitive, omit, setOwn } from '@orpc/shared';
-import { Lazy, unlazy } from './lazy.js';
-import { createContractProcedure } from './procedure-utils.js';
-import { Procedure } from './procedure.js';
-import { getHiddenRouterContract } from './router-hidden.js';
-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 (!isNonPrimitive(router)) {
-        return router;
-    }
-    const enhanced = {};
-    for (const [key, child] of Object.entries(router)) {
-        setOwn(enhanced, key, augmentRouter(child, options));
-    }
-    return enhanced;
+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;
 }
-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 (!isNonPrimitive(router)) {
-        return router;
-    }
-    const enhanced = {};
-    for (const [key, child] of Object.entries(router)) {
-        setOwn(enhanced, key, augmentImplementedRouter(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.
- */
-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);
+* 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);
 }
-export function getRouter(router, path) {
-    let current = router;
-    for (let i = 0; i < path.length; i++) {
-        const segment = path[i];
-        if (!isNonPrimitive(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 (!isNonPrimitive(current)) {
-        return undefined;
-    }
-    return current;
+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;
 }
-export function walkProcedureContractsSync(router, callback, path = []) {
-    const lazyResults = [];
-    walkProcedureContractsSyncInternal(router, callback, path.slice(), lazyResults);
-    return lazyResults;
+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 (!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();
-    }
+	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();
+	}
 }
-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 (!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]);
-        }
-    }
+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}
- */
-export 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;
+* 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 };

package/dist/router.d.ts

@@ -1,13 +1,11 @@
-import type { InferSchemaInput, InferSchemaOutput, ORPCErrorFromErrorMap, ProcedureContract, RouterContract, ThrowableError } from '@orpc/contract';
-import type { Context, MergedContext } from './context.ts';
-import type { Lazyable } from './lazy.ts';
-import type { Procedure } from './procedure.ts';
+import { Context, MergedContext } from "./context.js";
+import { Lazyable } from "./lazy.js";
+import { Procedure } from "./procedure.js";
+import { InferSchemaInput, InferSchemaOutput, ORPCErrorFromErrorMap, ProcedureContract, RouterContract, ThrowableError } from "@orpc/contract";
 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;
+  [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;
 /**
@@ -18,9 +16,7 @@ export type InferRouterInitialContext<T extends AnyRouter> = T extends Router<in
  *
  * @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;
-};
+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.
  *
@@ -29,9 +25,7 @@ export type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedur
  *
  * @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;
-};
+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.
  *
@@ -40,9 +34,7 @@ export type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<
  *
  * @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;
-};
+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.
  *
@@ -51,22 +43,16 @@ export type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, an
  *
  * @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;
-};
+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];
+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;
-};
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orpc/server",
-  "version": "2.0.0-beta.49",
+  "version": "2.0.0-beta.50",
   "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",
   "keywords": [
     "api",
@@ -105,15 +105,15 @@
     }
   },
   "dependencies": {
-    "@orpc/client": "2.0.0-beta.49",
-    "@orpc/contract": "2.0.0-beta.49",
-    "@orpc/shared": "2.0.0-beta.49",
-    "@standard-server/aws-lambda": "~0.15.0",
-    "@standard-server/core": "~0.15.0",
-    "@standard-server/fastify": "~0.15.0",
-    "@standard-server/fetch": "~0.15.0",
-    "@standard-server/node": "~0.15.0",
-    "@standard-server/peer": "~0.15.0",
+    "@orpc/client": "2.0.0-beta.50",
+    "@orpc/contract": "2.0.0-beta.50",
+    "@orpc/shared": "2.0.0-beta.50",
+    "@standard-server/aws-lambda": "~0.16.0",
+    "@standard-server/core": "~0.16.0",
+    "@standard-server/fastify": "~0.16.0",
+    "@standard-server/fetch": "~0.16.0",
+    "@standard-server/node": "~0.16.0",
+    "@standard-server/peer": "~0.16.0",
     "cookie": "^2.0.1"
   },
   "devDependencies": {

package/dist/adapters/standard/codec.js

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

package/dist/builder-variants.js

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

package/dist/context.js

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

package/dist/middleware.js

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

package/dist/router-hidden.d.ts

@@ -1,5 +0,0 @@
-import type { RouterContract } from '@orpc/contract';
-import type { Lazyable } from './lazy.ts';
-import type { AnyRouter } from './router.ts';
-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.js

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