@trpc/server 11.0.0-alpha-tmp-subscription-connection-state.489 → 11.0.0-alpha-tmp-12-06-react.665

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

@@ -7,57 +7,118 @@ 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:';
+
+    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;
+    }
 
-  return stream;
+    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)
  */
 export function incomingMessageToRequest(
   req: http.IncomingMessage,
+  res: http.ServerResponse,
   opts: {
     /**
      * Max body size in bytes. If the body is larger than this, the request will be aborted
@@ -66,29 +127,38 @@ export function incomingMessageToRequest(
   },
 ): Request {
   const ac = new AbortController();
-  const headers = new Headers(req.headers as any);
-  const url = `http://${headers.get('host')}${req.url}`;
-  req.once('aborted', () => {
+
+  const onAbort = () => {
+    res.off('close', onAbort);
+    req.socket.off('end', onAbort);
+
+    // abort the request
     ac.abort();
-  });
+  };
+
+  res.once('close', onAbort);
+  req.socket.once('end', onAbort);
+
+  // 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/node-http/nodeHTTPRequestHandler.ts

@@ -10,90 +10,112 @@
 
 // @trpc/server
 
-import { getTRPCErrorFromUnknown, type AnyRouter } from '../../@trpc/server';
+import {
+  getTRPCErrorFromUnknown,
+  transformTRPCResponse,
+  type AnyRouter,
+} from '../../@trpc/server';
 import type { ResolveHTTPRequestOptionsContextFn } from '../../@trpc/server/http';
 import { resolveResponse } from '../../@trpc/server/http';
+// eslint-disable-next-line no-restricted-imports
+import { getErrorShape, run } from '../../unstable-core-do-not-import';
 import { incomingMessageToRequest } from './incomingMessageToRequest';
 import type {
   NodeHTTPRequest,
   NodeHTTPRequestHandlerOptions,
   NodeHTTPResponse,
 } from './types';
+import { writeResponse } from './writeResponse';
 
-export async function nodeHTTPRequestHandler<
+/**
+ * @internal
+ */
+export function internal_exceptionHandler<
   TRouter extends AnyRouter,
   TRequest extends NodeHTTPRequest,
   TResponse extends NodeHTTPResponse,
 >(opts: NodeHTTPRequestHandlerOptions<TRouter, TRequest, TResponse>) {
-  const handleViaMiddleware = opts.middleware ?? ((_req, _res, next) => next());
+  return (cause: unknown) => {
+    const { res, req } = opts;
+    const error = getTRPCErrorFromUnknown(cause);
 
-  return handleViaMiddleware(opts.req, opts.res, async (err) => {
-    const req = incomingMessageToRequest(opts.req, {
-      maxBodySize: opts.maxBodySize ?? null,
+    const shape = getErrorShape({
+      config: opts.router._def._config,
+      error,
+      type: 'unknown',
+      path: undefined,
+      input: undefined,
+      ctx: undefined,
     });
 
-    // Build tRPC dependencies
-    const createContext: ResolveHTTPRequestOptionsContextFn<TRouter> = async (
-      innerOpts,
-    ) => {
-      return await opts.createContext?.({
-        ...opts,
-        ...innerOpts,
-      });
-    };
-
-    const response = await resolveResponse({
-      ...opts,
+    opts.onError?.({
       req,
-      error: err ? getTRPCErrorFromUnknown(err) : null,
-      createContext,
-      onError(o) {
-        opts?.onError?.({
-          ...o,
-          req: opts.req,
-        });
-      },
+      error,
+      type: 'unknown',
+      path: undefined,
+      input: undefined,
+      ctx: undefined,
     });
 
-    const { res } = opts;
-    if (res.statusCode === 200) {
-      // if the status code is set, we assume that it's been manually overridden
-      res.statusCode = response.status;
-    }
-    for (const [key, value] of response.headers) {
-      res.setHeader(key, value);
-    }
-    if (response.body) {
-      const reader = response.body.getReader();
-      const onAbort = () => {
-        // cancelling the reader will cause the whole stream to be cancelled
-        reader.cancel().catch(() => {
-          // console.error('reader.cancel() error', err);
-        });
-      };
-      req.signal.addEventListener('abort', onAbort, {
-        once: true,
-      });
+    const transformed = transformTRPCResponse(opts.router._def._config, {
+      error: shape,
+    });
+
+    res.statusCode = shape.data.httpStatus;
+    res.end(JSON.stringify(transformed));
+  };
+}
+
+/**
+ * @remark the promise never rejects
+ */
+export async function nodeHTTPRequestHandler<
+  TRouter extends AnyRouter,
+  TRequest extends NodeHTTPRequest,
+  TResponse extends NodeHTTPResponse,
+>(opts: NodeHTTPRequestHandlerOptions<TRouter, TRequest, TResponse>) {
+  return new Promise<void>((resolve) => {
+    const handleViaMiddleware =
+      opts.middleware ?? ((_req, _res, next) => next());
 
-      while (true) {
-        const { done, value } = await reader.read();
+    opts.res.once('finish', () => {
+      resolve();
+    });
+    return handleViaMiddleware(opts.req, opts.res, (err: unknown) => {
+      run(async () => {
+        const request = incomingMessageToRequest(opts.req, opts.res, {
+          maxBodySize: opts.maxBodySize ?? null,
+        });
 
-        if (done) {
-          break;
-        }
-        if (!res.writable) {
-          break;
-        }
-        if (res.write(value) === false) {
-          await new Promise<void>((resolve) => {
-            res.once('drain', resolve);
+        // Build tRPC dependencies
+        const createContext: ResolveHTTPRequestOptionsContextFn<
+          TRouter
+        > = async (innerOpts) => {
+          return await opts.createContext?.({
+            ...opts,
+            ...innerOpts,
           });
-        }
-        // IMPORTANT - flush the response buffer, otherwise the client will not receive the data until `.end()`
-        res.flush?.();
-      }
-      req.signal.removeEventListener('abort', onAbort);
-    }
-    res.end();
+        };
+
+        const response = await resolveResponse({
+          ...opts,
+          req: request,
+          error: err ? getTRPCErrorFromUnknown(err) : null,
+          createContext,
+          onError(o) {
+            opts?.onError?.({
+              ...o,
+              req: opts.req,
+            });
+          },
+        });
+
+        await writeResponse({
+          request,
+          response,
+          rawResponse: opts.res,
+        });
+      }).catch(internal_exceptionHandler(opts));
+    });
   });
 }

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

@@ -0,0 +1,94 @@
+// eslint-disable-next-line no-restricted-imports
+import { isAbortError } from '../../unstable-core-do-not-import';
+import type { NodeHTTPResponse } from './types';
+
+async function writeResponseBodyChunk(
+  res: NodeHTTPResponse,
+  chunk: Uint8Array,
+) {
+  // useful for debugging 🙃
+  // console.debug('writing', new TextDecoder().decode(chunk));
+
+  if (res.write(chunk) === false) {
+    await new Promise<void>((resolve, reject) => {
+      const onError = (err: unknown) => {
+        reject(err);
+        cleanup();
+      };
+      const onDrain = () => {
+        resolve();
+        cleanup();
+      };
+      const cleanup = () => {
+        res.off('error', onError);
+        res.off('drain', onDrain);
+      };
+      res.once('error', onError);
+      res.once('drain', onDrain);
+    });
+  }
+}
+/**
+ * @internal
+ */
+
+export async function writeResponseBody(opts: {
+  res: NodeHTTPResponse;
+  signal: AbortSignal;
+  body: NonNullable<Response['body']>;
+}) {
+  const { res } = opts;
+
+  try {
+    const writableStream = new WritableStream({
+      async write(chunk) {
+        await writeResponseBodyChunk(res, chunk);
+        res.flush?.();
+      },
+    });
+
+    await opts.body.pipeTo(writableStream, {
+      signal: opts.signal,
+    });
+  } catch (err) {
+    if (isAbortError(err)) {
+      return;
+    }
+    throw err;
+  }
+}
+/**
+ * @internal
+ */
+
+export async function writeResponse(opts: {
+  request: Request;
+  response: Response;
+  rawResponse: NodeHTTPResponse;
+}) {
+  const { response, rawResponse } = opts;
+
+  // Only override status code if it hasn't been explicitly set in a procedure etc
+  if (rawResponse.statusCode === 200) {
+    rawResponse.statusCode = response.status;
+  }
+  for (const [key, value] of response.headers) {
+    rawResponse.setHeader(key, value);
+  }
+  try {
+    if (response.body) {
+      await writeResponseBody({
+        res: rawResponse,
+        signal: opts.request.signal,
+        body: response.body,
+      });
+    }
+  } catch (err) {
+    if (!rawResponse.headersSent) {
+      rawResponse.statusCode = 500;
+    }
+    throw err;
+  } finally {
+    rawResponse.end();
+  }
+}

package/src/adapters/standalone.ts

@@ -7,16 +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';
+import { type AnyRouter } from '../@trpc/server';
+// eslint-disable-next-line no-restricted-imports
+import { run } from '../unstable-core-do-not-import';
 import type {
   NodeHTTPCreateContextFnOptions,
   NodeHTTPHandlerOptions,
 } from './node-http';
-import { nodeHTTPRequestHandler } from './node-http';
+import {
+  createURL,
+  internal_exceptionHandler,
+  nodeHTTPRequestHandler,
+} from './node-http';
 
 export type CreateHTTPHandlerOptions<TRouter extends AnyRouter> =
   NodeHTTPHandlerOptions<TRouter, http.IncomingMessage, http.ServerResponse>;
@@ -26,28 +31,40 @@ export type CreateHTTPContextOptions = NodeHTTPCreateContextFnOptions<
   http.ServerResponse
 >;
 
+/**
+ * @internal
+ */
 export function createHTTPHandler<TRouter extends AnyRouter>(
   opts: CreateHTTPHandlerOptions<TRouter>,
-) {
-  return async (req: http.IncomingMessage, res: http.ServerResponse) => {
-    const url = toURL(req.url!);
+): http.RequestListener {
+  return (req, res) => {
+    let path = '';
+    run(async () => {
+      const url = createURL(req);
 
-    // get procedure path and remove the leading slash
-    // /procedure -> procedure
-    const path = url.pathname.slice(1);
+      // get procedure path and remove the leading slash
+      // /procedure -> procedure
+      path = url.pathname.slice(1);
 
-    await nodeHTTPRequestHandler({
-      ...(opts as any),
-      req,
-      res,
-      path,
-    });
+      await nodeHTTPRequestHandler({
+        ...(opts as any),
+        req,
+        res,
+        path,
+      });
+    }).catch(
+      internal_exceptionHandler({
+        req,
+        res,
+        path,
+        ...opts,
+      }),
+    );
   };
 }
 
 export function createHTTPServer<TRouter extends AnyRouter>(
   opts: CreateHTTPHandlerOptions<TRouter>,
 ) {
-  const handler = createHTTPHandler(opts);
-  return http.createServer(handler);
+  return http.createServer(createHTTPHandler(opts));
 }