@trpc/server 11.0.0-rc.361 → 11.0.0-rc.362

package/src/adapters/fastify/fastifyRequestHandler.ts

@@ -7,23 +7,36 @@
  * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
  * ```
  */
-import { Readable } from 'stream';
 import type { FastifyReply, FastifyRequest } from 'fastify';
 // @trpc/server
 import type { AnyRouter } from '../../@trpc/server';
 import type {
-  HTTPRequest,
-  HTTPResponse,
+  HTTPBaseHandlerOptions,
   ResolveHTTPRequestOptionsContextFn,
-  ResponseChunk,
 } from '../../@trpc/server/http';
-import {
-  getBatchStreamFormatter,
-  resolveHTTPResponse,
-} from '../../@trpc/server/http';
-import { selectContentHandlerOrUnsupportedMediaType } from '../content-handlers/selectContentHandlerOrUnsupportedMediaType';
-import { getFastifyHTTPJSONContentTypeHandler } from './content-type/json';
-import type { FastifyRequestHandlerOptions } from './types';
+import { resolveResponse } from '../../@trpc/server/http';
+import type {
+  IncomingMessageWithBody,
+  NodeHTTPCreateContextOption,
+} from '../node-http';
+import { incomingMessageToRequest } from '../node-http';
+
+export type FastifyHandlerOptions<
+  TRouter extends AnyRouter,
+  TRequest extends FastifyRequest,
+  TResponse extends FastifyReply,
+> = HTTPBaseHandlerOptions<TRouter, TRequest> &
+  NodeHTTPCreateContextOption<TRouter, TRequest, TResponse>;
+
+type FastifyRequestHandlerOptions<
+  TRouter extends AnyRouter,
+  TRequest extends FastifyRequest,
+  TResponse extends FastifyReply,
+> = FastifyHandlerOptions<TRouter, TRequest, TResponse> & {
+  req: TRequest;
+  res: TResponse;
+  path: string;
+};
 
 export async function fastifyRequestHandler<
   TRouter extends AnyRouter,
@@ -39,90 +52,28 @@ export async function fastifyRequestHandler<
     });
   };
 
-  const query = opts.req.query
-    ? new URLSearchParams(opts.req.query as any)
-    : new URLSearchParams(opts.req.url.split('?')[1]);
+  const incomingMessage = opts.req.raw as IncomingMessageWithBody;
 
-  const req: HTTPRequest = {
-    query,
-    method: opts.req.method,
-    headers: opts.req.headers,
-  };
-
-  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));
-    }
-  };
-
-  const [contentTypeHandler, unsupportedMediaTypeError] =
-    selectContentHandlerOrUnsupportedMediaType(
-      [getFastifyHTTPJSONContentTypeHandler<TRouter, TRequest, TResponse>()],
-      opts,
-    );
+  // monkey-path body to the IncomingMessage
+  if ('body' in opts.req) {
+    incomingMessage.body = opts.req.body;
+  }
+  const req = incomingMessageToRequest(incomingMessage, {
+    maxBodySize: null,
+  });
 
-  resolveHTTPResponse({
+  const res = await resolveResponse({
     ...opts,
     req,
-    error: unsupportedMediaTypeError,
-    async getInput(info) {
-      return await contentTypeHandler?.getInputs(opts, info);
-    },
+    error: null,
     createContext,
-
     onError(o) {
-      opts?.onError?.({ ...o, req: opts.req });
+      opts?.onError?.({
+        ...o,
+        req: opts.req,
+      });
     },
-    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);
-      }
-    });
+  });
 
-  return promise;
+  await opts.res.send(res);
 }

package/src/adapters/fastify/fastifyTRPCPlugin.ts

@@ -14,8 +14,8 @@ import type { AnyRouter } from '../../@trpc/server';
 import type { NodeHTTPCreateContextFnOptions } from '../node-http';
 import type { WSSHandlerOptions } from '../ws';
 import { getWSConnectionHandler } from '../ws';
+import type { FastifyHandlerOptions } from './fastifyRequestHandler';
 import { fastifyRequestHandler } from './fastifyRequestHandler';
-import type { FastifyHandlerOptions } from './types';
 
 export interface FastifyTRPCPluginOptions<TRouter extends AnyRouter> {
   prefix?: string;

package/src/adapters/fetch/fetchRequestHandler.ts

@@ -10,20 +10,9 @@
 // @trpc/server
 
 import type { AnyRouter } from '../../@trpc/server';
-import type {
-  HTTPRequest,
-  HTTPResponse,
-  ResolveHTTPRequestOptionsContextFn,
-  ResponseChunk,
-} from '../../@trpc/server/http';
-import {
-  getBatchStreamFormatter,
-  resolveHTTPResponse,
-  toURL,
-} from '../../@trpc/server/http';
-import { selectContentHandlerOrUnsupportedMediaType } from '../content-handlers/selectContentHandlerOrUnsupportedMediaType';
-import { getFetchHTTPJSONContentTypeHandler } from './content-type/json';
-import type { FetchHandlerOptions } from './types';
+import type { ResolveHTTPRequestOptionsContextFn } from '../../@trpc/server/http';
+import { resolveResponse, toURL } from '../../@trpc/server/http';
+import type { FetchHandlerRequestOptions } from './types';
 
 const trimSlashes = (path: string): string => {
   path = path.startsWith('/') ? path.slice(1) : path;
@@ -33,7 +22,7 @@ const trimSlashes = (path: string): string => {
 };
 
 export async function fetchRequestHandler<TRouter extends AnyRouter>(
-  opts: FetchHandlerOptions<TRouter>,
+  opts: FetchHandlerRequestOptions<TRouter>,
 ): Promise<Response> {
   const resHeaders = new Headers();
 
@@ -49,108 +38,43 @@ export async function fetchRequestHandler<TRouter extends AnyRouter>(
   const endpoint = trimSlashes(opts.endpoint);
   const path = trimSlashes(pathname.slice(endpoint.length));
 
-  const req: HTTPRequest = {
-    query: url.searchParams,
-    method: opts.req.method,
-    headers: Object.fromEntries(opts.req.headers),
-  };
-
-  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)));
-    }
-  };
-
-  const [contentTypeHandler, unsupportedMediaTypeError] =
-    selectContentHandlerOrUnsupportedMediaType(
-      [getFetchHTTPJSONContentTypeHandler<TRouter>()],
-      {
-        ...opts,
-        url,
-      },
-    );
-
-  resolveHTTPResponse({
+  return await resolveResponse({
     ...opts,
-    req,
+    req: opts.req,
     createContext,
     path,
-    error: unsupportedMediaTypeError,
-    async getInput(info) {
-      return await contentTypeHandler?.getInputs(
-        {
-          ...opts,
-          url,
-        },
-        info,
-      );
-    },
+    error: null,
     onError(o) {
       opts?.onError?.({ ...o, req: opts.req });
     },
-    unstable_onHead,
-    unstable_onChunk,
-  })
-    .then(() => {
-      if (isStream) {
-        controller.enqueue(encoder.encode(formatter.end()));
-        controller.close();
-      }
-    })
-    .catch(() => {
-      if (isStream) {
-        controller.close();
+    responseMeta(data) {
+      const meta = opts.responseMeta?.(data);
+
+      if (meta?.headers) {
+        if (meta.headers instanceof Headers) {
+          for (const [key, value] of meta.headers.entries()) {
+            resHeaders.append(key, value);
+          }
+        } else {
+          /**
+           * @deprecated, delete in v12
+           */
+          for (const [key, value] of Object.entries(meta.headers)) {
+            if (Array.isArray(value)) {
+              for (const v of value) {
+                resHeaders.append(key, v);
+              }
+            } else if (typeof value === 'string') {
+              resHeaders.set(key, value);
+            }
+          }
+        }
       }
-    });
 
-  return promise;
+      return {
+        headers: resHeaders,
+        status: meta?.status,
+      };
+    },
+  });
 }

package/src/adapters/fetch/types.ts

@@ -12,7 +12,6 @@ import type {
   AnyRouter,
   CreateContextCallback,
   inferRouterContext,
-  WrapCreateContext,
 } from '../../@trpc/server';
 // @trpc/server/http
 import type {
@@ -45,7 +44,10 @@ export type FetchHandlerOptions<TRouter extends AnyRouter> =
 
 export type FetchHandlerRequestOptions<TRouter extends AnyRouter> =
   HTTPBaseHandlerOptions<TRouter, Request> &
-    WrapCreateContext<FetchCreateContextFn<TRouter>> & {
+    CreateContextCallback<
+      inferRouterContext<TRouter>,
+      FetchCreateContextFn<TRouter>
+    > & {
       req: Request;
       endpoint: string;
     };

package/src/adapters/next.ts

@@ -65,7 +65,7 @@ export function createNextApiHandler<TRouter extends AnyRouter>(
     }
 
     await nodeHTTPRequestHandler({
-      ...opts,
+      ...(opts as any),
       req,
       res,
       path,

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

@@ -0,0 +1,94 @@
+import type * as http from 'http';
+import { TRPCError } from '../../@trpc/server';
+
+export interface IncomingMessageWithBody extends http.IncomingMessage {
+  /**
+   * Many adapters will add a `body` property to the incoming message and pre-parse the body
+   */
+  body?: unknown;
+}
+/**
+ * Convert an incoming message to a body stream with a max size
+ */
+function incomingMessageToBodyStream(
+  req: IncomingMessageWithBody,
+  opts: { maxBodySize: number | null },
+) {
+  type Value = Buffer | Uint8Array | string | null;
+  let size = 0;
+  const maxBodySize = opts.maxBodySize;
+
+  let controller: ReadableStreamDefaultController<Value> =
+    null as unknown as ReadableStreamDefaultController<Value>;
+  const stream = new ReadableStream<Value>({
+    start(c) {
+      controller = c;
+    },
+    async pull(c) {
+      const chunk: Value = req.read();
+
+      if (chunk) {
+        size += chunk.length;
+      }
+      if (maxBodySize !== null && size > maxBodySize) {
+        controller.error(
+          new TRPCError({
+            code: 'PAYLOAD_TOO_LARGE',
+          }),
+        );
+        return;
+      }
+      if (chunk === null) {
+        c.close();
+        return;
+      }
+      controller.enqueue(chunk);
+    },
+    cancel() {
+      req.destroy();
+    },
+  });
+
+  return stream;
+}
+
+const bodyMethods = ['POST', 'PUT', 'PATCH'];
+/**
+ * Convert an [`IncomingMessage`](https://nodejs.org/api/http.html#class-httpincomingmessage) to a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)
+ */
+export function incomingMessageToRequest(
+  req: http.IncomingMessage,
+  opts: {
+    /**
+     * Max body size in bytes. If the body is larger than this, the request will be aborted
+     */
+    maxBodySize: number | null;
+  },
+): Request {
+  const ac = new AbortController();
+  const headers = new Headers(req.headers as any);
+  const url = `http://${headers.get('host')}${req.url}`;
+
+  req.once('aborted', () => ac.abort());
+
+  const init: RequestInit = {
+    headers,
+    method: req.method,
+    signal: ac.signal,
+    // @ts-expect-error this is fine
+    duplex: 'half',
+  };
+
+  if (req.method && bodyMethods.includes(req.method)) {
+    if (!('body' in req)) {
+      init.body = incomingMessageToBodyStream(req, opts);
+    } else if (typeof req.body === 'string') {
+      init.body = req.body;
+    } else if (req.body !== undefined) {
+      init.body = JSON.stringify(req.body);
+    }
+  }
+  const request = new Request(url, init);
+
+  return request;
+}

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

