fix(core): broken c.responses() type and optional URL paths types without pathParams (#556)

Author: Gabrola

.changeset/chilly-shrimps-relate.md

@@ -0,0 +1,5 @@
+---
+'@ts-rest/core': patch
+---
+
+Fix incorrect type for URL `params` when using optional params without defining `pathParams`

.changeset/proud-bobcats-scream.md

@@ -0,0 +1,5 @@
+---
+'@ts-rest/core': patch
+---
+
+Fix broken types for `c.responses()`

libs/ts-rest/core/src/lib/dsl.spec.ts

@@ -468,6 +468,39 @@ describe('contract', () => {
     >;
   });
 
+  it('should be typed correctly with separate responses with spread', () => {
+    const responses = c.responses({
+      200: c.type<{ id: number }>(),
+    });
+
+    const contract = c.router({
+      getPost: {
+        method: 'GET',
+        path: '/posts/:id',
+        responses: {
+          ...responses,
+        },
+      },
+    });
+
+    type ContractShape = Expect<
+      Equal<
+        typeof contract,
+        {
+          getPost: {
+            method: 'GET';
+            path: '/posts/:id';
+            responses: {
+              200: ContractPlainType<{
+                id: number;
+              }>;
+            };
+          };
+        }
+      >
+    >;
+  });
+
   it('should add strictStatusCodes=true option to routes', () => {
     const contract = c.router(
       {

libs/ts-rest/core/src/lib/dsl.ts

@@ -216,7 +216,7 @@ type ContractInstance = {
       ContractAnyType | ContractOtherResponse<ContractAnyType>
     >,
   >(
-    responses: NarrowObject<TResponses>,
+    responses: TResponses,
   ) => TResponses;
   /**
    * @deprecated Please use type() instead.

libs/ts-rest/core/src/lib/infer-types.spec.ts

@@ -434,6 +434,27 @@ it('type inference helpers', () => {
     >
   >;
 
+  const commonErrors = c.responses({
+    400: c.type<{ message: string }>(),
+  });
+
+  const contractWithCommonErrors = c.router({
+    get: {
+      method: 'GET',
+      path: '/',
+      responses: {
+        ...commonErrors,
+      },
+    },
+  });
+
+  type ClientInferResponseBodyCommonResponsesTest = Expect<
+    Equal<
+      ClientInferResponseBody<typeof contractWithCommonErrors.get, 400>,
+      { message: string }
+    >
+  >;
+
   type ServerInferRequestTest = Expect<
     Equal<
       ServerInferRequest<typeof contract>,

libs/ts-rest/core/src/lib/paths.spec.ts

@@ -24,14 +24,26 @@ expectType<{ id: string; commentId: string; commentId2: string }>(
 
 const urlOptional = '/post/:id?';
 expectType<{
-  id: string;
+  id?: string;
 }>(type<ParamsFromUrl<typeof urlOptional>>());
 
 const urlManyOptional = '/post/:id?/comments/:commentId?';
+expectType<{
+  id?: string;
+  commentId?: string;
+}>(type<ParamsFromUrl<typeof urlManyOptional>>());
+
+const urlMixedOptional = '/post/:id/comments/:commentId?';
 expectType<{
   id: string;
+  commentId?: string;
+}>(type<ParamsFromUrl<typeof urlMixedOptional>>());
+
+const urlMixedOptional2 = '/post/:id?/comments/:commentId';
+expectType<{
+  id?: string;
   commentId: string;
-}>(type<ParamsFromUrl<typeof urlManyOptional>>());
+}>(type<ParamsFromUrl<typeof urlMixedOptional2>>());
 
 describe('insertParamsIntoPath', () => {
   it('should insert params into path', () => {

libs/ts-rest/core/src/lib/paths.ts

@@ -1,4 +1,11 @@
-type StripOptional<T> = T extends `${infer U}?` ? U : T;
+type ResolveOptionalPathParam<T extends string> =
+  T extends `${infer PathParam}?`
+    ? {
+        [key in PathParam]?: string | undefined;
+      }
+    : {
+        [key in T]: string;
+      };
 
 /**
  * @params T - The URL e.g. /posts/:id
@@ -8,21 +15,19 @@ type RecursivelyExtractPathParams<
   T extends string,
   TAcc extends null | Record<string, string>,
 > = T extends `/:${infer PathParam}/${infer Right}`
-  ? {
-      [key in StripOptional<PathParam>]: string;
-    } & RecursivelyExtractPathParams<Right, TAcc>
+  ? ResolveOptionalPathParam<PathParam> &
+      RecursivelyExtractPathParams<Right, TAcc>
   : T extends `/:${infer PathParam}`
-  ? { [key in StripOptional<PathParam>]: string }
+  ? ResolveOptionalPathParam<PathParam>
   : T extends `/${string}/${infer Right}`
   ? RecursivelyExtractPathParams<Right, TAcc>
   : T extends `/${string}`
   ? TAcc
   : T extends `:${infer PathParam}/${infer Right}`
-  ? {
-      [key in StripOptional<PathParam>]: string;
-    } & RecursivelyExtractPathParams<Right, TAcc>
+  ? ResolveOptionalPathParam<PathParam> &
+      RecursivelyExtractPathParams<Right, TAcc>
   : T extends `:${infer PathParam}`
-  ? TAcc & { [key in StripOptional<PathParam>]: string }
+  ? TAcc & ResolveOptionalPathParam<PathParam>
   : T extends `${string}/${infer Right}`
   ? RecursivelyExtractPathParams<Right, TAcc>
   : TAcc;

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

@@ -234,6 +234,56 @@ describe('ts-rest-express', () => {
         expect(res.header['content-length']).toBeUndefined();
       });
   });
+
+  it('should handle optional url params', async () => {
+    const c = initContract();
+
+    const contract = c.router({
+      getPosts: {
+        method: 'GET',
+        path: '/posts/:id?',
+        pathParams: z.object({
+          id: z.string().optional(),
+        }),
+        responses: {
+          200: z.object({
+            id: z.string().optional(),
+          }),
+        },
+      },
+    });
+
+    const server = initServer();
+    const router = server.router(contract, {
+      getPosts: async ({ params }) => {
+        return {
+          status: 200,
+          body: {
+            id: params.id,
+          },
+        };
+      },
+    });
+
+    const app = express();
+    app.use(express.json());
+    app.use(express.urlencoded({ extended: true }));
+    createExpressEndpoints(contract, router, app);
+
+    await supertest(app)
+      .get('/posts')
+      .expect((res) => {
+        expect(res.status).toEqual(200);
+        expect(res.body).toEqual({});
+      });
+
+    await supertest(app)
+      .get('/posts/10')
+      .expect((res) => {
+        expect(res.status).toEqual(200);
+        expect(res.body).toEqual({ id: '10' });
+      });
+  });
 });
 
 describe('download', () => {