@jnode/server 2.0.1 → 2.1.0

package/README.md

@@ -264,10 +264,11 @@ We provide two methods to use them:
   - `<METHOD>/<path_segment>[/<path_segment>...]` [router](#class-serverrouter) | [handler-extended](#handler-extended) Used when the method matches; equals to `'/<path_segment>': r.Method({ '<METHOD>': <value> })`. E.G., `'GET/meow': 'Meow!'` (only works for HTTP method `'GET'`).
   - `@<METHOD>/<path_segment>[/<path_segment>...]` [router](#class-serverrouter) | [handler-extended](#handler-extended) Used when both the path resolver ends and the method matches; equals to `'/<path_segment>': r.Path(r.Method({ '<METHOD>': <value> }))`. E.G., `'@GET/meow': 'Meow!'` (only works for path `'/meow'` but not `'/meow/something'` and request method is `'GET'`).
   - `*` [router](#class-serverrouter) | [handler-extended](#handler-extended) Any path segment. E.G. `'*': h.Text('Meow? Nothing here!', { statusCode: 404 })`.
+  - `/%:<path_parameter_name>` [router](#class-serverrouter) | [handler-extended](#handler-extended) Match any segment (if exists) and save the segment to `ctx.params` by `<path_parameter_name>`. Do the similar thing as [`PathArgRouter`](#router-pathargrouterparamname-next).
 
 `PathRouter` is probably the most important router; almost every server needs it!
 
-By the way, we **DO NOT** support `'/*'` as a universal matching character, don't try this.
+By the way, if you’re looking for a universal matching character, use `'/%:'` instead of `'/*'` (this will match to `'*'` in a literal sense).
 
 #### How it works?
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jnode/server",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "description": "Simple web server package for Node.js.",
   "main": "src/index.js",
   "scripts": {

package/src/handlers.js

@@ -54,7 +54,7 @@ class DataHandler {
 // file handler: local file
 class FileHandler {
     constructor(file, options = {}) {
-        this.file = path.resolve(this.file);
+        this.file = path.resolve(file);
         this.options = options;
 
         // range may be disabled by `options.disableRange` or when `statusCode` is set to non-200 value

package/src/routers.js

@@ -29,20 +29,30 @@ class PathRouter {
             // key format: '[@ (path end check)][METHOD (method check)]/path/segments'
             // example: '@ GET /cat/names', 'POST /cats', '/api'
             const routeEnd = key.startsWith('@');
-            const routeMethod = key.substring(routeEnd ? 1 : 0, firstSlashIndex).trim().toUpperCase();
-            const routePath = key.substring(firstSlashIndex).split('/').slice(1).map(decodeURIComponent);
+            const routeMethod = key.substring(routeEnd ? 1 : 0, firstSlashIndex).trim();
+            const routePath = key.substring(firstSlashIndex).split('/').slice(1);
 
             // expand map
             let current = this.map;
-            for (const segment of routePath) {
-                if (!current['/' + segment]) current['/' + segment] = {};
-                current = current['/' + segment];
+            let args = [];
+            for (let segment of routePath) {
+                if (segment.startsWith('%:')) {
+                    args.push(segment.substring(2));
+                    if (!current[':']) current[':'] = {};
+                    current = current[':'];
+                    continue;
+                }
+
+                segment = '/' + decodeURIComponent(segment);
+                if (!current[segment]) current[segment] = {};
+                current = current[segment];
             }
 
             // '*' for non-end check, '@' for end check
             // '*' for any method, 'METHOD' for specific method
             if (!current[routeEnd ? '@' : '*']) current[routeEnd ? '@' : '*'] = {};
             current[routeEnd ? '@' : '*'][routeMethod || '*'] = value;
+            if (args.length > 0) current[routeEnd ? '@' : '*']['::' + (routeMethod || '*')] = args;
         }
     }
 
@@ -52,14 +62,23 @@ class PathRouter {
         let result = this.map['*'];
         let resultPointer = env.pathPointer;
         let current = this.map;
+        let resultArgs = [];
+        let currentArgs = [];
+        let resultArgNames = [];
         while (env.pathPointer < env.path.length) {
-            const segment = '/' + env.path[env.pathPointer];
-            if (!current[segment]) break;
+            let segment = '/' + env.path[env.pathPointer];
+            if (!current[segment] && !current[':']) break;
+            if (!current[segment]) {
+                segment = ':';
+                currentArgs.push(env.path[env.pathPointer]);
+            }
 
             // prepare fallback
             if (current[segment]['*']?.['*'] || current[segment]['*']?.[ctx.method]) {
                 result = current[segment]['*'][ctx.method] ?? current[segment]['*']['*'];
                 resultPointer = env.pathPointer + 1;
+                resultArgs = [...currentArgs];
+                resultArgNames = current[segment]['*']['::' + ctx.method] ?? current[segment]['*']['::*'];
             }
 
             current = current[segment];
@@ -69,10 +88,15 @@ class PathRouter {
             if (env.pathPointer >= env.path.length && (current['@']?.['*'] || current['@']?.[ctx.method])) {
                 result = current['@'][ctx.method] ?? current['@']['*'];
                 resultPointer = env.pathPointer;
+                resultArgs = currentArgs;
+                resultArgNames = current['@']['::' + ctx.method] ?? current['@']['::*'];
             }
         }
 
         env.pathPointer = resultPointer;
+        if (resultArgNames) resultArgs.forEach((arg, index) => {
+            ctx.params[resultArgNames[index]] = arg;
+        });
         return result;
     }
 }