@jaypie/express 1.2.11-dev.3 → 1.2.11-dev.5

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

@@ -14,6 +14,7 @@ export declare class LambdaResponseStreaming extends Writable {
     };
     _headers: Map<string, string | string[]>;
     _headersSent: boolean;
+    private _convertedFrom204;
     private _pendingWrites;
     private _responseStream;
     private _wrappedStream;

package/dist/esm/index.js

@@ -652,6 +652,7 @@ class LambdaResponseStreaming extends Writable {
         // that need to bypass dd-trace interception
         this._headers = new Map();
         this._headersSent = false;
+        this._convertedFrom204 = false;
         this._pendingWrites = [];
         this._wrappedStream = null;
         this._responseStream = responseStream;
@@ -659,10 +660,6 @@ class LambdaResponseStreaming extends Writable {
         // 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) {
@@ -850,30 +847,28 @@ class LambdaResponseStreaming extends Writable {
         return this._headersSent;
     }
     flushHeaders() {
-        // 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);
         }
+        // Lambda streaming requires body content for metadata to be transmitted.
+        // Convert 204 No Content to 200 OK with empty JSON body as workaround.
+        // See: https://github.com/finlaysonstudio/jaypie/issues/178
+        let statusCode = this.statusCode;
+        if (statusCode === 204) {
+            statusCode = 200;
+            this._convertedFrom204 = true;
+            // Set content-type for the JSON body we'll send
+            headers["content-type"] = "application/json";
+        }
         const metadata = {
             headers,
-            statusCode: this.statusCode,
+            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
+        // Create wrapped stream with metadata
         this._wrappedStream = awslambda.HttpResponseStream.from(this._responseStream, metadata);
         this._headersSent = true;
         // Flush pending writes
@@ -906,14 +901,6 @@ class LambdaResponseStreaming extends 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;
     }
@@ -959,17 +946,10 @@ class LambdaResponseStreaming extends 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 {
@@ -978,21 +958,15 @@ class LambdaResponseStreaming extends 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();
         }
+        // For converted 204 responses, write empty JSON body
+        // Lambda streaming requires body content for metadata to be transmitted
+        if (this._convertedFrom204 && this._wrappedStream) {
+            this._wrappedStream.write("{}");
+        }
         if (this._wrappedStream) {
-            // FIX #178: Write empty chunk to force Lambda to process metadata
-            // Without this, 204 responses have no writes and Lambda ignores our statusCode/headers
-            console.log("[DIAG:LambdaResponseStreaming:_final] Writing empty chunk for metadata");
-            this._wrappedStream.write("");
             this._wrappedStream.end();
         }
         // Use setImmediate to ensure stream operations complete before callback
@@ -1505,8 +1479,7 @@ const decorateResponse = (res, { handler = "", version = process.env.PROJECT_VER
         // X-Powered-By, override "Express" but nothing else
         const currentPoweredBy = safeGetHeader(extRes, HTTP.HEADER.POWERED_BY);
         if (!currentPoweredBy || currentPoweredBy === "Express") {
-            // DIAGNOSTIC: Include dev marker to verify build deployment
-            safeSetHeader(extRes, HTTP.HEADER.POWERED_BY, `${JAYPIE.LIB.EXPRESS}@1.2.11-dev`);
+            safeSetHeader(extRes, HTTP.HEADER.POWERED_BY, JAYPIE.LIB.EXPRESS);
         }
         // X-Project-Environment
         if (process.env.PROJECT_ENV) {
@@ -1603,16 +1576,8 @@ function isLambdaMockResponse(res) {
  * 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;
+    return (res[JAYPIE_LAMBDA_STREAMING] ===
+        true);
 }
 /**
  * Safely send a JSON response, avoiding dd-trace interception.
@@ -1641,34 +1606,19 @@ function safeSendJson(res, statusCode, data) {
             res._resolve(res.buildResult());
         }
         // Emit "finish" event so runExpressApp's promise resolves
-        console.log("[safeSendJson] Emitting finish event");
         res.emit("finish");
         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. 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");
+    if (isLambdaStreamingResponse(res) &&
+        typeof res.flushHeaders === "function") {
         res.flushHeaders();
     }
-    console.log("[DIAG:expressHandler:safeSendJson] Calling res.json()");
     res.json(data);
 }
 /**
@@ -1692,40 +1642,23 @@ function safeSend(res, statusCode, body) {
             res._resolve(res.buildResult());
         }
         // Emit "finish" event so runExpressApp's promise resolves
-        console.log("[safeSend] Emitting finish event");
         res.emit("finish");
         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. 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");
+    if (isLambdaStreamingResponse(res) &&
+        typeof res.flushHeaders === "function") {
         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();
     }
 }