@stacksjs/bun-router 0.0.13 → 0.0.15

package/src/router/route-building.ts

@@ -64,18 +64,26 @@ export function registerRouteBuilding(RouterClass: typeof Router): void {
               matchPath(path, url.pathname, params, constraintsRecord)
               const enhancedReq = this.enhanceRequest(req, params)
 
-              // Run middleware
-              const middlewareResult = await this.runMiddleware(
+              // 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,
-                [...this.globalMiddleware, ...route.middleware],
               )
-              if (middlewareResult) {
-                return this.applyModifiedCookies(middlewareResult, enhancedReq)
-              }
-
-              // Run route handler
-              const response = await this.resolveHandler(route.handler, enhancedReq)
-              return this.applyModifiedCookies(response, enhancedReq)
             }
           }
           else {
@@ -95,18 +103,19 @@ export function registerRouteBuilding(RouterClass: typeof Router): void {
                 matchPath(path, url.pathname, params, constraintsRecord)
                 const enhancedReq = this.enhanceRequest(req, params)
 
-                // Run middleware
-                const middlewareResult = await this.runMiddleware(
+                // 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,
-                  [...this.globalMiddleware, ...route.middleware],
                 )
-                if (middlewareResult) {
-                  return this.applyModifiedCookies(middlewareResult, enhancedReq)
-                }
-
-                // Run route handler
-                const response = await this.resolveHandler(route.handler, enhancedReq)
-                return this.applyModifiedCookies(response, enhancedReq)
               }
             }
 

package/src/router/router.ts

@@ -389,51 +389,73 @@ export class Router {
   }
 
   /**
-   * HTTP GET method
+   * HTTP GET method.
+   *
+   * `TPath` is inferred from the path literal at the call site, so an
+   * inline handler's `request.params` narrows to the extracted keyset:
+   *
+   * ```ts
+   * router.get('/api/users/{id}', (req) => {
+   *   req.params.id // typed `string`, no `as any`
+   *   // @ts-expect-error wrong key
+   *   req.params.bogus
+   * })
+   * ```
+   *
+   * The string-action / class-handler forms (`'Actions/Foo/BarAction'`)
+   * keep working — `ActionHandler<TPath>` is a union that accepts them.
+   * See stacksjs/stacks#1851 for the broader typed-request work.
    */
-  get(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router {
+  get<TPath extends string>(path: TPath, handler: ActionHandler<TPath>, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router {
     return this.registerRoute('GET', path, handler, type, name, middleware)
   }
 
   /**
-   * HTTP POST method
+   * HTTP POST method. See {@link get} for `TPath`-driven param
+   * narrowing on inline handlers.
    */
-  post(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router {
+  post<TPath extends string>(path: TPath, handler: ActionHandler<TPath>, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router {
     return this.registerRoute('POST', path, handler, type, name, middleware)
   }
 
   /**
-   * HTTP PUT method
+   * HTTP PUT method. See {@link get} for `TPath`-driven param
+   * narrowing on inline handlers.
    */
-  put(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router {
+  put<TPath extends string>(path: TPath, handler: ActionHandler<TPath>, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router {
     return this.registerRoute('PUT', path, handler, type, name, middleware)
   }
 
   /**
-   * HTTP PATCH method
+   * HTTP PATCH method. See {@link get} for `TPath`-driven param
+   * narrowing on inline handlers.
    */
-  patch(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router {
+  patch<TPath extends string>(path: TPath, handler: ActionHandler<TPath>, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router {
     return this.registerRoute('PATCH', path, handler, type, name, middleware)
   }
 
   /**
-   * HTTP DELETE method
+   * HTTP DELETE method. See {@link get} for `TPath`-driven param
+   * narrowing on inline handlers.
    */
-  delete(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router {
+  delete<TPath extends string>(path: TPath, handler: ActionHandler<TPath>, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router {
     return this.registerRoute('DELETE', path, handler, type, name, middleware)
   }
 
   /**
-   * HTTP OPTIONS method
+   * HTTP OPTIONS method. See {@link get} for `TPath`-driven param
+   * narrowing on inline handlers.
    */
-  options(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router {
+  options<TPath extends string>(path: TPath, handler: ActionHandler<TPath>, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router {
     return this.registerRoute('OPTIONS', path, handler, type, name, middleware)
   }
 
   /**
-   * Register route for multiple HTTP methods
+   * Register the same handler against multiple HTTP methods. The
+   * handler is type-narrowed via {@link ActionHandler}'s `TPath`
+   * generic, same as the single-method overloads.
    */
-  match(methods: string[], path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router {
+  match<TPath extends string>(methods: string[], path: TPath, handler: ActionHandler<TPath>, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router {
     for (const method of methods) {
       this.registerRoute(method, path, handler, type, name, middleware)
     }
@@ -441,9 +463,10 @@ export class Router {
   }
 
   /**
-   * Register route for any HTTP method
+   * Register the handler against every HTTP method. See {@link get}
+   * for `TPath`-driven param narrowing on inline handlers.
    */
-  any(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router {
+  any<TPath extends string>(path: TPath, handler: ActionHandler<TPath>, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Router {
     const methods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD']
     return this.match(methods, path, handler, type, name, middleware)
   }

package/src/types.ts

@@ -1959,6 +1959,18 @@ export interface RequestMacroMethods {
   cookies: () => Record<string, string>
 
   // Files
+  /**
+   * Lookup a single uploaded file by form field name. Returns the
+   * matching `FileInfo` (structurally an `UploadedFile`) or `null` when
+   * no field with that name was uploaded. Populated by the multipart
+   * file-upload middleware alongside `files: UploadedFile[]`. Mirrors
+   * Laravel's `$request->file('avatar')`:
+   *
+   * ```ts
+   * const avatar = req.file('avatar')
+   * if (!avatar) return new Response('Missing avatar', { status: 400 })
+   * ```
+   */
   file: (name: string) => FileInfo | null
   hasFile: (name: string) => boolean