vafast 0.1.10 → 0.1.12

package/dist/utils/dependency-manager.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 依赖管理器
+ * 负责按需加载和管理框架依赖
+ */
+export declare class DependencyManager {
+    private dependencyCache;
+    /**
+     * 按需获取框架依赖
+     */
+    getFrameworkDeps(framework: "vue" | "react"): Promise<any>;
+    /**
+     * 检测组件类型
+     */
+    detectComponentType(component: any): "vue" | "react";
+    /**
+     * 清除缓存
+     */
+    clearCache(): void;
+    /**
+     * 获取缓存状态
+     */
+    getCacheStatus(): Record<string, boolean>;
+}

package/dist/utils/dependency-manager.js

@@ -0,0 +1,67 @@
+/**
+ * 依赖管理器
+ * 负责按需加载和管理框架依赖
+ */
+export class DependencyManager {
+    dependencyCache = new Map();
+    /**
+     * 按需获取框架依赖
+     */
+    async getFrameworkDeps(framework) {
+        if (this.dependencyCache.has(framework)) {
+            return this.dependencyCache.get(framework);
+        }
+        console.log(`📦 按需加载 ${framework} 依赖...`);
+        try {
+            let deps;
+            switch (framework) {
+                case "vue":
+                    deps = await Promise.all([import("vue"), import("@vue/server-renderer")]);
+                    break;
+                case "react":
+                    deps = await Promise.all([import("react"), import("react-dom/server")]);
+                    break;
+                default:
+                    throw new Error(`不支持的框架: ${framework}`);
+            }
+            this.dependencyCache.set(framework, deps);
+            console.log(`✅ ${framework} 依赖加载完成`);
+            return deps;
+        }
+        catch (error) {
+            console.error(`❌ ${framework} 依赖加载失败:`, error);
+            throw error;
+        }
+    }
+    /**
+     * 检测组件类型
+     */
+    detectComponentType(component) {
+        // 简单的组件类型检测
+        if (component.render && typeof component.render === "function") {
+            return "vue";
+        }
+        if (component.$$typeof) {
+            return "react";
+        }
+        // 默认使用 Vue
+        return "vue";
+    }
+    /**
+     * 清除缓存
+     */
+    clearCache() {
+        this.dependencyCache.clear();
+        console.log("🧹 依赖缓存已清除");
+    }
+    /**
+     * 获取缓存状态
+     */
+    getCacheStatus() {
+        const status = {};
+        for (const [framework] of this.dependencyCache) {
+            status[framework] = true;
+        }
+        return status;
+    }
+}

package/dist/utils/go-await.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Go 风格的错误处理工具
+ * 将 Promise 转换为 [Error | null, T | undefined] 格式
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+/**
+ * Go 风格的错误处理工具
+ * 将 Promise 转换为 [Error | null, T | undefined] 格式
+ *
+ * @param promise 要处理的 Promise
+ * @returns [Error | null, T | undefined] 元组，第一个元素是错误，第二个是结果
+ *
+ * @example
+ * ```typescript
+ * const [error, result] = await goAwait(someAsyncFunction());
+ * if (error) {
+ *   console.error("操作失败:", error);
+ * } else {
+ *   console.log("操作成功:", result);
+ * }
+ * ```
+ */
+export declare function goAwait<T>(promise: Promise<T>): Promise<[Error | null, T | undefined]>;

package/dist/utils/go-await.js

@@ -0,0 +1,33 @@
+/**
+ * Go 风格的错误处理工具
+ * 将 Promise 转换为 [Error | null, T | undefined] 格式
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+/**
+ * Go 风格的错误处理工具
+ * 将 Promise 转换为 [Error | null, T | undefined] 格式
+ *
+ * @param promise 要处理的 Promise
+ * @returns [Error | null, T | undefined] 元组，第一个元素是错误，第二个是结果
+ *
+ * @example
+ * ```typescript
+ * const [error, result] = await goAwait(someAsyncFunction());
+ * if (error) {
+ *   console.error("操作失败:", error);
+ * } else {
+ *   console.log("操作成功:", result);
+ * }
+ * ```
+ */
+export function goAwait(promise) {
+    return promise
+        .then((data) => [null, data])
+        .catch((err) => [
+        err instanceof Error ? err : new Error(String(err)),
+        undefined,
+    ]);
+}

package/dist/utils/handle.d.ts

@@ -0,0 +1,10 @@
+/** 获取单个 Cookie 值 */
+export declare function getCookie(req: Request, key: string): string | null;
+/** 生成 Set-Cookie 头 */
+export declare function setCookie(key: string, value: string, options?: {
+    path?: string;
+    httpOnly?: boolean;
+    maxAge?: number;
+    secure?: boolean;
+}): string;
+export declare function setLocals<T extends object>(req: Request, extras: T): void;

package/dist/utils/handle.js

