• Stars
    star
    563
  • Rank 79,131 (Top 2 %)
  • Language
    JavaScript
  • License
    MIT License
  • Created almost 7 years ago
  • Updated over 1 year ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

🐟 A fast, small-but-mighty, familiar fish...errr, router*

trouter Build Status

🐟 A fast, small-but-mighty, familiar fish router

Install

$ npm install --save trouter

Usage

import Trouter from 'trouter';

const router = new Trouter();

// Define all routes
router
  .get('/users', _ => {
    console.log('> Getting all users');
  })
  .add('POST', '/users', _ => {
    console.log('~> Adding a user');
  })
  .get('/users/:id', val => {
    console.log('~> Getting user with ID:', val);
  });

// Find a route definition
let obj = router.find('GET', '/users/123');
//=> obj.params ~> { id:123 }
//=> obj.handlers ~> Array<Function>

// Execute the handlers, passing value
obj.handlers.forEach(fn => {
  fn(obj.params.id);
});
//=> ~> Getting user with ID: 123

// Returns empty keys when no match
router.find('DELETE', '/foo');
//=> { params:{}, handlers:[] }

API

Trouter()

Initializes a new Trouter instance.

trouter.add(method, pattern, ...handlers)

Returns: self

Stores a method + pattern pairing internally, along with its handler(s).

method

Type: String

Any uppercased, valid HTTP/1.1 verb β€” choose from one of the following:

GET  HEAD  PATCH  OPTIONS  CONNECT  DELETE  TRACE  POST  PUT

pattern

Type: String or RegExp

Trouter supports simple route patterns which are fast and well readable but limited. If you need more complex patterns, you can pass an instance of RegExp with parameters specified as named capture groups.

Important: RegExp named capture groups are supported in Node.js 10.x and above!

