@geostrategists/react-router-aws 2.2.1 → 2.3.0-rc.0

package/dist/index.js

@@ -1,378 +0,0 @@
-/**
-* @geostrategists/react-router-aws v2.2.1
-*
-* Copyright (c) Geostrategists Consulting GmbH
-*
-* This source code is licensed under the MIT license found in the
-* LICENSE.md file in the root directory of this source tree.
-*
-* @license MIT
-*/
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-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);
-
-// src/server.ts
-var import_react_router = require("react-router");
-
-// src/adapters/api-gateway-v2.ts
-var import_node = require("@react-router/node");
-
-// src/binaryTypes.ts
-var binaryTypes = [
-  "application/octet-stream",
-  // Docs
-  "application/epub+zip",
-  "application/msword",
-  "application/pdf",
-  "application/rtf",
-  "application/vnd.amazon.ebook",
-  "application/vnd.ms-excel",
-  "application/vnd.ms-powerpoint",
-  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-  // Fonts
-  "font/otf",
-  "font/woff",
-  "font/woff2",
-  // Images
-  "image/avif",
-  "image/bmp",
-  "image/gif",
-  "image/jpeg",
-  "image/png",
-  "image/tiff",
-  "image/vnd.microsoft.icon",
-  "image/webp",
-  // Audio
-  "audio/3gpp",
-  "audio/aac",
-  "audio/basic",
-  "audio/mpeg",
-  "audio/ogg",
-  "audio/wav",
-  "audio/webm",
-  "audio/x-aiff",
-  "audio/x-midi",
-  "audio/x-wav",
-  // Video
-  "video/3gpp",
-  "video/mp2t",
-  "video/mpeg",
-  "video/ogg",
-  "video/quicktime",
-  "video/webm",
-  "video/x-msvideo",
-  // Archives
-  "application/java-archive",
-  "application/vnd.apple.installer+xml",
-  "application/x-7z-compressed",
-  "application/x-apple-diskimage",
-  "application/x-bzip",
-  "application/x-bzip2",
-  "application/x-gzip",
-  "application/x-java-archive",
-  "application/x-rar-compressed",
-  "application/x-tar",
-  "application/x-zip",
-  "application/zip"
-];
-function isBinaryType(contentType) {
-  if (!contentType) return false;
-  const [test] = contentType.split(";");
-  return binaryTypes.includes(test);
-}
-
-// 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 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.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
-  });
-}
-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;
-}
-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");
-  result.isBase64Encoded = isBinaryType(contentType);
-  if (nodeResponse.body) {
-    if (result.isBase64Encoded) {
-      result.body = await (0, import_node.readableStreamToString)(nodeResponse.body, "base64");
-    } else {
-      result.body = await nodeResponse.text();
-    }
-  }
-  return result;
-}
-var apiGatewayV2Adapter = {
-  wrapHandler: (handler) => (e) => handler(e),
-  createReactRouterRequest: createReactRouterRequestAPIGateywayV2,
-  sendReactRouterResponse: sendReactRouterResponseAPIGatewayV2
-};
-
-// src/adapters/api-gateway-v1.ts
-var import_node2 = require("@react-router/node");
-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 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.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 || void 0
-  });
-}
-function createReactRouterHeadersAPIGatewayV1(requestHeaders) {
-  const headers = new Headers();
-  for (const [header, value] of Object.entries(requestHeaders)) {
-    if (value) {
-      headers.append(header, value);
-    }
-  }
-  return headers;
-}
-async function sendReactRouterResponseAPIGatewayV1(nodeResponse) {
-  const contentType = nodeResponse.headers.get("Content-Type");
-  const isBase64Encoded = isBinaryType(contentType);
-  let body;
-  if (nodeResponse.body) {
-    if (isBase64Encoded) {
-      body = await (0, import_node2.readableStreamToString)(nodeResponse.body, "base64");
-    } else {
-      body = await nodeResponse.text();
-    }
-  }
-  return {
-    statusCode: nodeResponse.status,
-    headers: Object.fromEntries(nodeResponse.headers.entries()),
-    body: body || "",
-    isBase64Encoded
-  };
-}
-var apiGatewayV1Adapter = {
-  wrapHandler: (handler) => (e) => handler(e),
-  createReactRouterRequest: createReactRouterRequestAPIGatewayV1,
-  sendReactRouterResponse: sendReactRouterResponseAPIGatewayV1
-};
-
-// src/adapters/application-load-balancer.ts
-var import_node3 = require("@react-router/node");
-var import_url2 = require("url");
-function createReactRouterRequestALB(event) {
-  const headers = event?.headers || {};
-  const host = headers["x-forwarded-host"] || headers.Host;
-  const scheme = headers["x-forwarded-proto"] || "http";
-  const rawQueryString = new import_url2.URLSearchParams(event.queryStringParameters).toString();
-  const search = rawQueryString.length > 0 ? `?${rawQueryString}` : "";
-  const url = new URL(event.path + search, `${scheme}://${host}`);
-  const isFormData = headers["content-type"]?.includes("multipart/form-data");
-  const controller = new AbortController();
-  return new Request(url.href, {
-    method: event.httpMethod,
-    headers: createReactRouterHeadersALB(headers),
-    signal: controller.signal,
-    body: event.body && event.isBase64Encoded ? isFormData ? Buffer.from(event.body, "base64") : Buffer.from(event.body, "base64").toString() : event.body || void 0
-  });
-}
-function createReactRouterHeadersALB(requestHeaders) {
-  const headers = new Headers();
-  for (const [header, value] of Object.entries(requestHeaders)) {
-    if (value) {
-      headers.append(header, value);
-    }
-  }
-  return headers;
-}
-async function sendReactRouterResponseALB(nodeResponse) {
-  const contentType = nodeResponse.headers.get("Content-Type");
-  const isBase64Encoded = isBinaryType(contentType);
-  let body;
-  if (nodeResponse.body) {
-    if (isBase64Encoded) {
-      body = await (0, import_node3.readableStreamToString)(nodeResponse.body, "base64");
-    } else {
-      body = await nodeResponse.text();
-    }
-  }
-  return {
-    statusCode: nodeResponse.status,
-    headers: Object.fromEntries(nodeResponse.headers.entries()),
-    body: body || "",
-    isBase64Encoded
-  };
-}
-var applicationLoadBalancerAdapter = {
-  wrapHandler: (handler) => (e) => handler(e),
-  createReactRouterRequest: createReactRouterRequestALB,
-  sendReactRouterResponse: sendReactRouterResponseALB
-};
-
-// src/adapters/function-url-streaming.ts
-var import_node4 = require("@react-router/node");
-var emptyStream = () => new ReadableStream({
-  start(controller) {
-    controller.enqueue("");
-    controller.close();
-  }
-});
-var sendReactRouterResponseFunctionUrlStreaming = async (response, responseStream) => {
-  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: createReactRouterRequestAPIGateywayV2,
-  sendReactRouterResponse: sendReactRouterResponseFunctionUrlStreaming
-};
-
-// src/server.ts
-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 awsAdapter.wrapHandler(async (event, res) => {
-    let request;
-    try {
-      request = awsAdapter.createReactRouterRequest(event);
-    } catch (e) {
-      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 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/test/alb.test.ts

@@ -1,95 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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=/"],
-    });
-  });
-});