@trpc/server 10.28.2 → 10.29.1

package/dist/resolveHTTPResponse-e0047ea2.js

@@ -0,0 +1,256 @@
+import { b as callProcedure } from './config-54786004.js';
+import { T as TRPCError, a as getTRPCErrorFromUnknown } from './TRPCError-7c3909ea.js';
+import { t as transformTRPCResponse, g as getErrorShape } from './transformTRPCResponse-7fcbe472.js';
+import { g as getJsonContentTypeInputs } from './contentType-7354963c.js';
+import { b as getHTTPStatusCode } from './index-ca9a128e.js';
+
+const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
+    GET: 'query',
+    POST: 'mutation',
+};
+const fallbackContentTypeHandler = {
+    getInputs: getJsonContentTypeInputs,
+};
+function initResponse(initOpts) {
+    const { ctx, paths, type, responseMeta, untransformedJSON, errors = [], } = initOpts;
+    let status = untransformedJSON ? getHTTPStatusCode(untransformedJSON) : 200;
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    const eagerGeneration = !untransformedJSON;
+    const data = eagerGeneration
+        ? []
+        : Array.isArray(untransformedJSON)
+            ? untransformedJSON
+            : [untransformedJSON];
+    const meta = responseMeta?.({
+        ctx,
+        paths,
+        type,
+        data,
+        errors,
+        eagerGeneration,
+    }) ?? {};
+    for (const [key, value] of Object.entries(meta.headers ?? {})) {
+        headers[key] = value;
+    }
+    if (meta.status) {
+        status = meta.status;
+    }
+    return {
+        status,
+        headers,
+    };
+}
+async function inputToProcedureCall(procedureOpts) {
+    const { opts, ctx, type, input, path } = procedureOpts;
+    try {
+        const data = await callProcedure({
+            procedures: opts.router._def.procedures,
+            path,
+            rawInput: input,
+            ctx,
+            type,
+        });
+        return {
+            result: {
+                data,
+            },
+        };
+    }
+    catch (cause) {
+        const error = getTRPCErrorFromUnknown(cause);
+        opts.onError?.({ error, path, input, ctx, type: type, req: opts.req });
+        return {
+            error: getErrorShape({
+                config: opts.router._def._config,
+                error,
+                type,
+                path,
+                input,
+                ctx,
+            }),
+        };
+    }
+}
+function caughtErrorToData(cause, errorOpts) {
+    const { router, req, onError } = errorOpts.opts;
+    const error = getTRPCErrorFromUnknown(cause);
+    onError?.({
+        error,
+        path: errorOpts.path,
+        input: errorOpts.input,
+        ctx: errorOpts.ctx,
+        type: errorOpts.type,
+        req,
+    });
+    const untransformedJSON = {
+        error: getErrorShape({
+            config: router._def._config,
+            error,
+            type: errorOpts.type,
+            path: errorOpts.path,
+            input: errorOpts.input,
+            ctx: errorOpts.ctx,
+        }),
+    };
+    const transformedJSON = transformTRPCResponse(router._def._config, untransformedJSON);
+    const body = JSON.stringify(transformedJSON);
+    return {
+        error,
+        untransformedJSON,
+        body,
+    };
+}
+// implementation
+async function resolveHTTPResponse(opts) {
+    const { router, req, unstable_onHead, unstable_onChunk } = opts;
+    if (req.method === 'HEAD') {
+        // can be used for lambda warmup
+        const headResponse = {
+            status: 204,
+        };
+        unstable_onHead?.(headResponse, false);
+        unstable_onChunk?.([-1, '']);
+        return headResponse;
+    }
+    const contentTypeHandler = opts.contentTypeHandler ?? fallbackContentTypeHandler;
+    const batchingEnabled = opts.batching?.enabled ?? true;
+    const type = HTTP_METHOD_PROCEDURE_TYPE_MAP[req.method] ?? 'unknown';
+    let ctx = undefined;
+    let paths;
+    const isBatchCall = !!req.query.get('batch');
+    const isStreamCall = isBatchCall &&
+        unstable_onHead &&
+        unstable_onChunk &&
+        req.headers['trpc-batch-mode'] === 'stream';
+    try {
+        if (opts.error) {
+            throw opts.error;
+        }
+        if (isBatchCall && !batchingEnabled) {
+            throw new Error(`Batching is not enabled on the server`);
+        }
+        /* istanbul ignore if -- @preserve */
+        if (type === 'subscription') {
+            throw new TRPCError({
+                message: 'Subscriptions should use wsLink',
+                code: 'METHOD_NOT_SUPPORTED',
+            });
+        }
+        if (type === 'unknown') {
+            throw new TRPCError({
+                message: `Unexpected request method ${req.method}`,
+                code: 'METHOD_NOT_SUPPORTED',
+            });
+        }
+        const inputs = await contentTypeHandler.getInputs({
+            isBatchCall,
+            req,
+            router,
+            preprocessedBody: opts.preprocessedBody ?? false,
+        });
+        paths = isBatchCall ? opts.path.split(',') : [opts.path];
+        ctx = await opts.createContext();
+        const promises = paths.map((path, index) => inputToProcedureCall({ opts, ctx, type, input: inputs[index], path }));
+        if (!isStreamCall) {
+            /**
+             * Non-streaming response:
+             * - await all responses in parallel, blocking on the slowest one
+             * - create headers with known response body
+             * - return a complete HTTPResponse
+             */
+            const untransformedJSON = await Promise.all(promises);
+            const errors = untransformedJSON.flatMap((response) => 'error' in response ? [response.error] : []);
+            const headResponse = initResponse({
+                ctx,
+                paths,
+                type,
+                responseMeta: opts.responseMeta,
+                untransformedJSON,
+                errors,
+            });
+            unstable_onHead?.(headResponse, false);
+            // return body stuff
+            const result = isBatchCall ? untransformedJSON : untransformedJSON[0]; // eslint-disable-line @typescript-eslint/no-non-null-assertion -- `untransformedJSON` should be the length of `paths` which should be at least 1 otherwise there wouldn't be a request at all
+            const transformedJSON = transformTRPCResponse(router._def._config, result);
+            const body = JSON.stringify(transformedJSON);
+            unstable_onChunk?.([-1, body]);
+            return {
+                status: headResponse.status,
+                headers: headResponse.headers,
+                body,
+            };
+        }
+        /**
+         * Streaming response:
+         * - block on none, call `onChunk` as soon as each response is ready
+         * - create headers with minimal data (cannot know the response body in advance)
+         * - return void
+         */
+        const headResponse = initResponse({
+            ctx,
+            paths,
+            type,
+            responseMeta: opts.responseMeta,
+        });
+        unstable_onHead(headResponse, true);
+        const indexedPromises = new Map(promises.map((promise, index) => [
+            index,
+            promise.then((r) => [index, r]),
+        ]));
+        for (let i = 0; i < paths.length; i++) {
+            const [index, untransformedJSON] = await Promise.race(indexedPromises.values());
+            indexedPromises.delete(index);
+            try {
+                const transformedJSON = transformTRPCResponse(router._def._config, untransformedJSON);
+                const body = JSON.stringify(transformedJSON);
+                unstable_onChunk([index, body]);
+            }
+            catch (cause) {
+                const path = paths[index];
+                const input = inputs[index];
+                const { body } = caughtErrorToData(cause, {
+                    opts,
+                    ctx,
+                    type,
+                    path,
+                    input,
+                });
+                unstable_onChunk([index, body]);
+            }
+        }
+        return;
+    }
+    catch (cause) {
+        // we get here if
+        // - batching is called when it's not enabled
+        // - `createContext()` throws
+        // - `router._def._config.transformer.output.serialize()` throws
+        // - post body is too large
+        // - input deserialization fails
+        // - `errorFormatter` return value is malformed
+        const { error, untransformedJSON, body } = caughtErrorToData(cause, {
+            opts,
+            ctx,
+            type,
+        });
+        const headResponse = initResponse({
+            ctx,
+            paths,
+            type,
+            responseMeta: opts.responseMeta,
+            untransformedJSON,
+            errors: [error],
+        });
+        unstable_onHead?.(headResponse, false);
+        unstable_onChunk?.([-1, body]);
+        return {
+            status: headResponse.status,
+            headers: headResponse.headers,
+            body,
+        };
+    }
+}
+
+export { resolveHTTPResponse as r };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "10.28.2",
+  "version": "10.29.1",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -143,7 +143,7 @@
     "@types/express": "^4.17.17",
     "@types/hash-sum": "^1.0.0",
     "@types/node": "^18.16.16",
