@jaypie/express 1.2.4-rc7 → 1.2.4-rc9

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

@@ -11,10 +11,10 @@ export declare class LambdaResponseBuffered extends Writable {
     readonly socket: {
         remoteAddress: string;
     };
-    private _chunks;
-    private _headers;
-    private _headersSent;
-    private _resolve;
+    _chunks: Buffer[];
+    _headers: Map<string, string | string[]>;
+    _headersSent: boolean;
+    _resolve: ((result: LambdaResponse) => void) | null;
     constructor();
     getResult(): Promise<LambdaResponse>;
     setHeader(name: string, value: number | string | string[]): this;
@@ -53,7 +53,7 @@ export declare class LambdaResponseBuffered extends Writable {
     _write(chunk: Buffer | string, encoding: BufferEncoding, // eslint-disable-line no-undef
     callback: (error?: Error | null) => void): void;
     _final(callback: (error?: Error | null) => void): void;
-    private buildResult;
+    buildResult(): LambdaResponse;
     private isBinaryContentType;
 }
 export default LambdaResponseBuffered;

package/dist/cjs/index.cjs

@@ -192,6 +192,8 @@ class LambdaResponseBuffered extends node_stream.Writable {
         this.socket = {
             remoteAddress: "127.0.0.1",
         };
+        // Internal state exposed for direct manipulation by safe response methods
+        // that need to bypass dd-trace interception of stream methods
         this._chunks = [];
         this._headers = new Map();
         this._headersSent = false;
@@ -1290,6 +1292,70 @@ function summarizeResponse(res, extras) {
 
 // Cast logger to extended interface for runtime features not in type definitions
 const logger$1 = logger$2.log;
+//
+//
+// Helpers - Safe response methods to bypass dd-trace interception
+//
+/**
+ * Check if response is a Lambda mock response with direct internal access.
+ */
+function isLambdaMockResponse(res) {
+    const mock = res;
+    return (mock._headers instanceof Map &&
+        Array.isArray(mock._chunks) &&
+        typeof mock.buildResult === "function");
+}
+/**
+ * Safely send a JSON response, avoiding dd-trace interception.
+ * For Lambda mock responses, directly manipulates internal state instead of
+ * using stream methods (write/end) which dd-trace intercepts.
+ */
+function safeSendJson(res, statusCode, data) {
+    if (isLambdaMockResponse(res)) {
+        // Direct internal state manipulation - bypasses dd-trace completely
+        res._headers.set("content-type", "application/json");
+        res.statusCode = statusCode;
+        // Directly push to chunks array instead of using stream write/end
+        const chunk = Buffer.from(JSON.stringify(data));
+        res._chunks.push(chunk);
+        res._headersSent = true;
+        // Signal completion if a promise is waiting
+        if (res._resolve) {
+            res._resolve(res.buildResult());
+        }
+        return;
+    }
+    // Fall back to standard Express methods for real responses
+    res.status(statusCode).json(data);
+}
+/**
+ * Safely send a response body, avoiding dd-trace interception.
+ * For Lambda mock responses, directly manipulates internal state instead of
+ * using stream methods (write/end) which dd-trace intercepts.
+ */
+function safeSend(res, statusCode, body) {
+    if (isLambdaMockResponse(res)) {
+        // Direct internal state manipulation - bypasses dd-trace completely
+        res.statusCode = statusCode;
+        if (body !== undefined) {
+            const chunk = Buffer.from(body);
+            res._chunks.push(chunk);
+        }
+        res._headersSent = true;
+        // Signal completion if a promise is waiting
+        if (res._resolve) {
+            res._resolve(res.buildResult());
+        }
+        return;
+    }
+    // Fall back to standard Express methods for real responses
+    if (body !== undefined) {
+        res.status(statusCode).send(body);
+    }
+    else {
+        res.status(statusCode).send();
+    }
+}
 function expressHandler(handlerOrOptions, optionsOrHandler) {
     /* eslint-enable no-redeclare */
     let handler;
@@ -1506,30 +1572,30 @@ function expressHandler(handlerOrOptions, optionsOrHandler) {
                     if (typeof response === "object") {
                         if (typeof response.json ===
                             "function") {
-                            res.json(response.json());
+                            safeSendJson(res, status, response.json());
                         }
                         else {
-                            res.status(status).json(response);
+                            safeSendJson(res, status, response);
                         }
                     }
                     else if (typeof response === "string") {
                         try {
-                            res.status(status).json(JSON.parse(response));
+                            safeSendJson(res, status, JSON.parse(response));
                         }
                         catch {
-                            res.status(status).send(response);
+                            safeSend(res, status, response);
                         }
                     }
                     else if (response === true) {
-                        res.status(kit.HTTP.CODE.CREATED).send();
+                        safeSend(res, kit.HTTP.CODE.CREATED);
                     }
                     else {
-                        res.status(status).send(response);
+                        safeSend(res, status, response);
                     }
                 }
                 else {
                     // No response
-                    res.status(kit.HTTP.CODE.NO_CONTENT).send();
+                    safeSend(res, kit.HTTP.CODE.NO_CONTENT);
                 }
             }
             else {