vafast 0.1.10 → 0.1.12

package/dist/middleware/rateLimit.js

@@ -0,0 +1,33 @@
+// src/middleware/rateLimit.ts
+import { VafastError } from "../middleware";
+const store = new Map();
+export function rateLimit(options = {}) {
+    const windowMs = options.windowMs ?? 60_000; // 默认: 1分钟
+    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();
+    };
+}
+// Edge 安全的 IP 获取
+function getIP(req) {
+    return (req.headers.get("cf-connecting-ip") || // Cloudflare
+        req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() || // Vercel
+        "unknown");
+}

package/dist/middleware.d.ts

@@ -0,0 +1,18 @@
+import type { Handler, Middleware } from "./types";
+/** 中间件类型：使用 next() 传递给下一个处理 */
+/** Vafast 自定义错误类型 */
+export declare class VafastError extends Error {
+    status: number;
+    type: string;
+    expose: boolean;
+    constructor(message: string, options?: {
+        status?: number;
+        type?: string;
+        expose?: boolean;
+        cause?: unknown;
+    });
+}
+/**
+ * 组合类型: 自动注入错误处理器进行中间件组合
+ */
+export declare function composeMiddleware(middleware: Middleware[], finalHandler: Handler): Handler;

package/dist/middleware.js

@@ -0,0 +1,51 @@
+// src/middleware.ts
+import { json } from "./utils/response";
+/** 中间件类型：使用 next() 传递给下一个处理 */
+/** Vafast 自定义错误类型 */
+export 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;
+    }
+}
+/**
+ * 组合类型: 自动注入错误处理器进行中间件组合
+ */
+export 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);
+    };
+}
+/** 默认包含的全局错误处理器 */
+const errorHandler = async (req, next) => {
+    try {
+        return await next();
+    }
+    catch (err) {
+        console.error("未处理的错误:", err);
+        if (err instanceof VafastError) {
+            return json({
+                error: err.type,
+                message: err.expose ? err.message : "发生了一个错误",
+            }, err.status);
+        }
+        return json({ error: "internal_error", message: "出现了一些问题" }, 500);
+    }
+};

package/dist/monitoring/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 原生监控系统入口
+ *
+ * @author Framework Team
+ * @version 2.0.0
+ * @license MIT
+ */
+export * from "./types";
+export * from "./native-monitor";
+export declare const defaultMonitoringConfig: {
+    enabled: boolean;
+    console: boolean;
+    slowThreshold: number;
+    errorThreshold: number;
+    tags: {
+        framework: string;
+        version: string;
+    };
+};
+export declare function createMonitoringConfig(config?: Partial<typeof defaultMonitoringConfig>): {
+    enabled: boolean;
+    console: boolean;
+    slowThreshold: number;
+    errorThreshold: number;
+    tags: {
+        framework: string;
+        version: string;
+    };
+};

package/dist/monitoring/index.js

@@ -0,0 +1,24 @@
+/**
+ * 原生监控系统入口
+ *
+ * @author Framework Team
+ * @version 2.0.0
+ * @license MIT
+ */
+export * from "./types";
+export * from "./native-monitor";
+// 默认监控配置
+export const defaultMonitoringConfig = {
+    enabled: true,
+    console: true,
+    slowThreshold: 1000, // 1秒
+    errorThreshold: 0.05, // 5%
+    tags: {
+        framework: "vafast",
+        version: "2.0.0",
+    },
+};
+// 创建监控配置
+export function createMonitoringConfig(config = {}) {
+    return { ...defaultMonitoringConfig, ...config };
+}

package/dist/monitoring/native-monitor.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 原生监控装饰器
+ *
+ * 通过装饰器模式为 Server 添加监控能力，完全不入侵原类
+ *
+ * @author Framework Team
+ * @version 2.0.0
+ * @license MIT
+ */
+import type { Server } from "../server";
+export interface NativeMonitoringConfig {
+    enabled?: boolean;
+    console?: boolean;
+    slowThreshold?: number;
+    errorThreshold?: number;
+    tags?: Record<string, string>;
+}
+export interface NativeMonitoringMetrics {
+    requestId: string;
+    method: string;
+    path: string;
+    statusCode: number;
+    totalTime: number;
+    timestamp: number;
+    memoryUsage: {
+        heapUsed: number;
+        heapTotal: number;
+    };
+}
+export interface MonitoredServer extends Server {
+    getMonitoringStatus(): any;
+    getMonitoringMetrics(): NativeMonitoringMetrics[];
+    resetMonitoring(): void;
+    fetch: (req: Request) => Promise<Response>;
+    use: (mw: any) => void;
+}
+export declare function withMonitoring(server: Server, config?: NativeMonitoringConfig): MonitoredServer;
+export declare function createMonitoredServer(routes: any[], config?: NativeMonitoringConfig): MonitoredServer;

package/dist/monitoring/native-monitor.js

