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

package/dist/unstable-core-do-not-import.js

@@ -1,13 +1,14 @@
 'use strict';
 
 var createProxy = require('./unstable-core-do-not-import/createProxy.js');
+var TRPCError = require('./unstable-core-do-not-import/error/TRPCError.js');
 var formatter = require('./unstable-core-do-not-import/error/formatter.js');
 var getErrorShape = require('./unstable-core-do-not-import/error/getErrorShape.js');
-var TRPCError = require('./unstable-core-do-not-import/error/TRPCError.js');
-var getHTTPStatusCode = require('./unstable-core-do-not-import/http/getHTTPStatusCode.js');
-var resolveHTTPResponse = require('./unstable-core-do-not-import/http/resolveHTTPResponse.js');
 var batchStreamFormatter = require('./unstable-core-do-not-import/http/batchStreamFormatter.js');
 var contentType = require('./unstable-core-do-not-import/http/contentType.js');
+var contentTypeParsers = require('./unstable-core-do-not-import/http/contentTypeParsers.js');
+var getHTTPStatusCode = require('./unstable-core-do-not-import/http/getHTTPStatusCode.js');
+var resolveHTTPResponse = require('./unstable-core-do-not-import/http/resolveHTTPResponse.js');
 var toURL = require('./unstable-core-do-not-import/http/toURL.js');
 var initTRPC = require('./unstable-core-do-not-import/initTRPC.js');
 var middleware = require('./unstable-core-do-not-import/middleware.js');
@@ -26,16 +27,17 @@ var utils = require('./unstable-core-do-not-import/utils.js');
 
 exports.createFlatProxy = createProxy.createFlatProxy;
 exports.createRecursiveProxy = createProxy.createRecursiveProxy;
-exports.defaultFormatter = formatter.defaultFormatter;
-exports.getErrorShape = getErrorShape.getErrorShape;
 exports.TRPCError = TRPCError.TRPCError;
 exports.getCauseFromUnknown = TRPCError.getCauseFromUnknown;
 exports.getTRPCErrorFromUnknown = TRPCError.getTRPCErrorFromUnknown;
+exports.defaultFormatter = formatter.defaultFormatter;
+exports.getErrorShape = getErrorShape.getErrorShape;
+exports.getBatchStreamFormatter = batchStreamFormatter.getBatchStreamFormatter;
+exports.getRequestInfo = contentType.getRequestInfo;
+exports.octetInputParser = contentTypeParsers.octetInputParser;
 exports.getHTTPStatusCode = getHTTPStatusCode.getHTTPStatusCode;
 exports.getHTTPStatusCodeFromError = getHTTPStatusCode.getHTTPStatusCodeFromError;
-exports.resolveHTTPResponse = resolveHTTPResponse.resolveHTTPResponse;
-exports.getBatchStreamFormatter = batchStreamFormatter.getBatchStreamFormatter;
-exports.getJsonContentTypeInputs = contentType.getJsonContentTypeInputs;
+exports.resolveResponse = resolveHTTPResponse.resolveResponse;
 exports.toURL = toURL.toURL;
 exports.initTRPC = initTRPC.initTRPC;
 exports.createInputMiddleware = middleware.createInputMiddleware;
@@ -46,7 +48,6 @@ exports.middlewareMarker = middleware.middlewareMarker;
 exports.getParseFn = parser.getParseFn;
 exports.procedureTypes = procedure.procedureTypes;
 exports.createBuilder = procedureBuilder.createBuilder;
-exports.unsetMarker = procedureBuilder.unsetMarker;
 exports.isServerDefault = rootConfig.isServerDefault;
 exports.callProcedure = router.callProcedure;
 exports.createCallerFactory = router.createCallerFactory;
@@ -64,3 +65,4 @@ exports.isFunction = utils.isFunction;
 exports.isObject = utils.isObject;
 exports.mergeWithoutOverrides = utils.mergeWithoutOverrides;
 exports.omitPrototype = utils.omitPrototype;
+exports.unsetMarker = utils.unsetMarker;

package/dist/unstable-core-do-not-import.mjs

