presets(aws-lambda): switch to srvx

src/presets/aws-lambda/runtime/aws-lambda-streaming.ts

@@ -1,53 +1,9 @@
 import "#nitro/virtual/polyfills";
+import { handleLambdaEventWithStream } from "srvx/aws-lambda";
 import { useNitroApp } from "nitro/app";
-import { awsRequest, awsResponseHeaders } from "./_utils.ts";
-
-import type { StreamingResponse } from "@netlify/functions";
-import type { Readable } from "node:stream";
-import type { APIGatewayProxyEventV2 } from "aws-lambda";
 
 const nitroApp = useNitroApp();
 
-export const handler = awslambda.streamifyResponse(
-  async (event: APIGatewayProxyEventV2, responseStream, context) => {
-    const request = awsRequest(event, context);
-
-    const response = await nitroApp.fetch(request);
-
-    const httpResponseMetadata: Omit<StreamingResponse, "body"> = {
-      statusCode: response.status,
-      ...awsResponseHeaders(response),
-    };
-
-    if (!httpResponseMetadata.headers!["transfer-encoding"]) {
-      httpResponseMetadata.headers!["transfer-encoding"] = "chunked";
-    }
-
-    const body =
-      response.body ??
-      new ReadableStream<string>({
-        start(controller) {
-          controller.enqueue("");
-          controller.close();
-        },
-      });
-
-    const writer = awslambda.HttpResponseStream.from(responseStream, httpResponseMetadata);
-
-    const reader = body.getReader();
-    await streamToNodeStream(reader, responseStream);
-    writer.end();
-  }
+export const handler = awslambda.streamifyResponse((event, responseStream, context) =>
+  handleLambdaEventWithStream(nitroApp.fetch, event, responseStream, context)
 );
-
-async function streamToNodeStream(
-  reader: Readable | ReadableStreamDefaultReader,
-  writer: NodeJS.WritableStream
-) {
-  let readResult = await reader.read();
-  while (!readResult.done) {
-    writer.write(readResult.value);
-    readResult = await reader.read();
-  }
-  writer.end();
-}

src/presets/aws-lambda/runtime/aws-lambda.ts

@@ -1,28 +1,12 @@
 import "#nitro/virtual/polyfills";
+import { handleLambdaEvent } from "srvx/aws-lambda";
 import { useNitroApp } from "nitro/app";
-import { awsRequest, awsResponseHeaders, awsResponseBody } from "./_utils.ts";
 
-import type {
-  APIGatewayProxyEvent,
-  APIGatewayProxyEventV2,
-  APIGatewayProxyResult,
-  APIGatewayProxyResultV2,
-  Context,
-} from "aws-lambda";
+import type { AwsLambdaEvent } from "srvx/aws-lambda";
+import type { Context } from "aws-lambda";
 
 const nitroApp = useNitroApp();
 
-export async function handler(
-  event: APIGatewayProxyEvent | APIGatewayProxyEventV2,
-  context: Context
-): Promise<APIGatewayProxyResult | APIGatewayProxyResultV2> {
-  const request = awsRequest(event, context);
-
-  const response = await nitroApp.fetch(request);
-
-  return {
-    statusCode: response.status,
-    ...awsResponseHeaders(response),
-    ...(await awsResponseBody(response)),
-  };
+export async function handler(event: AwsLambdaEvent, context: Context) {
+  return handleLambdaEvent(nitroApp.fetch, event, context);
 }

src/presets/stormkit/runtime/stormkit.ts

@@ -1,6 +1,5 @@
 import "#nitro/virtual/polyfills";
 import { useNitroApp } from "nitro/app";
-import { awsResponseBody } from "../../aws-lambda/runtime/_utils.ts";
 
 import type { Handler } from "aws-lambda";
 import type { ServerRequest } from "srvx";
@@ -39,7 +38,7 @@ export const handler: Handler<StormkitEvent, StormkitResponse> = async function
 
   const response = await nitroApp.fetch(req);
 
-  const { body, isBase64Encoded } = await awsResponseBody(response);
+  const { body, isBase64Encoded } = await encodeResponseBody(response);
 
   return {
     statusCode: response.status,
@@ -53,3 +52,41 @@ function normalizeOutgoingHeaders(headers: Headers): Record<string, string> {
     Object.entries(headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(",") : String(v)])
   );
 }
+
+async function encodeResponseBody(
+  response: Response
+): Promise<{ body: string; isBase64Encoded?: boolean }> {
+  if (!response.body) {
+    return { body: "" };
+  }
+  const buffer = await toBuffer(response.body as any);
+  const contentType = response.headers.get("content-type") || "";
+  return isTextType(contentType)
+    ? { body: buffer.toString("utf8") }
+    : { body: buffer.toString("base64"), isBase64Encoded: true };
+}
+
+function isTextType(contentType = "") {
+  return /^text\/|\/(javascript|json|xml)|utf-?8/i.test(contentType);
+}
+
+function toBuffer(data: ReadableStream): Promise<Buffer> {
+  return new Promise<Buffer>((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    data
+      .pipeTo(
+        new WritableStream({
+          write(chunk) {
+            chunks.push(chunk);
+          },
+          close() {
+            resolve(Buffer.concat(chunks));
+          },
+          abort(reason) {
+            reject(reason);
+          },
+        })
+      )
+      .catch(reject);
+  });
+}