@geostrategists/react-router-aws 2.0.0 → 2.1.0

package/README.md

@@ -1,52 +1,115 @@
-# @geostrategists/react-router-aws
-
-## AWS adapters for React Router v7 (successor to Remix)
-
 [![npm version](https://badge.fury.io/js/@geostrategists%2Freact-router-aws.svg)](https://badge.fury.io/js/@geostrategists%2Freact-router-aws)
 [![install size](https://packagephobia.com/badge?p=@geostrategists/react-router-aws)](https://packagephobia.com/result?p=@geostrategists/react-router-aws)
 
-Forked from [remix-aws](https://github.com/wingleung/remix-aws) to support React Router v7, which Remix was merged into.
+# AWS Lambda adapters for React Router v7
+
+This project provides adapters for running React Router Framework applications on AWS Lambda
+behind a number of different HTTP gateways.
+
+## 🚀 Supported gateways
+
+- Lambda function URL (streaming) _✨(recommended)_
+- Lambda function URL (buffered)
+- API Gateway v2
+- API Gateway v1
+- Application Load Balancer
 
-## 🚀 support
+### Acknowledgements
 
-- API gateway v1
-- API gateway v2
-- Application load balancer
+This project was forked from [remix-aws](https://github.com/wingleung/remix-aws) to support React Router v7, which Remix was merged into.
 
 ## Getting started
 
+### Installation
+
+```shell
+npm add @geostrategists/react-router-aws
+```
+
 ```shell
-npm install --save @geostrategists/react-router-aws
+yarn add @geostrategists/react-router-aws
 ```
 
+### Gateway-specific handlers
+
+Next, choose the handler that matches your AWS integration:
+
+- `createALBRequestHandler` for Application Load Balancer
+- `createAPIGatewayV1RequestHandler` for API Gateway v1
+- `createAPIGatewayV2RequestHandler` for API Gateway v2
+- `createFunctionURLRequestHandler` for Lambda Function URLs (Buffered)
+- `createFunctionURLStreamingRequestHandler` for Lambda Function URLs (Streaming)
+
+Example for API Gateway v2:
+
 ```javascript
-// server.js
+// lambda-handler.ts
 import * as build from "virtual:react-router/server-build";
-import { AWSProxy, createRequestHandler } from "@geostrategists/react-router-aws";
+import { createAPIGatewayV2RequestHandler } from "@geostrategists/react-router-aws";
 
-export const handler = createRequestHandler({
+export const handler = createAPIGatewayV2RequestHandler({
   build,
   mode: process.env.NODE_ENV,
-  awsProxy: AWSProxy.APIGatewayV2,
 });
 ```
 
-### `awsProxy`
+> [!NOTE]
+>
+> **DEPRECATION NOTICE**: The previous `createRequestHandler` method still exists, but is kept only for
+> backwards-compatibility reasons and will be removed in the next major release.  
+> It does not allow tree-shaking and will include all gateway adapters in your bundle.  
+> For optimal bundle size, always use the method specific to your gateway:
 
-By default, the `awsProxy` is set to `AWSProxy.APIGatewayV2`.
+### Streaming support for Lambda Function URLs
 
-#### Options
+React Router and React allow you to stream responses from the server to the client, reducing the TTFB (time to first byte)
+and improving the user experience. See [Streaming with Suspense](https://reactrouter.com/how-to/suspense) for details.
 
-- `AWSProxy.APIGatewayV1`
-- `AWSProxy.APIGatewayV2`
-- `AWSProxy.ALB`
-- `AWSProxy.FunctionURL`
+For this to work, the response from the Lambda must also be streamed. This is currently only possible with
+Lambda Function URLs, which is why we recommend this setup.
+
+For streaming responses from React Router on AWS Lambda Function URLs, use `createFunctionURLStreamingRequestHandler`:
+
+```typescript
+// lambda-handler.ts
+import * as build from "virtual:react-router/server-build";
+import { createFunctionURLStreamingRequestHandler } from "@geostrategists/react-router-aws";
+
+export const handler = createFunctionURLStreamingRequestHandler({
+  build,
+  mode: process.env.NODE_ENV,
+});
+```
+
+The Function URL must be configured to use streaming responses.
+
+For example, in CDK:
+
+```typescript
+// frontend-stack.ts
+declare const fn: lambda.Function;
+
+fn.addFunctionUrl({
+  authType: lambda.FunctionUrlAuthType.NONE,
+  invokeMode: lambda.InvokeMode.RESPONSE_STREAM,
+});
+```
+
+> [!TIP]
+> It is strongly recommended to include the `@geostrategists/react-router-aws` dependency in your Lambda handler bundle.  
+> Otherwise (if it is externalized and perhaps put in a Lambda layer), AWS Lambda may not detect the handler as a
+> streaming handler.
+>
+> If you encounter responses that show a `{ statusCode, headers, body }` JSON object instead of just the body,
+> this might be the reason.
+
+More on response streaming: https://docs.aws.amazon.com/lambda/latest/dg/configuration-response-streaming.html
 
 ## Deployment recommendation
 
 Since Vite already bundles the project into a single entry point, there is no need to further
 bundle the lambda code.
-For example, when using AWS CDK, we recommend using lambda.Function directly instead of lambda.NodeJsFunction.
+For example, when using AWS CDK, we recommend using [lambda.Function](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html) directly instead of lambda.NodeJsFunction.
 
 Dependencies can be provided using a layer, for example.
 
@@ -61,16 +124,4 @@ There are two primary methods to achieve this:
 - Use the .mjs extension:
   Alternatively, you can change the file extension to `.mjs`. For example, you can configure the React Router `serverBuildFile` setting to output `index.mjs`.
 
-more info: [AWS docs on ES module support in AWS lambdas](https://docs.aws.amazon.com/lambda/latest/dg/lambda-nodejs.html#designate-es-module)
-
-## Notes
-
-### split from @remix/architect
-
-As mentioned in [#3173](https://github.com/remix-run/remix/pull/3173) the goal would be to provide an AWS adapter for
-the community by the community.
-In doing so the focus will be on AWS integrations and less on Architect. I do think it's added value to provide examples
-for Architect, AWS SAM, AWS CDK, Serverless,...
-
-**info:** [ALB types](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/aws-lambda/trigger/alb.d.ts#L29-L48)
-vs [API gateway v1 types](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/aws-lambda/trigger/api-gateway-proxy.d.ts#L116-L145)
+See [AWS docs on ES module support in AWS lambdas](https://docs.aws.amazon.com/lambda/latest/dg/lambda-nodejs.html#designate-es-module) for more information.

package/dist/index.d.mts

@@ -1,12 +1,7 @@
-import { APIGatewayProxyEventV2, APIGatewayProxyEvent, ALBEvent, APIGatewayProxyHandlerV2, APIGatewayProxyHandler, ALBHandler } from 'aws-lambda';
 import { UNSAFE_MiddlewareEnabled, unstable_InitialContext, AppLoadContext, ServerBuild } from 'react-router';
+import { ALBEvent, ALBHandler, APIGatewayProxyEvent, APIGatewayProxyHandler, APIGatewayProxyEventV2, APIGatewayProxyHandlerV2, LambdaFunctionURLEvent, LambdaFunctionURLHandler, Handler, APIGatewayProxyResult, APIGatewayProxyStructuredResultV2, ALBResult } from 'aws-lambda';
+import { StreamifyHandler } from 'aws-lambda/handler';
 
-declare enum AWSProxy {
-    APIGatewayV1 = "APIGatewayV1",
-    APIGatewayV2 = "APIGatewayV2",
-    ALB = "ALB",
-    FunctionURL = "FunctionURL"
-}
 type MaybePromise<T> = T | Promise<T>;
 /**
  * A function that returns the value to use as `context` in route `loader` and
@@ -15,17 +10,93 @@ type MaybePromise<T> = T | Promise<T>;
  * You can think of this as an escape hatch that allows you to pass
  * environment/platform-specific values through to your loader/action.
  */
-type GetLoadContextFunction = (event: APIGatewayProxyEventV2 | APIGatewayProxyEvent | ALBEvent) => UNSAFE_MiddlewareEnabled extends true ? MaybePromise<unstable_InitialContext> : MaybePromise<AppLoadContext>;
-type RequestHandler = APIGatewayProxyHandlerV2 | APIGatewayProxyHandler | ALBHandler;
-/**
- * Returns a request handler for AWS that serves the response using
- * React Router.
- */
-declare function createRequestHandler({ build, getLoadContext, mode, awsProxy, }: {
+type GetLoadContextFunction<E> = (event: E) => UNSAFE_MiddlewareEnabled extends true ? MaybePromise<unstable_InitialContext> : MaybePromise<AppLoadContext>;
+type CreateRequestHandlerArgs<T> = {
     build: ServerBuild;
-    getLoadContext?: GetLoadContextFunction;
+    getLoadContext?: GetLoadContextFunction<T>;
     mode?: string;
-    awsProxy?: AWSProxy;
-}): RequestHandler;
+};
+/**
+ * Returns a request handler for AWS API Gateway V1
+ *
+ */
+/**
+ * Returns a request handler for AWS API Gateway V1 events.
+ *
+ * @param options - The handler options, including the React Router server build,
+ *   optional getLoadContext function, and mode string.
+ * @returns An AWS API Gateway V1 handler compatible with APIGatewayProxyHandler.
+ */
+declare function createAPIGatewayV1RequestHandler(options: CreateRequestHandlerArgs<APIGatewayProxyEvent>): APIGatewayProxyHandler;
+/**
+ * Returns a request handler for AWS API Gateway V2 events.
+ *
+ * @param options - The handler options, including the React Router server build,
+ *   optional getLoadContext function, and mode string.
+ * @returns An AWS API Gateway V2 handler compatible with APIGatewayProxyHandlerV2.
+ */
+declare function createAPIGatewayV2RequestHandler(options: CreateRequestHandlerArgs<APIGatewayProxyEventV2>): APIGatewayProxyHandlerV2;
+/**
+ * Returns a request handler for AWS Application Load Balancer events.
+ *
+ * @param options - The handler options, including the React Router server build,
+ *   optional getLoadContext function, and mode string.
+ * @returns An AWS ALB handler compatible with ALBHandler.
+ */
+declare function createALBRequestHandler(options: CreateRequestHandlerArgs<ALBEvent>): ALBHandler;
+/**
+ * Returns a request handler for AWS Lambda Function URL events (invoke mode BUFFERED).
+ *
+ * @param options - The handler options, including the React Router server build,
+ *   optional getLoadContext function, and mode string.
+ * @returns An AWS Lambda Function URL handler compatible with Lambda Function URLs with InvokeMode BUFFERED.
+ */
+declare function createFunctionURLRequestHandler(options: CreateRequestHandlerArgs<LambdaFunctionURLEvent>): LambdaFunctionURLHandler;
+/**
+ * Returns a request handler for AWS Lambda Function URL events (invoke mode RESPONSE_STREAM).
+ *
+ * @param options - The handler options, including the React Router server build,
+ *   optional getLoadContext function, and mode string.
+ * @returns A streaming AWS Lambda Function URL handler compatible with Lambda Function URLs with InvokeMode RESPONSE_STREAM.
+ */
+declare function createFunctionURLStreamingRequestHandler(options: CreateRequestHandlerArgs<LambdaFunctionURLEvent>): StreamifyHandler<LambdaFunctionURLEvent, void>;
+
+interface ReactRouterAdapter<E, Ret, Res = void, H = Handler<E, Ret>> {
+    wrapHandler: (handler: (event: E, res: Res) => Promise<Ret>) => H;
+    createReactRouterRequest: (event: E) => Request;
+    sendReactRouterResponse: (nodeResponse: Response, response: Res) => Promise<Ret>;
+}
+
+type ApiGatewayV1Adapter = ReactRouterAdapter<APIGatewayProxyEvent, APIGatewayProxyResult>;
+
+type ApiGatewayV2Adapter = ReactRouterAdapter<APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2>;
+
+type ApplicationLoadBalancerAdapter = ReactRouterAdapter<ALBEvent, ALBResult>;
+
+type FunctionUrlStreamingAdapter = ReactRouterAdapter<LambdaFunctionURLEvent, void, awslambda.HttpResponseStream, StreamifyHandler<LambdaFunctionURLEvent, void>>;
+
+declare enum AWSProxy {
+    APIGatewayV1 = "APIGatewayV1",
+    APIGatewayV2 = "APIGatewayV2",
+    ALB = "ALB",
+    FunctionURL = "FunctionURL",
+    FunctionURLStreaming = "FunctionURLStreaming"
+}
+type InferAdapter<T extends AWSProxy> = T extends AWSProxy.APIGatewayV1 ? ApiGatewayV1Adapter : T extends AWSProxy.APIGatewayV2 | AWSProxy.FunctionURL ? ApiGatewayV2Adapter : T extends AWSProxy.ALB ? ApplicationLoadBalancerAdapter : T extends AWSProxy.FunctionURLStreaming ? FunctionUrlStreamingAdapter : never;
+type InferEventType<T extends AWSProxy> = InferAdapter<T> extends ReactRouterAdapter<infer E, any, any, any> ? E : never;
+type InferHandlerType<T extends AWSProxy> = InferAdapter<T> extends ReactRouterAdapter<any, any, any, infer H> ? H : never;
+/**
+ * Returns a request handler for AWS that serves the response using React Router.
+ *
+ * @deprecated Use one of the gateway-specific create*RequestHandler methods instead for better tree-shaking.
+ *  - `createAPIGatewayV1RequestHandler`
+ *  - `createAPIGatewayV2RequestHandler`
+ *  - `createALBRequestHandler`
+ *  - `createFunctionURLRequestHandler`
+ *  - `createFunctionURLStreamingRequestHandler`
+ */
+declare function createRequestHandler<T extends AWSProxy>(options: CreateRequestHandlerArgs<InferEventType<T>> & {
+    awsProxy?: T;
+}): InferHandlerType<T>;
 
-export { AWSProxy, type GetLoadContextFunction, type RequestHandler, createRequestHandler };
+export { AWSProxy, type GetLoadContextFunction, createALBRequestHandler, createAPIGatewayV1RequestHandler, createAPIGatewayV2RequestHandler, createFunctionURLRequestHandler, createFunctionURLStreamingRequestHandler, createRequestHandler };

package/dist/index.d.ts

@@ -1,12 +1,7 @@
-import { APIGatewayProxyEventV2, APIGatewayProxyEvent, ALBEvent, APIGatewayProxyHandlerV2, APIGatewayProxyHandler, ALBHandler } from 'aws-lambda';
 import { UNSAFE_MiddlewareEnabled, unstable_InitialContext, AppLoadContext, ServerBuild } from 'react-router';
+import { ALBEvent, ALBHandler, APIGatewayProxyEvent, APIGatewayProxyHandler, APIGatewayProxyEventV2, APIGatewayProxyHandlerV2, LambdaFunctionURLEvent, LambdaFunctionURLHandler, Handler, APIGatewayProxyResult, APIGatewayProxyStructuredResultV2, ALBResult } from 'aws-lambda';
+import { StreamifyHandler } from 'aws-lambda/handler';
 
-declare enum AWSProxy {
-    APIGatewayV1 = "APIGatewayV1",
-    APIGatewayV2 = "APIGatewayV2",
-    ALB = "ALB",
-    FunctionURL = "FunctionURL"
-}
 type MaybePromise<T> = T | Promise<T>;
 /**
  * A function that returns the value to use as `context` in route `loader` and
@@ -15,17 +10,93 @@ type MaybePromise<T> = T | Promise<T>;
  * You can think of this as an escape hatch that allows you to pass
  * environment/platform-specific values through to your loader/action.
  */
-type GetLoadContextFunction = (event: APIGatewayProxyEventV2 | APIGatewayProxyEvent | ALBEvent) => UNSAFE_MiddlewareEnabled extends true ? MaybePromise<unstable_InitialContext> : MaybePromise<AppLoadContext>;
-type RequestHandler = APIGatewayProxyHandlerV2 | APIGatewayProxyHandler | ALBHandler;
-/**
- * Returns a request handler for AWS that serves the response using
- * React Router.
- */
-declare function createRequestHandler({ build, getLoadContext, mode, awsProxy, }: {
+type GetLoadContextFunction<E> = (event: E) => UNSAFE_MiddlewareEnabled extends true ? MaybePromise<unstable_InitialContext> : MaybePromise<AppLoadContext>;
+type CreateRequestHandlerArgs<T> = {
     build: ServerBuild;
-    getLoadContext?: GetLoadContextFunction;
+    getLoadContext?: GetLoadContextFunction<T>;
     mode?: string;
-    awsProxy?: AWSProxy;
-}): RequestHandler;
+};
+/**
+ * Returns a request handler for AWS API Gateway V1
+ *
+ */
+/**
+ * Returns a request handler for AWS API Gateway V1 events.
+ *
+ * @param options - The handler options, including the React Router server build,
+ *   optional getLoadContext function, and mode string.
+ * @returns An AWS API Gateway V1 handler compatible with APIGatewayProxyHandler.
+ */
+declare function createAPIGatewayV1RequestHandler(options: CreateRequestHandlerArgs<APIGatewayProxyEvent>): APIGatewayProxyHandler;
+/**
+ * Returns a request handler for AWS API Gateway V2 events.
+ *
+ * @param options - The handler options, including the React Router server build,
+ *   optional getLoadContext function, and mode string.
+ * @returns An AWS API Gateway V2 handler compatible with APIGatewayProxyHandlerV2.
+ */
+declare function createAPIGatewayV2RequestHandler(options: CreateRequestHandlerArgs<APIGatewayProxyEventV2>): APIGatewayProxyHandlerV2;
+/**
+ * Returns a request handler for AWS Application Load Balancer events.
+ *
+ * @param options - The handler options, including the React Router server build,
+ *   optional getLoadContext function, and mode string.
+ * @returns An AWS ALB handler compatible with ALBHandler.
+ */
+declare function createALBRequestHandler(options: CreateRequestHandlerArgs<ALBEvent>): ALBHandler;
+/**
+ * Returns a request handler for AWS Lambda Function URL events (invoke mode BUFFERED).
+ *
+ * @param options - The handler options, including the React Router server build,
+ *   optional getLoadContext function, and mode string.
+ * @returns An AWS Lambda Function URL handler compatible with Lambda Function URLs with InvokeMode BUFFERED.
+ */
+declare function createFunctionURLRequestHandler(options: CreateRequestHandlerArgs<LambdaFunctionURLEvent>): LambdaFunctionURLHandler;
+/**
+ * Returns a request handler for AWS Lambda Function URL events (invoke mode RESPONSE_STREAM).
+ *
+ * @param options - The handler options, including the React Router server build,
+ *   optional getLoadContext function, and mode string.
+ * @returns A streaming AWS Lambda Function URL handler compatible with Lambda Function URLs with InvokeMode RESPONSE_STREAM.
+ */
+declare function createFunctionURLStreamingRequestHandler(options: CreateRequestHandlerArgs<LambdaFunctionURLEvent>): StreamifyHandler<LambdaFunctionURLEvent, void>;
+
+interface ReactRouterAdapter<E, Ret, Res = void, H = Handler<E, Ret>> {
+    wrapHandler: (handler: (event: E, res: Res) => Promise<Ret>) => H;
+    createReactRouterRequest: (event: E) => Request;
+    sendReactRouterResponse: (nodeResponse: Response, response: Res) => Promise<Ret>;
+}
+
+type ApiGatewayV1Adapter = ReactRouterAdapter<APIGatewayProxyEvent, APIGatewayProxyResult>;
+
+type ApiGatewayV2Adapter = ReactRouterAdapter<APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2>;
+
+type ApplicationLoadBalancerAdapter = ReactRouterAdapter<ALBEvent, ALBResult>;
+
+type FunctionUrlStreamingAdapter = ReactRouterAdapter<LambdaFunctionURLEvent, void, awslambda.HttpResponseStream, StreamifyHandler<LambdaFunctionURLEvent, void>>;
+
+declare enum AWSProxy {
+    APIGatewayV1 = "APIGatewayV1",
+    APIGatewayV2 = "APIGatewayV2",
+    ALB = "ALB",
+    FunctionURL = "FunctionURL",
+    FunctionURLStreaming = "FunctionURLStreaming"
+}
+type InferAdapter<T extends AWSProxy> = T extends AWSProxy.APIGatewayV1 ? ApiGatewayV1Adapter : T extends AWSProxy.APIGatewayV2 | AWSProxy.FunctionURL ? ApiGatewayV2Adapter : T extends AWSProxy.ALB ? ApplicationLoadBalancerAdapter : T extends AWSProxy.FunctionURLStreaming ? FunctionUrlStreamingAdapter : never;
+type InferEventType<T extends AWSProxy> = InferAdapter<T> extends ReactRouterAdapter<infer E, any, any, any> ? E : never;
+type InferHandlerType<T extends AWSProxy> = InferAdapter<T> extends ReactRouterAdapter<any, any, any, infer H> ? H : never;
+/**
+ * Returns a request handler for AWS that serves the response using React Router.
+ *
+ * @deprecated Use one of the gateway-specific create*RequestHandler methods instead for better tree-shaking.
+ *  - `createAPIGatewayV1RequestHandler`
+ *  - `createAPIGatewayV2RequestHandler`
+ *  - `createALBRequestHandler`
+ *  - `createFunctionURLRequestHandler`
+ *  - `createFunctionURLStreamingRequestHandler`
+ */
+declare function createRequestHandler<T extends AWSProxy>(options: CreateRequestHandlerArgs<InferEventType<T>> & {
+    awsProxy?: T;
+}): InferHandlerType<T>;
 
-export { AWSProxy, type GetLoadContextFunction, type RequestHandler, createRequestHandler };
+export { AWSProxy, type GetLoadContextFunction, createALBRequestHandler, createAPIGatewayV1RequestHandler, createAPIGatewayV2RequestHandler, createFunctionURLRequestHandler, createFunctionURLStreamingRequestHandler, createRequestHandler };

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
-* @geostrategists/react-router-aws v2.0.0
+* @geostrategists/react-router-aws v2.1.0
 *
 * Copyright (c) Geostrategists Consulting GmbH
 *
@@ -9,9 +9,11 @@
 * @license MIT
 */
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -25,12 +27,25 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   AWSProxy: () => AWSProxy,
+  createALBRequestHandler: () => createALBRequestHandler,
+  createAPIGatewayV1RequestHandler: () => createAPIGatewayV1RequestHandler,
+  createAPIGatewayV2RequestHandler: () => createAPIGatewayV2RequestHandler,
+  createFunctionURLRequestHandler: () => createFunctionURLRequestHandler,
+  createFunctionURLStreamingRequestHandler: () => createFunctionURLStreamingRequestHandler,
   createRequestHandler: () => createRequestHandler
 });
 module.exports = __toCommonJS(index_exports);
@@ -38,9 +53,8 @@ module.exports = __toCommonJS(index_exports);
 // src/server.ts
 var import_react_router = require("react-router");
 
-// src/adapters/api-gateway-v1.ts
+// src/adapters/api-gateway-v2.ts
 var import_node = require("@react-router/node");
-var import_url = require("url");
 
 // src/binaryTypes.ts
 var binaryTypes = [
@@ -108,32 +122,38 @@ function isBinaryType(contentType) {
   return binaryTypes.includes(test);
 }
 
-// src/adapters/api-gateway-v1.ts
-function createReactRouterRequestAPIGatewayV1(event) {
-  const host = event.headers["x-forwarded-host"] || event.headers.Host;
+// src/adapters/api-gateway-v2.ts
+function createReactRouterRequestAPIGateywayV2(event) {
+  const host = event.headers["x-forwarded-host"] || event.headers.host;
+  const search = event.rawQueryString.length ? `?${event.rawQueryString}` : "";
   const scheme = event.headers["x-forwarded-proto"] || "http";
-  const rawQueryString = new import_url.URLSearchParams(event.queryStringParameters).toString();
-  const search = rawQueryString.length > 0 ? `?${rawQueryString}` : "";
-  const url = new URL(event.path + search, `${scheme}://${host}`);
+  const url = new URL(event.rawPath + search, `${scheme}://${host}`);
   const isFormData = event.headers["content-type"]?.includes("multipart/form-data");
   const controller = new AbortController();
   return new Request(url.href, {
-    method: event.requestContext.httpMethod,
-    headers: createReactRouterHeadersAPIGatewayV1(event.headers),
+    method: event.requestContext.http.method,
+    headers: createReactRouterHeadersAPIGatewayV2(event.headers, event.cookies),
     signal: controller.signal,
-    body: event.body && event.isBase64Encoded ? isFormData ? Buffer.from(event.body, "base64") : Buffer.from(event.body, "base64").toString() : event.body || void 0
+    body: event.body && event.isBase64Encoded ? isFormData ? Buffer.from(event.body, "base64") : Buffer.from(event.body, "base64").toString() : event.body
   });
 }
-function createReactRouterHeadersAPIGatewayV1(requestHeaders) {
+function createReactRouterHeadersAPIGatewayV2(requestHeaders, requestCookies) {
   const headers = new Headers();
   for (const [header, value] of Object.entries(requestHeaders)) {
     if (value) {
       headers.append(header, value);
     }
   }
+  if (requestCookies) {
+    headers.append("Cookie", requestCookies.join("; "));
+  }
   return headers;
 }
-async function sendReactRouterResponseAPIGatewayV1(nodeResponse) {
+async function sendReactRouterResponseAPIGatewayV2(nodeResponse) {
+  const cookies = nodeResponse.headers.getSetCookie();
+  if (cookies.length) {
+    nodeResponse.headers.delete("Set-Cookie");
+  }
   const contentType = nodeResponse.headers.get("Content-Type");
   const isBase64Encoded = isBinaryType(contentType);
   let body;
@@ -147,48 +167,45 @@ async function sendReactRouterResponseAPIGatewayV1(nodeResponse) {
   return {
     statusCode: nodeResponse.status,
     headers: Object.fromEntries(nodeResponse.headers.entries()),
-    body: body || "",
+    cookies,
+    body,
     isBase64Encoded
   };
 }
-var apiGatewayV1Adapter = {
-  createReactRouterRequest: createReactRouterRequestAPIGatewayV1,
-  sendReactRouterResponse: sendReactRouterResponseAPIGatewayV1
+var apiGatewayV2Adapter = {
+  wrapHandler: (handler) => (e) => handler(e),
+  createReactRouterRequest: createReactRouterRequestAPIGateywayV2,
+  sendReactRouterResponse: sendReactRouterResponseAPIGatewayV2
 };
 
-// src/adapters/api-gateway-v2.ts
+// src/adapters/api-gateway-v1.ts
 var import_node2 = require("@react-router/node");
-function createReactRouterRequestAPIGateywayV2(event) {
-  const host = event.headers["x-forwarded-host"] || event.headers.host;
-  const search = event.rawQueryString.length ? `?${event.rawQueryString}` : "";
+var import_url = require("url");
+function createReactRouterRequestAPIGatewayV1(event) {
+  const host = event.headers["x-forwarded-host"] || event.headers.Host;
   const scheme = event.headers["x-forwarded-proto"] || "http";
-  const url = new URL(event.rawPath + search, `${scheme}://${host}`);
+  const rawQueryString = new import_url.URLSearchParams(event.queryStringParameters).toString();
+  const search = rawQueryString.length > 0 ? `?${rawQueryString}` : "";
+  const url = new URL(event.path + search, `${scheme}://${host}`);
   const isFormData = event.headers["content-type"]?.includes("multipart/form-data");
   const controller = new AbortController();
   return new Request(url.href, {
-    method: event.requestContext.http.method,
-    headers: createReactRouterHeadersAPIGatewayV2(event.headers, event.cookies),
+    method: event.requestContext.httpMethod,
+    headers: createReactRouterHeadersAPIGatewayV1(event.headers),
     signal: controller.signal,
-    body: event.body && event.isBase64Encoded ? isFormData ? Buffer.from(event.body, "base64") : Buffer.from(event.body, "base64").toString() : event.body
+    body: event.body && event.isBase64Encoded ? isFormData ? Buffer.from(event.body, "base64") : Buffer.from(event.body, "base64").toString() : event.body || void 0
   });
 }
-function createReactRouterHeadersAPIGatewayV2(requestHeaders, requestCookies) {
+function createReactRouterHeadersAPIGatewayV1(requestHeaders) {
   const headers = new Headers();
   for (const [header, value] of Object.entries(requestHeaders)) {
     if (value) {
       headers.append(header, value);
     }
   }
-  if (requestCookies) {
-    headers.append("Cookie", requestCookies.join("; "));
-  }
   return headers;
 }
-async function sendReactRouterResponseAPIGatewayV2(nodeResponse) {
-  const cookies = nodeResponse.headers.getSetCookie();
-  if (cookies.length) {
-    nodeResponse.headers.delete("Set-Cookie");
-  }
+async function sendReactRouterResponseAPIGatewayV1(nodeResponse) {
   const contentType = nodeResponse.headers.get("Content-Type");
   const isBase64Encoded = isBinaryType(contentType);
   let body;
@@ -202,14 +219,14 @@ async function sendReactRouterResponseAPIGatewayV2(nodeResponse) {
   return {
     statusCode: nodeResponse.status,
     headers: Object.fromEntries(nodeResponse.headers.entries()),
-    cookies,
-    body,
+    body: body || "",
     isBase64Encoded
   };
 }
-var apiGatewayV2Adapter = {
-  createReactRouterRequest: createReactRouterRequestAPIGateywayV2,
-  sendReactRouterResponse: sendReactRouterResponseAPIGatewayV2
+var apiGatewayV1Adapter = {
+  wrapHandler: (handler) => (e) => handler(e),
+  createReactRouterRequest: createReactRouterRequestAPIGatewayV1,
+  sendReactRouterResponse: sendReactRouterResponseAPIGatewayV1
 };
 
 // src/adapters/application-load-balancer.ts
@@ -259,55 +276,109 @@ async function sendReactRouterResponseALB(nodeResponse) {
   };
 }
 var applicationLoadBalancerAdapter = {
+  wrapHandler: (handler) => (e) => handler(e),
   createReactRouterRequest: createReactRouterRequestALB,
   sendReactRouterResponse: sendReactRouterResponseALB
 };
 
-// src/adapters/index.ts
-var createReactRouterAdapter = (awsProxy) => {
-  switch (awsProxy) {
-    case "APIGatewayV1" /* APIGatewayV1 */:
-      return apiGatewayV1Adapter;
-    case "APIGatewayV2" /* APIGatewayV2 */:
-    case "FunctionURL" /* FunctionURL */:
-      return apiGatewayV2Adapter;
-    case "ALB" /* ALB */:
-      return applicationLoadBalancerAdapter;
+// src/adapters/function-url-streaming.ts
+var import_node4 = require("@react-router/node");
+var import_promises = __toESM(require("stream/promises"));
+var sendReactRouterResponseFunctionUrlStreaming = async (response, responseStream) => {
+  const httpResponseStream = awslambda.HttpResponseStream.from(responseStream, {
+    statusCode: response.status,
+    headers: Object.fromEntries(response.headers.entries())
+  });
+  if (response.body) {
+    await (0, import_node4.writeReadableStreamToWritable)(response.body, httpResponseStream);
+  } else {
+    await import_promises.default.finished(httpResponseStream);
   }
 };
+var functionUrlStreamingAdapter = {
+  wrapHandler: awslambda.streamifyResponse,
+  createReactRouterRequest: apiGatewayV2Adapter.createReactRouterRequest,
+  sendReactRouterResponse: sendReactRouterResponseFunctionUrlStreaming
+};
 
 // src/server.ts
-var AWSProxy = /* @__PURE__ */ ((AWSProxy2) => {
-  AWSProxy2["APIGatewayV1"] = "APIGatewayV1";
-  AWSProxy2["APIGatewayV2"] = "APIGatewayV2";
-  AWSProxy2["ALB"] = "ALB";
-  AWSProxy2["FunctionURL"] = "FunctionURL";
-  return AWSProxy2;
-})(AWSProxy || {});
-function createRequestHandler({
-  build,
-  getLoadContext,
-  mode = process.env.NODE_ENV,
-  awsProxy = "APIGatewayV2" /* APIGatewayV2 */
-}) {
+function createAPIGatewayV1RequestHandler(options) {
+  return createRequestHandlerForAdapter(apiGatewayV1Adapter, options);
+}
+function createAPIGatewayV2RequestHandler(options) {
+  return createRequestHandlerForAdapter(apiGatewayV2Adapter, options);
+}
+function createALBRequestHandler(options) {
+  return createRequestHandlerForAdapter(applicationLoadBalancerAdapter, options);
+}
+function createFunctionURLRequestHandler(options) {
+  return createRequestHandlerForAdapter(apiGatewayV2Adapter, options);
+}
+function createFunctionURLStreamingRequestHandler(options) {
+  return createRequestHandlerForAdapter(functionUrlStreamingAdapter, options);
+}
+function createRequestHandlerForAdapter(awsAdapter, { build, getLoadContext, mode = process.env.NODE_ENV }) {
   const handleRequest = (0, import_react_router.createRequestHandler)(build, mode);
-  return async (event) => {
-    const awsAdapter = createReactRouterAdapter(awsProxy);
+  return awsAdapter.wrapHandler(async (event, res) => {
     let request;
     try {
       request = awsAdapter.createReactRouterRequest(event);
     } catch (e) {
-      return awsAdapter.sendReactRouterResponse(
-        new Response(`Bad Request: ${e instanceof Error ? e.message : e}`, { status: 400 })
+      return await awsAdapter.sendReactRouterResponse(
+        new Response(`Bad Request: ${e instanceof Error ? e.message : e}`, { status: 400 }),
+        res
       );
     }
     const loadContext = await getLoadContext?.(event);
     const response = await handleRequest(request, loadContext);
-    return awsAdapter.sendReactRouterResponse(response);
-  };
+    return await awsAdapter.sendReactRouterResponse(response, res);
+  });
+}
+
+// src/legacy.ts
+var AWSProxy = /* @__PURE__ */ ((AWSProxy2) => {
+  AWSProxy2["APIGatewayV1"] = "APIGatewayV1";
+  AWSProxy2["APIGatewayV2"] = "APIGatewayV2";
+  AWSProxy2["ALB"] = "ALB";
+  AWSProxy2["FunctionURL"] = "FunctionURL";
+  AWSProxy2["FunctionURLStreaming"] = "FunctionURLStreaming";
+  return AWSProxy2;
+})(AWSProxy || {});
+function createRequestHandler(options) {
+  const { awsProxy = "APIGatewayV2" /* APIGatewayV2 */, ...opts } = options;
+  switch (awsProxy) {
+    case "APIGatewayV1" /* APIGatewayV1 */:
+      return createAPIGatewayV1RequestHandler(
+        opts
+      );
+    case "APIGatewayV2" /* APIGatewayV2 */:
+      return createAPIGatewayV2RequestHandler(
+        opts
+      );
+    case "ALB" /* ALB */:
+      return createALBRequestHandler(opts);
+    case "FunctionURL" /* FunctionURL */:
+      return createFunctionURLRequestHandler(
+        opts
+      );
+    case "FunctionURLStreaming" /* FunctionURLStreaming */:
+      return createFunctionURLStreamingRequestHandler(
+        opts
+      );
+    default:
+      return assertNever(awsProxy, `Unsupported buffered AWS Proxy type: ${awsProxy}`);
+  }
+}
+function assertNever(x, message) {
+  throw new Error(message);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AWSProxy,
+  createALBRequestHandler,
+  createAPIGatewayV1RequestHandler,
+  createAPIGatewayV2RequestHandler,
+  createFunctionURLRequestHandler,
+  createFunctionURLStreamingRequestHandler,
   createRequestHandler
 });

package/dist/index.mjs

@@ -1,5 +1,5 @@
 /**
-* @geostrategists/react-router-aws v2.0.0
+* @geostrategists/react-router-aws v2.1.0
 *
 * Copyright (c) Geostrategists Consulting GmbH
 *
@@ -10,11 +10,12 @@
 */
 
 // src/server.ts
-import { createRequestHandler as createReactRouterRequestHandler } from "react-router";
+import {
+  createRequestHandler as createReactRouterRequestHandler
+} from "react-router";
 
-// src/adapters/api-gateway-v1.ts
+// src/adapters/api-gateway-v2.ts
 import { readableStreamToString } from "@react-router/node";
-import { URLSearchParams } from "url";
 
 // src/binaryTypes.ts
 var binaryTypes = [
@@ -82,32 +83,38 @@ function isBinaryType(contentType) {
   return binaryTypes.includes(test);
 }
 
-// src/adapters/api-gateway-v1.ts
-function createReactRouterRequestAPIGatewayV1(event) {
-  const host = event.headers["x-forwarded-host"] || event.headers.Host;
+// src/adapters/api-gateway-v2.ts
+function createReactRouterRequestAPIGateywayV2(event) {
+  const host = event.headers["x-forwarded-host"] || event.headers.host;
+  const search = event.rawQueryString.length ? `?${event.rawQueryString}` : "";
   const scheme = event.headers["x-forwarded-proto"] || "http";
-  const rawQueryString = new URLSearchParams(event.queryStringParameters).toString();
-  const search = rawQueryString.length > 0 ? `?${rawQueryString}` : "";
-  const url = new URL(event.path + search, `${scheme}://${host}`);
+  const url = new URL(event.rawPath + search, `${scheme}://${host}`);
   const isFormData = event.headers["content-type"]?.includes("multipart/form-data");
   const controller = new AbortController();
   return new Request(url.href, {
-    method: event.requestContext.httpMethod,
-    headers: createReactRouterHeadersAPIGatewayV1(event.headers),
+    method: event.requestContext.http.method,
+    headers: createReactRouterHeadersAPIGatewayV2(event.headers, event.cookies),
     signal: controller.signal,
-    body: event.body && event.isBase64Encoded ? isFormData ? Buffer.from(event.body, "base64") : Buffer.from(event.body, "base64").toString() : event.body || void 0
+    body: event.body && event.isBase64Encoded ? isFormData ? Buffer.from(event.body, "base64") : Buffer.from(event.body, "base64").toString() : event.body
   });
 }
-function createReactRouterHeadersAPIGatewayV1(requestHeaders) {
+function createReactRouterHeadersAPIGatewayV2(requestHeaders, requestCookies) {
   const headers = new Headers();
   for (const [header, value] of Object.entries(requestHeaders)) {
     if (value) {
       headers.append(header, value);
     }
   }
+  if (requestCookies) {
+    headers.append("Cookie", requestCookies.join("; "));
+  }
   return headers;
 }
-async function sendReactRouterResponseAPIGatewayV1(nodeResponse) {
+async function sendReactRouterResponseAPIGatewayV2(nodeResponse) {
+  const cookies = nodeResponse.headers.getSetCookie();
+  if (cookies.length) {
+    nodeResponse.headers.delete("Set-Cookie");
+  }
   const contentType = nodeResponse.headers.get("Content-Type");
   const isBase64Encoded = isBinaryType(contentType);
   let body;
@@ -121,48 +128,45 @@ async function sendReactRouterResponseAPIGatewayV1(nodeResponse) {
   return {
     statusCode: nodeResponse.status,
     headers: Object.fromEntries(nodeResponse.headers.entries()),
-    body: body || "",
+    cookies,
+    body,
     isBase64Encoded
   };
 }
-var apiGatewayV1Adapter = {
-  createReactRouterRequest: createReactRouterRequestAPIGatewayV1,
-  sendReactRouterResponse: sendReactRouterResponseAPIGatewayV1
+var apiGatewayV2Adapter = {
+  wrapHandler: (handler) => (e) => handler(e),
+  createReactRouterRequest: createReactRouterRequestAPIGateywayV2,
+  sendReactRouterResponse: sendReactRouterResponseAPIGatewayV2
 };
 
-// src/adapters/api-gateway-v2.ts
+// src/adapters/api-gateway-v1.ts
 import { readableStreamToString as readableStreamToString2 } from "@react-router/node";
-function createReactRouterRequestAPIGateywayV2(event) {
-  const host = event.headers["x-forwarded-host"] || event.headers.host;
-  const search = event.rawQueryString.length ? `?${event.rawQueryString}` : "";
+import { URLSearchParams } from "url";
+function createReactRouterRequestAPIGatewayV1(event) {
+  const host = event.headers["x-forwarded-host"] || event.headers.Host;
   const scheme = event.headers["x-forwarded-proto"] || "http";
-  const url = new URL(event.rawPath + search, `${scheme}://${host}`);
+  const rawQueryString = new URLSearchParams(event.queryStringParameters).toString();
+  const search = rawQueryString.length > 0 ? `?${rawQueryString}` : "";
+  const url = new URL(event.path + search, `${scheme}://${host}`);
   const isFormData = event.headers["content-type"]?.includes("multipart/form-data");
   const controller = new AbortController();
   return new Request(url.href, {
-    method: event.requestContext.http.method,
-    headers: createReactRouterHeadersAPIGatewayV2(event.headers, event.cookies),
+    method: event.requestContext.httpMethod,
+    headers: createReactRouterHeadersAPIGatewayV1(event.headers),
     signal: controller.signal,
-    body: event.body && event.isBase64Encoded ? isFormData ? Buffer.from(event.body, "base64") : Buffer.from(event.body, "base64").toString() : event.body
+    body: event.body && event.isBase64Encoded ? isFormData ? Buffer.from(event.body, "base64") : Buffer.from(event.body, "base64").toString() : event.body || void 0
   });
 }
-function createReactRouterHeadersAPIGatewayV2(requestHeaders, requestCookies) {
+function createReactRouterHeadersAPIGatewayV1(requestHeaders) {
   const headers = new Headers();
   for (const [header, value] of Object.entries(requestHeaders)) {
     if (value) {
       headers.append(header, value);
     }
   }
-  if (requestCookies) {
-    headers.append("Cookie", requestCookies.join("; "));
-  }
   return headers;
 }
-async function sendReactRouterResponseAPIGatewayV2(nodeResponse) {
-  const cookies = nodeResponse.headers.getSetCookie();
-  if (cookies.length) {
-    nodeResponse.headers.delete("Set-Cookie");
-  }
+async function sendReactRouterResponseAPIGatewayV1(nodeResponse) {
   const contentType = nodeResponse.headers.get("Content-Type");
   const isBase64Encoded = isBinaryType(contentType);
   let body;
@@ -176,14 +180,14 @@ async function sendReactRouterResponseAPIGatewayV2(nodeResponse) {
   return {
     statusCode: nodeResponse.status,
     headers: Object.fromEntries(nodeResponse.headers.entries()),
-    cookies,
-    body,
+    body: body || "",
     isBase64Encoded
   };
 }
-var apiGatewayV2Adapter = {
-  createReactRouterRequest: createReactRouterRequestAPIGateywayV2,
-  sendReactRouterResponse: sendReactRouterResponseAPIGatewayV2
+var apiGatewayV1Adapter = {
+  wrapHandler: (handler) => (e) => handler(e),
+  createReactRouterRequest: createReactRouterRequestAPIGatewayV1,
+  sendReactRouterResponse: sendReactRouterResponseAPIGatewayV1
 };
 
 // src/adapters/application-load-balancer.ts
@@ -233,54 +237,108 @@ async function sendReactRouterResponseALB(nodeResponse) {
   };
 }
 var applicationLoadBalancerAdapter = {
+  wrapHandler: (handler) => (e) => handler(e),
   createReactRouterRequest: createReactRouterRequestALB,
   sendReactRouterResponse: sendReactRouterResponseALB
 };
 
-// src/adapters/index.ts
-var createReactRouterAdapter = (awsProxy) => {
-  switch (awsProxy) {
-    case "APIGatewayV1" /* APIGatewayV1 */:
-      return apiGatewayV1Adapter;
-    case "APIGatewayV2" /* APIGatewayV2 */:
-    case "FunctionURL" /* FunctionURL */:
-      return apiGatewayV2Adapter;
-    case "ALB" /* ALB */:
-      return applicationLoadBalancerAdapter;
+// src/adapters/function-url-streaming.ts
+import { writeReadableStreamToWritable } from "@react-router/node";
+import stream from "node:stream/promises";
+var sendReactRouterResponseFunctionUrlStreaming = async (response, responseStream) => {
+  const httpResponseStream = awslambda.HttpResponseStream.from(responseStream, {
+    statusCode: response.status,
+    headers: Object.fromEntries(response.headers.entries())
+  });
+  if (response.body) {
+    await writeReadableStreamToWritable(response.body, httpResponseStream);
+  } else {
+    await stream.finished(httpResponseStream);
   }
 };
+var functionUrlStreamingAdapter = {
+  wrapHandler: awslambda.streamifyResponse,
+  createReactRouterRequest: apiGatewayV2Adapter.createReactRouterRequest,
+  sendReactRouterResponse: sendReactRouterResponseFunctionUrlStreaming
+};
 
 // src/server.ts
-var AWSProxy = /* @__PURE__ */ ((AWSProxy2) => {
-  AWSProxy2["APIGatewayV1"] = "APIGatewayV1";
-  AWSProxy2["APIGatewayV2"] = "APIGatewayV2";
-  AWSProxy2["ALB"] = "ALB";
-  AWSProxy2["FunctionURL"] = "FunctionURL";
-  return AWSProxy2;
-})(AWSProxy || {});
-function createRequestHandler({
-  build,
-  getLoadContext,
-  mode = process.env.NODE_ENV,
-  awsProxy = "APIGatewayV2" /* APIGatewayV2 */
-}) {
+function createAPIGatewayV1RequestHandler(options) {
+  return createRequestHandlerForAdapter(apiGatewayV1Adapter, options);
+}
+function createAPIGatewayV2RequestHandler(options) {
+  return createRequestHandlerForAdapter(apiGatewayV2Adapter, options);
+}
+function createALBRequestHandler(options) {
+  return createRequestHandlerForAdapter(applicationLoadBalancerAdapter, options);
+}
+function createFunctionURLRequestHandler(options) {
+  return createRequestHandlerForAdapter(apiGatewayV2Adapter, options);
+}
+function createFunctionURLStreamingRequestHandler(options) {
+  return createRequestHandlerForAdapter(functionUrlStreamingAdapter, options);
+}
+function createRequestHandlerForAdapter(awsAdapter, { build, getLoadContext, mode = process.env.NODE_ENV }) {
   const handleRequest = createReactRouterRequestHandler(build, mode);
-  return async (event) => {
-    const awsAdapter = createReactRouterAdapter(awsProxy);
+  return awsAdapter.wrapHandler(async (event, res) => {
     let request;
     try {
       request = awsAdapter.createReactRouterRequest(event);
     } catch (e) {
-      return awsAdapter.sendReactRouterResponse(
-        new Response(`Bad Request: ${e instanceof Error ? e.message : e}`, { status: 400 })
+      return await awsAdapter.sendReactRouterResponse(
+        new Response(`Bad Request: ${e instanceof Error ? e.message : e}`, { status: 400 }),
+        res
       );
     }
     const loadContext = await getLoadContext?.(event);
     const response = await handleRequest(request, loadContext);
-    return awsAdapter.sendReactRouterResponse(response);
-  };
+    return await awsAdapter.sendReactRouterResponse(response, res);
+  });
+}
+
+// src/legacy.ts
+var AWSProxy = /* @__PURE__ */ ((AWSProxy2) => {
+  AWSProxy2["APIGatewayV1"] = "APIGatewayV1";
+  AWSProxy2["APIGatewayV2"] = "APIGatewayV2";
+  AWSProxy2["ALB"] = "ALB";
+  AWSProxy2["FunctionURL"] = "FunctionURL";
+  AWSProxy2["FunctionURLStreaming"] = "FunctionURLStreaming";
+  return AWSProxy2;
+})(AWSProxy || {});
+function createRequestHandler(options) {
+  const { awsProxy = "APIGatewayV2" /* APIGatewayV2 */, ...opts } = options;
+  switch (awsProxy) {
+    case "APIGatewayV1" /* APIGatewayV1 */:
+      return createAPIGatewayV1RequestHandler(
+        opts
+      );
+    case "APIGatewayV2" /* APIGatewayV2 */:
+      return createAPIGatewayV2RequestHandler(
+        opts
+      );
+    case "ALB" /* ALB */:
+      return createALBRequestHandler(opts);
+    case "FunctionURL" /* FunctionURL */:
+      return createFunctionURLRequestHandler(
+        opts
+      );
+    case "FunctionURLStreaming" /* FunctionURLStreaming */:
+      return createFunctionURLStreamingRequestHandler(
+        opts
+      );
+    default:
+      return assertNever(awsProxy, `Unsupported buffered AWS Proxy type: ${awsProxy}`);
+  }
+}
+function assertNever(x, message) {
+  throw new Error(message);
 }
 export {
   AWSProxy,
+  createALBRequestHandler,
+  createAPIGatewayV1RequestHandler,
+  createAPIGatewayV2RequestHandler,
+  createFunctionURLRequestHandler,
+  createFunctionURLStreamingRequestHandler,
   createRequestHandler
 };

package/eslint.config.mjs

@@ -5,7 +5,7 @@ import tseslint from "typescript-eslint";
 
 export default tseslint.config(
   {
-    ignores: ["dist"],
+    ignores: ["dist", "lib"],
   },
   eslint.configs.recommended,
   tseslint.configs.recommended,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geostrategists/react-router-aws",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "AWS adapter for React Router v7",
   "license": "MIT",
   "bugs": {
@@ -48,7 +48,7 @@
     "@react-router/dev": "^7.3.0",
     "@react-router/node": "^7.3.0",
     "@semantic-release/exec": "^7.0.3",
-    "@types/aws-lambda": "^8.10.125",
+    "@types/aws-lambda": "^8.10.152",
     "@types/node": "^20",
     "eslint": "^9.22.0",
     "husky": "^9.1.7",
@@ -58,10 +58,10 @@
     "react-router": "^7.3.0",
     "semantic-release": "^24.2.3",
     "tsup": "^8.4.0",
-    "typescript": "^5.8.2",
-    "typescript-eslint": "^8.26.1"
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.41.0"
   },
-  "packageManager": "yarn@4.7.0+sha256.293632d8a095d8ea4786eb2c5798c83c37544abed17ed31186a3ec4549a07c06",
+  "packageManager": "yarn@4.9.4+sha512.7b1cb0b62abba6a537b3a2ce00811a843bea02bcf53138581a6ae5b1bf563f734872bd47de49ce32a9ca9dcaff995aa789577ffb16811da7c603dcf69e73750b",
   "release": {
     "plugins": [
       "@semantic-release/commit-analyzer",