-    "@types/react": "^18.2.6",
+    "@types/react": "^18.2.8",
     "@types/react-dom": "^18.2.4",
     "@types/ws": "^8.2.0",
     "@web3-storage/multipart-parser": "^1.0.0",
@@ -164,7 +164,7 @@
     "superstruct": "^1.0.0",
     "tslib": "^2.5.0",
     "tsx": "^3.12.7",
-    "typescript": "^5.0.4",
+    "typescript": "^5.1.3",
     "vitest": "^0.28.5",
     "ws": "^8.0.0",
     "yup": "^1.0.0",
@@ -173,5 +173,5 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "055c27724a3163ee9fde633f92f30756caf7690b"
+  "gitHead": "3dbc7b7e9fff233f89627c21450ba89754bc3e46"
 }

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,49 @@ 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));
+
+  let isStream = false;
+  let stream: Readable;
+  let formatter: ReturnType<typeof getBatchStreamFormatter>;
+  const unstable_onHead = (head: HTTPResponse, isStreaming: boolean) => {
+    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);
+    }
+    if (isStreaming) {
+      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;
+      formatter = getBatchStreamFormatter();
+    }
+  };
+
+  const unstable_onChunk = ([index, string]: ResponseChunk) => {
+    if (index === -1) {
+      // full response, no streaming
+      resolve(opts.res.send(string));
+    } else {
+      stream.push(formatter!(index, string));
+    }
+  };
+
+  resolveHTTPResponse({
     req,
     createContext,
     path: opts.path,
@@ -53,20 +101,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;
-    }
+    unstable_onHead,
+    unstable_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/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,62 @@ 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;
+
+  let isStream = false;
+  let controller: ReadableStreamController<any>;
+  let encoder: TextEncoder;
+  let formatter: ReturnType<typeof getBatchStreamFormatter>;
+  const unstable_onHead = (head: HTTPResponse, isStreaming: boolean) => {
+    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;
+    if (isStreaming) {
+      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();
+      formatter = getBatchStreamFormatter();
+      isStream = true;
+    }
+  };
+
+  const unstable_onChunk = ([index, string]: ResponseChunk) => {
+    if (index === -1) {
+      // full response, no streaming
+      const response = new Response(string || null, {
+        status,
+        headers: resHeaders,
+      });
+      resolve(response);
+    } else {
+      controller.enqueue(encoder.encode(formatter!(index, string)));
+    }
+  };
+
+  resolveHTTPResponse({
     req,
     createContext,
     path,
@@ -39,28 +95,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,
-  });
+    unstable_onHead,
+    unstable_onChunk,
+  })
+    .then(() => {
+      if (isStream) {
+        controller.enqueue(encoder.encode(formatter!.end()));
+        controller.close();
+      }
+    })
+    .catch(() => {
+      if (isStream) {
+        controller.close();
+      }
+    });
 
