feat(server): unlazyRouter utility (#219)

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

- **New Features**
- Introduced an enhanced router processing capability that converts
deferred configurations into fully accessible structures for streamlined
routing.
  
- **Tests**
- Expanded test coverage to ensure functional correctness and type
consistency of the updated routing mechanism.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: dinwwwh

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

@@ -1,10 +1,11 @@
 import type { MergedErrorMap, Meta, Schema } from '@orpc/contract'
 import type { baseErrorMap, BaseMeta, inputSchema, outputSchema } from '../../contract/tests/shared'
-import type { CurrentContext, InitialContext, ping, pong, router } from '../tests/shared'
+import type { CurrentContext, InitialContext, router } from '../tests/shared'
 import type { Context } from './context'
 import type { Lazy } from './lazy'
 import type { Procedure } from './procedure'
-import type { AccessibleLazyRouter, EnhancedRouter } from './router-utils'
+import type { AccessibleLazyRouter, EnhancedRouter, UnlaziedRouter } from './router-utils'
+import { ping, pong } from '../tests/shared'
 
 it('AccessibleLazyRouter', () => {
     type Accessible = AccessibleLazyRouter<Lazy<typeof router>>
@@ -70,3 +71,16 @@ it('EnhancedRouter', () => {
       >
     >()
 })
+
+it('UnlaziedRouter', () => {
+    type Unlazied = UnlaziedRouter<typeof router>
+
+    expectTypeOf<Unlazied>().toEqualTypeOf({
+      ping,
+      pong,
+      nested: {
+        ping,
+        pong,
+      },
+    })
+})

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

@@ -2,7 +2,7 @@ import { enhanceRoute } from '@orpc/contract'
 import { contract, ping, pingMiddleware, pong, router } from '../tests/shared'
 import { getLazyMeta, isLazy, unlazy } from './lazy'
 import { setHiddenRouterContract } from './router-hidden'
-import { enhanceRouter, getRouter, resolveContractProcedures, traverseContractProcedures } from './router-utils'
+import { enhanceRouter, getRouter, resolveContractProcedures, traverseContractProcedures, unlazyRouter } from './router-utils'
 
 it('getRouter', () => {
   expect(getRouter(router, [])).toEqual(router)
@@ -188,3 +188,16 @@ it('resolveContractProcedures', async () => {
     path: ['nested', 'pong'],
   })
 })
+
+it('unlazyRouter', async () => {
+  const unlazied = await unlazyRouter(router)
+
+  expect(unlazied).toEqual({
+    ping,
+    pong,
+    nested: {
+      ping,
+      pong,
+    },
+  })
+})

packages/server/src/router-utils.ts

@@ -223,3 +223,28 @@ export async function resolveContractProcedures(
     }
   }
 }
+
+export type UnlaziedRouter<T extends AnyRouter> =
+  T extends AnyProcedure
+    ? T
+    : {
+        [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? UnlaziedRouter<U> : never
+      }
+
+export async function unlazyRouter<T extends AnyRouter>(router: T): Promise<UnlaziedRouter<T>> {
+  if (isProcedure(router)) {
+    return router as any
+  }
+
+  const unlazied = {} as Record<string, any>
+
+  for (const key in router) {
+    const item: Lazyable<AnyRouter> = router[key]!
+
+    const { default: unlaziedRouter } = await unlazy(item)
+
+    unlazied[key] = await unlazyRouter(unlaziedRouter)
+  }
+
+  return unlazied as any
+}