+++ /dev/null
-/* eslint-disable security/detect-object-injection */
-'use strict';
-
-/**
- * A very simple router.
- */
-
-const { METHODS: httpMethods } = require('http');
-const common = require('./common');
-const { DingusError } = require('./errors');
-
-// Internal identifiers for route entries.
-const METHODS = Symbol('METHODS');
-const PARAM = Symbol('PARAM');
-
-const defaultOptions = {
- ignoreTrailingSlash: false,
- paramPrefix: ':',
-};
-
-class Router {
- /**
- * @param {Object} options
- * @param {Boolean} options.ignoreTrailingSlash
- * @param {Boolean} options.paramPrefix
- */
- constructor(options = {}) {
- common.setOptions(this, defaultOptions, options);
-
- // Keep lists of paths to match, indexed by path length.
- this.pathsByLength = {
- 1: [],
- };
-
- this.METHODS = METHODS;
- this.PARAM = PARAM;
- }
-
-
- /**
- * Prepare a path for insertion into search list.
- * A searchable path is a list of path parts, with a property of method handlers.
- * @param {string} pathDefinition
- */
- _pathDefinitionToPathMatch(pathDefinition) {
- const pathMatch = pathDefinition.split('/').map((p) => p.startsWith(this.paramPrefix) ? { [PARAM]: p.slice(this.paramPrefix.length) } : p);
- if (this.ignoreTrailingSlash
- && pathMatch[pathMatch.length - 1] === '') {
- pathMatch.pop();
- }
- pathMatch[METHODS] = {};
- pathMatch.forEach((p) => Object.freeze(p));
- Object.freeze(pathMatch);
- return pathMatch;
- }
-
-
- /**
- * Compare checkPath to fixedPath, no param substitution, params must match.
- * @param {*} fixedPath
- * @param {*} checkPath
- */
- static _pathCompareExact(fixedPath, checkPath) {
- if (fixedPath.length !== checkPath.length) {
- return false;
- }
- for (let i = 0; i < fixedPath.length; i++) {
- const fixedPart = fixedPath[i];
- const checkPart = checkPath[i];
- if (typeof fixedPart === 'object' && typeof checkPart === 'object') {
- if (fixedPart[PARAM] !== checkPart[PARAM]) {
- return false;
- }
- } else if (fixedPart !== checkPart) {
- return false;
- }
- }
- return true;
- }
-
-
- /**
- * Compare checkPath to fixedPath, populating params.
- * @param {*} fixedPath
- * @param {*} checkPath
- * @param {*} returnParams
- */
- static _pathCompareParam(fixedPath, checkPath, returnParams = {}) {
- const params = {};
-
- if (fixedPath.length !== checkPath.length) {
- return false;
- }
- for (let i = 0; i < fixedPath.length; i++) {
- const fixedPart = fixedPath[i];
- const checkPart = checkPath[i];
- if (typeof fixedPart === 'object') {
- params[fixedPart[PARAM]] = checkPart;
- } else if (fixedPart !== checkPart) {
- return false;
- }
- }
- Object.assign(returnParams, params);
- return true;
- }
-
-
- /**
- * Search for an existing path, return matched path and path parameters.
- * @param {Array} matchParts
- */
- _pathFind(matchParts) {
- const result = {
- pathParams: {},
- matchedPath: undefined,
- };
- const pathsByLength = this.pathsByLength[matchParts.length];
- if (pathsByLength) {
- for (const p of pathsByLength) {
- if (Router._pathCompareParam(p, matchParts, result.pathParams)) {
- result.matchedPath = p;
- break;
- }
- }
- }
- return result;
- }
-
-
- /**
- * Return a matching path, no param substitution, params must match
- * @param {*} matchParts
- */
- _pathFindExact(matchParts) {
- const pathsByLength = this.pathsByLength[matchParts.length];
- if (pathsByLength) {
- for (const p of pathsByLength) {
- if (Router._pathCompareExact(p, matchParts)) {
- return p;
- }
- }
- }
- return undefined;
- }
-
-
- /**
- * Insert a new path handler.
- * @param {string|string[]} methods
- * @param {string} urlPath
- * @param {fn} handler
- */
- on(methods, urlPath, handler) {
- const matchParts = this._pathDefinitionToPathMatch(urlPath);
- let existingPath = this._pathFindExact(matchParts);
- if (!existingPath) {
- existingPath = matchParts;
- if (!(matchParts.length in this.pathsByLength)) {
- this.pathsByLength[matchParts.length] = [];
- }
- this.pathsByLength[matchParts.length].push(existingPath);
- }
- if (!Array.isArray(methods)) {
- methods = [methods];
- }
- methods.forEach((method) => {
- if (!httpMethods.includes(method) && method !== '*') {
- throw new DingusError(`invalid method '${method}'`);
- }
- existingPath[METHODS][method] = handler;
- });
- }
-
-
- /**
- * Return a matching handler for a request, sets path parameters on context.
- * @param {string} method
- * @param {string[]} urlPath
- * @param {object} ctx
- */
- lookup(method, urlPath, ctx = {}) {
- const pathParts = urlPath.split('/').map((part) => decodeURIComponent(part));
- if (this.ignoreTrailingSlash
- && pathParts[pathParts.length - 1] === '') {
- pathParts.pop();
- }
- const { matchedPath, pathParams } = this._pathFind(pathParts);
- ctx.params = pathParams;
- if (matchedPath) {
- ctx.matchedPath = matchedPath;
- if (method in matchedPath[METHODS]) {
- return matchedPath[METHODS][method];
- }
- if ('*' in matchedPath[METHODS]) {
- return matchedPath[METHODS]['*'];
- }
- throw new DingusError('NoMethod');
- }
- ctx.unmatchedPath = pathParts;
- throw new DingusError('NoPath');
- }
-
-
-}
-
-module.exports = Router;