Extremely Popular
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456/** * Adapted directly from koa-router at * https://github.com/alexmingoia/koa-router/ which is licensed as: * * The MIT License (MIT) * * Copyright (c) 2015 Alexander C. Mingoia * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */
import { Context } from "./context.ts";import { Status } from "./deps.ts";import { httpErrors } from "./httpError.ts";import { Middleware, compose } from "./middleware.ts";import { Key, pathToRegExp } from "./pathToRegExp.ts";import { HTTPMethods } from "./types.ts";import { decodeComponent } from "./util.ts";
const { MethodNotAllowed, NotImplemented } = httpErrors;
interface AllowedMethodsOptions { /** A method to be called in lieu of throwing a `MethodNotAllowed` HTTP * error. */ methodNotAllowed?: () => any;
/** A method to be called in lieu of throwing a `NotImplemented` HTTP * error */ notImplemented?: () => any; throw?: boolean;}
export type RouteParams = Record<string | number, string | undefined>;
export interface Route { path: string; methods: HTTPMethods[]; middleware: RouterMiddleware[]; options?: RouterOptions;}
/** The context passed router middleware. */export interface RouterContext< P extends RouteParams = RouteParams, S extends Record<string | number | symbol, any> = Record<string, any>,> extends Context<S> { /** Any parameters parsed from the route when matched. */ params: P;
/** A reference to the router instance. */ router: Router;}
export interface RouterMiddleware< P extends RouteParams = RouteParams, S extends Record<string | number | symbol, any> = Record<string, any>,> { (context: RouterContext<P, S>, next: () => Promise<void>): | Promise< void > | void;}
export interface RouterOptions { /** The part of the path that should prefix all the routes for this * router. */ prefix?: string;
/** The set of HTTP methods that this router can service. */ methods?: HTTPMethods[];
/** Determines if routes are matched in a case sensitive way. Defaults to * `false`. */ sensitive?: boolean;
/** Determines if routes are matched strictly, where the trailing `/` is not * optional. Defaults to `false`. */ strict?: boolean;}
interface LayerOptions { ignoreCaptures?: boolean; name?: string; sensitive?: boolean; strict?: boolean;}
class Layer { name: string | null; paramNames: Key[] = []; regexp: RegExp; stack: RouterMiddleware[];
constructor( public path: string, public methods: HTTPMethods[], middleware: RouterMiddleware | RouterMiddleware[], public options: LayerOptions = {}, ) { this.name = options.name ?? null; this.stack = Array.isArray(middleware) ? middleware : [middleware]; if (this.methods.includes("GET")) { this.methods.unshift("HEAD"); } this.regexp = pathToRegExp(path, this.paramNames, options); }
matches(path: string): boolean { return this.regexp.test(path); }
params(captures: string[], existingParams: RouteParams = {}): RouteParams { const params = existingParams; for (let i = 0; i < captures.length; i++) { if (this.paramNames[i]) { const capture = captures[i]; params[this.paramNames[i].name] = capture ? decodeComponent(capture) : capture; } } return params; }
captures(path: string): string[] { if (this.options.ignoreCaptures) { return []; } const [, ...captures] = path.match(this.regexp)!; return captures; }
setPrefix(prefix: string): this { if (this.path) { this.path = `${prefix}${this.path}`; this.paramNames = []; this.regexp = pathToRegExp(this.path, this.paramNames, this.options); } return this; }}
function inspectLayer(layer: Layer): Route { const { path, methods, stack, options } = layer; return { path, methods: [...methods], middleware: [...stack], options: options ? { ...options } : undefined, };}
const contextRouteMatches = new WeakMap<RouterContext, Layer[]>();
/** A class that routes requests to middleware based on the method and the * path name of the request. */export class Router { #methods: HTTPMethods[]; #prefix = ""; #stack: Layer[] = []; #strict = false;
#addRoute = ( path: string | string[], middleware: RouterMiddleware[], ...methods: HTTPMethods[] ): this => { if (Array.isArray(path)) { for (const r of path) { this.#addRoute(r, middleware, ...methods); } return this; } const layer = new Layer( path, methods, middleware, { strict: this.#strict }, ); layer.setPrefix(this.#prefix); this.#stack.push(layer); return this; };
#match = ( path: string, method: HTTPMethods, ): { routesMatched: Layer[]; matches: Layer[] } => { const routesMatched: Layer[] = []; const matches: Layer[] = []; for (const layer of this.#stack) { if (layer.matches(path)) { routesMatched.push(layer); if (layer.methods.includes(method)) { matches.push(layer); } } } return { routesMatched, matches }; };
constructor(options: RouterOptions = {}) { this.#methods = options.methods || [ "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", ]; if (options.prefix) this.#prefix = options.prefix; if (options.strict) this.#strict = options.strict; }
/** Register middleware for the specified routes and the `DELETE`, `GET`, * `POST`, or `PUT` method is requested */ all<P extends RouteParams = RouteParams>( route: string | string[], ...middleware: RouterMiddleware<P>[] ): this { return this.#addRoute( route, middleware as RouterMiddleware[], "DELETE", "GET", "POST", "PUT", ); }
/** Middleware that automatically handles dealing with responding with * allowed methods for the defined routes. */ allowedMethods(options: AllowedMethodsOptions = {}): Middleware { const implemented = this.#methods; return async function allowedMethods(context, next) { await next(); const allowed = new Set<HTTPMethods>(); if ( !context.response.status || context.response.status === Status.NotFound ) { const contextRoutesMatched = contextRouteMatches.get( context as RouterContext, ); if (contextRoutesMatched) { for (const layer of contextRoutesMatched) { for (const method of layer.methods) { allowed.add(method); } } } const allowedValue = Array.from(allowed).join(", "); if (!implemented.includes(context.request.method)) { if (options.throw) { let notImplementedThrowable: any; if (typeof options.notImplemented === "function") { notImplementedThrowable = options.notImplemented(); } else { notImplementedThrowable = new NotImplemented(); } throw notImplementedThrowable; } else { context.response.status = Status.NotImplemented; context.response.headers.set("Allow", allowedValue); } } else if (allowed.size) { if (context.request.method === "OPTIONS") { context.response.status = Status.OK; context.response.body = ""; context.response.headers.set("Allow", allowedValue); } else if (!allowed.has(context.request.method)) { if (options.throw) { let notAllowedThrowable: any; if (typeof options.methodNotAllowed === "function") { notAllowedThrowable = options.methodNotAllowed(); } else { notAllowedThrowable = new MethodNotAllowed(); } throw notAllowedThrowable; } else { context.response.status = Status.MethodNotAllowed; context.response.headers.set("Allow", allowedValue); } } } } }; }
/** Register middleware for the specified routes when the `DELETE` method is * requested. */ delete<P extends RouteParams = RouteParams>( route: string | string[], ...middleware: RouterMiddleware<P>[] ): this { return this.#addRoute(route, middleware as RouterMiddleware[], "DELETE"); }
/** Register middleware for the specified routes when the `GET` method is * requested. */ get<P extends RouteParams = RouteParams>( route: string | string[], ...middleware: RouterMiddleware<P>[] ): this { return this.#addRoute(route, middleware as RouterMiddleware[], "GET"); }
/** Register middleware for the specified routes when the `HEAD` method is * requested. */ head<P extends RouteParams = RouteParams>( route: string | string[], ...middleware: RouterMiddleware<P>[] ): this { return this.#addRoute(route, middleware as RouterMiddleware[], "HEAD"); }
/** Register middleware for the specified routes when the `OPTIONS` method is * requested. */ options<P extends RouteParams = RouteParams>( route: string | string[], ...middleware: RouterMiddleware<P>[] ): this { return this.#addRoute(route, middleware as RouterMiddleware[], "OPTIONS"); }
/** Register middleware for the specified routes when the `PATCH` method is * requested. */ patch<P extends RouteParams = RouteParams>( route: string | string[], ...middleware: RouterMiddleware<P>[] ): this { return this.#addRoute(route, middleware as RouterMiddleware[], "PATCH"); }
/** Register middleware for the specified routes when the `POST` method is * requested. */ post<P extends RouteParams = RouteParams>( route: string | string[], ...middleware: RouterMiddleware<P>[] ): this { return this.#addRoute(route, middleware as RouterMiddleware[], "POST"); }
/** Register middleware for the specified routes when the `PUT` method is * requested. */ put<P extends RouteParams = RouteParams>( route: string | string[], ...middleware: RouterMiddleware<P>[] ): this { return this.#addRoute(route, middleware as RouterMiddleware[], "PUT"); }
/** Return middleware that represents all the currently registered routes. */ routes(): Middleware { const dispatch = async ( context: RouterContext, next: () => Promise<void>, ): Promise<void> => { const { url: { pathname }, method } = context.request; const { routesMatched, matches } = this.#match(pathname, method);
const contextRoutesMatched = contextRouteMatches.get(context); contextRouteMatches.set( context, contextRoutesMatched ? [...contextRoutesMatched, ...routesMatched] : routesMatched, );
context.router = this;
if (!matches.length) { return next(); }
const chain = matches.reduce((prev, layer) => { prev.push((context: RouterContext, next: () => Promise<void>) => { const captures = layer.captures(pathname); context.params = layer.params(captures, context.params); return next(); }); return [...prev, ...layer.stack]; }, [] as RouterMiddleware[]); return compose(chain)(context as RouterContext); }; return dispatch as Middleware; }
// Iterator interfaces
*entries(): IterableIterator<[Route, Route]> { for (const layer of this.#stack) { const value = inspectLayer(layer); yield [value, value]; } }
forEach( callback: (value1: Route, value2: Route, router: this) => void, thisArg: any = null, ): void { for (const layer of this.#stack) { const value = inspectLayer(layer); callback.call(thisArg, value, value, this); } }
*keys(): IterableIterator<Route> { for (const layer of this.#stack) { yield inspectLayer(layer); } }
*values(): IterableIterator<Route> { for (const layer of this.#stack) { yield inspectLayer(layer); } }
*[Symbol.iterator](): IterableIterator<Route> { for (const layer of this.#stack) { yield inspectLayer(layer); } }}