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

package/dist/router-utils.mjs

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

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