@trpc/server 10.28.1 → 10.29.0

package/src/adapters/fastify/fastifyRequestHandler.ts

@@ -1,6 +1,12 @@
+import { Readable } from 'node:stream';
 import { FastifyReply, FastifyRequest } from 'fastify';
 import { AnyRouter, inferRouterContext } from '../../core';
-import { HTTPBaseHandlerOptions, HTTPRequest } from '../../http';
+import {
+  getBatchStreamFormatter,
+  HTTPBaseHandlerOptions,
+  HTTPRequest,
+} from '../../http';
+import { HTTPResponse, ResponseChunk } from '../../http/internals/types';
 import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
 import { NodeHTTPCreateContextOption } from '../node-http';
 
@@ -43,7 +49,48 @@ export async function fastifyRequestHandler<
     body: opts.req.body ?? 'null',
   };
 
-  const result = await resolveHTTPResponse({
+  let resolve: (value: FastifyReply) => void;
+  const promise = new Promise<FastifyReply>((r) => (resolve = r));
+
+  const onHead = (head: HTTPResponse) => {
+    if (!opts.res.statusCode || opts.res.statusCode === 200) {
+      opts.res.statusCode = head.status;
+    }
+    for (const [key, value] of Object.entries(head.headers ?? {})) {
+      /* istanbul ignore if -- @preserve */
+      if (typeof value === 'undefined') {
+        continue;
+      }
+      void opts.res.header(key, value);
+    }
+  };
+
+  let isStream = false;
+  let stream: Readable;
+  const formatter = getBatchStreamFormatter();
+  const onChunk = ([index, string]: ResponseChunk) => {
+    if (index === -1) {
+      // full response, no streaming
+      resolve(opts.res.send(string));
+      return;
+    }
+    if (!isStream) {
+      void opts.res.header('Transfer-Encoding', 'chunked');
+      void opts.res.header(
+        'Vary',
+        opts.res.hasHeader('Vary')
+          ? 'trpc-batch-mode, ' + opts.res.getHeader('Vary')
+          : 'trpc-batch-mode',
+      );
+      stream = new Readable();
+      stream._read = () => {}; // eslint-disable-line @typescript-eslint/no-empty-function -- https://github.com/fastify/fastify/issues/805#issuecomment-369172154
+      resolve(opts.res.send(stream));
+      isStream = true;
+    }
+    stream.push(formatter(index, string));
+  };
+
+  resolveHTTPResponse({
     req,
     createContext,
     path: opts.path,
@@ -53,20 +100,20 @@ export async function fastifyRequestHandler<
     onError(o) {
       opts?.onError?.({ ...o, req: opts.req });
     },
-  });
-
-  const { res } = opts;
-
-  if ('status' in result && (!res.statusCode || res.statusCode === 200)) {
-    res.statusCode = result.status;
-  }
-  for (const [key, value] of Object.entries(result.headers ?? {})) {
-    /* istanbul ignore if -- @preserve */
-    if (typeof value === 'undefined') {
-      continue;
-    }
+    onHead,
+    onChunk,
+  })
+    .then(() => {
+      if (isStream) {
+        stream.push(formatter.end());
+        stream.push(null); // https://github.com/fastify/fastify/issues/805#issuecomment-369172154
+      }
+    })
+    .catch(() => {
+      if (isStream) {
+        stream.push(null);
+      }
+    });
 
-    void res.header(key, value);
-  }
-  await res.send(result.body);
+  return promise;
 }

package/src/adapters/fastify/fastifyTRPCPlugin.ts

