router-http 1.0.12 → 1.0.13

package/README.md

@@ -6,9 +6,9 @@
 
 A middleware style router, similar to [express@router](https://github.com/pillarjs/router), plus:
 
-- Faster (x3 compared with Express).
+- Faster (~30% more requests per second than Express).
 - Maintained and well tested.
-- Smaller (1.4 kB).
+- Smaller (1.8 kB).
 
 Don't get me wrong: The original Express router is a piece of art. I used it for years and I just considered create this library after experienced a bug that never was addressed in the stable version due to the [lack of maintenance](https://github.com/pillarjs/router/pull/60).
 
@@ -110,20 +110,68 @@ They are only will add if the condition is satisfied.
 
 Middlewares always run **before** route handlers, regardless of declaration order. This means you can declare `.use()` before or after `.get()` / `.post()` / etc., and the middleware will still execute first.
 
-### Prefixing routes
+### Nested routers
 
-In case you need you can prefix all the routes:
+You can use a router as a middleware for another router. This is useful for prefixing routes or for modularizing your application.
+
+When a sub-router is used as a middleware, it will only handle requests that match its prefix. If no route matches inside the sub-router, it will automatically call `next()` to pass control back to the parent router.
 
 ```js
-routes.get('/', (req, res) => res.end('Welcome to my API!'))
+const createRouter = require('router-http')
+const http = require('http')
 
-/**
- * Prefix all routes with the API version
- */
+const final = (err, req, res) => {
+  res.statusCode = err ? 500 : 404
+  res.end(err ? err.message : 'Not Found')
+}
+
+// 1. Create a sub-router for API v1
+const v1 = createRouter(final)
+v1.get('/info', (req, res) => res.end('v1 info'))
+
+// 2. Create another sub-router for API v2
+const v2 = createRouter(final)
+v2.get('/info', (req, res) => res.end('v2 info'))
+
+// 3. Create the main router and mount sub-routers
 const router = createRouter(final)
+
 router
-  .use('/latest', routes)
-  .use('/v1', routes)
+  .use('/v1', v1)
+  .use('/v2', v2)
+  .get('/', (req, res) => res.end('Welcome to the main router'))
+
+http.createServer(router).listen(3000)
+```
+
+#### Exit Current Router
+
+You can use `next('router')` to skip all remaining handlers in the current router and pass control back to the parent router. This is useful for conditional routing, such as a "Beta" router that only handles requests for certain users:
+
+```js
+const beta = createRouter(final)
+
+// Middleware to check if the user is a beta tester
+beta.use((req, res, next) => {
+  if (!req.isBetaTester) return next('router')
+  next()
+})
+
+beta.get('/search', (req, res) => {
+  res.end('Using the new AI-powered search engine!')
+})
+
+const router = createRouter(final)
+
+// Mount the beta router
+router.use('/v1', beta)
+
+// This will be reached if:
+// 1. The user is NOT a beta tester (next('router') was called)
+// 2. Or the path didn't match anything inside the beta router
+router.get('/v1/search', (req, res) => {
+  res.end('Using the classic search engine.')
+})
 ```
 
 ### Using the router
@@ -136,30 +184,32 @@ const server = http.createServer(router)
 
 ## Benchmark
 
-**express@4.18.2**
+With all the improvements, router-http is approximately 30% faster than the express router:
+
+**express@5.2.1**
 
 ```
 Running 30s test @ http://localhost:3000/user/123
   8 threads and 100 connections
   Thread Stats   Avg      Stdev     Max   +/- Stdev
-    Latency     4.12ms  653.26us  21.71ms   89.35%
-    Req/Sec     2.93k   159.60     5.99k    84.75%
-  700421 requests in 30.06s, 102.87MB read
-Requests/sec:  23304.22
-Transfer/sec:      3.42MB
+    Latency     1.23ms    1.40ms  96.27ms   99.61%
+    Req/Sec    10.15k   615.89    11.07k    86.24%
+  2430687 requests in 30.10s, 356.98MB read
+Requests/sec:  80752.48
+Transfer/sec:     11.86MB
 ```
 
-**router-http@1.0.0**
+**router-http**
 
 ```
 Running 30s test @ http://localhost:3000/user/123
   8 threads and 100 connections
   Thread Stats   Avg      Stdev     Max   +/- Stdev
-    Latency     1.33ms  690.36us  30.28ms   97.16%
-    Req/Sec     9.27k     1.09k   11.76k    89.58%
-  2214097 requests in 30.02s, 276.61MB read
-Requests/sec:  73754.53
-Transfer/sec:      9.21MB
+    Latency     0.97ms    1.27ms  84.82ms   99.77%
+    Req/Sec    12.91k     1.07k   14.67k    71.51%
+  3092927 requests in 30.10s, 386.40MB read
+Requests/sec: 102751.65
+Transfer/sec:     12.84MB
 ```
 
 See more details, check [benchmark](/benchmark) section.

package/package.json

@@ -2,7 +2,7 @@
   "name": "router-http",
   "description": "Simple HTTP router compatible with Express",
   "homepage": "https://github.com/Kikobeats/router-http",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "main": "src/index.js",
   "author": {
     "email": "josefrancisco.verdu@gmail.com",
@@ -29,6 +29,7 @@
     "routes"
   ],
   "dependencies": {
+    "null-prototype-object": "~1.2.5",
     "trouter": "~4.0.0"
   },
   "devDependencies": {

package/src/index.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const NullProtoObj = require('null-prototype-object')
 const { Trouter } = require('trouter')
 
 const requiredFinalHandler = () => {
@@ -18,18 +19,18 @@ const value = x => {
 
 const parse = ({ url }) => {
   const index = url.indexOf('?', 1)
-  const obj = { pathname: url, query: null, search: null }
-  if (index !== -1) {
-    obj.search = url.substring(index)
-    obj.query = obj.search.substring(1)
-    obj.pathname = url.substring(0, index)
+  if (index === -1) return { pathname: url, query: null, search: null }
+  const search = url.substring(index)
+  return {
+    pathname: url.substring(0, index),
+    query: search.substring(1),
+    search
   }
-  return obj
 }
 
 const mutate = (str, req) => {
-  req.url = req.url.substring(str.length) ?? '/'
-  req.path = req.path.substring(str.length) ?? '/'
+  req.url = req.url.substring(str.length) || '/'
+  req.path = req.path.substring(str.length) || '/'
 }
 
 class Router extends Trouter {
@@ -46,7 +47,7 @@ class Router extends Trouter {
   /**
    * Middleware for specific routes
    */
-  #middlewaresBy = []
+  #middlewaresBy = new NullProtoObj()
 
   /**
    * Middleware declaration, where the page is optional
@@ -64,65 +65,97 @@ class Router extends Trouter {
       page = lead(page)
       fns.filter(Boolean).forEach(fn => {
         const array = this.#middlewaresBy[page] ?? []
-        // eslint-disable-next-line no-sequences
-        array.length > 0 || array.push((r, _, nxt) => (mutate(page, r), nxt()))
+        if (array.length === 0) {
+          array.push((r, _, nxt) => {
+            mutate(page, r)
+            nxt()
+          })
+        }
         this.#middlewaresBy[page] = array.concat(fn)
       })
     }
     return this
   }
 
-  handler = (req, res, info) => {
-    info = info ?? parse(req)
-    let fns = []
-    let middlewares = this.#middlewares
-    const route = this.find(req.method, info.pathname)
-    const page = value((req.path = info.pathname))
-    if (this.#middlewaresBy[page] !== undefined) {
-      middlewares = middlewares.concat(this.#middlewaresBy[page])
-    }
-    if (route) {
-      fns = route.handlers
-      req.params = { ...req.params, ...route.params }
+  handler = (req, res, next) => {
+    const info = parse(req)
+    const pathname = info.pathname
+    req.path = pathname
+    const route = this.find(req.method, pathname)
+    const page = value(pathname)
+
+    const m = this.#middlewares
+    const mb = this.#middlewaresBy[page]
+    const f = route.handlers.length > 0 ? route.handlers : null
+
+    if (f) {
+      req.params = req.params
+        ? { ...req.params, ...route.params }
+        : route.params
+    } else {
+      req.params = req.params || {}
     }
-    fns.push(this.unhandler)
-    req.search = req.query ?? info.search
-    req.query = req.query ?? info.query
-    // Exit if only a single function
+
+    req.search = req.query || info.search
+    req.query = req.query || info.query
+
     let index = 0
-    let size = middlewares.length
-    const num = fns.length
-    if (size === index && num === 1) return fns[0](undefined, req, res)
-
-    // Otherwise loop thru all middlware
-    const next = err => (err ? this.unhandler(err, req, res, next) : loop())
-
-    const loop = () =>
-      res.writableEnded ||
-      (index < size &&
-        (async () => {
-          try {
-            const mware = middlewares[index++]
-            const result =
-              index === size
-                ? mware(undefined, req, res, next)
-                : mware(req, res, next)
-            if (result && typeof result.then === 'function') {
-              await result
-            }
-          } catch (err) {
-            return this.unhandler(err, req, res, next)
+    let sync = 0
+
+    const mLen = m.length
+    const mbLen = mb ? mb.length : 0
+    const fLen = f ? f.length : 0
+    const total = mLen + mbLen + fLen
+
+    const _next = err => {
+      if (err === 'router') {
+        if (next) return next()
+        index = total
+        err = undefined
+      }
+      if (err) return this.unhandler(err, req, res, next)
+      if (++sync > 100) {
+        sync = 0
+        return setImmediate(loop)
+      }
+      loop()
+    }
+
+    const loop = () => {
+      if (index < total) {
+        if (res.writableEnded) return
+        const i = index++
+        const mware =
+          i < mLen
+            ? m[i]
+            : i < mLen + mbLen
+              ? mb[i - mLen]
+              : f[i - mLen - mbLen]
+
+        try {
+          const result = mware(req, res, _next)
+          if (result && typeof result.then === 'function') {
+            return result.then(undefined, _next)
           }
-        })())
+        } catch (err) {
+          return _next(err)
+        }
+        return
+      }
+
+      if (res.writableEnded) return
+
+      if (next) return next()
+
+      this.unhandler(undefined, req, res, _next)
+    }
 
-    middlewares = middlewares.concat(fns)
-    size += num
-    loop() // init
+    loop()
   }
 }
 
 module.exports = (finalhandler = requiredFinalHandler()) => {
   const router = new Router(finalhandler)
-  const handler = (req, res) => router.handler(req, res)
+  const handler = (req, res, next) => router.handler(req, res, next)
   return Object.assign(handler, router)
 }