feat(ts-rest/nest): allow TsRestException to be handled in Nest exception filters (#451)

Co-authored-by: Reece Fenwick <reecefenwick@Reeces-MacBook-Pro.local>
Co-authored-by: Michael Angelo Rivera <55844504+michaelangeloio@users.noreply.github.com>

Author: 3 people

.changeset/funny-taxis-brush.md

@@ -0,0 +1,5 @@
+---
+'@ts-rest/nest': minor
+---
+
+feat: `@ts-rest/nest` allow TsRestException to be handled by NestJS exception filters

libs/ts-rest/nest/src/lib/ts-rest-nest-handler.spec.ts

@@ -7,9 +7,13 @@ import {
 } from './ts-rest-nest-handler';
 import { z } from 'zod';
 import {
+  ArgumentsHost,
   Body,
+  Catch,
   Controller,
+  ExceptionFilter,
   Get,
+  HttpException,
   Post,
   UploadedFile,
   UseInterceptors,
@@ -20,6 +24,7 @@ import { TsRest } from './ts-rest.decorator';
 import path = require('path');
 import { FileInterceptor } from '@nestjs/platform-express';
 import { FastifyAdapter } from '@nestjs/platform-fastify';
+import { Response } from 'express';
 
 export type Equal<a, b> = (<T>() => T extends a ? 1 : 2) extends <
   T
@@ -1046,6 +1051,87 @@ describe('ts-rest-nest-handler', () => {
         }
       }
     });
