vafast 0.1.17 → 0.2.3

package/dist/utils/parsers.js

@@ -0,0 +1,126 @@
+// src/parsers.ts
+import qs from "qs";
+import cookie from "cookie";
+/**
+ * 简化的请求体解析函数
+ * 优先简洁性，处理最常见的场景
+ */
+export 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(); // fallback
+}
+/**
+ * 解析 multipart/form-data 格式
+ * 支持文件上传和普通表单字段
+ */
+async function parseMultipartFormData(req) {
+    const formData = await req.formData();
+    const result = {
+        fields: {},
+        files: {},
+    };
+    for (const [key, value] of formData.entries()) {
+        if (typeof value === "object" &&
+            value !== null &&
+            "name" in value &&
+            "type" in value &&
+            "size" in value) {
+            // 处理文件
+            const file = value;
+            const arrayBuffer = await file.arrayBuffer();
+            result.files[key] = {
+                name: file.name,
+                type: file.type,
+                size: file.size,
+                data: arrayBuffer,
+            };
+        }
+        else {
+            // 处理普通字段
+            result.fields[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * 解析请求体为特定类型
+ * 提供类型安全的解析方法
+ */
+export async function parseBodyAs(req) {
+    const body = await parseBody(req);
+    return body;
+}
+/**
+ * 解析请求体为表单数据
+ * 专门用于处理 multipart/form-data
+ */
+export async function parseFormData(req) {
+    const contentType = req.headers.get("content-type") || "";
+    if (!contentType.includes("multipart/form-data")) {
+        throw new Error("请求不是 multipart/form-data 格式");
+    }
+    return await parseMultipartFormData(req);
+}
+/**
+ * 解析请求体为文件
+ * 专门用于处理文件上传
+ */
+export async function parseFile(req) {
+    const contentType = req.headers.get("content-type") || "";
+    if (!contentType.includes("multipart/form-data")) {
+        throw new Error("请求不是 multipart/form-data 格式");
+    }
+    const formData = await parseMultipartFormData(req);
+    const fileKeys = Object.keys(formData.files);
+    if (fileKeys.length === 0) {
+        throw new Error("请求中没有文件");
+    }
+    if (fileKeys.length > 1) {
+        throw new Error("请求中包含多个文件，请使用 parseFormData");
+    }
+    return formData.files[fileKeys[0]];
+}
+/** 获取查询字符串，直接返回对象 */
+export function parseQuery(req) {
+    const url = new URL(req.url);
+    return qs.parse(url.search.slice(1)); // 去掉开头的 ?
+}
+/** 解析请求头，返回对象 */
+export function parseHeaders(req) {
+    const headers = {};
+    req.headers.forEach((value, key) => {
+        if (value !== undefined && value !== null) {
+            headers[key] = value;
+        }
+    });
+    return headers;
+}
+/** 使用cookie库解析Cookie，保证可靠性 */
+export function parseCookies(req) {
+    const cookieHeader = req.headers.get("cookie");
+    if (!cookieHeader)
+        return {};
+    try {
+        const parsed = cookie.parse(cookieHeader);
+        // 过滤掉undefined和null值
+        const result = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            if (value !== undefined && value !== null) {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        console.error("Cookie解析失败:", error);
+        console.error("原始Cookie字符串:", cookieHeader);
+        return {};
+    }
+}

package/dist/utils/path-matcher.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 路径匹配工具类
+ * 提供统一的路径匹配和参数提取功能
+ */
+export declare class PathMatcher {
+    /**
+     * 路径匹配
+     */
+    static matchPath(pattern: string, path: string): boolean;
+    /**
+     * 提取路径参数
+     */
+    static extractParams(pattern: string, path: string): Record<string, string>;
+    /**
+     * 计算路径特异性分数
+     * 用于路由排序：静态 > 动态(:param) > 通配符(*)
+     */
+    static calculatePathScore(path: string): number;
+    /**
+     * 判断两个路径是否可能冲突
+     */
+    static pathsMayConflict(path1: string, path2: string): boolean;
+}

package/dist/utils/path-matcher.js

@@ -0,0 +1,83 @@
+/**
+ * 路径匹配工具类
+ * 提供统一的路径匹配和参数提取功能
+ */
+export class PathMatcher {
+    /**
+     * 路径匹配
+     */
+    static 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;
+    }
+    /**
+     * 提取路径参数
+     */
+    static 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;
+    }
+    /**
+     * 计算路径特异性分数
+     * 用于路由排序：静态 > 动态(:param) > 通配符(*)
+     */
+    static calculatePathScore(path) {
+        const parts = path.split("/").filter(Boolean);
+        let score = 0;
+        for (const p of parts) {
+            if (p === "*")
+                score += 1; // 最弱
+            else if (p.startsWith(":"))
+                score += 2; // 中等
+            else
+                score += 3; // 静态最强
+        }
+        // 更长的路径更具体，略微提升
+        return score * 10 + parts.length;
+    }
+    /**
+     * 判断两个路径是否可能冲突
+     */
+    static 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;
+    }
+}

package/dist/utils/request-validator.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 请求解析和验证器
+ *
+ * 解析handler的req参数，使用Ultra验证器进行验证，
+ * 并类型安全地返回解析出来的值
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+import type { TSchema } from "@sinclair/typebox";
+import type { Static } from "@sinclair/typebox";
+import { type SchemaConfig } from "./validators/schema-validators-ultra";
+export interface RequestData {
+    body: unknown;
+    query: unknown;
+    params: Record<string, string>;
+    headers: Record<string, string>;
+    cookies: Record<string, string>;
+}
+export interface ValidatedRequestData<T extends SchemaConfig> {
+    body: T["body"] extends TSchema ? Static<T["body"]> : unknown;
+    query: T["query"] extends TSchema ? Static<T["query"]> : unknown;
+    params: T["params"] extends TSchema ? Static<T["params"]> : Record<string, string>;
+    headers: T["headers"] extends TSchema ? Static<T["headers"]> : Record<string, string>;
+    cookies: T["cookies"] extends TSchema ? Static<T["cookies"]> : Record<string, string>;
+}
+export interface ValidationResult<T extends SchemaConfig> {
+    success: boolean;
+    data?: ValidatedRequestData<T>;
+    errors?: Array<{
+        field: keyof SchemaConfig;
+        message: string;
+    }>;
+}
+/**
+ * 解析Request对象，提取所有相关数据
+ * @param request Request对象
+ * @param params 路径参数（可选）
+ * @returns 解析后的请求数据
+ */
+export declare function parseRequest(request: Request, params?: Record<string, string>): Promise<RequestData>;
+/**
+ * 验证请求数据
+ * @param config Schema配置
+ * @param requestData 请求数据
+ * @returns 验证结果
+ */
+export declare function validateRequest<T extends SchemaConfig>(config: T, requestData: RequestData): ValidationResult<T>;
+/**
+ * 完整的请求解析和验证流程
+ * @param request Request对象
+ * @param config Schema配置
+ * @param params 路径参数（可选）
+ * @returns 验证结果
+ */
+export declare function parseAndValidateRequest<T extends SchemaConfig>(request: Request, config: T, params?: Record<string, string>): Promise<ValidationResult<T>>;
+/**
+ * 创建类型安全的请求验证器工厂
+ * @param config Schema配置
+ * @returns 验证器函数
+ */
+export declare function createRequestValidator<T extends SchemaConfig>(config: T): (request: Request, params?: Record<string, string>) => Promise<ValidationResult<T>>;

package/dist/utils/request-validator.js

@@ -0,0 +1,94 @@
+/**
+ * 请求解析和验证器
+ *
+ * 解析handler的req参数，使用Ultra验证器进行验证，
+ * 并类型安全地返回解析出来的值
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+import { validateAllSchemasUltra, } from "./validators/schema-validators-ultra";
+import { parseBody, parseQuery, parseHeaders, parseCookies } from "./parsers";
+/**
+ * 解析Request对象，提取所有相关数据
+ * @param request Request对象
+ * @param params 路径参数（可选）
+ * @returns 解析后的请求数据
+ */
+export async function parseRequest(request, params) {
+    const requestData = {
+        body: undefined,
+        query: parseQuery(request),
+        params: params || {},
+        headers: parseHeaders(request),
+        cookies: parseCookies(request),
+    };
+    // 对于非GET请求，尝试解析请求体
+    if (request.method !== "GET" && request.method !== "HEAD") {
+        requestData.body = await parseBody(request);
+    }
+    return requestData;
+}
+/**
+ * 验证请求数据
+ * @param config Schema配置
+ * @param requestData 请求数据
+ * @returns 验证结果
+ */
+export function validateRequest(config, requestData) {
+    try {
+        const validatedData = validateAllSchemasUltra(config, requestData);
+        return {
+            success: true,
+            data: validatedData,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            errors: [
+                {
+                    field: "unknown",
+                    message: error instanceof Error ? error.message : "验证失败",
+                },
+            ],
+        };
+    }
+}
+/**
+ * 完整的请求解析和验证流程
+ * @param request Request对象
+ * @param config Schema配置
+ * @param params 路径参数（可选）
+ * @returns 验证结果
+ */
+export async function parseAndValidateRequest(request, config, params) {
+    try {
+        // 1. 解析请求
+        const requestData = await parseRequest(request, params);
+        // 2. 验证数据
+        return validateRequest(config, requestData);
+    }
+    catch (error) {
+        return {
+            success: false,
+            errors: [
+                {
+                    field: "unknown",
+                    message: error instanceof Error ? error.message : "请求解析失败",
+                },
+            ],
+        };
+    }
+}
+/**
+ * 创建类型安全的请求验证器工厂
+ * @param config Schema配置
+ * @returns 验证器函数
+ */
+export function createRequestValidator(config) {
+    return async (request, params) => {
+        return parseAndValidateRequest(request, config, params);
+    };
+}

package/dist/utils/response.d.ts

@@ -0,0 +1,17 @@
+/** 生成 JSON 响应 */
+export declare function json(data: unknown, status?: number, headers?: HeadersInit): Response;
+/**
+ * 类型特化的响应映射
+ * 根据返回值类型直接生成 Response，避免不必要的检查
+ */
+export declare function mapResponse(response: unknown): Response;
+/** 生成重定向响应 */
+export declare function redirect(location: string, status?: 301 | 302): Response;
+/** 生成纯文本响应 */
+export declare function text(content: string, status?: number, headers?: HeadersInit): Response;
+/** 生成HTML响应 */
+export declare function html(content: string, status?: number, headers?: HeadersInit): Response;
+/** 生成空响应（204 No Content） */
+export declare function empty(status?: number, headers?: HeadersInit): Response;
+/** 生成流式响应 */
+export declare function stream(stream: ReadableStream, status?: number, headers?: HeadersInit): Response;

package/dist/utils/response.js

@@ -0,0 +1,110 @@
+// src/response.ts
+/** 生成 JSON 响应 */
+export function json(data, status = 200, headers = {}) {
+    // 优化：只在有自定义 headers 时才创建 Headers 对象
+    if (Object.keys(headers).length === 0) {
+        return new Response(JSON.stringify(data), {
+            status,
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    // 有自定义 headers 时才创建 Headers 对象
+    const h = new Headers({
+        "Content-Type": "application/json",
+        ...headers,
+    });
+    return new Response(JSON.stringify(data), {
+        status,
+        headers: h,
+    });
+}
+// JSON 响应的预创建 headers（避免每次创建）
+const JSON_HEADERS = { "Content-Type": "application/json" };
+const TEXT_HEADERS = { "Content-Type": "text/plain" };
+/**
+ * 类型特化的响应映射
+ * 根据返回值类型直接生成 Response，避免不必要的检查
+ */
+export function mapResponse(response) {
+    // 快速路径：已经是 Response
+    if (response instanceof Response)
+        return response;
+    // 使用 constructor.name 进行类型判断（比 instanceof 更快）
+    switch (response?.constructor?.name) {
+        case "String":
+            return new Response(response, { headers: TEXT_HEADERS });
+        case "Object":
+        case "Array":
+            return new Response(JSON.stringify(response), { headers: JSON_HEADERS });
+        case "Number":
+        case "Boolean":
+            return new Response(String(response), { headers: TEXT_HEADERS });
+        case undefined:
+            // null 或 undefined
+            return new Response(null, { status: 204 });
+        case "ReadableStream":
+            return new Response(response);
+        case "Blob":
+            return new Response(response);
+        case "ArrayBuffer":
+            return new Response(response);
+        case "Uint8Array":
+            return new Response(response);
+        default:
+            // Promise 处理
+            if (response instanceof Promise) {
+                return response.then(mapResponse);
+            }
+            // 其他情况尝试 JSON
+            return new Response(JSON.stringify(response), { headers: JSON_HEADERS });
+    }
+}
+/** 生成重定向响应 */
+export function redirect(location, status = 302) {
+    return new Response(null, {
+        status,
+        headers: {
+            Location: location,
+        },
+    });
+}
+/** 生成纯文本响应 */
+export function text(content, status = 200, headers = {}) {
+    const h = new Headers({
+        "Content-Type": "text/plain; charset=utf-8",
+        ...headers,
+    });
+    return new Response(content, {
+        status,
+        headers: h,
+    });
+}
+/** 生成HTML响应 */
+export function html(content, status = 200, headers = {}) {
+    const h = new Headers({
+        "Content-Type": "text/html; charset=utf-8",
+        ...headers,
+    });
+    return new Response(content, {
+        status,
+        headers: h,
+    });
+}
+/** 生成空响应（204 No Content） */
+export function empty(status = 204, headers = {}) {
+    return new Response(null, {
+        status,
+        headers,
+    });
+}
+/** 生成流式响应 */
+export function stream(stream, status = 200, headers = {}) {
+    const h = new Headers({
+        "Content-Type": "application/octet-stream",
+        ...headers,
+    });
+    return new Response(stream, {
+        status,
+        headers: h,
+    });
+}

package/dist/utils/validators/schema-validator.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Schema配置验证器
+ *
+ * 使用validateSchema函数对SchemaConfig结构的数据进行验证
+ * 提供统一的验证接口和错误处理
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+import type { TSchema } from "@sinclair/typebox";
+import { type ValidationResult } from "./validators";
+export interface SchemaConfig {
+    body?: TSchema;
+    query?: TSchema;
+    params?: TSchema;
+    headers?: TSchema;
+    cookies?: TSchema;
+}
+export interface RequestData {
+    body?: unknown;
+    query?: unknown;
+    params?: unknown;
+    headers?: unknown;
+    cookies?: unknown;
+}
+export interface SchemaValidationResult {
+    success: boolean;
+    data?: {
+        body?: unknown;
+        query?: unknown;
+        params?: unknown;
+        headers?: unknown;
+        cookies?: unknown;
+    };
+    errors?: Array<{
+        field: keyof SchemaConfig;
+        error: ValidationResult<unknown>;
+    }>;
+}
+/**
+ * 使用SchemaConfig验证完整的请求数据
+ * @param config Schema配置
+ * @param data 请求数据
+ * @returns 验证结果
+ */
+export declare function validateSchemaConfig(config: SchemaConfig, data: RequestData): SchemaValidationResult;
+/**
+ * 异步验证SchemaConfig（支持异步验证器）
+ * @param config Schema配置
+ * @param data 请求数据
+ * @returns Promise<验证结果>
+ */
+export declare function validateSchemaConfigAsync(config: SchemaConfig, data: RequestData): Promise<SchemaValidationResult>;
+/**
+ * 创建验证器工厂函数
+ * @param config Schema配置
+ * @returns 验证器函数
+ */
+export declare function createSchemaValidator(config: SchemaConfig): (data: RequestData) => SchemaValidationResult;
+/**
+ * 创建异步验证器工厂函数
+ * @param config Schema配置
+ * @returns 异步验证器函数
+ */
+export declare function createAsyncSchemaValidator(config: SchemaConfig): (data: RequestData) => Promise<SchemaValidationResult>;