@@ -0,0 +1,176 @@
+/**
+ * 原生监控装饰器
+ *
+ * 通过装饰器模式为 Server 添加监控能力，完全不入侵原类
+ *
+ * @author Framework Team
+ * @version 2.0.0
+ * @license MIT
+ */
+// 原生监控器
+class NativeMonitor {
+    config;
+    metrics = [];
+    isEnabled = false;
+    constructor(config = {}) {
+        this.config = {
+            enabled: true,
+            console: true,
+            slowThreshold: 1000,
+            errorThreshold: 0.05,
+            tags: { framework: "vafast" },
+            ...config,
+        };
+        this.isEnabled = this.config.enabled ?? true;
+        if (this.isEnabled && this.config.console) {
+            console.log("✅ 原生监控已启用");
+            console.log(`📊 监控配置:`, {
+                慢请求阈值: `${this.config.slowThreshold}ms`,
+                错误率阈值: `${(this.config.errorThreshold * 100).toFixed(1)}%`,
+                标签: this.config.tags,
+            });
+        }
+    }
+    // 记录监控指标
+    recordMetrics(metrics) {
+        if (!this.isEnabled)
+            return;
+        this.metrics.push(metrics);
+        // 保持最近1000条记录
+        if (this.metrics.length > 1000) {
+            this.metrics = this.metrics.slice(-1000);
+        }
+        // 控制台输出
+        if (this.config.console) {
+            const status = metrics.statusCode < 400 ? "✅" : "❌";
+            const timeColor = metrics.totalTime > this.config.slowThreshold ? "🐌" : "⚡";
+            console.log(`${status} ${metrics.method} ${metrics.path} - ${metrics.statusCode} (${timeColor} ${metrics.totalTime.toFixed(2)}ms)`);
+            // 慢请求警告
+            if (metrics.totalTime > this.config.slowThreshold) {
+                console.warn(`🐌 慢请求警告: ${metrics.path} 耗时 ${metrics.totalTime.toFixed(2)}ms`);
+            }
+        }
+    }
+    // 获取监控状态
+    getStatus() {
+        if (!this.isEnabled) {
+            return { enabled: false, message: "监控未启用" };
+        }
+        const totalRequests = this.metrics.length;
+        const successfulRequests = this.metrics.filter((m) => m.statusCode < 400).length;
+        const failedRequests = totalRequests - successfulRequests;
+        const avgResponseTime = totalRequests > 0
+            ? this.metrics.reduce((sum, m) => sum + m.totalTime, 0) / totalRequests
+            : 0;
+        return {
+            enabled: true,
+            totalRequests,
+            successfulRequests,
+            failedRequests,
+            errorRate: totalRequests > 0 ? failedRequests / totalRequests : 0,
+            avgResponseTime: avgResponseTime.toFixed(2) + "ms",
+            memoryUsage: this.getMemoryUsage(),
+            recentRequests: this.metrics.slice(-5),
+        };
+    }
+    // 获取监控指标
+    getMetrics() {
+        return this.metrics;
+    }
+    // 重置监控数据
+    reset() {
+        this.metrics = [];
+        console.log("🔄 监控数据已重置");
+    }
+    // 获取内存使用情况
+    getMemoryUsage() {
+        if (typeof process !== "undefined" && process.memoryUsage) {
+            const mem = process.memoryUsage();
+            return {
+                heapUsed: (mem.heapUsed / 1024 / 1024).toFixed(2) + "MB",
+                heapTotal: (mem.heapTotal / 1024 / 1024).toFixed(2) + "MB",
+                external: (mem.external / 1024 / 1024).toFixed(2) + "MB",
+            };
+        }
+        return { message: "内存信息不可用" };
+    }
+}
+// 纯函数：为 Server 添加监控能力
+export function withMonitoring(server, config = {}) {
+    const monitor = new NativeMonitor(config);
+    // 保存原始的 fetch 方法
+    const originalFetch = server.fetch.bind(server);
+    // 创建带监控的 fetch 方法
+    const monitoredFetch = async (req) => {
+        const startTime = performance.now();
+        const requestId = `req_${Date.now()}_${Math.random()
+            .toString(36)
+            .substr(2, 9)}`;
+        const { pathname } = new URL(req.url);
+        const method = req.method;
+        try {
+            // 调用原始 fetch
+            const response = await originalFetch(req);
+            // 记录监控指标
+            const totalTime = performance.now() - startTime;
+            monitor.recordMetrics({
+                requestId,
+                method,
+                path: pathname,
+                statusCode: response.status,
+                totalTime,
+                timestamp: Date.now(),
+                memoryUsage: (() => {
+                    if (typeof process !== "undefined" && process.memoryUsage) {
+                        const mem = process.memoryUsage();
+                        return {
+                            heapUsed: mem.heapUsed,
+                            heapTotal: mem.heapTotal,
+                        };
+                    }
+                    return { heapUsed: 0, heapTotal: 0 };
+                })(),
+            });
+            return response;
+        }
+        catch (error) {
+            // 记录错误监控指标
+            const totalTime = performance.now() - startTime;
+            monitor.recordMetrics({
+                requestId,
+                method,
+                path: pathname,
+                statusCode: 500,
+                totalTime,
+                timestamp: Date.now(),
+                memoryUsage: (() => {
+                    if (typeof process !== "undefined" && process.memoryUsage) {
+                        const mem = process.memoryUsage();
+                        return {
+                            heapUsed: mem.heapUsed,
+                            heapTotal: mem.heapTotal,
+                        };
+                    }
+                    return { heapUsed: 0, heapTotal: 0 };
+                })(),
+            });
+            throw error;
+        }
+    };
+    // 创建带监控的 Server 对象
+    const monitoredServer = {
+        ...server,
+        fetch: monitoredFetch,
+        // 监控方法
+        getMonitoringStatus: () => monitor.getStatus(),
+        getMonitoringMetrics: () => monitor.getMetrics(),
+        resetMonitoring: () => monitor.reset(),
+    };
+    return monitoredServer;
+}
+// 便捷函数：创建带监控的 Server
+export function createMonitoredServer(routes, config) {
+    const { Server } = require("../server");
+    const server = new Server(routes);
+    return withMonitoring(server, config);
+}

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