@stacksjs/bun-router 0.0.15 → 0.0.17

package/src/router/router.ts

@@ -81,6 +81,14 @@ export class Router {
   // Middleware pipeline for advanced features
   _middlewarePipeline?: MiddlewarePipeline
 
+  // Bumped whenever global middleware changes; per-route compiled chains
+  // cache against this epoch and rebuild when it moves
+  _mwEpoch = 0
+
+  // Memoized getAllowedMethods results (the 405-vs-404 scan), keyed by
+  // domain:pathname. Cleared whenever routes change.
+  _allowedMethodsCache: Map<string, string[]> = new Map()
+
   config: RouterConfig = {
     verbose: false,
     routesPath: 'routes',
@@ -233,6 +241,7 @@ export class Router {
    */
   invalidateCache(): void {
     this.routeCache.clear()
+    this._allowedMethodsCache.clear()
   }
 
   /**
@@ -758,61 +767,46 @@ export class Router {
    */
   getAllowedMethods(path: string, domain?: string): string[] {
     const url = new URL(path, 'http://localhost')
-    const methods: Set<string> = new Set()
-    const allMethods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD']
-
-    for (const method of allMethods) {
-      // Check static routes
-      if (this.staticRoutes.has(method)) {
-        const staticRoute = this.staticRoutes.get(method)!.get(url.pathname)
-        if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
-          methods.add(method)
-          continue
-        }
-      }
 
-      // Get potential routes
-      const potentialRoutes: Route[] = domain && this.domains[domain]
-        ? this.domains[domain]
-        : this.routes
+    // Memoized per path: every unmatched request pays this scan for its
+    // 405-vs-404 decision, and 404 floods tend to hammer the same paths
+    const cacheKey = `${domain || ''}:${url.pathname}`
+    const cached = this._allowedMethodsCache.get(cacheKey)
+    if (cached) {
+      return cached
+    }
 
-      // Filter routes to only those matching the HTTP method
-      const methodRoutes = potentialRoutes.filter((route: Route) => route.method === method)
+    const methods: Set<string> = new Set()
 
-      // Check exact match
-      for (const route of methodRoutes) {
-        if (route.path === url.pathname) {
-          methods.add(method)
-          break
-        }
+    // Static routes: one map lookup per registered method
+    for (const [method, routesByPath] of this.staticRoutes) {
+      const staticRoute = routesByPath.get(url.pathname)
+      if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
+        methods.add(method)
       }
+    }
 
-      // Check pattern match if not already found
-      if (!methods.has(method)) {
-        for (const route of methodRoutes) {
-          if (route.pattern) {
-            const match = route.pattern.exec(url)
-            if (match) {
-              methods.add(method)
-              break
-            }
-          }
-        }
-      }
+    // Dynamic routes: a single pass over the candidate pool covers exact,
+    // pattern, and wildcard matches for every method at once (the old
+    // implementation re-scanned the table once per HTTP method)
+    const potentialRoutes: Route[] = domain && this.domains[domain]
+      ? this.domains[domain]
+      : this.routes
 
-      // Check wildcard routes if not already found
-      if (!methods.has(method)) {
-        const wildcardRoutes = potentialRoutes.filter((route: Route) =>
-          route.method === method && route.path.endsWith('*'),
-        )
-
-        for (const route of wildcardRoutes) {
-          const basePath = route.path.slice(0, -1)
-          if (url.pathname.startsWith(basePath)) {
-            methods.add(method)
-            break
-          }
-        }
+    for (const route of potentialRoutes) {
+      if (methods.has(route.method)) {
+        continue
+      }
+      if (route.path === url.pathname) {
+        methods.add(route.method)
+        continue
+      }
+      if (route.pattern && route.pattern.exec(url)) {
+        methods.add(route.method)
+        continue
+      }
+      if (route.path.endsWith('*') && url.pathname.startsWith(route.path.slice(0, -1))) {
+        methods.add(route.method)
       }
     }
 
@@ -821,7 +815,12 @@ export class Router {
       methods.add('HEAD')
     }
 
-    return Array.from(methods)
+    const result = Array.from(methods)
+    if (this._allowedMethodsCache.size >= 10_000) {
+      this._allowedMethodsCache.clear()
+    }
+    this._allowedMethodsCache.set(cacheKey, result)
+    return result
   }
 
   /**
@@ -1350,9 +1349,16 @@ export class Router {
   }
 
   /**
-   * Create a route group with prefix and middleware
+   * Create a route group with prefix and middleware.
+   *
+   * Synchronous callbacks return the router for chaining. Asynchronous
+   * callbacks return a promise that resolves once the callback (and any
+   * routes it registers) has finished — await it, or routes registered
+   * after an `await` inside the callback would lose the group prefix.
    */
-  group(options: { prefix?: string, middleware?: (string | MiddlewareHandler)[] }, callback: () => void | Promise<void>): Router {
+  group(options: { prefix?: string, middleware?: (string | MiddlewareHandler)[] }, callback: () => Promise<void>): Promise<Router>
+  group(options: { prefix?: string, middleware?: (string | MiddlewareHandler)[] }, callback: () => void): Router
+  group(options: { prefix?: string, middleware?: (string | MiddlewareHandler)[] }, callback: () => void | Promise<void>): Router | Promise<Router> {
     // Save current group state
     const previousGroup = this.currentGroup
 
@@ -1374,17 +1380,23 @@ export class Router {
     // Execute callback
     const result = callback()
 
-    // Handle async callbacks
+    // Async callbacks keep the group active until they settle
     if (result instanceof Promise) {
-      result.then(() => {
-        this.currentGroup = previousGroup
-      })
-    }
-    else {
-      // Restore previous group state
-      this.currentGroup = previousGroup
+      return result.then(
+        () => {
+          this.currentGroup = previousGroup
+          return this
+        },
+        (error: unknown) => {
+          this.currentGroup = previousGroup
+          throw error
+        },
+      )
     }
 
+    // Restore previous group state
+    this.currentGroup = previousGroup
+
     return this
   }