@b9g/router 0.1.7 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/router",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Universal request router for ServiceWorker applications. Built on web standards with cache-aware routing and generator-based middleware.",
   "keywords": [
     "router",
@@ -13,10 +13,11 @@
     "shovel"
   ],
   "dependencies": {
+    "@b9g/http-errors": "^0.1.5",
     "@b9g/match-pattern": "^0.1.7"
   },
   "devDependencies": {
-    "@b9g/libuild": "^0.1.11",
+    "@b9g/libuild": "^0.1.18",
     "bun-types": "latest"
   },
   "type": "module",

package/src/index.d.ts

@@ -189,4 +189,28 @@ export declare class Router {
         compiled: boolean;
     };
 }
+/**
+ * Mode for trailing slash normalization
+ * - "strip": Redirect /path/ → /path (removes trailing slash)
+ * - "add": Redirect /path → /path/ (adds trailing slash)
+ */
+export type TrailingSlashMode = "strip" | "add";
+/**
+ * Middleware that normalizes trailing slashes via 301 redirect
+ *
+ * @param mode - "strip" removes trailing slash, "add" adds trailing slash
+ * @returns Function middleware that redirects non-canonical URLs
+ *
+ * @example
+ * ```typescript
+ * import { Router, trailingSlash } from "@b9g/router";
+ *
+ * const router = new Router();
+ * router.use(trailingSlash("strip")); // Redirect /path/ → /path
+ *
+ * // Can also be scoped to specific paths
+ * router.use("/api", trailingSlash("strip"));
+ * ```
+ */
+export declare function trailingSlash(mode: TrailingSlashMode): FunctionMiddleware;
 export {};

package/src/index.js

@@ -5,7 +5,11 @@ import {
   isSimplePattern,
   compilePathname
 } from "@b9g/match-pattern";
-import { InternalServerError, isHTTPError } from "@b9g/http-errors";
+import {
+  InternalServerError,
+  NotFound,
+  isHTTPError
+} from "@b9g/http-errors";
 var RadixNode = class {
   children;
   // char -> RadixNode
@@ -265,27 +269,21 @@ var Router = class {
         }
         const matchResult = this.#executor.match(request);
         if (matchResult) {
-          const mutableRequest = this.#createMutableRequest(request);
           return await this.#executeMiddlewareStack(
             this.#middlewares,
-            mutableRequest,
+            request,
             matchResult.context,
-            matchResult.handler,
-            request.url,
-            this.#executor
+            matchResult.handler
           );
         } else {
           const notFoundHandler = async () => {
-            return new Response("Not Found", { status: 404 });
+            throw new NotFound();
           };
-          const mutableRequest = this.#createMutableRequest(request);
           return await this.#executeMiddlewareStack(
             this.#middlewares,
-            mutableRequest,
+            request,
             { params: {} },
-            notFoundHandler,
-            request.url,
-            this.#executor
+            notFoundHandler
           );
         }
       } catch (error) {
@@ -352,8 +350,6 @@ var Router = class {
       this.#executor = new RadixTreeExecutor(this.#routes);
       this.#dirty = false;
     }
-    const mutableRequest = this.#createMutableRequest(request);
-    const originalURL = mutableRequest.url;
     let matchResult = this.#executor.match(request);
     let handler;
     let context;
@@ -361,18 +357,25 @@ var Router = class {
       handler = matchResult.handler;
       context = matchResult.context;
     } else {
-      handler = async () => new Response("Not Found", { status: 404 });
+      handler = async () => {
+        throw new NotFound();
+      };
       context = { params: {} };
     }
-    let response = await this.#executeMiddlewareStack(
-      this.#middlewares,
-      mutableRequest,
-      context,
-      handler,
-      originalURL,
-      this.#executor
-      // Pass executor for re-routing
-    );
+    let response;
+    try {
+      response = await this.#executeMiddlewareStack(
+        this.#middlewares,
+        request,
+        context,
+        handler
+      );
+    } catch (error) {
+      if (!matchResult && isHTTPError(error) && error.status === 404) {
+        return null;
+      }
+      throw error;
+    }
     if (!matchResult && response?.status === 404) {
       return null;
     }
