chore: wip

Author: chrisbbreuer

packages/bun-router/src/config.ts

@@ -311,9 +311,9 @@ let _config: RouterConfig | null = null
 export async function getConfig(): Promise<RouterConfig> {
   if (!_config) {
     _config = await loadConfig({
-  name: 'router',
-  defaultConfig,
-})
+      name: 'router',
+      defaultConfig,
+    })
   }
   return _config
 }

packages/bun-router/src/router/fluent-router.ts

@@ -12,6 +12,7 @@ import type {
   RouteHandler,
 } from '../types'
 import type { Router } from './router'
+import { matchPath } from '../utils'
 
 // ============================================================================
 // Types
@@ -177,8 +178,10 @@ export class FluentRouter {
         handler: resolvedHandler,
         middleware,
         domain: this.currentDomain || undefined,
+        pattern: this.createPattern(fullPath),
       }
-      this.router.addRoute(route)
+      // Use direct push to routes array to avoid conflict with http-methods.ts addRoute
+      this.router.routes.push(route)
     }
 
     return new FluentRouteBuilder(this.router, fullPath, methods[0])
@@ -191,11 +194,11 @@ export class FluentRouter {
   /**
    * Register a resource controller
    */
-  resource(name: string, controller: ControllerClass, options: ResourceOptions = {}): this {
+  resource(name: string, Controller: ControllerClass, options: ResourceOptions = {}): this {
     const methods = this.getResourceMethods(options)
     const paramName = options.parameters?.[name] || 'id'
 
-    const controllerInstance = new controller()
+    const controllerInstance = new Controller()
 
     for (const method of methods) {
       const { httpMethod, path, handlerName } = this.getResourceRoute(name, method, paramName)
@@ -212,8 +215,13 @@ export class FluentRouter {
           middleware: this.buildMiddleware(options.middleware),
           name: this.currentNamePrefix + routeName,
           domain: this.currentDomain || undefined,
+          pattern: this.createPattern(fullPath),
+        }
+        // Use direct push to routes array to avoid conflict with http-methods.ts addRoute
+        this.router.routes.push(route)
+        if (route.name) {
+          this.router.namedRoutes.set(route.name, route)
         }
-        this.router.addRoute(route)
       }
     }
 
@@ -235,9 +243,9 @@ export class FluentRouter {
   /**
    * Register a singleton resource (no index, create, store, destroy)
    */
-  singleton(name: string, controller: ControllerClass, options: ResourceOptions = {}): this {
+  singleton(name: string, Controller: ControllerClass, options: ResourceOptions = {}): this {
     const singletonMethods: SingletonMethod[] = ['show', 'edit', 'update']
-    const controllerInstance = new controller()
+    const controllerInstance = new Controller()
 
     for (const method of singletonMethods) {
       if (options.except?.includes(method))
@@ -259,8 +267,13 @@ export class FluentRouter {
           middleware: this.buildMiddleware(options.middleware),
           name: this.currentNamePrefix + routeName,
           domain: this.currentDomain || undefined,
+          pattern: this.createPattern(fullPath),
+        }
+        // Use direct push to routes array to avoid conflict with http-methods.ts addRoute
+        this.router.routes.push(route)
+        if (route.name) {
+          this.router.namedRoutes.set(route.name, route)
         }
-        this.router.addRoute(route)
       }
     }
 
@@ -410,12 +423,39 @@ export class FluentRouter {
       handler: resolvedHandler,
       middleware,
       domain: this.currentDomain || undefined,
+      pattern: this.createPattern(fullPath),
     }
 
-    this.router.addRoute(route)
+    // Use direct push to routes array to avoid conflict with http-methods.ts addRoute
+    this.router.routes.push(route)
+    if (route.name) {
+      this.router.namedRoutes.set(route.name, route)
+    }
     return new FluentRouteBuilder(this.router, fullPath, method)
   }
 
+  /**
+   * Create a pattern object for route matching
+   */
+  private createPattern(routePath: string): { exec: (url: URL) => { pathname: { groups: Record<string, string> } } | null } {
+    return {
+      exec: (url: URL): { pathname: { groups: Record<string, string> } } | null => {
+        const params: Record<string, string> = {}
+        const isMatch = matchPath(routePath, url.pathname, params)
+
+        if (!isMatch) {
+          return null
+        }
+
+        return {
+          pathname: {
+            groups: params,
+          },
+        }
+      },
+    }
+  }
+
   private buildPath(path: string): string {
     if (this.currentPrefix) {
       return `${this.currentPrefix}${path.startsWith('/') ? path : `/${path}`}`
@@ -433,7 +473,8 @@ export class FluentRouter {
   private resolveHandler(handler: RouteHandler | string): ActionHandler {
     if (typeof handler === 'string') {
       if (this.currentController) {
-        const controllerInstance = new this.currentController()
+        const ControllerClass = this.currentController
+        const controllerInstance = new ControllerClass()
         const method = controllerInstance[handler] as RouteHandler | undefined
         if (method) {
           return method.bind(controllerInstance)

packages/bun-router/src/router/index.ts

@@ -1,4 +1,4 @@
-import type { ActionHandler, MiddlewareHandler, Route } from '../types'
+import type { ActionHandler, Route } from '../types'
 import { Dependencies, globalMiddlewarePipeline, MiddlewareFactory, MiddlewarePipeline, SkipConditions } from '../middleware/pipeline'
 import { registerFileStreaming } from './file-streaming'
 import { FluentRouteBuilder, FluentRouter, RouteFactory, router, RouterUtils } from './fluent-routing'

packages/bun-router/src/router/router.ts

@@ -2,6 +2,7 @@ import type { Server } from 'bun'
 import type { MiddlewareDependency, MiddlewarePipeline, MiddlewarePipelineStats, MiddlewareSkipCondition } from '../middleware/pipeline'
 import type {
   ActionHandler,
+  CookieOptions,
   EnhancedRequest,
   MiddlewareHandler,
   NextFunction,
@@ -490,19 +491,15 @@ export class Router {
     // Invalidate route cache before starting server
     this.invalidateCache()
 
-    // Create server options
-    const serverOptions: any = {
+    // Create server options - use type assertion for Bun.serve compatibility
+    const serverOptions = {
       ...options,
       fetch: this.handleRequest.bind(this),
-    }
-
-    // Apply WebSocket configuration if provided
-    if (this.wsConfig) {
-      serverOptions.websocket = this.wsConfig
-    }
+      websocket: this.wsConfig,
+    } as Parameters<typeof Bun.serve>[0]
 
     // Start the server
-    this.serverInstance = Bun.serve(serverOptions)
+    this.serverInstance = Bun.serve(serverOptions) as Server<WebSocketData>
 
     if (this.config.verbose) {
       const port = this.serverInstance.port
@@ -563,7 +560,7 @@ export class Router {
         }
 
         // Create a final middleware that executes the route handler
-        const routeHandlerMiddleware = async (req: EnhancedRequest, _next: any) => {
+        const routeHandlerMiddleware = async (req: EnhancedRequest, _next: NextFunction) => {
           return await this.resolveHandler(match.route.handler, req)
         }
 
@@ -742,14 +739,14 @@ export class Router {
     // Create cookie utilities with lazy parsing
     const cookies = {
       get: (name: string) => getCookies()[name],
-      set: (name: string, value: string, options: any = {}) => {
+      set: (name: string, value: string, options: CookieOptions = {}) => {
         const enhancedRequest = req as EnhancedRequest
         if (!enhancedRequest._cookiesToSet) {
           enhancedRequest._cookiesToSet = []
         }
         enhancedRequest._cookiesToSet.push({ name, value, options })
       },
-      delete: (name: string, options: any = {}) => {
+      delete: (name: string, options: CookieOptions = {}) => {
         const enhancedRequest = req as EnhancedRequest
         if (!enhancedRequest._cookiesToDelete) {
           enhancedRequest._cookiesToDelete = []
@@ -811,7 +808,7 @@ export class Router {
   /**
    * Serialize a cookie for the Set-Cookie header
    */
-  serializeCookie(name: string, value: string, options: any = {}): string {
+  serializeCookie(name: string, value: string, options: CookieOptions = {}): string {
     let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`
 
     if (options.maxAge !== undefined) {
@@ -899,22 +896,22 @@ export class Router {
   /**
    * Resolve an action handler
    */
-  async resolveHandler(handler: any, req: EnhancedRequest): Promise<Response> {
+  async resolveHandler(handler: ActionHandler, req: EnhancedRequest): Promise<Response> {
     // If it's a function, call it with the request
-    if (typeof handler === 'function' && !handler.prototype?.handle) {
-      return await handler(req)
+    if (typeof handler === 'function' && !(handler as { prototype?: { handle?: unknown } }).prototype?.handle) {
+      return await (handler as (req: EnhancedRequest) => Response | Promise<Response>)(req)
     }
 
     // If it's a class constructor, instantiate it and call handle
-    if (typeof handler === 'function' && handler.prototype && typeof handler.prototype.handle === 'function') {
-      const HandlerClass = handler
+    if (typeof handler === 'function' && (handler as { prototype?: { handle?: unknown } }).prototype?.handle) {
+      const HandlerClass = handler as new () => { handle: (req: EnhancedRequest) => Response | Promise<Response> }
       const handlerInstance = new HandlerClass()
       return await handlerInstance.handle(req)
     }
 
     // If it's an object with a handle method
-    if (handler && typeof handler.handle === 'function') {
-      return await handler.handle(req)
+    if (handler && typeof (handler as unknown as { handle?: unknown }).handle === 'function') {
+      return await (handler as unknown as { handle: (req: EnhancedRequest) => Response | Promise<Response> }).handle(req)
     }
 
     throw new Error(`Invalid action handler: ${typeof handler}`)

packages/bun-router/test/basic-middleware.test.ts

@@ -26,7 +26,7 @@ describe('Bun Router - Middleware Tests', () => {
     }
 
     // Create a route that uses the middleware
-    await router.get('/middleware-test', async (req) => {
+    await router.get('/middleware-test', async (req: EnhancedRequest) => {
       return new Response(`Request ID: ${req.requestId}`, {
         status: 200,
       })

packages/bun-router/test/cli.test.ts

@@ -1,3 +1,4 @@
+import type { EnhancedRequest } from '../src/types'
 import { beforeEach, describe, expect, it } from 'bun:test'
 import { Router } from '../src/router/index'
 
@@ -26,7 +27,7 @@ describe('CLI Commands', () => {
       await router.get('/test', () => new Response('test'))
       await router.post('/users', () => new Response('create user'))
       await router.get('/admin/dashboard', () => new Response('admin'), 'web', 'admin.dashboard')
-      await router.get('/users/{id}', req => new Response(`User ${req.params.id}`)) // Dynamic route
+      await router.get('/users/{id}', (req: EnhancedRequest) => new Response(`User ${req.params.id}`)) // Dynamic route
 
       // Verify routes were added
       expect(router.routes.length).toBe(4)
@@ -158,7 +159,7 @@ describe('CLI Commands', () => {
 
   describe('Route Debugging Logic', () => {
     it('should match routes successfully', async () => {
-      await router.get('/users/{id}', req => new Response(`User ${req.params.id}`), 'web', 'users.show')
+      await router.get('/users/{id}', (req: EnhancedRequest) => new Response(`User ${req.params.id}`), 'web', 'users.show')
 
       // Test route matching functionality
       expect(router.matchRoute).toBeDefined()
@@ -188,7 +189,7 @@ describe('CLI Commands', () => {
     })
 
     it('should handle routes with optional parameters', async () => {
-      await router.get('/products/{category}/{id?}', (req) => {
+      await router.get('/products/{category}/{id?}', (req: EnhancedRequest) => {
         if (req.params.id) {
           return new Response(`Product ${req.params.id} in ${req.params.category}`)
         }