fix: unable to nest fastify route implementations (#351)

* fix: unable to nest fastify route implementations [WIP Breaking]

* fix: in a non breaking way

* test: ensure we can mix and match direct/implemented routers

* refactor: remove logs [skip ci]

* refactor: remove whitespace

* changeset

---------

Co-authored-by: michaelangrivera <mar@michaelangrivera.com>

Author: oliverbutler

.changeset/mighty-spoons-float.md

@@ -0,0 +1,5 @@
+---
+'@ts-rest/fastify': patch
+---
+
+fix: Type error when combining server contracts with fastify

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

@@ -308,7 +308,6 @@ describe('ts-rest-fastify', () => {
     const router = s.router(postsContract, {
       posts: {
         getPost: async ({ params }) => {
-          console.log(params);
           return { status: 200, body: { id: params.postId } };
         },
       },
@@ -454,4 +453,150 @@ describe('ts-rest-fastify', () => {
       .send({});
     expect(response.statusCode).toEqual(500);
   });
+
+  it('should be able to instantiate two routers and combine them together', async () => {
+    const contractA = c.router({
+      a: {
+        method: 'GET',
+        path: '/a',
+        responses: {
+          200: z.object({
+            a: z.string(),
+          }),
+        },
+      },
+    });
+
+    const contractB = c.router({
+      b: {
+        method: 'GET',
+        path: '/b',
+        responses: {
+          200: z.object({
+            b: z.string(),
+          }),
+        },
+      },
+    });
+
+    const combinedContract = c.router({
+      apiA: contractA,
+      apiB: contractB,
+    });
+
+    const routerA = s.router(contractA, {
+      a: async () => {
+        return {
+          status: 200,
+          body: {
+            a: 'return',
+          },
+        };
+      },
+    });
+
+    const routerB = s.router(contractB, {
+      b: async () => {
+        return {
+          status: 200,
+          body: {
+            b: 'return',
+          },
+        };
+      },
+    });
+
+    const combinedRouter = s.router(combinedContract, {
+      apiA: routerA,
+      apiB: routerB,
+    });
+
+    const app = fastify({ logger: false });
+
+    app.register(s.plugin(combinedRouter));
+
+    await app.ready();
+
+    const responseA = await supertest(app.server).get('/a');
+    expect(responseA.statusCode).toEqual(200);
+    expect(responseA.body).toEqual({
+      a: 'return',
+    });
+
+    const responseB = await supertest(app.server).get('/b');
+    expect(responseB.statusCode).toEqual(200);
+    expect(responseB.body).toEqual({
+      b: 'return',
+    });
+  });
+
+  it('should be able to mix and match combining routers with direct implementation', async () => {
+    const contract = c.router({
+      apiA: {
+        a: {
+          method: 'GET',
+          path: '/a',
+          responses: {
+            200: z.object({
+              a: z.string(),
+            }),
+          },
+        },
+      },
+      apiB: {
+        b: {
+          method: 'GET',
+          path: '/b',
+          responses: {
+            200: z.object({
+              b: z.string(),
+            }),
+          },
+        },
+      },
+    });
+
+    const routerForApiA = s.router(contract.apiA, {
+      a: async () => {
+        return {
+          status: 200,
+          body: {
+            a: 'return',
+          },
+        };
+      },
+    });
+
+    const router = s.router(contract, {
+      apiA: routerForApiA,
+      apiB: {
+        b: async () => {
+          return {
+            status: 200,
+            body: {
+              b: 'return',
+            },
+          };
+        },
+      },
+    });
+
+    const app = fastify({ logger: false });
+
+    app.register(s.plugin(router));
+
+    await app.ready();
+
+    const responseA = await supertest(app.server).get('/a');
+    expect(responseA.statusCode).toEqual(200);
+    expect(responseA.body).toEqual({
+      a: 'return',
+    });
+
+    const responseB = await supertest(app.server).get('/b');
+    expect(responseB.statusCode).toEqual(200);
+    expect(responseB.body).toEqual({
+      b: 'return',
+    });
+  });
 });

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

@@ -33,7 +33,7 @@ type AppRouteImplementation<T extends AppRoute> = (
 
 type RecursiveRouterObj<T extends AppRouter> = {
   [TKey in keyof T]: T[TKey] extends AppRouter
-    ? RecursiveRouterObj<T[TKey]>
+    ? InitialisedRouter<T[TKey]> | RecursiveRouterObj<T[TKey]>
     : T[TKey] extends AppRoute
     ? AppRouteImplementation<T[TKey]>
     : never;
@@ -183,7 +183,6 @@ const requestValidationErrorHandler = (
 };
 
 /**
- *
  * @param routeImpl - User's implementation of the route
  * @param appRoute - the `ts-rest` contract for this route (e.g. with Path, params, query, body, etc.)
  * @param fastify - the fastify instance to register the route on
@@ -248,6 +247,12 @@ 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
@@ -264,14 +269,26 @@ const recursivelyRegisterRouter = <T extends AppRouter>(
   options: RegisterRouterOptions
 ) => {
   if (typeof routerImpl === 'object') {
-    for (const key in routerImpl) {
+    console.log(routerImpl);
+
+    if (implementationIsInitialisedRouter(routerImpl)) {
       recursivelyRegisterRouter(
-        routerImpl[key] as unknown as RecursiveRouterObj<T>,
-        appRouter[key] as unknown as T,
-        [...path, key],
+        routerImpl.routes,
+        routerImpl.contract,
+        [...path],
         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(