feat(serverless): add middleware support (#569)

Author: Gabrola

.changeset/rude-readers-thank.md

@@ -0,0 +1,5 @@
+---
+'@ts-rest/serverless': minor
+---
+
+Add middleware support

libs/ts-rest/serverless/package.json

@@ -3,7 +3,7 @@
   "version": "3.41.2",
   "dependencies": {
     "@ts-rest/core": "3.41.2",
-    "itty-router": "^4.2.2"
+    "itty-router": "^5.0.9"
   },
   "peerDependencies": {
     "@types/aws-lambda": "^8.10.115",

libs/ts-rest/serverless/src/lib/cors.ts

@@ -1,7 +1,9 @@
 import { initContract } from '@ts-rest/core';
 import { parse as parseMultipart, getBoundary } from 'parse-multipart-data';
 import { z } from 'zod';
+import { vi } from 'vitest';
 import { fetchRequestHandler } from './ts-rest-fetch';
+import { TsRestRequest } from '../request';
 
 const c = initContract();
 
@@ -54,8 +56,17 @@ const contract = c.router({
       }),
     },
   },
+  throw: {
+    method: 'GET',
+    path: '/throw',
+    responses: {
+      500: c.noBody(),
+    },
+  },
 });
 
+const mockFn = vi.fn();
+
 const testFetchRequestHandler = (request: Request) => {
   return fetchRequestHandler({
     contract,
@@ -77,11 +88,14 @@ const testFetchRequestHandler = (request: Request) => {
           },
         };
       },
-      noContent: async () => {
-        return {
-          status: 204,
-          body: undefined,
-        };
+      noContent: {
+        middleware: [(req) => mockFn(req.foo)],
+        handler: async () => {
+          return {
+            status: 204,
+            body: undefined,
+          } as const;
+        },
       },
       upload: async (_, { request }) => {
         const boundary = getBoundary(
@@ -97,20 +111,37 @@ const testFetchRequestHandler = (request: Request) => {
           body: blob,
         };
       },
+      throw: async () => {
+        throw new Error('Test error');
+      },
     },
     options: {
       jsonQuery: true,
       responseValidation: true,
       cors: {
-        origins: ['http://localhost'],
+        origin: ['http://localhost'],
         credentials: true,
       },
+      requestMiddleware: [
+        (req: TsRestRequest & { foo: string }) => {
+          req.foo = 'bar';
+        },
+      ],
+      responseHandlers: [
+        (res, req) => {
+          res.headers.set('x-foo', req.foo);
+        },
+      ],
     },
     request,
   });
 };
 
 describe('fetchRequestHandler', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
   it('should handle GET request', async () => {
     const request = new Request('http://localhost/test?foo=bar', {
       headers: { origin: 'http://localhost' },
@@ -123,6 +154,7 @@ describe('fetchRequestHandler', () => {
         'access-control-allow-origin': 'http://localhost',
         'content-type': 'application/json',
         vary: 'Origin',
+        'x-foo': 'bar',
       },
     });
 
@@ -148,6 +180,7 @@ describe('fetchRequestHandler', () => {
         'access-control-allow-origin': 'http://localhost',
         'content-type': 'application/json',
         vary: 'Origin',
+        'x-foo': 'bar',
       },
     });
 
@@ -169,12 +202,14 @@ describe('fetchRequestHandler', () => {
         'access-control-allow-credentials': 'true',
         'access-control-allow-origin': 'http://localhost',
         vary: 'Origin',
+        'x-foo': 'bar',
       },
     });
 
     expect(response.status).toEqual(expectedResponse.status);
     expect(response.headers).toEqual(expectedResponse.headers);
     expect(await response.text()).toEqual('');
+    expect(mockFn).toHaveBeenCalledWith('bar');
   });
 
   it('should handle file upload', async () => {
@@ -203,6 +238,7 @@ describe('fetchRequestHandler', () => {
           'access-control-allow-origin': 'http://localhost',
           'content-type': 'text/html',
           vary: 'Origin',
+          'x-foo': 'bar',
         },
       },
     );
@@ -211,4 +247,52 @@ describe('fetchRequestHandler', () => {
     expect(response.headers).toEqual(expectedResponse.headers);
     expect(await response.text()).toEqual(await expectedResponse.text());
   });
+
+  it('should handle validation error', async () => {
+    const request = new Request('http://localhost/test', {
+      headers: { origin: 'http://localhost' },
+    });
+
+    const response = await testFetchRequestHandler(request);
+    const expectedResponse = new Response(
+      '{"message":"Request validation failed","pathParameterErrors":null,"headerErrors":null,"queryParameterErrors":{"issues":[{"code":"invalid_type","expected":"string","received":"undefined","path":["foo"],"message":"Required"}],"name":"ZodError"},"bodyErrors":null}',
+      {
+        status: 400,
+        headers: {
+          'access-control-allow-credentials': 'true',
+          'access-control-allow-origin': 'http://localhost',
+          'content-type': 'application/json',
+          vary: 'Origin',
+          'x-foo': 'bar',
+        },
+      },
+    );
+
+    expect(response.status).toEqual(expectedResponse.status);
+    expect(response.headers).toEqual(expectedResponse.headers);
+    expect(await response.json()).toEqual(await expectedResponse.json());
+  });
+
+  it('should handle 500 response', async () => {
+    const request = new Request('http://localhost/throw', {
+      method: 'GET',
+      headers: { origin: 'http://localhost' },
+    });
+
+    const response = await testFetchRequestHandler(request);
+    const expectedResponse = new Response(null, {
+      status: 500,
+      headers: {
+        'access-control-allow-credentials': 'true',
+        'access-control-allow-origin': 'http://localhost',
+        'content-type': 'application/json',
+        vary: 'Origin',
+        'x-foo': 'bar',
+      },
+    });
+
+    expect(response.status).toEqual(expectedResponse.status);
+    expect(response.headers).toEqual(expectedResponse.headers);
+    expect(await response.json()).toEqual({ message: 'Server Error' });
+  });
 });