@@ -0,0 +1,24 @@
+import { parseCookies } from "./parsers";
+/** 获取单个 Cookie 值 */
+export function getCookie(req, key) {
+    const cookies = parseCookies(req);
+    return cookies[key] || null;
+}
+/** 生成 Set-Cookie 头 */
+export function setCookie(key, value, options = {}) {
+    let cookie = `${key}=${encodeURIComponent(value)}`;
+    if (options.path)
+        cookie += `; Path=${options.path}`;
+    if (options.httpOnly)
+        cookie += `; HttpOnly`;
+    if (options.secure)
+        cookie += `; Secure`;
+    if (options.maxAge)
+        cookie += `; Max-Age=${options.maxAge}`;
+    return cookie;
+}
+// 提供给中间件写入"局部上下文"的工具函数
+export function setLocals(req, extras) {
+    const target = req;
+    target.__locals = { ...(target.__locals ?? {}), ...extras };
+}

package/dist/utils/html-renderer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * HTML渲染工具类
+ * 提供统一的HTML模板生成功能
+ */
+export declare class HtmlRenderer {
+    /**
+     * 生成基础HTML模板
+     */
+    static generateBaseHtml(content: string, context: any, clientScriptPath?: string): string;
+    /**
+     * 生成Vue组件HTML
+     */
+    static generateVueHtml(content: string, context: any, clientScriptPath?: string): string;
+    /**
+     * 生成React组件HTML
+     */
+    static generateReactHtml(content: string, context: any, clientScriptPath?: string): string;
+}

package/dist/utils/html-renderer.js

@@ -0,0 +1,64 @@
+/**
+ * HTML渲染工具类
+ * 提供统一的HTML模板生成功能
+ */
+export class HtmlRenderer {
+    /**
+     * 生成基础HTML模板
+     */
+    static generateBaseHtml(content, context, clientScriptPath = "/client.js") {
+        return `
+      <!doctype html>
+      <html>
+        <head>
+          <meta charset="utf-8">
+          <title>Vafast SSR App</title>
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+        </head>
+        <body>
+          <div id="app">${content}</div>
+          <script>
+            window.__ROUTE_INFO__ = {
+              params: ${JSON.stringify(context.params || {})},
+              query: ${JSON.stringify(context.query || {})},
+              pathname: '${context.pathname}'
+            };
+          </script>
+          <script type="module" src="${clientScriptPath}"></script>
+        </body>
+      </html>
+    `;
+    }
+    /**
+     * 生成Vue组件HTML
+     */
+    static generateVueHtml(content, context, clientScriptPath = "/client.js") {
+        return this.generateBaseHtml(content, context, clientScriptPath);
+    }
+    /**
+     * 生成React组件HTML
+     */
+    static generateReactHtml(content, context, clientScriptPath = "/client.js") {
+        return `
+      <!doctype html>
+      <html>
+        <head>
+          <meta charset="utf-8">
+          <title>Vafast SSR App</title>
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+        </head>
+        <body>
+          <div id="root">${content}</div>
+          <script>
+            window.__ROUTE_INFO__ = {
+              params: ${JSON.stringify(context.params || {})},
+              query: ${JSON.stringify(context.query || {})},
+              pathname: '${context.pathname}'
+            };
+          </script>
+          <script type="module" src="${clientScriptPath}"></script>
+        </body>
+      </html>
+    `;
+    }
+}

package/dist/utils/parsers.d.ts

@@ -0,0 +1,36 @@
+export interface FileInfo {
+    name: string;
+    type: string;
+    size: number;
+    data: ArrayBuffer;
+}
+export interface FormData {
+    fields: Record<string, string>;
+    files: Record<string, FileInfo>;
+}
+/**
+ * 简化的请求体解析函数
+ * 优先简洁性，处理最常见的场景
+ */
+export declare function parseBody(req: Request): Promise<unknown>;
+/**
+ * 解析请求体为特定类型
+ * 提供类型安全的解析方法
+ */
+export declare function parseBodyAs<T>(req: Request): Promise<T>;
+/**
+ * 解析请求体为表单数据
+ * 专门用于处理 multipart/form-data
+ */
+export declare function parseFormData(req: Request): Promise<FormData>;
+/**
+ * 解析请求体为文件
+ * 专门用于处理文件上传
+ */
+export declare function parseFile(req: Request): Promise<FileInfo>;
+/** 获取查询字符串，直接返回对象 */
+export declare function parseQuery(req: Request): Record<string, any>;
+/** 解析请求头，返回对象 */
+export declare function parseHeaders(req: Request): Record<string, string>;
+/** 使用cookie库解析Cookie，保证可靠性 */
+export declare function parseCookies(req: Request): Record<string, string>;

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,82 @@
+/**
+ * 路径匹配工具类
+ * 提供统一的路径匹配和参数提取功能
+ */
+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>>;