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

package/dist/implementer-procedure.d.mts

@@ -0,0 +1,36 @@
+import type { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, ORPCErrorConstructorMap } from "@orpc/contract";
+import type { IntersectPick } from "@orpc/shared";
+import type { BuilderDefinition } from "./builder.mjs";
+import type { Context, MergedContext, MergedInitialContext } from "./context.mjs";
+import type { Middleware } from "./middleware.mjs";
+import type { ProcedureHandler } from "./procedure.mjs";
+import { Procedure } from "./procedure.mjs";
+export declare class ProcedureImplementer<
+	TInitialContext extends Context,
+	TInjectedContext extends Context,
+	TInputSchema extends AnySchema,
+	TOutputSchema extends AnySchema,
+	TErrorMap extends ErrorMap
+> {
+	"~orpc": BuilderDefinition<TInputSchema, TOutputSchema, TErrorMap>;
+	constructor(definition: BuilderDefinition<TInputSchema, TOutputSchema, TErrorMap>);
+	"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>): ProcedureImplementer<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, TOutputSchema, TErrorMap>;
+	"handler"(handler: ProcedureHandler<MergedContext<TInitialContext, TInjectedContext>, InferSchemaOutput<TInputSchema>, InferSchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>>): ImplementedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
+}
+export declare class ImplementedProcedure<
+	TInitialContext extends Context,
+	TInjectedContext extends Context,
+	TInputSchema extends AnySchema,
+	TOutputSchema extends AnySchema,
+	TErrorMap extends ErrorMap
+> extends Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap> {
+	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>): ImplementedProcedure<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, TOutputSchema, TErrorMap>;
+}

package/dist/implementer-procedure.mjs

@@ -0,0 +1,38 @@
+import { Procedure } from "./procedure.mjs";
+export class ProcedureImplementer {
+	"~orpc";
+	constructor(definition) {
+		this["~orpc"] = definition;
+	}
+	"use"(middleware) {
+		return new ProcedureImplementer({
+			...this["~orpc"],
+			orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
+				middleware,
+				inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
+				outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
+			}]
+		});
+	}
+	"handler"(handler) {
+		return new ImplementedProcedure({
+			...this["~orpc"],
+			handler
+		});
+	}
+}
+export class ImplementedProcedure extends Procedure {
+	use(middleware) {
+		
+		
+		
+		return new ImplementedProcedure({
+			...this["~orpc"],
+			orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
+				middleware,
+				inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
+				outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
+			}]
+		});
+	}
+}

package/dist/implementer-router.d.mts