libs/ts-rest/serverless/src/lib/handlers/ts-rest-fetch.spec.ts

@@ -1,33 +1,34 @@
 import { AppRouter } from '@ts-rest/core';
-import { createServerlessRouter, serverlessErrorHandler } from '../router';
+import { createServerlessRouter } from '../router';
 import { RecursiveRouterObj, ServerlessHandlerOptions } from '../types';
 import { TsRestRequest } from '../request';
 
 export const tsr = {
-  router: <T extends AppRouter>(
+  router: <T extends AppRouter, TRequestExtension>(
     contract: T,
-    router: RecursiveRouterObj<T, {}>,
+    router: RecursiveRouterObj<T, {}, TRequestExtension>,
   ) => router,
 };
 
-export const fetchRequestHandler = <T extends AppRouter>({
+export type FetchHandlerOptions<TRequestExtension = {}> =
+  ServerlessHandlerOptions<{}, TRequestExtension>;
+
+export const fetchRequestHandler = <T extends AppRouter, TRequestExtension>({
   contract,
   router,
   options = {},
   request,
 }: {
   contract: T;
-  router: RecursiveRouterObj<T, {}>;
-  options: ServerlessHandlerOptions;
+  router: RecursiveRouterObj<T, {}, TRequestExtension>;
+  options: FetchHandlerOptions<TRequestExtension>;
   request: Request;
 }) => {
-  const serverlessRouter = createServerlessRouter<T, {}>(
+  const serverlessRouter = createServerlessRouter<T, {}, TRequestExtension>(
     contract,
     router,
-    options,
+    options as ServerlessHandlerOptions,
   );
   const tsRestRequest = new TsRestRequest(request);
-  return serverlessRouter.handle(tsRestRequest, {}).catch(async (err) => {
-    return serverlessErrorHandler(err, tsRestRequest, options);
-  });
+  return serverlessRouter.fetch(tsRestRequest, {});
 };