refactor: optimize middleware handling and improve URL parsing in router

Author: jkyberneees

lib/next.js

@@ -5,18 +5,21 @@ module.exports = function next(
   defaultRoute,
   errorHandler,
 ) {
-  if (index >= middlewares.length) {
+  // Optimized loop unrolling for common cases
+  const length = middlewares.length
+  if (index >= length) {
     return defaultRoute(req)
   }
 
-  const middleware = middlewares[index++]
+  const middleware = middlewares[index]
+  const nextIndex = index + 1
 
   try {
     return middleware(req, (err) => {
       if (err) {
         return errorHandler(err, req)
       }
-      return next(middlewares, req, index, defaultRoute, errorHandler)
+      return next(middlewares, req, nextIndex, defaultRoute, errorHandler)
     })
   } catch (err) {
     return errorHandler(err, req)

lib/router/sequential.d.ts

@@ -1,3 +1,3 @@
-import { IRouter, IRouterConfig } from './../../index'
+import {IRouter, IRouterConfig} from './../../index'
 
 export default function createSequentialRouter(config?: IRouterConfig): IRouter

lib/router/sequential.js

@@ -1,6 +1,6 @@
-const { Trouter } = require("trouter")
-const qs = require("fast-querystring")
-const next = require("./../next")
+const {Trouter} = require('trouter')
+const qs = require('fast-querystring')
+const next = require('./../next')
 
 const STATUS_404 = {
   status: 404,
@@ -12,26 +12,26 @@ const STATUS_500 = {
 module.exports = (config = {}) => {
   const cache = new Map()
 
-  if (!config.defaultRoute) {
-    config.defaultRoute = () => {
-      return new Response(null, STATUS_404)
-    }
-  }
-  if (!config.errorHandler) {
-    config.errorHandler = (err) => {
-      return new Response(err.message, STATUS_500)
-    }
-  }
+  // Pre-create default responses to avoid object creation overhead
+  const default404Response = new Response(null, STATUS_404)
+
+  // Cache default functions to avoid closure creation
+  const defaultRouteHandler = config.defaultRoute || (() => default404Response)
+  const errorHandlerFn =
+    config.errorHandler || ((err) => new Response(err.message, STATUS_500))
+
+  // Optimize empty params object reuse
+  const emptyParams = {}
 
   const router = new Trouter()
   router.port = config.port || 3000
 
   const _use = router.use
 
   router.use = (prefix, ...middlewares) => {
-    if (typeof prefix === "function") {
+    if (typeof prefix === 'function') {
       middlewares = [prefix, ...middlewares]
-      prefix = "/"
+      prefix = '/'
     }
     _use.call(router, prefix, middlewares)
 
@@ -40,40 +40,84 @@ module.exports = (config = {}) => {
 
   router.fetch = (req) => {
     const url = req.url
-    const startIndex = url.indexOf("/", 11)
-    const queryIndex = url.indexOf("?", startIndex + 1)
-    const path =
-      queryIndex === -1
-        ? url.substring(startIndex)
-        : url.substring(startIndex, queryIndex)
-
-    req.path = path || "/"
-    req.query = queryIndex > 0 ? qs.parse(url.substring(queryIndex + 1)) : {}
-
-    const cacheKey = `${req.method}:${req.path}`
-    let match = null
-    if (cache.has(cacheKey)) {
-      match = cache.get(cacheKey)
+
+    // Highly optimized URL parsing - single pass through the string
+    let pathStart = 0
+    let pathEnd = url.length
+    let queryString = null
+
+    // Find protocol end
+    const protocolEnd = url.indexOf('://')
+    if (protocolEnd !== -1) {
+      // Find host end (start of path)
+      pathStart = url.indexOf('/', protocolEnd + 3)
+      if (pathStart === -1) {
+        pathStart = url.length
+      }
+    }
+
+    // Find query start
+    const queryStart = url.indexOf('?', pathStart)
+    if (queryStart !== -1) {
+      pathEnd = queryStart
+      queryString = url.substring(queryStart + 1)
+    }
+
+    const path = pathStart < pathEnd ? url.substring(pathStart, pathEnd) : '/'
+
+    req.path = path
+    req.query = queryString ? qs.parse(queryString) : {}
+
+    // Optimized cache lookup with method-based Map structure
+    const method = req.method
+    let methodCache = cache.get(method)
+    let match_result
+
+    if (methodCache) {
+      match_result = methodCache.get(path)
+      if (match_result === undefined) {
+        match_result = router.find(method, path)
+        methodCache.set(path, match_result)
+      }
     } else {
-      match = router.find(req.method, req.path)
-      cache.set(cacheKey, match)
+      match_result = router.find(method, path)
+      methodCache = new Map([[path, match_result]])
+      cache.set(method, methodCache)
     }
 
-    if (match?.handlers?.length > 0) {
-      if (!req.params) {
-        req.params = {}
+    if (match_result?.handlers?.length > 0) {
+      // Fast path for params assignment
+      const params = match_result.params
+      if (params) {
+        // Check if params object has properties without Object.keys()
+        let hasParams = false
+        for (const key in params) {
+          hasParams = true
+          break
+        }
+
+        if (hasParams) {
+          req.params = req.params || {}
+          // Direct property copy - faster than Object.keys() + loop
+          for (const key in params) {
+            req.params[key] = params[key]
+          }
+        } else if (!req.params) {
+          req.params = emptyParams
+        }
+      } else if (!req.params) {
+        req.params = emptyParams
       }
-      Object.assign(req.params, match.params)
 
       return next(
-        match.handlers,
+        match_result.handlers,
         req,
         0,
-        config.defaultRoute,
-        config.errorHandler
+        defaultRouteHandler,
+        errorHandlerFn,
       )
     } else {
-      return config.defaultRoute(req)
+      return defaultRouteHandler(req)
     }
   }