@@ -0,0 +1,78 @@
+import type { ErrorMap, InferRouterContractErrorMap, RouterContract } from "@orpc/contract";
+import type { IntersectPick, Public } from "@orpc/shared";
+import type { Context, MergedContext, MergedInitialContext } from "./context.mjs";
+import type { AnyMiddleware, Middleware } from "./middleware.mjs";
+import type { DecoratedMiddleware } from "./middleware-decorated.mjs";
+import type { ProcedureConfig } from "./procedure.mjs";
+import type { ContractedRouter } from "./router.mjs";
+import type { AugmentedRouterWithMiddlewares } from "./router-utils.mjs";
+import { ProcedureContract } from "@orpc/contract";
+import { ProcedureImplementer } from "./implementer-procedure.mjs";
+import { Lazy } from "./lazy.mjs";
+export declare class SharedRouterImplementer<
+	TContract extends RouterContract,
+	TInitialContext extends Context
+> {
+	private readonly contract;
+	private readonly config;
+	private readonly middlewares;
+	private constructor();
+	static create<
+		TContract extends RouterContract,
+		TInitialContext extends Context
+	>(contract: TContract, config: ProcedureConfig): SharedRouterImplementer<TContract, TInitialContext>;
+	static create<
+		TContract extends RouterContract,
+		TInitialContext extends Context,
+		TInjectedContext extends Context
+	>(contract: TContract, config: ProcedureConfig, middlewares: AnyMiddleware[]): SharedRouterImplementerWithMiddlewares<TContract, TInitialContext, TInjectedContext>;
+	use<
+		$OutContext extends IntersectPick<TInitialContext, $OutContext>,
+		$InContext extends Context = TInitialContext,
+		$ErrorMap extends ErrorMap = InferRouterContractErrorMap<TContract>
+	>(middleware: Middleware<$InContext | TInitialContext, $OutContext, unknown, unknown, $ErrorMap>): RouterImplementerWithMiddlewares<TContract, MergedInitialContext<TInitialContext, object, $InContext>, $OutContext>;
+	middleware<
+		$OutContext extends IntersectPick<TInitialContext, $OutContext>,
+		$Input,
+		$InContext extends Context = TInitialContext,
+		$Output = any
+	>(middleware: Middleware<$InContext | TInitialContext, $OutContext, $Input, $Output, InferRouterContractErrorMap<TContract>>): DecoratedMiddleware<MergedInitialContext<TInitialContext, object, $InContext>, $OutContext, $Input, $Output, object>;
+	router<T extends ContractedRouter<TContract, any>>(router: T): T;
+	lazy<T extends ContractedRouter<TContract, any>>(loader: () => Promise<{
+		default: T;
+	}>): Lazy<T>;
+}
+export interface SharedRouterImplementerWithMiddlewares<
+	TContract extends RouterContract,
+	TInitialContext extends Context,
+	TInjectedContext extends Context
+> {
+	use<
+		$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>,
+		$InContext extends Context = MergedContext<TInitialContext, TInjectedContext>,
+		$ErrorMap extends ErrorMap = InferRouterContractErrorMap<TContract>
+	>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, unknown, unknown, $ErrorMap>): RouterImplementerWithMiddlewares<TContract, MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>>;
+	middleware<
+		$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>,
+		$Input,
+		$InContext extends Context = MergedContext<TInitialContext, TInjectedContext>,
+		$Output = any
+	>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, $Input, $Output, InferRouterContractErrorMap<TContract>>): DecoratedMiddleware<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, $Input, $Output, object>;
+	router<T extends ContractedRouter<TContract, MergedContext<TInitialContext, TInjectedContext>>>(router: T): AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, object>;
+	lazy<T extends ContractedRouter<TContract, any>>(loader: () => Promise<{
+		default: T;
+	}>): Lazy<AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, object>>;
+}
+export type RouterImplementer<
+	TContract extends RouterContract,
+	TInitialContext extends Context
+> = TContract extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? ProcedureImplementer<TInitialContext, object, $InputSchema, $OutputSchema, $ErrorMap> : Public<SharedRouterImplementer<TContract, TInitialContext>> & { [K in keyof TContract]: TContract[K] extends RouterContract ? RouterImplementer<TContract[K], TInitialContext> : never };
+export type RouterImplementerWithMiddlewares<
+	TContract extends RouterContract,
+	TInitialContext extends Context,
+	TInjectedContext extends Context
+> = TContract extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? ProcedureImplementer<TInitialContext, TInjectedContext, $InputSchema, $OutputSchema, $ErrorMap> : SharedRouterImplementerWithMiddlewares<TContract, TInitialContext, TInjectedContext> & { [K in keyof TContract]: TContract[K] extends RouterContract ? RouterImplementerWithMiddlewares<TContract[K], TInitialContext, TInjectedContext> : never };
+export declare function createRouterImplementer<
+	TContract extends RouterContract,
+	TInitialContext extends Context
+>(contract: TContract, config: ProcedureConfig): RouterImplementer<TContract, TInitialContext>;

package/dist/implementer-router.mjs

