@jaypie/express 1.2.32 → 1.2.34

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

@@ -36,6 +36,13 @@ export declare class LambdaResponseBuffered extends Writable {
      */
     get headers(): Record<string, string | string[] | undefined>;
     writeHead(statusCode: number, statusMessageOrHeaders?: OutgoingHttpHeaders | string, headers?: OutgoingHttpHeaders): this;
+    /**
+     * Node's implicit-header hook, called before the first body byte commits.
+     * Routes through this.writeHead resolved at call time so wrappers installed
+     * mid-request (on-headers, and through it express-session, morgan,
+     * compression, express-openid-connect) run their listeners.
+     */
+    _implicitHeader(): void;
     get headersSent(): boolean;
     /**
      * Express-style alias for getHeader().

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

@@ -36,8 +36,16 @@ export declare class LambdaResponseStreaming extends Writable {
      */
     get headers(): Record<string, string | string[] | undefined>;
     writeHead(statusCode: number, statusMessageOrHeaders?: OutgoingHttpHeaders | string, headers?: OutgoingHttpHeaders): this;
+    /**
+     * Node's implicit-header hook, called before the first body byte commits.
+     * Routes through this.writeHead resolved at call time so wrappers installed
+     * mid-request (on-headers, and through it express-session, morgan,
+     * compression, express-openid-connect) run their listeners.
+     */
+    _implicitHeader(): void;
     get headersSent(): boolean;
     flushHeaders(): void;
+    private _commitHeaders;
     /**
      * Express-style alias for getHeader().
      * Used by middleware like decorateResponse that use res.get().

package/dist/cjs/adapter/headers.helper.d.ts

@@ -0,0 +1,15 @@
+export declare const SET_COOKIE = "set-cookie";
+/**
+ * Normalize a header value for storage, preserving arrays.
+ * Node's ServerResponse keeps multi-value headers as arrays; stringifying
+ * here would fold them into a single comma-separated value.
+ */
+export declare function normalizeHeaderValue(value: number | string | string[]): string | string[];
+/**
+ * Split stored headers into a single-value header record and a cookies
+ * array, matching the Lambda Function URL (v2) response shape.
+ */
+export declare function splitCookieHeaders(source: Map<string, string | string[]>): {
+    cookies: string[];
+    headers: Record<string, string>;
+};

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

@@ -82,6 +82,7 @@ export interface ResponseStream {
     write(chunk: string | Uint8Array): void;
 }
 export interface HttpResponseStreamMetadata {
+    cookies?: string[];
     headers: Record<string, string>;
     statusCode: number;
 }

package/dist/cjs/index.cjs

@@ -278,6 +278,50 @@ function createLambdaRequest(event, context) {
     });
 }
 
+//
+//
+// Constants
+//
+// Set-Cookie is the one header that must never be comma-folded: cookie
+// expiry dates contain commas, so a folded value is unparseable. Lambda
+// carries these out-of-band in the `cookies` field of the v2 response
+// payload and of the response-streaming metadata prelude.
+const SET_COOKIE = "set-cookie";
+//
+//
+// Functions
+//
+/**
+ * Normalize a header value for storage, preserving arrays.
+ * Node's ServerResponse keeps multi-value headers as arrays; stringifying
+ * here would fold them into a single comma-separated value.
+ */
+function normalizeHeaderValue(value) {
+    return Array.isArray(value) ? value.map(String) : String(value);
+}
+/**
+ * Split stored headers into a single-value header record and a cookies
+ * array, matching the Lambda Function URL (v2) response shape.
+ */
+function splitCookieHeaders(source) {
+    const cookies = [];
+    const headers = {};
+    for (const [key, value] of source) {
+        if (key === SET_COOKIE) {
+            if (Array.isArray(value)) {
+                cookies.push(...value);
+            }
+            else {
+                cookies.push(value);
+            }
+        }
+        else {
+            headers[key] = Array.isArray(value) ? value.join(", ") : String(value);
+        }
+    }
+    return { cookies, headers };
+}
+
 //
 //
 // Constants
