feat(serverless): ability to add custom platform context (#574)

Author: Gabrola

.changeset/soft-mayflies-tickle.md

@@ -0,0 +1,5 @@
+---
+'@ts-rest/serverless': minor
+---
+
+Add ability to include custom platform context for serverless fetch handler

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

@@ -2,7 +2,7 @@ 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 { fetchRequestHandler, tsr } from './ts-rest-fetch';
 import { TsRestRequest } from '../request';
 
 const c = initContract();
@@ -295,4 +295,62 @@ describe('fetchRequestHandler', () => {
     expect(response.headers).toEqual(expectedResponse.headers);
     expect(await response.json()).toEqual({ message: 'Server Error' });
   });
+
+  it('should handle custom context', async () => {
+    type PlatformContext = {
+      foo: string;
+    };
+
+    const fetchRequestHandlerWithContext = (
+      request: Request,
+      platformContext: PlatformContext,
+    ) => {
+      const contract = c.router({
+        test: {
+          method: 'GET',
+          path: '/test',
+          responses: {
+            200: z.object({}).passthrough(),
+          },
+        },
+      });
+
+      const router = tsr.platformContext<PlatformContext>().router(contract, {
+        test: async (_, { foo }) => {
+          return {
+            status: 200,
+            body: {
+              foo,
+            },
+          };
+        },
+      });
+
+      return fetchRequestHandler({
+        contract,
+        router,
+        options: {},
+        request,
+        platformContext,
+      });
+    };
+
+    const request = new Request('http://localhost/test', {
+      method: 'GET',
+      headers: { origin: 'http://localhost' },
+    });
+
+    const response = await fetchRequestHandlerWithContext(request, {
+      foo: 'context-bar',
+    });
+    const expectedResponse = new Response('{"foo":"context-bar"}', {
+      headers: {
+        'content-type': 'application/json',
+      },
+    });
+
+    expect(response.status).toEqual(expectedResponse.status);
+    expect(response.headers).toEqual(expectedResponse.headers);
+    expect(await response.json()).toEqual(await expectedResponse.json());
+  });
 });

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

@@ -1,34 +1,70 @@
-import { AppRouter } from '@ts-rest/core';
+import { AppRoute, AppRouter } from '@ts-rest/core';
 import { createServerlessRouter } from '../router';
