@stacksjs/bun-router 0.0.17 → 0.0.19

package/src/router/optimized-route-matching.ts

@@ -1,302 +0,0 @@
-import type { HTTPMethod, MatchResult, Route } from '../types'
-import type { Router } from './router'
-import { RouteCompiler } from './route-compiler'
-
-/**
- * Optimized route matching extension for Router class
- * Replaces the original route matching with high-performance trie-based matching
- */
-export function registerOptimizedRouteMatching(RouterClass: typeof Router): void {
-  Object.defineProperties(RouterClass.prototype, {
-    /**
-     * Initialize the route compiler
-     */
-    initializeRouteCompiler: {
-      value() {
-        if (!this.routeCompiler) {
-          this.routeCompiler = new RouteCompiler({
-            enableCaching: true,
-            enableMethodGrouping: true,
-            enablePriorityOptimization: true,
-            cacheSize: 1000,
-            precompilePatterns: true,
-          })
-        }
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Add route to the optimized compiler
-     */
-    addRouteToCompiler: {
-      value(route: Route) {
-        this.initializeRouteCompiler()
-        this.routeCompiler.addRoute(route)
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Optimized route matching using trie structure
-     */
-    matchRoute: {
-      value(path: string, method: HTTPMethod, domain?: string): MatchResult | undefined {
-        this.initializeRouteCompiler()
-
-        // Domain-scoped routes are matched by the domain-aware fallback.
-        // The trie (and its cache key) is method+path only, so letting it
-        // answer for hosts with registered domain routes would let one
-        // domain's cached match poison another's.
-        if (domain && this.domains[domain]) {
-          const domainMatch = this.fallbackMatchRoute(path, method, domain)
-          if (domainMatch) {
-            return domainMatch
-          }
-        }
-        else {
-          // Use the optimized compiler for matching
-          const match = this.routeCompiler.match(path, method)
-
-          if (match && (!domain || !match.route.domain || match.route.domain === domain)) {
-            return match
-          }
-
-          // Fallback to original matching for edge cases (optional params, etc.)
-          const fallback = this.fallbackMatchRoute(path, method, domain)
-          if (fallback) {
-            return fallback
-          }
-        }
-
-        // A HEAD request is served by the matching GET route when no
-        // explicit HEAD route exists (RFC 9110 §9.3.2)
-        if (method === 'HEAD') {
-          return this.matchRoute(path, 'GET', domain)
-        }
-
-        return undefined
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Fallback to original route matching logic
-     */
-    fallbackMatchRoute: {
-      value(path: string, method: HTTPMethod, domain?: string): MatchResult | undefined {
-        const url = new URL(path, 'http://localhost')
-
-        // Generate cache key
-        const cacheKey = `${domain || ''}:${method}:${url.pathname}`
-
-        // Check legacy cache first
-        if (this.routeCache.has(cacheKey)) {
-          return this.routeCache.get(cacheKey)
-        }
-
-        // Bound the legacy cache — high-cardinality dynamic paths would
-        // otherwise grow it without limit
-        if (this.routeCache.size >= 10_000) {
-          this.routeCache.clear()
-        }
-
-        // Fast path for static routes
-        if (this.staticRoutes.has(method)) {
-          const staticRoute = this.staticRoutes.get(method)!.get(url.pathname)
-          if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
-            const result = {
-              route: staticRoute,
-              params: {},
-            }
-            this.routeCache.set(cacheKey, result)
-            return result
-          }
-        }
-
-        // Get potential routes - either all routes or domain-specific routes
-        const potentialRoutes: Route[] = domain && this.domains[domain]
-          ? this.domains[domain]
-          : this.routes
-
-        // Filter routes to only those matching the HTTP method
-        const methodRoutes = potentialRoutes.filter((route: Route) => route.method === method)
-
-        // First, try to find an exact match
-        for (const route of methodRoutes) {
-          if (route.path === url.pathname) {
-            const result = {
-              route,
-              params: {},
-            }
-            this.routeCache.set(cacheKey, result)
-            return result
-          }
-        }
-
-        // If no exact match, try matching patterns
-        for (const route of methodRoutes) {
-          if (route.pattern) {
-            const match = route.pattern.exec(url)
-            if (match) {
-              const result = {
-                route,
-                params: match.pathname.groups,
-              }
-              this.routeCache.set(cacheKey, result)
-              return result
-            }
-          }
-        }
-
-        // Try wildcard routes — domain-scoped first, then global
-        const wildcardPools: Route[][] = domain && this.domains[domain]
-          ? [this.domains[domain], this.routes]
-          : [this.routes]
-
-        for (const pool of wildcardPools) {
-          for (const route of pool) {
-            if (route.method !== method || !route.path.endsWith('*')) {
-              continue
-            }
-            const basePath = route.path.slice(0, -1) // Remove the '*'
-            if (url.pathname.startsWith(basePath)) {
-              const result = {
-                route,
-                params: { wildcard: url.pathname.slice(basePath.length) },
-              }
-              this.routeCache.set(cacheKey, result)
-              return result
-            }
-          }
-        }
-
-        // Cache the miss too — repeated requests for an unknown path skip
-        // the full scan (the cache is cleared whenever routes change)
-        this.routeCache.set(cacheKey, undefined)
-        return undefined
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Get route matching statistics
-     */
-    getRouteStats: {
-      value() {
-        this.initializeRouteCompiler()
-        return this.routeCompiler.getStats()
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Get cache statistics
-     */
-    getCacheStats: {
-      value() {
-        this.initializeRouteCompiler()
-        return this.routeCompiler.getCacheStats()
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Warm up the route cache with common paths
-     */
-    warmRouteCache: {
-      value(commonPaths: Array<{ path: string, method: HTTPMethod }>) {
-        this.initializeRouteCompiler()
-        this.routeCompiler.warmCache(commonPaths)
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Get routes grouped by HTTP method for debugging
-     */
-    getRoutesByMethod: {
-      value() {
-        this.initializeRouteCompiler()
-        return this.routeCompiler.getRoutesByMethod()
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Get route conflicts for debugging
-     */
-    getRouteConflicts: {
-      value() {
-        this.initializeRouteCompiler()
-        return this.routeCompiler.getRouteConflicts()
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Clear route compiler caches
-     */
-    clearRouteCache: {
-      value() {
-        if (this.routeCompiler) {
-          this.routeCompiler.clear()
-        }
-        // Also clear legacy caches
-        this.routeCache.clear()
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Rebuild route compiler with current routes
-     */
-    rebuildRouteCompiler: {
-      value() {
-        this.routeCompiler = new RouteCompiler({
-          enableCaching: true,
-          enableMethodGrouping: true,
-          enablePriorityOptimization: true,
-          cacheSize: 1000,
-          precompilePatterns: true,
-        })
-
-        // Re-add all routes
-        for (const route of this.routes) {
-          this.routeCompiler.addRoute(route)
-        }
-
-        // Re-add domain-specific routes
-        for (const domainRoutes of Object.values(this.domains) as Route[][]) {
-          for (const route of domainRoutes) {
-            this.routeCompiler.addRoute(route)
-          }
-        }
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Optimize route order based on usage patterns
-     */
-    optimizeRoutes: {
-      value(usageStats: Record<string, number> = {}) {
-        this.initializeRouteCompiler()
-        this.routeCompiler.optimizeRouteOrder(usageStats)
-      },
-      writable: true,
-      configurable: true,
-    },
-  })
-}

package/src/router/route-building.ts

@@ -1,221 +0,0 @@
-import type { Route, RouteDefinition } from '../types'
-import type { Router } from './router'
-import { matchPath } from '../utils'
-
-/**
- * Route building extension for Router class
- */
-export function registerRouteBuilding(RouterClass: typeof Router): void {
-  Object.defineProperties(RouterClass.prototype, {
-    /**
-     * Convert existing routes to the Bun.serve routes format
-     */
-    buildBunServeRoutes: {
-      value(): Record<string, any> {
-        const bunRoutes: Record<string, any> = {}
-
-        // Group routes by path to build method-specific handlers
-        const routesByPath = new Map<string, Route[]>()
-
-        for (const route of this.routes) {
-          if (!routesByPath.has(route.path)) {
-            routesByPath.set(route.path, [])
-          }
-          routesByPath.get(route.path)!.push(route)
-        }
-
-        // Build route handlers
-        for (const [path, routes] of routesByPath.entries()) {
-          if (routes.length === 1) {
-            // Single route handler
-            const route = routes[0]
-
-            // For static responses like health checks, use direct Response objects
-            if (
-              typeof route.handler === 'function'
-              && route.handler.toString().includes('new Response')
-              && !route.handler.toString().includes('await')
-              && route.middleware.length === 0
-            ) {
-              try {
-                // Create an enhanced request with empty params and cookie support
-                const mockReq = this.enhanceRequest(new Request('https://example.com'), {})
-                const testResult = (route.handler as any)(mockReq)
-
-                // If it returns a Response directly, use it as a static route
-                if (testResult instanceof Response) {
-                  bunRoutes[path] = testResult
-                  continue
-                }
-              }
-              catch {
-                // If there's an error, fall back to the dynamic handler
-              }
-            }
-
-            // Dynamic route handler
-            bunRoutes[path] = async (req: Request) => {
-              // Create enhanced request with params
-              const url = new URL(req.url)
-              const params: Record<string, string> = {}
-              const constraintsRecord = route.constraints && !Array.isArray(route.constraints)
-                ? route.constraints as Record<string, string>
-                : undefined
-              matchPath(path, url.pathname, params, constraintsRecord)
-              const enhancedReq = this.enhanceRequest(req, params)
-
-              // Treat the route handler as the terminal middleware so the
-              // chain reaches it. Previously this code called
-              // `runMiddleware(stack)` without the handler and then only
-              // called `resolveHandler()` if middlewareResult was falsy.
-              // The chain in `buildMiddlewareChain` bottoms out in
-              // `return result || new Response(null, { status: 200 })` —
-              // so any user middleware that does `await next()` (cors,
-              // request-id, auth gates, etc.) gets a truthy empty Response
-              // back from the bottom of the chain, returns it, and the
-              // outer `if (middlewareResult)` short-circuits before the
-              // handler runs. Visible symptom: every route returns
-              // `200 OK` with `Content-Length: 0`.
-              const routeHandlerMiddleware = async (req2: any, _next: any) =>
-                await this.resolveHandler(route.handler, req2)
-              const middlewareStack = [...this.globalMiddleware, ...route.middleware, routeHandlerMiddleware]
-              const response = await this.runMiddleware(enhancedReq, middlewareStack)
-              return this.applyModifiedCookies(
-                response ?? new Response('No response from middleware chain', { status: 500 }),
-                enhancedReq,
-              )
-            }
-          }
-          else {
-            // Multiple routes for same path (method-specific)
-            const methodHandlers: Record<string, any> = {}
-
-            for (const route of routes) {
-              const method = route.method
-
-              methodHandlers[method] = async (req: Request) => {
-                // Create enhanced request with params
-                const url = new URL(req.url)
-                const params: Record<string, string> = {}
-                const constraintsRecord = route.constraints && !Array.isArray(route.constraints)
-                  ? route.constraints as Record<string, string>
-                  : undefined
-                matchPath(path, url.pathname, params, constraintsRecord)
-                const enhancedReq = this.enhanceRequest(req, params)
-
-                // See the long comment above the single-method branch:
-                // include the route handler as the terminal middleware so
-                // the chain reaches it. Without this, any user middleware
-                // (cors, request-id) short-circuits to a 200-empty default
-                // and the handler never runs.
-                const routeHandlerMiddleware = async (req2: any, _next: any) =>
-                  await this.resolveHandler(route.handler, req2)
-                const middlewareStack = [...this.globalMiddleware, ...route.middleware, routeHandlerMiddleware]
-                const response = await this.runMiddleware(enhancedReq, middlewareStack)
-                return this.applyModifiedCookies(
-                  response ?? new Response('No response from middleware chain', { status: 500 }),
-                  enhancedReq,
-                )
-              }
-            }
-
-            bunRoutes[path] = methodHandlers
-          }
-        }
-
-        return bunRoutes
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Load routes from files
-     */
-    loadRoutes: {
-      async value(): Promise<void> {
-        if (!this.config.routesPath) {
-          return
-        }
-
-        try {
-          // Try to import API routes if configured
-          if (this.config.apiRoutesPath) {
-            try {
-              const apiRoutes = await import(this.config.apiRoutesPath)
-              if (apiRoutes.default && Array.isArray(apiRoutes.default)) {
-                // Register each route
-                for (const route of apiRoutes.default) {
-                  this.registerRoute(route, 'api')
-                }
-              }
-            }
-            catch (error) {
-              if (this.config.verbose) {
-                console.warn(`Failed to load API routes: ${error}`)
-              }
-            }
-          }
-
-          // Try to import Web routes if configured
-          if (this.config.webRoutesPath) {
-            try {
-              const webRoutes = await import(this.config.webRoutesPath)
-              if (webRoutes.default && Array.isArray(webRoutes.default)) {
-                // Register each route
-                for (const route of webRoutes.default) {
-                  this.registerRoute(route, 'web')
-                }
-              }
-            }
-            catch (error) {
-              if (this.config.verbose) {
-                console.warn(`Failed to load Web routes: ${error}`)
-              }
-            }
-          }
-        }
-        catch (error) {
-          console.error('Error loading routes:', error)
-        }
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Register a route definition
-     */
-    registerRoute: {
-      value(route: RouteDefinition, type: 'api' | 'web'): void {
-        const { path, method, handler, middleware = [], name } = route
-
-        // Map HTTP method to Router method
-        switch (method) {
-          case 'GET':
-            this.get(path, handler, type, name, middleware)
-            break
-          case 'POST':
-            this.post(path, handler, type, name, middleware)
-            break
-          case 'PUT':
-            this.put(path, handler, type, name, middleware)
-            break
-          case 'DELETE':
-            this.delete(path, handler, type, name, middleware)
-            break
-          case 'PATCH':
-            this.patch(path, handler, type, name, middleware)
-            break
-          case 'OPTIONS':
-            this.options(path, handler, type, name, middleware)
-            break
-          default:
-            console.warn(`Unsupported HTTP method: ${method}`)
-        }
-      },
-      writable: true,
-      configurable: true,
-    },
-  })
-}