-  return res;
+  return promise;
 }

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,50 @@ export async function nodeHTTPRequestHandler<
       body: bodyResult.ok ? bodyResult.data : undefined,
     };
 
-    const result = await resolveHTTPResponse({
+    let isStream = false;
+    let formatter: ReturnType<typeof getBatchStreamFormatter>;
+    const unstable_onHead = (head: HTTPResponse, isStreaming: boolean) => {
+      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);
+      }
+      if (isStreaming) {
+        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;
+        formatter = getBatchStreamFormatter();
+        opts.res.flushHeaders();
+      }
+    };
+
+    const unstable_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);
+      } else {
+        opts.res.write(formatter!(index, string));
+        opts.res.flush?.();
+      }
+    };
+
+    await resolveHTTPResponse({
       batching: opts.batching,
       responseMeta: opts.responseMeta,
       path: opts.path,
@@ -79,18 +123,15 @@ export async function nodeHTTPRequestHandler<
         });
       },
       contentTypeHandler,
+      unstable_onHead,
+      unstable_onChunk,
     });
 
-    const { res } = opts;
-    if ('status' in result && (!res.statusCode || res.statusCode === 200)) {
-      res.statusCode = result.status;
+    if (isStream) {
+      opts.res.write(formatter!.end());
+      opts.res.end();
     }
-    for (const [key, value] of Object.entries(result.headers ?? {})) {
-      if (typeof value === 'undefined') {
-        continue;
-      }
-      res.setHeader(key, value);
-    }
-    res.end(result.body);
+
+    return opts.res;
   });
 }

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

@@ -12,7 +12,17 @@ export type NodeHTTPRequest = IncomingMessage & {
   query?: ParsedQs;
   body?: unknown;
 };
-export type NodeHTTPResponse = ServerResponse;
+export type NodeHTTPResponse = ServerResponse & {
+  /**
+   * Force the partially-compressed response to be flushed to the client.
+   *
+   * Added by compression middleware
+   * (depending on the environment,
+   * e.g. Next <= 12,
+   * e.g. Express w/ `compression()`)
+   */
+  flush?: () => void;
+};
 
 export type NodeHTTPCreateContextOption<
   TRouter extends AnyRouter,