Skip to main content
Module

x/mandarinets/deps.ts>Router

Mandarine.TS is a typescript, decorator-driven framework that allows you to create server-side applications. Mandarine.TS provides a range of built-in solutions such as Dependency Injection, Components, ORM and more. Under its umbrella, Mandarine.TS has 4 modules: Core, Data, Security and MVC, these modules will offer you the requirements to build a Mandarine-powered application.
Latest
class Router
import { Router } from "https://deno.land/x/mandarinets@v2.3.2/deps.ts";

An interface for registering middleware that will run when certain HTTP methods and paths are requested, as well as provides a way to parameterize parts of the requested path.

Constructors

new
Router(opts?: RouterOptions)

Type Parameters

optional
RP extends RouteParams = RouteParams
optional
RS extends State = Record<string, any>

Methods

all<P extends RouteParams = RP, S extends State = RS>(
name: string,
path: string,
...middleware: RouterMiddleware<P, S>[],
): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register named middleware for the specified routes when the DELETE, GET, POST, or PUT method is requested.

all<P extends RouteParams = RP, S extends State = RS>(path: string, ...middleware: RouterMiddleware<P, S>[]): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register middleware for the specified routes when the DELETE, GET, POST, or PUT method is requested.

allowedMethods(options?: RouterAllowedMethodsOptions): Middleware

Middleware that handles requests for HTTP methods registered with the router. If none of the routes handle a method, then "not allowed" logic will be used. If a method is supported by some routes, but not the particular matched router, then "not implemented" will be returned.

The middleware will also automatically handle the OPTIONS method, responding with a 200 OK when the Allowed header sent to the allowed methods for a given route.

By default, a "not allowed" request will respond with a 405 Not Allowed and a "not implemented" will respond with a 501 Not Implemented. Setting the option .throw to true will cause the middleware to throw an HTTPError instead of setting the response status. The error can be overridden by providing a .notImplemented or .notAllowed method in the options, of which the value will be returned will be thrown instead of the HTTP error.

delete<P extends RouteParams = RP, S extends State = RS>(
name: string,
path: string,
...middleware: RouterMiddleware<P, S>[],
): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register named middleware for the specified routes when the DELETE, method is requested.

delete<P extends RouteParams = RP, S extends State = RS>(path: string, ...middleware: RouterMiddleware<P, S>[]): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register middleware for the specified routes when the DELETE, method is requested.

entries(): IterableIterator<[Route, Route]>

Iterate over the routes currently added to the router. To be compatible with the iterable interfaces, both the key and value are set to the value of the route.

forEach(callback: (
value1: Route,
value2: Route,
router: this,
) => void
, thisArg?: any
): void

Iterate over the routes currently added to the router, calling the callback function for each value.

get<P extends RouteParams = RP, S extends State = RS>(
name: string,
path: string,
...middleware: RouterMiddleware<P, S>[],
): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register named middleware for the specified routes when the GET, method is requested.

get<P extends RouteParams = RP, S extends State = RS>(path: string, ...middleware: RouterMiddleware<P, S>[]): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register middleware for the specified routes when the GET, method is requested.

head<P extends RouteParams = RP, S extends State = RS>(
name: string,
path: string,
...middleware: RouterMiddleware<P, S>[],
): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register named middleware for the specified routes when the HEAD, method is requested.

head<P extends RouteParams = RP, S extends State = RS>(path: string, ...middleware: RouterMiddleware<P, S>[]): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register middleware for the specified routes when the HEAD, method is requested.

keys(): IterableIterator<Route>

Iterate over the routes currently added to the router. To be compatible with the iterable interfaces, the key is set to the value of the route.

options<P extends RouteParams = RP, S extends State = RS>(
name: string,
path: string,
...middleware: RouterMiddleware<P, S>[],
): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register named middleware for the specified routes when the OPTIONS, method is requested.

options<P extends RouteParams = RP, S extends State = RS>(path: string, ...middleware: RouterMiddleware<P, S>[]): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register middleware for the specified routes when the OPTIONS, method is requested.

param<S extends State = RS>(param: keyof RP, middleware: RouterParamMiddleware<RP, S>): Router<RP, S>

Register param middleware, which will be called when the particular param is parsed from the route.

patch<P extends RouteParams = RP, S extends State = RS>(
name: string,
path: string,
...middleware: RouterMiddleware<P, S>[],
): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register named middleware for the specified routes when the PATCH, method is requested.

patch<P extends RouteParams = RP, S extends State = RS>(path: string, ...middleware: RouterMiddleware<P, S>[]): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register middleware for the specified routes when the PATCH, method is requested.

post<P extends RouteParams = RP, S extends State = RS>(
name: string,
path: string,
...middleware: RouterMiddleware<P, S>[],
): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register named middleware for the specified routes when the POST, method is requested.

post<P extends RouteParams = RP, S extends State = RS>(path: string, ...middleware: RouterMiddleware<P, S>[]): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register middleware for the specified routes when the POST, method is requested.

prefix(prefix: string): this

Set the router prefix for this router.

put<P extends RouteParams = RP, S extends State = RS>(
name: string,
path: string,
...middleware: RouterMiddleware<P, S>[],
): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register named middleware for the specified routes when the PUT method is requested.

put<P extends RouteParams = RP, S extends State = RS>(path: string, ...middleware: RouterMiddleware<P, S>[]): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register middleware for the specified routes when the PUT method is requested.

redirect(
source: string,
destination: string,
status?: RedirectStatus,
): this

Register a direction middleware, where when the source path is matched the router will redirect the request to the destination path. A status of 302 Found will be set by default.

The source and destination can be named routes.

Return middleware that will do all the route processing that the router has been configured to handle. Typical usage would be something like this:

import { Application, Router } from "https://deno.land/x/oak/mod.ts";

const app = new Application();
const router = new Router();

// register routes

app.use(router.routes());
app.use(router.allowedMethods());
await app.listen({ port: 80 });
url<P extends RouteParams = RP>(
name: string,
params?: P,
options?: UrlOptions,
): string | undefined

Generate a URL pathname for a named route, interpolating the optional params provided. Also accepts an optional set of options.

use<P extends RouteParams = RP, S extends State = RS>(...middleware: RouterMiddleware<P, S>[]): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register middleware to be used on every matched route.

use<P extends RouteParams = RP, S extends State = RS>(path: string | string[], ...middleware: RouterMiddleware<P, S>[]): Router<P extends RP ? P : (P & RP), S extends RS ? S : (S & RS)>

Register middleware to be used on every route that matches the supplied path.

values(): IterableIterator<Route<RP, RS>>

Iterate over the routes currently added to the router.

[Symbol.iterator](): IterableIterator<Route<RP, RS>>

Provide an iterator interface that iterates over the routes registered with the router.

Static Methods

url(
path: string,
params?: RouteParams,
options?: UrlOptions,
): string

Generate a URL pathname based on the provided path, interpolating the optional params provided. Also accepts an optional set of options.