vafast 0.1.10 → 0.1.12

package/dist/server/base-server.js

@@ -0,0 +1,167 @@
+/**
+ * 服务器基类
+ * 包含所有服务器类型的公共逻辑
+ */
+export class BaseServer {
+    globalMiddleware = [];
+    use(mw) {
+        this.globalMiddleware.push(mw);
+    }
+    /**
+     * 打印扁平化后的路由信息，用于调试
+     */
+    logFlattenedRoutes(routes, type = "路由") {
+        console.log(`🚀 扁平化后的${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(`    中间件链: ${route.middlewareChain.length} 个`);
+            }
+        }
+        console.log("");
+    }
+    /**
+     * 检测路由冲突
+     * 检查是否有路径相同但方法不同的路由，以及潜在的路径冲突
+     */
+    detectRouteConflicts(routes) {
+        const pathGroups = 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 });
+        }
+        // 检查冲突
+        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(`⚠️  路由冲突: ${uniqueMethods[0]} ${path} 定义了 ${routeList.length} 次`);
+                    routeList.forEach((route, index) => {
+                        console.warn(`   ${index + 1}. ${route.method} ${path}`);
+                    });
+                }
+                else {
+                    // 相同路径、不同方法 - 这是正常的
+                    console.log(`ℹ️  路径 ${path} 支持方法: ${uniqueMethods.join(", ")}`);
+                }
+            }
+        }
+        // 检查潜在的路径冲突（动态路由可能冲突）
+        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(`⚠️  潜在路由冲突: ${method1} ${path1} 可能与 ${path2} 冲突`);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * 判断两个路径是否可能冲突
+     */
+    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];
+            }
+        }
+        return params;
+    }
+    /**
+     * 处理 OPTIONS 请求
+     */
+    handleOptions(pathname, routes) {
+        const availableMethods = [];
+        for (const route of routes) {
+            const path = route.fullPath || route.path;
+            const method = route.method || "GET";
+            if (this.matchPath(path, pathname)) {
+                availableMethods.push(method);
+            }
+        }
+        // 去重并排序
+        const uniqueMethods = [...new Set(availableMethods)].sort();
+        return new Response(null, {
+            status: 204,
+            headers: {
+                Allow: uniqueMethods.join(", "),
+                "Access-Control-Allow-Methods": uniqueMethods.join(", "),
+                "Access-Control-Allow-Headers": "Content-Type, Authorization",
+            },
+        });
+    }
+}

package/dist/server/component-server.d.ts

@@ -0,0 +1,32 @@
+import type { ComponentRoute, NestedComponentRoute } from "../types/component-route";
+import { BaseServer } from "./base-server";
+import { DependencyManager } from "../utils/dependency-manager";
+/**
+ * 组件路由服务器
+ * 专门处理声明式组件路由
+ */
+export declare class ComponentServer extends BaseServer {
+    private routes;
+    private dependencyManager;
+    constructor(routes: (ComponentRoute | NestedComponentRoute)[]);
+    /**
+     * 处理请求
+     */
+    fetch(req: Request): Promise<Response>;
+    /**
+     * 执行中间件链
+     */
+    private executeMiddlewareChain;
+    /**
+     * 渲染 Vue 组件
+     */
+    private renderVueComponent;
+    /**
+     * 渲染 React 组件
+     */
+    private renderReactComponent;
+    /**
+     * 获取依赖管理器（用于外部访问）
+     */
+    getDependencyManager(): DependencyManager;
+}

package/dist/server/component-server.js

@@ -0,0 +1,146 @@
+import { flattenComponentRoutes } from "../middleware/component-router";
+import { BaseServer } from "./base-server";
+import { PathMatcher } from "../utils/path-matcher";
+import { HtmlRenderer } from "../utils/html-renderer";
+import { DependencyManager } from "../utils/dependency-manager";
+/**
+ * 组件路由服务器
+ * 专门处理声明式组件路由
+ */
+export class ComponentServer extends BaseServer {
+    routes;
+    dependencyManager;
+    constructor(routes) {
+        super();
+        this.routes = flattenComponentRoutes(routes);
+        this.dependencyManager = new DependencyManager();
+        // 检测路由冲突
+        this.detectRouteConflicts(this.routes);
+        this.logFlattenedRoutes(this.routes, "组件路由");
+        console.log("🚀 依赖按需加载，服务器启动完成");
+    }
+    /**
+     * 处理请求
+     */
+    async fetch(req) {
+        const url = new URL(req.url);
+        const pathname = url.pathname;
+        const method = req.method;
+        // 只支持 GET 请求
+        if (method !== "GET") {
+            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;
+                break;
+            }
+        }
+        if (!matchedRoute) {
+            return new Response("Not Found", { status: 404 });
+        }
+        try {
+            // 创建中间件上下文
+            const context = {
+                req,
+                params: PathMatcher.extractParams(matchedRoute.fullPath, pathname),
+                query: Object.fromEntries(url.searchParams),
+                pathname,
+            };
+            // 执行中间件链，中间件会处理组件渲染
+            return await this.executeMiddlewareChain(matchedRoute.middlewareChain, context, matchedRoute.component);
+        }
+        catch (error) {
+            console.error("组件渲染失败:", error);
+            return new Response("Internal Server Error", { status: 500 });
+        }
+    }
+    /**
+     * 执行中间件链
+     */
+    async executeMiddlewareChain(middlewareChain, context, componentImport) {
+        // 创建最终的渲染函数
+        const renderComponent = async () => {
+            const componentModule = await componentImport();
+            const component = componentModule.default || componentModule;
+            // 自动检测组件类型
+            const componentType = this.dependencyManager.detectComponentType(component);
+            // 按需加载依赖
+            const deps = await this.dependencyManager.getFrameworkDeps(componentType);
+            // 根据组件类型渲染
+            if (componentType === "vue") {
+                return await this.renderVueComponent(component, context, deps);
+            }
+            else if (componentType === "react") {
+                return await this.renderReactComponent(component, context, deps);
+            }
+            else {
+                throw new Error(`不支持的组件类型: ${componentType}`);
+            }
+        };
+        // 执行中间件链
+        let index = 0;
+        const next = async () => {
+            if (index >= middlewareChain.length) {
+                return await renderComponent();
+            }
+            const middleware = middlewareChain[index++];
+            return await middleware(context.req, next);
+        };
+        return await next();
+    }
+    /**
+     * 渲染 Vue 组件
+     */
+    async renderVueComponent(component, context, deps) {
+        try {
+            const [vue, renderer] = deps;
+            const app = vue.createSSRApp(component);
+            // 提供路由信息
+            app.provide("routeInfo", {
+                params: context.params || {},
+                query: context.query || {},
+                pathname: context.pathname,
+            });
+            const html = await renderer.renderToString(app);
+            const fullHtml = HtmlRenderer.generateVueHtml(html, context);
+            return new Response(fullHtml, {
+                headers: { "Content-Type": "text/html; charset=utf-8" },
+            });
+        }
+        catch (error) {
+            console.error("Vue 组件渲染失败:", error);
+            return new Response("Vue Component Render Error", { status: 500 });
+        }
+    }
+    /**
+     * 渲染 React 组件
+     */
+    async renderReactComponent(component, context, deps) {
+        try {
+            const [react, renderer] = deps;
+            const content = react.createElement(component, {
+                req: context.req,
+                params: context.params || {},
+                query: context.query || {},
+            });
+            const html = renderer.renderToString(content);
+            const fullHtml = HtmlRenderer.generateReactHtml(html, context);
+            return new Response(fullHtml, {
+                headers: { "Content-Type": "text/html; charset=utf-8" },
+            });
+        }
+        catch (error) {
+            console.error("React 组件渲染失败:", error);
+            return new Response("React Component Render Error", { status: 500 });
+        }
+    }
+    /**
+     * 获取依赖管理器（用于外部访问）
+     */
+    getDependencyManager() {
+        return this.dependencyManager;
+    }
+}

package/dist/server/index.d.ts

@@ -0,0 +1,7 @@
+export { Server } from "./server";
+export { ComponentServer } from "./component-server";
+export { BaseServer } from "./base-server";
+export { ServerFactory } from "./server-factory";
+export { PathMatcher } from "../utils/path-matcher";
+export { HtmlRenderer } from "../utils/html-renderer";
+export { DependencyManager } from "../utils/dependency-manager";

package/dist/server/index.js

@@ -0,0 +1,9 @@
+// 导出所有服务器相关的类和工具
+export { Server } from "./server";
+export { ComponentServer } from "./component-server";
+export { BaseServer } from "./base-server";
+export { ServerFactory } from "./server-factory";
+// 导出工具类
+export { PathMatcher } from "../utils/path-matcher";
+export { HtmlRenderer } from "../utils/html-renderer";
+export { DependencyManager } from "../utils/dependency-manager";

package/dist/server/server-factory.d.ts

@@ -0,0 +1,42 @@
+import type { Route, NestedRoute } from "../types";
+import type { ComponentRoute, NestedComponentRoute } from "../types/component-route";
+import { Server } from "../server";
+import { ComponentServer } from "./component-server";
+/**
+ * 服务器工厂类
+ * 用于创建和管理不同类型的服务器
+ */
+export declare class ServerFactory {
+    private servers;
+    /**
+     * 创建标准REST API服务器
+     */
+    createRestServer(routes: (Route | NestedRoute)[]): Server;
+    /**
+     * 创建组件服务器
+     */
+    createComponentServer(routes: (ComponentRoute | NestedComponentRoute)[]): ComponentServer;
+    /**
+     * 获取指定类型的服务器
+     */
+    getServer(type: "rest" | "component"): Server | ComponentServer | undefined;
+    /**
+     * 获取所有服务器
+     */
+    getAllServers(): Map<string, Server | ComponentServer>;
+    /**
+     * 移除指定类型的服务器
+     */
+    removeServer(type: string): boolean;
+    /**
+     * 清除所有服务器
+     */
+    clearServers(): void;
+    /**
+     * 获取服务器状态信息
+     */
+    getServerStatus(): Record<string, {
+        type: string;
+        routes: number;
+    }>;
+}

package/dist/server/server-factory.js

@@ -0,0 +1,70 @@
+import { Server } from "../server";
+import { ComponentServer } from "./component-server";
+/**
+ * 服务器工厂类
+ * 用于创建和管理不同类型的服务器
+ */
+export class ServerFactory {
+    servers = new Map();
+    /**
+     * 创建标准REST API服务器
+     */
+    createRestServer(routes) {
+        const server = new Server(routes);
+        this.servers.set("rest", server);
+        return server;
+    }
+    /**
+     * 创建组件服务器
+     */
+    createComponentServer(routes) {
+        const server = new ComponentServer(routes);
+        this.servers.set("component", server);
+        return server;
+    }
+    /**
+     * 获取指定类型的服务器
+     */
+    getServer(type) {
+        return this.servers.get(type);
+    }
+    /**
+     * 获取所有服务器
+     */
+    getAllServers() {
+        return this.servers;
+    }
+    /**
+     * 移除指定类型的服务器
+     */
+    removeServer(type) {
+        return this.servers.delete(type);
+    }
+    /**
+     * 清除所有服务器
+     */
+    clearServers() {
+        this.servers.clear();
+    }
+    /**
+     * 获取服务器状态信息
+     */
+    getServerStatus() {
+        const status = {};
+        for (const [name, server] of this.servers) {
+            if (server instanceof Server) {
+                status[name] = {
+                    type: "REST API",
+                    routes: server.routes?.length || 0,
+                };
+            }
+            else if (server instanceof ComponentServer) {
+                status[name] = {
+                    type: "Component",
+                    routes: server.routes?.length || 0,
+                };
+            }
+        }
+        return status;
+    }
+}

package/dist/server/server.d.ts

@@ -0,0 +1,7 @@
+import type { Route, NestedRoute } from "../types";
+import { BaseServer } from "./base-server";
+export declare class Server extends BaseServer {
+    private routes;
+    constructor(routes: (Route | NestedRoute)[]);
+    fetch: (req: Request) => Promise<Response>;
+}

package/dist/server/server.js

@@ -0,0 +1,73 @@
+import { matchPath, flattenNestedRoutes } from "../router";
+import { composeMiddleware } from "../middleware";
+import { json } from "../utils/response";
+import { BaseServer } from "./base-server";
+import { PathMatcher } from "../utils/path-matcher";
+export class Server extends BaseServer {
+    routes;
+    constructor(routes) {
+        super();
+        // 扁平化嵌套路由，计算完整的中间件链
+        this.routes = flattenNestedRoutes(routes);
+        // 在构造时按路由"特异性"排序：静态 > 动态(:param) > 通配符(*)
+        this.routes = this.routes.sort((a, b) => PathMatcher.calculatePathScore(b.fullPath) -
+            PathMatcher.calculatePathScore(a.fullPath));
+        // 检测路由冲突
+        this.detectRouteConflicts(this.routes);
+        // 打印扁平化后的路由信息
+        this.logFlattenedRoutes(this.routes);
+    }
+    fetch = async (req) => {
+        const { pathname } = new URL(req.url);
+        const method = req.method;
+        // 自动处理 OPTIONS 请求
+        if (method === "OPTIONS") {
+            return this.handleOptions(pathname, this.routes);
+        }
+        let matched;
+        let params = {};
+        let availableMethods = [];
+        for (const route of this.routes) {
+            const result = matchPath(route.fullPath, pathname);
+            if (result.matched) {
+                if (route.method === method) {
+                    matched = route;
+                    params = result.params;
+                    break;
+                }
+                else {
+                    // 路径匹配但方法不匹配，收集可用方法
+                    availableMethods.push(route.method);
+                }
+            }
+        }
+        const handler = async (req) => {
+            if (matched) {
+                // 将路径参数设置到 req 对象上，以便 TypedRoute 处理器能够访问
+                req.params = params;
+                return await matched.handler(req, params);
+            }
+            else if (availableMethods.length > 0) {
+                // 路径存在但方法不匹配，返回 405 Method Not Allowed
+                return json({
+                    success: false,
+                    error: "Method Not Allowed",
+                    message: `Method ${method} not allowed for this endpoint`,
+                    allowedMethods: availableMethods,
+                }, 405, {
+                    Allow: availableMethods.join(", "),
+                });
+            }
+            else {
+                // 路径不存在，返回 404 Not Found
+                return json({ success: false, error: "Not Found" }, 404);
+            }
+        };
+        const middlewareChain = matched?.middlewareChain
+            ? [...this.globalMiddleware, ...matched.middlewareChain]
+            : this.globalMiddleware;
+        // 使用 composeMiddleware 来确保错误处理中间件被应用
+        const composedHandler = composeMiddleware(middlewareChain, handler);
+        return await composedHandler(req);
+    };
+}

package/dist/types/component-route.d.ts

@@ -0,0 +1,25 @@
+import type { Middleware } from "./route";
+/**
+ * 组件路由配置
+ * 支持声明式的组件关联
+ */
+export interface ComponentRoute {
+    path: string;
+    component: () => Promise<any>;
+    middleware?: Middleware[];
+}
+/**
+ * 嵌套组件路由配置
+ */
+export interface NestedComponentRoute {
+    path: string;
+    middleware?: Middleware[];
+    children?: (ComponentRoute | NestedComponentRoute)[];
+}
+/**
+ * 扁平化后的组件路由
+ */
+export interface FlattenedComponentRoute extends ComponentRoute {
+    fullPath: string;
+    middlewareChain: Middleware[];
+}

package/dist/types/component-route.js

@@ -0,0 +1 @@
+export {};

package/dist/types/route.d.ts

@@ -0,0 +1,37 @@
+import { Route } from "..";
+export interface Middleware {
+    (req: Request, next: () => Promise<Response>): Promise<Response>;
+}
+export interface BaseRouteConfig {
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD";
+    path: string;
+    handler: (req: Request) => Response | Promise<Response>;
+}
+export interface ExtendedRouteConfig extends BaseRouteConfig {
+    middleware?: Middleware[];
+    body?: any;
+    query?: any;
+    params?: any;
+    headers?: any;
+    cookies?: any;
+    docs?: {
+        description?: string;
+        tags?: string[];
+        security?: any[];
+        responses?: Record<string, any>;
+    };
+    timeout?: number;
+    maxBodySize?: string;
+    [key: string]: any;
+}
+export interface NestedRouteConfig {
+    path: string;
+    middleware?: Middleware[];
+    children?: (NestedRouteConfig | ExtendedRouteConfig)[];
+}
+export type TypedRoute = ExtendedRouteConfig;
+export type CompatibleRoute = Route | TypedRoute;
+export interface FlattenedRoute extends ExtendedRouteConfig {
+    fullPath: string;
+    middlewareChain: Middleware[];
+}

package/dist/types/route.js

@@ -0,0 +1 @@
+export {};

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+export type Method = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD";
+export type Handler = (req: Request, params?: Record<string, string>, user?: Record<string, any>) => Response | Promise<Response>;
+export type Middleware = (req: Request, next: () => Promise<Response>) => Promise<Response>;
+export interface Route {
+    method: Method;
+    path: string;
+    handler: Handler;
+    middleware?: Middleware[];
+}
+export interface NestedRoute {
+    path: string;
+    middleware?: Middleware[];
+    children?: (NestedRoute | Route)[];
+}
+export interface FlattenedRoute extends Route {
+    fullPath: string;
+    middlewareChain: Middleware[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/base64url.d.ts

@@ -0,0 +1,2 @@
+export declare function base64urlEncode(str: string): string;
+export declare function base64urlDecode(str: string): string;

package/dist/utils/base64url.js

@@ -0,0 +1,11 @@
+export function base64urlEncode(str) {
+    return btoa(str)
+        .replace(/=/g, "") // ✅ 删除填充
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_");
+}
+export 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);
+}