@stacksjs/bun-router 0.0.6 → 0.0.7

package/dist/cli.js

@@ -1879,7 +1879,7 @@ var prefix = getPrefix();
 var color18 = __toESM(require_picocolors(), 1);
 var import_picocolors19 = __toESM(require_picocolors(), 1);
 // package.json
-var version = "0.0.6";
+var version = "0.0.7";
 
 // src/cli/middleware.ts
 import fs from "fs/promises";

package/dist/index.js

@@ -8847,7 +8847,12 @@ class Router {
       const allowedMethods = this.getAllowedMethods(url2.pathname, hostname);
       if (allowedMethods.length > 0) {
         const methodNotAllowedHandler = async (_req, _next) => {
-          return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+          return new Response(JSON.stringify({
+            error: "Method Not Allowed",
+            path: url2.pathname,
+            method: req.method,
+            allowed: allowedMethods
+          }), {
             status: 405,
             headers: {
               "Content-Type": "application/json",
@@ -8869,7 +8874,11 @@ class Router {
           if (this.fallbackHandler) {
             return await this.resolveHandler(this.fallbackHandler, enhancedReq);
           }
-          return new Response(JSON.stringify({ error: "Not Found" }), {
+          return new Response(JSON.stringify({
+            error: "Not Found",
+            path: url2.pathname,
+            method: req.method
+          }), {
             status: 404,
             headers: { "Content-Type": "application/json" }
           });
@@ -8884,7 +8893,11 @@ class Router {
         const response2 = await this.resolveHandler(this.fallbackHandler, enhancedReq);
         return this.applyModifiedCookies(response2, enhancedReq);
       }
-      return new Response(JSON.stringify({ error: "Not Found" }), {
+      return new Response(JSON.stringify({
+        error: "Not Found",
+        path: url2.pathname,
+        method: req.method
+      }), {
         status: 404,
         headers: { "Content-Type": "application/json" }
       });
@@ -9637,31 +9650,52 @@ function registerServerHandling(RouterClass) {
             return new Response("No response from middleware chain", { status: 500 });
           }
           const allowedMethods = this.getAllowedMethods(url2.pathname, hostname);
+          const corsHeaders = {
+            "Content-Type": "application/json",
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+            "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Requested-With, Accept, Origin"
+          };
           if (allowedMethods.length > 0) {
-            return new Response(JSON.stringify({ success: false, message: "Method Not Allowed" }), {
-              status: 405,
-              headers: {
-                "Content-Type": "application/json",
-                Allow: allowedMethods.join(", "),
-                "Access-Control-Allow-Origin": "*",
-                "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
-                "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Requested-With, Accept, Origin"
-              }
-            });
+            const methodNotAllowedHandler = async (_req, _next) => {
+              return new Response(JSON.stringify({
+                success: false,
+                message: "Method Not Allowed",
+                path: url2.pathname,
+                method: req.method,
+                allowed: allowedMethods
+              }), {
+                status: 405,
+                headers: { ...corsHeaders, Allow: allowedMethods.join(", ") }
+              });
+            };
+            if (this.globalMiddleware.length > 0) {
+              const stack = [...this.globalMiddleware, methodNotAllowedHandler];
+              const response2 = await this.runMiddleware(enhancedReq, stack);
+              if (response2)
+                return this.applyModifiedCookies(response2, enhancedReq);
+            }
+            return await methodNotAllowedHandler(enhancedReq, async () => null);
           }
           if (this.fallbackHandler) {
             const response2 = await this.resolveHandler(this.fallbackHandler, enhancedReq);
             return this.applyModifiedCookies(response2, enhancedReq);
           }
-          return new Response(JSON.stringify({ success: false, message: "Not Found" }), {
-            status: 404,
-            headers: {
-              "Content-Type": "application/json",
-              "Access-Control-Allow-Origin": "*",
-              "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
-              "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Requested-With, Accept, Origin"
-            }
-          });
+          const notFoundHandler = async (_req, _next) => {
+            return new Response(JSON.stringify({
+              success: false,
+              message: "Not Found",
+              path: url2.pathname,
+              method: req.method
+            }), { status: 404, headers: corsHeaders });
+          };
+          if (this.globalMiddleware.length > 0) {
+            const stack = [...this.globalMiddleware, notFoundHandler];
+            const response2 = await this.runMiddleware(enhancedReq, stack);
+            if (response2)
+              return this.applyModifiedCookies(response2, enhancedReq);
+          }
+          return await notFoundHandler(enhancedReq, async () => null);
         } catch (error) {
           console.error("Error handling request:", error);
           if (this.errorHandler) {

package/package.json

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

package/src/router/router.ts

@@ -611,13 +611,21 @@ export class Router {
         return new Response('No response from middleware chain', { status: 500 })
       }
 
-      // No route found - check if the path exists with a different method (405 vs 404)
+      // No route found - check if the path exists with a different method (405 vs 404).
+      // 404/405 bodies now include path + method so client-side debugging (typo'd
+      // endpoint, stale SPA cache, missing route registration) is one grep away.
+      // Both responses still flow through globalMiddleware so user middleware
+      // (X-Request-ID, audit, custom CORS) sees them.
       const allowedMethods = this.getAllowedMethods(url.pathname, hostname)
 
-      // If there are allowed methods, return 405 Method Not Allowed
       if (allowedMethods.length > 0) {
         const methodNotAllowedHandler = async (_req: EnhancedRequest, _next: NextFunction) => {
-          return new Response(JSON.stringify({ error: 'Method Not Allowed' }), {
+          return new Response(JSON.stringify({
+            error: 'Method Not Allowed',
+            path: url.pathname,
+            method: req.method,
+            allowed: allowedMethods,
+          }), {
             status: 405,
             headers: {
               'Content-Type': 'application/json',
@@ -643,7 +651,11 @@ export class Router {
           if (this.fallbackHandler) {
             return await this.resolveHandler(this.fallbackHandler, enhancedReq)
           }
-          return new Response(JSON.stringify({ error: 'Not Found' }), {
+          return new Response(JSON.stringify({
+            error: 'Not Found',
+            path: url.pathname,
+            method: req.method,
+          }), {
             status: 404,
             headers: { 'Content-Type': 'application/json' },
           })
@@ -661,8 +673,12 @@ export class Router {
         return this.applyModifiedCookies(response, enhancedReq)
       }
 
-      // No fallback handler, return a 404
-      return new Response(JSON.stringify({ error: 'Not Found' }), {
+      // No fallback handler, return a 404 with path context
+      return new Response(JSON.stringify({
+        error: 'Not Found',
+        path: url.pathname,
+        method: req.method,
+      }), {
         status: 404,
         headers: { 'Content-Type': 'application/json' },
       })

package/src/router/server.ts

@@ -195,21 +195,38 @@ export function registerServerHandling(RouterClass: typeof Router): void {
             return new Response('No response from middleware chain', { status: 500 })
           }
 
-          // No route found - check if the path exists with a different method (405 vs 404)
+          // No route found - check if the path exists with a different method (405 vs 404).
+          // The 404/405 responses below now (a) include path + method in the body so client
+          // debugging is one grep away, and (b) flow through globalMiddleware so cross-cutting
+          // concerns (X-Request-ID, Server-Timing, audit logging, custom CORS) can observe
+          // them. Previously these paths short-circuited entirely.
           const allowedMethods = this.getAllowedMethods(url.pathname, hostname)
+          const corsHeaders = {
+            'Content-Type': 'application/json',
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, PATCH, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-Requested-With, Accept, Origin',
+          }
 
-          // If there are allowed methods, return 405 Method Not Allowed
           if (allowedMethods.length > 0) {
-            return new Response(JSON.stringify({ success: false, message: 'Method Not Allowed' }), {
-              status: 405,
-              headers: {
-                'Content-Type': 'application/json',
-                'Allow': allowedMethods.join(', '),
-                'Access-Control-Allow-Origin': '*',
-                'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, PATCH, OPTIONS',
-                'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-Requested-With, Accept, Origin',
-              },
-            })
+            const methodNotAllowedHandler = async (_req: EnhancedRequest, _next: any) => {
+              return new Response(JSON.stringify({
+                success: false,
+                message: 'Method Not Allowed',
+                path: url.pathname,
+                method: req.method,
+                allowed: allowedMethods,
+              }), {
+                status: 405,
+                headers: { ...corsHeaders, Allow: allowedMethods.join(', ') },
+              })
+            }
+            if (this.globalMiddleware.length > 0) {
+              const stack = [...this.globalMiddleware, methodNotAllowedHandler]
+              const response = await this.runMiddleware(enhancedReq, stack)
+              if (response) return this.applyModifiedCookies(response, enhancedReq)
+            }
+            return await methodNotAllowedHandler(enhancedReq, async () => null as any)
           }
 
           // No route found, try the fallback handler
@@ -218,16 +235,22 @@ export function registerServerHandling(RouterClass: typeof Router): void {
             return this.applyModifiedCookies(response, enhancedReq)
           }
 
-          // No fallback handler, return a 404 with CORS headers
-          return new Response(JSON.stringify({ success: false, message: 'Not Found' }), {
-            status: 404,
-            headers: {
-              'Content-Type': 'application/json',
-              'Access-Control-Allow-Origin': '*',
-              'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, PATCH, OPTIONS',
-              'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-Requested-With, Accept, Origin',
-            },
-          })
+          // No fallback — emit a 404 enriched with path + method, also through
+          // globalMiddleware so user middleware sees it.
+          const notFoundHandler = async (_req: EnhancedRequest, _next: any) => {
+            return new Response(JSON.stringify({
+              success: false,
+              message: 'Not Found',
+              path: url.pathname,
+              method: req.method,
+            }), { status: 404, headers: corsHeaders })
+          }
+          if (this.globalMiddleware.length > 0) {
+            const stack = [...this.globalMiddleware, notFoundHandler]
+            const response = await this.runMiddleware(enhancedReq, stack)
+            if (response) return this.applyModifiedCookies(response, enhancedReq)
+          }
+          return await notFoundHandler(enhancedReq, async () => null as any)
         }
         catch (error) {
           console.error('Error handling request:', error)