vafast 0.1.17 → 0.2.3

package/dist/index.js

@@ -1,323 +1,13 @@
-// @bun
-// src/router.ts
-function matchPath(pattern, path) {
-  const patternParts = pattern.split("/").filter(Boolean);
-  const pathParts = path.split("/").filter(Boolean);
-  const params = {};
-  for (let i = 0;i < patternParts.length; i++) {
-    const pat = patternParts[i];
-    const part = pathParts[i];
-    if (pat === "*") {
-      params["*"] = pathParts.slice(i).join("/");
-      return { matched: true, params };
-    }
-    if (pat.startsWith(":")) {
-      if (!part)
-        return { matched: false, params: {} };
-      params[pat.slice(1)] = part;
-      continue;
-    }
-    if (pat !== part)
-      return { matched: false, params: {} };
-  }
-  if (patternParts.length !== pathParts.length)
-    return { matched: false, params: {} };
-  return { matched: true, params };
-}
-
-// src/util.ts
-function json(data, status = 200, headers = {}) {
-  const h = new Headers({
-    "Content-Type": "application/json",
-    ...headers
-  });
-  return new Response(JSON.stringify(data), {
-    status,
-    headers: h
-  });
-}
-function redirect(location, status = 302) {
-  return new Response(null, {
-    status,
-    headers: {
-      Location: location
-    }
-  });
-}
-function parseQuery(req) {
-  return new URL(req.url).searchParams;
-}
-async function parseBody(req) {
-  const contentType = req.headers.get("content-type") || "";
-  if (contentType.includes("application/json")) {
-    return await req.json();
-  }
-  if (contentType.includes("application/x-www-form-urlencoded")) {
-    const text = await req.text();
-    return Object.fromEntries(new URLSearchParams(text));
-  }
-  return await req.text();
-}
-
-// src/middleware.ts
-class VafastError 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;
-      const fn = index < all.length ? all[index] : finalHandler;
-      return Promise.resolve(fn(req, () => dispatch(index + 1)));
-    };
-    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.ts
-class Server {
-  routes;
-  globalMiddleware = [];
-  constructor(routes) {
-    this.routes = routes;
-  }
-  use(mw) {
-    this.globalMiddleware.push(mw);
-  }
-  fetch = async (req) => {
-    const { pathname } = new URL(req.url);
-    const method = req.method;
-    let matched;
-    let params = {};
-    for (const route of this.routes) {
-      if (route.method !== method)
-        continue;
-      const result = matchPath(route.path, pathname);
-      if (result.matched) {
-        matched = route;
-        params = result.params;
-        break;
-      }
-    }
-    const handler = async (req2) => {
-      if (matched) {
-        req2.params = params;
-        return await matched.handler(req2, params);
-      } else {
-        return new Response("Not Found", { status: 404 });
-      }
-    };
-    const middlewareChain = matched?.middleware ? [...this.globalMiddleware, ...matched.middleware] : this.globalMiddleware;
-    const composedHandler = composeMiddleware(middlewareChain, handler);
-    return await composedHandler(req);
-  };
-}
-// src/cookie.ts
-function getCookie(req, key) {
-  const cookie = req.headers.get("cookie");
-  console.log("[Vafast] \u63A5\u6536\u5230\u7684 Cookie:", cookie);
-  if (!cookie)
-    return null;
-  const pairs = cookie.split(";").map((c) => c.trim().split("="));
-  for (const [k, v] of pairs) {
-    if (k === key) {
-      console.log(`[Vafast] \u5339\u914D\u7684 Cookie: ${k}=${v}`);
-      return decodeURIComponent(v);
-    }
-  }
-  console.log("[Vafast] \u6CA1\u6709\u5339\u914D\u7684 cookie \u952E:", key);
-  return null;
-}
-function setCookie(key, value, options = {}) {
-  let cookie = `${key}=${encodeURIComponent(value)}`;
-  if (options.path)
-    cookie += `; Path=${options.path}`;
-  if (options.httpOnly)
-    cookie += `; HttpOnly`;
-  if (options.secure)
-    cookie += `; Secure`;
-  if (options.maxAge)
-    cookie += `; Max-Age=${options.maxAge}`;
-  return cookie;
-}
-// src/middleware/authMiddleware.ts
-var requireAuth = async (req, next) => {
-  const token = getCookie(req, "auth");
-  if (!token || token !== "valid-token") {
-    throw new VafastError("Unauthorized", {
-      status: 401,
-      type: "unauthorized",
-      expose: true
-    });
-  }
-  return next();
-};
-// src/middleware/rateLimit.ts
-var store = new Map;
-function rateLimit(options = {}) {
-  const windowMs = options.windowMs ?? 60000;
-  const max = options.max ?? 30;
-  const keyFn = options.keyFn ?? getIP;
-  return async (req, next) => {
-    const key = keyFn(req);
-    const now = Date.now();
-    const entry = store.get(key);
-    if (entry && entry.expires > now) {
-      if (entry.count >= max) {
-        throw new VafastError("Too many requests", {
-          status: 429,
-          type: "rate_limit",
-          expose: true
-        });
-      }
-      entry.count += 1;
-    } else {
-      store.set(key, { count: 1, expires: now + windowMs });
-    }
-    return next();
-  };
-}
-function getIP(req) {
-  return req.headers.get("cf-connecting-ip") || req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() || "unknown";
-}
-// src/middleware/cors.ts
-function createCORS(options = {}) {
-  const {
-    origin = [],
-    methods = ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
-    headers = [],
-    credentials = false,
-    maxAge
-  } = options;
-  return async (req, next) => {
-    const reqOrigin = req.headers.get("Origin") || "";
-    const isAllowedOrigin = origin === "*" || origin.includes(reqOrigin);
-    if (req.method === "OPTIONS") {
-      const resHeaders = new Headers;
-      if (isAllowedOrigin) {
-        resHeaders.set("Access-Control-Allow-Origin", origin === "*" ? "*" : reqOrigin);
-        resHeaders.set("Access-Control-Allow-Methods", methods.join(","));
-        resHeaders.set("Access-Control-Allow-Headers", headers.join(","));
-        if (credentials)
-          resHeaders.set("Access-Control-Allow-Credentials", "true");
-        if (maxAge)
-          resHeaders.set("Access-Control-Max-Age", maxAge.toString());
-      }
-      return new Response(null, { status: 204, headers: resHeaders });
-    }
-    const res = await next();
-    if (isAllowedOrigin) {
-      res.headers.set("Access-Control-Allow-Origin", origin === "*" ? "*" : reqOrigin);
-      if (credentials)
-        res.headers.set("Access-Control-Allow-Credentials", "true");
-    }
-    return res;
-  };
-}
-// src/utils/base64url.ts
-function base64urlEncode(str) {
-  return btoa(str).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
-}
-function base64urlDecode(str) {
-  const pad = str.length % 4 === 0 ? "" : "=".repeat(4 - str.length % 4);
-  const base64 = str.replace(/-/g, "+").replace(/_/g, "/") + pad;
-  return atob(base64);
-}
-
-// src/auth/token.ts
-var encoder = new TextEncoder;
-async function sign(data, secret) {
-  const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(data));
-  return btoa(String.fromCharCode(...new Uint8Array(signature)));
-}
-async function generateToken(payload, secret) {
-  const data = base64urlEncode(JSON.stringify(payload));
-  const sig = await sign(data, secret);
-  return `${data}.${base64urlEncode(sig)}`;
-}
-async function verifyToken(token, secret) {
-  const [data, sig] = token.split(".");
-  if (!data || !sig)
-    return null;
-  const expectedSig = await sign(data, secret);
-  const expected = base64urlEncode(expectedSig);
-  if (sig !== expected)
-    return null;
-  try {
-    return JSON.parse(base64urlDecode(data));
-  } catch {
-    return null;
-  }
-}
-// src/middleware/auth.ts
-function createAuth(options) {
-  const { secret, cookieName = "auth", headerName = "authorization" } = options;
-  return async (req, next) => {
-    const token = getCookie(req, cookieName) || req.headers.get(headerName)?.replace("Bearer ", "") || "";
-    const user = await verifyToken(token, secret);
-    if (!user) {
-      throw new VafastError("Unauthorized", {
-        status: 401,
-        type: "unauthorized",
-        expose: true
-      });
-    }
-    req.user = user;
-    return next();
-  };
-}
-// src/defineRoute.ts
-function defineRoutes(routes) {
-  return routes;
-}
-export {
-  verifyToken,
-  setCookie,
-  requireAuth,
-  redirect,
-  rateLimit,
-  parseQuery,
-  parseBody,
-  matchPath,
-  json,
-  getCookie,
-  generateToken,
-  defineRoutes,
-  createCORS,
-  createAuth,
-  composeMiddleware,
-  base64urlEncode,
-  base64urlDecode,
-  VafastError,
-  Server
-};
+export * from "./server";
+export * from "./middleware";
+export * from "./utils";
+export * from "./router";
+export * from "./middleware/authMiddleware";
+export * from "./middleware/rateLimit";
+export * from "./middleware/cors";
+export * from "./auth/token";
+export * from "./middleware/auth";
+export * from "./defineRoute";
+export * from "./types/index";
+// 重新导出 Type 以便用户使用
+export { Type } from "@sinclair/typebox";