@@ -1,21 +1,22 @@
 export { createFlatProxy, createRecursiveProxy } from './unstable-core-do-not-import/createProxy.mjs';
+export { TRPCError, getCauseFromUnknown, getTRPCErrorFromUnknown } from './unstable-core-do-not-import/error/TRPCError.mjs';
 export { defaultFormatter } from './unstable-core-do-not-import/error/formatter.mjs';
 export { getErrorShape } from './unstable-core-do-not-import/error/getErrorShape.mjs';
-export { TRPCError, getCauseFromUnknown, getTRPCErrorFromUnknown } from './unstable-core-do-not-import/error/TRPCError.mjs';
-export { getHTTPStatusCode, getHTTPStatusCodeFromError } from './unstable-core-do-not-import/http/getHTTPStatusCode.mjs';
-export { resolveHTTPResponse } from './unstable-core-do-not-import/http/resolveHTTPResponse.mjs';
 export { getBatchStreamFormatter } from './unstable-core-do-not-import/http/batchStreamFormatter.mjs';
-export { getJsonContentTypeInputs } from './unstable-core-do-not-import/http/contentType.mjs';
+export { getRequestInfo } from './unstable-core-do-not-import/http/contentType.mjs';
+export { octetInputParser } from './unstable-core-do-not-import/http/contentTypeParsers.mjs';
+export { getHTTPStatusCode, getHTTPStatusCodeFromError } from './unstable-core-do-not-import/http/getHTTPStatusCode.mjs';
+export { resolveResponse } from './unstable-core-do-not-import/http/resolveHTTPResponse.mjs';
 export { toURL } from './unstable-core-do-not-import/http/toURL.mjs';
 export { initTRPC } from './unstable-core-do-not-import/initTRPC.mjs';
 export { createInputMiddleware, createMiddlewareFactory, createOutputMiddleware, experimental_standaloneMiddleware, middlewareMarker } from './unstable-core-do-not-import/middleware.mjs';
 export { getParseFn } from './unstable-core-do-not-import/parser.mjs';
 export { procedureTypes } from './unstable-core-do-not-import/procedure.mjs';
-export { createBuilder, unsetMarker } from './unstable-core-do-not-import/procedureBuilder.mjs';
+export { createBuilder } from './unstable-core-do-not-import/procedureBuilder.mjs';
 export { isServerDefault } from './unstable-core-do-not-import/rootConfig.mjs';
 export { callProcedure, createCallerFactory, createRouterFactory, mergeRouters } from './unstable-core-do-not-import/router.mjs';
 export { TRPC_ERROR_CODES_BY_KEY, TRPC_ERROR_CODES_BY_NUMBER } from './unstable-core-do-not-import/rpc/codes.mjs';
 export { parseTRPCMessage } from './unstable-core-do-not-import/rpc/parseTRPCMessage.mjs';
 export { defaultTransformer, getDataTransformer, transformResult, transformTRPCResponse } from './unstable-core-do-not-import/transformer.mjs';
 export { ERROR_SYMBOL } from './unstable-core-do-not-import/types.mjs';
-export { isFunction, isObject, mergeWithoutOverrides, omitPrototype } from './unstable-core-do-not-import/utils.mjs';
+export { isFunction, isObject, mergeWithoutOverrides, omitPrototype, unsetMarker } from './unstable-core-do-not-import/utils.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "11.0.0-rc.359+3bb71110f",
+  "version": "11.0.0-rc.362+01bb2eade",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -58,16 +58,6 @@
       "require": "./dist/adapters/next.js",
       "default": "./dist/adapters/next.js"
     },
