@trpc/server 11.0.0-rc.584 → 11.0.0-rc.587

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

@@ -65,86 +65,95 @@ export function internal_exceptionHandler<
   };
 }
 
-export function nodeHTTPRequestHandler<
+/**
+ * @remark the promise never rejects
+ */
+export async function nodeHTTPRequestHandler<
   TRouter extends AnyRouter,
   TRequest extends NodeHTTPRequest,
   TResponse extends NodeHTTPResponse,
 >(opts: NodeHTTPRequestHandlerOptions<TRouter, TRequest, TResponse>) {
-  const handleViaMiddleware = opts.middleware ?? ((_req, _res, next) => next());
-
-  return handleViaMiddleware(opts.req, opts.res, (err: unknown) => {
-    run(async () => {
-      const req = incomingMessageToRequest(opts.req, {
-        maxBodySize: opts.maxBodySize ?? null,
-      });
-
-      // Build tRPC dependencies
-      const createContext: ResolveHTTPRequestOptionsContextFn<TRouter> = async (
-        innerOpts,
-      ) => {
-        return await opts.createContext?.({
-          ...opts,
-          ...innerOpts,
+  return new Promise<void>((resolve) => {
+    const handleViaMiddleware =
+      opts.middleware ?? ((_req, _res, next) => next());
+
+    opts.res.once('finish', () => {
+      resolve();
+    });
+    return handleViaMiddleware(opts.req, opts.res, (err: unknown) => {
+      run(async () => {
+        const req = incomingMessageToRequest(opts.req, {
+          maxBodySize: opts.maxBodySize ?? null,
         });
-      };
-
-      const response = await resolveResponse({
-        ...opts,
-        req,
-        error: err ? getTRPCErrorFromUnknown(err) : null,
-        createContext,
-        onError(o) {
-          opts?.onError?.({
-            ...o,
-            req: opts.req,
-          });
-        },
-      });
-
-      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);
+
+        // Build tRPC dependencies
+        const createContext: ResolveHTTPRequestOptionsContextFn<
+          TRouter
+        > = async (innerOpts) => {
+          return await opts.createContext?.({
+            ...opts,
+            ...innerOpts,
           });
         };
-        req.signal.addEventListener('abort', onAbort, {
-          once: true,
-        });
 
-        while (true) {
-          const { done, value } = await reader.read();
-
-          if (done) {
-            break;
-          }
-          if (!res.writable) {
-            break;
-          }
-          if (res.write(value) === false) {
-            await new Promise<void>((resolve) => {
-              res.once('drain', resolve);
+        const response = await resolveResponse({
+          ...opts,
+          req,
+          error: err ? getTRPCErrorFromUnknown(err) : null,
+          createContext,
+          onError(o) {
+            opts?.onError?.({
+              ...o,
+              req: opts.req,
             });
-          }
+          },
+        });
 
-          // useful for debugging chunked responses:
-          // console.log('wrote', Buffer.from(value).toString());
+        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,
+          });
 
-          // IMPORTANT - flush the response buffer, otherwise the client will not receive the data until `.end()`
-          res.flush?.();
+          while (true) {
+            const { done, value } = await reader.read();
+
+            if (done) {
+              break;
+            }
+            if (!res.writable) {
+              break;
+            }
+            if (res.write(value) === false) {
+              await new Promise<void>((resolve) => {
+                res.once('drain', resolve);
+              });
+            }
+
+            // useful for debugging chunked responses:
+            // console.log('wrote', Buffer.from(value).toString());
+
+            // IMPORTANT - flush the response buffer, otherwise the client will not receive the data until `.end()`
+            res.flush?.();
+          }
+          req.signal.removeEventListener('abort', onAbort);
         }
-        req.signal.removeEventListener('abort', onAbort);
-      }
-      res.end();
-    }).catch(internal_exceptionHandler(opts));
+        res.end();
+      }).catch(internal_exceptionHandler(opts));
+    });
   });
 }

package/src/adapters/standalone.ts

@@ -12,6 +12,8 @@ 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,
@@ -34,31 +36,27 @@ export function createHTTPHandler<TRouter extends AnyRouter>(
 ): http.RequestListener {
   return (req, res) => {
     let path = '';
-    try {
+    run(async () => {
       const url = toURL(req.url!);
 
       // get procedure path and remove the leading slash
       // /procedure -> procedure
       path = url.pathname.slice(1);
 
-      nodeHTTPRequestHandler({
+      await nodeHTTPRequestHandler({
         ...(opts as any),
         req,
         res,
         path,
       });
-    } catch (cause) {
-      internal_exceptionHandler<
-        TRouter,
-        http.IncomingMessage,
-        http.ServerResponse
-      >({
+    }).catch(
+      internal_exceptionHandler({
         req,
         res,
         path,
         ...opts,
-      })(cause);
-    }
+      }),
+    );
   };
 }