apitally 0.12.0 → 0.14.0

package/dist/express/middleware.cjs

@@ -814,7 +814,7 @@ var _ApitallyClient = class _ApitallyClient {
       throw new Error("Apitally client is already initialized");
     }
     if (!isValidClientId(clientId)) {
-      throw new Error(`Invalid client ID '${clientId}' (expecting hexadeciaml UUID format)`);
+      throw new Error(`Invalid Apitally client ID '${clientId}' (expecting hexadecimal UUID format)`);
     }
     if (!isValidEnv(env)) {
       throw new Error(`Invalid env '${env}' (expecting 1-32 alphanumeric lowercase characters and hyphens only)`);
@@ -1070,6 +1070,25 @@ function getPackageVersion(name) {
 }
 __name(getPackageVersion, "getPackageVersion");
 
+// src/common/utils.ts
+function parseContentLength(contentLength) {
+  if (contentLength === void 0 || contentLength === null) {
+    return void 0;
+  }
+  if (typeof contentLength === "number") {
+    return contentLength;
+  }
+  if (typeof contentLength === "string") {
+    const parsed = parseInt(contentLength);
+    return isNaN(parsed) ? void 0 : parsed;
+  }
+  if (Array.isArray(contentLength)) {
+    return parseContentLength(contentLength[0]);
+  }
+  return void 0;
+}
+__name(parseContentLength, "parseContentLength");
+
 // src/express/utils.js
 var regExpToParseExpressPathRegExp = /^\/\^\\?\/?(?:(:?[\w\\.-]*(?:\\\/:?[\w\\.-]*)*)|(\(\?:\\?\/?\([^)]+\)\)))\\\/.*/;
 var regExpToReplaceExpressPathRegExpParams = /\(\?:\\?\/?\([^)]+\)\)/;
@@ -1081,6 +1100,29 @@ var STACK_ITEM_VALID_NAMES = [
   "bound dispatch",
   "mounted_app"
 ];
+var getRouterInfo = /* @__PURE__ */ __name(function(app) {
+  var _a2, _b;
+  if (app.stack) {
+    return {
+      stack: app.stack,
+      version: "v4"
+    };
+  } else if ((_a2 = app._router) == null ? void 0 : _a2.stack) {
+    return {
+      stack: app._router.stack,
+      version: "v4"
+    };
+  } else if ((_b = app.router) == null ? void 0 : _b.stack) {
+    return {
+      stack: app.router.stack,
+      version: "v5"
+    };
+  }
+  return {
+    stack: null,
+    version: "v4"
+  };
+}, "getRouterInfo");
 var getRouteMethods = /* @__PURE__ */ __name(function(route) {
   let methods = Object.keys(route.methods);
   methods = methods.filter((method) => method !== "_all");
@@ -1113,12 +1155,12 @@ var parseExpressRoute = /* @__PURE__ */ __name(function(route, basePath) {
   });
   return endpoints;
 }, "parseExpressRoute");
