@belmonddev/catch-request-express-middleware 3.2.0 → 3.2.2

package/index.js

@@ -56,26 +56,55 @@ const catchHttpResponse = (reqObject, responseCb) => {
   });
 };
 
+const transformHeaderValues = (headers) => {
+  let transformedHeaders = {};
+  const headerEntries = Object.entries(headers);
+  headerEntries.forEach(([key, value]) => {
+    transformedHeaders[key] = typeof value === 'string' ? [value] : value;
+  });
+
+  return transformedHeaders;
+};
+
 const overrideHttpModule = (httpModule, requestSentCb) => {
-  override(httpModule, 'request', (reqObject, request) => {
-    const contentLength = getHeaderValue(
-      request.headers || {},
-      'content-length'
-    );
+  override(httpModule, 'request', (reqObject, urlOrRequest, request) => {
+    // node-fetch v3+ will return the 2nd arg as url, so correctly identify the request object
+    request = typeof urlOrRequest === 'string' ? request : urlOrRequest;
+
+    // transform headers to use array values instead of string
+    const headers = transformHeaderValues(request.headers);
+    const contentLength = getHeaderValue(headers || {}, 'content-length');
     const requestHasBody = !!contentLength;
-    const params = Object.fromEntries(
-      new URLSearchParams(request.query).entries()
-    );
+
+    const [pathname, query] = request.path.split('?');
+    const params = Object.fromEntries(new URLSearchParams(query).entries());
+
+    // add values not included in node-fetch v3+
+    request = {
+      ...request,
+      href: `${reqObject.protocol}//${reqObject.host}${request.path}`,
+      protocol: reqObject.protocol,
+      host: reqObject.host,
+      search: `&${query}`,
+      pathname,
+      query,
+    };
 
     let responseCb;
     if (requestHasBody) {
+      let requestBody = '';
       override(reqObject, 'write', (result, data) => {
         const body = data.toString();
+        requestBody += body;
+      });
+
+      override(reqObject, 'end', () => {
         responseCb = requestSentCb({
           ...request,
           params,
-          body,
+          body: requestBody,
         });
+
         if (responseCb) {
           catchHttpResponse(reqObject, responseCb);
         }

package/package.json

@@ -1,16 +1,10 @@
 {
   "name": "@belmonddev/catch-request-express-middleware",
-  "version": "3.2.0",
+  "version": "3.2.2",
   "main": "index.js",
-  "scripts": {
-    "start": "nodemon -L --experimental-specifier-resolution=node ./src/index.js"
-  },
   "author": "David Escalera",
   "license": "ISC",
-  "dependencies": {},
-  "devDependencies": {
-    "nodemon": "^2.0.7"
-  },
+  "description": "",
   "type": "module",
-  "description": ""
+  "dependencies": {}
 }

package/deleteme.js

@@ -1,175 +0,0 @@
-import http from 'http';
-import https from 'https';
-import zlib from 'zlib';
-
-const override = (module, attr, fn) => {
-  let original = module[attr];
-
-  function wrapper(...args) {
-    const result = original.apply(this, args);
-    fn.apply(this, [result, ...args]);
-    return result;
-  }
-
-  module[attr] = wrapper;
-};
-
-export const getHeaderValue = (headers, key) =>
-  Object.entries(headers).find(([k]) => k.toLowerCase() === key)?.[1];
-
-const catchHttpResponse = (reqObject, responseCb) => {
-  override(reqObject, 'emit', (result, eventName, response) => {
-    const chunks = [];
-    switch (eventName) {
-      case 'response': {
-        response.on('data', (d) => {
-          chunks.push(d);
-        });
-
-        response.on('end', () => {
-          const responseObj = {
-            headers: response.headers,
-            statusCode: response.statusCode,
-            statusMessage: response.statusMessage,
-          };
-          const contentEncoding = getHeaderValue(
-            response.headers,
-            'content-encoding'
-          );
-          if (['gzip', 'deflate'].indexOf(contentEncoding) !== -1) {
-            const buffer = Buffer.concat(chunks);
-            const zlibFunc =
-              contentEncoding === 'gzip' ? zlib.gunzip : zlib.inflate;
-            zlibFunc(buffer, (_, decoded) => {
-              const stringBody = decoded.toString('utf8');
-              const request = { ...responseObj, body: stringBody };
-              responseCb(request);
-            });
-          } else {
-            const stringBody = chunks.map((c) => c.toString('utf8')).join('');
-            const request = { ...responseObj, body: stringBody };
-            responseCb(request);
-          }
-        });
-      }
-    }
-  });
-};
-
-const overrideHttpModule = (httpModule, requestSentCb) => {
-  override(httpModule, 'request', (reqObject, request) => {
-    const contentLength = getHeaderValue(
-      request.headers || {},
-      'content-length'
-    );
-    const requestHasBody = !!contentLength;
-    const params = Object.fromEntries(
-      new URLSearchParams(request.query).entries()
-    );
-
-    if (requestHasBody) {
-      override(reqObject, 'write', (result, data) => {
-        const body = data.toString();
-        const responseCb = requestSentCb({
-          ...request,
-          params,
-          body,
-        });
-        if (responseCb) {
-          catchHttpResponse(reqObject, responseCb);
-        }
-      });
-    } else {
-      const responseCb = requestSentCb({ ...request, params, body: null });
-      if (responseCb) {
-        catchHttpResponse(reqObject, responseCb);
-      }
-    }
-  });
-};
-
-const callResponseCb = (responseCb, res) => {
-  const response = {
-    headers: res.getHeaders(),
-    statusCode: res.statusCode,
-    statusMessage: res.statusMessage,
-    body: res.bodyWritten,
-  };
-  responseCb(response);
-};
-
-const callReceivedCbs = (req, res, requestReceivedCb, body) => {
-  const responseCb = requestReceivedCb({
-    originalRequest: req,
-    headers: req.headers,
-    method: req.method,
-    host: req.headers.host,
-    pathname: req._parsedUrl.pathname,
-    params: req.params,
-    query: req.query,
-    body,
-  });
-
-  if (responseCb) {
-    res.setMaxListeners(100);
-    if (res.writableFinished) {
-      callResponseCb(responseCb, res);
-    } else {
-      res.on('finish', () => {
-        callResponseCb(responseCb, res);
-      });
-    }
-  }
-};
-
-const catchExpressReceivedRequest = (req, res, requestReceivedCb) => {
-  // we override write method ASAP cause otherwise if the request finishes too fast the response callback is not called
-  let writeCount = 0;
-  let firstData = '';
-  override(req.socket, 'write', (result, data) => {
-    writeCount++;
-    if (writeCount === 1) {
-      firstData = data;
-    } else if (writeCount === 2) {
-      res.bodyWritten = data.toString();
-      if (!res.bodyWritten.length) {
-        res.bodyWritten = firstData.split('\r\n\r\n')?.[1];
-      }
-    }
-  });
-
-  if (req.body !== undefined) {
-    callReceivedCbs(req, res, requestReceivedCb, req.body);
-  } else {
-    const contentLength = getHeaderValue(req.headers, 'content-length');
-    if (contentLength) {
-      let body = '';
-      req.on('data', function (data) {
-        body += data;
-      });
-      req.on('end', function () {
-        callReceivedCbs(req, res, requestReceivedCb, body);
-      });
-    } else {
-      callReceivedCbs(req, res, requestReceivedCb, '');
-    }
-  }
-};
-
-const catchRequestExpressMiddleware = (
-  requestReceivedCb = null,
-  requestSentCb = null
-) => {
-  if (requestSentCb) {
-    overrideHttpModule(http, requestSentCb);
-    overrideHttpModule(https, requestSentCb);
-  }
-  return (req, res, next) => {
-    if (requestReceivedCb) {
-      catchExpressReceivedRequest(req, res, requestReceivedCb);
-    }
-    next();
-  };
-};
-
-export default catchRequestExpressMiddleware;