vafast 0.1.17 → 0.2.1

package/dist/middleware/cors.js

@@ -0,0 +1,30 @@
+export 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") || "";
+        // 判断：是否为允许的 Origin？
+        const isAllowedOrigin = origin === "*" || origin.includes(reqOrigin);
+        // 预检 (OPTIONS) 请求处理
+        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 });
+        }
+        // 正常请求：在 next 后添加头部
+        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;
+    };
+}

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

@@ -15,4 +15,4 @@ export declare class VafastError extends Error {
 /**
  * 组合类型: 自动注入错误处理器进行中间件组合
  */
-export declare function composeMiddleware(middleware: Middleware[], finalHandler: Handler): Handler;
+export declare function composeMiddleware(middleware: Middleware[], finalHandler: Handler): (req: Request) => Promise<Response>;

package/dist/middleware.js

@@ -0,0 +1,56 @@
+// src/middleware.ts
+import { json, mapResponse } 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;
+            // 中间件阶段
+            if (index < all.length) {
+                const mw = all[index];
+                return Promise.resolve(mw(req, () => dispatch(index + 1)));
+            }
+            // 最终 handler - 使用 mapResponse 转换返回值
+            return Promise.resolve(finalHandler(req)).then(mapResponse);
+        };
+        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/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 路由模块导出
+ */
+export { RadixRouter } from "./radix-tree";
+export { flattenNestedRoutes, normalizePath } from "../router";

package/dist/router/index.js

@@ -0,0 +1,7 @@
+/**
+ * 路由模块导出
+ */
+// Radix Tree 路由器
+export { RadixRouter } from "./radix-tree";
+// 路由工具函数
+export { flattenNestedRoutes, normalizePath } from "../router";

package/dist/router/radix-tree.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Radix Tree 路由匹配器
+ *
+ * 高性能路由匹配实现，时间复杂度 O(k)，k 为路径段数
+ *
+ * 支持的路由模式:
+ * - 静态路径: /users, /api/v1/health
+ * - 动态参数: /users/:id, /posts/:postId/comments/:commentId
+ * - 通配符: /files/*, /static/*filepath
+ */
+import type { Handler, Middleware, Method } from "../types";
+/** 路由匹配结果 */
+export interface MatchResult {
+    handler: Handler;
+    middleware: Middleware[];
+    params: Record<string, string>;
+}
+/**
+ * Radix Tree 路由器
+ *
+ * @example
+ * ```typescript
+ * const router = new RadixRouter();
+ * router.register("GET", "/users/:id", handler);
+ * const result = router.match("GET", "/users/123");
+ * // result.params = { id: "123" }
+ * ```
+ */
+export declare class RadixRouter {
+    private root;
+    constructor();
+    private createNode;
+    /** 分割路径 */
+    private splitPath;
+    /** 注册路由 */
+    register(method: Method, pattern: string, handler: Handler, middleware?: Middleware[]): void;
+    /** 匹配路由 */
+    match(method: Method, path: string): MatchResult | null;
+    /** 递归匹配节点 (优先级: 静态 > 动态参数 > 通配符) */
+    private matchNode;
+    /** 获取路径允许的 HTTP 方法 */
+    getAllowedMethods(path: string): Method[];
+    /** 查找节点（不提取参数） */
+    private findNode;
+    /** 获取所有已注册的路由 */
+    getRoutes(): Array<{
+        method: Method;
+        path: string;
+    }>;
+    private collectRoutes;
+}