-    "./adapters/node-http/content-type/form-data": {
-      "import": "./dist/adapters/node-http/content-type/form-data/index.mjs",
-      "require": "./dist/adapters/node-http/content-type/form-data/index.js",
-      "default": "./dist/adapters/node-http/content-type/form-data/index.js"
-    },
-    "./adapters/node-http/content-type/json": {
-      "import": "./dist/adapters/node-http/content-type/json/index.mjs",
-      "require": "./dist/adapters/node-http/content-type/json/index.js",
-      "default": "./dist/adapters/node-http/content-type/json/index.js"
-    },
     "./adapters/node-http": {
       "import": "./dist/adapters/node-http/index.mjs",
       "require": "./dist/adapters/node-http/index.js",
@@ -128,14 +118,13 @@
   "devDependencies": {
     "@fastify/websocket": "^10.0.1",
     "@tanstack/react-query": "^5.25.0",
-    "@types/aws-lambda": "^8.10.97",
+    "@types/aws-lambda": "^8.10.137",
     "@types/express": "^4.17.17",
     "@types/hash-sum": "^1.0.0",
     "@types/node": "^20.10.0",
     "@types/react": "^18.3.0",
     "@types/react-dom": "^18.3.0",
     "@types/ws": "^8.2.0",
-    "@web3-storage/multipart-parser": "^1.0.0",
     "devalue": "^5.0.0",
     "eslint": "^8.56.0",
     "express": "^4.17.1",
@@ -160,5 +149,5 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "3bb71110fc13467b7fa1b692f949e1249488a4f3"
+  "gitHead": "01bb2eadebe880a91f31192b2d4e16bfd679d99a"
 }

package/src/@trpc/server/http.ts

@@ -1,27 +1,21 @@
 export {
   getHTTPStatusCode,
   getHTTPStatusCodeFromError,
+  resolveResponse,
 } from '../../unstable-core-do-not-import';
-export { resolveHTTPResponse } from '../../unstable-core-do-not-import';
 export type {
   BaseHandlerOptions,
   HTTPBaseHandlerOptions,
-  HTTPHeaders,
-  HTTPRequest,
-  HTTPResponse,
-  OnErrorFunction,
-  ProcedureCall,
+  HTTPErrorHandler,
+  /**
+   * @deprecated Use `HTTPErrorHandler` instead
+   */
+  HTTPErrorHandler as OnErrorFunction,
   ResolveHTTPRequestOptionsContextFn,
-  ResponseChunk,
   ResponseMeta,
   ResponseMetaFn,
   TRPCRequestInfo,
 } from '../../unstable-core-do-not-import';
 
 export { getBatchStreamFormatter } from '../../unstable-core-do-not-import';
-export type {
-  BaseContentTypeHandler,
-  BodyResult,
-} from '../../unstable-core-do-not-import';
-export { getJsonContentTypeInputs } from '../../unstable-core-do-not-import';
-export { toURL } from '../../unstable-core-do-not-import';
+export { octetInputParser, toURL } from '../../unstable-core-do-not-import';

package/src/@trpc/server/index.ts

@@ -32,6 +32,7 @@ export {
   type RouterRecord as TRPCRouterRecord,
   type AnySubscriptionProcedure as AnyTRPCSubscriptionProcedure,
   type ProcedureOptions as TRPCProcedureOptions,
+  type CreateContextCallback,
   type MutationProcedure as TRPCMutationProcedure,
   type QueryProcedure as TRPCQueryProcedure,
   type SubscriptionProcedure as TRPCSubscriptionProcedure,

package/src/adapters/aws-lambda/getPlanner.ts

@@ -0,0 +1,191 @@
+import type {
+  APIGatewayProxyEvent,
+  APIGatewayProxyEventV2,
+  APIGatewayProxyResult,
+  APIGatewayProxyStructuredResultV2,
+} from 'aws-lambda';
+
+export type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2;
+
+export type APIGatewayResult =
+  | APIGatewayProxyResult
+  | APIGatewayProxyStructuredResultV2;
+
+function determinePayloadFormat(event: LambdaEvent): string {
+  // https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+  // According to AWS support, version is is extracted from the version property in the event.
+  // If there is no version property, then the version is implied as 1.0
+  const unknownEvent = event as { version?: string };
+  if (typeof unknownEvent.version === 'undefined') {
+    return '1.0';
+  } else {
+    return unknownEvent.version;
+  }
+}
+
+/** 1:1 mapping of v1 or v2 input events, deduces which is which.
+ * @internal
+ **/
+export type inferAPIGWReturn<TEvent> = TEvent extends APIGatewayProxyEvent
+  ? APIGatewayProxyResult
+  : TEvent extends APIGatewayProxyEventV2
+  ? APIGatewayProxyStructuredResultV2
+  : never;
+
+interface Processor<TEvent extends LambdaEvent> {
+  getTRPCPath: (event: TEvent) => string;
+  url(event: TEvent): Pick<URL, 'hostname' | 'pathname' | 'search'>;
+  getHeaders: (event: TEvent) => Headers;
+  getMethod: (event: TEvent) => string;
+  toResult: (response: Response) => Promise<inferAPIGWReturn<TEvent>>;
+}
+
+const v1Processor: Processor<APIGatewayProxyEvent> = {
+  // same as getPath above
+  getTRPCPath: (event) => {
+    if (!event.pathParameters) {
+      // Then this event was not triggered by a resource denoted with {proxy+}
+      return event.path.split('/').pop() ?? '';
+    }
+    const matches = event.resource.matchAll(/\{(.*?)\}/g);
+    for (const match of matches) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const group = match[1]!;
+      if (group.includes('+') && event.pathParameters) {
+        return event.pathParameters[group.replace('+', '')] ?? '';
+      }
+    }
+    return event.path.slice(1);
+  },
+  url(event) {
+    const hostname: string =
+      event.requestContext.domainName ??
+      event.headers['host'] ??
+      event.multiValueHeaders?.['host']?.[0] ??
+      'localhost';
+
+    const searchParams = new URLSearchParams();
+
+    for (const [key, value] of Object.entries(
+      event.queryStringParameters ?? {},
+    )) {
+      if (value !== undefined) {
+        searchParams.append(key, value);
+      }
+    }
+    const qs = searchParams.toString();
+    return {
+      hostname,
+      pathname: event.path,
+      search: qs && `?${qs}`,
+    };
+  },
+  getHeaders: (event) => {
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(event.headers ?? {})) {
+      if (value !== undefined) {
+        headers.append(key, value);
+      }
+    }
+
+    for (const [k, values] of Object.entries(event.multiValueHeaders ?? {})) {
+      if (values) {
+        values.forEach((v) => headers.append(k, v));
+      }
+    }
+
+    return headers;
+  },
+  getMethod: (event) => event.httpMethod,
+  toResult: async (response) => {
+    const result: APIGatewayProxyResult = {
+      statusCode: response.status,
+      body: await response.text(),
+      headers: Object.fromEntries(response.headers.entries()),
+    };
+
+    return result;
+  },
+};
+
+const v2Processor: Processor<APIGatewayProxyEventV2> = {
+  getTRPCPath: (event) => {
+    const matches = event.routeKey.matchAll(/\{(.*?)\}/g);
+    for (const match of matches) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const group = match[1]!;
+      if (group.includes('+') && event.pathParameters) {
+        return event.pathParameters[group.replace('+', '')] ?? '';
+      }
+    }
+    return event.rawPath.slice(1);
+  },
+  url(event) {
+    return {
+      hostname: event.requestContext.domainName,
+      pathname: event.rawPath,
+      search: event.rawQueryString && `?${event.rawQueryString}`,
+    };
+  },
+  getHeaders: (event) => {
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(event.headers ?? {})) {
+      if (value !== undefined) {
+        headers.append(key, value);
+      }
+    }
+
+    if (event.cookies) {
+      headers.append('cookie', event.cookies.join('; '));
+    }
+    return headers;
+  },
+  getMethod: (event) => event.requestContext.http.method,
+  toResult: async (response) => {
+    const result: APIGatewayProxyStructuredResultV2 = {
+      statusCode: response.status,
+      body: await response.text(),
+      headers: Object.fromEntries(response.headers.entries()),
+    };
+
+    return result;
+  },
+};
+
+export function getPlanner<TEvent extends LambdaEvent>(event: TEvent) {
+  const version = determinePayloadFormat(event);
+  let processor: Processor<TEvent>;
+  switch (version) {
+    case '1.0':
+      processor = v1Processor as Processor<TEvent>;
+      break;
+    case '2.0':
+      processor = v2Processor as Processor<TEvent>;
+      break;
+    default:
+      throw new Error(`Unsupported version: ${version}`);
+  }
+
+  const urlParts = processor.url(event);
+  const url = `https://${urlParts.hostname}${urlParts.pathname}${urlParts.search}`;
+
+  const init: RequestInit = {
+    headers: processor.getHeaders(event),
+    method: processor.getMethod(event),
+    // @ts-expect-error this is fine
+    duplex: 'half',
+  };
+  if (event.body) {
+    init.body = event.isBase64Encoded
+      ? Buffer.from(event.body, 'base64')
+      : event.body;
+  }
+
+  const request = new Request(url, init);
+
+  return {
+    path: processor.getTRPCPath(event),
+    request,
+    toResult: processor.toResult,
+  };
+}