package/dist/middleware/auth.d.ts

@@ -3,6 +3,12 @@ interface AuthOptions {
     secret: string;
     cookieName?: string;
     headerName?: string;
+    required?: boolean;
+    roles?: string[];
+    permissions?: string[];
 }
 export declare function createAuth(options: AuthOptions): Middleware;
+export declare function createOptionalAuth(options: Omit<AuthOptions, "required">): Middleware;
+export declare function createRoleAuth(roles: string[], options: Omit<AuthOptions, "roles">): Middleware;
+export declare function createPermissionAuth(permissions: string[], options: Omit<AuthOptions, "permissions">): Middleware;
 export {};

package/dist/middleware/auth.js

@@ -0,0 +1,106 @@
+// src/middleware/auth.ts
+import { VafastError } from "../middleware";
+import { getCookie } from "../utils/handle";
+import { verifyToken, TokenError } from "../auth/token";
+export function createAuth(options) {
+    const { secret, cookieName = "auth", headerName = "authorization", required = true, roles = [], permissions = [], } = options;
+    return async (req, next) => {
+        const token = getCookie(req, cookieName) ||
+            req.headers.get(headerName)?.replace("Bearer ", "") ||
+            "";
+        if (!token && required) {
+            throw new VafastError("缺少认证令牌", {
+                status: 401,
+                type: "unauthorized",
+                expose: true,
+            });
+        }
+        if (!token && !required) {
+            return next();
+        }
+        try {
+            const user = (await verifyToken(token, secret));
+            if (!user) {
+                throw new VafastError("令牌验证失败", {
+                    status: 401,
+                    type: "unauthorized",
+                    expose: true,
+                });
+            }
+            // 检查角色权限
+            if (roles.length > 0 && user.role && !roles.includes(user.role)) {
+                throw new VafastError("权限不足", {
+                    status: 403,
+                    type: "forbidden",
+                    expose: true,
+                });
+            }
+            // 检查具体权限
+            if (permissions.length > 0 && user.permissions) {
+                const userPermissions = Array.isArray(user.permissions)
+                    ? user.permissions
+                    : [user.permissions];
+                const hasPermission = permissions.some((permission) => userPermissions.includes(permission));
+                if (!hasPermission) {
+                    throw new VafastError("权限不足", {
+                        status: 403,
+                        type: "forbidden",
+                        expose: true,
+                    });
+                }
+            }
+            // 🪄 在这里扩展 Request 对象
+            req.user = user;
+            req.token = token;
+            return next();
+        }
+        catch (error) {
+            if (error instanceof TokenError) {
+                let status = 401;
+                let message = "认证失败";
+                switch (error.code) {
+                    case "EXPIRED_TOKEN":
+                        status = 401;
+                        message = "令牌已过期";
+                        break;
+                    case "INVALID_SIGNATURE":
+                        status = 401;
+                        message = "令牌签名无效";
+                        break;
+                    case "MALFORMED_TOKEN":
+                        status = 400;
+                        message = "令牌格式错误";
+                        break;
+                    default:
+                        status = 401;
+                        message = "令牌验证失败";
+                }
+                throw new VafastError(message, {
+                    status,
+                    type: "unauthorized",
+                    expose: true,
+                });
+            }
+            if (error instanceof VafastError) {
+                throw error;
+            }
+            throw new VafastError("认证过程中发生错误", {
+                status: 500,
+                type: "internal_error",
+                expose: false,
+            });
+        }
+    };
+}
+// 可选认证中间件
+export function createOptionalAuth(options) {
+    return createAuth({ ...options, required: false });
+}
+// 角色验证中间件
+export function createRoleAuth(roles, options) {
+    return createAuth({ ...options, roles });
+}
+// 权限验证中间件
+export function createPermissionAuth(permissions, options) {
+    return createAuth({ ...options, permissions });
+}

