azurajs 3.0.1 → 3.0.2

package/src/core/router.ts

@@ -0,0 +1,284 @@
+import type { HttpMethod, RouteHandler, MiddlewareHandler, RouteMatch } from "../types/common.type.js";
+
+const PARAM_PREFIX = 58; // ':'
+
+interface RadixNode {
+  segment: string;
+  children: Map<string, RadixNode>;
+  paramChild: RadixNode | null;
+  paramName: string;
+  handlers: Map<HttpMethod, StoredRoute>;
+  wildcardHandler: Map<HttpMethod, StoredRoute> | null;
+}
+
+interface StoredRoute {
+  handler: RouteHandler;
+  middlewares: MiddlewareHandler[];
+  meta?: Record<string, any>;
+}
+
+function createNode(segment: string = ""): RadixNode {
+  return {
+    segment,
+    children: new Map(),
+    paramChild: null,
+    paramName: "",
+    handlers: new Map(),
+    wildcardHandler: null,
+  };
+}
+
+/**
+ * LRU Cache with O(1) get/set via doubly linked list + hash map.
+ * Used for route lookup caching in hot paths.
+ */
+class LRUCache<K, V> {
+  private capacity: number;
+  private map: Map<K, { value: V; key: K; prev: any; next: any }>;
+  private head: any;
+  private tail: any;
+
+  constructor(capacity: number) {
+    this.capacity = capacity;
+    this.map = new Map();
+    this.head = { prev: null, next: null };
+    this.tail = { prev: null, next: null };
+    this.head.next = this.tail;
+    this.tail.prev = this.head;
+  }
+
+  get(key: K): V | undefined {
+    const node = this.map.get(key);
+    if (!node) return undefined;
+    this.moveToHead(node);
+    return node.value;
+  }
+
+  set(key: K, value: V): void {
+    const existing = this.map.get(key);
+    if (existing) {
+      existing.value = value;
+      this.moveToHead(existing);
+      return;
+    }
+
+    const node = { value, key, prev: null as any, next: null as any };
+    this.map.set(key, node);
+    this.addToHead(node);
+
+    if (this.map.size > this.capacity) {
+      const removed = this.removeTail();
+      if (removed) this.map.delete(removed.key);
+    }
+  }
+
+  private addToHead(node: any): void {
+    node.prev = this.head;
+    node.next = this.head.next;
+    this.head.next.prev = node;
+    this.head.next = node;
+  }
+
+  private removeNode(node: any): void {
+    node.prev.next = node.next;
+    node.next.prev = node.prev;
+  }
+
+  private moveToHead(node: any): void {
+    this.removeNode(node);
+    this.addToHead(node);
+  }
+
+  private removeTail(): any {
+    const node = this.tail.prev;
+    if (node === this.head) return null;
+    this.removeNode(node);
+    return node;
+  }
+
+  clear(): void {
+    this.map.clear();
+    this.head.next = this.tail;
+    this.tail.prev = this.head;
+  }
+}
+
+export class Router {
+  private root: RadixNode = createNode();
+  private cache: LRUCache<string, RouteMatch | null>;
+  private staticRoutes: Map<string, StoredRoute> = new Map();
+
+  constructor(cacheSize: number = 1024) {
+    this.cache = new LRUCache(cacheSize);
+  }
+
+  add(
+    method: HttpMethod,
+    path: string,
+    handler: RouteHandler,
+    middlewares: MiddlewareHandler[] = [],
+    meta?: Record<string, any>,
+  ): void {
+    this.cache.clear();
+    const normalizedPath = this.normalizePath(path);
+    const stored: StoredRoute = { handler, middlewares, meta };
+
+    if (!normalizedPath.includes(":") && !normalizedPath.includes("*")) {
+      const key = `${method}:${normalizedPath}`;
+      this.staticRoutes.set(key, stored);
+      return;
+    }
+
+    const segments = normalizedPath.split("/").filter(Boolean);
+    let node = this.root;
+
+    for (let i = 0; i < segments.length; i++) {
+      const seg = segments[i];
+
+      if (seg === "*") {
+        if (!node.wildcardHandler) {
+          node.wildcardHandler = new Map();
+        }
+        node.wildcardHandler.set(method, stored);
+        return;
+      }
+
+      if (seg.charCodeAt(0) === PARAM_PREFIX) {
+        if (!node.paramChild) {
+          node.paramChild = createNode(seg);
+          node.paramChild.paramName = seg.slice(1);
+        }
+        node = node.paramChild;
+        continue;
+      }
+
+      let child = node.children.get(seg);
+      if (!child) {
+        child = createNode(seg);
+        node.children.set(seg, child);
+      }
+      node = child;
+    }
+
+    node.handlers.set(method, stored);
+  }
+
+  find(method: HttpMethod, path: string): RouteMatch | null {
+    const normalizedPath = this.normalizePath(path);
+
+    const staticKey = `${method}:${normalizedPath}`;
+    const staticRoute = this.staticRoutes.get(staticKey);
+    if (staticRoute) {
+      return {
+        handler: staticRoute.handler,
+        params: {},
+        middlewares: staticRoute.middlewares,
+        meta: staticRoute.meta,
+      };
+    }
+
+    const cacheKey = staticKey;
+    const cached = this.cache.get(cacheKey);
+    if (cached !== undefined) {
+      return cached ? { ...cached, params: { ...cached.params } } : null;
+    }
+
+    const segments = normalizedPath.split("/").filter(Boolean);
+    const params: Record<string, string> = {};
+    const result = this.matchNode(this.root, segments, 0, params, method);
+
+    if (result) {
+      const match: RouteMatch = {
+        handler: result.handler,
+        params,
+        middlewares: result.middlewares,
+        meta: result.meta,
+      };
+      this.cache.set(cacheKey, match);
+      return { ...match, params: { ...params } };
+    }
+
+    this.cache.set(cacheKey, null);
+    return null;
+  }
+
+  private matchNode(
+    node: RadixNode,
+    segments: string[],
+    idx: number,
+    params: Record<string, string>,
+    method: HttpMethod,
+  ): StoredRoute | null {
+    if (idx === segments.length) {
+      return node.handlers.get(method) ?? null;
+    }
+
+    const seg = segments[idx];
+
+    const child = node.children.get(seg);
+    if (child) {
+      const result = this.matchNode(child, segments, idx + 1, params, method);
+      if (result) return result;
+    }
+
+    if (node.paramChild) {
+      params[node.paramChild.paramName] = seg;
+      const result = this.matchNode(node.paramChild, segments, idx + 1, params, method);
+      if (result) return result;
+      delete params[node.paramChild.paramName];
+    }
+
+    if (node.wildcardHandler) {
+      const route = node.wildcardHandler.get(method);
+      if (route) return route;
+    }
+
+    return null;
+  }
+
+  private normalizePath(path: string): string {
+    if (path === "/") return "/";
+    if (path.endsWith("/") && path.length > 1) return path.slice(0, -1);
+    return path;
+  }
+
+  getAllRoutes(): Array<{ method: HttpMethod; path: string }> {
+    const routes: Array<{ method: HttpMethod; path: string }> = [];
+
+    for (const [key] of this.staticRoutes) {
+      const [method, path] = key.split(":", 2) as [HttpMethod, string];
+      routes.push({ method, path });
+    }
+
+    this.collectRoutes(this.root, "", routes);
+    return routes;
+  }
+
+  private collectRoutes(
+    node: RadixNode,
+    prefix: string,
+    routes: Array<{ method: HttpMethod; path: string }>,
+  ): void {
+    for (const [method] of node.handlers) {
+      routes.push({ method, path: prefix || "/" });
+    }
+
+    for (const [seg, child] of node.children) {
+      this.collectRoutes(child, `${prefix}/${seg}`, routes);
+    }
+
+    if (node.paramChild) {
+      this.collectRoutes(
+        node.paramChild,
+        `${prefix}/:${node.paramChild.paramName}`,
+        routes,
+      );
+    }
+
+    if (node.wildcardHandler) {
+      for (const [method] of node.wildcardHandler) {
+        routes.push({ method, path: `${prefix}/*` });
+      }
+    }
+  }
+}