@@ -0,0 +1,77 @@
+import { ProcedureContract } from "@orpc/contract";
+import { bindMethods } from "@orpc/shared";
+import { ProcedureImplementer } from "./implementer-procedure.mjs";
+import { Lazy } from "./lazy.mjs";
+import { decorateMiddleware } from "./middleware-decorated.mjs";
+import { withHiddenRouterContract } from "./router-hidden.mjs";
+import { augmentImplementedRouter } from "./router-utils.mjs";
+export class SharedRouterImplementer {
+	contract;
+	config;
+	middlewares;
+	constructor(contract, config, middlewares) {
+		this.contract = contract;
+		this.config = config;
+		this.middlewares = middlewares;
+	}
+	static create(contract, config, middlewares = []) {
+		return new SharedRouterImplementer(contract, config, middlewares);
+	}
+	use(middleware) {
+		return createRouterImplementerInternal(this.contract, this.config, [...this.middlewares, middleware]);
+	}
+	middleware(middleware) {
+		const allMiddlewares = [...this.middlewares, middleware];
+		let current = decorateMiddleware(allMiddlewares.shift());
+		for (const mid of allMiddlewares) {
+			current = current.use(mid);
+		}
+		return current;
+	}
+	router(router) {
+		if (this.middlewares.length) {
+			router = augmentImplementedRouter(router, {
+				...this.config,
+				middlewares: this.middlewares
+			});
+		}
+		return withHiddenRouterContract(router, this.contract);
+	}
+	lazy(loader) {
+		return new Lazy({
+			loader: async () => {
+				const { default: router } = await loader();
+				return { default: this.router(router) };
+			},
+			meta: {}
+		});
+	}
+}
+export function createRouterImplementer(contract, config) {
+	return createRouterImplementerInternal(contract, config, []);
+}
+function createRouterImplementerInternal(contract, config, middlewares) {
+	if (contract instanceof ProcedureContract) {
+		return new ProcedureImplementer({
+			...config,
+			...contract["~orpc"],
+			orderedMiddlewares: middlewares.map((middleware) => ({ middleware }))
+		});
+	}
+	const implementer = {};
+	for (const [key, child] of Object.entries(contract)) {
+		implementer[key] = createRouterImplementerInternal(child, config, middlewares);
+	}
+	const shared = bindMethods(SharedRouterImplementer.create(contract, config, middlewares));
+	for (const [key, method] of Object.entries(shared)) {
+		if (key in implementer) {
+			const child = implementer[key];
+			implementer[key] = new Proxy(method, { get(_, p) {
+				return Reflect.get(child, p);
+			} });
+		} else {
+			implementer[key] = method;
+		}
+	}
+	return implementer;
+}

package/dist/implementer.d.mts

@@ -0,0 +1,22 @@
+import type { RouterContract } from "@orpc/contract";
+import type { DefaultInitialContext } from "./builder.mjs";
+import type { Context } from "./context.mjs";
+import type { RouterImplementer } from "./implementer-router.mjs";
+import type { ProcedureConfig } from "./procedure.mjs";
+export type Implementer<
+	TContract extends RouterContract,
+	TInitialContext extends Context
+> = {
+	$context<T extends Context = DefaultInitialContext>(): Implementer<TContract, T & object>;
+	$config(config: ProcedureConfig): Implementer<TContract, TInitialContext>;
+} & RouterImplementer<TContract, TInitialContext>;
+/**
+* Turns a contract into an implementer, used to implement the contract's
+* procedures, routers, and middleware with full type safety.
+*
+* @see {@link https://orpc.dev/docs/contract/implementation#implementer | Contract Implementation - Implementer}
+*/
+export declare function implement<
+	TContract extends RouterContract,
+	TInitialContext extends Context = DefaultInitialContext
+>(contract: TContract, config?: ProcedureConfig): Implementer<TContract, TInitialContext & object>;

package/dist/implementer.mjs

@@ -0,0 +1,30 @@
+import { isTypescriptObject } from "@orpc/shared";
+import { createRouterImplementer } from "./implementer-router.mjs";
+
+export function implement(contract, config = {}) {
+	
+	
+	const routerImplementer = createRouterImplementer(contract, config);
+	const implementer = new Proxy(routerImplementer, { get(_, p) {
+		let method;
+		if (p === "$context") {
+			method = () => implementer;
+		} else if (p === "$config") {
+			method = (incoming) => implement(contract, {
+				...config,
+				...incoming
+			});
+		}
+		const value = Reflect.get(routerImplementer, p);
+		if (method) {
+			if (!isTypescriptObject(value)) {
+				return method;
+			}
+			return new Proxy(method, { get(_, p) {
+				return Reflect.get(value, p);
+			} });
+		}
+		return value;
+	} });
+	return implementer;
+}