feat(server): InferRouterInitialContexts & InferRouterCurrentContexts (#201)

Author: dinwwwh

apps/content/docs/router.md

@@ -82,7 +82,9 @@ export default {
 
 ## Utilities
 
-### Infer Router Input
+> **Note:** Every [procedure](/docs/procedure) is also a router, so you can apply these utilities to procedures as well.
+
+### Infer Router Inputs
 
 ```ts twoslash
 import type { router } from './shared/planet'
@@ -94,9 +96,9 @@ export type Inputs = InferRouterInputs<typeof router>
 type FindPlanetInput = Inputs['planet']['find']
 ```
 
-This snippet automatically extracts the expected input types for each procedure in the router.
+Infers the expected input types for each procedure in the router.
 
-### Infer Router Output
+### Infer Router Outputs
 
 ```ts twoslash
 import type { router } from './shared/planet'
@@ -108,4 +110,32 @@ export type Outputs = InferRouterOutputs<typeof router>
 type FindPlanetOutput = Outputs['planet']['find']
 ```
 
-Similarly, this utility infers the output types, ensuring that your application correctly handles the results from each procedure.
+Infers the expected output types for each procedure in the router.
+
+### Infer Router Initial Contexts
+
+```ts twoslash
+import type { router } from './shared/planet'
+// ---cut---
+import type { InferRouterInitialContexts } from '@orpc/server'
+
+export type InitialContexts = InferRouterInitialContexts<typeof router>
+
+type FindPlanetInitialContext = InitialContexts['planet']['find']
+```
+
+Infers the [initial context](/docs/context#initial-context) types defined for each procedure.
+
+### Infer Router Current Contexts
+
+```ts twoslash
+import type { router } from './shared/planet'
+// ---cut---
+import type { InferRouterCurrentContexts } from '@orpc/server'
+
+export type CurrentContexts = InferRouterCurrentContexts<typeof router>
+
+type FindPlanetCurrentContext = CurrentContexts['planet']['find']
+```
+
+Infers the [current context](/docs/context#combining-initial-and-execution-context) types, which combine the initial context with the execution context and pass it to the handler.

packages/server/src/router.test-d.ts

@@ -4,7 +4,7 @@ import type { CurrentContext, InitialContext } from '../tests/shared'
 import type { Context } from './context'
 import type { Lazy } from './lazy'
 import type { Procedure } from './procedure'
-import type { AdaptedRouter, InferRouterInitialContext, InferRouterInputs, InferRouterOutputs, Router } from './router'
+import type { AdaptedRouter, InferRouterCurrentContexts, InferRouterInitialContext, InferRouterInitialContexts, InferRouterInputs, InferRouterOutputs, Router } from './router'
 import { ping, pong, router } from '../tests/shared'
 
 describe('Router', () => {
@@ -23,6 +23,20 @@ it('InferRouterInitialContext', () => {
   expectTypeOf<InferRouterInitialContext<typeof pong>>().toEqualTypeOf<Context>()
 })
 
+it('InferRouterInitialContexts', () => {
+  expectTypeOf<InferRouterInitialContexts<typeof router>['ping']>().toEqualTypeOf<InitialContext>()
+  expectTypeOf<InferRouterInitialContexts<typeof router>['nested']['ping']>().toEqualTypeOf<InitialContext>()
+  expectTypeOf<InferRouterInitialContexts<typeof router>['pong']>().toEqualTypeOf<Context>()
+  expectTypeOf<InferRouterInitialContexts<typeof router>['nested']['pong']>().toEqualTypeOf<Context>()
+})
+
+it('InferRouterCurrentContexts', () => {
+  expectTypeOf<InferRouterCurrentContexts<typeof router>['ping']>().toEqualTypeOf<CurrentContext>()
+  expectTypeOf<InferRouterCurrentContexts<typeof router>['nested']['ping']>().toEqualTypeOf<CurrentContext>()
+  expectTypeOf<InferRouterCurrentContexts<typeof router>['pong']>().toEqualTypeOf<Context>()
+  expectTypeOf<InferRouterCurrentContexts<typeof router>['nested']['pong']>().toEqualTypeOf<Context>()
+})
+
 it('InferRouterInputs', () => {
     type Inferred = InferRouterInputs<typeof router>
 

packages/server/src/router.ts

@@ -28,6 +28,22 @@ export type InferRouterInitialContext<T extends AnyRouter> = T extends Router<in
   ? UInitialContext
   : never
 
+export type InferRouterInitialContexts<T extends AnyRouter> =
+  T extends Lazy<infer U extends AnyRouter> ? InferRouterInitialContexts<U>
+    : T extends Procedure<infer UInitialContext, any, any, any, any, any, any>
+      ? UInitialContext
+      : {
+          [K in keyof T]: T[K] extends AnyRouter ? InferRouterInitialContexts<T[K]> : never
+        }
+
+export type InferRouterCurrentContexts<T extends AnyRouter> =
+  T extends Lazy<infer U extends AnyRouter> ? InferRouterCurrentContexts<U>
+    : T extends Procedure<any, infer UCurrentContext, any, any, any, any, any>
+      ? UCurrentContext
+      : {
+          [K in keyof T]: T[K] extends AnyRouter ? InferRouterCurrentContexts<T[K]> : never
+        }
+
 export type InferRouterInputs<T extends AnyRouter> =
   T extends Lazy<infer U extends AnyRouter> ? InferRouterInputs<U>
     : T extends Procedure<any, any, infer UInputSchema, any, any, any, any>