@b9g/router 0.1.5 → 0.1.6

package/src/index.js

@@ -1,6 +1,651 @@
 /// <reference types="./index.d.ts" />
 // src/index.ts
-import { Router } from "./router.js";
+import {
+  MatchPattern,
+  isSimplePattern,
+  compilePathname
+} from "@b9g/match-pattern";
+var RadixNode = class {
+  children;
+  // char -> RadixNode
+  handlers;
+  // method -> handler
+  paramName;
+  // param name if this is a :param segment
+  paramChild;
+  // child node for :param
+  wildcardChild;
+  // child node for * wildcard
+  constructor() {
+    this.children = /* @__PURE__ */ new Map();
+    this.handlers = /* @__PURE__ */ new Map();
+    this.paramName = null;
+    this.paramChild = null;
+    this.wildcardChild = null;
+  }
+};
+var RadixTreeExecutor = class {
+  #root;
+  #complexRoutes;
+  constructor(routes) {
+    this.#root = new RadixNode();
+    this.#complexRoutes = [];
+    for (const route of routes) {
+      const pathname = route.pattern.pathname;
+      if (isSimplePattern(pathname)) {
+        this.#addToTree(pathname, route.method, route.handler);
+      } else {
+        const compiled = compilePathname(pathname);
+        this.#complexRoutes.push({
+          compiled,
+          method: route.method,
+          handler: route.handler,
+          pattern: route.pattern
+        });
+      }
+    }
+  }
+  /**
+   * Add a simple pattern to the radix tree
+   */
+  #addToTree(pathname, method, handler) {
+    let node = this.#root;
+    let i = 0;
+    while (i < pathname.length) {
+      const char = pathname[i];
+      if (char === ":") {
+        const match = pathname.slice(i).match(/^:(\w+)/);
+        if (match) {
+          const paramName = match[1];
+          if (!node.paramChild) {
+            node.paramChild = new RadixNode();
+            node.paramChild.paramName = paramName;
+          }
+          node = node.paramChild;
+          i += match[0].length;
+          continue;
+        }
+      }
+      if (char === "*") {
+        if (!node.wildcardChild) {
+          node.wildcardChild = new RadixNode();
+        }
+        node = node.wildcardChild;
+        break;
+      }
+      if (!node.children.has(char)) {
+        node.children.set(char, new RadixNode());
+      }
+      node = node.children.get(char);
+      i++;
+    }
+    node.handlers.set(method, handler);
+  }
+  /**
+   * Match a pathname against the radix tree
+   */
+  #matchTree(pathname, method) {
+    const params = {};
+    let node = this.#root;
+    let i = 0;
+    while (i < pathname.length) {
+      const char = pathname[i];
+      if (node.children.has(char)) {
+        node = node.children.get(char);
+        i++;
+        continue;
+      }
+      if (node.paramChild) {
+        let j = i;
+        while (j < pathname.length && pathname[j] !== "/") {
+          j++;
+        }
+        const value = pathname.slice(i, j);
+        if (value) {
+          params[node.paramChild.paramName] = value;
+          node = node.paramChild;
+          i = j;
+          continue;
+        }
+      }
+      if (node.wildcardChild) {
+        const rest = pathname.slice(i);
+        params["0"] = rest;
+        node = node.wildcardChild;
+        break;
+      }
+      return null;
+    }
+    const handler = node.handlers.get(method);
+    if (handler) {
+      return { handler, params };
+    }
+    if (node.wildcardChild) {
+      const wildcardHandler = node.wildcardChild.handlers.get(method);
+      if (wildcardHandler) {
+        params["0"] = "";
+        return { handler: wildcardHandler, params };
+      }
+    }
+    return null;
+  }
+  /**
+   * Find the first route that matches the request
+   */
+  match(request) {
+    const url = new URL(request.url);
+    const method = request.method.toUpperCase();
+    const pathname = url.pathname;
+    const treeResult = this.#matchTree(pathname, method);
+    if (treeResult) {
+      return {
+        handler: treeResult.handler,
+        context: { params: treeResult.params }
+      };
+    }
+    for (const route of this.#complexRoutes) {
+      if (route.method !== method) {
+        continue;
+      }
+      const match = pathname.match(route.compiled.regex);
+      if (match) {
+        const params = {};
+        for (let i = 0; i < route.compiled.paramNames.length; i++) {
+          if (match[i + 1] !== void 0) {
+            params[route.compiled.paramNames[i]] = match[i + 1];
+          }
+        }
+        return {
+          handler: route.handler,
+          context: { params }
+        };
+      }
+    }
+    return null;
+  }
+};
+var RouteBuilder = class {
+  #router;
+  #pattern;
+  constructor(router, pattern) {
+    this.#router = router;
+    this.#pattern = pattern;
+  }
+  /**
+   * Register a GET handler for this route pattern
+   */
+  get(handler) {
+    this.#router.addRoute("GET", this.#pattern, handler);
+    return this;
+  }
+  /**
+   * Register a POST handler for this route pattern
+   */
+  post(handler) {
+    this.#router.addRoute("POST", this.#pattern, handler);
+    return this;
+  }
+  /**
+   * Register a PUT handler for this route pattern
+   */
+  put(handler) {
+    this.#router.addRoute("PUT", this.#pattern, handler);
+    return this;
+  }
+  /**
+   * Register a DELETE handler for this route pattern
+   */
+  delete(handler) {
+    this.#router.addRoute("DELETE", this.#pattern, handler);
+    return this;
+  }
+  /**
+   * Register a PATCH handler for this route pattern
+   */
+  patch(handler) {
+    this.#router.addRoute("PATCH", this.#pattern, handler);
+    return this;
+  }
+  /**
+   * Register a HEAD handler for this route pattern
+   */
+  head(handler) {
+    this.#router.addRoute("HEAD", this.#pattern, handler);
+    return this;
+  }
+  /**
+   * Register an OPTIONS handler for this route pattern
+   */
+  options(handler) {
+    this.#router.addRoute("OPTIONS", this.#pattern, handler);
+    return this;
+  }
+  /**
+   * Register a handler for all HTTP methods on this route pattern
+   */
+  all(handler) {
+    const methods = [
+      "GET",
+      "POST",
+      "PUT",
+      "DELETE",
+      "PATCH",
+      "HEAD",
+      "OPTIONS"
+    ];
+    methods.forEach((method) => {
+      this.#router.addRoute(method, this.#pattern, handler);
+    });
+    return this;
+  }
+};
+var Router = class {
+  #routes;
+  #middlewares;
+  #executor;
+  #dirty;
+  constructor() {
+    this.#routes = [];
+    this.#middlewares = [];
+    this.#executor = null;
+    this.#dirty = false;
+    this.#handlerImpl = async (request) => {
+      try {
+        if (this.#dirty || !this.#executor) {
+          this.#executor = new RadixTreeExecutor(this.#routes);
+          this.#dirty = false;
+        }
+        const matchResult = this.#executor.match(request);
+        if (matchResult) {
+          const mutableRequest = this.#createMutableRequest(request);
+          return await this.#executeMiddlewareStack(
+            this.#middlewares,
+            mutableRequest,
+            matchResult.context,
+            matchResult.handler,
+            request.url,
+            this.#executor
+          );
+        } else {
+          const notFoundHandler = async () => {
+            return new Response("Not Found", { status: 404 });
+          };
+          const mutableRequest = this.#createMutableRequest(request);
+          return await this.#executeMiddlewareStack(
+            this.#middlewares,
+            mutableRequest,
+            { params: {} },
+            notFoundHandler,
+            request.url,
+            this.#executor
+          );
+        }
+      } catch (error) {
+        return this.#createErrorResponse(error);
+      }
+    };
+    this.handler = this.#handlerImpl;
+  }
+  use(patternOrMiddleware, handler) {
+    if (typeof patternOrMiddleware === "string" && handler) {
+      this.addRoute("GET", patternOrMiddleware, handler);
+      this.addRoute("POST", patternOrMiddleware, handler);
+      this.addRoute("PUT", patternOrMiddleware, handler);
+      this.addRoute("DELETE", patternOrMiddleware, handler);
+      this.addRoute("PATCH", patternOrMiddleware, handler);
+      this.addRoute("HEAD", patternOrMiddleware, handler);
+      this.addRoute("OPTIONS", patternOrMiddleware, handler);
+    } else if (typeof patternOrMiddleware === "function") {
+      if (!this.#isValidMiddleware(patternOrMiddleware)) {
+        throw new Error(
+          "Invalid middleware type. Must be function or async generator function."
+        );
+      }
+      this.#middlewares.push({ middleware: patternOrMiddleware });
+      this.#dirty = true;
+    } else {
+      throw new Error(
+        "Invalid middleware type. Must be function or async generator function."
+      );
+    }
+  }
+  route(patternOrConfig) {
+    if (typeof patternOrConfig === "string") {
+      return new RouteBuilder(this, patternOrConfig);
+    } else {
+      return new RouteBuilder(this, patternOrConfig.pattern);
+    }
+  }
+  /**
+   * Internal method called by RouteBuilder to register routes
+   * Public for RouteBuilder access, but not intended for direct use
+   */
+  addRoute(method, pattern, handler) {
+    const matchPattern = new MatchPattern(pattern);
+    this.#routes.push({
+      pattern: matchPattern,
+      method: method.toUpperCase(),
+      handler
+    });
+    this.#dirty = true;
+  }
+  /**
+   * Handle a request - main entrypoint for ServiceWorker usage
+   * Returns a response or throws if no route matches
+   */
+  handler;
+  #handlerImpl;
+  /**
+   * Match a request against registered routes and execute the handler chain
+   * Returns the response from the matched handler, or null if no route matches
+   * Note: Global middleware executes even if no route matches
+   */
+  async match(request) {
+    if (this.#dirty || !this.#executor) {
+      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;
+    if (matchResult) {
+      handler = matchResult.handler;
+      context = matchResult.context;
+    } else {
+      handler = async () => new Response("Not Found", { status: 404 });
+      context = { params: {} };
+    }
+    const response = await this.#executeMiddlewareStack(
+      this.#middlewares,
+      mutableRequest,
+      context,
+      handler,
+      originalURL,
+      this.#executor
+      // Pass executor for re-routing
+    );
+    if (!matchResult && response?.status === 404) {
+      return null;
+    }
+    return response;
+  }
+  /**
+   * Get registered routes for debugging/introspection
+   */
+  getRoutes() {
+    return [...this.#routes];
+  }
+  /**
+   * Get registered middleware for debugging/introspection
+   */
+  getMiddlewares() {
+    return [...this.#middlewares];
+  }
+  /**
+   * Mount a subrouter at a specific path prefix
+   * All routes from the subrouter will be prefixed with the mount path
+   *
+   * Example:
+   *   const apiRouter = new Router();
+   *   apiRouter.route('/users').get(getUsersHandler);
+   *   apiRouter.route('/users/:id').get(getUserHandler);
+   *
+   *   const mainRouter = new Router();
+   *   mainRouter.mount('/api/v1', apiRouter);
+   *   // Routes become: /api/v1/users, /api/v1/users/:id
+   */
+  mount(mountPath, subrouter) {
+    const normalizedMountPath = this.#normalizeMountPath(mountPath);
+    const subroutes = subrouter.getRoutes();
+    for (const subroute of subroutes) {
+      const mountedPattern = this.#combinePaths(
+        normalizedMountPath,
+        subroute.pattern.pathname
+      );
+      this.#routes.push({
+        pattern: new MatchPattern(mountedPattern),
+        method: subroute.method,
+        handler: subroute.handler
+      });
+    }
+    const submiddlewares = subrouter.getMiddlewares();
+    for (const submiddleware of submiddlewares) {
+      this.#middlewares.push(submiddleware);
+    }
+    this.#dirty = true;
+  }
+  /**
+   * Normalize mount path: ensure it starts with / and doesn't end with /
+   */
+  #normalizeMountPath(mountPath) {
+    if (!mountPath.startsWith("/")) {
+      mountPath = "/" + mountPath;
+    }
+    if (mountPath.endsWith("/") && mountPath.length > 1) {
+      mountPath = mountPath.slice(0, -1);
+    }
+    return mountPath;
+  }
+  /**
+   * Combine mount path with route pattern
+   */
+  #combinePaths(mountPath, routePattern) {
+    if (routePattern === "/") {
+      return mountPath;
+    }
+    if (!routePattern.startsWith("/")) {
+      routePattern = "/" + routePattern;
+    }
+    return mountPath + routePattern;
+  }
+  /**
+   * Validate that a function is valid middleware
+   */
+  #isValidMiddleware(middleware) {
+    const constructorName = middleware.constructor.name;
+    return constructorName === "AsyncGeneratorFunction" || constructorName === "AsyncFunction" || constructorName === "Function";
+  }
+  /**
+   * Detect if a function is a generator middleware
+   */
+  #isGeneratorMiddleware(middleware) {
+    return middleware.constructor.name === "AsyncGeneratorFunction";
+  }
+  /**
+   * Execute middleware stack with guaranteed execution using Rack-style LIFO order
+   */
+  async #executeMiddlewareStack(middlewares, request, context, handler, originalURL, executor) {
+    const runningGenerators = [];
+    let currentResponse = null;
+    for (let i = 0; i < middlewares.length; i++) {
+      const middleware = middlewares[i].middleware;
+      if (this.#isGeneratorMiddleware(middleware)) {
+        const generator = middleware(request, context);
+        const result = await generator.next();
+        if (result.done) {
+          if (result.value) {
+            currentResponse = result.value;
+            break;
+          }
+        } else {
+          runningGenerators.push({ generator, index: i });
+        }
+      } else {
+        const result = await middleware(
+          request,
+          context
+        );
+        if (result) {
+          currentResponse = result;
+          break;
+        }
+      }
+    }
+    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);
+      } catch (error) {
+        handlerError = error;
+      }
+      if (handlerError) {
+        currentResponse = await this.#handleErrorThroughGenerators(
+          handlerError,
+          runningGenerators
+        );
+      }
+    }
+    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);
+      if (result.value) {
+        currentResponse = result.value;
+      }
+    }
+    return currentResponse;
+  }
+  /**
+   * Handle errors by trying generators in reverse order
+   */
+  async #handleErrorThroughGenerators(error, runningGenerators) {
+    for (let i = runningGenerators.length - 1; i >= 0; i--) {
+      const { generator } = runningGenerators[i];
+      try {
+        const result = await generator.throw(error);
+        if (result.value) {
+          runningGenerators.splice(i, 1);
+          return result.value;
+        }
+      } catch (generatorError) {
+        runningGenerators.splice(i, 1);
+        continue;
+      }
+    }
+    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
+   */
+  getStats() {
+    return {
+      routeCount: this.#routes.length,
+      middlewareCount: this.#middlewares.length,
+      compiled: !this.#dirty && this.#executor !== null
+    };
+  }
+  /**
+   * Create an error response for unhandled errors
+   * In development mode, includes error details; in production, returns generic message
+   */
+  #createErrorResponse(error) {
+    const isDev = typeof import.meta !== "undefined" && import.meta.env?.MODE !== "production";
+    if (isDev) {
+      const html = `<!DOCTYPE html>
+<html>
+<head>
+  <title>500 Internal Server Error</title>
+  <style>
+    body { font-family: system-ui, sans-serif; padding: 2rem; max-width: 800px; margin: 0 auto; }
+    h1 { color: #dc2626; }
+    pre { background: #1e1e1e; color: #d4d4d4; padding: 1rem; overflow-x: auto; border-radius: 4px; }
+    .message { font-size: 1.25rem; color: #374151; }
+  </style>
+</head>
+<body>
+  <h1>500 Internal Server Error</h1>
+  <p class="message">${escapeHtml(error.message)}</p>
+  <pre>${escapeHtml(error.stack || "No stack trace available")}</pre>
+</body>
+</html>`;
+      return new Response(html, {
+        status: 500,
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    } else {
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  }
+};
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
 export {
   Router
 };