vafast 0.3.2 → 0.3.4

package/dist/server/server.js

@@ -1,122 +1,563 @@
-/**
- * Vafast 核心服务器
- *
- * 基于 Radix Tree 的高性能路由匹配
- * 时间复杂度: O(k)，k 为路径段数
- */
-import { flattenNestedRoutes } from "../router";
-import { composeMiddleware } from "../middleware";
-import { json } from "../utils/response";
-import { BaseServer } from "./base-server";
-import { RadixRouter } from "../router/radix-tree";
-/**
- * Vafast 服务器
- *
- * @example
- * ```typescript
- * const server = new Server([
- *   { method: "GET", path: "/", handler: () => new Response("Hello") },
- * ]);
- * export default { fetch: server.fetch };
- * ```
- */
-export class Server extends BaseServer {
-    router;
-    routes;
-    /** 是否已预编译 */
-    isCompiled = false;
-    /** 预编译时的全局中间件数量 */
-    compiledWithMiddlewareCount = 0;
-    constructor(routes = []) {
-        super();
-        this.router = new RadixRouter();
-        this.routes = [];
-        // 设置中间件编译器
-        this.router.setCompiler((middleware, handler) => composeMiddleware(middleware, handler));
-        if (routes.length > 0) {
-            this.registerRoutes(routes);
-        }
+// src/router.ts
+function flattenNestedRoutes(routes) {
+  const flattened = [];
+  function processRoute(route, parentPath = "", parentMiddleware = []) {
+    const currentPath = normalizePath(parentPath + route.path);
+    const currentMiddleware = [
+      ...parentMiddleware,
+      ...route.middleware || []
+    ];
+    if ("method" in route && "handler" in route) {
+      flattened.push({
+        ...route,
+        fullPath: currentPath,
+        middlewareChain: currentMiddleware
+      });
+    } else if ("children" in route && route.children) {
+      for (const child of route.children) {
+        processRoute(child, currentPath, currentMiddleware);
+      }
+    }
+  }
+  for (const route of routes) {
+    processRoute(route);
+  }
+  return flattened;
+}
+function normalizePath(path) {
+  let normalized = decodeURIComponent(path);
+  normalized = normalized.replace(/\/+/g, "/");
+  if (normalized === "") return "/";
+  if (normalized !== "/" && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+
+// src/utils/response.ts
+function json(data, status = 200, headers = {}) {
+  const body = JSON.stringify(data);
+  if (Object.keys(headers).length === 0) {
+    return new Response(body, {
+      status,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  const h = new Headers({
+    "Content-Type": "application/json",
+    ...headers
+  });
+  return new Response(body, {
+    status,
+    headers: h
+  });
+}
+var JSON_HEADERS = { "Content-Type": "application/json" };
+var TEXT_HEADERS = { "Content-Type": "text/plain" };
+function mapResponse(response) {
+  if (response instanceof Response) return response;
+  switch (response?.constructor?.name) {
+    case "String":
+      return new Response(response, { headers: TEXT_HEADERS });
+    case "Object":
+    case "Array":
+      return new Response(JSON.stringify(response), { headers: JSON_HEADERS });
+    case "Number":
+    case "Boolean":
+      return new Response(String(response), { headers: TEXT_HEADERS });
+    case void 0:
+      return new Response(null, { status: 204 });
+    case "ReadableStream":
+      return new Response(response);
+    case "Blob":
+      return new Response(response);
+    case "ArrayBuffer":
+      return new Response(response);
+    case "Uint8Array":
+      return new Response(response);
+    default:
+      if (response instanceof Promise) {
+        return response.then(mapResponse);
+      }
+      return new Response(JSON.stringify(response), { headers: JSON_HEADERS });
+  }
+}
+
+// src/middleware.ts
+var VafastError = class extends Error {
+  status;
+  type;
+  expose;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "VafastError";
+    this.status = options.status ?? 500;
+    this.type = options.type ?? "internal_error";
+    this.expose = options.expose ?? false;
+    if (options.cause) this.cause = options.cause;
+  }
+};
+function composeMiddleware(middleware, finalHandler) {
+  const all = [errorHandler, ...middleware];
+  return function composedHandler(req) {
+    let i = -1;
+    const dispatch = (index) => {
+      if (index <= i)
+        return Promise.reject(new Error("next() called multiple times"));
+      i = index;
+      if (index < all.length) {
+        const mw = all[index];
+        return Promise.resolve(mw(req, () => dispatch(index + 1)));
+      }
+      return Promise.resolve(finalHandler(req)).then(mapResponse);
+    };
+    return dispatch(0);
+  };
+}
+var errorHandler = async (req, next) => {
+  try {
+    return await next();
+  } catch (err) {
+    console.error("\u672A\u5904\u7406\u7684\u9519\u8BEF:", err);
+    if (err instanceof VafastError) {
+      return json(
+        {
+          error: err.type,
+          message: err.expose ? err.message : "\u53D1\u751F\u4E86\u4E00\u4E2A\u9519\u8BEF"
+        },
+        err.status
+      );
+    }
+    return json({ error: "internal_error", message: "\u51FA\u73B0\u4E86\u4E00\u4E9B\u95EE\u9898" }, 500);
+  }
+};
+
+// src/server/base-server.ts
+var BaseServer = class {
+  globalMiddleware = [];
+  use(mw) {
+    this.globalMiddleware.push(mw);
+  }
+  /**
+   * 打印扁平化后的路由信息，用于调试
+   */
+  logFlattenedRoutes(routes, type = "\u8DEF\u7531") {
+    console.log(`\u{1F680} \u6241\u5E73\u5316\u540E\u7684${type}:`);
+    for (const route of routes) {
+      const method = route.method || "GET";
+      const path = route.fullPath || route.path;
+      console.log(`  ${method} ${path}`);
+      if (route.middlewareChain && route.middlewareChain.length > 0) {
+        console.log(`    \u4E2D\u95F4\u4EF6\u94FE: ${route.middlewareChain.length} \u4E2A`);
+      }
+    }
+    console.log("");
+  }
+  /**
+   * 检测路由冲突
+   * 检查是否有路径相同但方法不同的路由，以及潜在的路径冲突
+   */
+  detectRouteConflicts(routes) {
+    const pathGroups = /* @__PURE__ */ new Map();
+    for (const route of routes) {
+      const path = route.fullPath || route.path;
+      const method = route.method || "GET";
+      if (!pathGroups.has(path)) {
+        pathGroups.set(path, []);
+      }
+      pathGroups.get(path).push({ ...route, method });
     }
-    /**
-     * 预编译所有路由处理链
-     * 在添加所有路由和全局中间件后调用，可提升运行时性能
-     */
-    compile() {
-        this.router.precompileAll(this.globalMiddleware);
-        this.isCompiled = true;
-        this.compiledWithMiddlewareCount = this.globalMiddleware.length;
-        return this;
-    }
-    registerRoutes(routes) {
-        const flattened = flattenNestedRoutes(routes);
-        this.routes.push(...flattened);
-        for (const route of flattened) {
-            this.router.register(route.method, route.fullPath, route.handler, route.middlewareChain || []);
+    for (const [path, routeList] of pathGroups) {
+      if (routeList.length > 1) {
+        const methods = routeList.map((r) => r.method);
+        const uniqueMethods = [...new Set(methods)];
+        if (uniqueMethods.length === 1) {
+          console.warn(
+            `\u26A0\uFE0F  \u8DEF\u7531\u51B2\u7A81: ${uniqueMethods[0]} ${path} \u5B9A\u4E49\u4E86 ${routeList.length} \u6B21`
+          );
+          routeList.forEach((route, index) => {
+            console.warn(`   ${index + 1}. ${route.method} ${path}`);
+          });
+        } else {
+          console.log(`\u2139\uFE0F  \u8DEF\u5F84 ${path} \u652F\u6301\u65B9\u6CD5: ${uniqueMethods.join(", ")}`);
         }
-        this.detectRouteConflicts(flattened);
-        this.logFlattenedRoutes(flattened);
-        // 自动预编译（如果没有全局中间件）
-        if (this.globalMiddleware.length === 0 && !this.isCompiled) {
-            this.compile();
+      }
+    }
+    this.detectDynamicRouteConflicts(routes);
+  }
+  /**
+   * 检测动态路由的潜在冲突
+   */
+  detectDynamicRouteConflicts(routes) {
+    const dynamicRoutes = routes.filter((r) => {
+      const path = r.fullPath || r.path;
+      return path.includes(":") || path.includes("*");
+    });
+    for (let i = 0; i < dynamicRoutes.length; i++) {
+      for (let j = i + 1; j < dynamicRoutes.length; j++) {
+        const route1 = dynamicRoutes[i];
+        const route2 = dynamicRoutes[j];
+        const method1 = route1.method || "GET";
+        const method2 = route2.method || "GET";
+        if (method1 === method2) {
+          const path1 = route1.fullPath || route1.path;
+          const path2 = route2.fullPath || route2.path;
+          if (this.pathsMayConflict(path1, path2)) {
+            console.warn(
+              `\u26A0\uFE0F  \u6F5C\u5728\u8DEF\u7531\u51B2\u7A81: ${method1} ${path1} \u53EF\u80FD\u4E0E ${path2} \u51B2\u7A81`
+            );
+          }
         }
+      }
+    }
+  }
+  /**
+   * 判断两个路径是否可能冲突
+   */
+  pathsMayConflict(path1, path2) {
+    const parts1 = path1.split("/").filter(Boolean);
+    const parts2 = path2.split("/").filter(Boolean);
+    if (parts1.length !== parts2.length) return false;
+    for (let i = 0; i < parts1.length; i++) {
+      const p1 = parts1[i];
+      const p2 = parts2[i];
+      if (!p1.startsWith(":") && !p1.startsWith("*") && !p2.startsWith(":") && !p2.startsWith("*") && p1 !== p2) {
+        return false;
+      }
+      if (p1 === "*" && p2.startsWith(":") || p2 === "*" && p1.startsWith(":")) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * 路径匹配
+   */
+  matchPath(pattern, path) {
+    const patternParts = pattern.split("/").filter(Boolean);
+    const pathParts = path.split("/").filter(Boolean);
+    if (patternParts.length !== pathParts.length) {
+      return false;
+    }
+    for (let i = 0; i < patternParts.length; i++) {
+      if (patternParts[i] !== pathParts[i] && !patternParts[i].startsWith(":")) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * 提取路径参数
+   */
+  extractParams(pattern, path) {
+    const params = {};
+    const patternParts = pattern.split("/").filter(Boolean);
+    const pathParts = path.split("/").filter(Boolean);
+    for (let i = 0; i < patternParts.length; i++) {
+      if (patternParts[i].startsWith(":")) {
+        const paramName = patternParts[i].slice(1);
+        params[paramName] = pathParts[i];
+      }
     }
-    /** 快速提取 pathname */
-    extractPathname(url) {
-        let start = url.indexOf("://");
-        start = start === -1 ? 0 : start + 3;
-        const pathStart = url.indexOf("/", start);
-        if (pathStart === -1)
-            return "/";
-        let end = url.indexOf("?", pathStart);
-        if (end === -1)
-            end = url.indexOf("#", pathStart);
-        if (end === -1)
-            end = url.length;
-        return url.substring(pathStart, end) || "/";
-    }
-    /** 处理请求 */
-    fetch = async (req) => {
-        const pathname = this.extractPathname(req.url);
-        const method = req.method;
-        const match = this.router.match(method, pathname);
-        if (match) {
-            req.params = match.params;
-            // 优先使用预编译的处理链（仅当全局中间件未变化时）
-            if (match.compiled &&
-                this.globalMiddleware.length === this.compiledWithMiddlewareCount) {
-                return match.compiled(req);
-            }
-            // 回退：运行时组合中间件
-            const allMiddleware = [...this.globalMiddleware, ...match.middleware];
-            const handler = composeMiddleware(allMiddleware, match.handler);
-            return handler(req);
+    return params;
+  }
+};
+
+// src/router/radix-tree.ts
+var RadixRouter = class {
+  root;
+  constructor() {
+    this.root = this.createNode("");
+  }
+  createNode(path) {
+    return {
+      path,
+      children: /* @__PURE__ */ Object.create(null),
+      handlers: /* @__PURE__ */ Object.create(null)
+    };
+  }
+  /** 分割路径 */
+  splitPath(path) {
+    return path.split("/").filter(Boolean);
+  }
+  /** 编译器函数 - 用于预编译中间件链 */
+  compiler;
+  /** 设置中间件编译器 */
+  setCompiler(compiler) {
+    this.compiler = compiler;
+  }
+  /** 注册路由 */
+  register(method, pattern, handler, middleware = []) {
+    const segments = this.splitPath(pattern);
+    let node = this.root;
+    for (const segment of segments) {
+      const firstChar = segment[0];
+      if (firstChar === ":") {
+        if (!node.paramChild) {
+          node.paramChild = this.createNode(segment);
+          node.paramChild.paramName = segment.substring(1);
+        }
+        node = node.paramChild;
+      } else if (firstChar === "*") {
+        if (!node.wildcardChild) {
+          node.wildcardChild = this.createNode(segment);
+          node.wildcardChild.paramName = segment.length > 1 ? segment.substring(1) : "*";
         }
-        // 405 Method Not Allowed
-        const allowedMethods = this.router.getAllowedMethods(pathname);
-        if (allowedMethods.length > 0) {
-            return json({
-                success: false,
-                error: "Method Not Allowed",
-                message: `Method ${method} not allowed for this endpoint`,
-                allowedMethods,
-            }, 405, { Allow: allowedMethods.join(", ") });
+        node = node.wildcardChild;
+        break;
+      } else {
+        if (!node.children[segment]) {
+          node.children[segment] = this.createNode(segment);
         }
-        // 404 Not Found
-        return json({ success: false, error: "Not Found" }, 404);
+        node = node.children[segment];
+      }
+    }
+    const routeHandler = { handler, middleware };
+    if (this.compiler && middleware.length === 0) {
+      routeHandler.compiled = this.compiler([], handler);
+    }
+    node.handlers[method] = routeHandler;
+  }
+  /** 预编译所有路由（在添加全局中间件后调用） */
+  precompileAll(globalMiddleware) {
+    if (!this.compiler) return;
+    this.precompileNode(this.root, globalMiddleware);
+  }
+  precompileNode(node, globalMiddleware) {
+    for (const method in node.handlers) {
+      const routeHandler = node.handlers[method];
+      if (routeHandler) {
+        const allMiddleware = [...globalMiddleware, ...routeHandler.middleware];
+        routeHandler.compiled = this.compiler(
+          allMiddleware,
+          routeHandler.handler
+        );
+      }
+    }
+    for (const key in node.children) {
+      this.precompileNode(node.children[key], globalMiddleware);
+    }
+    if (node.paramChild) {
+      this.precompileNode(node.paramChild, globalMiddleware);
+    }
+    if (node.wildcardChild) {
+      this.precompileNode(node.wildcardChild, globalMiddleware);
+    }
+  }
+  /** 匹配路由 */
+  match(method, path) {
+    const segments = this.splitPath(path);
+    const params = /* @__PURE__ */ Object.create(null);
+    const node = this.matchNode(this.root, segments, 0, params);
+    if (!node) return null;
+    const routeHandler = node.handlers[method];
+    if (!routeHandler) return null;
+    return {
+      handler: routeHandler.handler,
+      middleware: routeHandler.middleware,
+      params,
+      compiled: routeHandler.compiled
     };
-    addRoute(route) {
-        const flattenedRoute = {
-            ...route,
-            fullPath: route.path,
-            middlewareChain: route.middleware || [],
-        };
-        this.routes.push(flattenedRoute);
-        this.router.register(route.method, route.path, route.handler, route.middleware || []);
+  }
+  /** 递归匹配节点 (优先级: 静态 > 动态参数 > 通配符) */
+  matchNode(node, segments, index, params) {
+    if (index === segments.length) {
+      for (const method in node.handlers) {
+        if (node.handlers[method]) return node;
+      }
+      return null;
     }
-    addRoutes(routes) {
-        this.registerRoutes(routes);
+    const segment = segments[index];
+    const staticChild = node.children[segment];
+    if (staticChild) {
+      const result = this.matchNode(staticChild, segments, index + 1, params);
+      if (result) return result;
     }
-    getRoutes() {
-        return this.router.getRoutes();
+    if (node.paramChild) {
+      const paramName = node.paramChild.paramName;
+      const oldValue = params[paramName];
+      params[paramName] = segment;
+      const result = this.matchNode(
+        node.paramChild,
+        segments,
+        index + 1,
+        params
+      );
+      if (result) return result;
+      if (oldValue === void 0) {
+        delete params[paramName];
+      } else {
+        params[paramName] = oldValue;
+      }
     }
-}
+    if (node.wildcardChild) {
+      params[node.wildcardChild.paramName || "*"] = segments.slice(index).join("/");
+      return node.wildcardChild;
+    }
+    return null;
+  }
+  /** 获取路径允许的 HTTP 方法 */
+  getAllowedMethods(path) {
+    const segments = this.splitPath(path);
+    const node = this.findNode(segments);
+    if (!node) return [];
+    const methods = [];
+    for (const method in node.handlers) {
+      if (node.handlers[method]) {
+        methods.push(method);
+      }
+    }
+    return methods;
+  }
+  /** 查找节点（不提取参数） */
+  findNode(segments) {
+    let node = this.root;
+    for (const segment of segments) {
+      if (node.children[segment]) {
+        node = node.children[segment];
+      } else if (node.paramChild) {
+        node = node.paramChild;
+      } else if (node.wildcardChild) {
+        return node.wildcardChild;
+      } else {
+        return null;
+      }
+    }
+    return node;
+  }
+  /** 获取所有已注册的路由 */
+  getRoutes() {
+    const routes = [];
+    this.collectRoutes(this.root, "", routes);
+    return routes;
+  }
+  collectRoutes(node, prefix, routes) {
+    const currentPath = prefix + (node.path ? "/" + node.path : "");
+    for (const method in node.handlers) {
+      if (node.handlers[method]) {
+        routes.push({ method, path: currentPath || "/" });
+      }
+    }
+    for (const key in node.children) {
+      this.collectRoutes(node.children[key], currentPath, routes);
+    }
+    if (node.paramChild) {
+      this.collectRoutes(node.paramChild, currentPath, routes);
+    }
+    if (node.wildcardChild) {
+      this.collectRoutes(node.wildcardChild, currentPath, routes);
+    }
+  }
+};
+
+// src/server/server.ts
+var Server = class extends BaseServer {
+  router;
+  routes;
+  /** 是否已预编译 */
+  isCompiled = false;
+  /** 预编译时的全局中间件数量 */
+  compiledWithMiddlewareCount = 0;
+  constructor(routes = []) {
+    super();
+    this.router = new RadixRouter();
+    this.routes = [];
+    this.router.setCompiler(
+      (middleware, handler) => composeMiddleware(middleware, handler)
+    );
+    if (routes.length > 0) {
+      this.registerRoutes(routes);
+    }
+  }
+  /**
+   * 预编译所有路由处理链
+   * 在添加所有路由和全局中间件后调用，可提升运行时性能
+   */
+  compile() {
+    this.router.precompileAll(this.globalMiddleware);
+    this.isCompiled = true;
+    this.compiledWithMiddlewareCount = this.globalMiddleware.length;
+    return this;
+  }
+  registerRoutes(routes) {
+    const flattened = flattenNestedRoutes(routes);
+    this.routes.push(...flattened);
+    for (const route of flattened) {
+      this.router.register(
+        route.method,
+        route.fullPath,
+        route.handler,
+        route.middlewareChain || []
+      );
+    }
+    this.detectRouteConflicts(flattened);
+    this.logFlattenedRoutes(flattened);
+    if (this.globalMiddleware.length === 0 && !this.isCompiled) {
+      this.compile();
+    }
+  }
+  /** 快速提取 pathname */
+  extractPathname(url) {
+    let start = url.indexOf("://");
+    start = start === -1 ? 0 : start + 3;
+    const pathStart = url.indexOf("/", start);
+    if (pathStart === -1) return "/";
+    let end = url.indexOf("?", pathStart);
+    if (end === -1) end = url.indexOf("#", pathStart);
+    if (end === -1) end = url.length;
+    return url.substring(pathStart, end) || "/";
+  }
+  /** 处理请求 */
+  fetch = async (req) => {
+    const pathname = this.extractPathname(req.url);
+    const method = req.method;
+    const match = this.router.match(method, pathname);
+    if (match) {
+      req.params = match.params;
+      if (match.compiled && this.globalMiddleware.length === this.compiledWithMiddlewareCount) {
+        return match.compiled(req);
+      }
+      const allMiddleware = [...this.globalMiddleware, ...match.middleware];
+      const handler = composeMiddleware(allMiddleware, match.handler);
+      return handler(req);
+    }
+    const allowedMethods = this.router.getAllowedMethods(pathname);
+    if (allowedMethods.length > 0) {
+      return json(
+        {
+          success: false,
+          error: "Method Not Allowed",
+          message: `Method ${method} not allowed for this endpoint`,
+          allowedMethods
+        },
+        405,
+        { Allow: allowedMethods.join(", ") }
+      );
+    }
+    return json({ success: false, error: "Not Found" }, 404);
+  };
+  addRoute(route) {
+    const flattenedRoute = {
+      ...route,
+      fullPath: route.path,
+      middlewareChain: route.middleware || []
+    };
+    this.routes.push(flattenedRoute);
+    this.router.register(
+      route.method,
+      route.path,
+      route.handler,
+      route.middleware || []
+    );
+  }
+  addRoutes(routes) {
+    this.registerRoutes(routes);
+  }
+  getRoutes() {
+    return this.router.getRoutes();
+  }
+};
+export {
+  Server
+};
+//# sourceMappingURL=server.js.map