fix(core): Replace optional path params in request URL (#704)

Co-authored-by: Oliver Butler <dev@oliverbutler.uk>

Author: mgnsk

.changeset/sixty-horses-drum.md

@@ -0,0 +1,7 @@
+---
+'@ts-rest/express': minor
+'@ts-rest/core': minor
+'@ts-rest/nest': minor
+---
+
+Support optional path params in the type system, and ensure multiple levels of query params are dealt with in nest

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

@@ -92,4 +92,46 @@ describe('insertParamsIntoPath', () => {
 
     expect(result).toBe('/1');
   });
+
+  it('should insert optional params into path with many params', () => {
+    const path = '/post/:id?/comments/:commentId?/:commentId2?';
+
+    const params = {
+      commentId: '2',
+      commentId2: '3',
+      id: '1',
+    };
+
+    const result = insertParamsIntoPath({ path, params });
+
+    expect(result).toBe('/post/1/comments/2/3');
+  });
+
+  it('should insert optional params into path with no params', () => {
+    const path = '/post/:id?/comments/:commentId?/:commentId2?';
+
+    const result = insertParamsIntoPath({ path, params: {} });
+
+    expect(result).toBe('/post/comments');
+  });
+
+  it('should insert not have trailing slashes', () => {
+    const path = '/post/:id?/comments/:commentId?/:commentId2?/:commentId3?';
+
+    const result = insertParamsIntoPath({ path, params: {} });
+
+    expect(result).toBe('/post/comments');
+  });
+
+  it('should insert optional params into paths with only one param', () => {
+    const path = '/:id?';
+
+    const params = {
+      id: '1',
+    };
+
+    const result = insertParamsIntoPath({ path, params });
+
+    expect(result).toBe('/1');
+  });
 });

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

@@ -48,6 +48,9 @@ export type ParamsFromUrl<T extends string> = RecursivelyExtractPathParams<
     }
   : never;
 
+const PARAM_REGEX = /:([^/?]+)\??/g;
+const DOUBLE_SLASH_REGEX = /\/\//g;
+
 /**
  * @param path - The URL e.g. /posts/:id
  * @param params - The params e.g. `{ id: string }`
@@ -60,9 +63,13 @@ export const insertParamsIntoPath = <T extends string>({
   path: T;
   params: ParamsFromUrl<T>;
 }) => {
-  return path
-    .replace(/:([^/]+)/g, (_, p) => {
-      return (params as any)[p] || '';
-    })
-    .replace(/\/\//g, '/');
+  let result = path
+    .replace(PARAM_REGEX, (_, p) => (params as Record<string, string>)[p] || '')
+    .replace(DOUBLE_SLASH_REGEX, '/');
+
+  while (result.length > 1 && result.endsWith('/')) {
+    result = result.slice(0, -1);
+  }
+
+  return result;
 };

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

@@ -286,6 +286,59 @@ describe('ts-rest-express', () => {
       });
   });
 
+  it('should handle two levels of optional url params', async () => {
+    const contract = c.router({
+      getPosts: {
+        method: 'GET',
+        path: '/posts/:year?/:month?',
+        responses: {
+          200: z.object({
+            id: z.string().optional(),
+          }),
+        },
+      },
+    });
+
+    const router = s.router(contract, {
+      getPosts: async ({ params }) => {
+        return {
+          status: 200,
+          body: {
+            id: `${params.year}-${params.month}`,
+          },
+        };
+      },
+    });
+
+    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({
+          id: `undefined-undefined`,
+        });
+      });
+
+    await supertest(app)
+      .get('/posts/2025')
+      .expect((res) => {
+        expect(res.status).toEqual(200);
+        expect(res.body).toEqual({ id: '2025-undefined' });
+      });
+
+    await supertest(app)
+      .get('/posts/2025/01')
+      .expect((res) => {
+        expect(res.status).toEqual(200);
+        expect(res.body).toEqual({ id: '2025-01' });
+      });
+  });
+
   it('should handle multipart/form-data', async () => {
     const contract = c.router({
       uploadFiles: {

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

@@ -765,6 +765,72 @@ describe('ts-rest-nest-handler', () => {
         },
       });
     });
+
+    it('should route correctly for optional params', async () => {
+      const c = initContract();
+
+      const contract = c.router({
+        getPosts: {
+          path: '/posts/:year?/:month?',
+          method: 'GET',
+          responses: {
+            200: z.object({
+              rangeSearched: z.string(),
+            }),
+          },
+        },
+      });
+
+      @Controller()
+      class TestController {
+        @TsRestHandler(contract)
+        async handler() {
+          return tsRestHandler(contract, {
+            getPosts: async ({ params }) => ({
+              status: 200,
+              body: { rangeSearched: `${params.year}-${params.month}` },
+            }),
+          });
+        }
+      }
+
+      const moduleRef = await Test.createTestingModule({
+        controllers: [TestController],
+      }).compile();
+
+      const app = moduleRef.createNestApplication();
+      await app.init();
+
+      await supertest(app.getHttpServer())
+        .get('/posts')
+        .send()
+        .expect(200)
+        .then((res) =>
+          expect(res.body).toStrictEqual({
+            rangeSearched: 'undefined-undefined',
+          }),
+        );
+
+      await supertest(app.getHttpServer())
+        .get('/posts/yyyy')
+        .send()
+        .expect(200)
+        .then((res) =>
+          expect(res.body).toStrictEqual({
+            rangeSearched: 'yyyy-undefined',
+          }),
+        );
+
+      await supertest(app.getHttpServer())
+        .get('/posts/yyyy/mm')
+        .send()
+        .expect(200)
+        .then((res) =>
+          expect(res.body).toStrictEqual({
+            rangeSearched: 'yyyy-mm',
+          }),
+        );
+    });
   });
 
   describe('single-handler api', () => {
@@ -1584,6 +1650,70 @@ describe('ts-rest-nest-handler', () => {
           expect(res.header.location).toBe('/redirected');
         });
     });
+
+    it('should route correctly for optional params', async () => {
+      const c = initContract();
+
+      const contract = c.router({
+        getPosts: {
+          path: '/posts/:year?/:month?',
+          method: 'GET',
+          responses: {
+            200: z.object({
+              rangeSearched: z.string(),
+            }),
+          },
+        },
+      });
+
+      @Controller()
+      class TestController {
+        @TsRestHandler(contract.getPosts)
+        async handler() {
+          return tsRestHandler(contract.getPosts, async ({ params }) => ({
+            status: 200,
+            body: { rangeSearched: `${params.year}-${params.month}` },
+          }));
+        }
+      }
+
+      const moduleRef = await Test.createTestingModule({
+        controllers: [TestController],
+      }).compile();
+
+      const app = moduleRef.createNestApplication();
+      await app.init();
+
+      await supertest(app.getHttpServer())
+        .get('/posts')
+        .send()
+        .expect(200)
+        .then((res) =>
+          expect(res.body).toStrictEqual({
+            rangeSearched: 'undefined-undefined',
+          }),
+        );
+
+      await supertest(app.getHttpServer())
+        .get('/posts/yyyy')
+        .send()
+        .expect(200)
+        .then((res) =>
+          expect(res.body).toStrictEqual({
+            rangeSearched: 'yyyy-undefined',
+          }),
+        );
+
+      await supertest(app.getHttpServer())
+        .get('/posts/yyyy/mm')
+        .send()
+        .expect(200)
+        .then((res) =>
+          expect(res.body).toStrictEqual({
+            rangeSearched: 'yyyy-mm',
+          }),
+        );
+    });
   });
 
   it('should be able to combine single-handler, multi-handler and vanilla nest controllers', async () => {