@b9g/router 0.1.5 → 0.1.6

package/src/router.d.ts

@@ -1,167 +0,0 @@
-import type { Handler, Middleware, RouteEntry, MiddlewareEntry, HttpMethod, RouterOptions, RouteConfig, RouteCacheConfig } from "./_types.js";
-/**
- * RouteBuilder provides a chainable API for defining routes with multiple HTTP methods
- *
- * Example:
- *   router.route('/api/users/:id')
- *     .get(getUserHandler)
- *     .put(updateUserHandler)
- *     .delete(deleteUserHandler);
- */
-declare class RouteBuilder {
-    private router;
-    private pattern;
-    private cacheConfig?;
-    constructor(router: Router, pattern: string, cacheConfig?: RouteCacheConfig);
-    /**
-     * Register a GET handler for this route pattern
-     */
-    get(handler: Handler): RouteBuilder;
-    /**
-     * Register a POST handler for this route pattern
-     */
-    post(handler: Handler): RouteBuilder;
-    /**
-     * Register a PUT handler for this route pattern
-     */
-    put(handler: Handler): RouteBuilder;
-    /**
-     * Register a DELETE handler for this route pattern
-     */
-    delete(handler: Handler): RouteBuilder;
-    /**
-     * Register a PATCH handler for this route pattern
-     */
-    patch(handler: Handler): RouteBuilder;
-    /**
-     * Register a HEAD handler for this route pattern
-     */
-    head(handler: Handler): RouteBuilder;
-    /**
-     * Register an OPTIONS handler for this route pattern
-     */
-    options(handler: Handler): RouteBuilder;
-    /**
-     * Register a handler for all HTTP methods on this route pattern
-     */
-    all(handler: Handler): RouteBuilder;
-}
-/**
- * Router provides Request/Response routing with middleware support
- * Designed to work universally across all JavaScript runtimes
- */
-export declare class Router {
-    private routes;
-    private middlewares;
-    private executor;
-    private dirty;
-    private caches?;
-    constructor(options?: RouterOptions);
-    /**
-     * Register middleware that applies to all routes
-     * Middleware executes in the order it was registered
-     */
-    use(middleware: Middleware): void;
-    /**
-     * Register a handler for a specific pattern
-     */
-    use(pattern: string, handler: Handler): void;
-    /**
-     * Create a route builder for the given pattern
-     * Returns a chainable interface for registering HTTP method handlers
-     *
-     * Example:
-     *   router.route('/api/users/:id')
-     *     .get(getUserHandler)
-     *     .put(updateUserHandler);
-     *
-     * With cache configuration:
-     *   router.route({ pattern: '/api/users/:id', cache: { name: 'users' } })
-     *     .get(getUserHandler);
-     */
-    route(pattern: string): RouteBuilder;
-    route(config: RouteConfig): RouteBuilder;
-    /**
-     * Internal method called by RouteBuilder to register routes
-     * Public for RouteBuilder access, but not intended for direct use
-     */
-    addRoute(method: HttpMethod, pattern: string, handler: Handler, cache?: RouteCacheConfig): void;
-    /**
-     * Handle a request - main entrypoint for ServiceWorker usage
-     * Returns a response or throws if no route matches
-     */
-    handler: (request: Request) => Promise<Response>;
-    /**
-     * 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
-     */
-    match(request: Request): Promise<Response | null>;
-    /**
-     * Build the complete route context including cache access
-     */
-    private buildContext;
-    /**
-     * Get registered routes for debugging/introspection
-     */
-    getRoutes(): RouteEntry[];
-    /**
-     * Get registered middleware for debugging/introspection
-     */
-    getMiddlewares(): MiddlewareEntry[];
-    /**
-     * 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: string, subrouter: Router): void;
-    /**
-     * Normalize mount path: ensure it starts with / and doesn't end with /
-     */
-    private normalizeMountPath;
-    /**
-     * Combine mount path with route pattern
-     */
-    private combinePaths;
-    /**
-     * Validate that a function is valid middleware
-     */
-    private isValidMiddleware;
-    /**
-     * Detect if a function is a generator middleware
-     */
-    private isGeneratorMiddleware;
-    /**
-     * Execute middleware stack with guaranteed execution using Rack-style LIFO order
-     */
-    private executeMiddlewareStack;
-    /**
-     * Handle errors by trying generators in reverse order
-     */
-    private handleErrorThroughGenerators;
-    /**
-     * Create a mutable request wrapper that allows URL modification
-     */
-    private createMutableRequest;
-    /**
-     * Handle automatic redirects when URL is modified
-     */
-    private handleAutomaticRedirect;
-    /**
-     * Get route statistics
-     */
-    getStats(): {
-        routeCount: number;
-        middlewareCount: number;
-        compiled: boolean;
-    };
-}
-export {};

package/src/router.js

