@trpc/server 11.0.0-rc.607 → 11.0.0-rc.619

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

@@ -1,6 +1,5 @@
 import type * as http from 'http';
 import { TRPCError } from '../../@trpc/server';
-import { toURL } from '../../http';
 
 export interface IncomingMessageWithBody extends http.IncomingMessage {
   /**
@@ -8,52 +7,112 @@ export interface IncomingMessageWithBody extends http.IncomingMessage {
    */
   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;
+
+function createBody(
+  req: http.IncomingMessage,
+  opts: {
+    /**
+     * Max body size in bytes. If the body is larger than this, the request will be aborted
+     */
+    maxBodySize: number | null;
+  },
+): RequestInit['body'] {
+  // Some adapters will pre-parse the body and add it to the request object
+  if ('body' in req) {
+    // If the body is already a string, return it directly
+    if (typeof req.body === 'string') {
+      return req.body;
+    }
+    // If body exists but isn't a string, stringify it as JSON
+    else if (req.body !== undefined) {
+      return JSON.stringify(req.body);
+    }
+    // If body property exists but is undefined, return undefined
+    return undefined;
+  }
   let size = 0;
-  const maxBodySize = opts.maxBodySize;
   let hasClosed = false;
 
-  const stream = new ReadableStream<Value>({
+  return new ReadableStream({
     start(controller) {
-      req.on('data', (chunk) => {
+      const onData = (chunk: Buffer) => {
         size += chunk.length;
-        if (maxBodySize != null && size > maxBodySize) {
-          controller.error(
-            new TRPCError({
-              code: 'PAYLOAD_TOO_LARGE',
-            }),
+        if (!opts.maxBodySize || size <= opts.maxBodySize) {
+          controller.enqueue(
+            new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength),
           );
-          // an error is thrown if we try to close the controller after
-          // erroring, so track the closure
-          hasClosed = true;
           return;
         }
-        controller.enqueue(chunk);
-      });
-      req.once('end', () => {
+        controller.error(
+          new TRPCError({
+            code: 'PAYLOAD_TOO_LARGE',
+          }),
+        );
+        hasClosed = true;
+        req.off('data', onData);
+        req.off('end', onEnd);
+      };
+
+      const onEnd = () => {
         if (hasClosed) {
           return;
         }
         hasClosed = true;
+        req.off('data', onData);
+        req.off('end', onEnd);
         controller.close();
-      });
+      };
+
+      req.on('data', onData);
+      req.on('end', onEnd);
     },
     cancel() {
       req.destroy();
     },
   });
+}
+export function createURL(req: http.IncomingMessage): URL {
+  try {
+    const protocol =
+      req.socket && 'encrypted' in req.socket && req.socket.encrypted
+        ? 'https:'
+        : 'http:';
 
-  return stream;
+    const host = req.headers.host ?? 'localhost';
+
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return new URL(req.url!, `${protocol}//${host}`);
+  } catch (cause) {
+    throw new TRPCError({
+      code: 'BAD_REQUEST',
+      message: 'Invalid URL',
+      cause,
+    });
+  }
+}
+
+function createHeaders(incoming: http.IncomingHttpHeaders): Headers {
+  const headers = new Headers();
+
+  for (const key in incoming) {
+    const value = incoming[key];
+    if (typeof key === 'string' && key.startsWith(':')) {
+      // Skip HTTP/2 pseudo-headers
+      continue;
+    }
+
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        headers.append(key, item);
+      }
+    } else if (value != null) {
+      headers.append(key, value);
+    }
+  }
+
+  return headers;
 }
 
-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)
  */
@@ -67,29 +126,30 @@ export function incomingMessageToRequest(
   },
 ): Request {
   const ac = new AbortController();
-  const headers = new Headers(req.headers as any);
-  const url = toURL(`http://${headers.get('host')}${req.url}`);
   req.once('aborted', () => {
     ac.abort();
   });
 
+  // Get host from either regular header or HTTP/2 pseudo-header
+  const url = createURL(req);
+
   const init: RequestInit = {
-    headers,
+    headers: createHeaders(req.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);
-    }
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    init.body = createBody(req, opts);
+
+    // init.duplex = 'half' must be set when body is a ReadableStream, and Node follows the spec.
+    // However, this property is not defined in the TypeScript types for RequestInit, so we have
+    // to cast it here in order to set it without a type error.
+    // See https://fetch.spec.whatwg.org/#dom-requestinit-duplex
+    // @ts-expect-error this is fine
+    init.duplex = 'half';
   }
+
   const request = new Request(url, init);
 
   return request;

package/src/adapters/standalone.ts

