@reckona/mreact-router 0.0.203 → 0.0.205

package/dist/adapters/aws-lambda.js

@@ -1,12 +1,13 @@
-import { Buffer } from "node:buffer";
+import { Buffer, isUtf8 } from "node:buffer";
 import { createHash } from "node:crypto";
 import { access, lstat, mkdir, readFile, readlink, symlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { normalizeBuiltAppRuntimePreloadStrategy, } from "../preload-policy.js";
 import { emitRouterLog, logDurationMs, logError, logNow, requestLogFields, } from "../logger.js";
-import { createBuiltRequestRuntime, preloadBuiltAppRuntime, resolveRequestHost, warnIfImplicitHostTrust, } from "../serve.js";
-const invalidAwsLambdaHttpEventV2Diagnostic = 'Expected an AWS Lambda HTTP API payload format 2.0 event with rawPath and requestContext.http.method.';
+import { createBuiltRequestRuntime, preloadBuiltAppRuntime, resolveRequestHost, } from "../serve.js";
+let warnedImplicitAwsLambdaHostPolicy = false;
+const invalidAwsLambdaHttpEventV2Diagnostic = "Expected an AWS Lambda HTTP API payload format 2.0 event with rawPath and requestContext.http.method.";
 function invalidAwsLambdaHttpEventV2Result() {
     return {
         body: invalidAwsLambdaHttpEventV2Diagnostic,
@@ -27,7 +28,7 @@ function invalidAwsLambdaHttpEventV2Response() {
  * The handler materializes runtime files under `/tmp` by default, starts middleware-focused background preload, applies the generated import policy when requested, and returns API Gateway v2 response objects.
  */
 export function createAwsLambdaRequestHandler(options) {
-    warnIfImplicitHostTrust(options);
+    warnIfImplicitAwsLambdaHostPolicy(options);
     let handler;
     return async (event) => {
         try {
@@ -51,7 +52,7 @@ export function createAwsLambdaRequestHandler(options) {
  * Invalid events are rejected before runtime materialization or preload work begins.
  */
 export async function createPreloadedAwsLambdaRequestHandler(options) {
-    warnIfImplicitHostTrust(options);
+    warnIfImplicitAwsLambdaHostPolicy(options);
     let handler;
     return async (event) => {
         try {
@@ -75,7 +76,7 @@ export async function createPreloadedAwsLambdaRequestHandler(options) {
  * Call this during controlled Lambda initialization only when the extra startup work is preferable to first-valid-request latency. Request handlers always validate events before they start runtime work.
  */
 export async function warmAwsLambdaRuntime(options) {
-    warnIfImplicitHostTrust(options);
+    warnIfImplicitAwsLambdaHostPolicy(options);
     const runtimeDir = await prepareAwsLambdaRuntimeDir(options);
     await preloadAwsLambdaRuntime(options, runtimeDir);
 }
@@ -89,15 +90,17 @@ function createAwsLambdaRequestHandlerFromRuntime(options, runtimeDirPromise, ru
         }
         const startedAt = logNow();
         const phases = createAwsLambdaTimingPhases(options);
-        const eventToRequestStartedAt = phaseStartedAt(phases);
-        const request = eventToRequest(event, options);
-        finishPhase(phases, eventToRequestStartedAt, "eventToRequestMs");
-        const logFields = requestLogFields(request, "aws-lambda");
-        emitRouterLog(options.logger, "info", {
-            ...logFields,
-            type: "router:request:start",
-        });
+        let request;
+        let logFields = awsLambdaEventLogFields(event);
         try {
+            const eventToRequestStartedAt = phaseStartedAt(phases);
+            request = eventToRequest(event, options);
+            finishPhase(phases, eventToRequestStartedAt, "eventToRequestMs");
+            logFields = requestLogFields(request, "aws-lambda");
+            emitRouterLog(options.logger, "info", {
+                ...logFields,
+                type: "router:request:start",
+            });
             const runtimeDirStartedAt = phaseStartedAt(phases);
             const runtimeDir = await runtimeDirPromise;
             finishPhase(phases, runtimeDirStartedAt, "runtimeDirMs");
@@ -112,6 +115,7 @@ function createAwsLambdaRequestHandlerFromRuntime(options, runtimeDirPromise, ru
             });
             const preload = awsLambdaRenderPreload(options, runtimePreloadPromise, defaultPreloadMode);
             const response = await builtRuntime.render(request, {
+                dehydrateOptions: options.dehydrateOptions,
                 instrumentation: options.instrumentation,
                 logger: awsLambdaRenderLogger(options),
                 onResponse: options.onResponse,
@@ -161,7 +165,7 @@ function createAwsLambdaRequestHandlerFromRuntime(options, runtimeDirPromise, ru
  * Use this with Lambda response streaming runtimes when HTML or route responses should be written progressively instead of buffered into an API Gateway result.
  */
 export function createAwsLambdaStreamingRequestHandler(options) {
-    warnIfImplicitHostTrust(options);
+    warnIfImplicitAwsLambdaHostPolicy(options);
     const runtime = awsLambdaRuntime();
     let handler;
     return runtime.streamifyResponse(async (event, responseStream, context) => {
@@ -187,7 +191,7 @@ export function createAwsLambdaStreamingRequestHandler(options) {
  * Invalid events are rejected before runtime materialization or preload work begins.
  */
 export async function createPreloadedAwsLambdaStreamingRequestHandler(options) {
-    warnIfImplicitHostTrust(options);
+    warnIfImplicitAwsLambdaHostPolicy(options);
     const runtime = awsLambdaRuntime();
     let handler;
     return runtime.streamifyResponse(async (event, responseStream, context) => {
@@ -307,15 +311,20 @@ function createAwsLambdaStreamingRequestHandlerFromRuntime(options, runtime, run
         }
         const startedAt = logNow();
         const phases = createAwsLambdaTimingPhases(options);
-        const eventToRequestStartedAt = phaseStartedAt(phases);
-        const request = eventToRequest(event, options);
-        finishPhase(phases, eventToRequestStartedAt, "eventToRequestMs");
-        const logFields = requestLogFields(request, "aws-lambda");
-        emitRouterLog(options.logger, "info", {
-            ...logFields,
-            type: "router:request:start",
-        });
+        const requestAbortController = new AbortController();
+        let request;
+        let requestLifecycle;
+        let logFields = awsLambdaEventLogFields(event);
         try {
+            const eventToRequestStartedAt = phaseStartedAt(phases);
+            request = eventToRequest(event, options, requestAbortController.signal);
+            requestLifecycle = observeLambdaStreamFailure(responseStream, requestAbortController);
+            finishPhase(phases, eventToRequestStartedAt, "eventToRequestMs");
+            logFields = requestLogFields(request, "aws-lambda");
+            emitRouterLog(options.logger, "info", {
+                ...logFields,
+                type: "router:request:start",
+            });
             const runtimeDirStartedAt = phaseStartedAt(phases);
             const runtimeDir = await runtimeDirPromise;
             finishPhase(phases, runtimeDirStartedAt, "runtimeDirMs");
@@ -330,6 +339,7 @@ function createAwsLambdaStreamingRequestHandlerFromRuntime(options, runtime, run
             });
             const preload = awsLambdaRenderPreload(options, runtimePreloadPromise, defaultPreloadMode);
             const response = await builtRuntime.render(request, {
+                dehydrateOptions: options.dehydrateOptions,
                 instrumentation: options.instrumentation,
                 logger: awsLambdaRenderLogger(options),
                 onResponse: options.onResponse,
@@ -341,7 +351,7 @@ function createAwsLambdaStreamingRequestHandlerFromRuntime(options, runtime, run
             });
             finishPhase(phases, renderStartedAt, "renderMs");
             const responseStreamingStartedAt = phaseStartedAt(phases);
-            await streamResponseToLambda(response, responseStream, runtime, phases);
+            await streamResponseToLambda(response, responseStream, runtime, phases, requestAbortController);
             finishPhase(phases, responseStreamingStartedAt, "responseStreamingMs");
             emitRouterLog(options.logger, "info", {
                 ...logFields,
@@ -358,6 +368,9 @@ function createAwsLambdaStreamingRequestHandlerFromRuntime(options, runtime, run
                 error: logError(error),
                 type: "router:request:error",
             });
+            if (requestAbortController.signal.aborted) {
+                return;
+            }
             const payload = options.errorHandler
                 ? options.errorHandler(error)
                 : { body: "Internal Server Error", status: 500 };
@@ -368,11 +381,17 @@ function createAwsLambdaStreamingRequestHandlerFromRuntime(options, runtime, run
                 },
                 status: payload.status,
             }), options, request);
-            await streamResponseToLambda(response, responseStream, runtime, phases);
+            await streamResponseToLambda(response, responseStream, runtime, phases, requestAbortController);
+        }
+        finally {
+            requestLifecycle?.dispose();
         }
     });
 }
 async function applyAwsLambdaResponseHook(response, options, request) {
+    if (request === undefined) {
+        return response;
+    }
     const hooked = await options.onResponse?.(response, { request });
     return hooked instanceof Response ? hooked : response;
 }
@@ -428,7 +447,7 @@ function isNodeErrorCode(error, code) {
         "code" in error &&
         error.code === code);
 }
-function eventToRequest(event, options) {
+function eventToRequest(event, options, signal) {
     validateAwsLambdaHttpEventV2(event);
     const headers = eventHeaders(event);
     const rawHost = lambdaRequestHost(headers, options);
@@ -438,19 +457,51 @@ function eventToRequest(event, options) {
         hostPolicy: lambdaHostPolicy(options),
         rawHost: rawHost ?? undefined,
     });
-    const protocol = lambdaRequestProtocol(event, headers, options);
-    const rawPath = event.rawPath;
-    const rawQueryString = event.rawQueryString === "" ? "" : `?${event.rawQueryString}`;
+    const protocol = lambdaRequestProtocol(headers, options);
     const method = event.requestContext.http.method;
     const init = {
         headers,
         method,
+        ...(signal === undefined ? {} : { signal }),
     };
     if (method !== "GET" && method !== "HEAD" && event.body !== undefined) {
-        init.body =
-            event.isBase64Encoded === true ? Buffer.from(event.body, "base64") : event.body;
+        init.body = event.isBase64Encoded === true ? Buffer.from(event.body, "base64") : event.body;
+    }
+    return new Request(lambdaRequestUrl(protocol, host, event.rawPath, event.rawQueryString), init);
+}
+function lambdaRequestUrl(protocol, host, rawPath, rawQueryString) {
+    if (hasInvalidLambdaRequestAuthorityCharacter(host)) {
+        throw new TypeError("AWS Lambda request Host is not a valid URL authority");
+    }
+    const url = new URL(`${protocol}://${host}`);
+    if (url.protocol !== `${protocol}:` ||
+        url.host === "" ||
+        url.username !== "" ||
+        url.password !== "" ||
+        url.pathname !== "/" ||
+        url.search !== "" ||
+        url.hash !== "") {
+        throw new TypeError("AWS Lambda request Host is not a valid URL authority");
+    }
+    url.pathname = rawPath;
+    url.search = rawQueryString;
+    return url;
+}
+function hasInvalidLambdaRequestAuthorityCharacter(host) {
+    for (const character of host) {
+        const codePoint = character.codePointAt(0) ?? 0;
+        if (character === "/" ||
+            character === "?" ||
+            character === "#" ||
+            character === "\\" ||
+            character === "@" ||
+            character.trim() === "" ||
+            codePoint < 0x20 ||
+            codePoint === 0x7f) {
+            return true;
+        }
     }
-    return new Request(`${protocol}://${host}${rawPath}${rawQueryString}`, init);
+    return false;
 }
 function validateAwsLambdaHttpEventV2(event) {
     const candidate = event;
@@ -462,10 +513,12 @@ function validateAwsLambdaHttpEventV2(event) {
         typeof candidate.rawQueryString !== "string" ||
         typeof candidate.requestContext !== "object" ||
         candidate.requestContext === null ||
-        typeof (candidate.requestContext.http) !== "object" ||
+        typeof candidate.requestContext.http !== "object" ||
         candidate.requestContext.http === null ||
-        typeof (candidate.requestContext.http.method) !== "string" ||
-        candidate.requestContext.http.method === "") {
+        typeof candidate.requestContext.http
+            .method !== "string" ||
+        candidate.requestContext.http.method ===
+            "") {
         throw new Error(invalidAwsLambdaHttpEventV2Diagnostic);
     }
 }
@@ -478,18 +531,34 @@ function lambdaRequestHost(headers, options) {
 function lambdaHostPolicy(options) {
     return options.hostPolicy ?? (process.env.NODE_ENV === "production" ? "strict" : undefined);
 }
-function lambdaRequestProtocol(event, headers, options) {
+function warnIfImplicitAwsLambdaHostPolicy(options) {
+    if (process.env.NODE_ENV !== "production" ||
+        options.allowedHosts !== undefined ||
+        options.hostPolicy !== undefined ||
+        warnedImplicitAwsLambdaHostPolicy) {
+        return;
+    }
+    warnedImplicitAwsLambdaHostPolicy = true;
+    console.error('[mreact] AWS Lambda Host handling defaults to strict because neither allowedHosts nor hostPolicy is configured. Unlisted Host headers use the configured hostname or lambda.local. Set allowedHosts for public deployments or hostPolicy: "trusted-proxy" when a trusted reverse proxy normalizes Host.');
+}
+function lambdaRequestProtocol(headers, options) {
     if (options.trustForwardedProto === true) {
         return normalizeRequestProtocol(firstForwardedValue(headers.get("x-forwarded-proto")));
     }
-    return normalizeRequestProtocol(event.requestContext?.http?.protocol);
+    return "https";
 }
 function normalizeRequestProtocol(value) {
     if (value === undefined || value === "") {
         return "https";
     }
-    const normalized = value.toLowerCase();
-    return normalized === "http" || normalized.startsWith("http/") ? "http" : "https";
+    return value.toLowerCase() === "http" ? "http" : "https";
+}
+function awsLambdaEventLogFields(event) {
+    return {
+        method: event.requestContext.http.method,
+        path: event.rawPath,
+        runtime: "aws-lambda",
+    };
 }
 function eventHeaders(event) {
     const headers = new Headers();
@@ -525,7 +594,7 @@ async function responseToLambdaResult(response, phases) {
     addPhaseDuration(phases, streamDrainStartedAt, "streamDrainMs");
     const bodyEncodeStartedAt = phaseStartedAt(phases);
     const contentType = response.headers.get("content-type");
-    const text = isTextContentType(contentType);
+    const text = isUtf8TextContentType(contentType) && isUtf8(bytes);
     const result = {
         body: text ? bytes.toString("utf8") : bytes.toString("base64"),
         ...(cookies.length === 0 ? {} : { cookies }),
@@ -605,26 +674,58 @@ function emitAwsLambdaTiming(options, logFields, status, startedAt, phases) {
         type: "router:request:timing",
     });
 }
-async function streamResponseToLambda(response, responseStream, runtime, phases) {
+async function streamResponseToLambda(response, responseStream, runtime, phases, requestAbortController) {
+    if (isLambdaStreamingAborted(requestAbortController)) {
+        return;
+    }
     const stream = runtime.HttpResponseStream.from(responseStream, responseStreamingMetadata(response));
+    if (isLambdaStreamingAborted(requestAbortController)) {
+        return;
+    }
     try {
         if (response.body === null) {
             stream.end();
             return;
         }
         const reader = response.body.getReader();
-        while (true) {
-            const streamWaitStartedAt = phaseStartedAt(phases);
-            const result = await reader.read();
-            addPhaseDuration(phases, streamWaitStartedAt, "streamWaitMs");
-            if (result.done) {
-                break;
+        const lifecycle = observeLambdaStreamFailure(stream, requestAbortController);
+        try {
+            while (true) {
+                const streamWaitStartedAt = phaseStartedAt(phases);
+                const result = await readLambdaBodyWithAbort(reader, lifecycle.signal);
+                addPhaseDuration(phases, streamWaitStartedAt, "streamWaitMs");
+                if (lifecycle.signal.aborted) {
+                    throw lambdaAbortReason(lifecycle.signal);
+                }
+                if (result.done) {
+                    break;
+                }
+                const streamWriteStartedAt = phaseStartedAt(phases);
+                await writeStreamingChunk(stream, result.value, lifecycle.signal);
+                addPhaseDuration(phases, streamWriteStartedAt, "streamWriteMs");
+            }
+            if (lifecycle.signal.aborted) {
+                throw lambdaAbortReason(lifecycle.signal);
+            }
+            stream.end();
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error : new Error(String(error));
+            requestAbortController?.abort(reason);
+            try {
+                await reader.cancel(reason);
             }
-            const streamWriteStartedAt = phaseStartedAt(phases);
-            await writeStreamingChunk(stream, result.value);
-            addPhaseDuration(phases, streamWriteStartedAt, "streamWriteMs");
+            catch {
+                // The response body may already be errored or cancelled.
+            }
+            if (stream.destroyed !== true) {
+                stream.destroy?.(reason);
+            }
+        }
+        finally {
+            lifecycle.dispose();
+            reader.releaseLock();
         }
-        stream.end();
     }
     catch (error) {
         if (typeof stream.destroy === "function") {
@@ -634,6 +735,9 @@ async function streamResponseToLambda(response, responseStream, runtime, phases)
         throw error;
     }
 }
+function isLambdaStreamingAborted(controller) {
+    return controller?.signal.aborted === true;
+}
 function responseStreamingMetadata(response) {
     const headers = {};
     response.headers.forEach((value, key) => {
@@ -648,20 +752,116 @@ function responseStreamingMetadata(response) {
         statusCode: response.status,
     };
 }
-async function writeStreamingChunk(stream, chunk) {
-    if (stream.write(chunk) !== false) {
+async function writeStreamingChunk(stream, chunk, signal) {
+    if (signal.aborted) {
+        throw lambdaAbortReason(signal);
+    }
+    const accepted = stream.write(chunk);
+    if (signal.aborted) {
+        throw lambdaAbortReason(signal);
+    }
+    if (accepted !== false) {
         return;
     }
     if (typeof stream.once !== "function") {
         return;
     }
-    await new Promise((resolve) => {
-        stream.once?.("drain", resolve);
+    await new Promise((resolve, reject) => {
+        const dispose = () => {
+            removeLambdaStreamListener(stream, "drain", onDrain);
+            signal.removeEventListener("abort", onAbort);
+        };
+        const onDrain = () => {
+            dispose();
+            resolve();
+        };
+        const onAbort = () => {
+            dispose();
+            reject(lambdaAbortReason(signal));
+        };
+        addLambdaStreamListener(stream, "drain", onDrain);
+        signal.addEventListener("abort", onAbort, { once: true });
     });
 }
+function observeLambdaStreamFailure(stream, abortController = new AbortController()) {
+    let disposed = false;
+    const dispose = () => {
+        if (disposed) {
+            return;
+        }
+        disposed = true;
+        removeLambdaStreamListener(stream, "close", onClose);
+        removeLambdaStreamListener(stream, "error", onError);
+    };
+    const abort = (reason) => {
+        abortController.abort(reason);
+        dispose();
+    };
+    const onClose = () => {
+        if (stream.writableEnded === true) {
+            dispose();
+            return;
+        }
+        abort(new Error("The AWS Lambda response stream closed during streaming."));
+    };
+    const onError = (error) => {
+        abort(error instanceof Error ? error : new Error(String(error ?? "AWS Lambda stream error")));
+    };
+    const canRemoveListeners = typeof stream.off === "function" || typeof stream.removeListener === "function";
+    if (canRemoveListeners) {
+        addLambdaStreamListener(stream, "close", onClose);
+        addLambdaStreamListener(stream, "error", onError);
+    }
+    if (abortController.signal.aborted) {
+        dispose();
+    }
+    else if (stream.destroyed === true && stream.writableEnded !== true) {
+        onClose();
+    }
+    return { dispose, signal: abortController.signal };
+}
+function readLambdaBodyWithAbort(reader, signal) {
+    if (signal.aborted) {
+        return Promise.reject(lambdaAbortReason(signal));
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            signal.removeEventListener("abort", onAbort);
+            reject(lambdaAbortReason(signal));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        void reader.read().then((result) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(result);
+        }, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(error);
+        });
+    });
+}
+function removeLambdaStreamListener(stream, event, listener) {
+    if (typeof stream.off === "function") {
+        stream.off(event, listener);
+        return;
+    }
+    stream.removeListener?.(event, listener);
+}
+function addLambdaStreamListener(stream, event, listener) {
+    const once = stream.once;
+    try {
+        once?.call(stream, event, listener);
+    }
+    catch {
+        // A structurally compatible drain-only stream may reject lifecycle event names.
+    }
+}
+function lambdaAbortReason(signal) {
+    return signal.reason instanceof Error
+        ? signal.reason
+        : new Error("AWS Lambda response streaming was aborted.");
+}
 function awsLambdaRuntime() {
-    const runtime = globalThis
-        .awslambda;
+    const runtime = globalThis.awslambda;
     if (typeof runtime?.streamifyResponse !== "function" ||
         typeof runtime.HttpResponseStream?.from !== "function") {
         throw new Error("AWS Lambda response streaming requires the Node.js Lambda runtime awslambda.streamifyResponse() and awslambda.HttpResponseStream.from().");
@@ -704,18 +904,56 @@ function splitSetCookieHeader(header) {
     cookies.push(header.slice(start).trim());
     return cookies.filter((cookie) => cookie.length > 0);
 }
-function isTextContentType(contentType) {
+function isUtf8TextContentType(contentType) {
     if (contentType === null) {
-        return true;
+        return false;
     }
-    const type = contentType.toLowerCase().split(";")[0]?.trim() ?? "";
-    return (type.startsWith("text/") ||
+    const [rawType = "", ...parameters] = contentType.split(";");
+    const type = rawType.trim().toLowerCase();
+    const textual = type.startsWith("text/") ||
         type === "application/json" ||
         type === "application/javascript" ||
         type === "application/x-javascript" ||
         type === "application/xml" ||
         type === "application/x-www-form-urlencoded" ||
         type.endsWith("+json") ||
-        type.endsWith("+xml"));
+        type.endsWith("+xml");
+    if (!textual) {
+        return false;
+    }
+    let hasCharset = false;
+    for (const parameter of parameters) {
+        const equals = parameter.indexOf("=");
+        const name = (equals === -1 ? parameter : parameter.slice(0, equals)).trim().toLowerCase();
+        if (name !== "charset") {
+            continue;
+        }
+        hasCharset = true;
+        if (equals === -1) {
+            return false;
+        }
+        const value = unquoteContentTypeParameter(parameter.slice(equals + 1).trim()).toLowerCase();
+        if (value !== "utf-8" && value !== "utf8") {
+            return false;
+        }
+    }
+    if (hasCharset) {
+        return true;
+    }
+    return (type === "application/json" ||
+        type === "application/javascript" ||
+        type === "application/x-javascript" ||
+        type === "text/javascript" ||
+        type.endsWith("+json"));
+}
+function unquoteContentTypeParameter(value) {
+    if (value.length < 2) {
+        return value;
+    }
+    const first = value[0];
+    const last = value.at(-1);
+    return (first === '"' && last === '"') || (first === "'" && last === "'")
+        ? value.slice(1, -1)
+        : value;
 }
 //# sourceMappingURL=aws-lambda.js.map