The supported route pattern types are:

  • static (/users)
  • named parameters (/users/:id)
  • nested parameters (/users/:id/books/:title)
  • optional parameters (/users/:id?/books/:title?)
  • suffixed parameters (/movies/:title.mp4, movies/:title.(mp4|mov))
  • any match / wildcards (/users/*)

...handlers

Type: Function

The function(s) that should be tied to this pattern.

Because this is a rest parameter, whatever you pass will always be cast to an Array.

Important: Trouter does not care what your function signature looks like!
You are not bound to the (req, res) standard, or even passing a Function at all!

trouter.use(pattern, ...handlers)

Returns: self

This is an alias for trouter.add('', pattern, ...handlers), matching all HTTP methods.

However, unlike trouter.all, the pattern you defined IS NOT RESTRICTIVE, which means that the route will match any & all URLs that start (but not end) with a matching segment.

router.use('/foo', 'USE /foo');
router.use('/foo/:name', 'USE /foo/:name');
router.post('/foo/:name', 'POST /foo/:name');
router.head('/foo/:name/hello', 'HEAD /foo/:name/hello');

router.find('GET', '/foo').handlers;
//=> ['USE /foo']

router.find('POST', '/foo/bar').handlers;
//=> ['USE /foo', 'USE /foo/:name', 'POST /foo/:name']

router.find('HEAD', '/foo/bar/hello').handlers;
//=> ['USE /foo', 'USE /foo/:name', 'HEAD /foo/:name/hello']

Compare this snippet with the one below to see differences between trouter.all and this method.

trouter.all(pattern, ...handlers)

Returns: self

This is an alias for trouter.add('', pattern, ...handlers), matching all HTTP methods.

However, unlike trouter.use, the pattern you defined IS RESTRICTIVE and behaves like any other trouter.METHOD route. This means that the URL must match the defined pattern exactly – or have the appropriate optional and/or wildcard segments to accommodate the desired flexibility.

router.all('/foo', 'ALL /foo');
router.all('/foo/:name', 'ALL /foo/:name');
router.post('/foo/:name', 'POST /foo/:name');
router.head('/foo/:name/hello', 'HEAD /foo/:name/hello');

router.find('GET', '/foo').handlers;
//=> ['ALL /foo']

router.find('POST', '/foo/bar').handlers;
//=> ['ALL /foo/:name', 'POST /foo/:name']

router.find('HEAD', '/foo/bar/hello').handlers;
//=> ['HEAD /foo/:name/hello']

Compare this snippet with the one above to see differences between trouter.use and this method.

trouter.METHOD(pattern, ...handlers)

This is an alias for trouter.add(METHOD, pattern, ...handlers), where METHOD is any lowercased HTTP verb.

const noop = _ => {}:
const app = new Trouter();

app.get('/users/:id', noop);
app.post('/users', noop);
app.patch('/users/:id', noop);

// less common methods too
app.trace('/foo', noop);
app.connect('/bar', noop);

trouter.find(method, url)

Returns: Object

Searches within current instance for all method + pattern pairs that satisfy the current method + url.

Important: Parameters and handlers are assembled/gathered in the order that they were defined!

This method will always return an Object with params and handlers keys.

  • params β€” Object whose keys are the named parameters of your route pattern.
  • handlers β€” Array containing the ...handlers provided to .add() or .METHOD()

Note: The handlers and params keys will be empty if no matches were found.

method

Type: String

Any valid HTTP method name, uppercased.

Note: When searching for HEAD routes, GET routes will also be inspected.

url

Type: String

The URL used to match against pattern definitions. This is typically req.url.

Benchmarks

Run on Node v10.13.0

GET /                           x 10,349,863 ops/sec Β±2.15% (93 runs sampled)
POST /users                     x 13,895,099 ops/sec Β±0.40% (94 runs sampled)
GET /users/:id                  x  6,288,457 ops/sec Β±0.25% (93 runs sampled)
PUT /users/:id/books/:title?    x  6,176,501 ops/sec Β±0.22% (96 runs sampled)
DELETE /users/:id/books/:title  x  5,581,288 ops/sec Β±2.04% (96 runs sampled)
HEAD /hello (all)               x  9,700,097 ops/sec Β±0.47% (90 runs sampled)

License

MIT Β© Luke Edwards

More Repositories

1

clsx

A tiny (239B) utility for constructing `className` strings conditionally.
JavaScript
8,212
star
2

polka

A micro web server so fast, it'll make you dance! πŸ‘―
JavaScript
5,266
star
3

pwa

(WIP) Universal PWA Builder
JavaScript
3,127
star
4

uvu

uvu is an extremely fast and lightweight test runner for Node.js and the browser
JavaScript
2,970
star
5

taskr

A fast, concurrency-focused task automation tool.
JavaScript
2,528
star
6

sockette

The cutest little WebSocket wrapper! 🧦
JavaScript
2,398
star
7

worktop

The next generation web framework for Cloudflare Workers
TypeScript
1,652
star
8

kleur

The fastest Node.js library for formatting terminal text with ANSI colors~!
JavaScript
1,616
star
9

klona

A tiny (240B to 501B) and fast utility to "deep clone" Objects, Arrays, Dates, RegExps, and more!
JavaScript
1,602
star
10

dequal

A tiny (304B to 489B) utility to check for deep equality
JavaScript
1,365
star
11

tsm

TypeScript Module Loader
TypeScript
1,179
star
12

tinydate

A tiny (349B) reusable date formatter. Extremely fast!
JavaScript
1,060
star
13

sirv

An optimized middleware & CLI application for serving static files~!
JavaScript
1,059
star
14

sade

Smooth (CLI) Operator 🎢
JavaScript
1,009
star
15

rosetta

A general purpose internationalization library in 292 bytes
JavaScript
788
star
16

navaid

A navigation aid (aka, router) for the browser in 850 bytes~!
JavaScript
775
star
17

dset

A tiny (194B) utility for safely writing deep Object values~!
JavaScript
754
star
18

tschema

A tiny (500b) utility to build JSON schema types.
TypeScript
697
star
19

uid

A tiny (130B to 205B) and fast utility to generate random IDs of fixed length
JavaScript
652
star
20

httpie

A Node.js HTTP client as easy as pie! πŸ₯§
JavaScript
579
star
21

ganalytics

A tiny (312B) client-side module for tracking with Google Analytics
JavaScript
575
star
22

regexparam

A tiny (394B) utility that converts route patterns into RegExp. Limited alternative to `path-to-regexp` πŸ™‡β€β™‚οΈ
JavaScript
565
star
23

dimport

Run ES Module syntax (`import`, `import()`, and `export`) in any browser – even IE!
JavaScript
548
star
24

mri

Quickly scan for CLI flags and arguments
JavaScript
533
star
25

tempura

A light, crispy, and delicious template engine 🍀
JavaScript
527
star
26

calendarize

A tiny (202B) utility to generate calendar views.
JavaScript
478
star
27

formee

A tiny (532B) library for handling <form> elements.
JavaScript
441
star
28

qss

A tiny (294b) browser utility for encoding & decoding a querystring.
JavaScript
408
star
29

uuid

A tiny (~230B)and fast UUID (V4) generator for Node and the browser
JavaScript
396
star
30

preact-starter

Webpack3 boilerplate for building SPA / PWA / offline front-end apps with Preact
JavaScript
387
star
31

fetch-event-stream

A tiny (736b) utility for Server Sent Event (SSE) streaming via `fetch` and Web Streams API
TypeScript
374
star
32

vegemite

A Pub/Sub state manager you'll love... or hate
JavaScript
373
star
33

resolve.exports

A tiny (952b), correct, general-purpose, and configurable `"exports"` and `"imports"` resolver without file-system reliance
TypeScript
366
star
34

polkadot

The tiny HTTP server that gets out of your way! ・
JavaScript
325
star
35

matchit

Quickly parse & match URLs
JavaScript
321
star
36

flru

A tiny (215B) and fast Least Recently Used (LRU) cache
JavaScript
313
star
37

mrmime

A tiny (2.8kB) and fast utility for getting a MIME type from an extension or filename
TypeScript
312
star
38

watchlist

Recursively watch a list of directories & run a command on any file system changes
JavaScript
262
star
39

ley

(WIP) Driver-agnostic database migrations
JavaScript
261
star
40

arr

A collection of tiny, highly performant Array.prototype alternatives
JavaScript
255
star
41

flattie

A tiny (203B) and fast utility to flatten an object with customizable glue
JavaScript
254
star
42

webpack-messages

Beautifully format Webpack messages throughout your bundle lifecycle(s)!
JavaScript
246
star
43

obj-str

A tiny (96B) library for serializing Object values to Strings.
JavaScript
225
star
44

templite

Lightweight templating in 150 bytes
JavaScript
224
star
45

empathic

A set of small Node.js utilities to understand your pathing needs.
TypeScript
221
star
46

ms

A tiny (414B) and fast utility to convert milliseconds to and from strings.
JavaScript
215
star
47

nestie

A tiny (215B) and fast utility to expand a flattened object
JavaScript
201
star
48

throttles

A tiny (139B to 204B) utility to regulate the execution rate of your functions
JavaScript
199
star
49

hexoid

A tiny (190B) and extremely fast utility to generate random IDs of fixed length
JavaScript
193
star
50

astray

Walk an AST without being led astray
JavaScript
184
star
51

fromnow

A tiny (339B) utility for human-readable time differences between now and past or future dates.
JavaScript
178
star
52

tmp-cache

A least-recently-used cache in 35 lines of code~!
JavaScript
177
star
53

bundt

A simple bundler for your delicious modules
JavaScript
169
star
54

wrr

A tiny (148B) weighted round robin utility
JavaScript
164
star
55

freshie

(WIP) A fresh take on building universal applications with support for pluggable frontends and backends.
TypeScript
155
star
56

svelte-ssr-worker

A quick demo for rendering Svelte server-side (SSR), but within a Cloudflare Worker!
JavaScript
154
star
57

totalist

A tiny (195B to 224B) utility to recursively list all (total) files in a directory
JavaScript
152
star
58

escalade

A tiny (183B to 210B) and fast utility to ascend parent directories
JavaScript
148
star
59

typescript-module

Template repository for authoring npm modules via TypeScript
TypeScript
143
star
60

sublet

Reactive leases for data subscriptions
JavaScript
140
star
61

webpack-route-manifest

Generate an asset manifest file, keyed by route patterns!
JavaScript
127
star
62

semiver

A tiny (153B) utility to compare semver strings.
JavaScript
123
star
63

url-shim

A 1.5kB browser polyfill for the Node.js `URL` and `URLSearchParams` classes.
JavaScript
123
star
64

svelte-demo

Multi-page demo built Svelte 3.x and Rollup with code-splitting
Svelte
114
star
65

saturated

A tiny (203B) utility to enqueue items for batch processing and/or satisfying rate limits.
JavaScript
112
star
66

webpack-format-messages

Beautiful formatting for Webpack messages; ported from Create React App!
JavaScript
111
star
67

gittar

🎸 Download and/or Extract git repositories (GitHub, GitLab, BitBucket). Cross-platform and Offline-first!
JavaScript
111
star
68

cfw

(WIP) A build and deploy utility for Cloudflare Workers.
TypeScript
109
star
69

webpack-critical

Extracts & inlines Critical CSS with Wepack
JavaScript
109
star
70

pages-fullstack

Demo SvelteKit application running on Cloudflare Pages
Svelte
101
star
71

sort-isostring

A tiny (110B) and fast utility to sort ISO 8601 Date strings
JavaScript
98
star
72

colors-app

🎨 A PWA for copying values from popular color palettes. Supports HEX, RGB, and HSL formats.
JavaScript
95
star
73

salteen

A snappy and lightweight (259B) utility to encrypt and decrypt values with salt.
JavaScript
95
star
74

is-offline

A tiny (174B) library to detect `offline` status & respond to changes in the browser.
JavaScript
91
star
75

seolint

(WIP) A robust and configurable SEO linter
TypeScript
87
star
76

rafps

A tiny (178B) helper for playing, pausing, and setting `requestAnimationFrame` frame rates
JavaScript
82
star
77

preact-cli-ssr

A quick demo for adding SSR to a Preact CLI app
JavaScript
79
star
78

webpack-modules

Handle `.mjs` files correctly within webpack
JavaScript
71
star
79

csprng

A tiny (~90B) isomorphic wrapper for `crypto.randomBytes` in Node.js and browsers.
JavaScript
68
star
80

premove

A tiny (201B to 247B) utility to remove items recursively
JavaScript
66
star
81

classico

A tiny (255B) shim when Element.classList cannot be used~!
JavaScript
62
star
82

mk-dirs

A tiny (381B to 419B) utility to make a directory and its parents, recursively
JavaScript
54
star
83

primeval

A tiny (128B) utility to check if a value is a prime number
JavaScript
52
star
84

loadr

Quickly attach multiple ESM Loaders and/or Require Hooks together but without the repetitive `--experimental-loader` and/or `--require` Node flags
JavaScript
49
star
85

preact-progress

Simple and lightweight (~590 bytes gzip) progress bar component for Preact
JavaScript
49
star
86

route-manifest

A tiny (412B) runtime to retrieve the correct entry from a Route Manifest file.
JavaScript
46
star
87

svelte-preprocess-esbuild

A Svelte Preprocessor to compile TypeScript via esbuild!
TypeScript
45
star
88

rollup-route-manifest

A Rollup plugin to generate an asset manifest, keyed by route patterns ("route manifest")
JavaScript
41
star
89

preact-scroll-header

A (800b gzip) header that will show/hide while scrolling for Preact
JavaScript
41
star
90

inferno-starter

Webpack2 boilerplate for building SPA / PWA / offline front-end apps with Inferno.js
JavaScript
41
star
91

onloaded

A tiny (350B) library to detect when images have loaded.
JavaScript
38
star
92

route-sort

A tiny (200B) utility to sort route patterns by specificity
JavaScript
36
star
93

webpack-plugin-replace

Replace content while bundling.
JavaScript
36
star
94

scorta

A tiny (330B to 357B) and fast utility to find a package's hidden supply / cache directory.
JavaScript
34
star
95

local-hostname

A tiny (171B) utility to check if a hostname is local
JavaScript
32
star
96

taskr-outdated

A generator & coroutine-based task runner. Fasten your seatbelt. πŸš€
JavaScript
32
star
97

rewrite-imports

Rewrite `import` statements as `require()`s; via RegExp
JavaScript
31
star
98

preact-offline

A (300b gzip) component to render alerts/messages when offline.
JavaScript
29
star
99

fly-kit-preact

A starter kit for building offline / SPA / PWA apps with Preact
JavaScript
28
star
100

fannypack

The tool belt for front-end developers
JavaScript
28
star