@b9g/router 0.1.5 → 0.1.7

package/src/index.js

@@ -1,6 +1,672 @@
 /// <reference types="./index.d.ts" />
 // src/index.ts
-import { Router } from "./router.js";
+import {
+  MatchPattern,
+  isSimplePattern,
+  compilePathname
+} from "@b9g/match-pattern";
+import { InternalServerError, isHTTPError } from "@b9g/http-errors";
+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;
+    }
+    let handler = node.handlers.get(method);
+    if (!handler && method === "HEAD") {
+      handler = node.handlers.get("GET");
+    }
+    if (handler) {
+      return { handler, params };
+    }
+    if (node.wildcardChild) {
+      let wildcardHandler = node.wildcardChild.handlers.get(method);
+      if (!wildcardHandler && method === "HEAD") {
+        wildcardHandler = node.wildcardChild.handlers.get("GET");
+      }
+      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) {
+      const methodMatches = route.method === method || method === "HEAD" && route.method === "GET";
+      if (!methodMatches) {
+        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(pathPrefixOrMiddleware, maybeMiddleware) {
+    if (typeof pathPrefixOrMiddleware === "string") {
+      const middleware = maybeMiddleware;
+      if (!this.#isValidMiddleware(middleware)) {
+        throw new Error(
+          "Invalid middleware type. Must be function or async generator function."
+        );
+      }
+      this.#middlewares.push({
+        middleware,
+        pathPrefix: pathPrefixOrMiddleware
+      });
+    } else {
+      if (!this.#isValidMiddleware(pathPrefixOrMiddleware)) {
+        throw new Error(
+          "Invalid middleware type. Must be function or async generator function."
+        );
+      }
+      this.#middlewares.push({ middleware: pathPrefixOrMiddleware });
+    }
+    this.#dirty = true;
+  }
+  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: {} };
+    }
+    let response = await this.#executeMiddlewareStack(
+      this.#middlewares,
+      mutableRequest,
+      context,
+      handler,
+      originalURL,
+      this.#executor
+      // Pass executor for re-routing
+    );
+    if (!matchResult && response?.status === 404) {
+      return null;
+    }
+    if (response && request.method.toUpperCase() === "HEAD") {
+      response = new Response(null, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    }
+    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) {
+      let composedPrefix;
+      if (submiddleware.pathPrefix) {
+        composedPrefix = this.#combinePaths(
+          normalizedMountPath,
+          submiddleware.pathPrefix
+        );
+      } else {
+        composedPrefix = normalizedMountPath;
+      }
+      this.#middlewares.push({
+        middleware: submiddleware.middleware,
+        pathPrefix: composedPrefix
+      });
+    }
+    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 === "GeneratorFunction" || constructorName === "AsyncFunction" || constructorName === "Function";
+  }
+  /**
+   * Detect if a function is a generator middleware
+   */
+  #isGeneratorMiddleware(middleware) {
+    const name = middleware.constructor.name;
+    return name === "GeneratorFunction" || name === "AsyncGeneratorFunction";
+  }
+  /**
+   * Check if a request pathname matches a middleware's path prefix
+   * Matches on segment boundaries: /admin matches /admin, /admin/, /admin/users
+   * but NOT /administrator
+   */
+  #matchesPathPrefix(pathname, pathPrefix) {
+    if (pathname === pathPrefix) {
+      return true;
+    }
+    if (pathname.startsWith(pathPrefix)) {
+      const nextChar = pathname[pathPrefix.length];
+      return nextChar === "/" || nextChar === void 0;
+    }
+    return false;
+  }
+  /**
+   * Execute middleware stack with guaranteed execution using Rack-style LIFO order
+   */
+  async #executeMiddlewareStack(middlewares, request, context, handler, originalURL, executor) {
+    const runningGenerators = [];
+    let currentResponse = null;
+    const requestPathname = new URL(request.url).pathname;
+    for (let i = 0; i < middlewares.length; i++) {
+      const entry = middlewares[i];
+      const middleware = entry.middleware;
+      if (entry.pathPrefix && !this.#matchesPathPrefix(requestPathname, entry.pathPrefix)) {
+        continue;
+      }
+      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 && result.done) {
+        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.done && 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
+   * Uses HTTPError.toResponse() for consistent error formatting
+   */
+  #createErrorResponse(error) {
+    const httpError = isHTTPError(error) ? error : new InternalServerError(error.message, { cause: error });
+    const isDev = import.meta.env?.MODE !== "production";
+    return httpError.toResponse(isDev);
+  }
+};
 export {
   Router
 };