+
+    it('should be able to throw a TsRestException to be handled by an exception filter', async () => {
+      const c = initContract();
+
+      const contract = c.router({
+        test: {
+          path: '/test',
+          method: 'GET',
+          responses: {
+            200: z.object({
+              message: z.string(),
+            }),
+            400: z.object({
+              myError: z.string(),
+            }),
+          },
+        },
+      });
+
+      const httpExceptionObserver = jest.fn();
+
+      @Catch()
+      class HttpExceptionFilter implements ExceptionFilter {
+        catch(exception: unknown, host: ArgumentsHost): void {
+          httpExceptionObserver(exception);
+
+          const ctx = host.switchToHttp();
+
+          const response = ctx.getResponse<Response>();
+
+          if (exception instanceof HttpException) {
+            response
+              .status(exception.getStatus())
+              .send(exception.getResponse());
+          } else {
+            response.status(500).send('something went wrong');
+          }
+        }
+      }
+
+      @Controller()
+      class SingleHandlerTestController {
+        @TsRestHandler(contract, { validateResponses: true })
+        async postRequest() {
+          return tsRestHandler(contract, {
+            test: async () => {
+              throw new TsRestException(contract.test, {
+                status: 400,
+                body: {
+                  myError: 'my error',
+                },
+              });
+            },
+          });
+        }
+      }
+
+      const moduleRef = await Test.createTestingModule({
+        controllers: [SingleHandlerTestController],
+      }).compile();
+
+      const app = moduleRef.createNestApplication();
+      app.useGlobalFilters(new HttpExceptionFilter());
+
+      await app.init();
+
+      const response = await supertest(app.getHttpServer()).get('/test').send();
+
+      expect(response.status).toBe(400);
+      expect(response.body).toEqual({ myError: 'my error' });
+
+      // verify exception filter received error from ts-rest handler
+      expect(httpExceptionObserver).toHaveBeenCalledTimes(1);
+      expect(httpExceptionObserver.mock.calls[0][0]).toMatchObject({
+        status: 400,
+        response: { myError: 'my error' },
+        options: {
+          cause: expect.any(TsRestException),
+        },
+      });
+    });
   });
 
   it('should be able to combine single-handler, multi-handler and vanilla nest controllers', async () => {

libs/ts-rest/nest/src/lib/ts-rest-nest-handler.ts

@@ -49,7 +49,7 @@ export class RequestValidationError extends BadRequestException {
     public pathParams: z.ZodError | null,
     public headers: z.ZodError | null,
     public query: z.ZodError | null,
-    public body: z.ZodError | null
+    public body: z.ZodError | null,
   ) {
     super({
       paramsResult: pathParams,
@@ -61,16 +61,19 @@ export class RequestValidationError extends BadRequestException {
 }
 
 export class ResponseValidationError extends InternalServerErrorException {
-  constructor(public appRoute: AppRoute, public error: z.ZodError) {
+  constructor(
+    public appRoute: AppRoute,
+    public error: z.ZodError,
+  ) {
     super(
-      `[ts-rest] Response validation failed for ${appRoute.method} ${appRoute.path}: ${error.message}`
+      `[ts-rest] Response validation failed for ${appRoute.method} ${appRoute.path}: ${error.message}`,
     );
   }
 }
 
 export const TsRestHandler = (
   appRouterOrRoute: AppRouter | AppRoute,
-  options: TsRestOptions = {}
+  options: TsRestOptions = {},
 ): MethodDecorator => {
   const decorators = [];
 
@@ -80,20 +83,20 @@ export const TsRestHandler = (
 
   if (options.validateResponses !== undefined) {
     decorators.push(
-      SetMetadata(ValidateResponsesSymbol, options.validateResponses)
+      SetMetadata(ValidateResponsesSymbol, options.validateResponses),
     );
   }
 
   decorators.push(
     SetMetadata(
       ValidateRequestHeadersSymbol,
-      options.validateRequestHeaders ?? true
+      options.validateRequestHeaders ?? true,
     ),
     SetMetadata(
       ValidateRequestQuerySymbol,
-      options.validateRequestQuery ?? true
+      options.validateRequestQuery ?? true,
     ),
-    SetMetadata(ValidateRequestBodySymbol, options.validateRequestBody ?? true)
+    SetMetadata(ValidateRequestBodySymbol, options.validateRequestBody ?? true),
   );
 
   const isMultiHandler = !isAppRoute(appRouterOrRoute);
@@ -112,7 +115,7 @@ export const TsRestHandler = (
     decorators.push(
       All(routerPathsArray),
       SetMetadata(TsRestAppRouteMetadataKey, appRouterOrRoute),
-      UseInterceptors(TsRestHandlerInterceptor)
+      UseInterceptors(TsRestHandlerInterceptor),
     );
   } else {
     const apiDecorator = (() => {
@@ -133,7 +136,7 @@ export const TsRestHandler = (
     decorators.push(
       apiDecorator,
       SetMetadata(TsRestAppRouteMetadataKey, appRouterOrRoute),
-      UseInterceptors(TsRestHandlerInterceptor)
+      UseInterceptors(TsRestHandlerInterceptor),
     );
   }
 
@@ -146,7 +149,7 @@ type NestHandlerImplementation<T extends AppRouter | AppRoute> =
     : {
         [K in keyof T]: T[K] extends AppRoute
           ? (
-              args: TsRestRequestShape<T[K]>
+              args: TsRestRequestShape<T[K]>,
             ) => Promise<ServerInferResponses<T[K]>>
           : never;
       };
@@ -159,7 +162,7 @@ type NestHandlerImplementation<T extends AppRouter | AppRoute> =
  */
 export const tsRestHandler = <T extends AppRouter | AppRoute>(
   contract: T,
-  implementation: NestHandlerImplementation<T>
+  implementation: NestHandlerImplementation<T>,
 ) => implementation;
 
 /**
@@ -179,7 +182,7 @@ export const doesUrlMatchContractPath = (
   /**
    * @example '/posts/1'
    */
-  url: string
+  url: string,
 ): boolean => {
   // strip trailing slash
   if (contractPath !== '/' && contractPath.endsWith('/')) {
@@ -223,12 +226,12 @@ export class TsRestHandlerInterceptor implements NestInterceptor {
 
     const appRoute = this.reflector.get<AppRoute | AppRouter | undefined>(
       TsRestAppRouteMetadataKey,
-      ctx.getHandler()
+      ctx.getHandler(),
     );
 
     if (!appRoute) {
       throw new Error(
-        'Could not find app router or app route, ensure you are using the @TsRestHandler decorator on your method'
+        'Could not find app router or app route, ensure you are using the @TsRestHandler decorator on your method',
       );
     }
 
@@ -246,7 +249,7 @@ export class TsRestHandlerInterceptor implements NestInterceptor {
         return (
           doesUrlMatchContractPath(
             value.path,
-            'path' in req ? req.path : req.routeOptions.url
+            'path' in req ? req.path : req.routeOptions.url,
           ) && req.method === value.method
         );
       }
@@ -280,13 +283,13 @@ export class TsRestHandlerInterceptor implements NestInterceptor {
         | typeof ValidateResponsesSymbol
         | typeof ValidateRequestHeadersSymbol
         | typeof ValidateRequestQuerySymbol
-        | typeof ValidateRequestBodySymbol
+        | typeof ValidateRequestBodySymbol,
     ) =>
       Boolean(
         this.reflector.getAllAndOverride<boolean | undefined>(key, [
           ctx.getHandler(),
           ctx.getClass(),
-        ])
+        ]),
       );
 
     const paramsResult = checkZodSchema(req.params, appRoute.pathParams, {
@@ -305,7 +308,7 @@ export class TsRestHandlerInterceptor implements NestInterceptor {
 
     const bodyResult = checkZodSchema(
       req.body,
-      'body' in appRoute ? appRoute.body : null
+      'body' in appRoute ? appRoute.body : null,
     );
 
     const isValidationEnabled = getMetadataValue(ValidateResponsesSymbol);
@@ -329,7 +332,7 @@ export class TsRestHandlerInterceptor implements NestInterceptor {
         !paramsResult.success ? paramsResult.error : null,
         isHeadersInvalid ? headersResult.error : null,
         isQueryInvalid ? queryResult.error : null,
-        isBodyInvalid ? bodyResult.error : null
+        isBodyInvalid ? bodyResult.error : null,
       );
     }
 
@@ -350,7 +353,7 @@ export class TsRestHandlerInterceptor implements NestInterceptor {
             result = {
               status: e.getStatus(),
               body: e.getResponse(),
-              error: true,
+              error: e,
             };
           } else {
             throw e;
@@ -362,7 +365,16 @@ export class TsRestHandlerInterceptor implements NestInterceptor {
           : result;
 
         const responseType = appRoute.responses[result.status];
-        if (!result.error && isAppRouteOtherResponse(responseType)) {
+
+        if (result.error) {
+          throw new HttpException(
+            responseAfterValidation.body,
+            responseAfterValidation.status,
+            {
+              cause: result.error,
+            },
+          );
+        } else if (!result.error && isAppRouteOtherResponse(responseType)) {
           if ('setHeader' in res) {
             res.setHeader('content-type', responseType.contentType);
           } else {
@@ -372,15 +384,15 @@ export class TsRestHandlerInterceptor implements NestInterceptor {
 
         res.status(responseAfterValidation.status);
         return responseAfterValidation.body;
-      })
+      }),
     );
   }
 }
 
 const validateResponse = (
   appRoute: AppRoute,
-  response: { status: number; body?: unknown }
-) => {
+  response: { status: number; body?: unknown },
+): { body: unknown; status: number } => {
   const { body } = response;
 
   const responseType = appRoute.responses[response.status];
@@ -390,13 +402,13 @@ const validateResponse = (
 
   if (!responseSchema) {
     throw new InternalServerErrorException(
-      `[ts-rest] Couldn't find a response schema for ${response.status} on route ${appRoute.path}`
+      `[ts-rest] Couldn't find a response schema for ${response.status} on route ${appRoute.path}`,
     );
   }
 
   const responseValidation = checkZodSchema(
     body,
-    appRoute.responses[response.status]
+    appRoute.responses[response.status],
   );
 
   if (!responseValidation.success) {