feat: allow exclude prefix set dynamaic route

Author: fefit

examples/such.config.js

@@ -11,7 +11,7 @@ module.exports = {
       cors: true,
       prefix: [prefix, {
         exclude: [{
-          path: /list(\/\d+)?/,
+          path: "/list/:id?",
           method: 'post'
         }]
       }],

lib/commands/such-serve.js

@@ -165,6 +165,8 @@ program
       }
     }
   };
+  // dynamic route rule
+  const dynamicRouteRule = /\/:/;
   // http server
   const startHttpServer = async () => {
     const suchStoreConfig = cliSuch.store("config");
@@ -217,22 +219,118 @@ program
         ? () => timeout[0] + Math.round(Math.random() * timeout[1])
         : () => timeout || 0;
     const genTimeout = genTimeoutHandle(timeout);
+    // dynamic helper handles
+    const getDynamicRoutePatterns = (pathname) => {
+      const segments = trimPathnameLeft(pathname).split("/");
+      const pathSegs = [];
+      const patterns = [];
+      for (const seg of segments) {
+        if (seg.startsWith(":")) {
+          let len = seg.length;
+          let optional = false;
+          if (seg.endsWith("?")) {
+            optional = true;
+            len--;
+          }
+          const param = seg.slice(1, len);
+          patterns.push({
+            param,
+            optional,
+          });
+          pathSegs.push(`_${param}`);
+        } else {
+          patterns.push({
+            path: seg,
+            optional: false,
+          });
+          pathSegs.push(seg);
+        }
+      }
+      return {
+        pathSegs,
+        patterns,
+      };
+    };
+    const buildDynamicMatchFn = (pathname, patterns) => {
+      if (dynamicMatchFns[pathname]) {
+        return dynamicMatchFns[pathname];
+      }
+      if (!patterns) {
+        patterns = getDynamicRoutePatterns(pathname).patterns;
+      }
+      return (dynamicMatchFns[pathname] = (segs) => {
+        const params = {};
+        for (const [index, seg] of Object.entries(segs)) {
+          const pattern = patterns[index] || {};
+          if (hasOwn(pattern, "path")) {
+            if (pattern.path === seg) {
+              continue;
+            }
+          } else if (hasOwn(pattern, "param")) {
+            params[pattern.param] = seg;
+            continue;
+          }
+          return {
+            matched: false,
+            params,
+          };
+        }
+        if (patterns.length > segs.length) {
+          const leavePatterns = patterns.slice(segs.length);
+          for (const pattern of leavePatterns) {
+            if (!pattern.optional) {
+              return {
+                matched: false,
+                params,
+              };
+            }
+          }
+        }
+        return {
+          matched: true,
+          params,
+        };
+      });
+    };
+    const dynamicMatchFns = {};
+    // do with the prefix
     const hasPrefixExclude = Array.isArray(prefix);
     // find and remove the prefix
     const matchPrefix = prefix
       ? hasPrefixExclude
         ? (pathname, method) => {
             const [curPrefix, { exclude = [] } = {}] = prefix;
+            let params = {};
             // check if is in exclude
             const isInExclude = exclude.some((item) => {
+              let isDynamic = false;
+              let excludePathname;
               if (typeof item === "string") {
-                return pathname === item;
+                if (dynamicRouteRule.test(item)) {
+                  isDynamic = true;
+                  excludePathname = item;
+                } else {
+                  return pathname === item;
+                }
               } else if (isObject(item) && item.path) {
                 let isMatch = false;
-                if (typeof item.path === "string") {
-                  isMatch = item.path === pathname;
-                } else if (item.path instanceof RegExp) {
-                  isMatch = item.path.test(pathname);
+                const curPath = item.path;
+                if (typeof curPath === "string") {
+                  if (dynamicRouteRule.test(curPath)) {
+                    isDynamic = true;
+                    excludePathname = curPath;
+                  } else {
+                    isMatch = curPath === pathname;
+                  }
+                } else if (curPath instanceof RegExp) {
+                  isMatch = curPath.test(pathname);
+                }
+                // dynamic route
+                if (isDynamic) {
+                  const matchFn = buildDynamicMatchFn(excludePathname);
+                  const ret = matchFn(trimPathnameLeft(pathname).split("/"));
+                  isMatch = ret.matched;
+                  if (isMatch) params = ret.params;
                 }
                 if (isMatch && item.method) {
                   return item.method === method;
@@ -246,6 +344,7 @@ program
                 matched: true,
                 pathname,
                 exclude: true,
+                params,
               };
             }
             // not in exclude
@@ -381,35 +480,12 @@ program
           ? config.method
           : [config.method]
         : undefined;
-      if (/\/:/.test(key)) {
-        const segments = trimPathnameLeft(key).split("/");
-        const pathSegs = [];
-        const patterns = [];
-        for (const seg of segments) {
-          if (seg.startsWith(":")) {
-            let len = seg.length;
-            let optional = false;
-            if (seg.endsWith("?")) {
-              optional = true;
-              len--;
-            }
-            const param = seg.slice(1, len);
-            patterns.push({
-              param,
-              optional,
-            });
-            pathSegs.push(`_${param}`);
-          } else {
-            patterns.push({
-              path: seg,
-              optional: false,
-            });
-            pathSegs.push(seg);
-          }
-        }
+      if (dynamicRouteRule.test(key)) {
+        const { pathSegs, patterns } = getDynamicRoutePatterns(key);
         const pathname = hasOwn(config, "rewrite")
           ? trimPathnameLeft(config.rewrite)
           : pathSegs.join("/");
+        const matchFn = buildDynamicMatchFn(key, patterns);
         const matcher = (segs, method) => {
           // first, check the method if is matched
           if (allowMethods && !allowMethods.includes(method)) {
@@ -418,39 +494,16 @@ program
             };
           }
           // check the pathname segments
-          const params = {};
-          for (const [index, seg] of Object.entries(segs)) {
-            const pattern = patterns[index] || {};
-            if (hasOwn(pattern, "path")) {
-              if (pattern.path === seg) {
-                continue;
-              }
-            } else if (hasOwn(pattern, "param")) {
-              params[pattern.param] = seg;
-              continue;
-            }
+          const ret = matchFn(segs);
+          if (ret.matched) {
             return {
-              matched: false,
-              params,
+              matched: true,
+              params: ret.params,
+              pathname,
+              origPathname: key,
             };
           }
-          if (patterns.length > segs.length) {
-            const leavePatterns = patterns.slice(segs.length);
-            for (const pattern of leavePatterns) {
-              if (!pattern.optional) {
-                return {
-                  matched: false,
-                  params,
-                };
-              }
-            }
-          }
-          return {
-            matched: true,
-            params,
-            pathname,
-            origPathname: key,
-          };
+          return ret;
         };
         dynamicRouteMatcher.push(matcher);
       } else {
@@ -518,6 +571,7 @@ program
       let matched = true;
       let searchExtensions = extensions;
       let reason = "";
+      let params = {};
       printDebugInfo("Request url", addr);
       // print the debug information
       if (debug) printDebugInfo("The request's pathname", pathname);
@@ -552,6 +606,7 @@ program
         const prefixData = matchPrefix(pathname, method);
         matched = prefixData.matched;
         pathname = prefixData.pathname;
+        params = prefixData.params || params;
         if (!matched)
           reason = `The url's pathname not match a prefix ${
             hasPrefixExclude
@@ -586,7 +641,6 @@ program
         // do with dynamic routes
         const pathSegs = pathname.split("/");
         const dynamicRoute = matchDynamicRoute(pathSegs, method);
-        let params = {};
         if (dynamicRoute.matched) {
           pathname = dynamicRoute.pathname;
           params = dynamicRoute.params;

package.json

@@ -1,7 +1,7 @@
 {
   "name": "such-cli",
   "description": "Run a mock server & Generate fake data & Initialize suchjs in command line.",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "author": "[email protected]",
   "bin": {
     "such": "bin/such.js"