@@ -3,7 +3,7 @@ import { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
 import { FastifyHandlerOptions } from '.';
 import { AnyRouter } from '../../core';
 import { NodeHTTPCreateContextFnOptions } from '../node-http';
-import { WSSHandlerOptions, applyWSSHandler } from '../ws';
+import { applyWSSHandler, WSSHandlerOptions } from '../ws';
 import { fastifyRequestHandler } from './fastifyRequestHandler';
 
 export interface FastifyTRPCPluginOptions<TRouter extends AnyRouter> {

package/src/adapters/fetch/fetchRequestHandler.ts

@@ -1,5 +1,6 @@
 import { AnyRouter } from '../../core';
-import { HTTPRequest } from '../../http';
+import { getBatchStreamFormatter, HTTPRequest } from '../../http';
+import { HTTPResponse, ResponseChunk } from '../../http/internals/types';
 import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
 import { FetchHandlerOptions } from './types';
 
@@ -29,7 +30,61 @@ export async function fetchRequestHandler<TRouter extends AnyRouter>(
         : '',
   };
 
-  const result = await resolveHTTPResponse({
+  let resolve: (value: Response) => void;
+  const promise = new Promise<Response>((r) => (resolve = r));
+  let status = 200;
+
+  const onHead = (head: HTTPResponse) => {
+    for (const [key, value] of Object.entries(head.headers ?? {})) {
+      /* istanbul ignore if -- @preserve */
+      if (typeof value === 'undefined') {
+        continue;
+      }
+      if (typeof value === 'string') {
+        resHeaders.set(key, value);
+        continue;
+      }
+      for (const v of value) {
+        resHeaders.append(key, v);
+      }
+    }
+    status = head.status;
+  };
+
+  let isStream = false;
+  let controller: ReadableStreamController<any>;
+  let encoder: TextEncoder;
+  const formatter = getBatchStreamFormatter();
+  const onChunk = ([index, string]: ResponseChunk) => {
+    if (index === -1) {
+      // full response, no streaming
+      const response = new Response(string || null, {
+        status,
+        headers: resHeaders,
+      });
+      resolve(response);
+      return;
+    }
+    if (!isStream) {
+      resHeaders.set('Transfer-Encoding', 'chunked');
+      resHeaders.append('Vary', 'trpc-batch-mode');
+      const stream = new ReadableStream({
+        start(c) {
+          controller = c;
+        },
+      });
+      const response = new Response(stream, {
+        status,
+        headers: resHeaders,
+      });
+      resolve(response);
+      encoder = new TextEncoder();
+      isStream = true;
+    }
+    controller.enqueue(encoder.encode(formatter(index, string)));
+  };
+
+  resolveHTTPResponse({
     req,
     createContext,
     path,
@@ -39,28 +94,20 @@ export async function fetchRequestHandler<TRouter extends AnyRouter>(
     onError(o) {
       opts?.onError?.({ ...o, req: opts.req });
     },
-  });
-
-  for (const [key, value] of Object.entries(result.headers ?? {})) {
-    /* istanbul ignore if -- @preserve */
-    if (typeof value === 'undefined') {
-      continue;
-    }
-
-    if (typeof value === 'string') {
-      resHeaders.set(key, value);
-      continue;
-    }
-
-    for (const v of value) {
-      resHeaders.append(key, v);
-    }
-  }
-
-  const res = new Response(result.body, {
-    status: result.status,
-    headers: resHeaders,
-  });
+    onHead,
+    onChunk,
+  })
+    .then(() => {
+      if (isStream) {
+        controller.enqueue(encoder.encode(formatter.end()));
+        controller.close();
+      }
+    })
+    .catch(() => {
+      if (isStream) {
+        controller.close();
+      }
+    });
 
-  return res;
+  return promise;
 }

package/src/adapters/lambda/index.ts

@@ -1,6 +1,6 @@
 import {
-  CreateAWSLambdaContextOptions,
   awsLambdaRequestHandler,
+  CreateAWSLambdaContextOptions,
 } from '../aws-lambda';
 import { APIGatewayEvent } from '../aws-lambda/utils';
 

package/src/adapters/next.ts

@@ -6,10 +6,10 @@ import type {
 import { AnyRouter } from '../core';
 import { TRPCError } from '../error/TRPCError';
 import { getErrorShape } from '../shared/getErrorShape';
-import { nodeHTTPRequestHandler } from './node-http';
 import {
   NodeHTTPCreateContextFnOptions,
   NodeHTTPHandlerOptions,
+  nodeHTTPRequestHandler,
 } from './node-http';
 
 export type CreateNextContextOptions = NodeHTTPCreateContextFnOptions<

package/src/adapters/node-http/content-type/form-data/fileUploadHandler.ts

@@ -15,7 +15,7 @@ import { createReadStream, createWriteStream, statSync } from 'node:fs';
 import { mkdir, rm, stat as statAsync, unlink } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { basename, dirname, extname, resolve as resolvePath } from 'node:path';
-import { Readable, finished } from 'node:stream';
+import { finished, Readable } from 'node:stream';
 import { promisify } from 'node:util';
 import { streamSlice } from './streamSlice';
 import { MaxPartSizeExceededError, UploadHandler } from './uploadHandler';

package/src/adapters/node-http/content-type/form-data/index.ts

@@ -8,9 +8,9 @@
 /**
  * @see https://github.com/remix-run/remix/blob/0bcb4a304dd2f08f6032c3bf0c3aa7eb5b976901/packages/remix-server-runtime/formData.ts
  */
+import { Readable } from 'node:stream';
 import { CombinedDataTransformer } from '@trpc/server/transformer';
 import { streamMultipart } from '@web3-storage/multipart-parser';
-import { Readable } from 'node:stream';
 import { createNodeHTTPContentTypeHandler } from '../../internals/contentType';
 import { NodeHTTPRequest } from '../../types';
 import { UploadHandler, UploadHandlerPart } from './uploadHandler';

package/src/adapters/node-http/content-type/form-data/streamSlice.ts

@@ -1,28 +1,24 @@
 import { Transform, TransformCallback } from 'node:stream';
 
 class SliceStream extends Transform {
-  #start: number;
-  #end: number;
-  #offset = 0;
-  #emitUp = false;
-  #emitDown = false;
+  private indexOffset = 0;
+  private emitUp = false;
+  private emitDown = false;
 
-  constructor(start = 0, end = Infinity) {
+  constructor(private startIndex = 0, private endIndex = Infinity) {
     super();
-    this.#start = start;
-    this.#end = end;
   }
 
   _transform(chunk: any, _: BufferEncoding, done: TransformCallback): void {
-    this.#offset += chunk.length;
+    this.indexOffset += chunk.length;
 
-    if (!this.#emitUp && this.#offset >= this.#start) {
-      this.#emitUp = true;
-      const start = chunk.length - (this.#offset - this.#start);
+    if (!this.emitUp && this.indexOffset >= this.startIndex) {
+      this.emitUp = true;
+      const start = chunk.length - (this.indexOffset - this.startIndex);
 
-      if (this.#offset > this.#end) {
-        const end = chunk.length - (this.#offset - this.#end);
-        this.#emitDown = true;
+      if (this.indexOffset > this.endIndex) {
+        const end = chunk.length - (this.indexOffset - this.endIndex);
+        this.emitDown = true;
         this.push(chunk.slice(start, end));
       } else {
         this.push(chunk.slice(start, chunk.length));
@@ -31,10 +27,12 @@ class SliceStream extends Transform {
       return done();
     }
 
-    if (this.#emitUp && !this.#emitDown) {
-      if (this.#offset >= this.#end) {
-        this.#emitDown = true;
-        this.push(chunk.slice(0, chunk.length - (this.#offset - this.#end)));
+    if (this.emitUp && !this.emitDown) {
+      if (this.indexOffset >= this.endIndex) {
+        this.emitDown = true;
+        this.push(
+          chunk.slice(0, chunk.length - (this.indexOffset - this.endIndex)),
+        );
       } else {
         this.push(chunk);
       }
@@ -46,6 +44,6 @@ class SliceStream extends Transform {
   }
 }
 
-export function streamSlice(start = 0, end = Infinity): SliceStream {
-  return new SliceStream(start, end);
+export function streamSlice(startIndex = 0, endIndex = Infinity): SliceStream {
+  return new SliceStream(startIndex, endIndex);
 }

package/src/adapters/node-http/nodeHTTPRequestHandler.ts

@@ -1,7 +1,8 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { AnyRouter } from '../../core';
 import { inferRouterContext } from '../../core/types';
-import { HTTPRequest } from '../../http';
+import { getBatchStreamFormatter, HTTPRequest } from '../../http';
+import { HTTPResponse, ResponseChunk } from '../../http/internals/types';
 import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
 import { nodeHTTPJSONContentTypeHandler } from './content-type/json';
 import { NodeHTTPContentTypeHandler } from './internals/contentType';
@@ -63,7 +64,47 @@ export async function nodeHTTPRequestHandler<
       body: bodyResult.ok ? bodyResult.data : undefined,
     };
 
-    const result = await resolveHTTPResponse({
+    const onHead = (head: HTTPResponse) => {
+      if (
+        'status' in head &&
+        (!opts.res.statusCode || opts.res.statusCode === 200)
+      ) {
+        opts.res.statusCode = head.status;
+      }
+      for (const [key, value] of Object.entries(head.headers ?? {})) {
+        /* istanbul ignore if -- @preserve */
+        if (typeof value === 'undefined') {
+          continue;
+        }
+        opts.res.setHeader(key, value);
+      }
+    };
+
+    const formatter = getBatchStreamFormatter();
+    let isStream = false;
+    const onChunk = ([index, string]: ResponseChunk) => {
+      if (index === -1) {
+        /**
+         * Full response, no streaming. This can happen
+         * - if the response is an error
+         * - if response is empty (HEAD request)
+         */
+        opts.res.end(string);
+        return;
+      }
+      if (!isStream) {
+        opts.res.setHeader('Transfer-Encoding', 'chunked');
+        const vary = opts.res.getHeader('Vary');
+        opts.res.setHeader(
+          'Vary',
+          vary ? 'trpc-batch-mode, ' + vary : 'trpc-batch-mode',
+        );
+        isStream = true;
+      }
+      opts.res.write(formatter(index, string));
+    };
+
+    await resolveHTTPResponse({
       batching: opts.batching,
       responseMeta: opts.responseMeta,
       path: opts.path,
@@ -79,18 +120,16 @@ export async function nodeHTTPRequestHandler<
         });
       },
       contentTypeHandler,
+      onHead,
+      onChunk,
     });
 
-    const { res } = opts;
-    if ('status' in result && (!res.statusCode || res.statusCode === 200)) {
-      res.statusCode = result.status;
+    if (!isStream) {
+      return opts.res;
     }
-    for (const [key, value] of Object.entries(result.headers ?? {})) {
-      if (typeof value === 'undefined') {
-        continue;
-      }
-      res.setHeader(key, value);
-    }
-    res.end(result.body);
+
+    opts.res.write(formatter.end());
+    opts.res.end();
+    return opts.res;
   });
 }

package/src/adapters/ws.ts

@@ -2,14 +2,14 @@ import { IncomingMessage } from 'http';
 import ws from 'ws';
 import {
   AnyRouter,
-  ProcedureType,
   callProcedure,
   inferRouterContext,
+  ProcedureType,
 } from '../core';
-import { TRPCError, getTRPCErrorFromUnknown } from '../error/TRPCError';
+import { getTRPCErrorFromUnknown, TRPCError } from '../error/TRPCError';
 import { getCauseFromUnknown } from '../error/utils';
 import { BaseHandlerOptions } from '../internals/types';
-import { Unsubscribable, isObservable } from '../observable';
+import { isObservable, Unsubscribable } from '../observable';
 import {
   JSONRPC2,
   TRPCClientOutgoingMessage,

package/src/core/initTRPC.ts

@@ -1,8 +1,8 @@
 import {
   DefaultErrorShape,
+  defaultFormatter,
   ErrorFormatter,
   ErrorFormatterShape,
-  defaultFormatter,
 } from '../error/formatter';
 import { createFlatProxy } from '../shared/createProxy';
 import {
@@ -14,10 +14,10 @@ import {
 import { FlatOverwrite, Unwrap } from '../types';
 import {
   CreateRootConfigTypes,
+  isServerDefault,
   RootConfig,
   RootConfigTypes,
   RuntimeConfig,
-  isServerDefault,
 } from './internals/config';
 import { mergeRouters } from './internals/mergeRouters';
 import { createBuilder } from './internals/procedureBuilder';

package/src/core/internals/mergeRouters.ts

@@ -3,9 +3,9 @@ import { CombinedDataTransformer, defaultTransformer } from '../../transformer';
 import {
   AnyRouter,
   AnyRouterDef,
+  createRouterFactory,
   Router,
   RouterDef,
-  createRouterFactory,
 } from '../router';
 import { mergeWithoutOverrides } from './mergeWithoutOverrides';
 

package/src/core/internals/procedureBuilder.ts

@@ -1,13 +1,13 @@
-import { TRPCError, getTRPCErrorFromUnknown } from '../../error/TRPCError';
+import { getTRPCErrorFromUnknown, TRPCError } from '../../error/TRPCError';
 import { MaybePromise, Simplify } from '../../types';
 import {
+  createInputMiddleware,
+  createOutputMiddleware,
   MiddlewareBuilder,
   MiddlewareFunction,
   MiddlewareResult,
-  createInputMiddleware,
-  createOutputMiddleware,
 } from '../middleware';
-import { Parser, inferParser } from '../parser';
+import { inferParser, Parser } from '../parser';
 import {
   AnyMutationProcedure,
   AnyProcedure,
@@ -22,11 +22,11 @@ import { getParseFn } from './getParseFn';
 import { mergeWithoutOverrides } from './mergeWithoutOverrides';
 import {
   DefaultValue as FallbackValue,
+  middlewareMarker,
   Overwrite,
   OverwriteKnown,
   ResolveOptions,
   UnsetMarker,
-  middlewareMarker,
 } from './utils';
 
 type CreateProcedureReturnInput<

package/src/core/router.ts

@@ -1,5 +1,5 @@
-import { TRPCError } from '../error/TRPCError';
 import { DefaultErrorShape, defaultFormatter } from '../error/formatter';
+import { TRPCError } from '../error/TRPCError';
 import { getHTTPStatusCodeFromError } from '../http/getHTTPStatusCode';
 import { TRPC_ERROR_CODES_BY_KEY } from '../rpc';
 import { createRecursiveProxy } from '../shared/createProxy';
@@ -15,9 +15,9 @@ import {
   ProcedureArgs,
 } from './procedure';
 import {
-  ProcedureType,
   inferHandlerInput,
   inferProcedureOutput,
+  ProcedureType,
   procedureTypes,
 } from './types';
 

package/src/deprecated/internals/procedure.ts

@@ -1,11 +1,11 @@
-import { TRPCError, getTRPCErrorFromUnknown } from '../../error/TRPCError';
+import { getTRPCErrorFromUnknown, TRPCError } from '../../error/TRPCError';
 import { getCauseFromUnknown } from '../../error/utils';
 import { InferLast } from '../../types';
 import { ProcedureType } from '../router';
 import {
   MiddlewareFunction,
-  MiddlewareResult,
   middlewareMarker,
+  MiddlewareResult,
 } from './middlewares';
 
 export type ProcedureParserZodEsque<TInput, TOutput> = {

package/src/deprecated/interop.ts

@@ -10,10 +10,10 @@ import {
 } from '../core/middleware';
 import { Procedure } from '../core/procedure';
 import {
+  createRouterFactory,
   ProcedureRecord as NewProcedureRecord,
   Router as NewRouter,
   RouterDef,
-  createRouterFactory,
 } from '../core/router';
 import {
   AnyRouter as AnyOldRouter,

package/src/deprecated/router.ts

@@ -1,13 +1,13 @@
 /* eslint-disable @typescript-eslint/ban-types */
-import { TRPCError } from '../error/TRPCError';
 import { defaultFormatter } from '../error/formatter';
+import { TRPCError } from '../error/TRPCError';
 import { getHTTPStatusCodeFromError } from '../http/getHTTPStatusCode';
-import { Observable, inferObservableValue } from '../observable';
+import { inferObservableValue, Observable } from '../observable';
 import {
-  TRPCErrorShape,
-  TRPC_ERROR_CODES_BY_KEY,
   TRPC_ERROR_CODE_KEY,
   TRPC_ERROR_CODE_NUMBER,
+  TRPC_ERROR_CODES_BY_KEY,
+  TRPCErrorShape,
 } from '../rpc';
 import {
   CombinedDataTransformer,
@@ -18,14 +18,14 @@ import {
 import { FlatOverwrite, ThenArg } from '../types';
 import { MiddlewareFunction } from './internals/middlewares';
 import {
+  createProcedure,
   CreateProcedureOptions,
   CreateProcedureWithInput,
   CreateProcedureWithInputOutputParser,
   CreateProcedureWithoutInput,
+  inferProcedureFromOptions,
   Procedure,
   ProcedureCallOptions,
-  createProcedure,
-  inferProcedureFromOptions,
 } from './internals/procedure';
 import { MigrateRouter, migrateRouter } from './interop';
 

package/src/error/formatter.ts

@@ -1,8 +1,8 @@
 import { ProcedureType } from '../core';
 import {
-  TRPCErrorShape,
   TRPC_ERROR_CODE_KEY,
   TRPC_ERROR_CODE_NUMBER,
+  TRPCErrorShape,
 } from '../rpc';
 import { TRPCError } from './TRPCError';
 

package/src/http/batchStreamFormatter.ts

@@ -0,0 +1,29 @@
+/**
+ * Format a batch response as a line-delimited JSON stream
+ * that the `unstable_httpBatchStreamLink` can parse:
+ *
+ * @example
+ * ```ts
+ * const formatter = getBatchStreamFormatter();
+ * res.send(formatter(1, 'response #2'));
+ * res.send(formatter(0, 'response #1'));
+ * res.send(formatter.end());
+ * ```
+ *
+ * Expected format:
+ * ```json
+ * {"1":"response #2"
+ * ,"0":"response #1"
+ * }
+ * ```
+ */
+export function getBatchStreamFormatter() {
+  let first = true;
+  function format(index: number, string: string) {
+    const prefix = first ? '{' : ',';
+    first = false;
+    return `${prefix}"${index}":${string}\n`;
+  }
+  format.end = () => '}';
+  return format;
+}

package/src/http/getHTTPStatusCode.ts

@@ -1,6 +1,6 @@
 import { TRPCError } from '../error/TRPCError';
 import { invert } from '../internals/invert';
-import { TRPCResponse, TRPC_ERROR_CODES_BY_KEY } from '../rpc';
+import { TRPC_ERROR_CODES_BY_KEY, TRPCResponse } from '../rpc';
 
 export const TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
 type ValueOf<TType> = TType[keyof TType];

package/src/http/index.ts

@@ -1,3 +1,4 @@
 export * from './getHTTPStatusCode';
 export * from './resolveHTTPResponse';
 export * from './types';
+export * from './batchStreamFormatter';

package/src/http/internals/types.ts

@@ -1,8 +1,8 @@
 import {
   AnyRouter,
-  ProcedureType,
   inferRouterContext,
   inferRouterError,
+  ProcedureType,
 } from '../../core';
 import { TRPCError } from '../../error/TRPCError';
 import { TRPCResponse } from '../../rpc';
@@ -17,6 +17,8 @@ export interface HTTPResponse {
   body?: string;
 }
 
+export type ResponseChunk = [procedureIndex: number, responseBody: string];
+
 /**
  * @internal
  */
@@ -29,4 +31,10 @@ export type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
   paths?: string[];
   type: ProcedureType | 'unknown';
   errors: TRPCError[];
+  /**
+   * `true` if the `ResponseMeta` are being
+   * generated without knowing the response data
+   * (e.g. for streaming requests).
+   */
+  eagerGeneration: boolean;
 }) => ResponseMeta;