feat: export a Zod schema that matches the request validation error responses (#601)

Co-authored-by: lrwlfdevnet <lrwlfyang@tencent.com>

Author: lrwlf

.changeset/sharp-kings-listen.md

@@ -0,0 +1,10 @@
+---
+'@ts-rest/serverless': minor
+'@ts-rest/express': minor
+'@ts-rest/fastify': minor
+'@ts-rest/core': minor
+'@ts-rest/nest': minor
+'@ts-rest/next': minor
+---
+
+Export `RequestValidationErrorSchema` for default request validation error responses.

libs/ts-rest/core/src/lib/zod-utils.ts

@@ -101,3 +101,17 @@ export const zodErrorResponse = (
     issues: error.issues,
   };
 };
+
+export const ZodErrorSchema = z.object({
+  name: z.literal('ZodError'),
+  issues: z.array(
+    z
+      .object({
+        path: z.array(z.union([z.string(), z.number()])),
+        message: z.string().optional(),
+        code: z.nativeEnum(z.ZodIssueCode),
+      })
+      // ZodIssuse type are complex and potentially unstable. So we don’t deal with his specific fields other than the common.
+      .catchall(z.any()),
+  ),
+});

libs/ts-rest/express/src/lib/request-validation-error.ts

@@ -1,3 +1,4 @@
+import { ZodErrorSchema } from '@ts-rest/core';
 import { z } from 'zod';
 
 export class RequestValidationError extends Error {
@@ -10,3 +11,12 @@ export class RequestValidationError extends Error {
     super('[ts-rest] request validation failed');
   }
 }
+
+export const DefaultRequestValidationErrorSchema = ZodErrorSchema;
+
+export const CombinedRequestValidationErrorSchema = z.object({
+  pathParameterErrors: ZodErrorSchema.nullable(),
+  headerErrors: ZodErrorSchema.nullable(),
+  queryParameterErrors: ZodErrorSchema.nullable(),
+  bodyErrors: ZodErrorSchema.nullable(),
+});

libs/ts-rest/express/src/lib/ts-rest-express.spec.ts

@@ -10,6 +10,10 @@ import * as express from 'express';
 import { z } from 'zod';
 import { createExpressEndpoints, initServer } from './ts-rest-express';
 import * as multer from 'multer';
+import {
+  CombinedRequestValidationErrorSchema,
+  DefaultRequestValidationErrorSchema,
+} from './request-validation-error';
 
 const upload = multer();
 
@@ -468,4 +472,88 @@ describe('ts-rest-express', () => {
         expect(res.body).toEqual({ message: 'Not found' });
       });
   });
+
+  it("should throw default requestValidation error if body doesn't match", async () => {
+    const contract = c.router({
+      createPost: {
+        method: 'POST',
+        path: '/posts',
+        body: z.object({
+          id: z.string(),
+          content: z.string(),
+        }),
+        responses: {
+          200: c.noBody(),
+          400: DefaultRequestValidationErrorSchema,
+        },
+      },
+    });
+
+    const router = s.router(contract, {
+      createPost: async () => {
+        return {
+          status: 200,
+          body: undefined,
+        };
+      },
+    });
+
+    const app = express();
+    app.use(express.json());
+    app.use(express.urlencoded({ extended: true }));
+    createExpressEndpoints(contract, router, app, {
+      requestValidationErrorHandler: 'default',
+    });
+
+    await supertest(app)
+      .post('/posts')
+      .expect((res) => {
+        expect(res.status).toEqual(400);
+        expect(() =>
+          DefaultRequestValidationErrorSchema.parse(res.body),
+        ).not.toThrowError();
+      });
+  });
+
+  it("should throw combined requestValidation error if body doesn't match", async () => {
+    const contract = c.router({
+      createPost: {
+        method: 'POST',
+        path: '/posts',
+        body: z.object({
+          id: z.string(),
+          content: z.string(),
+        }),
+        responses: {
+          200: c.noBody(),
+          400: DefaultRequestValidationErrorSchema,
+        },
+      },
+    });
+
+    const router = s.router(contract, {
+      createPost: async () => {
+        return {
+          status: 200,
+          body: undefined,
+        };
+      },
+    });
+
+    const app = express();
+    app.use(express.json());
+    app.use(express.urlencoded({ extended: true }));
+    createExpressEndpoints(contract, router, app, {
+      requestValidationErrorHandler: 'combined',
+    });
+
+    await supertest(app)
+      .post('/posts')
+      .expect((res) => {
+        expect(res.status).toEqual(400);
+        expect(() =>
+          CombinedRequestValidationErrorSchema.parse(res.body),
+        ).not.toThrowError();
+      });
+  });
 });

libs/ts-rest/fastify/src/lib/ts-rest-fastify.spec.ts

