fix(event-handler): http response body validation typings (#5125)

Co-authored-by: Stefano Vozza <[email protected]>

Author: nateiler

packages/event-handler/src/types/http.ts

@@ -259,9 +259,10 @@ type TypedRouteHandler<
 > = (
   reqCtx: TypedRequestContext<TEnv, TReq, TRes>
 ) =>
-  | Promise<TResBody | ExtendedAPIGatewayProxyResult<TResBody>>
+  | Promise<TResBody | ExtendedAPIGatewayProxyResult<TResBody> | Response>
   | TResBody
-  | ExtendedAPIGatewayProxyResult<TResBody>;
+  | ExtendedAPIGatewayProxyResult<TResBody>
+  | Response;
 
 type HttpMethod = keyof typeof HttpVerbs;
 
@@ -526,13 +527,13 @@ type InferReqSchema<V extends ValidationConfig> = V extends {
   : ReqSchema;
 
 /**
- * Infers the response body type from a `ValidationConfig` by extracting the output type
+ * Infers the response body type from a `ValidationConfig` by extracting the input type
  * from the response body schema.
  */
 type InferResBody<V extends ValidationConfig> = V extends {
-  res: { body: StandardSchemaV1<infer _I, infer O> };
+  res: { body: infer S extends StandardSchemaV1 };
 }
-  ? O
+  ? StandardSchemaV1.InferInput<S>
   : HandlerResponse;
 
 /**

packages/event-handler/tests/types/http.test-d.ts

@@ -1,8 +1,11 @@
 import { describe, expectTypeOf, it } from 'vitest';
+import { z } from 'zod';
 import { Router } from '../../src/http/index.js';
 import type { IStore } from '../../src/store/Store.js';
 import type {
   Env,
+  InferResBody,
+  InferResSchema,
   IntersectAll,
   MergeEnv,
   Middleware,
@@ -307,3 +310,113 @@ describe('includeRouter typing', () => {
     });
   });
 });
+
+describe('Response validation typing', () => {
+  it('infers the output type for a standard response schema', () => {
+    const responseSchema = z.object({ id: z.string(), name: z.string() });
+    type Config = { res: { body: typeof responseSchema } };
+
+    expectTypeOf<InferResBody<Config>>().toEqualTypeOf<{
+      id: string;
+      name: string;
+    }>();
+  });
+
+  it('infers the output type for a coerced response schema', () => {
+    const responseSchema = z.object({
+      id: z.coerce.string(),
+      name: z.string(),
+    });
+    type Config = { res: { body: typeof responseSchema } };
+
+    expectTypeOf<InferResBody<Config>>().toEqualTypeOf<{
+      id: unknown;
+      name: string;
+    }>();
+  });
+
+  it('infers the output type for a transformed response schema', () => {
+    const responseSchema = z
+      .object({
+        id: z.number(),
+        name: z.string(),
+      })
+      .transform((r) => ({
+        ...r,
+        id: String(r.id),
+      }));
+
+    type Config = { res: { body: typeof responseSchema } };
+
+    expectTypeOf<InferResBody<Config>>().toEqualTypeOf<{
+      id: number;
+      name: string;
+    }>();
+  });
+
+  it('rejects handler returning wrong types with a standard schema', () => {
+    const app = new Router();
+    const responseSchema = z.object({ id: z.string(), name: z.string() });
+
+    app.get(
+      '/users/:id',
+      // @ts-expect-error - number is not assignable to string for id
+      () => {
+        return { id: 123, name: 'John' };
+      },
+      { validation: { res: { body: responseSchema } } }
+    );
+  });
+
+  it('accepts handler returning pre-coercion types with z.coerce', () => {
+    const app = new Router();
+    const responseSchema = z.object({
+      id: z.coerce.string(),
+      name: z.string(),
+    });
+
+    app.get(
+      '/users/:id',
+      () => {
+        return { id: 123, name: 'John' };
+      },
+      { validation: { res: { body: responseSchema } } }
+    );
+  });
+
+  it('accepts handler returning a Response object with response validation', () => {
+    const app = new Router();
+    const responseSchema = z.object({ id: z.string(), name: z.string() });
+
+    app.get(
+      '/users/:id',
+      () => {
+        return Response.json({ id: '123', name: 'John' });
+      },
+      { validation: { res: { body: responseSchema } } }
+    );
+  });
+
+  it('infers validated response body as output type for a standard schema', () => {
+    const responseSchema = z.object({ id: z.string(), name: z.string() });
+    type Config = { res: { body: typeof responseSchema } };
+
+    expectTypeOf<InferResSchema<Config>>().toEqualTypeOf<{
+      body: { id: string; name: string };
+      headers: undefined;
+    }>();
+  });
+
+  it('infers validated response body as output type for a coerced schema', () => {
+    const responseSchema = z.object({
+      id: z.coerce.string(),
+      name: z.string(),
+    });
+    type Config = { res: { body: typeof responseSchema } };
+
+    expectTypeOf<InferResSchema<Config>>().toEqualTypeOf<{
+      body: { id: string; name: string };
+      headers: undefined;
+    }>();
+  });
+});

packages/event-handler/tests/unit/http/middleware/validation.test.ts

@@ -286,6 +286,33 @@ describe('Router Validation Integration', () => {
     expect(result.body).toBe(JSON.stringify({ id: '123', name: 'John' }));
   });
 
+  it('validates response object successfully', async () => {
+    // Prepare
+    const responseSchema = z.object({
+      id: z.coerce.string(),
+      name: z.string(),
+    });
+
+    app.get(
+      '/users/:id',
+      () => {
+        return Response.json({ id: 123, name: 'John' });
+      },
+      {
+        validation: { res: { body: responseSchema } },
+      }
+    );
+
+    const event = createTestEvent('/users/123', 'GET', {});
+    event.pathParameters = { id: '123' };
+
+    // Act
+    const result = await app.resolve(event, context);
+
+    // Assess
+    expect(result.statusCode).toBe(200);
+  });
+
   it('validates response body successfully', async () => {
     // Prepare
     const responseSchema = z.object({ id: z.string(), name: z.string() });
@@ -358,7 +385,6 @@ describe('Router Validation Integration', () => {
     const responseSchema = z.object({ name: z.string() });
     app.get(
       '/invalid',
-      // @ts-expect-error TS2345 testing for validation failure
       () => {
         return new Response('{"name": "John"', {
           headers: {