package/dist/middleware/authMiddleware.js

@@ -0,0 +1,13 @@
+import { VafastError } from "../middleware";
+import { getCookie } from "../utils/handle";
+export const requireAuth = async (req, next) => {
+    const token = getCookie(req, "auth");
+    if (!token || token !== "valid-token") {
+        throw new VafastError("Unauthorized", {
+            status: 401,
+            type: "unauthorized",
+            expose: true,
+        });
+    }
+    return next();
+};

package/dist/middleware/component-renderer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 组件渲染中间件 - 专注 SSR
+ * 支持 Vue 和 React 的服务端渲染
+ */
+export declare const vueRenderer: (preloadedDeps?: any) => (req: Request, next: () => Promise<Response>) => Promise<Response>;
+export declare const reactRenderer: (preloadedDeps?: any) => (req: Request, next: () => Promise<Response>) => Promise<Response>;

package/dist/middleware/component-renderer.js

@@ -0,0 +1,132 @@
+/**
+ * 组件渲染中间件 - 专注 SSR
+ * 支持 Vue 和 React 的服务端渲染
+ */
+// Vue SSR 渲染
+const renderVueSSR = async (componentImport, req, preloadedDeps) => {
+    try {
+        // 使用预加载的依赖或动态导入
+        const { createSSRApp, renderToString } = preloadedDeps ||
+            (await Promise.all([import("vue"), import("@vue/server-renderer")]).then(([vue, renderer]) => ({
+                createSSRApp: vue.createSSRApp,
+                renderToString: renderer.renderToString,
+            })));
+        const componentModule = await componentImport();
+        const component = componentModule.default || componentModule;
+        const app = createSSRApp(component);
+        // 提供路由信息
+        app.provide("routeInfo", {
+            params: req.params || {},
+            query: Object.fromEntries(new URL(req.url).searchParams),
+            pathname: new URL(req.url).pathname,
+        });
+        const html = await renderToString(app);
+        return new Response(`
+      <!doctype html>
+      <html>
+        <head>
+          <meta charset="utf-8">
+          <title>Vue SSR App</title>
+        </head>
+        <body>
+          <div id="app">${html}</div>
+          <script>
+            window.__ROUTE_INFO__ = {
+              params: ${JSON.stringify(req.params || {})},
+              query: ${JSON.stringify(Object.fromEntries(new URL(req.url).searchParams))},
+              pathname: '${new URL(req.url).pathname}'
+            };
+          </script>
+          <script type="module" src="/client.js"></script>
+        </body>
+      </html>
+    `, {
+            headers: { "Content-Type": "text/html; charset=utf-8" },
+        });
+    }
+    catch (error) {
+        console.error("Vue SSR 渲染失败:", error);
+        return new Response(`
+      <!doctype html>
+      <html>
+        <head><title>渲染错误</title></head>
+        <body>
+          <h1>Vue SSR 渲染失败</h1>
+          <p>错误信息: ${error instanceof Error ? error.message : "未知错误"}</p>
+        </body>
+      </html>
+    `, { status: 500 });
+    }
+};
+// React SSR 渲染
+const renderReactSSR = async (componentImport, req, preloadedDeps) => {
+    try {
+        // 使用预加载的依赖或动态导入
+        const { createElement, renderToString } = preloadedDeps ||
+            (await Promise.all([import("react"), import("react-dom/server")]).then(([react, renderer]) => ({
+                createElement: react.createElement,
+                renderToString: renderer.renderToString,
+            })));
+        const componentModule = await componentImport();
+        const Component = componentModule.default || componentModule;
+        const content = createElement(Component, {
+            req,
+            params: req.params || {},
+            query: Object.fromEntries(new URL(req.url).searchParams),
+        });
+        const html = renderToString(content);
+        return new Response(`
+      <!doctype html>
+      <html>
+        <head>
+          <meta charset="utf-8">
+          <title>React SSR App</title>
+        </head>
+        <body>
+          <div id="root">${html}</div>
+          <script>
+            window.__ROUTE_INFO__ = {
+              params: ${JSON.stringify(req.params || {})},
+              query: ${JSON.stringify(Object.fromEntries(new URL(req.url).searchParams))},
+              pathname: '${new URL(req.url).pathname}'
+            };
+          </script>
+          <script type="module" src="/client.js"></script>
+        </body>
+      </html>
+    `, {
+            headers: { "Content-Type": "text/html; charset=utf-8" },
+        });
+    }
+    catch (error) {
+        console.error("React SSR 渲染失败:", error);
+        return new Response(`
+      <!doctype html>
+      <html>
+        <head><title>渲染错误</title></head>
+        <body>
+          <h1>React SSR 渲染失败</h1>
+          <p>错误信息: ${error instanceof Error ? error.message : "未知错误"}</p>
+        </body>
+      </html>
+    `, { status: 500 });
+    }
+};
+// Vue 组件渲染器 - 专注 SSR
+export const vueRenderer = (preloadedDeps) => {
+    return async (req, next) => {
+        req.renderVue = async (componentImport) => {
+            return await renderVueSSR(componentImport, req, preloadedDeps);
+        };
+        return next();
+    };
+};
+// React 组件渲染器 - 专注 SSR
+export const reactRenderer = (preloadedDeps) => {
+    return async (req, next) => {
+        req.renderReact = async (componentImport) => {
+            return await renderReactSSR(componentImport, req, preloadedDeps);
+        };
+        return next();
+    };
+};

