refactor: optimize router handling and middleware execution logic

Author: jkyberneees

index.js

@@ -1,82 +1,112 @@
-const handlers = {
-  match: updateParams => (req, res, params) => {
-    if (updateParams) {
-      req.params = params
-    }
+// Optimized handlers with minimal allocations
+const createMatchHandler = (updateParams) =>
+  updateParams
+    ? (req, res, params) => {
+        req.params = params;
+        return true;
+      }
+    : () => true;
+
+const defaultHandler = () => false;
 
-    return true
-  },
-  default: () => false
+// Router cache for reusing router instances
+const routerCache = new WeakMap();
+
+function normalizeEndpoint(endpoint) {
+  if (typeof endpoint === "string") {
+    return { url: endpoint, methods: ["GET"], updateParams: false };
+  }
+  return {
+    methods: endpoint.methods || ["GET"],
+    url: endpoint.url,
+    version: endpoint.version,
+    updateParams: endpoint.updateParams || false,
+  };
 }
 
-module.exports = function (routerOpts = {}, routerFactory = require('find-my-way')) {
-  routerOpts.defaultRoute = handlers.default
-
-  function exec (options, isIff = true) {
-    const middleware = this
-
-    // independent router instance per config
-    const router = routerFactory(routerOpts)
-
-    const opts = typeof options === 'function' ? { custom: options } : (Array.isArray(options) ? { endpoints: options } : options)
-    if (opts.endpoints && opts.endpoints.length) {
-      // setup matching router
-      opts.endpoints
-        .map(endpoint => typeof endpoint === 'string' ? { url: endpoint } : endpoint)
-        .forEach(({ methods = ['GET'], url, version, updateParams = false }) => {
-          if (version) {
-            router.on(methods, url, { constraints: { version } }, handlers.match(updateParams))
-          } else {
-            router.on(methods, url, handlers.match(updateParams))
+module.exports = function (routerOpts = {}, routerFactory = require("find-my-way")) {
+  function exec(options, isIff = true) {
+    const middleware = this;
+    let router = null;
+    let customFn = null;
+
+    // Process options efficiently
+    if (typeof options === "function") {
+      customFn = options;
+    } else {
+      const endpoints = Array.isArray(options) ? options : options?.endpoints;
+
+      if (endpoints?.length) {
+        // Try to get cached router first
+        let cache = routerCache.get(routerOpts);
+        if (!cache) {
+          cache = new Map();
+          routerCache.set(routerOpts, cache);
+        }
+
+        const cacheKey = JSON.stringify(endpoints);
+        router = cache.get(cacheKey);
+
+        if (!router) {
+          router = routerFactory({ ...routerOpts, defaultRoute: defaultHandler });
+
+          // Normalize and register routes
+          const normalized = endpoints.map(normalizeEndpoint);
+          for (const { methods, url, version, updateParams } of normalized) {
+            const handler = createMatchHandler(updateParams);
+
+            if (version) {
+              router.on(methods, url, { constraints: { version } }, handler);
+            } else {
+              router.on(methods, url, handler);
+            }
           }
-        })
+
+          cache.set(cacheKey, router);
+        }
+      }
+
+      if (options?.custom) {
+        customFn = options.custom;
+      }
     }
 
+    // Optimized execution function
     const result = function (req, res, next) {
-      // supporting custom matching function
-      if (opts.custom) {
-        if (opts.custom(req)) {
-          if (isIff) {
-            return middleware(req, res, next)
-          }
-        } else if (!isIff) {
-          return middleware(req, res, next)
-        }
+      let shouldExecute = false;
 
-        // leave here and do not process opts.endpoints
-        return next()
+      if (customFn) {
+        shouldExecute = customFn(req);
+      } else if (router) {
+        shouldExecute = router.lookup(req, res);
       }
 
-      // matching endpoints and moving forward
-      if (router.lookup(req, res)) {
-        if (isIff) {
-          return middleware(req, res, next)
-        }
-      } else if (!isIff) {
-        return middleware(req, res, next)
+      // Simplified logic: execute middleware if conditions match
+      if ((isIff && shouldExecute) || (!isIff && !shouldExecute)) {
+        return middleware(req, res, next);
       }
 
-      return next()
-    }
+      return next();
+    };
 
-    // allowing chaining
-    result.iff = iff
-    result.unless = unless
+    // Allow chaining
+    result.iff = iff;
+    result.unless = unless;
 
-    return result
+    return result;
   }
 
-  function iff (options) {
-    return exec.call(this, options, true)
+  function iff(options) {
+    return exec.call(this, options, true);
   }
-  function unless (options) {
-    return exec.call(this, options, false)
+  function unless(options) {
+    return exec.call(this, options, false);
   }
 
   return function (middleware) {
-    middleware.iff = iff
-    middleware.unless = unless
+    middleware.iff = iff;
+    middleware.unless = unless;
 
-    return middleware
-  }
-}
+    return middleware;
+  };
+};