@trpc/server 11.0.0-rc.747 → 11.0.0-rc.748

package/dist/unstable-core-do-not-import.js

@@ -66,6 +66,8 @@ exports.isServerDefault = rootConfig.isServerDefault;
 exports.callProcedure = router.callProcedure;
 exports.createCallerFactory = router.createCallerFactory;
 exports.createRouterFactory = router.createRouterFactory;
+exports.getProcedureAtPath = router.getProcedureAtPath;
+exports.lazy = router.lazy;
 exports.mergeRouters = router.mergeRouters;
 exports.TRPC_ERROR_CODES_BY_KEY = codes.TRPC_ERROR_CODES_BY_KEY;
 exports.TRPC_ERROR_CODES_BY_NUMBER = codes.TRPC_ERROR_CODES_BY_NUMBER;

package/dist/unstable-core-do-not-import.mjs

@@ -15,7 +15,7 @@ export { getParseFn } from './unstable-core-do-not-import/parser.mjs';
 export { procedureTypes } from './unstable-core-do-not-import/procedure.mjs';
 export { createBuilder } from './unstable-core-do-not-import/procedureBuilder.mjs';
 export { isServerDefault } from './unstable-core-do-not-import/rootConfig.mjs';
-export { callProcedure, createCallerFactory, createRouterFactory, mergeRouters } from './unstable-core-do-not-import/router.mjs';
+export { callProcedure, createCallerFactory, createRouterFactory, getProcedureAtPath, lazy, mergeRouters } from './unstable-core-do-not-import/router.mjs';
 export { TRPC_ERROR_CODES_BY_KEY, TRPC_ERROR_CODES_BY_NUMBER } from './unstable-core-do-not-import/rpc/codes.mjs';
 export { parseTRPCMessage } from './unstable-core-do-not-import/rpc/parseTRPCMessage.mjs';
 export { isPromise, jsonlStreamConsumer, jsonlStreamProducer } from './unstable-core-do-not-import/stream/jsonl.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "11.0.0-rc.747+64714681c",
+  "version": "11.0.0-rc.748+b19e7e9a6",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -152,5 +152,5 @@
   "peerDependencies": {
     "typescript": ">=5.7.2"
   },
-  "gitHead": "64714681ca127cd859a819d61ce8a990b928baf9"
+  "gitHead": "b19e7e9a640511f49de05bcd4436dc0a514f5e0f"
 }

package/src/@trpc/server/index.ts