package/dist/middleware/component-router.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentRoute, NestedComponentRoute, FlattenedComponentRoute } from "../types/component-route";
+/**
+ * 扁平化嵌套组件路由
+ */
+export declare function flattenComponentRoutes(routes: (ComponentRoute | NestedComponentRoute)[]): FlattenedComponentRoute[];
+/**
+ * 组件路由处理器中间件
+ * 自动检测组件类型并应用相应的渲染器
+ */
+export declare const componentRouter: () => (req: Request, next: () => Promise<Response>) => Promise<Response>;

package/dist/middleware/component-router.js

@@ -0,0 +1,42 @@
+/**
+ * 扁平化嵌套组件路由
+ */
+export function flattenComponentRoutes(routes) {
+    const flattened = [];
+    function processRoute(route, parentPath = "", parentMiddleware = []) {
+        const currentPath = parentPath + route.path;
+        const currentMiddleware = [
+            ...parentMiddleware,
+            ...(route.middleware || []),
+        ];
+        if ("component" 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;
+}
+/**
+ * 组件路由处理器中间件
+ * 自动检测组件类型并应用相应的渲染器
+ */
+export const componentRouter = () => {
+    return async (req, next) => {
+        // 这里可以添加组件路由的自动处理逻辑
+        // 比如自动检测组件类型，应用相应的渲染器
+        return next();
+    };
+};