Add endpointAdapter to Lambda adapter

.changeset/lambda-endpoint-adapter.md

@@ -0,0 +1,5 @@
+---
+"inngest": minor
+---
+
+Add `endpointAdapter` to the Lambda adapter for Durable Endpoints support

packages/inngest/src/lambda.test.ts

@@ -1,6 +1,8 @@
 import type { APIGatewayProxyResult } from "aws-lambda";
 import * as LambdaHandler from "./lambda.ts";
+import { endpointAdapter } from "./lambda.ts";
 import { testFramework } from "./test/helpers.ts";
+import { testEndpointAdapter } from "./test/testEndpointAdapter.ts";
 
 testFramework("AWS Lambda", LambdaHandler, {
   transformReq: (req, _res, _env) => {
@@ -35,3 +37,39 @@ testFramework("AWS Lambda", LambdaHandler, {
     };
   },
 });
+
+testEndpointAdapter("Lambda", endpointAdapter, {
+  invokeProxy: async (client, { url, method }) => {
+    const handler = client.endpointProxy();
+
+    const parsedUrl = new URL(url);
+
+    // Build query string parameters from the URL
+    const queryStringParameters: Record<string, string> = {};
+    parsedUrl.searchParams.forEach((v, k) => {
+      queryStringParameters[k] = v;
+    });
+
+    // Create a minimal API Gateway v1 event
+    const event = {
+      path: parsedUrl.pathname,
+      headers: { host: parsedUrl.host },
+      httpMethod: method,
+      queryStringParameters:
+        Object.keys(queryStringParameters).length > 0
+          ? queryStringParameters
+          : null,
+      body: null,
+      isBase64Encoded: false,
+    };
+
+    // biome-ignore lint/suspicious/noExplicitAny: test mock
+    const res = await handler(event as any, {} as any);
+
+    return {
+      status: res.statusCode,
+      body: res.body || "",
+      headers: (res.headers || {}) as Record<string, string>,
+    };
+  },
+});

packages/inngest/src/lambda.ts

@@ -30,12 +30,16 @@ import type {
   APIGatewayProxyResult,
   Context,
 } from "aws-lambda";
+import type { Inngest } from "./components/Inngest.ts";
 import {
   InngestCommHandler,
   type ServeHandlerOptions,
+  type SyncHandlerOptions,
 } from "./components/InngestCommHandler.ts";
+import { handleDurableEndpointProxyRequest } from "./components/InngestDurableEndpointProxy.ts";
+import { InngestEndpointAdapter } from "./components/InngestEndpointAdapter.ts";
 import type { Either } from "./helpers/types.ts";
-import type { SupportedFrameworkName } from "./types.ts";
+import type { RegisterOptions, SupportedFrameworkName } from "./types.ts";
 
 /**
  * The name of the framework, used to identify the framework in Inngest
@@ -44,40 +48,33 @@ import type { SupportedFrameworkName } from "./types.ts";
 export const frameworkName: SupportedFrameworkName = "aws-lambda";
 
 /**
- * With AWS Lambda, serve and register any declared functions with Inngest,
- * making them available to be triggered by events.
- *
- * @example
- *
- * ```ts
- * import { Inngest } from "inngest";
- * import { serve } from "inngest/lambda";
- *
- * const inngest = new Inngest({ id: "my-lambda-app" });
- *
- * const fn = inngest.createFunction(
- *   { id: "hello-world" },
- *   { event: "test/hello.world" },
- *   async ({ event }) => {
- *    return "Hello World";
- *  }
- * );
- *
- * export const handler = serve({ client: inngest, functions: [fn] });
- * ```
- *
- * @public
+ * The handler type for AWS Lambda with API Gateway (v1 or v2).
  */
-// Has explicit return type to avoid JSR-defined "slow types"
-export const serve = (
-  options: ServeHandlerOptions,
-): ((
+export type LambdaHandler = (
   event: Either<APIGatewayEvent, APIGatewayProxyEventV2>,
-  _context: Context,
-) => Promise<APIGatewayProxyResult>) => {
+  context: Context,
+) => Promise<APIGatewayProxyResult>;
+
+/**
+ * Detect whether the incoming Lambda event is API Gateway v2.
+ */
+const isV2Event = (
+  ev: APIGatewayEvent | APIGatewayProxyEventV2,
+): ev is APIGatewayProxyEventV2 => {
+  return (ev as APIGatewayProxyEventV2).version === "2.0";
+};
+
+/**
+ * Shared comm handler factory used by both `serve()` and `endpointAdapter`.
+ */
+const commHandler = (
+  options: RegisterOptions & { client: Inngest.Like },
+  syncOptions?: SyncHandlerOptions,
+) => {
   const handler = new InngestCommHandler({
     frameworkName,
     ...options,
+    syncOptions,
     handler: (
       event: Either<APIGatewayEvent, APIGatewayProxyEventV2>,
       _context: Context,
@@ -88,11 +85,7 @@ export const serve = (
        *
        * This still doesn't handle all cases, but it's a start.
        */
-      const eventIsV2 = ((
-        ev: APIGatewayEvent | APIGatewayProxyEventV2,
-      ): ev is APIGatewayProxyEventV2 => {
-        return (ev as APIGatewayProxyEventV2).version === "2.0";
-      })(event);
+      const eventIsV2 = isV2Event(event);
 
       // Create a map of headers
       const headersMap = new Map<string, string | undefined>([
@@ -129,7 +122,7 @@ export const serve = (
 
           return url;
         },
-        queryString: (key) => {
+        queryString: (key: string) => {
           return event.queryStringParameters?.[key];
         },
         transformResponse: ({
@@ -139,9 +132,130 @@ export const serve = (
         }): Promise<APIGatewayProxyResult> => {
           return Promise.resolve({ body, statusCode, headers });
         },
+        experimentalTransformSyncResponse: async (data: unknown) => {
+          const res = data as APIGatewayProxyResult;
+
+          return {
+            headers: (res.headers || {}) as Record<string, string>,
+            status: res.statusCode,
+            body: res.body || "",
+          };
+        },
       };
     },
   });
 
-  return handler.createHandler();
+  return handler;
+};
+
+/**
+ * With AWS Lambda, serve and register any declared functions with Inngest,
+ * making them available to be triggered by events.
+ *
+ * @example
+ *
+ * ```ts
+ * import { Inngest } from "inngest";
+ * import { serve } from "inngest/lambda";
+ *
+ * const inngest = new Inngest({ id: "my-lambda-app" });
+ *
+ * const fn = inngest.createFunction(
+ *   { id: "hello-world" },
+ *   { event: "test/hello.world" },
+ *   async ({ event }) => {
+ *    return "Hello World";
+ *  }
+ * );
+ *
+ * export const handler = serve({ client: inngest, functions: [fn] });
+ * ```
+ *
+ * @public
+ */
+// Has explicit return type to avoid JSR-defined "slow types"
+export const serve = (options: ServeHandlerOptions): LambdaHandler => {
+  return commHandler(options).createHandler();
+};
+
+/**
+ * Creates a durable endpoint proxy handler for AWS Lambda environments.
+ *
+ * This handler extracts `runId` and `token` from query parameters,
+ * fetches the run output from Inngest, decrypts it via middleware
+ * (if configured), and returns it with CORS headers.
+ */
+const createDurableEndpointProxyHandler = (
+  options: InngestEndpointAdapter.ProxyHandlerOptions,
+): LambdaHandler => {
+  return async (
+    event: Either<APIGatewayEvent, APIGatewayProxyEventV2>,
+    _context: Context,
+  ): Promise<APIGatewayProxyResult> => {
+    const method = isV2Event(event)
+      ? event.requestContext.http.method
+      : event.httpMethod;
+
+    const result = await handleDurableEndpointProxyRequest(
+      options.client as Inngest.Any,
+      {
+        runId: event.queryStringParameters?.runId ?? null,
+        token: event.queryStringParameters?.token ?? null,
+        method,
+      },
+    );
+
+    return {
+      statusCode: result.status,
+      headers: result.headers,
+      body: result.body,
+    };
+  };
 };
+
+/**
+ * In AWS Lambda, create a function that can wrap any endpoint to be able
+ * to use steps seamlessly within that API.
+ *
+ * @example
+ * ```ts
+ * import { Inngest, step } from "inngest";
+ * import { endpointAdapter } from "inngest/lambda";
+ *
+ * const inngest = new Inngest({
+ *   id: "my-app",
+ *   endpointAdapter,
+ * });
+ *
+ * // Your durable endpoint Lambda handler
+ * export const handler = inngest.endpoint(async (event, context) => {
+ *   const result = await step.run("work", () => "done");
+ *
+ *   return {
+ *     statusCode: 200,
+ *     body: JSON.stringify({ result }),
+ *   };
+ * });
+ * ```
+ *
+ * You can also configure a custom redirect URL and create a proxy endpoint:
+ *
+ * @example
+ * ```ts
+ * import { Inngest } from "inngest";
+ * import { endpointAdapter } from "inngest/lambda";
+ *
+ * const inngest = new Inngest({
+ *   id: "my-app",
+ *   endpointAdapter: endpointAdapter.withOptions({
+ *     asyncRedirectUrl: "/poll",
+ *   }),
+ * });
+ *
+ * // Proxy endpoint Lambda handler - handles CORS and decryption
+ * export const pollHandler = inngest.endpointProxy();
+ * ```
+ */
+export const endpointAdapter = InngestEndpointAdapter.create((options) => {
+  return commHandler(options, options).createSyncHandler();
+}, createDurableEndpointProxyHandler);