-var parseExpressPath = /* @__PURE__ */ __name(function(expressPathRegExp, params) {
+var parseExpressPathRegExp = /* @__PURE__ */ __name(function(expressPathRegExp, keys) {
   let parsedRegExp = expressPathRegExp.toString();
   let expressPathRegExpExec = regExpToParseExpressPathRegExp.exec(parsedRegExp);
   let paramIndex = 0;
   while (hasParams(parsedRegExp)) {
-    const paramName = params[paramIndex].name;
+    const paramName = keys[paramIndex].name;
     const paramId = `:${paramName}`;
     parsedRegExp = parsedRegExp.replace(regExpToReplaceExpressPathRegExpParams, (str) => {
       if (str.startsWith("(?:\\/")) {
@@ -1131,11 +1173,19 @@ var parseExpressPath = /* @__PURE__ */ __name(function(expressPathRegExp, params
   if (parsedRegExp !== expressPathRegExp.toString()) {
     expressPathRegExpExec = regExpToParseExpressPathRegExp.exec(parsedRegExp);
   }
-  const parsedPath = expressPathRegExpExec[1].replace(/\\\//g, "/");
-  return parsedPath;
+  return expressPathRegExpExec[1].replace(/\\\//g, "/");
+}, "parseExpressPathRegExp");
+var parseExpressPath = /* @__PURE__ */ __name(function(expressPath, params) {
+  let result = expressPath;
+  for (const [paramName, paramValue] of Object.entries(params)) {
+    result = result.replace(paramValue, `:${paramName}`);
+  }
+  return result;
 }, "parseExpressPath");
 var parseEndpoints = /* @__PURE__ */ __name(function(app, basePath, endpoints) {
-  const stack = app.stack || app._router && app._router.stack;
+  const routerInfo = getRouterInfo(app);
+  const stack = routerInfo.stack;
+  const version = routerInfo.version;
   endpoints = endpoints || [];
   basePath = basePath || "";
   if (!stack) {
@@ -1149,7 +1199,7 @@ var parseEndpoints = /* @__PURE__ */ __name(function(app, basePath, endpoints) {
       ]);
     }
   } else {
-    endpoints = parseStack(stack, basePath, endpoints);
+    endpoints = parseStack(stack, basePath, endpoints, version);
   }
   return endpoints;
 }, "parseEndpoints");
@@ -1165,20 +1215,28 @@ var addEndpoints = /* @__PURE__ */ __name(function(currentEndpoints, endpointsTo
   });
   return currentEndpoints;
 }, "addEndpoints");
-var parseStack = /* @__PURE__ */ __name(function(stack, basePath, endpoints) {
+var parseStack = /* @__PURE__ */ __name(function(stack, basePath, endpoints, version) {
   stack.forEach((stackItem) => {
     if (stackItem.route) {
       const newEndpoints = parseExpressRoute(stackItem.route, basePath);
       endpoints = addEndpoints(endpoints, newEndpoints);
     } else if (STACK_ITEM_VALID_NAMES.includes(stackItem.name)) {
-      const isExpressPathRegexp = regExpToParseExpressPathRegExp.test(stackItem.regexp);
       let newBasePath = basePath;
-      if (isExpressPathRegexp) {
-        const parsedPath = parseExpressPath(stackItem.regexp, stackItem.keys);
-        newBasePath += `/${parsedPath}`;
-      } else if (!stackItem.path && stackItem.regexp && stackItem.regexp.toString() !== EXPRESS_ROOT_PATH_REGEXP_VALUE) {
-        const regExpPath = ` RegExp(${stackItem.regexp}) `;
-        newBasePath += `/${regExpPath}`;
+      if (version === "v4") {
+        const isExpressPathRegExp = regExpToParseExpressPathRegExp.test(stackItem.regexp);
+        if (isExpressPathRegExp) {
+          const parsedPath = parseExpressPathRegExp(stackItem.regexp, stackItem.keys);
+          newBasePath += `/${parsedPath}`;
+        } else if (!stackItem.path && stackItem.regexp && stackItem.regexp.toString() !== EXPRESS_ROOT_PATH_REGEXP_VALUE) {
+          const regExpPath = `RegExp(${stackItem.regexp})`;
+          newBasePath += `/${regExpPath}`;
+        }
+      } else if (version === "v5") {
+        if (!stackItem.path) {
+          return;
+        } else if (stackItem.path !== "/") {
+          newBasePath += stackItem.path.startsWith("/") ? stackItem.path : `/${stackItem.path}`;
+        }
       }
       endpoints = parseEndpoints(stackItem.handle, newBasePath, endpoints);
     }
@@ -1229,12 +1287,14 @@ var getMiddleware = /* @__PURE__ */ __name((app, client) => {
         }
         return originalSend.call(res, body);
       };
-      res.on("finish", () => {
+      res.once("finish", () => {
         try {
           const responseTime = import_perf_hooks.performance.now() - startTime;
           const path = getRoutePath(req);
           const consumer = getConsumer(req);
           client.consumerRegistry.addOrUpdateConsumer(consumer);
+          const requestSize = parseContentLength(req.get("content-length"));
+          const responseSize = parseContentLength(res.get("content-length"));
           if (path) {
             client.requestCounter.addRequest({
               consumer: consumer == null ? void 0 : consumer.identifier,
@@ -1242,8 +1302,8 @@ var getMiddleware = /* @__PURE__ */ __name((app, client) => {
               path,
               statusCode: res.statusCode,
               responseTime,
-              requestSize: req.get("content-length"),
-              responseSize: res.get("content-length")
+              requestSize,
+              responseSize
             });
             if ((res.statusCode === 400 || res.statusCode === 422) && res.locals.body) {
               let jsonBody;
@@ -1291,14 +1351,14 @@ var getMiddleware = /* @__PURE__ */ __name((app, client) => {
               path,
               url: `${req.protocol}://${req.host}${req.originalUrl}`,
               headers: convertHeaders(req.headers),
-              size: Number(req.get("content-length")),
+              size: requestSize,
               consumer: consumer == null ? void 0 : consumer.identifier,
               body: convertBody(req.body, req.get("content-type"))
             }, {
               statusCode: res.statusCode,
               responseTime: responseTime / 1e3,
               headers: convertHeaders(res.getHeaders()),
-              size: Number(res.get("content-length")),
+              size: responseSize,
               body: convertBody(res.locals.body, res.get("content-type"))
             }, res.locals.serverError);
           }
@@ -1326,8 +1386,11 @@ var getRoutePath = /* @__PURE__ */ __name((req) => {
     return;
   }
   if (req.baseUrl) {
-    const routerPath = getRouterPath(req.app._router.stack, req.baseUrl);
-    return req.route.path === "/" ? routerPath : routerPath + req.route.path;
+    const routerInfo = getRouterInfo(req.app);
+    if (routerInfo.stack) {
+      const routerPath = getRouterPath(routerInfo.stack, req.baseUrl);
+      return req.route.path === "/" ? routerPath : routerPath + req.route.path;
+    }
   }
   return req.route.path;
 }, "getRoutePath");
@@ -1337,12 +1400,15 @@ var getRouterPath = /* @__PURE__ */ __name((stack, baseUrl) => {
   while (stack && stack.length > 0) {
     const routerLayer = stack.find((layer) => {
       var _a3;
-      return layer.name === "router" && layer.path && ((_a3 = layer.regexp) == null ? void 0 : _a3.test(baseUrl));
+      return layer.name === "router" && layer.path && (baseUrl.startsWith(layer.path) || ((_a3 = layer.regexp) == null ? void 0 : _a3.test(baseUrl)));
     });
     if (routerLayer) {
-      if (routerLayer.keys.length > 0) {
-        const parsedPath = parseExpressPath(routerLayer.regexp, routerLayer.keys);
+      if (routerLayer.regexp && routerLayer.keys && routerLayer.keys.length > 0) {
+        const parsedPath = parseExpressPathRegExp(routerLayer.regexp, routerLayer.keys);
         routerPaths.push("/" + parsedPath);
+      } else if (routerLayer.params && Object.keys(routerLayer.params).length > 0) {
+        const parsedPath = parseExpressPath(routerLayer.path, routerLayer.params);
+        routerPaths.push(parsedPath);
       } else {
         routerPaths.push(routerLayer.path);
       }