package/src/adapters/aws-lambda/index.ts

@@ -7,119 +7,70 @@
  * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
  * ```
  */
-import type {
-  APIGatewayProxyEvent,
-  APIGatewayProxyEventV2,
-  APIGatewayProxyResult,
-  APIGatewayProxyStructuredResultV2,
-  Context as APIGWContext,
-} from 'aws-lambda';
+import type { Context as APIGWContext } from 'aws-lambda';
 // @trpc/server
-import type { AnyRouter } from '../../@trpc/server';
+import type {
+  AnyRouter,
+  CreateContextCallback,
+  inferRouterContext,
+} from '../../@trpc/server';
 // @trpc/server
-import { TRPCError } from '../../@trpc/server';
 import type {
-  HTTPRequest,
-  HTTPResponse,
+  HTTPBaseHandlerOptions,
   ResolveHTTPRequestOptionsContextFn,
+  TRPCRequestInfo,
 } from '../../@trpc/server/http';
-import { resolveHTTPResponse } from '../../@trpc/server/http';
-import type {
-  APIGatewayEvent,
-  APIGatewayResult,
-  AWSLambdaOptions,
-} from './utils';
-import {
-  getHTTPMethod,
-  getPath,
-  isPayloadV1,
-  isPayloadV2,
-  transformHeaders,
-  UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE,
-} from './utils';
-
-export * from './utils';
+import { resolveResponse } from '../../@trpc/server/http';
+import type { inferAPIGWReturn, LambdaEvent } from './getPlanner';
+import { getPlanner } from './getPlanner';
 
-function lambdaEventToHTTPRequest(event: APIGatewayEvent): HTTPRequest {
-  const query = new URLSearchParams();
-  for (const [key, value] of Object.entries(
-    event.queryStringParameters ?? {},
-  )) {
-    if (typeof value !== 'undefined') {
-      query.append(key, value);
-    }
-  }
+export type CreateAWSLambdaContextOptions<TEvent extends LambdaEvent> = {
+  event: TEvent;
+  context: APIGWContext;
+  info: TRPCRequestInfo;
+};
 
-  let body: string | null | undefined;
-  if (event.body && event.isBase64Encoded) {
-    body = Buffer.from(event.body, 'base64').toString('utf8');
-  } else {
-    body = event.body;
-  }
-
-  return {
-    method: getHTTPMethod(event),
-    query: query,
-    headers: event.headers,
-    body: body,
-  };
-}
+export type AWSLambdaOptions<
+  TRouter extends AnyRouter,
+  TEvent extends LambdaEvent,
+> =
+  | HTTPBaseHandlerOptions<TRouter, TEvent> &
+      CreateContextCallback<
+        inferRouterContext<AnyRouter>,
+        AWSLambdaCreateContextFn<TRouter, TEvent>
+      >;
 
-function tRPCOutputToAPIGatewayOutput<
-  TEvent extends APIGatewayEvent,
-  TResult extends APIGatewayResult,
->(event: TEvent, response: HTTPResponse): TResult {
-  if (isPayloadV1(event)) {
-    const resp: APIGatewayProxyResult = {
-      statusCode: response.status,
-      body: response.body ?? '',
-      headers: transformHeaders(response.headers ?? {}),
-    };
-    return resp as TResult;
-  } else if (isPayloadV2(event)) {
-    const resp: APIGatewayProxyStructuredResultV2 = {
-      statusCode: response.status,
-      body: response.body ?? undefined,
-      headers: transformHeaders(response.headers ?? {}),
-    };
-    return resp as TResult;
-  } else {
-    throw new TRPCError({
-      code: 'INTERNAL_SERVER_ERROR',
-      message: UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE,
-    });
-  }
-}
+export type AWSLambdaCreateContextFn<
+  TRouter extends AnyRouter,
+  TEvent extends LambdaEvent,
+> = ({
+  event,
+  context,
+  info,
+}: CreateAWSLambdaContextOptions<TEvent>) =>
+  | inferRouterContext<TRouter>
+  | Promise<inferRouterContext<TRouter>>;
 
-/** 1:1 mapping of v1 or v2 input events, deduces which is which.
- * @internal
- **/
-type inferAPIGWReturn<TType> = TType extends APIGatewayProxyEvent
-  ? APIGatewayProxyResult
-  : TType extends APIGatewayProxyEventV2
-  ? APIGatewayProxyStructuredResultV2
-  : never;
 export function awsLambdaRequestHandler<
   TRouter extends AnyRouter,
-  TEvent extends APIGatewayEvent,
-  TResult extends inferAPIGWReturn<TEvent>,
+  TEvent extends LambdaEvent,
 >(
   opts: AWSLambdaOptions<TRouter, TEvent>,
-): (event: TEvent, context: APIGWContext) => Promise<TResult> {
+): (event: TEvent, context: APIGWContext) => Promise<inferAPIGWReturn<TEvent>> {
   return async (event, context) => {
-    const req = lambdaEventToHTTPRequest(event);
-    const path = getPath(event);
+    const planner = getPlanner(event);
+
     const createContext: ResolveHTTPRequestOptionsContextFn<TRouter> = async (
       innerOpts,
     ) => {
       return await opts.createContext?.({ event, context, ...innerOpts });
     };
 
-    const response = await resolveHTTPResponse({
+    const response = await resolveResponse({
       ...opts,
       createContext,
-      req,
-      path,
+      req: planner.request,
+      path: planner.path,
       error: null,
       onError(o) {
         opts?.onError?.({
@@ -129,6 +80,6 @@ export function awsLambdaRequestHandler<
       },
     });
 
-    return tRPCOutputToAPIGatewayOutput<TEvent, TResult>(event, response);
+    return await planner.toResult(response);
   };
 }

package/src/adapters/express.ts

@@ -27,12 +27,7 @@ export function createExpressMiddleware<TRouter extends AnyRouter>(
     const endpoint = req.path.slice(1);
 
     await nodeHTTPRequestHandler({
-      // FIXME: no typecasting should be needed here
-      ...(opts as NodeHTTPHandlerOptions<
-        AnyRouter,
-        express.Request,
-        express.Response
-      >),
+      ...(opts as any),
       req,
       res,
       path: endpoint,

package/src/adapters/fastify/fastifyRequestHandler.ts

@@ -7,22 +7,19 @@
  * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
  * ```
  */
