How to create a generic procedure?

[NMNMCC]

I have the following types to implement on-demand data retrieval (similar to GraphQL):

/**
 * Array selection descriptor for arrays.
 * Tuple of [item selection, pagination options].
 * - select: selection applied to each item
 * - option.offset: 0-based start index
 * - option.length: number of items to include (optional)
 * @template TBaseItem Item type of the source array
 */
export type ArraySelect<TBaseItem> = [
	select: Select<TBaseItem>,
	option?: {
		/** 0-based start index */
		offset: number;
		/** Number of items to include (to end if omitted) */
		length?: number;
	},
];

/** Select all fields at current depth (shallow) */
export type SelectAll = "*";

/** Select all fields recursively (deep) */
export type SelectDeepAll = "**";

/**
 * Flexible selection type depending on the base type:
 * - Array → ArraySelect of its item type
 * - Object → partial map of keys to nested Select, or wildcards "*" / "**"
 * - Scalar → true
 * @template TBase Base type to select from
 */
export type Select<TBase> = (TBase extends Date ? string : TBase) extends object
	// Is Object
	? TBase extends Array<infer TBaseItem>
		// Is Array
		? ArraySelect<TBaseItem>
		// Is Object, But Not Array
	:
		| Partial<{ [TKey in keyof TBase]: Select<TBase[TKey]> }>
		| SelectAll
		| SelectDeepAll
	// Is Scalar
	: true;

/**
 * Result type for array selections: an array of selected item results.
 * @template TBaseItem Item type of the source array
 * @template TSelect Array selection applied to items
 */
export type ArrayResult<
	TBaseItem,
	TSelect extends ArraySelect<TBaseItem>,
> = Result<TBaseItem, TSelect[0]>[];

/**
 * Transform TBase into the shape described by TSelect.
 * Rules:
 * - Array → ArrayResult of item Result using the item selection (tuple[0])
 * - Object + "*" → Shallow<TBase>
 * - Object + "**" → TBase (deep copy)
 * - Object + field map → object with only selected keys, each recursively transformed
 * - Scalar → TBase
 * @template TBase Base type to transform
 * @template TSelect Selection to apply
 */
export type Result<TBase, TSelect extends Select<TBase>> = TBase extends object
	// Is Object
	? TBase extends Array<infer TBaseItem>
		// Is Array -> ArrayResult
		? ArrayResult<
			TBaseItem,
			TSelect extends ArraySelect<TBaseItem> ? TSelect : never
		>
		// Is Object, But Not Array
	: TSelect extends SelectAll
		// Select All (Shallow)
		? Shallow<TBase>
	: TSelect extends SelectDeepAll
		// Select Deep All
		? TBase
	: {
		[
			K in keyof TSelect as K extends keyof TBase
				? TSelect[K] extends Select<TBase[K]> ? K
				: never
				: never
		]: K extends keyof TBase
			// K Is In TBase
			? TSelect[K] extends Select<TBase[K]>
				// TSelect[K] Is Select
				? Result<TBase[K], TSelect[K]>
			: never
			: never;
	}
	// Is Scalar
	: TBase;

However, this requires the type of select to determine the type of result, like:

type get = <TSelect extends Select<Base>>(select: TSelect) => Result<Base, TSelect>

Currently, oRPC seems unable to do this?

[dosubot[bot]]

Hi @NMNMCC! I'm Dosu and I’m helping the orpc team.

oRPC does not currently support generic procedures where the output type is inferred from the input type parameter, such as the select/result pattern you described. The framework defines API contracts using static input and output schemas (often with zod), and TypeScript's type inference limitations prevent propagating arbitrary generic relationships from input to output through oRPC's abstraction layers. There are workarounds using direct function types, but these break features like runtime validation and OpenAPI generation. This is a known challenge and limitation in the codebase, and while there are aspirations and partial attempts to support this pattern, it's not natively possible at the moment see contract README.

To reply, just mention @dosu.

---

^{How did I do? Good | Irrelevant | Incorrect | Verbose | Hallucination | Report 🐛 | Other}    

[NMNMCC]

@dosu Can you give me the workaround example?

[dosubot[bot]]

Here are the main workarounds for generic procedures in oRPC where the output type depends on the input type parameter:

1. Use direct function types outside oRPC's contract system. You can define a plain TypeScript function like <TSelect extends Select>(select: TSelect) => Result<Base, TSelect>, but you lose runtime validation, OpenAPI generation, and other oRPC features.

2. Cast contracts to any to bypass TypeScript errors. For example, you can cast a contract or router to any when wiring up, but this is a hack, not type-safe, and can break tooling and validation. See discussion and example in the repo: source.

3. Use ContractProcedure to create procedures from contracts, but this approach can leak business logic to the client bundle and is not recommended for production. It also doesn't solve the generic inference problem fully and may still require static typing for OpenAPI and validation source.

The recommended approach is to stick with contract-first patterns and avoid these workarounds unless you are aware of the trade-offs: you will lose type safety, runtime validation, and OpenAPI support. If you need full generic inference, you may need to implement your own layer outside oRPC or accept the limitations of static schemas.

To reply, just mention @dosu.

---

^{How did I do? Good | Irrelevant | Incorrect | Verbose | Hallucination | Report 🐛 | Other}    

[NMNMCC]

Coincidentally, there was also a user on Discord who posted a similar question at almost the same time.

https://discord.com/channels/1308966753044398161/1409453220010524702

[unnoq]

In short, we can’t make something generic if it’s already generic, like a procedure