@jaypie/express 1.2.9 → 1.2.11-dev.0

package/dist/cjs/adapter/LambdaResponseStreaming.d.ts

@@ -1,6 +1,7 @@
 import type { OutgoingHttpHeaders } from "node:http";
 import { Writable } from "node:stream";
 import type { ResponseStream } from "./types.js";
+export declare const JAYPIE_LAMBDA_STREAMING: unique symbol;
 /**
  * Mock ServerResponse that streams directly to Lambda responseStream.
  * Uses awslambda.HttpResponseStream.from() to set status and headers.

package/dist/cjs/index.cjs

@@ -626,6 +626,9 @@ class LambdaResponseBuffered extends node_stream.Writable {
 //
 // Constants
 //
+// Symbol to identify Lambda streaming responses. Uses Symbol.for() to ensure
+// the same symbol is used across bundles/realms. Survives prototype manipulation.
+const JAYPIE_LAMBDA_STREAMING = Symbol.for("@jaypie/express/LambdaStreaming");
 // Get Node's internal kOutHeaders symbol from ServerResponse prototype.
 // This is needed for compatibility with Datadog dd-trace instrumentation,
 // which patches HTTP methods and expects this internal state to exist.
@@ -654,6 +657,14 @@ class LambdaResponseStreaming extends node_stream.Writable {
         this._pendingWrites = [];
         this._wrappedStream = null;
         this._responseStream = responseStream;
+        // Mark as Lambda streaming response using Symbol for reliable detection.
+        // Survives prototype manipulation from Express and dd-trace.
+        this[JAYPIE_LAMBDA_STREAMING] =
+            true;
+        // DIAGNOSTIC: Log symbol assignment
+        console.log("[DIAG:LambdaResponseStreaming:constructor] Symbol set", {
+            symbolValue: this[JAYPIE_LAMBDA_STREAMING],
+        });
         // Initialize Node's internal kOutHeaders for dd-trace compatibility.
         // dd-trace patches HTTP methods and expects this internal state.
         if (kOutHeaders) {
@@ -841,8 +852,17 @@ class LambdaResponseStreaming extends node_stream.Writable {
         return this._headersSent;
     }
     flushHeaders() {
-        if (this._headersSent)
+        // DIAGNOSTIC: Log every flushHeaders call with stack trace
+        const caller = new Error().stack?.split("\n").slice(1, 5).join("\n");
+        console.log("[DIAG:LambdaResponseStreaming:flushHeaders] Called", {
+            statusCode: this.statusCode,
+            headersSent: this._headersSent,
+            caller,
+        });
+        if (this._headersSent) {
+            console.log("[DIAG:LambdaResponseStreaming:flushHeaders] Already sent, returning early");
             return;
+        }
         const headers = {};
         for (const [key, value] of this._headers) {
             headers[key] = Array.isArray(value) ? value.join(", ") : String(value);
@@ -851,6 +871,10 @@ class LambdaResponseStreaming extends node_stream.Writable {
             headers,
             statusCode: this.statusCode,
         };
+        // DIAGNOSTIC: Log what we're sending to Lambda
+        console.log("[DIAG:LambdaResponseStreaming:flushHeaders] Creating wrapped stream", {
+            metadata,
+        });
         // Wrap the stream with metadata using awslambda global
         this._wrappedStream = awslambda.HttpResponseStream.from(this._responseStream, metadata);
         this._headersSent = true;
@@ -884,6 +908,14 @@ class LambdaResponseStreaming extends node_stream.Writable {
         return this;
     }
     status(code) {
+        // DIAGNOSTIC: Log status code changes
+        const caller = new Error().stack?.split("\n").slice(1, 4).join("\n");
+        console.log("[DIAG:LambdaResponseStreaming:status] Setting status", {
+            newCode: code,
+            previousCode: this.statusCode,
+            headersSent: this._headersSent,
+            caller,
+        });
         this.statusCode = code;
         return this;
     }
@@ -929,10 +961,17 @@ class LambdaResponseStreaming extends node_stream.Writable {
         const buffer = Buffer.isBuffer(chunk)
             ? chunk
             : Buffer.from(chunk, encoding);
+        // DIAGNOSTIC: Log every write
+        console.log("[DIAG:LambdaResponseStreaming:_write] Called", {
+            chunkLength: buffer.length,
+            headersSent: this._headersSent,
+            statusCode: this.statusCode,
+        });
         if (!this._headersSent) {
             // Buffer writes until headers are sent
             this._pendingWrites.push({ callback: () => callback(), chunk: buffer });
             // Auto-flush headers on first write
+            console.log("[DIAG:LambdaResponseStreaming:_write] Auto-flushing headers on first write");
             this.flushHeaders();
         }
         else {
@@ -941,7 +980,14 @@ class LambdaResponseStreaming extends node_stream.Writable {
         }
     }
     _final(callback) {
+        // DIAGNOSTIC: Log _final call
+        console.log("[DIAG:LambdaResponseStreaming:_final] Called", {
+            headersSent: this._headersSent,
+            statusCode: this.statusCode,
+            hasWrappedStream: !!this._wrappedStream,
+        });
         if (!this._headersSent) {
+            console.log("[DIAG:LambdaResponseStreaming:_final] Headers not sent, flushing now");
             this.flushHeaders();
         }
         this._wrappedStream?.end();
@@ -1026,13 +1072,6 @@ function createLambdaHandler(app, _options) {
             await runExpressApp(app, req, res);
             // Get Lambda response - await explicitly to ensure we have the result
             result = await res.getResult();
-            // Debug: Log the response before returning
-            console.log("[createLambdaHandler] Returning response:", JSON.stringify({
-                statusCode: result.statusCode,
-                headers: result.headers,
-                bodyLength: result.body?.length,
-                isBase64Encoded: result.isBase64Encoded,
-            }));
             return result;
         }
         catch (error) {
@@ -1461,7 +1500,8 @@ const decorateResponse = (res, { handler = "", version = process.env.PROJECT_VER
         // X-Powered-By, override "Express" but nothing else
         const currentPoweredBy = safeGetHeader(extRes, kit.HTTP.HEADER.POWERED_BY);
         if (!currentPoweredBy || currentPoweredBy === "Express") {
-            safeSetHeader(extRes, kit.HTTP.HEADER.POWERED_BY, kit.JAYPIE.LIB.EXPRESS);
+            // DIAGNOSTIC: Include dev marker to verify build deployment
+            safeSetHeader(extRes, kit.HTTP.HEADER.POWERED_BY, `${kit.JAYPIE.LIB.EXPRESS}#dev-178`);
         }
         // X-Project-Environment
         if (process.env.PROJECT_ENV) {
@@ -1553,6 +1593,22 @@ const logger$1 = logger$2.log;
 function isLambdaMockResponse(res) {
     return (res[JAYPIE_LAMBDA_MOCK] === true);
 }
+/**
+ * Check if response is a Lambda streaming response.
+ * Uses Symbol marker to survive prototype chain modifications from Express and dd-trace.
+ */
+function isLambdaStreamingResponse(res) {
+    const symbolValue = res[JAYPIE_LAMBDA_STREAMING];
+    const result = symbolValue === true;
+    // DIAGNOSTIC: Log symbol check
+    console.log("[DIAG:expressHandler:isLambdaStreamingResponse] Check", {
+        symbolValue,
+        result,
+        resConstructorName: res?.constructor?.name,
+        hasFlushHeaders: typeof res.flushHeaders === "function",
+    });
+    return result;
+}
 /**
  * Safely send a JSON response, avoiding dd-trace interception.
  * For Lambda mock responses, directly manipulates internal state instead of
@@ -1585,13 +1641,29 @@ function safeSendJson(res, statusCode, data) {
         return;
     }
     // Fall back to standard Express methods for real responses
+    // DIAGNOSTIC: Log before setting status
+    console.log("[DIAG:expressHandler:safeSendJson] Before res.status()", {
+        statusCode,
+        currentStatusCode: res.statusCode,
+    });
     res.status(statusCode);
+    console.log("[DIAG:expressHandler:safeSendJson] After res.status()", {
+        statusCode,
+        newStatusCode: res.statusCode,
+    });
     // CRITICAL: For Lambda streaming responses, flush headers before send to
-    // initialize the stream wrapper. Check for _responseStream which is unique
-    // to LambdaResponseStreaming (regular Express res doesn't have this).
-    if ("_responseStream" in res && typeof res.flushHeaders === "function") {
+    // initialize the stream wrapper. This ensures the status code is captured
+    // before any writes occur (which would auto-flush with default 200).
+    // Uses Symbol marker for reliable detection that survives prototype manipulation.
+    const isStreaming = isLambdaStreamingResponse(res);
+    console.log("[DIAG:expressHandler:safeSendJson] Streaming check", {
+        isStreaming,
+    });
+    if (isStreaming && typeof res.flushHeaders === "function") {
+        console.log("[DIAG:expressHandler:safeSendJson] Calling flushHeaders explicitly");
         res.flushHeaders();
     }
+    console.log("[DIAG:expressHandler:safeSendJson] Calling res.json()");
     res.json(data);
 }
 /**
@@ -1620,17 +1692,35 @@ function safeSend(res, statusCode, body) {
         return;
     }
     // Fall back to standard Express methods for real responses
+    // DIAGNOSTIC: Log before setting status
+    console.log("[DIAG:expressHandler:safeSend] Before res.status()", {
+        statusCode,
+        currentStatusCode: res.statusCode,
+        hasBody: body !== undefined,
+    });
     res.status(statusCode);
+    console.log("[DIAG:expressHandler:safeSend] After res.status()", {
+        statusCode,
+        newStatusCode: res.statusCode,
+    });
     // CRITICAL: For Lambda streaming responses, flush headers before send to
-    // initialize the stream wrapper. Check for _responseStream which is unique
-    // to LambdaResponseStreaming (regular Express res doesn't have this).
-    if ("_responseStream" in res && typeof res.flushHeaders === "function") {
+    // initialize the stream wrapper. This ensures the status code is captured
+    // before any writes occur (which would auto-flush with default 200).
+    // Uses Symbol marker for reliable detection that survives prototype manipulation.
+    const isStreaming = isLambdaStreamingResponse(res);
+    console.log("[DIAG:expressHandler:safeSend] Streaming check", {
+        isStreaming,
+    });
+    if (isStreaming && typeof res.flushHeaders === "function") {
+        console.log("[DIAG:expressHandler:safeSend] Calling flushHeaders explicitly");
         res.flushHeaders();
     }
     if (body !== undefined) {
+        console.log("[DIAG:expressHandler:safeSend] Calling res.send(body)");
         res.send(body);
     }
     else {
+        console.log("[DIAG:expressHandler:safeSend] Calling res.send() (no body)");
         res.send();
     }
 }