vafast 0.1.11 → 0.1.13

package/dist/monitoring/types.d.ts

@@ -0,0 +1,146 @@
+/**
+ * 性能监控系统类型定义
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+export interface BaseMetrics {
+    timestamp: number;
+    requestId: string;
+    method: string;
+    path: string;
+    statusCode: number;
+    userAgent?: string;
+    ip?: string;
+}
+export interface PerformanceMetrics extends BaseMetrics {
+    totalTime: number;
+    routeMatchTime: number;
+    validationTime: number;
+    handlerTime: number;
+    responseTime: number;
+    memoryUsage: {
+        heapUsed: number;
+        heapTotal: number;
+        external: number;
+        rss: number;
+    };
+    validation: {
+        bodyValidated: boolean;
+        queryValidated: boolean;
+        paramsValidated: boolean;
+        headersValidated: boolean;
+        cookiesValidated: boolean;
+        validationErrors: number;
+    };
+    routing: {
+        routeFound: boolean;
+        middlewareCount: number;
+        dynamicParams: number;
+    };
+    error?: {
+        type: string;
+        message: string;
+        stack?: string;
+    };
+}
+export interface AggregatedMetrics {
+    timeRange: {
+        start: number;
+        end: number;
+    };
+    requests: {
+        total: number;
+        successful: number;
+        failed: number;
+        byMethod: Record<string, number>;
+        byPath: Record<string, number>;
+        byStatusCode: Record<number, number>;
+    };
+    performance: {
+        avgTotalTime: number;
+        avgRouteMatchTime: number;
+        avgValidationTime: number;
+        avgHandlerTime: number;
+        avgResponseTime: number;
+        p50TotalTime: number;
+        p90TotalTime: number;
+        p95TotalTime: number;
+        p99TotalTime: number;
+        minTotalTime: number;
+        maxTotalTime: number;
+    };
+    memory: {
+        avgHeapUsed: number;
+        avgHeapTotal: number;
+        maxHeapUsed: number;
+        maxHeapTotal: number;
+    };
+    validation: {
+        totalValidations: number;
+        validationErrors: number;
+        validationSuccessRate: number;
+    };
+    routing: {
+        totalRoutes: number;
+        routesWithMiddleware: number;
+        dynamicRoutes: number;
+        routeHitCount: Record<string, number>;
+    };
+}
+export interface MonitoringConfig {
+    enabled: boolean;
+    retention: {
+        maxRecords: number;
+        maxAge: number;
+        cleanupInterval: number;
+    };
+    samplingRate: number;
+    recordErrors: boolean;
+    recordBodySize: boolean;
+    recordResponseSize: boolean;
+    thresholds: {
+        slowRequest: number;
+        highMemoryUsage: number;
+        errorRate: number;
+    };
+}
+export interface MonitoringEvent {
+    type: 'request_start' | 'request_end' | 'validation_start' | 'validation_end' | 'error';
+    timestamp: number;
+    requestId: string;
+    data: any;
+}
+export interface PerformanceReport {
+    id: string;
+    timestamp: number;
+    timeRange: {
+        start: number;
+        end: number;
+    };
+    summary: {
+        totalRequests: number;
+        avgResponseTime: number;
+        errorRate: number;
+        memoryUsage: number;
+    };
+    details: {
+        topSlowestRoutes: Array<{
+            path: string;
+            avgTime: number;
+            count: number;
+        }>;
+        topErrorRoutes: Array<{
+            path: string;
+            errorCount: number;
+            errorRate: number;
+        }>;
+        memoryTrend: Array<{
+            timestamp: number;
+            heapUsed: number;
+        }>;
+        responseTimeDistribution: Record<string, number>;
+    };
+    recommendations: string[];
+}

package/dist/monitoring/types.js

@@ -0,0 +1,8 @@
+/**
+ * 性能监控系统类型定义
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+export {};

package/dist/router.d.ts

@@ -0,0 +1,17 @@
+import type { Route, NestedRoute, FlattenedRoute } from "./types";
+export interface MatchResult {
+    matched: boolean;
+    params: Record<string, string>;
+}
+/**
+ * 扁平化嵌套路由，计算完整路径和中间件链
+ */
+export declare function flattenNestedRoutes(routes: (Route | NestedRoute)[]): FlattenedRoute[];
+/**
+ * 标准化路径：去重斜杠、解码URL、处理结尾斜杠
+ */
+export declare function normalizePath(path: string): string;
+/**
+ * 匹配函数：支持动态路由和路径标准化
+ */
+export declare function matchPath(pattern: string, path: string): MatchResult;

package/dist/router.js

@@ -0,0 +1,74 @@
+/**
+ * 扁平化嵌套路由，计算完整路径和中间件链
+ */
+export function flattenNestedRoutes(routes) {
+    const flattened = [];
+    function processRoute(route, parentPath = "", parentMiddleware = []) {
+        const currentPath = 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;
+}
+/**
+ * 标准化路径：去重斜杠、解码URL、处理结尾斜杠
+ */
+export function normalizePath(path) {
+    // 解码 URL 编码的字符
+    let normalized = decodeURIComponent(path);
+    // 去重连续的斜杠
+    normalized = normalized.replace(/\/+/g, "/");
+    // 处理根路径
+    if (normalized === "")
+        normalized = "/";
+    // 去掉结尾斜杠（除非是根路径）
+    if (normalized !== "/" && normalized.endsWith("/")) {
+        normalized = normalized.slice(0, -1);
+    }
+    return normalized;
+}
+/**
+ * 匹配函数：支持动态路由和路径标准化
+ */
+export function matchPath(pattern, path) {
+    // 标准化输入路径
+    const normalizedPath = normalizePath(path);
+    const patternParts = pattern.split("/").filter(Boolean);
+    const pathParts = normalizedPath.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 };
+}

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

@@ -0,0 +1,38 @@
+import type { Middleware } from "../types";
+/**
+ * 服务器基类
+ * 包含所有服务器类型的公共逻辑
+ */
+export declare abstract class BaseServer {
+    protected globalMiddleware: Middleware[];
+    use(mw: Middleware): void;
+    /**
+     * 打印扁平化后的路由信息，用于调试
+     */
+    protected logFlattenedRoutes(routes: any[], type?: string): void;
+    /**
+     * 检测路由冲突
+     * 检查是否有路径相同但方法不同的路由，以及潜在的路径冲突
+     */
+    protected detectRouteConflicts(routes: any[]): void;
+    /**
+     * 检测动态路由的潜在冲突
+     */
+    private detectDynamicRouteConflicts;
+    /**
+     * 判断两个路径是否可能冲突
+     */
+    private pathsMayConflict;
+    /**
+     * 路径匹配
+     */
+    protected matchPath(pattern: string, path: string): boolean;
+    /**
+     * 提取路径参数
+     */
+    protected extractParams(pattern: string, path: string): Record<string, string>;
+    /**
+     * 处理 OPTIONS 请求
+     */
+    protected handleOptions(pathname: string, routes: any[]): Response;
+}

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;
+    }>;
+}