Fast, generic and type safe router (match request method and path).

• Minimal and opinionless router, can be used in any script and environment.
• Matches a request method (e.g. GET) and a path (e.g. /foobar) against a list of routes
• Uses path-to-regexp, which is used by express and therefore familiar
• Allows wildcards (e.g. /user/(.*)/age) and named parameters (e.g. /info/:username/:age)
• Will not call your handlers automatically, as it only cares about matching
• Battle hardened in production (Cloudflare Worker with 10M requests per day)
• No magic, no assumptions, no fluff, type safe, tested

• You can use the Express Route Tester (select 2.0.0) to debug your path patterns quickly

yarn add tiny-request-router # or npm install --save tiny-request-router

import { Router } from 'tiny-request-router' // NodeJS: const { Router } = require('tiny-request-router') const router = new Router() router .get('/(v1|v2)/:name/:age', 'foo1') .get('/info/(.*)/export', 'foo2') .post('/upload/user', 'foo3') const match1 = router.match('GET', '/v1/') // => null const match2 = router.match('GET', '/v1/bob/22') // => { handler: 'foo1', params: { name: 'bob', age: '22' }, ... }

import { Router, Method, Params } from 'tiny-request-router' // Let the router know that handlers are async functions returning a Response type Handler = (params: Params) => Promise<Response> const router = new Router<Handler>() router.all('*', async () => new Response('Hello')) const match = router.match('GET' as Method, '/foobar') if (match) { // Call the async function of that match const response = await match.handler() console.log(response) // => Response('Hello') }

Use something like wrangler to bundle the router with your worker code.

import { Router } from 'tiny-request-router' const router = new Router() router.get('/worker', async () => new Response('Hi from worker!')) router.get('/hello/:name', async params => new Response(`Hello ${params.name}!`)) router.post('/test', async () => new Response('Post received!')) // Main entry point in workers addEventListener('fetch', event => { const request = event.request const { pathname } = new URL(request.url) const match = router.match(request.method, pathname) if (match) { event.respondWith(match.handler(match.params)) } })

• Method()
• RouteOptions()
• RouteMatch()
• class: Router
  • .routes
  • .all(path, handler, options)
  • .get(path, handler, options)
  • .post(path, handler, options)
  • .put(path, handler, options)
  • .patch(path, handler, options)
  • .delete(path, handler, options)
  • .head(path, handler, options)
  • .options(path, handler, options)
  • .match(method, path)

Type: ("GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS")

Valid HTTP methods for matching.

Extends: TokensToRegexpOptions

Optional route options.

Example:

// When `true` the regexp will be case sensitive. (default: `false`) sensitive?: boolean; // When `true` the regexp allows an optional trailing delimiter to match. (default: `false`) strict?: boolean; // When `true` the regexp will match to the end of the string. (default: `true`) end?: boolean; // When `true` the regexp will match from the beginning of the string. (default: `true`) start?: boolean; // Sets the final character for non-ending optimistic matches. (default: `/`) delimiter?: string; // List of characters that can also be "end" characters. endsWith?: string; // Encode path tokens for use in the `RegExp`. encode?: (value: string) => string;

Extends: Route<HandlerType>

The object returned when a route matches.

The handler can then be used to execute the relevant function.

Example:

{ params: Params matches?: RegExpExecArray method: Method | MethodWildcard path: string regexp: RegExp options: RouteOptions keys: Keys handler: HandlerType }

Tiny request router. Allows overloading of handler type to be fully type safe.

Example:

import { Router, Method, Params } from 'tiny-request-router' // Let the router know that handlers are async functions returning a Response type Handler = (params: Params) => Promise<Response> const router = new Router<Handler>()

List of all registered routes.

• path string
• handler HandlerType
• options RouteOptions (optional, default {})

Add a route that matches any method.

• path string
• handler HandlerType
• options RouteOptions (optional, default {})

Add a route that matches the GET method.

• path string
• handler HandlerType
• options RouteOptions (optional, default {})

Add a route that matches the POST method.

• path string
• handler HandlerType
• options RouteOptions (optional, default {})

Add a route that matches the PUT method.

• path string
• handler HandlerType
• options RouteOptions (optional, default {})

Add a route that matches the PATCH method.

• path string
• handler HandlerType
• options RouteOptions (optional, default {})

Add a route that matches the DELETE method.

• path string
• handler HandlerType
• options RouteOptions (optional, default {})

Add a route that matches the HEAD method.

• path string
• handler HandlerType
• options RouteOptions (optional, default {})

Add a route that matches the OPTIONS method.

• method Method
• path string

Returns: (RouteMatch<HandlerType> | null)

Match the provided method and path against the list of registered routes.

Example:

router.get('/foobar', async () => new Response('Hello')) const match = router.match('GET', '/foobar') if (match) { // Call the async function of that match const response = await match.handler() console.log(response) // => Response('Hello') }

Please check out the tiny source code or tests for more info.

MIT