vafast 0.3.10 → 0.4.0

package/dist/index.js

@@ -1,26 +1,27 @@
 // src/router.ts
 function flattenNestedRoutes(routes) {
   const flattened = [];
-  function processRoute(route, parentPath = "", parentMiddleware = []) {
-    const currentPath = normalizePath(parentPath + route.path);
+  function processRoute(route2, parentPath = "", parentMiddleware = []) {
+    const currentPath = normalizePath(parentPath + route2.path);
     const currentMiddleware = [
       ...parentMiddleware,
-      ...route.middleware || []
+      ...route2.middleware || []
     ];
-    if ("method" in route && "handler" in route) {
+    if ("method" in route2 && "handler" in route2) {
+      const leafRoute = route2;
       flattened.push({
-        ...route,
+        ...leafRoute,
         fullPath: currentPath,
         middlewareChain: currentMiddleware
       });
-    } else if ("children" in route && route.children) {
-      for (const child of route.children) {
+    } else if ("children" in route2 && route2.children) {
+      for (const child of route2.children) {
         processRoute(child, currentPath, currentMiddleware);
       }
     }
   }
-  for (const route of routes) {
-    processRoute(route);
+  for (const route2 of routes) {
+    processRoute(route2);
   }
   return flattened;
 }
@@ -187,12 +188,12 @@ var BaseServer = class {
    */
   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;
+    for (const route2 of routes) {
+      const method = route2.method || "GET";
+      const path = route2.fullPath || route2.path;
       console.log(`  ${method} ${path}`);
-      if (route.middlewareChain && route.middlewareChain.length > 0) {
-        console.log(`    \u4E2D\u95F4\u4EF6\u94FE: ${route.middlewareChain.length} \u4E2A`);
+      if (route2.middlewareChain && route2.middlewareChain.length > 0) {
+        console.log(`    \u4E2D\u95F4\u4EF6\u94FE: ${route2.middlewareChain.length} \u4E2A`);
       }
     }
     console.log("");
@@ -203,13 +204,13 @@ var BaseServer = class {
    */
   detectRouteConflicts(routes) {
     const pathGroups = /* @__PURE__ */ new Map();
-    for (const route of routes) {
-      const path = route.fullPath || route.path;
-      const method = route.method || "GET";
+    for (const route2 of routes) {
+      const path = route2.fullPath || route2.path;
+      const method = route2.method || "GET";
       if (!pathGroups.has(path)) {
         pathGroups.set(path, []);
       }
-      pathGroups.get(path).push({ ...route, method });
+      pathGroups.get(path).push({ ...route2, method });
     }
     for (const [path, routeList] of pathGroups) {
       if (routeList.length > 1) {
@@ -219,8 +220,8 @@ var BaseServer = class {
           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}`);
+          routeList.forEach((route2, index) => {
+            console.warn(`   ${index + 1}. ${route2.method} ${path}`);
           });
         } else {
           console.log(`\u2139\uFE0F  \u8DEF\u5F84 ${path} \u652F\u6301\u65B9\u6CD5: ${uniqueMethods.join(", ")}`);
@@ -526,12 +527,12 @@ var Server = class extends BaseServer {
   registerRoutes(routes) {
     const flattened = flattenNestedRoutes(routes);
     this.routes.push(...flattened);
-    for (const route of flattened) {
+    for (const route2 of flattened) {
       this.router.register(
-        route.method,
-        route.fullPath,
-        route.handler,
-        route.middlewareChain || []
+        route2.method,
+        route2.fullPath,
+        route2.handler,
+        route2.middlewareChain || []
       );
     }
     this.detectRouteConflicts(flattened);
@@ -608,18 +609,18 @@ var Server = class extends BaseServer {
     }
     return this.createErrorResponse(method, pathname);
   };
-  addRoute(route) {
+  addRoute(route2) {
     const flattenedRoute = {
-      ...route,
-      fullPath: route.path,
-      middlewareChain: route.middleware || []
+      ...route2,
+      fullPath: route2.path,
+      middlewareChain: route2.middleware || []
     };
     this.routes.push(flattenedRoute);
     this.router.register(
-      route.method,
-      route.path,
-      route.handler,
-      route.middleware || []
+      route2.method,
+      route2.path,
+      route2.handler,
+      route2.middleware || []
     );
   }
   addRoutes(routes) {
@@ -628,31 +629,47 @@ var Server = class extends BaseServer {
   getRoutes() {
     return this.router.getRoutes();
   }
+  /**
+   * 获取完整的路由元信息（不含 handler 和 middleware）
+   *
+   * 用于 API 文档生成、Webhook 事件注册、权限检查等场景
+   *
+   * @example
+   * ```typescript
+   * const routes = server.getRoutesWithMeta()
+   * for (const route of routes) {
+   *   console.log(route.fullPath, route.name, route.description)
+   * }
+   * ```
+   */
+  getRoutesWithMeta() {
+    return this.routes;
+  }
 };
 
 // src/middleware/component-router.ts
 function flattenComponentRoutes(routes) {
   const flattened = [];
-  function processRoute(route, parentPath = "", parentMiddleware = []) {
-    const currentPath = parentPath + route.path;
+  function processRoute(route2, parentPath = "", parentMiddleware = []) {
+    const currentPath = parentPath + route2.path;
     const currentMiddleware = [
       ...parentMiddleware,
-      ...route.middleware || []
+      ...route2.middleware || []
     ];
-    if ("component" in route) {
+    if ("component" in route2) {
       flattened.push({
-        ...route,
+        ...route2,
         fullPath: currentPath,
         middlewareChain: currentMiddleware
       });
-    } else if ("children" in route && route.children) {
-      for (const child of route.children) {
+    } else if ("children" in route2 && route2.children) {
+      for (const child of route2.children) {
         processRoute(child, currentPath, currentMiddleware);
       }
     }
   }
-  for (const route of routes) {
-    processRoute(route);
+  for (const route2 of routes) {
+    processRoute(route2);
   }
   return flattened;
 }
@@ -880,9 +897,9 @@ var ComponentServer = class extends BaseServer {
       return new Response("Method Not Allowed", { status: 405 });
     }
     let matchedRoute = null;
-    for (const route of this.routes) {
-      if (PathMatcher.matchPath(route.fullPath, pathname)) {
-        matchedRoute = route;
+    for (const route2 of this.routes) {
+      if (PathMatcher.matchPath(route2.fullPath, pathname)) {
+        matchedRoute = route2;
         break;
       }
     }
@@ -1314,7 +1331,7 @@ function createHandler(schemaOrHandler, maybeHandler) {
   if (schema.body || schema.query || schema.params || schema.headers || schema.cookies) {
     precompileSchemas(schema);
   }
-  return async (req) => {
+  const handlerFn = async (req) => {
     try {
       const query = parseQuery(req);
       const headers = parseHeaders(req);
@@ -1345,6 +1362,7 @@ function createHandler(schemaOrHandler, maybeHandler) {
       return handleInternalError(error);
     }
   };
+  return handlerFn;
 }
 function createHandlerWithExtra(schemaOrHandler, maybeHandler) {
   const hasSchema = !isHandler(schemaOrHandler);
@@ -1587,6 +1605,225 @@ var Patterns = {
   JWT: JWT_REGEX
 };
 
+// src/utils/sse.ts
+function formatSSEEvent(event) {
+  const lines = [];
+  if (event.id !== void 0) {
+    lines.push(`id: ${event.id}`);
+  }
+  if (event.event !== void 0) {
+    lines.push(`event: ${event.event}`);
+  }
+  if (event.retry !== void 0) {
+    lines.push(`retry: ${event.retry}`);
+  }
+  const dataStr = typeof event.data === "string" ? event.data : JSON.stringify(event.data);
+  const dataLines = dataStr.split("\n");
+  for (const line of dataLines) {
+    lines.push(`data: ${line}`);
+  }
+  return lines.join("\n") + "\n\n";
+}
+function createSSEHandler(schemaOrGenerator, maybeGenerator) {
+  const hasSchema = typeof schemaOrGenerator !== "function";
+  const schema = hasSchema ? schemaOrGenerator : {};
+  const generator = hasSchema ? maybeGenerator : schemaOrGenerator;
+  if (schema.body || schema.query || schema.params || schema.headers || schema.cookies) {
+    precompileSchemas(schema);
+  }
+  const handlerFn = async (req) => {
+    try {
+      const query = parseQuery(req);
+      const headers = parseHeaders(req);
+      const cookies = parseCookies(req);
+      const params = req.params || {};
+      const data = { body: void 0, query, params, headers, cookies };
+      if (schema.body || schema.query || schema.params || schema.headers || schema.cookies) {
+        validateAllSchemas(schema, data);
+      }
+      const stream2 = new ReadableStream({
+        async start(controller) {
+          const encoder2 = new TextEncoder();
+          try {
+            const gen = generator({
+              req,
+              body: void 0,
+              query,
+              params,
+              headers,
+              cookies
+            });
+            for await (const event of gen) {
+              const formatted = formatSSEEvent(event);
+              controller.enqueue(encoder2.encode(formatted));
+            }
+          } catch (error) {
+            const errorEvent = formatSSEEvent({
+              event: "error",
+              data: {
+                message: error instanceof Error ? error.message : "Unknown error"
+              }
+            });
+            controller.enqueue(encoder2.encode(errorEvent));
+          } finally {
+            controller.close();
+          }
+        }
+      });
+      return new Response(stream2, {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive",
+          "X-Accel-Buffering": "no"
+          // Nginx 禁用缓冲
+        }
+      });
+    } catch (error) {
+      return new Response(
+        JSON.stringify({
+          success: false,
+          error: "Validation Error",
+          message: error instanceof Error ? error.message : "Unknown error"
+        }),
+        {
+          status: 400,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+  };
+  const handler = handlerFn;
+  handler.__sse = { __brand: "SSE" };
+  handler.__schema = schema;
+  handler.__returnType = void 0;
+  return handler;
+}
+
+// src/utils/route-registry.ts
+var RouteRegistry = class {
+  /** 所有路由元信息 */
+  routes = [];
+  /** 路由映射表：METHOD:fullPath -> RouteMeta */
+  routeMap = /* @__PURE__ */ new Map();
+  /** 分类映射表：category -> RouteMeta[] */
+  categoryMap = /* @__PURE__ */ new Map();
+  constructor(routes) {
+    this.buildRegistry(routes);
+  }
+  /**
+   * 构建注册表
+   */
+  buildRegistry(routes) {
+    for (const route2 of routes) {
+      const meta = {
+        method: route2.method,
+        path: route2.path,
+        fullPath: route2.fullPath,
+        name: route2.name,
+        description: route2.description
+      };
+      for (const key of Object.keys(route2)) {
+        if (!["method", "path", "fullPath", "name", "description", "handler", "middleware", "middlewareChain"].includes(key)) {
+          meta[key] = route2[key];
+        }
+      }
+      this.routes.push(meta);
+      this.routeMap.set(`${route2.method}:${route2.fullPath}`, meta);
+      const category = this.extractCategory(route2.fullPath);
+      if (!this.categoryMap.has(category)) {
+        this.categoryMap.set(category, []);
+      }
+      this.categoryMap.get(category).push(meta);
+    }
+  }
+  /**
+   * 提取分类（第一段路径）
+   */
+  extractCategory(path) {
+    const segments = path.split("/").filter(Boolean);
+    return segments[0] || "root";
+  }
+  // ============================================
+  // 查询接口
+  // ============================================
+  /**
+   * 获取所有路由元信息
+   */
+  getAll() {
+    return [...this.routes];
+  }
+  /**
+   * 按 method + path 查询路由
+   */
+  get(method, path) {
+    return this.routeMap.get(`${method}:${path}`);
+  }
+  /**
+   * 检查路由是否存在
+   */
+  has(method, path) {
+    return this.routeMap.has(`${method}:${path}`);
+  }
+  /**
+   * 按分类获取路由
+   */
+  getByCategory(category) {
+    return this.categoryMap.get(category) || [];
+  }
+  /**
+   * 获取所有分类
+   */
+  getCategories() {
+    return Array.from(this.categoryMap.keys()).sort();
+  }
+  /**
+   * 筛选有特定字段的路由
+   *
+   * @example
+   * ```typescript
+   * // 获取所有配置了 webhook 的路由
+   * const webhookRoutes = registry.filter('webhook')
+   * ```
+   */
+  filter(field) {
+    return this.routes.filter((r) => field in r && r[field] !== void 0);
+  }
+  /**
+   * 按条件筛选路由
+   *
+   * @example
+   * ```typescript
+   * // 获取所有 POST 请求
+   * const postRoutes = registry.filterBy(r => r.method === 'POST')
+   * ```
+   */
+  filterBy(predicate) {
+    return this.routes.filter(predicate);
+  }
+  /**
+   * 获取路由数量
+   */
+  get size() {
+    return this.routes.length;
+  }
+  /**
+   * 遍历所有路由
+   */
+  forEach(callback) {
+    this.routes.forEach(callback);
+  }
+  /**
+   * 映射所有路由
+   */
+  map(callback) {
+    return this.routes.map(callback);
+  }
+};
+function createRouteRegistry(routes) {
+  return new RouteRegistry(routes);
+}
+
 // src/middleware/authMiddleware.ts
 var requireAuth = async (req, next) => {
   const token = getCookie2(req, "auth");
@@ -1885,6 +2122,29 @@ function createPermissionAuth(permissions, options) {
 }
 
 // src/defineRoute.ts
+function route(method, path, handler, middleware) {
+  return {
+    method,
+    path,
+    handler,
+    middleware
+  };
+}
+function get(path, handler, middleware) {
+  return route("GET", path, handler, middleware);
+}
+function post(path, handler, middleware) {
+  return route("POST", path, handler, middleware);
+}
+function put(path, handler, middleware) {
+  return route("PUT", path, handler, middleware);
+}
+function del(path, handler, middleware) {
+  return route("DELETE", path, handler, middleware);
+}
+function patch(path, handler, middleware) {
+  return route("PATCH", path, handler, middleware);
+}
 function defineRoutes(routes) {
   return routes;
 }
@@ -1893,8 +2153,8 @@ function defineRoutes(routes) {
 function createTypedRoute(config) {
   return config;
 }
-function isTypedRoute(route) {
-  return route && typeof route === "object" && "method" in route && "path" in route && "handler" in route;
+function isTypedRoute(route2) {
+  return route2 && typeof route2 === "object" && "method" in route2 && "path" in route2 && "handler" in route2;
 }
 
 // src/node-server/serve.ts
@@ -2108,10 +2368,53 @@ function createRequestHandler(fetch, defaultHost, onError) {
   };
 }
 function serve(options, callback) {
-  const { fetch, port = 3e3, hostname = "0.0.0.0", onError } = options;
+  const { fetch, port = 3e3, hostname = "0.0.0.0", onError, gracefulShutdown } = options;
   const defaultHost = `${hostname === "0.0.0.0" ? "localhost" : hostname}:${port}`;
   const handler = createRequestHandler(fetch, defaultHost, onError);
   const server = createServer(handler);
+  const connections = /* @__PURE__ */ new Set();
+  server.on("connection", (socket) => {
+    connections.add(socket);
+    socket.on("close", () => connections.delete(socket));
+  });
+  let isShuttingDown = false;
+  const shutdown = async () => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    const shutdownOptions = typeof gracefulShutdown === "object" ? gracefulShutdown : {};
+    const timeout = shutdownOptions.timeout ?? 3e4;
+    if (shutdownOptions.onShutdown) {
+      await shutdownOptions.onShutdown();
+    }
+    return new Promise((resolve) => {
+      const forceCloseTimer = setTimeout(() => {
+        for (const socket of connections) {
+          socket.destroy();
+        }
+        connections.clear();
+        resolve();
+      }, timeout);
+      server.close(() => {
+        clearTimeout(forceCloseTimer);
+        shutdownOptions.onShutdownComplete?.();
+        resolve();
+      });
+      for (const socket of connections) {
+        if (!socket.writableLength) {
+          socket.end();
+        }
+      }
+    });
+  };
+  if (gracefulShutdown) {
+    const shutdownOptions = typeof gracefulShutdown === "object" ? gracefulShutdown : {};
+    const signals = shutdownOptions.signals ?? ["SIGINT", "SIGTERM"];
+    for (const signal of signals) {
+      process.on(signal, () => {
+        shutdown().then(() => process.exit(0));
+      });
+    }
+  }
   server.listen(port, hostname, callback);
   return {
     server,
@@ -2122,7 +2425,8 @@ function serve(options, callback) {
         if (err) reject(err);
         else resolve();
       });
-    })
+    }),
+    shutdown
   };
 }
 
@@ -2136,6 +2440,7 @@ export {
   FormatRegistry2 as FormatRegistry,
   HtmlRenderer,
   Patterns,
+  RouteRegistry,
   Server,
   ServerFactory,
   TokenError,
@@ -2152,13 +2457,17 @@ export {
   createPermissionAuth,
   createRequestValidator,
   createRoleAuth,
+  createRouteRegistry,
+  createSSEHandler,
   createTokenPair,
   createTypedRoute,
   createValidator,
   defineRoutes,
+  del,
   empty,
   flattenNestedRoutes,
   generateToken,
+  get,
   getCookie,
   getHeader,
   getLocals,
@@ -2180,13 +2489,17 @@ export {
   parseQueryFast,
   parseRequest,
   parseToken,
+  patch,
+  post,
   precompileSchemas,
+  put,
   rateLimit,
   redirect,
   refreshToken,
   registerFormat,
   registerFormats,
   requireAuth,
+  route,
   serve,
   setLocals,
   simpleHandler,