@@ -1,2 +1,3 @@
 export * from './nodeHTTPRequestHandler';
 export * from './types';
+export * from './incomingMessageToRequest';

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

@@ -7,30 +7,27 @@
  * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
  * ```
  */
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
 
 // @trpc/server
-import type { AnyRouter } from '../../@trpc/server';
-import type {
-  HTTPRequest,
-  HTTPResponse,
-  ResolveHTTPRequestOptionsContextFn,
-  ResponseChunk,
-} from '../../@trpc/server/http';
-import {
-  getBatchStreamFormatter,
-  resolveHTTPResponse,
-} from '../../@trpc/server/http';
-import { selectContentHandlerOrUnsupportedMediaType } from '../content-handlers/selectContentHandlerOrUnsupportedMediaType';
-import { getFormDataContentTypeHandler } from './content-type/form-data';
-import { getNodeHTTPJSONContentTypeHandler } from './content-type/json';
-import { getOctetContentTypeHandler } from './content-type/octet';
+
+import { getTRPCErrorFromUnknown, type AnyRouter } from '../../@trpc/server';
+import type { ResolveHTTPRequestOptionsContextFn } from '../../@trpc/server/http';
+import { resolveResponse } from '../../@trpc/server/http';
+import { incomingMessageToRequest } from './incomingMessageToRequest';
 import type {
   NodeHTTPRequest,
   NodeHTTPRequestHandlerOptions,
   NodeHTTPResponse,
 } from './types';
 
+function assertAsyncIterable<TValue>(
+  value: any,
+): asserts value is AsyncIterable<TValue> {
+  if (!(Symbol.asyncIterator in value)) {
+    throw new Error('Expected AsyncIterable - are you using Node >= 18.0.0?');
+  }
+}
+
 export async function nodeHTTPRequestHandler<
   TRouter extends AnyRouter,
   TRequest extends NodeHTTPRequest,
@@ -39,11 +36,11 @@ export async function nodeHTTPRequestHandler<
   const handleViaMiddleware = opts.middleware ?? ((_req, _res, next) => next());
 
   return handleViaMiddleware(opts.req, opts.res, async (err) => {
-    if (err) throw err;
+    const req = incomingMessageToRequest(opts.req, {
+      maxBodySize: opts.maxBodySize ?? null,
+    });
 
-    //
     // Build tRPC dependencies
-
     const createContext: ResolveHTTPRequestOptionsContextFn<TRouter> = async (
       innerOpts,
     ) => {
@@ -53,95 +50,32 @@ export async function nodeHTTPRequestHandler<
       });
     };
 
-    const query = opts.req.query
-      ? new URLSearchParams(opts.req.query as any)
-      : new URLSearchParams(opts.req.url!.split('?')[1]);
-
-    const req: HTTPRequest = {
-      method: opts.req.method!,
-      headers: opts.req.headers,
-      query,
-    };
-
-    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?.();
-      }
-    };
-
-    const [contentTypeHandler, unsupportedMediaTypeError] =
-      selectContentHandlerOrUnsupportedMediaType(
-        [
-          getNodeHTTPJSONContentTypeHandler<TRouter, TRequest, TResponse>(),
-          getFormDataContentTypeHandler<TRouter, TRequest, TResponse>(),
-          getOctetContentTypeHandler<TRouter, TRequest, TResponse>(),
-        ],
-        { ...opts, query },
-      );
-
-    await resolveHTTPResponse<TRouter, HTTPRequest>({
+    const response = await resolveResponse({
       ...opts,
       req,
+      error: err ? getTRPCErrorFromUnknown(err) : null,
       createContext,
-      error: unsupportedMediaTypeError,
       onError(o) {
         opts?.onError?.({
           ...o,
           req: opts.req,
         });
       },
-      async getInput(inputsOpts) {
-        return await contentTypeHandler?.getInputs(
-          { ...opts, query },
-          inputsOpts,
-        );
-      },
-      unstable_onHead,
-      unstable_onChunk,
     });
 
-    if (isStream) {
-      opts.res.write(formatter!.end());
-      opts.res.end();
+    if (opts.res.statusCode === 200) {
+      // if the status code is set, we assume that it's been manually overridden
+      opts.res.statusCode = response.status;
     }
-
-    return opts.res;
+    for (const [key, value] of response.headers) {
+      opts.res.setHeader(key, value);
+    }
+    if (response.body) {
+      assertAsyncIterable(response.body);
+      for await (const chunk of response.body) {
+        opts.res.write(chunk);
+      }
+    }
+    opts.res.end();
   });
 }