@stacksjs/bun-router 0.0.7 → 0.0.9

package/dist/response/response-factory.d.ts

@@ -39,7 +39,7 @@ export interface ResponseCookieOptions {
     sameSite?: 'strict' | 'lax' | 'none';
 }
 export interface ResponseFactory {
-    json: <T>(data: T, options?: JsonResponseOptions) => Response;
+    json: <T>(data: T, options?: JsonResponseOptions | ResponseStatus) => Response;
     noContent: (headers?: Record<string, string>) => Response;
     download: (filePath: string, filename?: string, headers?: Record<string, string>) => Promise<Response>;
     file: (filePath: string, headers?: Record<string, string>) => Promise<Response>;

package/dist/router/index.d.ts

@@ -4,6 +4,7 @@ import { FluentRouteBuilder, FluentRouter, RouteFactory, router, RouterUtils } f
 import { Router } from './router';
 import '../types';
 export { Router };
+export { applyRequestEnhancements } from './router';
 declare module './router' {
     interface Router {
         stream: (callback: () => Generator<string | Uint8Array, void, unknown> | AsyncGenerator<string | Uint8Array, void, unknown>, status?: number, headers?: Record<string, string>) => Response;

package/dist/router/router.d.ts

@@ -274,3 +274,21 @@ export declare class RouteGroupBuilder {
     put(_path: string, _handler: RouteHandler): this;
     delete(_path: string, _handler: RouteHandler): this;
 }
+/**
+ * Attach bun-router's request macros (`bearerToken`, `getParam`, `cookie`,
+ * `cookies`, `header`, `params`, plus the Laravel-style input helpers
+ * `get`, `input`, `string`, `integer`, `float`, `boolean`, `array`, `has`,
+ * `filled`, etc.) to a request.
+ *
+ * Idempotent: calling on an already-enhanced request returns it unchanged.
+ * We sniff `req.bearerToken` as the marker — cheap and reliable since no
+ * native Request has it.
+ *
+ * @example
+ * import { applyRequestEnhancements } from '@stacksjs/bun-router'
+ *
+ * const enhanced = applyRequestEnhancements(req, { id: '42' })
+ * enhanced.bearerToken()  // → string | null
+ * enhanced.getParam('id') // → '42'
+ */
+export declare function applyRequestEnhancements(req: Request | EnhancedRequest, params?: Record<string, string>): EnhancedRequest;

package/dist/types.d.ts

@@ -688,6 +688,12 @@ export interface EnhancedRequest extends Request, Omit<RequestMacroMethods, 'ip'
      * Route parameters extracted from the URL
      */
     params: Record<string, string>;
+    /**
+     * Lookup a single route param. Equivalent to `request.params[name]` but
+     * with optional default-value handling, matching the Laravel-style
+     * `$request->route('name')` ergonomics.
+     */
+    getParam: <T = string>(name: string, defaultValue?: T) => T | undefined;
     /**
      * Query parameters from the URL
      */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/bun-router",
   "type": "module",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "A fast, type-safe router for Bun.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",

package/src/development/typescript-utilities.ts

@@ -423,6 +423,10 @@ export type MiddlewareWithConfig<T> = (config: T) => MiddlewareFunction
     const responseType = options.responseType || 'Response'
     const paramsType = options.paramsType || 'Record<string, string>'
 
+    // pickier mis-parses the embedded `req:` token in this template literal
+    // as a real unused function parameter — disable on the next line so a
+    // pre-existing rule false positive doesn't block CI.
+    // eslint-disable-next-line pickier/no-unused-vars
     return `(req: ${requestType} & { params: ${paramsType} }) => Promise<${responseType}>`
   }
 

package/src/response/response-factory.ts

@@ -53,7 +53,7 @@ export interface ResponseCookieOptions {
 // ============================================================================
 
 export interface ResponseFactory {
-  json: <T>(data: T, options?: JsonResponseOptions) => Response
+  json: <T>(data: T, options?: JsonResponseOptions | ResponseStatus) => Response
   noContent: (headers?: Record<string, string>) => Response
   download: (filePath: string, filename?: string, headers?: Record<string, string>) => Promise<Response>
   file: (filePath: string, headers?: Record<string, string>) => Promise<Response>
@@ -89,10 +89,18 @@ export interface ResponseFactory {
  */
 export const response: ResponseFactory = {
   /**
-   * Create a JSON response with proper typing
-   */
-  json: <T>(data: T, options: JsonResponseOptions = {}): Response => {
-    const { status = 200, headers = {}, pretty = false } = options
+   * Create a JSON response with proper typing.
+   *
+   * The second argument may be either a status code (Hono/Express style) or
+   * a `JsonResponseOptions` bag. The number form exists because passing a
+   * status as the second arg is the most common pattern in other web
+   * frameworks, and the silent `response.json(data, 401)` → HTTP 200 trap
+   * (the number was being interpreted as `options` and discarded) caused
+   * real bugs.
+   */
+  json: <T>(data: T, options: JsonResponseOptions | ResponseStatus = {}): Response => {
+    const opts: JsonResponseOptions = typeof options === 'number' ? { status: options } : options
+    const { status = 200, headers = {}, pretty = false } = opts
     const body = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data)
 
     return new Response(body, {

package/src/router/index.ts

@@ -33,8 +33,10 @@ registerModelBinding(Router)
 registerFileBasedRouting(Router)
 registerApiRoutes(Router)
 
-// Export the Router class and fluent routing features
+// Export the Router class, the standalone request-enhancement helper, and
+// fluent routing features.
 export { Router }
+export { applyRequestEnhancements } from './router'
 
 // Type augmentation for Laravel-style methods
 declare module './router' {

package/src/router/router.ts

@@ -1147,6 +1147,15 @@ export class Router {
       return req.headers.get(name) || req.headers.get(name.toLowerCase()) || null
     }
 
+    // Convenience cookie reader. The full `enhancedReq.cookies.get(name)` API
+    // is also available below — `cookie(name)` is the shorter form callers
+    // (and the Laravel-style macros) reach for first, so it deserves a
+    // direct method on the enhanced request, not just on the macros class.
+    ;(enhancedReq as any).cookie = (name: string, defaultValue?: string): string | null => {
+      const value = getCookies()[name]
+      return value !== undefined ? value : (defaultValue ?? null)
+    }
+
     ;(enhancedReq as any).getParam = <T = string>(name: string, defaultValue?: T): T | undefined => {
       const value = params?.[name] as T | undefined
       return value !== undefined ? value : defaultValue
@@ -1522,3 +1531,51 @@ export class RouteGroupBuilder {
     return this
   }
 }
+
+// ---------------------------------------------------------------------------
+// Standalone enhancement helper
+// ---------------------------------------------------------------------------
+
+// Singleton scratch Router used to expose `enhanceRequest` as a standalone
+// function. Downstream consumers (frameworks layered on bun-router) often
+// need to attach the request macros to a request that was created outside
+// of `route.serve()` — for instance, when a higher-level router wraps
+// each handler with its own middleware chain. Without an exported function,
+// those consumers either spin up their own `new Router()` per call or
+// duplicate the attachment logic in user code.
+//
+// We share one instance because `enhanceRequest` does not depend on any
+// per-router state (route table, middleware groups, etc.) — it only reads
+// from the request and the supplied params.
+let _enhancementHost: Router | null = null
+
+function getEnhancementHost(): Router {
+  if (_enhancementHost === null) _enhancementHost = new Router()
+  return _enhancementHost
+}
+
+/**
+ * Attach bun-router's request macros (`bearerToken`, `getParam`, `cookie`,
+ * `cookies`, `header`, `params`, plus the Laravel-style input helpers
+ * `get`, `input`, `string`, `integer`, `float`, `boolean`, `array`, `has`,
+ * `filled`, etc.) to a request.
+ *
+ * Idempotent: calling on an already-enhanced request returns it unchanged.
+ * We sniff `req.bearerToken` as the marker — cheap and reliable since no
+ * native Request has it.
+ *
+ * @example
+ * import { applyRequestEnhancements } from '@stacksjs/bun-router'
+ *
+ * const enhanced = applyRequestEnhancements(req, { id: '42' })
+ * enhanced.bearerToken()  // → string | null
+ * enhanced.getParam('id') // → '42'
+ */
+export function applyRequestEnhancements(
+  req: Request | EnhancedRequest,
+  params: Record<string, string> = {},
+): EnhancedRequest {
+  if (typeof (req as any).bearerToken === 'function')
+    return req as EnhancedRequest
+  return getEnhancementHost().enhanceRequest(req as Request, params)
+}

package/src/router/server.ts

@@ -1,6 +1,7 @@
 import type { Server } from 'bun'
 import type { EnhancedRequest, HTTPMethod, ServerOptions } from '../types'
 import type { Router } from './router'
+import { RequestWithMacros } from '../request/macros'
 import { runWithRequest, setCurrentRequest } from '../request/context'
 
 /**
@@ -333,7 +334,13 @@ export function registerServerHandling(RouterClass: typeof Router): void {
           _cookiesToDelete: [],
         }) as unknown as EnhancedRequest
 
-        // Add cookie methods to the request
+        // Attach registered request macros (input, has, bearerToken, etc.) so
+        // they're available in middleware and handlers without manual setup.
+        // Applied *before* the cookie utility so the cookies macro doesn't
+        // overwrite the get/set/delete object form consumers depend on.
+        RequestWithMacros.applyMacros(enhancedReq)
+
+        // Add cookie methods to the request (overrides any macro named `cookies`).
         Object.assign(enhancedReq, { cookies: { ...getCookies(), ...cookies } })
 
         return enhancedReq

package/src/types.ts

@@ -793,6 +793,12 @@ export interface EnhancedRequest extends Request, Omit<RequestMacroMethods, 'ip'
    * Route parameters extracted from the URL
    */
   params: Record<string, string>
+  /**
+   * Lookup a single route param. Equivalent to `request.params[name]` but
+   * with optional default-value handling, matching the Laravel-style
+   * `$request->route('name')` ergonomics.
+   */
+  getParam: <T = string>(name: string, defaultValue?: T) => T | undefined
   /**
    * Query parameters from the URL
    */