@@ -498,7 +501,7 @@ var Router = class {
   /**
    * Execute middleware stack with guaranteed execution using Rack-style LIFO order
    */
-  async #executeMiddlewareStack(middlewares, request, context, handler, originalURL, executor) {
+  async #executeMiddlewareStack(middlewares, request, context, handler) {
     const runningGenerators = [];
     let currentResponse = null;
     const requestPathname = new URL(request.url).pathname;
@@ -531,24 +534,9 @@ var Router = class {
       }
     }
     if (!currentResponse) {
-      let finalHandler = handler;
-      let finalContext = context;
-      if (request.url !== originalURL && executor) {
-        const newMatchResult = executor.match(
-          new Request(request.url, {
-            method: request.method,
-            headers: request.headers,
-            body: request.body
-          })
-        );
-        if (newMatchResult) {
-          finalHandler = newMatchResult.handler;
-          finalContext = newMatchResult.context;
-        }
-      }
       let handlerError = null;
       try {
-        currentResponse = await finalHandler(request, finalContext);
+        currentResponse = await handler(request, context);
       } catch (error) {
         handlerError = error;
       }
@@ -559,13 +547,6 @@ var Router = class {
         );
       }
     }
-    if (request.url !== originalURL && currentResponse) {
-      currentResponse = this.#handleAutomaticRedirect(
-        originalURL,
-        request.url,
-        request.method
-      );
-    }
     for (let i = runningGenerators.length - 1; i >= 0; i--) {
       const { generator } = runningGenerators[i];
       const result = await generator.next(currentResponse);
@@ -594,59 +575,6 @@ var Router = class {
     }
     throw error;
   }
-  /**
-   * Create a mutable request wrapper that allows URL modification
-   */
-  #createMutableRequest(request) {
-    return {
-      url: request.url,
-      method: request.method,
-      headers: new Headers(request.headers),
-      body: request.body,
-      bodyUsed: request.bodyUsed,
-      cache: request.cache,
-      credentials: request.credentials,
-      destination: request.destination,
-      integrity: request.integrity,
-      keepalive: request.keepalive,
-      mode: request.mode,
-      redirect: request.redirect,
-      referrer: request.referrer,
-      referrerPolicy: request.referrerPolicy,
-      signal: request.signal,
-      // Add all other Request methods
-      arrayBuffer: () => request.arrayBuffer(),
-      blob: () => request.blob(),
-      clone: () => request.clone(),
-      formData: () => request.formData(),
-      json: () => request.json(),
-      text: () => request.text()
-    };
-  }
-  /**
-   * Handle automatic redirects when URL is modified
-   */
-  #handleAutomaticRedirect(originalURL, newURL, method) {
-    const originalURLObj = new URL(originalURL);
-    const newURLObj = new URL(newURL);
-    if (originalURLObj.hostname !== newURLObj.hostname || originalURLObj.port !== newURLObj.port && originalURLObj.port !== "" && newURLObj.port !== "") {
-      throw new Error(
-        `Cross-origin redirect not allowed: ${originalURL} -> ${newURL}`
-      );
-    }
-    let status = 302;
-    if (originalURLObj.protocol !== newURLObj.protocol) {
-      status = 301;
-    } else if (method.toUpperCase() !== "GET") {
-      status = 307;
-    }
-    return new Response(null, {
-      status,
-      headers: {
-        Location: newURL
-      }
-    });
-  }
   /**
    * Get route statistics
    */
@@ -667,6 +595,28 @@ var Router = class {
     return httpError.toResponse(isDev);
   }
 };
+function trailingSlash(mode) {
+  return (request, _context) => {
+    const url = new URL(request.url);
+    const pathname = url.pathname;
+    if (pathname === "/")
+      return;
+    let newPathname = null;
+    if (mode === "strip" && pathname.endsWith("/")) {
+      newPathname = pathname.slice(0, -1);
+    } else if (mode === "add" && !pathname.endsWith("/")) {
+      newPathname = pathname + "/";
+    }
+    if (newPathname) {
+      url.pathname = newPathname;
+      return new Response(null, {
+        status: 301,
+        headers: { Location: url.toString() }
+      });
+    }
+  };
+}
 export {
-  Router
+  Router,
+  trailingSlash
 };