fix(fastify): fix when nested routers are used with pathPrefix (#632)

Author: Gabrola

.changeset/good-apes-study.md

@@ -0,0 +1,5 @@
+---
+'@ts-rest/fastify': patch
+---
+
+Fix when `pathPrefix` is used multiple times in nested contracts

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

@@ -358,6 +358,54 @@ describe('ts-rest-fastify', () => {
     expect(response.body).toEqual({ id: '10' });
   });
 
+  it('prefixed contract should work with fastify sub-routers', async () => {
+    const postsContractNested = c.router(
+      {
+        getPost: {
+          path: '/:postId',
+          method: 'GET',
+          responses: { 200: c.type<{ id: string }>() },
+        },
+      },
+      { pathPrefix: '/posts' },
+    );
+
+    const mainContract = c.router(
+      {
+        health: {
+          method: 'GET',
+          path: '/health',
+          responses: { 200: c.type<{ message: string }>() },
+        },
+        posts: postsContractNested,
+      },
+      { pathPrefix: '/v1' },
+    );
+
+    const postsRouter = s.router(mainContract.posts, {
+      getPost: async ({ params }) => {
+        return { status: 200, body: { id: params.postId } };
+      },
+    });
+
+    const router = s.router(mainContract, {
+      health: async () => {
+        return { status: 200, body: { message: 'ok' } };
+      },
+      posts: postsRouter,
+    });
+
+    const app = fastify();
+    s.registerRouter(mainContract, router, app);
+
+    await app.ready();
+
+    await supertest(app.server).get('/v1/posts/10').expect(200, { id: '10' });
+    await supertest(app.server)
+      .get('/v1/health')
+      .expect(200, { message: 'ok' });
+  });
+
   it('should handle non-json response types from contract', async () => {
     const c = initContract();
 

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

@@ -50,17 +50,12 @@ type AppRouteImplementation<T extends AppRoute> = (
 
 type RecursiveRouterObj<T extends AppRouter> = {
   [TKey in keyof T]: T[TKey] extends AppRouter
-    ? InitialisedRouter<T[TKey]> | RecursiveRouterObj<T[TKey]>
+    ? RecursiveRouterObj<T[TKey]>
     : T[TKey] extends AppRoute
     ? AppRouteImplementation<T[TKey]>
     : never;
 };
 
-type InitialisedRouter<TContract extends AppRouter> = {
-  contract: TContract;
-  routes: RecursiveRouterObj<TContract>;
-};
-
 type RegisterRouterOptions = {
   logInitialization?: boolean;
   jsonQuery?: boolean;
@@ -122,20 +117,22 @@ const validateRequest = (
   };
 };
 
+const RouterEmbeddedContract = Symbol('RouterEmbeddedContract');
+
 export const initServer = () => ({
   router: <TContract extends AppRouter>(
     contract: TContract,
     routes: RecursiveRouterObj<TContract>,
-  ): InitialisedRouter<TContract> => ({
-    contract,
-    routes,
+  ): RecursiveRouterObj<TContract> => ({
+    ...routes,
+    [RouterEmbeddedContract]: contract,
   }),
   route: <TAppRoute extends AppRoute>(
     route: TAppRoute,
     implementation: AppRouteImplementation<TAppRoute>,
   ) => implementation,
   registerRouter: <
-    T extends InitialisedRouter<TContract>,
+    T extends RecursiveRouterObj<TContract>,
     TContract extends AppRouter,
   >(
     contract: TContract,
@@ -148,15 +145,15 @@ export const initServer = () => ({
       requestValidationErrorHandler: 'combined',
     },
   ) => {
-    recursivelyRegisterRouter(routerImpl.routes, contract, [], app, options);
+    recursivelyRegisterRouter(routerImpl, contract, [], app, options);
 
     app.setErrorHandler(
       requestValidationErrorHandler(options.requestValidationErrorHandler),
     );
   },
   plugin:
     <T extends AppRouter>(
-      router: InitialisedRouter<T>,
+      router: RecursiveRouterObj<T>,
     ): fastify.FastifyPluginCallback<RegisterRouterOptions> =>
     (
       app,
@@ -168,7 +165,11 @@ export const initServer = () => ({
       },
       done,
     ) => {
-      recursivelyRegisterRouter(router.routes, router.contract, [], app, opts);
+      const embeddedContract = (
+        router as RecursiveRouterObj<T> & { [RouterEmbeddedContract]: T }
+      )[RouterEmbeddedContract];
+
+      recursivelyRegisterRouter(router, embeddedContract, [], app, opts);
 
       app.setErrorHandler(
         requestValidationErrorHandler(opts.requestValidationErrorHandler),
@@ -289,12 +290,6 @@ const registerRoute = <TAppRoute extends AppRoute>(
   });
 };
 
-const implementationIsInitialisedRouter = <T extends AppRouter>(
-  implementation: InitialisedRouter<T> | RecursiveRouterObj<T>,
-): implementation is InitialisedRouter<T> => {
-  return 'contract' in implementation && 'routes' in implementation;
-};
-
 /**
  *
  * @param routerImpl - the user's implementation of the router
@@ -311,24 +306,14 @@ const recursivelyRegisterRouter = <T extends AppRouter>(
   options: RegisterRouterOptions,
 ) => {
   if (typeof routerImpl === 'object') {
-    if (implementationIsInitialisedRouter(routerImpl)) {
+    for (const key in routerImpl) {
       recursivelyRegisterRouter(
-        routerImpl.routes,
-        routerImpl.contract,
-        [...path],
+        routerImpl[key] as unknown as RecursiveRouterObj<T>,
+        appRouter[key] as unknown as T,
+        [...path, key],
         fastify,
         options,
       );
-    } else {
-      for (const key in routerImpl) {
-        recursivelyRegisterRouter(
-          routerImpl[key] as unknown as RecursiveRouterObj<T>,
-          appRouter[key] as unknown as T,
-          [...path, key],
-          fastify,
-          options,
-        );
-      }
     }
   } else if (typeof routerImpl === 'function') {
     registerRoute(