@koa/router 12.0.1 → 13.0.1

package/README.md

@@ -69,6 +69,7 @@ See [API Reference](./API.md) for more documentation.
 | ---------------- |
 | **Alex Mingoia** |
 | **@koajs**       |
+| **Imed Jaberi**  |
 
 
 ## License
@@ -82,4 +83,4 @@ See [API Reference](./API.md) for more documentation.
 
 [lad]: https://lad.js.org
 
-[npm]: https//www.npmjs.com
+[npm]: https://www.npmjs.com

package/lib/layer.js

@@ -1,229 +1,246 @@
-const { parse: parseUrl, format: formatUrl } = require('url');
-const { pathToRegexp, compile, parse } = require('path-to-regexp');
+const { parse: parseUrl, format: formatUrl } = require('node:url');
+
+const { pathToRegexp, compile, parse, stringify } = require('path-to-regexp');
+
+module.exports = class Layer {
+  /**
+   * Initialize a new routing Layer with given `method`, `path`, and `middleware`.
+   *
+   * @param {String|RegExp} path Path string or regular expression.
+   * @param {Array} methods Array of HTTP verbs.
+   * @param {Array} middleware Layer callback/middleware or series of.
+   * @param {Object=} opts
+   * @param {String=} opts.name route name
+   * @param {String=} opts.sensitive case sensitive (default: false)
+   * @param {String=} opts.strict require the trailing slash (default: false)
+   * @param {Boolean=} opts.pathIsRegexp if true, treat `path` as a regular expression
+   * @returns {Layer}
+   * @private
+   */
+  constructor(path, methods, middleware, opts = {}) {
+    this.opts = opts;
+    this.name = this.opts.name || null;
+    this.methods = [];
+    this.paramNames = [];
+    this.stack = Array.isArray(middleware) ? middleware : [middleware];
 
-module.exports = Layer;
+    for (const method of methods) {
+      const l = this.methods.push(method.toUpperCase());
+      if (this.methods[l - 1] === 'GET') this.methods.unshift('HEAD');
+    }
 
-/**
- * Initialize a new routing Layer with given `method`, `path`, and `middleware`.
- *
- * @param {String|RegExp} path Path string or regular expression.
- * @param {Array} methods Array of HTTP verbs.
- * @param {Array} middleware Layer callback/middleware or series of.
- * @param {Object=} opts
- * @param {String=} opts.name route name
- * @param {String=} opts.sensitive case sensitive (default: false)
- * @param {String=} opts.strict require the trailing slash (default: false)
- * @returns {Layer}
- * @private
- */
+    // ensure middleware is a function
+    for (let i = 0; i < this.stack.length; i++) {
+      const fn = this.stack[i];
+      const type = typeof fn;
+      if (type !== 'function')
+        throw new Error(
+          `${methods.toString()} \`${
+            this.opts.name || path
+          }\`: \`middleware\` must be a function, not \`${type}\``
+        );
+    }
 
-function Layer(path, methods, middleware, opts = {}) {
-  this.opts = opts;
-  this.name = this.opts.name || null;
-  this.methods = [];
-  this.paramNames = [];
-  this.stack = Array.isArray(middleware) ? middleware : [middleware];
+    this.path = path;
 
-  for (const method of methods) {
-    const l = this.methods.push(method.toUpperCase());
-    if (this.methods[l - 1] === 'GET') this.methods.unshift('HEAD');
-  }
+    if (this.opts.pathIsRegexp === true) {
+      this.regexp = new RegExp(path);
+    } else if (this.path) {
+      if (this.opts.strict === true) {
+        // path-to-regexp renamed strict to trailing in v8.1.0
+        this.opts.trailing = false;
+      }
 
-  // ensure middleware is a function
-  for (let i = 0; i < this.stack.length; i++) {
-    const fn = this.stack[i];
-    const type = typeof fn;
-    if (type !== 'function')
-      throw new Error(
-        `${methods.toString()} \`${
-          this.opts.name || path
-        }\`: \`middleware\` must be a function, not \`${type}\``
-      );
+      const { regexp: regex, keys } = pathToRegexp(this.path, this.opts);
+      this.regexp = regex;
+      this.paramNames = keys;
+    }
   }
 
-  this.path = path;
-  this.regexp = pathToRegexp(path, this.paramNames, this.opts);
-}
-
-/**
- * Returns whether request `path` matches route.
- *
- * @param {String} path
- * @returns {Boolean}
- * @private
- */
-
-Layer.prototype.match = function (path) {
-  return this.regexp.test(path);
-};
-
-/**
- * Returns map of URL parameters for given `path` and `paramNames`.
- *
- * @param {String} path
- * @param {Array.<String>} captures
- * @param {Object=} params
- * @returns {Object}
- * @private
- */
+  /**
+   * Returns whether request `path` matches route.
+   *
+   * @param {String} path
+   * @returns {Boolean}
+   * @private
+   */
+  match(path) {
+    return this.regexp.test(path);
+  }
 
-Layer.prototype.params = function (path, captures, params = {}) {
-  for (let len = captures.length, i = 0; i < len; i++) {
-    if (this.paramNames[i]) {
-      const c = captures[i];
-      if (c && c.length > 0)
-        params[this.paramNames[i].name] = c ? safeDecodeURIComponent(c) : c;
+  /**
+   * Returns map of URL parameters for given `path` and `paramNames`.
+   *
+   * @param {String} path
+   * @param {Array.<String>} captures
+   * @param {Object=} params
+   * @returns {Object}
+   * @private
+   */
+  params(path, captures, params = {}) {
+    for (let len = captures.length, i = 0; i < len; i++) {
+      if (this.paramNames[i]) {
+        const c = captures[i];
+        if (c && c.length > 0)
+          params[this.paramNames[i].name] = c ? safeDecodeURIComponent(c) : c;
+      }
     }
-  }
 
-  return params;
-};
+    return params;
+  }
 
-/**
- * Returns array of regexp url path captures.
- *
- * @param {String} path
- * @returns {Array.<String>}
- * @private
- */
+  /**
+   * Returns array of regexp url path captures.
+   *
+   * @param {String} path
+   * @returns {Array.<String>}
+   * @private
+   */
+  captures(path) {
+    return this.opts.ignoreCaptures ? [] : path.match(this.regexp).slice(1);
+  }
 
-Layer.prototype.captures = function (path) {
-  return this.opts.ignoreCaptures ? [] : path.match(this.regexp).slice(1);
-};
+  /**
+   * Generate URL for route using given `params`.
+   *
+   * @example
+   *
+   * ```javascript
+   * const route = new Layer('/users/:id', ['GET'], fn);
+   *
+   * route.url({ id: 123 }); // => "/users/123"
+   * ```
+   *
+   * @param {Object} params url parameters
+   * @returns {String}
+   * @private
+   */
+  url(params, options) {
+    let args = params;
+    const url = this.path.replace(/\(\.\*\)/g, '');
+
+    if (typeof params !== 'object') {
+      args = Array.prototype.slice.call(arguments);
+      if (typeof args[args.length - 1] === 'object') {
+        options = args[args.length - 1];
+        args = args.slice(0, -1);
+      }
+    }
 
-/**
- * Generate URL for route using given `params`.
- *
- * @example
- *
- * ```javascript
- * const route = new Layer('/users/:id', ['GET'], fn);
- *
- * route.url({ id: 123 }); // => "/users/123"
- * ```
- *
- * @param {Object} params url parameters
- * @returns {String}
- * @private
- */
+    const toPath = compile(url, { encode: encodeURIComponent, ...options });
+    let replaced;
+    const { tokens } = parse(url);
+    let replace = {};
 
-Layer.prototype.url = function (params, options) {
-  let args = params;
-  const url = this.path.replace(/\(\.\*\)/g, '');
+    if (Array.isArray(args)) {
+      for (let len = tokens.length, i = 0, j = 0; i < len; i++) {
+        if (tokens[i].name) {
+          replace[tokens[i].name] = args[j++];
+        }
+      }
+    } else if (tokens.some((token) => token.name)) {
+      replace = params;
+    } else if (!options) {
+      options = params;
+    }
 
-  if (typeof params !== 'object') {
-    args = Array.prototype.slice.call(arguments);
-    if (typeof args[args.length - 1] === 'object') {
-      options = args[args.length - 1];
-      args = args.slice(0, -1);
+    for (const [key, value] of Object.entries(replace)) {
+      replace[key] = String(value);
     }
-  }
 
-  const toPath = compile(url, { encode: encodeURIComponent, ...options });
-  let replaced;
+    replaced = toPath(replace);
 
-  const tokens = parse(url);
-  let replace = {};
+    if (options && options.query) {
+      replaced = parseUrl(replaced);
+      if (typeof options.query === 'string') {
+        replaced.search = options.query;
+      } else {
+        replaced.search = undefined;
+        replaced.query = options.query;
+      }
 
-  if (Array.isArray(args)) {
-    for (let len = tokens.length, i = 0, j = 0; i < len; i++) {
-      if (tokens[i].name) replace[tokens[i].name] = args[j++];
+      return formatUrl(replaced);
     }
-  } else if (tokens.some((token) => token.name)) {
-    replace = params;
-  } else if (!options) {
-    options = params;
+
+    return replaced;
   }
 
-  replaced = toPath(replace);
+  /**
+   * Run validations on route named parameters.
+   *
+   * @example
+   *
+   * ```javascript
+   * router
+   *   .param('user', function (id, ctx, next) {
+   *     ctx.user = users[id];
+   *     if (!ctx.user) return ctx.status = 404;
+   *     next();
+   *   })
+   *   .get('/users/:user', function (ctx, next) {
+   *     ctx.body = ctx.user;
+   *   });
+   * ```
+   *
+   * @param {String} param
+   * @param {Function} middleware
+   * @returns {Layer}
+   * @private
+   */
+  param(param, fn) {
+    const { stack } = this;
+    const params = this.paramNames;
+    const middleware = function (ctx, next) {
+      return fn.call(this, ctx.params[param], ctx, next);
+    };
+
+    middleware.param = param;
+
+    const names = params.map(function (p) {
+      return p.name;
+    });
 
-  if (options && options.query) {
-    replaced = parseUrl(replaced);
-    if (typeof options.query === 'string') {
-      replaced.search = options.query;
-    } else {
-      replaced.search = undefined;
-      replaced.query = options.query;
+    const x = names.indexOf(param);
+    if (x > -1) {
+      // iterate through the stack, to figure out where to place the handler fn
+      stack.some((fn, i) => {
+        // param handlers are always first, so when we find an fn w/o a param property, stop here
+        // if the param handler at this part of the stack comes after the one we are adding, stop here
+        if (!fn.param || names.indexOf(fn.param) > x) {
+          // inject this param handler right before the current item
+          stack.splice(i, 0, middleware);
+          return true; // then break the loop
+        }
+      });
     }
 
-    return formatUrl(replaced);
+    return this;
   }
 
-  return replaced;
-};
-
-/**
- * Run validations on route named parameters.
- *
- * @example
- *
- * ```javascript
- * router
- *   .param('user', function (id, ctx, next) {
- *     ctx.user = users[id];
- *     if (!ctx.user) return ctx.status = 404;
- *     next();
- *   })
- *   .get('/users/:user', function (ctx, next) {
- *     ctx.body = ctx.user;
- *   });
- * ```
- *
- * @param {String} param
- * @param {Function} middleware
- * @returns {Layer}
- * @private
- */
-
-Layer.prototype.param = function (param, fn) {
-  const { stack } = this;
-  const params = this.paramNames;
-  const middleware = function (ctx, next) {
-    return fn.call(this, ctx.params[param], ctx, next);
-  };
-
-  middleware.param = param;
-
-  const names = params.map(function (p) {
-    return p.name;
-  });
-
-  const x = names.indexOf(param);
-  if (x > -1) {
-    // iterate through the stack, to figure out where to place the handler fn
-    stack.some(function (fn, i) {
-      // param handlers are always first, so when we find an fn w/o a param property, stop here
-      // if the param handler at this part of the stack comes after the one we are adding, stop here
-      if (!fn.param || names.indexOf(fn.param) > x) {
-        // inject this param handler right before the current item
-        stack.splice(i, 0, middleware);
-        return true; // then break the loop
+  /**
+   * Prefix route path.
+   *
+   * @param {String} prefix
+   * @returns {Layer}
+   * @private
+   */
+  setPrefix(prefix) {
+    if (this.path) {
+      this.path =
+        this.path !== '/' || this.opts.strict === true
+          ? `${prefix}${this.path}`
+          : prefix;
+      if (this.opts.pathIsRegexp === true || prefix instanceof RegExp) {
+        this.regexp = new RegExp(this.path);
+      } else if (this.path) {
+        const { regexp: regex, keys } = pathToRegexp(this.path, this.opts);
+        this.regexp = regex;
+        this.paramNames = keys;
       }
-    });
-  }
-
-  return this;
-};
-
-/**
- * Prefix route path.
- *
- * @param {String} prefix
- * @returns {Layer}
- * @private
- */
+    }
 
-Layer.prototype.setPrefix = function (prefix) {
-  if (this.path) {
-    this.path =
-      this.path !== '/' || this.opts.strict === true
-        ? `${prefix}${this.path}`
-        : prefix;
-    this.paramNames = [];
-    this.regexp = pathToRegexp(this.path, this.paramNames, this.opts);
+    return this;
   }
-
-  return this;
 };
 
 /**
@@ -237,7 +254,8 @@ Layer.prototype.setPrefix = function (prefix) {
 
 function safeDecodeURIComponent(text) {
   try {
-    return decodeURIComponent(text);
+    // @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#decoding_query_parameters_from_a_url
+    return decodeURIComponent(text.replace(/\+/g, ' '));
   } catch {
     return text;
   }