@@ -1,5 +1,5 @@
 import { initContract, TsRestResponseError } from '@ts-rest/core';
-import { initServer } from './ts-rest-fastify';
+import { initServer, RequestValidationErrorSchema } from './ts-rest-fastify';
 import { z } from 'zod';
 import fastify from 'fastify';
 import * as supertest from 'supertest';
@@ -26,6 +26,7 @@ const contract = c.router({
       200: z.object({
         pong: z.string(),
       }),
+      400: RequestValidationErrorSchema,
     },
   },
   noContent: {
@@ -199,6 +200,9 @@ describe('ts-rest-fastify', () => {
       pathParameterErrors: null,
       queryParameterErrors: null,
     });
+    expect(() =>
+      RequestValidationErrorSchema.parse(response.body),
+    ).not.toThrowError();
   });
 
   it('should handle no content response', async () => {

libs/ts-rest/fastify/src/lib/ts-rest-fastify.ts

@@ -12,6 +12,7 @@ import {
   ServerInferResponses,
   TsRestResponseError,
   validateResponse,
+  ZodErrorSchema,
 } from '@ts-rest/core';
 import * as fastify from 'fastify';
 import { z } from 'zod';
@@ -27,6 +28,13 @@ export class RequestValidationError extends Error {
   }
 }
 
+export const RequestValidationErrorSchema = z.object({
+  pathParameterErrors: ZodErrorSchema.nullable(),
+  headerErrors: ZodErrorSchema.nullable(),
+  queryParameterErrors: ZodErrorSchema.nullable(),
+  bodyErrors: ZodErrorSchema.nullable(),
+});
+
 type AppRouteImplementation<T extends AppRoute> = (
   input: ServerInferRequest<T, fastify.FastifyRequest['headers']> & {
     request: fastify.FastifyRequest<

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

@@ -1,6 +1,7 @@
 import { initContract } from '@ts-rest/core';
 import {
   doesUrlMatchContractPath,
+  RequestValidationErrorSchema,
   TsRestException,
   tsRestHandler,
   TsRestHandler,
@@ -201,6 +202,9 @@ describe('ts-rest-nest-handler', () => {
           queryResult: null,
           paramsResult: null,
         });
+        expect(() =>
+          RequestValidationErrorSchema.parse(responsePost.body),
+        ).not.toThrowError();
       });
 
       it("shouldn't validate body", async () => {

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

@@ -33,6 +33,7 @@ import {
   parseJsonQueryObject,
   ServerInferResponses,
   TsRestResponseError,
+  ZodErrorSchema,
 } from '@ts-rest/core';
 import {
   TsRestAppRouteMetadataKey,
@@ -63,6 +64,13 @@ export class RequestValidationError extends BadRequestException {
   }
 }
 
+export const RequestValidationErrorSchema = z.object({
+  paramsResult: ZodErrorSchema.nullable(),
+  headersResult: ZodErrorSchema.nullable(),
+  queryResult: ZodErrorSchema.nullable(),
+  bodyResult: ZodErrorSchema.nullable(),
+});
+
 export class ResponseValidationError extends InternalServerErrorException {
   constructor(
     public appRoute: AppRoute,

libs/ts-rest/next/src/lib/ts-rest-next.spec.ts

@@ -9,6 +9,7 @@ import {
   createNextRouter,
   createSingleRouteHandler,
   RequestValidationError,
+  RequestValidationErrorSchema,
 } from './ts-rest-next';
 import { z } from 'zod';
 
@@ -29,6 +30,7 @@ const contract = c.router({
     query: null,
     responses: {
       200: c.type<{ id: string }>(),
+      400: RequestValidationErrorSchema,
       404: z.object({
         message: z.literal('Not Found'),
       }),
@@ -417,6 +419,9 @@ describe('createNextRouter', () => {
 
       expect(errorHandler).not.toHaveBeenCalled();
       expect(mockRes.status).toHaveBeenCalledWith(400);
+      expect(() =>
+        RequestValidationErrorSchema.parse(jsonMock.mock.calls[0][0]),
+      ).not.toThrowError();
     });
   });
 

libs/ts-rest/next/src/lib/ts-rest-next.ts

@@ -13,6 +13,7 @@ import {
   ServerInferResponses,
   TsRestResponseError,
   validateResponse,
+  ZodErrorSchema,
 } from '@ts-rest/core';
 import { getPathParamsFromArray } from './path-utils';
 import { z } from 'zod';
@@ -28,6 +29,8 @@ export class RequestValidationError extends Error {
   }
 }
 
+export const RequestValidationErrorSchema = ZodErrorSchema;
+
 type AppRouteImplementation<T extends AppRoute> = (
   args: ServerInferRequest<T, NextApiRequest['headers']> & {
     req: NextApiRequest;