@trpc/server 11.0.0-rc.566 → 11.0.0-rc.567

package/src/adapters/express.ts

@@ -23,14 +23,14 @@ export type CreateExpressContextOptions = NodeHTTPCreateContextFnOptions<
 export function createExpressMiddleware<TRouter extends AnyRouter>(
   opts: NodeHTTPHandlerOptions<TRouter, express.Request, express.Response>,
 ): express.Handler {
-  return async (req, res) => {
-    const endpoint = req.path.slice(1);
+  return (req, res) => {
+    const path = req.path.slice(1);
 
-    await nodeHTTPRequestHandler({
+    nodeHTTPRequestHandler({
       ...(opts as any),
       req,
       res,
-      path: endpoint,
+      path,
     });
   };
 }

package/src/adapters/next.ts

@@ -11,12 +11,14 @@ import type { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
 // @trpc/server
 import type { AnyRouter } from '../@trpc/server';
 // @trpc/server
-import { getErrorShape, TRPCError } from '../@trpc/server';
+import { TRPCError } 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 { internal_exceptionHandler, nodeHTTPRequestHandler } from './node-http';
 
 export type CreateNextContextOptions = NodeHTTPCreateContextFnOptions<
   NextApiRequest,
@@ -28,47 +30,43 @@ export type CreateNextContextOptions = NodeHTTPCreateContextFnOptions<
  */
 export type { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
 
+type SyncNextApiHandler = (req: NextApiRequest, res: NextApiResponse) => void;
+
 export function createNextApiHandler<TRouter extends AnyRouter>(
   opts: NodeHTTPHandlerOptions<TRouter, NextApiRequest, NextApiResponse>,
 ): NextApiHandler {
-  return async (req, res) => {
-    function getPath(): string | null {
-      if (typeof req.query['trpc'] === 'string') {
-        return req.query['trpc'];
-      }
-      if (Array.isArray(req.query['trpc'])) {
-        return req.query['trpc'].join('/');
-      }
-      return null;
-    }
-    const path = getPath();
-
-    if (path === null) {
-      const error = getErrorShape({
-        config: opts.router._def._config,
-        error: new TRPCError({
+  let path = '';
+  const handler: SyncNextApiHandler = (req, res) => {
+    try {
+      path = run(() => {
+        if (typeof req.query['trpc'] === 'string') {
+          return req.query['trpc'];
+        }
+        if (Array.isArray(req.query['trpc'])) {
+          return req.query['trpc'].join('/');
+        }
+        throw new TRPCError({
           message:
             'Query "trpc" not found - is the file named `[trpc]`.ts or `[...trpc].ts`?',
           code: 'INTERNAL_SERVER_ERROR',
-        }),
-        type: 'unknown',
-        ctx: undefined,
-        path: undefined,
-        input: undefined,
+        });
       });
-      res.statusCode = 500;
-      res.json({
-        id: -1,
-        error,
+
+      nodeHTTPRequestHandler({
+        ...(opts as any),
+        req,
+        res,
+        path,
       });
-      return;
+    } catch (cause) {
+      internal_exceptionHandler({
+        req,
+        res,
+        path,
+        ...opts,
+      })(cause);
     }
-
-    await nodeHTTPRequestHandler({
-      ...(opts as any),
-      req,
-      res,
-      path,
-    });
   };
+
+  return handler;
 }

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

@@ -1,5 +1,6 @@
 import type * as http from 'http';
 import { TRPCError } from '../../@trpc/server';
+import { toURL } from '../../http';
 
 export interface IncomingMessageWithBody extends http.IncomingMessage {
   /**
@@ -67,7 +68,7 @@ export function incomingMessageToRequest(
 ): Request {
   const ac = new AbortController();
   const headers = new Headers(req.headers as any);
-  const url = `http://${headers.get('host')}${req.url}`;
+  const url = toURL(`http://${headers.get('host')}${req.url}`);
   req.once('aborted', () => {
     ac.abort();
   });

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

@@ -10,9 +10,15 @@
 
 // @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,
@@ -20,84 +26,125 @@ import type {
   NodeHTTPResponse,
 } from './types';
 
-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 transformed = transformTRPCResponse(opts.router._def._config, {
+      error: shape,
     });
 
-    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);
+    res.statusCode = shape.data.httpStatus;
+    res.end(JSON.stringify(transformed));
+  };
+}
+
+export 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,
         });
       };
-      req.signal.addEventListener('abort', onAbort, {
-        once: true,
-      });
 
-      while (true) {
-        const { done, value } = await reader.read();
+      const response = await resolveResponse({
+        ...opts,
+        req,
+        error: err ? getTRPCErrorFromUnknown(err) : null,
+        createContext,
+        onError(o) {
+          opts?.onError?.({
+            ...o,
+            req: opts.req,
+          });
+        },
+      });
 
-        if (done) {
-          break;
-        }
-        if (!res.writable) {
-          break;
-        }
-        if (res.write(value) === false) {
-          await new Promise<void>((resolve) => {
-            res.once('drain', resolve);
+      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,
+        });
+
+        while (true) {
+          const { done, value } = await reader.read();
 
-        // useful for debugging chunked responses:
-        // console.log('wrote', Buffer.from(value).toString());
+          if (done) {
+            break;
+          }
+          if (!res.writable) {
+            break;
+          }
+          if (res.write(value) === false) {
+            await new Promise<void>((resolve) => {
+              res.once('drain', resolve);
+            });
+          }
 
-        // IMPORTANT - flush the response buffer, otherwise the client will not receive the data until `.end()`
-        res.flush?.();
+          // 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();
+      res.end();
+    }).catch(internal_exceptionHandler(opts));
   });
 }

package/src/adapters/standalone.ts

@@ -10,13 +10,13 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import http from 'http';
 // @trpc/server
-import type { AnyRouter } from '../@trpc/server';
+import { type AnyRouter } from '../@trpc/server';
 import { toURL } from '../@trpc/server/http';
 import type {
   NodeHTTPCreateContextFnOptions,
   NodeHTTPHandlerOptions,
 } from './node-http';
-import { nodeHTTPRequestHandler } from './node-http';
+import { internal_exceptionHandler, nodeHTTPRequestHandler } from './node-http';
 
 export type CreateHTTPHandlerOptions<TRouter extends AnyRouter> =
   NodeHTTPHandlerOptions<TRouter, http.IncomingMessage, http.ServerResponse>;
@@ -26,28 +26,44 @@ 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 = '';
+    try {
+      const url = toURL(req.url!);
 
-    // 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,
-    });
+      nodeHTTPRequestHandler({
+        ...(opts as any),
+        req,
+        res,
+        path,
+      });
+    } catch (cause) {
+      internal_exceptionHandler<
+        TRouter,
+        http.IncomingMessage,
+        http.ServerResponse
+      >({
+        req,
+        res,
+        path,
+        ...opts,
+      })(cause);
+    }
   };
 }
 
 export function createHTTPServer<TRouter extends AnyRouter>(
   opts: CreateHTTPHandlerOptions<TRouter>,
 ) {
-  const handler = createHTTPHandler(opts);
-  return http.createServer(handler);
+  return http.createServer(createHTTPHandler(opts));
 }

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

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