@contrast/route-coverage 1.11.1 → 1.11.2

package/lib/index.js

@@ -73,6 +73,7 @@ module.exports = function init(core) {
     },
   };
 
+  require('./install/http')(core);
   require('./install/express')(core);
   require('./install/fastify')(core);
   require('./install/koa')(core);

package/lib/install/express.js

@@ -117,84 +117,64 @@ module.exports = function init(core) {
     }
   }
 
-  core.routeCoverage.express = {
+  return core.routeCoverage.express = {
     install() {
-      depHooks.resolve(
-        { name: 'express' },
-        (express) => {
+      depHooks.resolve({ name: 'express' }, (express) => {
+        patcher.patch(express.Router, 'use', {
+          name: 'express.Router.use',
+          patchType,
+          post({ args, result }) {
+            const [prefix, router] = args;
+            if (typeof prefix === 'string' && prefix !== '/') {
+              updateRoutes(prefix, router, result);
+            }
+          }
+        });
 
-          patcher.patch(express.Router, 'use', {
-            name: 'express.Router.use',
-            patchType,
-            post({ args, result }) {
-              const [prefix, router] = args;
-              if (typeof prefix === 'string' && prefix !== '/') {
-                updateRoutes(prefix, router, result);
-              }
+        patcher.patch(express.application, 'use', {
+          name: 'express.application.use',
+          patchType,
+          post({ args }) {
+            const idx = args.length;
+            const router = args[idx - 1];
+            const routes = routers.get(router);
+            if (routes) {
+              routes.forEach((route) => {
+                discoverRoute(route);
+              });
             }
-          });
+          }
+        });
 
-          patcher.patch(express.application, 'use', {
-            name: 'express.application.use',
+        METHODS.forEach((method) => {
+          patcher.patch(express.application, method, {
+            name: `express.application.${method}`,
             patchType,
-            post({ args }) {
-              const idx = args.length;
-              const router = args[idx - 1];
-              const routes = routers.get(router);
-              if (routes) {
-                routes.forEach((route) => {
-                  discoverRoute(route);
-                });
-              }
+            post({ args, result }) {
+              const [url, fn] = args;
+              if (!url || !fn) return;
+              const route = createRoute(formatUrl(url), method);
+              instrumentRoute(result?._router, route);
+              discoverRoute(route);
             }
           });
 
-          METHODS.forEach((method) => {
-            patcher.patch(express.application, method, {
-              name: `express.application.${method}`,
-              patchType,
-              post({ args, result }) {
-                const [url, fn] = args;
-                if (!url || !fn) return;
-                const route = createRoute(formatUrl(url), method);
-                instrumentRoute(result?._router, route);
-                discoverRoute(route);
-              }
-            });
-
-            patcher.patch(express.Router, method, {
-              name: `express.Router.${method}`,
-              patchType,
-              post({ args, obj: router }) {
-                const [url, fn] = args;
-                if (!url || !fn) return;
-                const route = createRoute(formatUrl(url), method);
-                const routes = routers.get(router) || [];
-
-                instrumentRoute(router, route);
-                routes.push(route);
-                routers.set(router, routes);
-              }
-            });
-          });
-        }
-      );
-
-      ['http', 'https', 'spdy'].forEach((name) => {
-        depHooks.resolve({ name }, (module) => {
-          if (!module.Server?.prototype) return;
-
-          patcher.patch(module.Server.prototype, 'listen', {
-            name: `${name}.Server.prototype.listen`,
+          patcher.patch(express.Router, method, {
+            name: `express.Router.${method}`,
             patchType,
-            post() {
-              routeCoverage.discoveryFinished();
+            post({ args, obj: router }) {
+              const [url, fn] = args;
+              if (!url || !fn) return;
+              const route = createRoute(formatUrl(url), method);
+              const routes = routers.get(router) || [];
+
+              instrumentRoute(router, route);
+              routes.push(route);
+              routers.set(router, routes);
             }
           });
         });
       });
     }
   };
-
-  return core.routeCoverage.express;
 };

package/lib/install/fastify.js

@@ -82,7 +82,7 @@ module.exports = function init(core) {
     routeCoverage.observe({ method, url });
   }
 
-  core.routeCoverage.fastify = {
+  return core.routeCoverage.fastify = {
     install() {
       depHooks.resolve(
         { name: 'fastify', version: '>=3.0.0' },
@@ -105,6 +105,4 @@ module.exports = function init(core) {
       );
     }
   };
-
-  return core.routeCoverage.fastify;
 };

package/lib/install/http.js

@@ -0,0 +1,44 @@
+/*
+ * Copyright: 2023 Contrast Security, Inc
+ * Contact: support@contrastsecurity.com
+ * License: Commercial
+
+ * NOTICE: This Software and the patented inventions embodied within may only be
+ * used as part of Contrast Security’s commercial offerings. Even though it is
+ * made available through public repositories, use of this Software is subject to
+ * the applicable End User Licensing Agreement found at
+ * https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
+ * between Contrast Security and the End User. The Software may not be reverse
+ * engineered, modified, repackaged, sold, redistributed or otherwise used in a
+ * way not consistent with the End User License Agreement.
+ */
+'use strict';
+
+module.exports = function init(core) {
+  const { depHooks, patcher, routeCoverage } = core;
+
+  let handled;
+
+  return core.routeCoverage.http = {
+    install() {
+      ['http', 'https', 'spdy'].forEach((name) => {
+        depHooks.resolve({ name }, (_export) => {
+          if (!_export?.Server?.prototype) return;
+
+          patcher.patch(_export.Server.prototype, 'listen', {
+            name: `${name}.Server.prototype.listen`,
+            patchType: 'route-coverage',
+            post(data) {
+              data.result?.on('listening', () => {
+                if (!handled) {
+                  handled = true;
+                  routeCoverage.discoveryFinished();
+                }
+              });
+            }
+          });
+        });
+      });
+    }
+  };
+};

package/lib/install/koa.js

@@ -14,8 +14,8 @@
  */
 'use strict';
 
-const { createSignature, patchType } = require('./../utils/route-info');
 const { toLowerCase } = require('@contrast/common');
+const { createSignature, patchType } = require('./../utils/route-info');
 
 module.exports = function init(core) {
   const { patcher, depHooks, routeCoverage } = core;
@@ -37,46 +37,34 @@ module.exports = function init(core) {
       await next();
     };
 
-  function registerRouteHandler(Router) {
-    patcher.patch(Router.prototype, 'register', {
-      name: 'koaRouter.prototype',
-      patchType,
-      post: ({ args, result: layer }) => {
-        const [path, methods] = args;
-        if (!path || !methods || Array.isArray(path)) {
-          return;
-        }
+  return core.routeCoverage.koa = {
+    install() {
+      ['@koa/router', 'koa-router'].forEach((name) => {
+        depHooks.resolve({ name }, (_export) => {
+          if (!_export?.prototype?.register) return;
 
-        if (methods.length === 0) {
-          emitRouteCoverage(path, 'use');
-        } else {
-          methods.forEach((method) => {
-            emitRouteCoverage(path, toLowerCase(method || ''));
-          });
-        }
+          patcher.patch(_export.prototype, 'register', {
+            name: 'koaRouter.prototype',
+            patchType,
+            post: ({ args, result: layer }) => {
+              const [path, methods] = args;
+              if (!path || !methods || Array.isArray(path)) {
+                return;
+              }
 
-        layer.stack.unshift(routeObservationPathClosure({ path }).bind(this));
-      }
-    });
+              if (methods.length === 0) {
+                emitRouteCoverage(path, 'use');
+              } else {
+                methods.forEach((method) => {
+                  emitRouteCoverage(path, toLowerCase(method || ''));
+                });
+              }
 
-    patcher.patch(Router.prototype, 'routes', {
-      name: 'koaRouter.prototype',
-      patchType,
-      post: () => {
-        routeCoverage.discoveryFinished();
-      }
-    });
-  }
-
-  core.routeCoverage.koa = {
-    install() {
-      ['@koa/router', 'koa-router'].forEach((name) => {
-        depHooks.resolve(
-          { name }, registerRouteHandler.bind(this)
-        );
+              layer.stack.unshift(routeObservationPathClosure({ path }).bind(this));
+            }
+          });
+        });
       });
     }
   };
-
-  return core.routeCoverage.koa;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrast/route-coverage",
-  "version": "1.11.1",
+  "version": "1.11.2",
   "description": "Handles route discovery and observation",
   "license": "SEE LICENSE IN LICENSE",
   "author": "Contrast Security <nodejs@contrastsecurity.com> (https://www.contrastsecurity.com)",