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

package/src/adapters/fastify/fastifyTRPCPlugin.ts

@@ -9,12 +9,12 @@
  */
 /// <reference types="@fastify/websocket" />
 import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
-import type { FastifyHandlerOptions } from '.';
 // @trpc/server
 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';
 
 export interface FastifyTRPCPluginOptions<TRouter extends AnyRouter> {

package/src/adapters/fetch/fetchRequestHandler.ts

@@ -10,24 +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 type { FetchHandlerOptions } from './types';
-
-export type FetchHandlerRequestOptions<TRouter extends AnyRouter> =
-  FetchHandlerOptions<TRouter> & {
-    req: Request;
-    endpoint: string;
-  };
+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;
@@ -53,92 +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),
-    body: opts.req.headers.get('content-type')?.startsWith('application/json')
-      ? await opts.req.text()
-      : '',
-  };
-
-  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({
+  return await resolveResponse({
     ...opts,
-    req,
+    req: opts.req,
     createContext,
     path,
+    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

@@ -8,7 +8,11 @@
  * ```
  */
 // @trpc/server
-import type { AnyRouter, inferRouterContext } from '../../@trpc/server';
+import type {
+  AnyRouter,
+  CreateContextCallback,
+  inferRouterContext,
+} from '../../@trpc/server';
 // @trpc/server/http
 import type {
   HTTPBaseHandlerOptions,
@@ -26,19 +30,24 @@ export type FetchCreateContextFn<TRouter extends AnyRouter> = (
 ) => inferRouterContext<TRouter> | Promise<inferRouterContext<TRouter>>;
 
 export type FetchCreateContextOption<TRouter extends AnyRouter> =
-  unknown extends inferRouterContext<TRouter>
-    ? {
-        /**
-         * @link https://trpc.io/docs/v11/context
-         **/
-        createContext?: FetchCreateContextFn<TRouter>;
-      }
-    : {
-        /**
-         * @link https://trpc.io/docs/v11/context
-         **/
-        createContext: FetchCreateContextFn<TRouter>;
-      };
+  CreateContextCallback<
+    inferRouterContext<TRouter>,
+    FetchCreateContextFn<TRouter>
+  >;
 
 export type FetchHandlerOptions<TRouter extends AnyRouter> =
-  FetchCreateContextOption<TRouter> & HTTPBaseHandlerOptions<TRouter, Request>;
+  FetchCreateContextOption<TRouter> &
+    HTTPBaseHandlerOptions<TRouter, Request> & {
+      req: Request;
+      endpoint: string;
+    };
+
+export type FetchHandlerRequestOptions<TRouter extends AnyRouter> =
+  HTTPBaseHandlerOptions<TRouter, Request> &
+    CreateContextCallback<
+      inferRouterContext<TRouter>,
+      FetchCreateContextFn<TRouter>
+    > & {
+      req: Request;
+      endpoint: string;
+    };

package/src/adapters/next-app-dir/nextAppDirCaller.ts

@@ -1,3 +1,4 @@
+import type { CreateContextCallback } from '../../@trpc/server';
 import { getTRPCErrorFromUnknown, TRPCError } from '../../@trpc/server';
 // FIXME: fix lint rule, this is ok
 // eslint-disable-next-line no-restricted-imports
@@ -15,14 +16,6 @@ import { formDataToObject } from './formDataToObject';
 import { TRPCRedirectError } from './redirect';
 import { rethrowNextErrors } from './rethrowNextErrors';
 
-type ContextCallback<TContext> = object extends TContext
-  ? {
-      createContext?: () => MaybePromise<TContext>;
-    }
-  : {
-      createContext: () => MaybePromise<TContext>;
-    };
-
 /**
  * Create a caller that works with Next.js React Server Components & Server Actions
  */
@@ -38,7 +31,7 @@ export function nextAppDirCaller<TContext>(
        * Called when an error occurs in the handler
        */
       onError?: (opts: ErrorHandlerOptions<TContext>) => void;
-    } & ContextCallback<TContext>
+    } & CreateContextCallback<TContext, () => MaybePromise<TContext>>
   >,
 ): CallerOverride<TContext> {
   const {

package/src/adapters/next.ts

@@ -65,12 +65,7 @@ export function createNextApiHandler<TRouter extends AnyRouter>(
     }
 
     await nodeHTTPRequestHandler({
-      // FIXME: no typecasting should be needed here
-      ...(opts as NodeHTTPHandlerOptions<
-        AnyRouter,
-        NextApiRequest,
-        NextApiResponse
-      >),
+      ...(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,28 +7,26 @@
  * 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 { nodeHTTPJSONContentTypeHandler } from './content-type/json';
-import type { NodeHTTPContentTypeHandler } from './internals/contentType';
+
+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';
 
-const defaultJSONContentTypeHandler = nodeHTTPJSONContentTypeHandler();
+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,
@@ -38,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,
     ) => {
@@ -52,109 +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 jsonContentTypeHandler =
-      defaultJSONContentTypeHandler as unknown as NodeHTTPContentTypeHandler<
-        TRequest,
-        TResponse
-      >;
-
-    const contentTypeHandlers = opts.experimental_contentTypeHandlers ?? [
-      jsonContentTypeHandler,
-    ];
-
-    const contentTypeHandler =
-      contentTypeHandlers.find((handler) =>
-        handler.isMatch({
-          // FIXME: no typecasting should be needed here
-          ...(opts as any),
-          query,
-        }),
-      ) ??
-      // fallback to json
-      jsonContentTypeHandler;
-
-    const bodyResult = await contentTypeHandler.getBody({
-      // FIXME: no typecasting should be needed here
-      ...(opts as any),
-      query,
-    });
-
-    const req: HTTPRequest = {
-      method: opts.req.method!,
-      headers: opts.req.headers,
-      query,
-      body: bodyResult.ok ? bodyResult.data : undefined,
-    };
-
-    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<TRouter, HTTPRequest>({
+    const response = await resolveResponse({
       ...opts,
       req,
+      error: err ? getTRPCErrorFromUnknown(err) : null,
       createContext,
-      error: bodyResult.ok ? null : bodyResult.error,
-      preprocessedBody: bodyResult.ok ? bodyResult.preprocessed : false,
       onError(o) {
         opts?.onError?.({
           ...o,
           req: opts.req,
         });
       },
-      contentTypeHandler,
-      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();
   });
 }

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

@@ -9,7 +9,11 @@
  */
 import type * as http from 'http';
 // @trpc/server
-import type { AnyRouter, inferRouterContext } from '../../@trpc/server';
+import type {
+  AnyRouter,
+  CreateContextCallback,
+  inferRouterContext,
+} from '../../@trpc/server';
 // @trpc/server/http
 import type {
   HTTPBaseHandlerOptions,
@@ -17,7 +21,6 @@ import type {
 } from '../../@trpc/server/http';
 // eslint-disable-next-line no-restricted-imports
 import type { MaybePromise } from '../../unstable-core-do-not-import';
-import type { NodeHTTPContentTypeHandler } from './internals/contentType';
 
 interface ParsedQs {
   [key: string]: ParsedQs | ParsedQs[] | string[] | string | undefined;
@@ -43,19 +46,10 @@ export type NodeHTTPCreateContextOption<
   TRouter extends AnyRouter,
   TRequest,
   TResponse,
-> = object extends inferRouterContext<TRouter>
-  ? {
-      /**
-       * @link https://trpc.io/docs/v11/context
-       **/
-      createContext?: NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>;
-    }
-  : {
-      /**
-       * @link https://trpc.io/docs/v11/context
-       **/
-      createContext: NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>;
-    };
+> = CreateContextCallback<
+  inferRouterContext<TRouter>,
+  NodeHTTPCreateContextFn<TRouter, TRequest, TResponse>
+>;
 
 /**
  * @internal
@@ -89,10 +83,6 @@ export type NodeHTTPHandlerOptions<
      */
     middleware?: ConnectMiddleware;
     maxBodySize?: number;
-    experimental_contentTypeHandlers?: NodeHTTPContentTypeHandler<
-      TRequest,
-      TResponse
-    >[];
   };
 
 export type NodeHTTPRequestHandlerOptions<

package/src/adapters/standalone.ts

@@ -37,8 +37,7 @@ export function createHTTPHandler<TRouter extends AnyRouter>(
     const path = url.pathname.slice(1);
 
     await nodeHTTPRequestHandler({
-      // FIXME: no typecasting should be needed here
-      ...(opts as CreateHTTPHandlerOptions<AnyRouter>),
+      ...(opts as any),
       req,
       res,
       path,

package/src/adapters/ws.ts

@@ -1,6 +1,10 @@
 import type { IncomingMessage } from 'http';
 import type ws from 'ws';
-import type { AnyRouter, inferRouterContext } from '../@trpc/server';
+import type {
+  AnyRouter,
+  CreateContextCallback,
+  inferRouterContext,
+} from '../@trpc/server';
 import {
   callProcedure,
   getErrorShape,
@@ -46,19 +50,10 @@ export type CreateWSSContextFn<TRouter extends AnyRouter> = (
 
 export type WSConnectionHandlerOptions<TRouter extends AnyRouter> =
   BaseHandlerOptions<TRouter, IncomingMessage> &
-    (object extends inferRouterContext<TRouter>
-      ? {
-          /**
-           * @link https://trpc.io/docs/v11/context
-           **/
-          createContext?: CreateWSSContextFn<TRouter>;
-        }
-      : {
-          /**
-           * @link https://trpc.io/docs/v11/context
-           **/
-          createContext: CreateWSSContextFn<TRouter>;
-        });
+    CreateContextCallback<
+      inferRouterContext<TRouter>,
+      CreateWSSContextFn<TRouter>
+    >;
 
 /**
  * Web socket server handler