@@ -340,6 +384,7 @@ class LambdaResponseBuffered extends node_stream.Writable {
         this.getHeaders = this.getHeaders.bind(this);
         this.getHeaderNames = this.getHeaderNames.bind(this);
         this.writeHead = this.writeHead.bind(this);
+        this._implicitHeader = this._implicitHeader.bind(this);
         this.get = this.get.bind(this);
         this.set = this.set.bind(this);
         this.status = this.status.bind(this);
@@ -415,13 +460,14 @@ class LambdaResponseBuffered extends node_stream.Writable {
             return this;
         }
         const lowerName = name.toLowerCase();
-        this._headers.set(lowerName, String(value));
+        const normalized = normalizeHeaderValue(value);
+        this._headers.set(lowerName, normalized);
         // Sync with kOutHeaders for dd-trace compatibility
         // Node stores as { 'header-name': ['Header-Name', value] }
         if (kOutHeaders$1) {
             const outHeaders = this[kOutHeaders$1];
             if (outHeaders) {
-                outHeaders[lowerName] = [name, String(value)];
+                outHeaders[lowerName] = [name, normalized];
             }
         }
         return this;
@@ -495,6 +541,9 @@ class LambdaResponseBuffered extends node_stream.Writable {
         });
     }
     writeHead(statusCode, statusMessageOrHeaders, headers) {
+        if (this._headersSent) {
+            return this;
+        }
         this.statusCode = statusCode;
         let headersToSet;
         if (typeof statusMessageOrHeaders === "string") {
@@ -509,13 +558,24 @@ class LambdaResponseBuffered extends node_stream.Writable {
             // Use direct _headers access to bypass dd-trace interception
             for (const [key, value] of Object.entries(headersToSet)) {
                 if (value !== undefined) {
-                    this._headers.set(key.toLowerCase(), String(value));
+                    this._headers.set(key.toLowerCase(), normalizeHeaderValue(value));
                 }
             }
         }
         this._headersSent = true;
         return this;
     }
+    /**
+     * Node's implicit-header hook, called before the first body byte commits.
+     * Routes through this.writeHead resolved at call time so wrappers installed
+     * mid-request (on-headers, and through it express-session, morgan,
+     * compression, express-openid-connect) run their listeners.
+     */
+    _implicitHeader() {
+        if (!this._headersSent) {
+            this.writeHead(this.statusCode);
+        }
+    }
     get headersSent() {
         return this._headersSent;
     }
@@ -537,7 +597,7 @@ class LambdaResponseBuffered extends node_stream.Writable {
      */
     set(name, value) {
         if (!this._headersSent) {
-            this._headers.set(name.toLowerCase(), String(value));
+            this._headers.set(name.toLowerCase(), normalizeHeaderValue(value));
         }
         return this;
     }
@@ -587,11 +647,13 @@ class LambdaResponseBuffered extends node_stream.Writable {
         const buffer = Buffer.isBuffer(chunk)
             ? chunk
             : Buffer.from(chunk, encoding);
+        this._implicitHeader();
         this._chunks.push(buffer);
         this._headersSent = true;
         callback();
     }
     _final(callback) {
+        this._implicitHeader();
         this._ended = true;
         if (this._resolve) {
             this._resolve(this.buildResult());
@@ -607,23 +669,8 @@ class LambdaResponseBuffered extends node_stream.Writable {
         const contentType = this._headers.get("content-type") || "";
         // Determine if response should be base64 encoded
         const isBase64Encoded = this.isBinaryContentType(contentType);
-        // Build headers object
-        const headers = {};
-        const cookies = [];
-        for (const [key, value] of this._headers) {
-            if (key === "set-cookie") {
-                // Collect Set-Cookie headers for v2 response format
-                if (Array.isArray(value)) {
-                    cookies.push(...value);
-                }
-                else {
-                    cookies.push(value);
-                }
-            }
-            else {
-                headers[key] = Array.isArray(value) ? value.join(", ") : String(value);
-            }
-        }
+        // Build headers object, carrying Set-Cookie out-of-band (v2 format)
+        const { cookies, headers } = splitCookieHeaders(this._headers);
         const result = {
             body: isBase64Encoded ? body.toString("base64") : body.toString("utf8"),
             headers,
@@ -698,6 +745,8 @@ class LambdaResponseStreaming extends node_stream.Writable {
         this.getHeaderNames = this.getHeaderNames.bind(this);
         this.writeHead = this.writeHead.bind(this);
         this.flushHeaders = this.flushHeaders.bind(this);
+        this._implicitHeader = this._implicitHeader.bind(this);
+        this._commitHeaders = this._commitHeaders.bind(this);
         this.get = this.get.bind(this);
         this.set = this.set.bind(this);
         this.status = this.status.bind(this);
@@ -756,13 +805,14 @@ class LambdaResponseStreaming extends node_stream.Writable {
             return this;
         }
         const lowerName = name.toLowerCase();
-        this._headers.set(lowerName, String(value));
+        const normalized = normalizeHeaderValue(value);
+        this._headers.set(lowerName, normalized);
         // Sync with kOutHeaders for dd-trace compatibility
         // Node stores as { 'header-name': ['Header-Name', value] }
         if (kOutHeaders) {
             const outHeaders = this[kOutHeaders];
             if (outHeaders) {
-                outHeaders[lowerName] = [name, String(value)];
+                outHeaders[lowerName] = [name, normalized];
             }
         }
         return this;
@@ -857,24 +907,36 @@ class LambdaResponseStreaming extends node_stream.Writable {
             // Use direct _headers access to bypass dd-trace interception
             for (const [key, value] of Object.entries(headersToSet)) {
                 if (value !== undefined) {
-                    this._headers.set(key.toLowerCase(), String(value));
+                    this._headers.set(key.toLowerCase(), normalizeHeaderValue(value));
                 }
             }
         }
-        this.flushHeaders();
+        this._commitHeaders();
         return this;
     }
+    /**
+     * Node's implicit-header hook, called before the first body byte commits.
+     * Routes through this.writeHead resolved at call time so wrappers installed
+     * mid-request (on-headers, and through it express-session, morgan,
+     * compression, express-openid-connect) run their listeners.
+     */
+    _implicitHeader() {
+        if (!this._headersSent) {
+            this.writeHead(this.statusCode);
+        }
+    }
     get headersSent() {
         return this._headersSent;
     }
     flushHeaders() {
+        this._implicitHeader();
+    }
+    _commitHeaders() {
         if (this._headersSent) {
             return;
         }
-        const headers = {};
-        for (const [key, value] of this._headers) {
-            headers[key] = Array.isArray(value) ? value.join(", ") : String(value);
-        }
+        // Set-Cookie travels in metadata.cookies, never folded into headers
+        const { cookies, headers } = splitCookieHeaders(this._headers);
         // 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
@@ -889,6 +951,10 @@ class LambdaResponseStreaming extends node_stream.Writable {
             headers,
             statusCode,
         };
+        // Only include cookies if present (v2 format)
+        if (cookies.length > 0) {
+            metadata.cookies = cookies;
+        }
         // Create wrapped stream with metadata
         this._wrappedStream = awslambda.HttpResponseStream.from(this._responseStream, metadata);
         this._headersSent = true;
@@ -917,7 +983,7 @@ class LambdaResponseStreaming extends node_stream.Writable {
      */
     set(name, value) {
         if (!this._headersSent) {
-            this._headers.set(name.toLowerCase(), String(value));
+            this._headers.set(name.toLowerCase(), normalizeHeaderValue(value));
         }
         return this;
     }
@@ -971,7 +1037,7 @@ class LambdaResponseStreaming extends node_stream.Writable {
             // Buffer writes until headers are sent
             this._pendingWrites.push({ callback: () => callback(), chunk: buffer });
             // Auto-flush headers on first write
-            this.flushHeaders();
+            this._implicitHeader();
         }
         else {
             this._wrappedStream.write(buffer);
@@ -979,9 +1045,7 @@ class LambdaResponseStreaming extends node_stream.Writable {
         }
     }
     _final(callback) {
-        if (!this._headersSent) {
-            this.flushHeaders();
-        }
+        this._implicitHeader();
         // For converted 204 responses, write empty JSON body
         // Lambda streaming requires body content for metadata to be transmitted
         if (this._convertedFrom204 && this._wrappedStream) {