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

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;
           }

package/src/unstable-core-do-not-import/stream/jsonl.ts

@@ -309,13 +309,6 @@ export function jsonlStreamProducer(opts: JSONLProducerOptions) {
     .pipeThrough(new TextEncoderStream());
 }
 
-class StreamInterruptedError extends Error {
-  constructor(cause?: unknown) {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore https://github.com/tc39/proposal-error-cause
-    super('Invalid response or stream interrupted', { cause });
-  }
-}
 class AsyncError extends Error {
   constructor(public readonly data: unknown) {
     super('Received error from server');
@@ -403,10 +396,6 @@ function createConsumerStream<THead>(
     }),
   );
 }
-/**
- * Represents a chunk of data or stream interruption error that can be enqueued to a controller
- */
-type ControllerChunk = ChunkData | StreamInterruptedError;
 
 /**
  * Creates a handler for managing stream controllers and their lifecycle
@@ -428,29 +417,19 @@ function createStreamsManager(abortController: AbortController) {
    * Creates a stream controller
    */
   function createStreamController() {
-    let originalController: ReadableStreamDefaultController<ControllerChunk>;
-    const stream = new ReadableStream<ControllerChunk>({
+    let originalController: ReadableStreamDefaultController<ChunkData>;
+    const stream = new ReadableStream<ChunkData>({
       start(controller) {
         originalController = controller;
       },
     });
 
     const streamController = {
-      enqueue: (v: ControllerChunk) => originalController.enqueue(v),
+      enqueue: (v: ChunkData) => originalController.enqueue(v),
       close: () => {
         originalController.close();
 
-        // mark as closed and remove methods
-        Object.assign(streamController, {
-          closed: true,
-          close: () => {
-            // noop
-          },
-          enqueue: () => {
-            // noop
-          },
-          getReaderResource: null,
-        });
+        clear();
 
         if (isEmpty()) {
           abortController.abort();
@@ -465,7 +444,26 @@ function createStreamsManager(abortController: AbortController) {
           streamController.close();
         });
       },
+      error: (reason: unknown) => {
+        originalController.error(reason);
+        clear();
+      },
     };
+    function clear() {
+      Object.assign(streamController, {
+        closed: true,
+        close: () => {
+          // noop
+        },
+        enqueue: () => {
+          // noop
+        },
+        getReaderResource: null,
+        error: () => {
+          // noop
+        },
+      });
+    }
 
     return streamController;
   }
@@ -486,10 +484,8 @@ function createStreamsManager(abortController: AbortController) {
    * Cancels all pending controllers and rejects deferred promises
    */
   function cancelAll(reason: unknown) {
-    const error = new StreamInterruptedError(reason);
     for (const controller of controllerMap.values()) {
-      controller.enqueue(error);
-      controller.close();
+      controller.error(reason);
     }
   }
 
@@ -541,9 +537,6 @@ export async function jsonlStreamConsumer<THead>(opts: {
           using reader = controller.getReaderResource();
 
           const { value } = await reader.read();
-          if (value instanceof StreamInterruptedError) {
-            throw value;
-          }
           const [_chunkId, status, data] = value as PromiseChunk;
           switch (status) {
             case PROMISE_STATUS_FULFILLED:
@@ -559,9 +552,6 @@ export async function jsonlStreamConsumer<THead>(opts: {
 
           while (true) {
             const { value } = await reader.read();
-            if (value instanceof StreamInterruptedError) {
-              throw value;
-            }
 
             const [_chunkId, status, data] = value as IterableChunk;
 
@@ -598,11 +588,9 @@ export async function jsonlStreamConsumer<THead>(opts: {
     return data;
   }
 
-  const closeOrAbort = (reason?: unknown) => {
-    const error = new StreamInterruptedError(reason);
-
-    headDeferred?.reject(error);
-    streamManager.cancelAll(error);
+  const closeOrAbort = (reason: unknown) => {
+    headDeferred?.reject(reason);
+    streamManager.cancelAll(reason);
   };
   source
     .pipeTo(
@@ -626,7 +614,7 @@ export async function jsonlStreamConsumer<THead>(opts: {
           const controller = streamManager.getOrCreate(idx);
           controller.enqueue(chunk);
         },
-        close: closeOrAbort,
+        close: () => closeOrAbort(new Error('Stream closed')),
         abort: closeOrAbort,
       }),
       {