@geostrategists/react-router-aws 2.1.0 → 2.2.0

package/biome.json

@@ -0,0 +1,47 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.2.2/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  },
+  "files": {
+    "ignoreUnknown": false
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "lineWidth": 120
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "double"
+    }
+  },
+  "assist": {
+    "enabled": true,
+    "actions": {
+      "source": {
+        "organizeImports": "on"
+      }
+    }
+  },
+  "overrides": [
+    {
+      "includes": ["test/**"],
+      "linter": {
+        "rules": {
+          "suspicious": {
+            "noExplicitAny": "off"
+          }
+        }
+      }
+    }
+  ]
+}

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { UNSAFE_MiddlewareEnabled, unstable_InitialContext, AppLoadContext, ServerBuild } from 'react-router';
+import { UNSAFE_MiddlewareEnabled, RouterContextProvider, 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';
 
@@ -10,7 +10,7 @@ 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<E> = (event: E) => UNSAFE_MiddlewareEnabled extends true ? MaybePromise<unstable_InitialContext> : MaybePromise<AppLoadContext>;
+type GetLoadContextFunction<E> = (event: E) => UNSAFE_MiddlewareEnabled extends true ? MaybePromise<RouterContextProvider> : MaybePromise<AppLoadContext>;
 type CreateRequestHandlerArgs<T> = {
     build: ServerBuild;
     getLoadContext?: GetLoadContextFunction<T>;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { UNSAFE_MiddlewareEnabled, unstable_InitialContext, AppLoadContext, ServerBuild } from 'react-router';
+import { UNSAFE_MiddlewareEnabled, RouterContextProvider, 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';
 
@@ -10,7 +10,7 @@ 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<E> = (event: E) => UNSAFE_MiddlewareEnabled extends true ? MaybePromise<unstable_InitialContext> : MaybePromise<AppLoadContext>;
+type GetLoadContextFunction<E> = (event: E) => UNSAFE_MiddlewareEnabled extends true ? MaybePromise<RouterContextProvider> : MaybePromise<AppLoadContext>;
 type CreateRequestHandlerArgs<T> = {
     build: ServerBuild;
     getLoadContext?: GetLoadContextFunction<T>;

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
-* @geostrategists/react-router-aws v2.1.0
+* @geostrategists/react-router-aws v2.2.0
 *
 * Copyright (c) Geostrategists Consulting GmbH
 *
@@ -9,11 +9,9 @@
 * @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)
@@ -27,14 +25,6 @@ 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
@@ -149,28 +139,29 @@ function createReactRouterHeadersAPIGatewayV2(requestHeaders, requestCookies) {
   }
   return headers;
 }
-async function sendReactRouterResponseAPIGatewayV2(nodeResponse) {
+function extractAPIGatewayV2ResponseMetadata(nodeResponse) {
   const cookies = nodeResponse.headers.getSetCookie();
   if (cookies.length) {
     nodeResponse.headers.delete("Set-Cookie");
   }
+  return {
+    statusCode: nodeResponse.status,
+    headers: Object.fromEntries(nodeResponse.headers.entries()),
+    cookies
+  };
+}
+async function sendReactRouterResponseAPIGatewayV2(nodeResponse) {
+  const result = extractAPIGatewayV2ResponseMetadata(nodeResponse);
   const contentType = nodeResponse.headers.get("Content-Type");
-  const isBase64Encoded = isBinaryType(contentType);
-  let body;
+  result.isBase64Encoded = isBinaryType(contentType);
   if (nodeResponse.body) {
-    if (isBase64Encoded) {
-      body = await (0, import_node.readableStreamToString)(nodeResponse.body, "base64");
+    if (result.isBase64Encoded) {
+      result.body = await (0, import_node.readableStreamToString)(nodeResponse.body, "base64");
     } else {
-      body = await nodeResponse.text();
+      result.body = await nodeResponse.text();
     }
   }
-  return {
-    statusCode: nodeResponse.status,
-    headers: Object.fromEntries(nodeResponse.headers.entries()),
-    cookies,
-    body,
-    isBase64Encoded
-  };
+  return result;
 }
 var apiGatewayV2Adapter = {
   wrapHandler: (handler) => (e) => handler(e),
@@ -283,21 +274,24 @@ var applicationLoadBalancerAdapter = {
 
 // src/adapters/function-url-streaming.ts
 var import_node4 = require("@react-router/node");
-var import_promises = __toESM(require("stream/promises"));
+var emptyStream = () => new ReadableStream({
+  start(controller) {
+    controller.enqueue("");
+    controller.close();
+  }
+});
 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);
+  const metadata = extractAPIGatewayV2ResponseMetadata(response);
+  let body = response.body;
+  if (!body) {
+    body = emptyStream();
   }
+  const httpResponseStream = awslambda.HttpResponseStream.from(responseStream, metadata);
+  await (0, import_node4.writeReadableStreamToWritable)(body, httpResponseStream);
 };
 var functionUrlStreamingAdapter = {
   wrapHandler: awslambda.streamifyResponse,
-  createReactRouterRequest: apiGatewayV2Adapter.createReactRouterRequest,
+  createReactRouterRequest: createReactRouterRequestAPIGateywayV2,
   sendReactRouterResponse: sendReactRouterResponseFunctionUrlStreaming
 };
 
@@ -369,7 +363,7 @@ function createRequestHandler(options) {
       return assertNever(awsProxy, `Unsupported buffered AWS Proxy type: ${awsProxy}`);
   }
 }
-function assertNever(x, message) {
+function assertNever(_x, message) {
   throw new Error(message);
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/index.mjs

@@ -1,5 +1,5 @@
 /**
-* @geostrategists/react-router-aws v2.1.0
+* @geostrategists/react-router-aws v2.2.0
 *
 * Copyright (c) Geostrategists Consulting GmbH
 *
@@ -110,28 +110,29 @@ function createReactRouterHeadersAPIGatewayV2(requestHeaders, requestCookies) {
   }
   return headers;
 }
-async function sendReactRouterResponseAPIGatewayV2(nodeResponse) {
+function extractAPIGatewayV2ResponseMetadata(nodeResponse) {
   const cookies = nodeResponse.headers.getSetCookie();
   if (cookies.length) {
     nodeResponse.headers.delete("Set-Cookie");
   }
+  return {
+    statusCode: nodeResponse.status,
+    headers: Object.fromEntries(nodeResponse.headers.entries()),
+    cookies
+  };
+}
+async function sendReactRouterResponseAPIGatewayV2(nodeResponse) {
+  const result = extractAPIGatewayV2ResponseMetadata(nodeResponse);
   const contentType = nodeResponse.headers.get("Content-Type");
-  const isBase64Encoded = isBinaryType(contentType);
-  let body;
+  result.isBase64Encoded = isBinaryType(contentType);
   if (nodeResponse.body) {
-    if (isBase64Encoded) {
-      body = await readableStreamToString(nodeResponse.body, "base64");
+    if (result.isBase64Encoded) {
+      result.body = await readableStreamToString(nodeResponse.body, "base64");
     } else {
-      body = await nodeResponse.text();
+      result.body = await nodeResponse.text();
     }
   }
-  return {
-    statusCode: nodeResponse.status,
-    headers: Object.fromEntries(nodeResponse.headers.entries()),
-    cookies,
-    body,
-    isBase64Encoded
-  };
+  return result;
 }
 var apiGatewayV2Adapter = {
   wrapHandler: (handler) => (e) => handler(e),
@@ -244,21 +245,24 @@ var applicationLoadBalancerAdapter = {
 
 // src/adapters/function-url-streaming.ts
 import { writeReadableStreamToWritable } from "@react-router/node";
-import stream from "node:stream/promises";
+var emptyStream = () => new ReadableStream({
+  start(controller) {
+    controller.enqueue("");
+    controller.close();
+  }
+});
 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);
+  const metadata = extractAPIGatewayV2ResponseMetadata(response);
+  let body = response.body;
+  if (!body) {
+    body = emptyStream();
   }
+  const httpResponseStream = awslambda.HttpResponseStream.from(responseStream, metadata);
+  await writeReadableStreamToWritable(body, httpResponseStream);
 };
 var functionUrlStreamingAdapter = {
   wrapHandler: awslambda.streamifyResponse,
-  createReactRouterRequest: apiGatewayV2Adapter.createReactRouterRequest,
+  createReactRouterRequest: createReactRouterRequestAPIGateywayV2,
   sendReactRouterResponse: sendReactRouterResponseFunctionUrlStreaming
 };
 
@@ -330,7 +334,7 @@ function createRequestHandler(options) {
       return assertNever(awsProxy, `Unsupported buffered AWS Proxy type: ${awsProxy}`);
   }
 }
-function assertNever(x, message) {
+function assertNever(_x, message) {
   throw new Error(message);
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geostrategists/react-router-aws",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "AWS adapter for React Router v7",
   "license": "MIT",
   "bugs": {
@@ -29,37 +29,46 @@
     "./package.json": "./package.json"
   },
   "scripts": {
-    "lint": "eslint .",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
+    "lint": "biome lint .",
+    "format": "biome format --write .",
+    "format:check": "biome format .",
     "typecheck": "tsc --noEmit",
     "build": "tsc && tsup",
     "prepack": "yarn build && yarn npmignore --auto",
     "prepare": "husky",
-    "release": "semantic-release"
+    "release": "semantic-release",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "peerDependencies": {
-    "@react-router/dev": "^7.3.0",
-    "@react-router/node": "^7.3.0",
-    "react-router": "^7.3.0"
+    "@react-router/dev": "^7.9.1",
+    "@react-router/node": "^7.9.1",
+    "react-router": "^7.9.1"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.2.2",
     "@eslint/js": "^9.22.0",
-    "@react-router/dev": "^7.3.0",
-    "@react-router/node": "^7.3.0",
+    "@react-router/dev": "^7.9.1",
+    "@react-router/node": "^7.9.1",
     "@semantic-release/exec": "^7.0.3",
     "@types/aws-lambda": "^8.10.152",
-    "@types/node": "^20",
+    "@types/node": "^20.19.17",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "@vitest/coverage-v8": "^3.2.4",
     "eslint": "^9.22.0",
     "husky": "^9.1.7",
     "lint-staged": "^15.5.0",
     "npmignore": "^0.3.1",
     "prettier": "3.5.3",
-    "react-router": "^7.3.0",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "react-router": "^7.9.1",
     "semantic-release": "^24.2.3",
     "tsup": "^8.4.0",
     "typescript": "^5.9.2",
-    "typescript-eslint": "^8.41.0"
+    "typescript-eslint": "^8.41.0",
+    "vitest": "^3.2.4"
   },
   "packageManager": "yarn@4.9.4+sha512.7b1cb0b62abba6a537b3a2ce00811a843bea02bcf53138581a6ae5b1bf563f734872bd47de49ce32a9ca9dcaff995aa789577ffb16811da7c603dcf69e73750b",
   "release": {

package/test/alb.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect } from "vitest";
+import { htmlResponse, redirectResponse, invokeHandlerWithRRMock } from "./utils";
+import type { ALBEvent } from "aws-lambda";
+
+function albEvent(path: string, method = "GET", headers: Record<string, string> = {}): ALBEvent {
+  return {
+    requestContext: {} as ALBEvent["requestContext"],
+    httpMethod: method,
+    path,
+    queryStringParameters: {},
+    headers: {
+      Host: "example.com",
+      "x-forwarded-proto": "https",
+      ...headers,
+    },
+    body: null,
+    isBase64Encoded: false,
+  };
+}
+
+describe("ALB request handling", () => {
+  it("parses ALB event", async () => {
+    await invokeHandlerWithRRMock(
+      "createALBRequestHandler",
+      async (request: Request) => {
+        expect(request.url).toBe("https://example.com/test");
+        expect(request.method).toBe("POST");
+        expect(request.headers.get("x-custom-header")).toBe("a");
+        return new Response("ok");
+      },
+      albEvent("/test", "POST", { "x-custom-header": "a" }),
+    );
+  });
+});
+
+describe("ALB response handling", () => {
+  it("html without cookie", async () => {
+    const res = await invokeHandlerWithRRMock("createALBRequestHandler", () => htmlResponse(), albEvent("/html"));
+
+    expect(res).toStrictEqual({
+      statusCode: 200,
+      headers: {
+        "content-type": "text/html",
+      },
+      body: "<html>ok</html>",
+      isBase64Encoded: false,
+    });
+  });
+
+  it("html with cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createALBRequestHandler",
+      () => htmlResponse("a=1; Path=/"),
+      albEvent("/html"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 200,
+      headers: {
+        "content-type": "text/html",
+        "set-cookie": "a=1; Path=/",
+      },
+      body: "<html>ok</html>",
+      isBase64Encoded: false,
+    });
+  });
+
+  it("redirect without cookie", async () => {
+    const res = await invokeHandlerWithRRMock("createALBRequestHandler", () => redirectResponse(), albEvent("/redir"));
+    expect(res).toStrictEqual({
+      statusCode: 302,
+      headers: {
+        location: "https://example.com/next",
+      },
+      body: "",
+      isBase64Encoded: false,
+    });
+  });
+
+  it("redirect with cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createALBRequestHandler",
+      () => redirectResponse("b=2; Path=/"),
+      albEvent("/redir"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 302,
+      headers: {
+        location: "https://example.com/next",
+        "set-cookie": "b=2; Path=/",
+      },
+      body: "",
+      isBase64Encoded: false,
+    });
+  });
+});

package/test/apigw-v1.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect } from "vitest";
+import { htmlResponse, redirectResponse, invokeHandlerWithRRMock } from "./utils";
+import type { APIGatewayProxyEvent } from "aws-lambda";
+
+function apiGatewayV1Event(path: string, method = "GET", headers: Record<string, string> = {}): APIGatewayProxyEvent {
+  return {
+    requestContext: { httpMethod: method } as APIGatewayProxyEvent["requestContext"],
+    path,
+    queryStringParameters: {},
+    headers: {
+      Host: "example.com",
+      "x-forwarded-proto": "https",
+      ...headers,
+    },
+    body: null,
+    isBase64Encoded: false,
+  } as Partial<APIGatewayProxyEvent> as APIGatewayProxyEvent;
+}
+
+describe("API Gateway v1 request handling", () => {
+  it("parses API Gateway v1 event", async () => {
+    await invokeHandlerWithRRMock(
+      "createAPIGatewayV1RequestHandler",
+      (request) => {
+        expect(request.url).toBe("https://example.com/test");
+        expect(request.method).toBe("POST");
+        expect(request.headers.get("x-custom-header")).toBe("a");
+        return new Response("ok");
+      },
+      apiGatewayV1Event("/test", "POST", { "x-custom-header": "a" }),
+    );
+  });
+});
+
+describe("API Gateway v1 response handling", () => {
+  it("html without cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createAPIGatewayV1RequestHandler",
+      () => htmlResponse(),
+      apiGatewayV1Event("/html"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 200,
+      headers: {
+        "content-type": "text/html",
+      },
+      body: "<html>ok</html>",
+      isBase64Encoded: false,
+    });
+  });
+
+  it("html with cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createAPIGatewayV1RequestHandler",
+      () => htmlResponse("a=1; Path=/"),
+      apiGatewayV1Event("/html"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 200,
+      headers: {
+        "content-type": "text/html",
+        "set-cookie": "a=1; Path=/",
+      },
+      body: "<html>ok</html>",
+      isBase64Encoded: false,
+    });
+  });
+
+  it("redirect without cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createAPIGatewayV1RequestHandler",
+      () => redirectResponse(),
+      apiGatewayV1Event("/redir"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 302,
+      headers: {
+        location: "https://example.com/next",
+      },
+      body: "",
+      isBase64Encoded: false,
+    });
+  });
+
+  it("redirect with cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createAPIGatewayV1RequestHandler",
+      () => redirectResponse("b=2; Path=/"),
+      apiGatewayV1Event("/redir"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 302,
+      headers: {
+        location: "https://example.com/next",
+        "set-cookie": "b=2; Path=/",
+      },
+      body: "",
+      isBase64Encoded: false,
+    });
+  });
+});

package/test/apigw-v2.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it } from "vitest";
+import { htmlResponse, invokeHandlerWithRRMock, redirectResponse } from "./utils";
+import type { APIGatewayProxyEventV2 } from "aws-lambda";
+
+function apiGatewayV2Event(
+  path: string,
+  method = "GET",
+  headers: Record<string, string> = {},
+  cookies?: string[],
+): APIGatewayProxyEventV2 {
+  return {
+    requestContext: { http: { method } } as APIGatewayProxyEventV2["requestContext"],
+    rawPath: path,
+    rawQueryString: "",
+    headers: {
+      host: "example.com",
+      "x-forwarded-proto": "https",
+      ...headers,
+    },
+    cookies,
+    body: undefined,
+    isBase64Encoded: false,
+  } as Partial<APIGatewayProxyEventV2> as APIGatewayProxyEventV2;
+}
+
+describe("API Gateway v2 request handling", () => {
+  it("parses API Gateway v2 event", async () => {
+    await invokeHandlerWithRRMock(
+      "createAPIGatewayV2RequestHandler",
+      (request) => {
+        expect(request.url).toBe("https://example.com/test");
+        expect(request.method).toBe("POST");
+        expect(request.headers.get("x-custom-header")).toBe("a");
+        return new Response("ok");
+      },
+      apiGatewayV2Event("/test", "POST", { "x-custom-header": "a" }),
+    );
+  });
+});
+
+describe("API Gateway v2 response handling", () => {
+  it("html without cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createAPIGatewayV2RequestHandler",
+      () => htmlResponse(),
+      apiGatewayV2Event("/html"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 200,
+      headers: {
+        "content-type": "text/html",
+      },
+      body: "<html>ok</html>",
+      isBase64Encoded: false,
+      cookies: [],
+    });
+  });
+
+  it("html with cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createAPIGatewayV2RequestHandler",
+      () => htmlResponse("a=1; Path=/"),
+      apiGatewayV2Event("/html"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 200,
+      headers: {
+        "content-type": "text/html",
+      },
+      body: "<html>ok</html>",
+      isBase64Encoded: false,
+      cookies: ["a=1; Path=/"],
+    });
+  });
+
+  it("redirect without cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createAPIGatewayV2RequestHandler",
+      () => redirectResponse(),
+      apiGatewayV2Event("/redir"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 302,
+      headers: {
+        location: "https://example.com/next",
+      },
+      isBase64Encoded: false,
+      cookies: [],
+    });
+  });
+
+  it("redirect with cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createAPIGatewayV2RequestHandler",
+      () => redirectResponse("b=2; Path=/"),
+      apiGatewayV2Event("/redir"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 302,
+      headers: {
+        location: "https://example.com/next",
+      },
+      isBase64Encoded: false,
+      cookies: ["b=2; Path=/"],
+    });
+  });
+});

package/test/function-url-streaming.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it } from "vitest";
+import { htmlResponse, invokeHandlerWithRRMock, redirectResponse } from "./utils";
+import type { LambdaFunctionURLEvent } from "aws-lambda";
+
+function lambdaFunctionUrlEvent(
+  path: string,
+  method = "GET",
+  headers: Record<string, string> = {},
+  cookies?: string[],
+): LambdaFunctionURLEvent {
+  return {
+    requestContext: { http: { method } } as LambdaFunctionURLEvent["requestContext"],
+    rawPath: path,
+    rawQueryString: "",
+    headers: {
+      host: "example.com",
+      "x-forwarded-proto": "https",
+      ...headers,
+    },
+    cookies,
+    body: undefined,
+    isBase64Encoded: false,
+  } as Partial<LambdaFunctionURLEvent> as LambdaFunctionURLEvent;
+}
+
+describe("Function URL streaming request handling", () => {
+  it("parses Function URL event", async () => {
+    await invokeHandlerWithRRMock(
+      "createFunctionURLStreamingRequestHandler",
+      (request) => {
+        expect(request.url).toBe("https://example.com/test");
+        expect(request.method).toBe("POST");
+        expect(request.headers.get("x-custom-header")).toBe("a");
+        return new Response("ok");
+      },
+      lambdaFunctionUrlEvent("/test", "POST", { "x-custom-header": "a" }),
+    );
+  });
+});
+
+describe("Function URL streaming response handling", () => {
+  it("html without cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createFunctionURLStreamingRequestHandler",
+      () => htmlResponse(),
+      lambdaFunctionUrlEvent("/html"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 200,
+      headers: {
+        "content-type": "text/html",
+      },
+      body: "<html>ok</html>",
+      cookies: [],
+    });
+  });
+
+  it("html with cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createFunctionURLStreamingRequestHandler",
+      () => htmlResponse("a=1; Path=/"),
+      lambdaFunctionUrlEvent("/html"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 200,
+      headers: {
+        "content-type": "text/html",
+      },
+      body: "<html>ok</html>",
+      cookies: ["a=1; Path=/"],
+    });
+  });
+
+  it("redirect without cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createFunctionURLStreamingRequestHandler",
+      () => redirectResponse(),
+      lambdaFunctionUrlEvent("/redir"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 302,
+      headers: {
+        location: "https://example.com/next",
+      },
+      cookies: [],
+      // empty body gets added to provoke a write on the stream
+      body: "",
+    });
+  });
+
+  it("redirect with cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createFunctionURLStreamingRequestHandler",
+      () => redirectResponse("b=2; Path=/"),
+      lambdaFunctionUrlEvent("/redir"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 302,
+      headers: {
+        location: "https://example.com/next",
+      },
+      cookies: ["b=2; Path=/"],
+      // empty body gets added to provoke a write on the stream
+      body: "",
+    });
+  });
+});

package/test/function-url.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it } from "vitest";
+import { htmlResponse, invokeHandlerWithRRMock, redirectResponse } from "./utils";
+import type { LambdaFunctionURLEvent } from "aws-lambda";
+
+function lambdaFunctionUrlEvent(
+  path: string,
+  method = "GET",
+  headers: Record<string, string> = {},
+  cookies?: string[],
+): LambdaFunctionURLEvent {
+  return {
+    requestContext: { http: { method } } as LambdaFunctionURLEvent["requestContext"],
+    rawPath: path,
+    rawQueryString: "",
+    headers: {
+      host: "example.com",
+      "x-forwarded-proto": "https",
+      ...headers,
+    },
+    cookies,
+    body: undefined,
+    isBase64Encoded: false,
+  } as Partial<LambdaFunctionURLEvent> as LambdaFunctionURLEvent;
+}
+
+describe("Function URL request handling", () => {
+  it("parses Function URL event", async () => {
+    await invokeHandlerWithRRMock(
+      "createFunctionURLRequestHandler",
+      (request) => {
+        expect(request.url).toBe("https://example.com/test");
+        expect(request.method).toBe("POST");
+        expect(request.headers.get("x-custom-header")).toBe("a");
+        return new Response("ok");
+      },
+      lambdaFunctionUrlEvent("/test", "POST", { "x-custom-header": "a" }),
+    );
+  });
+});
+
+describe("Function URL buffered response handling", () => {
+  it("html without cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createFunctionURLRequestHandler",
+      () => htmlResponse(),
+      lambdaFunctionUrlEvent("/html"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 200,
+      headers: {
+        "content-type": "text/html",
+      },
+      body: "<html>ok</html>",
+      isBase64Encoded: false,
+      cookies: [],
+    });
+  });
+
+  it("html with cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createFunctionURLRequestHandler",
+      () => htmlResponse("a=1; Path=/"),
+      lambdaFunctionUrlEvent("/html"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 200,
+      headers: {
+        "content-type": "text/html",
+      },
+      body: "<html>ok</html>",
+      isBase64Encoded: false,
+      cookies: ["a=1; Path=/"],
+    });
+  });
+
+  it("redirect without cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createFunctionURLRequestHandler",
+      () => redirectResponse(),
+      lambdaFunctionUrlEvent("/redir"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 302,
+      headers: {
+        location: "https://example.com/next",
+      },
+      isBase64Encoded: false,
+      cookies: [],
+    });
+  });
+
+  it("redirect with cookie", async () => {
+    const res = await invokeHandlerWithRRMock(
+      "createFunctionURLRequestHandler",
+      () => redirectResponse("b=2; Path=/"),
+      lambdaFunctionUrlEvent("/redir"),
+    );
+    expect(res).toStrictEqual({
+      statusCode: 302,
+      headers: {
+        location: "https://example.com/next",
+      },
+      isBase64Encoded: false,
+      cookies: ["b=2; Path=/"],
+    });
+  });
+});

package/test/lambda-stream/HttpResponseStream.ts

@@ -0,0 +1,34 @@
+// biome-ignore-all lint: keep close to upstream
+/**
+ * Copyright 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * HttpResponseStream is NOT used by the runtime.
+ * It is only exposed in the `awslambda` variable for customers to use.
+ */
+
+// based on https://github.com/aws/aws-lambda-nodejs-runtime-interface-client/blob/main/src/HttpResponseStream.js
+// which is licensed under Apache License 2.0
+
+import type { ResponseStream } from "./ResponseStream";
+
+const METADATA_PRELUDE_CONTENT_TYPE = "application/vnd.awslambda.http-integration-response";
+const DELIMITER_LEN = 8;
+
+// Implements the application/vnd.awslambda.http-integration-response content type.
+export class HttpResponseStream {
+  static from(underlyingStream: ResponseStream, prelude: unknown) {
+    underlyingStream.setContentType(METADATA_PRELUDE_CONTENT_TYPE);
+
+    // JSON.stringify is required. NULL byte is not allowed in metadataPrelude.
+    const metadataPrelude = JSON.stringify(prelude);
+
+    underlyingStream._onBeforeFirstWrite = (write) => {
+      write(metadataPrelude);
+
+      // Write 8 null bytes after the JSON prelude.
+      write(new Uint8Array(DELIMITER_LEN));
+    };
+
+    return underlyingStream;
+  }
+}

package/test/lambda-stream/ResponseStream.ts

@@ -0,0 +1,44 @@
+import { Stream } from "node:stream";
+
+// based on https://github.com/astuyve/lambda-stream/blob/main/src/ResponseStream.ts
+// which is MIT licensed according to https://www.npmjs.com/package/lambda-stream
+
+export class ResponseStream extends Stream.Writable {
+  private response: Buffer[];
+  _contentType?: string;
+  _isBase64Encoded?: boolean;
+  _onBeforeFirstWrite?: (write: (chunk: string | Uint8Array) => void) => void;
+  _firstWriteHappened?: boolean = false;
+
+  constructor() {
+    super();
+    this.response = [];
+  }
+
+  write(chunk: any, encoding: any, callback?: any): boolean {
+    if (!this._firstWriteHappened) {
+      this._firstWriteHappened = true;
+      this._onBeforeFirstWrite?.(super.write.bind(this));
+    }
+    return super.write(chunk, encoding, callback);
+  }
+
+  // @param chunk Chunk of data to unshift onto the read queue. For streams not operating in object mode, `chunk` must be a string, `Buffer`, `Uint8Array` or `null`. For object mode
+  // streams, `chunk` may be any JavaScript value.
+  _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void {
+    this.response.push(Buffer.from(chunk, encoding));
+    callback();
+  }
+
+  getBufferedData(): Buffer {
+    return Buffer.concat(this.response);
+  }
+
+  setContentType(contentType: string) {
+    this._contentType = contentType;
+  }
+
+  setIsBase64Encoded(isBase64Encoded: boolean) {
+    this._isBase64Encoded = isBase64Encoded;
+  }
+}

package/test/lambda-stream/index.ts

@@ -0,0 +1,56 @@
+// based on https://github.com/astuyve/lambda-stream/blob/main/src/index.ts
+// which is MIT licensed according to https://www.npmjs.com/package/lambda-stream
+
+import type { StreamifyHandler } from "aws-lambda";
+import { ResponseStream } from "./ResponseStream";
+import { HttpResponseStream } from "./HttpResponseStream";
+
+export function streamifyResponse<TEvent = any, TResult = void>(
+  handler: StreamifyHandler<TEvent, TResult>,
+): StreamifyHandler<TEvent, TResult> {
+  // Check for global awslambda
+  return new Proxy(handler, {
+    apply: async (target, _, argList: Parameters<StreamifyHandler<TEvent, TResult>>) => {
+      const responseStream: ResponseStream = patchArgs(argList);
+      await target(...argList);
+
+      const bodyAndPrelude = responseStream._isBase64Encoded
+        ? responseStream.getBufferedData().toString("base64")
+        : responseStream.getBufferedData().toString();
+
+      const delim = "\0".repeat(8);
+      const delimPos = bodyAndPrelude.indexOf(delim);
+      if (delimPos === -1) {
+        return {
+          statusCode: 200,
+          headers: {
+            "content-type": responseStream._contentType ?? "application/json",
+          },
+          cookies: [],
+          body: bodyAndPrelude,
+        };
+      } else {
+        const prelude = bodyAndPrelude.slice(0, delimPos);
+        const body = bodyAndPrelude.slice(delimPos + delim.length);
+        const parsedPrelude = JSON.parse(prelude);
+        return {
+          ...parsedPrelude,
+          body,
+        };
+      }
+    },
+  });
+}
+
+function patchArgs(argList: any[]): ResponseStream {
+  if (!(argList[1] instanceof ResponseStream)) {
+    const responseStream = new ResponseStream();
+    argList.splice(1, 0, responseStream);
+  }
+  return argList[1];
+}
+
+export const awslambda = {
+  HttpResponseStream: HttpResponseStream,
+  streamifyResponse: streamifyResponse,
+};

package/test/setup.ts

@@ -0,0 +1,7 @@
+import { vi } from "vitest";
+import { awslambda } from "./lambda-stream";
+
+vi.mock("react", () => ({}));
+vi.mock("react/jsx-runtime", () => ({}));
+
+vi.stubGlobal("awslambda", awslambda);

package/test/utils.ts

@@ -0,0 +1,69 @@
+import { vi } from "vitest";
+import type { Context, Handler } from "aws-lambda";
+
+import type { ServerBuild } from "react-router";
+
+let currentRRHandler: RRHandler | null = null;
+export function setReactRouterHandler(fn: RRHandler) {
+  currentRRHandler = fn;
+}
+vi.mock("react-router", () => {
+  return {
+    createRequestHandler: () => {
+      if (!currentRRHandler) throw new Error("React Router handler not set");
+      return currentRRHandler;
+    },
+  };
+});
+
+type ReactRouterAws = typeof import("../src");
+type GatewayHandlers = Pick<
+  ReactRouterAws,
+  | "createALBRequestHandler"
+  | "createAPIGatewayV1RequestHandler"
+  | "createAPIGatewayV2RequestHandler"
+  | "createFunctionURLRequestHandler"
+  | "createFunctionURLStreamingRequestHandler"
+>;
+
+type RRHandler = (request: Request) => Response | Promise<Response>;
+
+export async function createHandlerWithRRMock<T extends keyof GatewayHandlers>(
+  gatewayHandler: T,
+  handler: RRHandler,
+): Promise<GatewayHandlers[T]> {
+  setReactRouterHandler(handler);
+  const handlerFactory = (await import("../src"))[gatewayHandler] as any;
+  return handlerFactory({ build: {} as unknown as ServerBuild });
+}
+
+export async function invokeHandlerWithRRMock<T extends keyof GatewayHandlers>(
+  gatewayHandler: T,
+  rrHandler: RRHandler,
+  event: Parameters<ReturnType<GatewayHandlers[T]>>[0],
+) {
+  const handler = await createHandlerWithRRMock(gatewayHandler, rrHandler);
+  return invokeHandler(handler as any, event);
+}
+
+export async function invokeHandler<E, R>(handler: Handler<E, R>, event: E): Promise<R> {
+  return (await handler(event, {} as unknown as Context, () => {
+    throw new Error("Callback not supported");
+  })) as R;
+}
+
+export function htmlResponse(setCookie?: string) {
+  const headers = new Headers({ "Content-Type": "text/html" });
+  if (setCookie) {
+    headers.append("Set-Cookie", setCookie);
+  }
+  return new Response("<html>ok</html>", { status: 200, headers });
+}
+
+export function redirectResponse(setCookie?: string) {
+  const headers = new Headers({ Location: "https://example.com/next" });
+  if (setCookie) {
+    headers.append("Set-Cookie", setCookie);
+  }
+  return new Response(null, { status: 302, headers });
+}

package/vitest.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+    include: ["test/**/*.test.ts"],
+    setupFiles: ["./test/setup.ts"],
+    coverage: {
+      reporter: ["text", "lcov"],
+    },
+  },
+});

package/eslint.config.mjs

@@ -1,12 +0,0 @@
-// @ts-check
-
-import eslint from "@eslint/js";
-import tseslint from "typescript-eslint";
-
-export default tseslint.config(
-  {
-    ignores: ["dist", "lib"],
-  },
-  eslint.configs.recommended,
-  tseslint.configs.recommended,
-);