feat: add better typing for TsRestRequest (#372)

* feat: add better typing for TsRestRequest

* dev(express-types): add tests for req type inference

* fix: add type test for params

* chore: bump @ts-rest/express

* Update late-dingos-search.md

* Update late-dingos-search.md

---------

Co-authored-by: Michael Angelo Rivera <55844504+michaelangeloio@users.noreply.github.com>

Author: tefkah

.changeset/late-dingos-search.md

@@ -0,0 +1,5 @@
+---
+'@ts-rest/express': minor
+---
+
+feat: added stronger typing for the `req` object in the route handler for '@ts-rest/express' 

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

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+import { initContract } from '@ts-rest/core';
+import { AppRouteImplementation } from './types';
+import { IncomingHttpHeaders } from 'http';
+
+export type Equal<a, b> = (<T>() => T extends a ? 1 : 2) extends <
+  T
+>() => T extends b ? 1 : 2
+  ? true
+  : false;
+
+export type Expect<a extends true> = a;
+
+const c = initContract();
+
+const contract = c.router({
+  postSomethingIndex: {
+    method: 'POST',
+    path: `/:something/index.html`,
+    body: z.object({
+      echoHtml: z.string(),
+    }),
+    query: z.object({
+      extraPath: z.string().optional(),
+    }),
+    headers: z.object({
+      'x-application-index': z.literal('index'),
+    }),
+    pathParams: z.object({
+      something: z.string(),
+    }),
+    responses: {
+      200: c.otherResponse({
+        contentType: 'text/html',
+        body: z.string().regex(/^<([a-z][a-z0-9]*)\b[^>]*>(.*?)<\/\1>$/im),
+      }),
+    },
+  },
+});
+
+it('should have type inference on req', () => {
+  type PostIndexImplementation = AppRouteImplementation<
+    typeof contract.postSomethingIndex
+  >;
+
+  type PostIndexParam = Parameters<PostIndexImplementation>[0];
+
+  type PostIndexReq = PostIndexParam['req'];
+
+  type PostIndexBod = PostIndexReq['body'];
+
+  type ShouldHaveReq = Expect<
+    Equal<
+      PostIndexBod,
+      {
+        echoHtml: string;
+      }
+    >
+  >;
+
+  type PostIndexHeaders = PostIndexReq['headers'];
+
+  type ShouldHaveHeaders = Expect<
+    Equal<
+      PostIndexHeaders,
+      {
+        'x-application-index': 'index';
+      } & IncomingHttpHeaders
+    >
+  >;
+
+  type PostIndexQuery = PostIndexReq['query'];
+
+  type ShouldHaveQuery = Expect<
+    Equal<
+      PostIndexQuery,
+      {
+        extraPath?: string;
+      }
+    >
+  >;
+
+  type PostIndexParams = PostIndexReq['params'];
+
+  type ShouldHaveParams = Expect<
+    Equal<
+      PostIndexParams,
+      {
+        something: string;
+      }
+    >
+  >;
+});

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

@@ -4,9 +4,15 @@ import {
   AppRouteQuery,
   AppRouter,
   ServerInferRequest,
+  ServerInferResponseBody,
   ServerInferResponses,
 } from '@ts-rest/core';
-import { Express, NextFunction, Response } from 'express-serve-static-core';
+import {
+  Express,
+  NextFunction,
+  Response,
+  Request,
+} from 'express-serve-static-core';
 import { RequestValidationError } from './request-validation-error';
 
 type AppRouteQueryImplementation<T extends AppRouteQuery> = (
@@ -32,10 +38,21 @@ export type AppRouteImplementation<T extends AppRoute> =
     ? AppRouteQueryImplementation<T>
     : never;
 
-export type TsRestRequest<T extends AppRouter | AppRoute> =
-  Express['request'] & {
-    tsRestRoute: FlattenAppRouter<T>;
-  };
+export type TsRestRequest<
+  T extends AppRouter | AppRoute,
+  F extends FlattenAppRouter<T> = FlattenAppRouter<T>,
+  S extends ServerInferRequest<F> = ServerInferRequest<F>
+> = Request<
+  'params' extends keyof S ? S['params'] : Express['request']['params'],
+  ServerInferResponseBody<F>,
+  'body' extends keyof S ? S['body'] : Express['request']['body'],
+  'query' extends keyof S ? S['query'] : Express['request']['query']
+> & {
+  tsRestRoute: F;
+  headers: 'headers' extends keyof S
+    ? S['headers']
+    : Express['request']['headers'];
+};
 
 export type TsRestRequestHandler<T extends AppRouter | AppRoute> = (
   req: TsRestRequest<T>,