-import { Readable } from 'node:stream';
 import type { FastifyReply, FastifyRequest } from 'fastify';
 // @trpc/server
 import type { AnyRouter } from '../../@trpc/server';
 import type {
   HTTPBaseHandlerOptions,
-  HTTPRequest,
-  HTTPResponse,
   ResolveHTTPRequestOptionsContextFn,
-  ResponseChunk,
 } from '../../@trpc/server/http';
-import {
-  getBatchStreamFormatter,
-  resolveHTTPResponse,
-} from '../../@trpc/server/http';
-import type { NodeHTTPCreateContextOption } from '../node-http';
+import { resolveResponse } from '../../@trpc/server/http';
+import type {
+  IncomingMessageWithBody,
+  NodeHTTPCreateContextOption,
+} from '../node-http';
+import { incomingMessageToRequest } from '../node-http';
 
 export type FastifyHandlerOptions<
   TRouter extends AnyRouter,
@@ -55,80 +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,
-    body: opts.req.body ?? 'null',
-  };
+  // monkey-path body to the IncomingMessage
+  if ('body' in opts.req) {
+    incomingMessage.body = opts.req.body;
+  }
+  const req = incomingMessageToRequest(incomingMessage, {
+    maxBodySize: null,
+  });
 
-  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({
+  const res = await resolveResponse({
     ...opts,
     req,
+    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);
 }