@@ -7,18 +7,21 @@
  * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
  * ```
  */
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
 import http from 'http';
 // @trpc/server
 import { type AnyRouter } from '../@trpc/server';
-import { toURL } from '../@trpc/server/http';
 // eslint-disable-next-line no-restricted-imports
 import { run } from '../unstable-core-do-not-import';
 import type {
   NodeHTTPCreateContextFnOptions,
   NodeHTTPHandlerOptions,
 } from './node-http';
-import { internal_exceptionHandler, nodeHTTPRequestHandler } from './node-http';
+import {
+  createURL,
+  internal_exceptionHandler,
+  nodeHTTPRequestHandler,
+} from './node-http';
 
 export type CreateHTTPHandlerOptions<TRouter extends AnyRouter> =
   NodeHTTPHandlerOptions<TRouter, http.IncomingMessage, http.ServerResponse>;
@@ -37,7 +40,7 @@ export function createHTTPHandler<TRouter extends AnyRouter>(
   return (req, res) => {
     let path = '';
     run(async () => {
-      const url = toURL(req.url!);
+      const url = createURL(req);
 
       // get procedure path and remove the leading slash
       // /procedure -> procedure

package/src/adapters/ws.ts

@@ -13,7 +13,7 @@ import {
   TRPCError,
 } from '../@trpc/server';
 import type { TRPCRequestInfo } from '../@trpc/server/http';
-import { toURL, type BaseHandlerOptions } from '../@trpc/server/http';
+import { type BaseHandlerOptions } from '../@trpc/server/http';
 import { parseTRPCMessage } from '../@trpc/server/rpc';
 // @trpc/server/rpc
 import type {
@@ -34,7 +34,7 @@ import {
   type MaybePromise,
 } from '../unstable-core-do-not-import';
 import { Unpromise } from '../vendor/unpromise';
-import type { NodeHTTPCreateContextFnOptions } from './node-http';
+import { createURL, type NodeHTTPCreateContextFnOptions } from './node-http';
 
 /**
  * Importing ws causes a build error
@@ -178,7 +178,7 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
      * - if connection params are expected, they will be created once received
      */
     let ctxPromise =
-      toURL(req.url ?? '').searchParams.get('connectionParams') === '1'
+      createURL(req).searchParams.get('connectionParams') === '1'
         ? unsetContextPromiseSymbol
         : createCtxPromise(() => null);
 

package/src/unstable-core-do-not-import.ts

@@ -22,7 +22,6 @@ export * from './unstable-core-do-not-import/http/formDataToObject';
 export * from './unstable-core-do-not-import/http/getHTTPStatusCode';
 export * from './unstable-core-do-not-import/http/parseConnectionParams';
 export * from './unstable-core-do-not-import/http/resolveResponse';
-export * from './unstable-core-do-not-import/http/toURL';
 export * from './unstable-core-do-not-import/http/types';
 export * from './unstable-core-do-not-import/initTRPC';
 export * from './unstable-core-do-not-import/middleware';

package/dist/unstable-core-do-not-import/http/toURL.d.ts

@@ -1,2 +0,0 @@
-export declare function toURL(urlOrPathname: string): URL;
-//# sourceMappingURL=toURL.d.ts.map

package/dist/unstable-core-do-not-import/http/toURL.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"toURL.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/http/toURL.ts"],"names":[],"mappings":"AAEA,wBAAgB,KAAK,CAAC,aAAa,EAAE,MAAM,GAAG,GAAG,CAchD"}

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

@@ -1,18 +0,0 @@
-'use strict';
-
-var TRPCError = require('../error/TRPCError.js');
-
-function toURL(urlOrPathname) {
-    try {
-        const url = urlOrPathname.startsWith('/') ? `http://127.0.0.1${urlOrPathname}` : urlOrPathname;
-        return new URL(url);
-    } catch (cause) {
-        throw new TRPCError.TRPCError({
-            code: 'BAD_REQUEST',
-            message: 'Invalid URL',
-            cause
-        });
-    }
-}
-
-exports.toURL = toURL;

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

@@ -1,16 +0,0 @@
-import { TRPCError } from '../error/TRPCError.mjs';
-
-function toURL(urlOrPathname) {
-    try {
-        const url = urlOrPathname.startsWith('/') ? `http://127.0.0.1${urlOrPathname}` : urlOrPathname;
-        return new URL(url);
-    } catch (cause) {
-        throw new TRPCError({
-            code: 'BAD_REQUEST',
-            message: 'Invalid URL',
-            cause
-        });
-    }
-}
-
-export { toURL };

package/src/unstable-core-do-not-import/http/toURL.ts

@@ -1,17 +0,0 @@
-import { TRPCError } from '../error/TRPCError';
-
-export function toURL(urlOrPathname: string): URL {
-  try {
-    const url = urlOrPathname.startsWith('/')
-      ? `http://127.0.0.1${urlOrPathname}`
-      : urlOrPathname;
-
-    return new URL(url);
-  } catch (cause) {
-    throw new TRPCError({
-      code: 'BAD_REQUEST',
-      message: 'Invalid URL',
-      cause,
-    });
-  }
-}