-import { RecursiveRouterObj, ServerlessHandlerOptions } from '../types';
+import {
+  AppRouteImplementationOrOptions,
+  RecursiveRouterObj,
+  ServerlessHandlerOptions,
+} from '../types';
 import { TsRestRequest } from '../request';
 
 export const tsr = {
-  router: <T extends AppRouter, TRequestExtension>(
+  router: <T extends AppRouter, TPlatformContext = {}, TRequestExtension = {}>(
     contract: T,
-    router: RecursiveRouterObj<T, {}, TRequestExtension>,
+    router: RecursiveRouterObj<T, TPlatformContext, TRequestExtension>,
   ) => router,
+  route: <T extends AppRoute, TPlatformContext = {}, TRequestExtension = {}>(
+    contractEndpoint: T,
+    route: AppRouteImplementationOrOptions<
+      T,
+      TPlatformContext,
+      TRequestExtension
+    >,
+  ) => route,
+  platformContext: <TPlatformContext>() => ({
+    router: <T extends AppRouter, TRequestExtension = {}>(
+      contract: T,
+      router: RecursiveRouterObj<T, TPlatformContext, TRequestExtension>,
+    ) => router,
+    route: <T extends AppRoute, TRequestExtension = {}>(
+      contractEndpoint: T,
+      route: AppRouteImplementationOrOptions<
+        T,
+        TPlatformContext,
+        TRequestExtension
+      >,
+    ) => route,
+  }),
 };
 
-export type FetchHandlerOptions<TRequestExtension = {}> =
-  ServerlessHandlerOptions<{}, TRequestExtension>;
+export type FetchHandlerOptions<
+  TPlatformContext = {},
+  TRequestExtension = {},
+> = ServerlessHandlerOptions<TPlatformContext, TRequestExtension>;
 
-export const fetchRequestHandler = <T extends AppRouter, TRequestExtension>({
+export const fetchRequestHandler = <
+  T extends AppRouter,
+  TRequestExtension,
+  TPlatformContext = {},
+>({
   contract,
   router,
   options = {},
   request,
+  platformContext,
 }: {
   contract: T;
-  router: RecursiveRouterObj<T, {}, TRequestExtension>;
-  options: FetchHandlerOptions<TRequestExtension>;
+  router: RecursiveRouterObj<T, TPlatformContext, TRequestExtension>;
+  options: FetchHandlerOptions<TPlatformContext, TRequestExtension>;
   request: Request;
+  platformContext?: TPlatformContext;
 }) => {
-  const serverlessRouter = createServerlessRouter<T, {}, TRequestExtension>(
-    contract,
-    router,
-    options as ServerlessHandlerOptions,
-  );
+  const serverlessRouter = createServerlessRouter<
+    T,
+    TPlatformContext,
+    TRequestExtension
+  >(contract, router, options as ServerlessHandlerOptions<TPlatformContext>);
   const tsRestRequest = new TsRestRequest(request);
-  return serverlessRouter.fetch(tsRestRequest, {});
+  return serverlessRouter.fetch(tsRestRequest, {
+    ...platformContext,
+  });
 };

libs/ts-rest/serverless/src/lib/handlers/ts-rest-lambda.ts

@@ -1,13 +1,17 @@
 import type { Context } from 'aws-lambda';
-import { AppRouter } from '@ts-rest/core';
+import { AppRoute, AppRouter } from '@ts-rest/core';
 import {
   ApiGatewayEvent,
   ApiGatewayResponse,
   requestFromEvent,
   responseToResult,
 } from '../mappers/aws/api-gateway';
 import { createServerlessRouter } from '../router';
-import { RecursiveRouterObj, ServerlessHandlerOptions } from '../types';
+import {
+  AppRouteImplementationOrOptions,
+  RecursiveRouterObj,
+  ServerlessHandlerOptions,
+} from '../types';
 
 type LambdaPlatformArgs = {
   rawEvent: ApiGatewayEvent;
@@ -19,6 +23,14 @@ export const tsr = {
     contract: T,
     router: RecursiveRouterObj<T, LambdaPlatformArgs, TRequestExtension>,
   ) => router,
+  route: <T extends AppRoute, TRequestExtension = {}>(
+    contractEndpoint: T,
+    route: AppRouteImplementationOrOptions<
+      T,
+      LambdaPlatformArgs,
+      TRequestExtension
+    >,
+  ) => route,
 };
 
 export type LambdaHandlerOptions<TRequestExtension = {}> =

libs/ts-rest/serverless/src/lib/handlers/ts-rest-next.ts

@@ -1,7 +1,11 @@
-import { AppRouter } from '@ts-rest/core';
+import { AppRoute, AppRouter } from '@ts-rest/core';
 import type { NextRequest, NextResponse } from 'next/server';
 import { createServerlessRouter } from '../router';
-import { RecursiveRouterObj, ServerlessHandlerOptions } from '../types';
+import {
+  AppRouteImplementationOrOptions,
+  RecursiveRouterObj,
+  ServerlessHandlerOptions,
+} from '../types';
 import { TsRestRequest } from '../request';
 
 type NextPlatformArgs = {
@@ -13,6 +17,14 @@ export const tsr = {
     contract: T,
     router: RecursiveRouterObj<T, NextPlatformArgs, TRequestExtension>,
   ) => router,
+  route: <T extends AppRoute, TRequestExtension = {}>(
+    contractEndpoint: T,
+    route: AppRouteImplementationOrOptions<
+      T,
+      NextPlatformArgs,
+      TRequestExtension
+    >,
+  ) => route,
 };
 
 export type NextHandlerOptions<TRequestExtension> = ServerlessHandlerOptions<