@@ -1,504 +0,0 @@
-/// <reference types="./router.d.ts" />
-// src/router.ts
-import { MatchPattern } from "@b9g/match-pattern";
-var LinearExecutor = class {
-  constructor(routes) {
-    this.routes = routes;
-  }
-  /**
-   * Find the first route that matches the request
-   * Returns null if no route matches
-   */
-  match(request) {
-    const url = new URL(request.url);
-    const method = request.method.toUpperCase();
-    for (const route of this.routes) {
-      if (route.method !== method) {
-        continue;
-      }
-      if (route.pattern.test(url)) {
-        const result = route.pattern.exec(url);
-        if (result) {
-          return {
-            handler: route.handler,
-            context: {
-              params: result.params
-            },
-            cacheConfig: route.cache
-          };
-        }
-      }
-    }
-    return null;
-  }
-};
-var RouteBuilder = class {
-  constructor(router, pattern, cacheConfig) {
-    this.router = router;
-    this.pattern = pattern;
-    this.cacheConfig = cacheConfig;
-  }
-  /**
-   * Register a GET handler for this route pattern
-   */
-  get(handler) {
-    this.router.addRoute("GET", this.pattern, handler, this.cacheConfig);
-    return this;
-  }
-  /**
-   * Register a POST handler for this route pattern
-   */
-  post(handler) {
-    this.router.addRoute("POST", this.pattern, handler, this.cacheConfig);
-    return this;
-  }
-  /**
-   * Register a PUT handler for this route pattern
-   */
-  put(handler) {
-    this.router.addRoute("PUT", this.pattern, handler, this.cacheConfig);
-    return this;
-  }
-  /**
-   * Register a DELETE handler for this route pattern
-   */
-  delete(handler) {
-    this.router.addRoute("DELETE", this.pattern, handler, this.cacheConfig);
-    return this;
-  }
-  /**
-   * Register a PATCH handler for this route pattern
-   */
-  patch(handler) {
-    this.router.addRoute("PATCH", this.pattern, handler, this.cacheConfig);
-    return this;
-  }
-  /**
-   * Register a HEAD handler for this route pattern
-   */
-  head(handler) {
-    this.router.addRoute("HEAD", this.pattern, handler, this.cacheConfig);
-    return this;
-  }
-  /**
-   * Register an OPTIONS handler for this route pattern
-   */
-  options(handler) {
-    this.router.addRoute("OPTIONS", this.pattern, handler, this.cacheConfig);
-    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, this.cacheConfig);
-    });
-    return this;
-  }
-};
-var Router = class {
-  routes = [];
-  middlewares = [];
-  executor = null;
-  dirty = false;
-  caches;
-  constructor(options) {
-    this.caches = options?.caches;
-  }
-  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,
-        patternOrConfig.cache
-      );
-    }
-  }
-  /**
-   * Internal method called by RouteBuilder to register routes
-   * Public for RouteBuilder access, but not intended for direct use
-   */
-  addRoute(method, pattern, handler, cache) {
-    const matchPattern = new MatchPattern(pattern);
-    this.routes.push({
-      pattern: matchPattern,
-      method: method.toUpperCase(),
-      handler,
-      cache
-    });
-    this.dirty = true;
-  }
-  /**
-   * Handle a request - main entrypoint for ServiceWorker usage
-   * Returns a response or throws if no route matches
-   */
-  handler = async (request) => {
-    if (this.dirty || !this.executor) {
-      this.executor = new LinearExecutor(this.routes);
-      this.dirty = false;
-    }
-    const matchResult = this.executor.match(request);
-    if (matchResult) {
-      const context = await this.buildContext(
-        matchResult.context,
-        matchResult.cacheConfig
-      );
-      const mutableRequest = this.createMutableRequest(request);
-      return this.executeMiddlewareStack(
-        this.middlewares,
-        mutableRequest,
-        context,
-        matchResult.handler,
-        request.url,
-        this.executor
-      );
-    } else {
-      const notFoundHandler = async () => {
-        return new Response("Not Found", { status: 404 });
-      };
-      const mutableRequest = this.createMutableRequest(request);
-      return this.executeMiddlewareStack(
-        this.middlewares,
-        mutableRequest,
-        { params: {} },
-        notFoundHandler,
-        request.url,
-        this.executor
-      );
-    }
-  };
-  /**
-   * 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 LinearExecutor(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 = await this.buildContext(
-        matchResult.context,
-        matchResult.cacheConfig
-      );
-    } 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;
-  }
-  /**
-   * Build the complete route context including cache access
-   */
-  async buildContext(baseContext, cacheConfig) {
-    const context = { ...baseContext };
-    if (this.caches) {
-      context.caches = this.caches;
-      if (cacheConfig?.name) {
-        try {
-          context.cache = await this.caches.open(cacheConfig.name);
-        } catch (error) {
-          console.warn(`Failed to open cache '${cacheConfig.name}':`, error);
-        }
-      }
-    }
-    return context;
-  }
-  /**
-   * 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,
-        cache: subroute.cache
-      });
-    }
-    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 = await this.buildContext(
-            newMatchResult.context,
-            newMatchResult.cacheConfig || void 0
-          );
-        }
-      }
-      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 originalURL = new URL(originalUrl);
-    const newURL = new URL(newUrl);
-    if (originalURL.hostname !== newURL.hostname || originalURL.port !== newURL.port && originalURL.port !== "" && newURL.port !== "") {
-      throw new Error(
-        `Cross-origin redirect not allowed: ${originalUrl} -> ${newUrl}`
-      );
-    }
-    let status = 302;
-    if (originalURL.protocol !== newURL.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
-    };
-  }
-};
-export {
-  Router
-};