@@ -44,6 +44,7 @@ export {
   tracked,
   type TrackedEnvelope,
   isTrackedEnvelope,
+  lazy as experimental_lazy,
 } from '../../unstable-core-do-not-import';
 
 export type {

package/src/adapters/ws.ts

@@ -219,7 +219,7 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
 
         const abortController = new AbortController();
         const result = await callProcedure({
-          procedures: router._def.procedures,
+          _def: router._def,
           path,
           getRawInput: async () => input,
           ctx,

package/src/unstable-core-do-not-import/http/contentType.ts

@@ -1,6 +1,6 @@
 import { TRPCError } from '../error/TRPCError';
-import type { AnyProcedure, ProcedureType } from '../procedure';
-import type { AnyRouter } from '../router';
+import type { ProcedureType } from '../procedure';
+import { getProcedureAtPath, type AnyRouter } from '../router';
 import { isObject, unsetMarker } from '../utils';
 import { parseConnectionParamsFromString } from './parseConnectionParams';
 import type { TRPCAcceptHeader, TRPCRequestInfo } from './types';
@@ -16,7 +16,7 @@ type GetRequestInfoOptions = {
 
 type ContentTypeHandler = {
   isMatch: (opts: Request) => boolean;
-  parse: (opts: GetRequestInfoOptions) => TRPCRequestInfo;
+  parse: (opts: GetRequestInfoOptions) => Promise<TRPCRequestInfo>;
 };
 
 /**
@@ -66,7 +66,7 @@ const jsonContentTypeHandler: ContentTypeHandler = {
   isMatch(req) {
     return !!req.headers.get('content-type')?.startsWith('application/json');
   },
-  parse(opts) {
+  async parse(opts) {
     const { req } = opts;
     const isBatchCall = opts.searchParams.get('batch') === '1';
     const paths = isBatchCall ? opts.path.split(',') : [opts.path];
@@ -110,42 +110,45 @@ const jsonContentTypeHandler: ContentTypeHandler = {
       return acc;
     });
 
-    const calls = paths.map((path, index): TRPCRequestInfo['calls'][number] => {
-      const procedure: AnyProcedure | null =
-        opts.router._def.procedures[path] ?? null;
-      return {
-        path,
-        procedure,
-        getRawInput: async () => {
-          const inputs = await getInputs.read();
-          let input = inputs[index];
+    const calls = await Promise.all(
+      paths.map(
+        async (path, index): Promise<TRPCRequestInfo['calls'][number]> => {
+          const procedure = await getProcedureAtPath(opts.router._def, path);
+          return {
+            path,
+            procedure,
+            getRawInput: async () => {
+              const inputs = await getInputs.read();
+              let input = inputs[index];
 
-          if (procedure?._def.type === 'subscription') {
-            const lastEventId =
-              opts.headers.get('last-event-id') ??
-              opts.searchParams.get('lastEventId') ??
-              opts.searchParams.get('Last-Event-Id');
+              if (procedure?._def.type === 'subscription') {
+                const lastEventId =
+                  opts.headers.get('last-event-id') ??
+                  opts.searchParams.get('lastEventId') ??
+                  opts.searchParams.get('Last-Event-Id');
 
-            if (lastEventId) {
-              if (isObject(input)) {
-                input = {
-                  ...input,
-                  lastEventId: lastEventId,
-                };
-              } else {
-                input ??= {
-                  lastEventId: lastEventId,
-                };
+                if (lastEventId) {
+                  if (isObject(input)) {
+                    input = {
+                      ...input,
+                      lastEventId: lastEventId,
+                    };
+                  } else {
+                    input ??= {
+                      lastEventId: lastEventId,
+                    };
+                  }
+                }
               }
-            }
-          }
-          return input;
-        },
-        result: () => {
-          return getInputs.result()?.[index];
+              return input;
+            },
+            result: () => {
+              return getInputs.result()?.[index];
+            },
+          };
         },
-      };
-    });
+      ),
+    );
 
     const types = new Set(
       calls.map((call) => call.procedure?._def.type).filter(Boolean),
@@ -185,7 +188,7 @@ const formDataContentTypeHandler: ContentTypeHandler = {
   isMatch(req) {
     return !!req.headers.get('content-type')?.startsWith('multipart/form-data');
   },
-  parse(opts) {
+  async parse(opts) {
     const { req } = opts;
     if (req.method !== 'POST') {
       throw new TRPCError({
@@ -198,6 +201,7 @@ const formDataContentTypeHandler: ContentTypeHandler = {
       const fd = await req.formData();
       return fd;
     });
+    const procedure = await getProcedureAtPath(opts.router._def, opts.path);
     return {
       accept: null,
       calls: [
@@ -205,7 +209,7 @@ const formDataContentTypeHandler: ContentTypeHandler = {
           path: opts.path,
           getRawInput: getInputs.read,
           result: getInputs.result,
-          procedure: opts.router._def.procedures[opts.path] ?? null,
+          procedure,
         },
       ],
       isBatchCall: false,
@@ -223,7 +227,7 @@ const octetStreamContentTypeHandler: ContentTypeHandler = {
       .get('content-type')
       ?.startsWith('application/octet-stream');
   },
-  parse(opts) {
+  async parse(opts) {
     const { req } = opts;
     if (req.method !== 'POST') {
       throw new TRPCError({
@@ -241,7 +245,7 @@ const octetStreamContentTypeHandler: ContentTypeHandler = {
           path: opts.path,
           getRawInput: getInputs.read,
           result: getInputs.result,
-          procedure: opts.router._def.procedures[opts.path] ?? null,
+          procedure: await getProcedureAtPath(opts.router._def, opts.path),
         },
       ],
       isBatchCall: false,
@@ -279,7 +283,9 @@ function getContentTypeHandler(req: Request): ContentTypeHandler {
   });
 }
 
-export function getRequestInfo(opts: GetRequestInfoOptions): TRPCRequestInfo {
+export async function getRequestInfo(
+  opts: GetRequestInfoOptions,
+): Promise<TRPCRequestInfo> {
   const handler = getContentTypeHandler(opts.req);
-  return handler.parse(opts);
+  return await handler.parse(opts);
 }

package/src/unstable-core-do-not-import/http/resolveResponse.ts

@@ -223,11 +223,11 @@ export async function resolveResponse<TRouter extends AnyRouter>(
 
   type $Context = inferRouterContext<TRouter>;
 
-  const infoTuple: ResultTuple<TRPCRequestInfo> = run(() => {
+  const infoTuple: ResultTuple<TRPCRequestInfo> = await run(async () => {
     try {
       return [
         undefined,
-        getRequestInfo({
+        await getRequestInfo({
           req,
           path: decodeURIComponent(opts.path),
           router,

package/src/unstable-core-do-not-import/procedureBuilder.ts

@@ -637,6 +637,7 @@ function createProcedureCaller(_def: AnyProcedureBuilderDef): AnyProcedure {
   }
 
   procedure._def = _def;
+  procedure.procedure = true;
 
   // FIXME typecast shouldn't be needed - fixittt
   return procedure as unknown as AnyProcedure;

package/src/unstable-core-do-not-import/router.ts

@@ -13,7 +13,13 @@ import type { ProcedureCallOptions } from './procedureBuilder';
 import type { AnyRootTypes, RootConfig } from './rootConfig';
 import { defaultTransformer } from './transformer';
 import type { MaybePromise, ValueOf } from './types';
-import { isFunction, mergeWithoutOverrides, omitPrototype } from './utils';
+import {
+  isFunction,
+  isObject,
+  mergeWithoutOverrides,
+  omitPrototype,
+  run,
+} from './utils';
 
 export interface RouterRecord {
   [key: string]: AnyProcedure | RouterRecord;
@@ -69,6 +75,58 @@ export type RouterCaller<
   },
 ) => DecorateRouterRecord<TRecord>;
 
+const lazySymbol = Symbol('lazy');
+export type Lazy<TAny> = (() => Promise<TAny>) & { [lazySymbol]: true };
+
+type LazyLoader<TAny> = {
+  load: () => Promise<void>;
+  ref: Lazy<TAny>;
+};
+
+/**
+ * Lazy load a router
+ * @see https://trpc.io/docs/server/merging-routers#lazy-load
+ */
+export function lazy<TRouter extends AnyRouter>(
+  getRouter: () => Promise<
+    | TRouter
+    | {
+        [key: string]: TRouter;
+      }
+  >,
+): Lazy<NoInfer<TRouter>> {
+  let cachedPromise: Promise<TRouter> | null = null;
+  const lazyGetter = (() => {
+    if (!cachedPromise) {
+      cachedPromise = run(async (): Promise<TRouter> => {
+        const mod = await getRouter();
+
+        // if the module is a router, return it
+        if (isRouter(mod)) {
+          return mod;
+        }
+
+        const routers = Object.values(mod);
+
+        if (routers.length !== 1 || !isRouter(routers[0])) {
+          throw new Error(
+            "Invalid router module - either define exactly 1 export or return the router directly.\nExample: `experimental_lazy(() => import('./slow.js').then((m) => m.slowRouter))`",
+          );
+        }
+
+        return routers[0];
+      });
+    }
+    return cachedPromise;
+  }) as Lazy<TRouter>;
+  lazyGetter[lazySymbol] = true;
+  return lazyGetter;
+}
+
+function isLazy<TAny>(input: unknown): input is Lazy<TAny> {
+  return typeof input === 'function' && lazySymbol in input;
+}
+
 export interface Router<
   TRoot extends AnyRootTypes,
   TRecord extends RouterRecord,
@@ -79,6 +137,7 @@ export interface Router<
     procedure?: never;
     procedures: TRecord;
     record: TRecord;
+    lazy: Record<string, LazyLoader<AnyRouter>>;
   };
   /**
    * @deprecated use `t.createCallerFactory(router)` instead
@@ -104,10 +163,10 @@ export type inferRouterError<TRouter extends AnyRouter> =
 export type inferRouterMeta<TRouter extends AnyRouter> =
   inferRouterRootTypes<TRouter>['meta'];
 
-function isRouter(
-  procedureOrRouter: ValueOf<CreateRouterOptions>,
-): procedureOrRouter is AnyRouter {
-  return procedureOrRouter._def && 'router' in procedureOrRouter._def;
+function isRouter(value: unknown): value is AnyRouter {
+  return (
+    isObject(value) && isObject(value['_def']) && 'router' in value['_def']
+  );
 }
 
 const emptyRouter = {
@@ -138,7 +197,11 @@ const reservedWords = [
 ];
 
 export type CreateRouterOptions = {
-  [key: string]: AnyProcedure | AnyRouter | CreateRouterOptions;
+  [key: string]:
+    | AnyProcedure
+    | AnyRouter
+    | CreateRouterOptions
+    | Lazy<AnyRouter>;
 };
 
 export type DecorateCreateRouterOptions<
@@ -149,9 +212,11 @@ export type DecorateCreateRouterOptions<
       ? $Value
       : $Value extends Router<any, infer TRecord>
         ? TRecord
-        : $Value extends CreateRouterOptions
-          ? DecorateCreateRouterOptions<$Value>
-          : never
+        : $Value extends Lazy<Router<any, infer TRecord>>
+          ? TRecord
+          : $Value extends CreateRouterOptions
+            ? DecorateCreateRouterOptions<$Value>
+            : never
     : never;
 };
 
@@ -175,10 +240,55 @@ export function createRouterFactory<TRoot extends AnyRootTypes>(
     }
 
     const procedures: Record<string, AnyProcedure> = omitPrototype({});
+    const lazy: Record<string, LazyLoader<AnyRouter>> = omitPrototype({});
+
+    function createLazyLoader(opts: {
+      ref: Lazy<AnyRouter>;
+      path: readonly string[];
+      key: string;
+      aggregate: RouterRecord;
+    }): LazyLoader<AnyRouter> {
+      return {
+        ref: opts.ref,
+        load: async () => {
+          const router = await opts.ref();
+          const lazyPath = [...opts.path, opts.key];
+          const lazyKey = lazyPath.join('.');
+
+          opts.aggregate[opts.key] = step(router._def.record, lazyPath);
+
+          delete lazy[lazyKey];
+
+          // add lazy loaders for nested routers
+          for (const [nestedKey, nestedItem] of Object.entries(
+            router._def.lazy,
+          )) {
+            const nestedRouterKey = [...lazyPath, nestedKey].join('.');
+
+            // console.log('adding lazy', nestedRouterKey);
+            lazy[nestedRouterKey] = createLazyLoader({
+              ref: nestedItem.ref,
+              path: lazyPath,
+              key: nestedKey,
+              aggregate: opts.aggregate[opts.key] as RouterRecord,
+            });
+          }
+        },
+      };
+    }
 
     function step(from: CreateRouterOptions, path: readonly string[] = []) {
       const aggregate: RouterRecord = omitPrototype({});
       for (const [key, item] of Object.entries(from ?? {})) {
+        if (isLazy(item)) {
+          lazy[[...path, key].join('.')] = createLazyLoader({
+            path,
+            ref: item,
+            key,
+            aggregate,
+          });
+          continue;
+        }
         if (isRouter(item)) {
           aggregate[key] = step(item._def.record, [...path, key]);
           continue;
@@ -207,6 +317,7 @@ export function createRouterFactory<TRoot extends AnyRootTypes>(
       _config: config,
       router: true,
       procedures,
+      lazy,
       ...emptyRouter,
       record,
     };
@@ -229,17 +340,42 @@ function isProcedure(
 ): procedureOrRouter is AnyProcedure {
   return typeof procedureOrRouter === 'function';
 }
+
+export async function getProcedureAtPath(
+  _def: AnyRouter['_def'],
+  path: string,
+): Promise<AnyProcedure | null> {
+  let procedure = _def.procedures[path];
+
+  while (!procedure) {
+    const key = Object.keys(_def.lazy).find((key) => path.startsWith(key));
+    // console.log(`found lazy: ${key ?? 'NOPE'} (fullPath: ${fullPath})`);
+
+    if (!key) {
+      return null;
+    }
+    // console.log('loading', key, '.......');
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const lazyRouter = _def.lazy[key]!;
+    await lazyRouter.load();
+
+    procedure = _def.procedures[path];
+  }
+
+  return procedure;
+}
+
 /**
  * @internal
  */
-export function callProcedure(
+export async function callProcedure(
   opts: ProcedureCallOptions<unknown> & {
-    procedures: RouterRecord;
+    _def: AnyRouter['_def'];
     allowMethodOverride?: boolean;
   },
 ) {
   const { type, path } = opts;
-  const proc = opts.procedures[path];
+  const proc = await getProcedureAtPath(opts._def, path);
   if (
     !proc ||
     !isProcedure(proc) ||
@@ -282,10 +418,16 @@ export function createCallerFactory<TRoot extends AnyRootTypes>() {
             return _def;
           }
 
-          const procedure = _def.procedures[fullPath] as AnyProcedure;
+          const procedure = await getProcedureAtPath(_def, fullPath);
 
           let ctx: Context | undefined = undefined;
           try {
+            if (!procedure) {
+              throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: `No procedure found on path "${path}"`,
+              });
+            }
             ctx = isFunction(ctxOrCallback)
               ? await Promise.resolve(ctxOrCallback())
               : ctxOrCallback;
@@ -303,7 +445,7 @@ export function createCallerFactory<TRoot extends AnyRootTypes>() {
               error: getTRPCErrorFromUnknown(cause),
               input: args[0],
               path: fullPath,
-              type: procedure._def.type,
+              type: procedure?._def.type ?? 'unknown',
             });
             throw cause;
           }