vafast 0.1.17 → 0.2.1

package/dist/server/index.js

@@ -0,0 +1,11 @@
+/**
+ * 服务器模块导出
+ */
+// 主服务器类
+export { Server } from "./server";
+// 组件服务器 (SSR)
+export { ComponentServer } from "./component-server";
+// 服务器工厂
+export { ServerFactory } from "./server-factory";
+// 基类 (仅用于扩展)
+export { BaseServer } from "./base-server";

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

package/dist/server/server-factory.js

@@ -0,0 +1,70 @@
+import { Server } from "../server";
+import { ComponentServer } from "./component-server";
+/**
+ * 服务器工厂类
+ * 用于创建和管理不同类型的服务器
+ */
+export class ServerFactory {
+    servers = new Map();
+    /**
+     * 创建标准REST API服务器
+     */
+    createRestServer(routes) {
+        const server = new Server(routes);
+        this.servers.set("rest", server);
+        return server;
+    }
+    /**
+     * 创建组件服务器
+     */
+    createComponentServer(routes) {
+        const server = new ComponentServer(routes);
+        this.servers.set("component", server);
+        return server;
+    }
+    /**
+     * 获取指定类型的服务器
+     */
+    getServer(type) {
+        return this.servers.get(type);
+    }
+    /**
+     * 获取所有服务器
+     */
+    getAllServers() {
+        return this.servers;
+    }
+    /**
+     * 移除指定类型的服务器
+     */
+    removeServer(type) {
+        return this.servers.delete(type);
+    }
+    /**
+     * 清除所有服务器
+     */
+    clearServers() {
+        this.servers.clear();
+    }
+    /**
+     * 获取服务器状态信息
+     */
+    getServerStatus() {
+        const status = {};
+        for (const [name, server] of this.servers) {
+            if (server instanceof Server) {
+                status[name] = {
+                    type: "REST API",
+                    routes: server.routes?.length || 0,
+                };
+            }
+            else if (server instanceof ComponentServer) {
+                status[name] = {
+                    type: "Component",
+                    routes: server.routes?.length || 0,
+                };
+            }
+        }
+        return status;
+    }
+}

package/dist/server/server.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Vafast 核心服务器
+ *
+ * 基于 Radix Tree 的高性能路由匹配
+ * 时间复杂度: O(k)，k 为路径段数
+ */
+import type { Route, NestedRoute, Method } from "../types";
+import { BaseServer } from "./base-server";
+/**
+ * Vafast 服务器
+ *
+ * @example
+ * ```typescript
+ * const server = new Server([
+ *   { method: "GET", path: "/", handler: () => new Response("Hello") },
+ * ]);
+ * export default { fetch: server.fetch };
+ * ```
+ */
+export declare class Server extends BaseServer {
+    private router;
+    private routes;
+    constructor(routes?: (Route | NestedRoute)[]);
+    private registerRoutes;
+    /** 快速提取 pathname */
+    private extractPathname;
+    /** 处理请求 */
+    fetch: (req: Request) => Promise<Response>;
+    addRoute(route: Route): void;
+    addRoutes(routes: (Route | NestedRoute)[]): void;
+    getRoutes(): Array<{
+        method: Method;
+        path: string;
+    }>;
+}

package/dist/server/server.js

@@ -0,0 +1,97 @@
+/**
+ * Vafast 核心服务器
+ *
+ * 基于 Radix Tree 的高性能路由匹配
+ * 时间复杂度: O(k)，k 为路径段数
+ */
+import { flattenNestedRoutes } from "../router";
+import { composeMiddleware } from "../middleware";
+import { json } from "../utils/response";
+import { BaseServer } from "./base-server";
+import { RadixRouter } from "../router/radix-tree";
+/**
+ * Vafast 服务器
+ *
+ * @example
+ * ```typescript
+ * const server = new Server([
+ *   { method: "GET", path: "/", handler: () => new Response("Hello") },
+ * ]);
+ * export default { fetch: server.fetch };
+ * ```
+ */
+export class Server extends BaseServer {
+    router;
+    routes;
+    constructor(routes = []) {
+        super();
+        this.router = new RadixRouter();
+        this.routes = [];
+        if (routes.length > 0) {
+            this.registerRoutes(routes);
+        }
+    }
+    registerRoutes(routes) {
+        const flattened = flattenNestedRoutes(routes);
+        this.routes.push(...flattened);
+        for (const route of flattened) {
+            this.router.register(route.method, route.fullPath, route.handler, route.middlewareChain || []);
+        }
+        this.detectRouteConflicts(flattened);
+        this.logFlattenedRoutes(flattened);
+    }
+    /** 快速提取 pathname */
+    extractPathname(url) {
+        let start = url.indexOf("://");
+        start = start === -1 ? 0 : start + 3;
+        const pathStart = url.indexOf("/", start);
+        if (pathStart === -1)
+            return "/";
+        let end = url.indexOf("?", pathStart);
+        if (end === -1)
+            end = url.indexOf("#", pathStart);
+        if (end === -1)
+            end = url.length;
+        return url.substring(pathStart, end) || "/";
+    }
+    /** 处理请求 */
+    fetch = async (req) => {
+        const pathname = this.extractPathname(req.url);
+        const method = req.method;
+        const match = this.router.match(method, pathname);
+        if (match) {
+            req.params = match.params;
+            // 组合全局中间件 + 路由中间件（mapResponse 在 composeMiddleware 内部处理）
+            const allMiddleware = [...this.globalMiddleware, ...match.middleware];
+            const handler = composeMiddleware(allMiddleware, match.handler);
+            return handler(req);
+        }
+        // 405 Method Not Allowed
+        const allowedMethods = this.router.getAllowedMethods(pathname);
+        if (allowedMethods.length > 0) {
+            return json({
+                success: false,
+                error: "Method Not Allowed",
+                message: `Method ${method} not allowed for this endpoint`,
+                allowedMethods,
+            }, 405, { Allow: allowedMethods.join(", ") });
+        }
+        // 404 Not Found
+        return json({ success: false, error: "Not Found" }, 404);
+    };
+    addRoute(route) {
+        const flattenedRoute = {
+            ...route,
+            fullPath: route.path,
+            middlewareChain: route.middleware || [],
+        };
+        this.routes.push(flattenedRoute);
+        this.router.register(route.method, route.path, route.handler, route.middleware || []);
+    }
+    addRoutes(routes) {
+        this.registerRoutes(routes);
+    }
+    getRoutes() {
+        return this.router.getRoutes();
+    }
+}

package/dist/types/component-route.d.ts

@@ -0,0 +1,25 @@
+import type { Middleware } from "./route";
+/**
+ * 组件路由配置
+ * 支持声明式的组件关联
+ */
+export interface ComponentRoute {
+    path: string;
+    component: () => Promise<any>;
+    middleware?: Middleware[];
+}
+/**
+ * 嵌套组件路由配置
+ */
+export interface NestedComponentRoute {
+    path: string;
+    middleware?: Middleware[];
+    children?: (ComponentRoute | NestedComponentRoute)[];
+}
+/**
+ * 扁平化后的组件路由
+ */
+export interface FlattenedComponentRoute extends ComponentRoute {
+    fullPath: string;
+    middlewareChain: Middleware[];
+}

package/dist/types/component-route.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export type { Method, Handler, Route, NestedRoute, Middleware, FlattenedRoute, ResponseBody, } from "./types";
+export type { BaseRouteConfig, ExtendedRouteConfig, NestedRouteConfig, TypedRoute, CompatibleRoute, } from "./route";
+export { createTypedRoute, isTypedRoute } from "./route";
+export * from "./component-route";
+export * from "./schema";

package/dist/types/index.js

@@ -0,0 +1,4 @@
+export { createTypedRoute, isTypedRoute } from "./route";
+// 组件路由和 Schema 类型
+export * from "./component-route";
+export * from "./schema";

package/dist/types/route.d.ts

@@ -0,0 +1,39 @@
+import { Route, ResponseBody } from "./types";
+export interface Middleware {
+    (req: Request, next: () => Promise<Response>): Promise<Response>;
+}
+export interface BaseRouteConfig {
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD";
+    path: string;
+    handler: (req: Request) => ResponseBody | Promise<ResponseBody>;
+}
+export interface ExtendedRouteConfig extends BaseRouteConfig {
+    middleware?: Middleware[];
+    body?: any;
+    query?: any;
+    params?: any;
+    headers?: any;
+    cookies?: any;
+    docs?: {
+        description?: string;
+        tags?: string[];
+        security?: any[];
+        responses?: Record<string, any>;
+    };
+    timeout?: number;
+    maxBodySize?: string;
+    [key: string]: any;
+}
+export interface NestedRouteConfig {
+    path: string;
+    middleware?: Middleware[];
+    children?: (NestedRouteConfig | ExtendedRouteConfig)[];
+}
+export type TypedRoute = ExtendedRouteConfig;
+export type CompatibleRoute = Route | TypedRoute;
+export interface FlattenedRoute extends ExtendedRouteConfig {
+    fullPath: string;
+    middlewareChain: Middleware[];
+}
+export declare function createTypedRoute(config: ExtendedRouteConfig): ExtendedRouteConfig;
+export declare function isTypedRoute(route: any): route is TypedRoute;

package/dist/types/route.js

@@ -0,0 +1,11 @@
+// 导出一些实际的函数，确保 JavaScript 代码生成
+export function createTypedRoute(config) {
+    return config;
+}
+export function isTypedRoute(route) {
+    return (route &&
+        typeof route === "object" &&
+        "method" in route &&
+        "path" in route &&
+        "handler" in route);
+}

package/dist/types/schema.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Schema 类型定义
+ *
+ * 使用 TSchema 约束替代 any，提供完整的类型安全
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+import type { TSchema, Static } from "@sinclair/typebox";
+/**
+ * 路由 Schema 配置
+ * 所有 schema 字段使用 TSchema 约束
+ */
+export interface RouteSchema {
+    body?: TSchema;
+    query?: TSchema;
+    params?: TSchema;
+    headers?: TSchema;
+    cookies?: TSchema;
+}
+/**
+ * 从 Schema 配置推导出具体类型
+ */
+export type InferSchema<T extends RouteSchema> = {
+    body: T["body"] extends TSchema ? Static<T["body"]> : unknown;
+    query: T["query"] extends TSchema ? Static<T["query"]> : Record<string, string>;
+    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>;
+};
+/**
+ * Handler 上下文类型
+ */
+export interface HandlerContext<T extends RouteSchema = RouteSchema> {
+    /** 原始请求对象 */
+    req: Request;
+    /** 请求体 (经过 schema 验证) */
+    body: InferSchema<T>["body"];
+    /** 查询参数 (经过 schema 验证) */
+    query: InferSchema<T>["query"];
+    /** 路径参数 (经过 schema 验证) */
+    params: InferSchema<T>["params"];
+    /** 请求头 (经过 schema 验证) */
+    headers: InferSchema<T>["headers"];
+    /** Cookie (经过 schema 验证) */
+    cookies: InferSchema<T>["cookies"];
+}
+/**
+ * 带额外上下文的 Handler 上下文类型
+ * 用于中间件注入额外数据
+ */
+export type HandlerContextWithExtra<T extends RouteSchema = RouteSchema, TExtra extends Record<string, unknown> = Record<string, never>> = HandlerContext<T> & TExtra;
+/**
+ * Handler 函数类型
+ */
+export type TypedHandler<T extends RouteSchema = RouteSchema, TExtra extends Record<string, unknown> = Record<string, never>, TReturn = unknown> = (ctx: HandlerContextWithExtra<T, TExtra>) => TReturn | Promise<TReturn>;
+/**
+ * 扩展的路由配置 (包含 schema)
+ */
+export interface TypedRouteConfig<T extends RouteSchema = RouteSchema> {
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD";
+    path: string;
+    schema?: T;
+    handler: (req: Request) => Response | Promise<Response>;
+    middleware?: Array<(req: Request, next: () => Promise<Response>) => Promise<Response>>;
+    docs?: {
+        description?: string;
+        tags?: string[];
+        security?: unknown[];
+        responses?: Record<string, unknown>;
+    };
+    timeout?: number;
+    maxBodySize?: string;
+}

package/dist/types/schema.js

@@ -0,0 +1,10 @@
+/**
+ * Schema 类型定义
+ *
+ * 使用 TSchema 约束替代 any，提供完整的类型安全
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+export {};

package/dist/types/types.d.ts

@@ -0,0 +1,22 @@
+export type Method = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD";
+/** 支持的响应类型 - 由 mapResponse 自动转换 */
+export type ResponseBody = Response | string | number | boolean | object | null | undefined | ReadableStream | Blob | ArrayBuffer;
+/** Handler 返回值（支持同步/异步，任意类型） */
+export type Handler = (req: Request, params?: Record<string, string>, user?: Record<string, any>) => ResponseBody | Promise<ResponseBody>;
+/** 中间件（返回值必须是 Response 或 Promise<Response>） */
+export type Middleware = (req: Request, next: () => Promise<Response>) => Response | Promise<Response>;
+export interface Route {
+    method: Method;
+    path: string;
+    handler: Handler;
+    middleware?: Middleware[];
+}
+export interface NestedRoute {
+    path: string;
+    middleware?: Middleware[];
+    children?: (NestedRoute | Route)[];
+}
+export interface FlattenedRoute extends Route {
+    fullPath: string;
+    middlewareChain: Middleware[];
+}

package/dist/types/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/base64url.js

@@ -0,0 +1,11 @@
+export function base64urlEncode(str) {
+    return btoa(str)
+        .replace(/=/g, "") // ✅ 删除填充
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_");
+}
+export function base64urlDecode(str) {
+    const pad = str.length % 4 === 0 ? "" : "=".repeat(4 - (str.length % 4));
+    const base64 = str.replace(/-/g, "+").replace(/_/g, "/") + pad;
+    return atob(base64);
+}

package/dist/utils/create-handler.d.ts

@@ -0,0 +1,74 @@
+/**
+ * 类型安全的路由处理器工厂
+ *
+ * 非柯里化设计，API 更简洁
+ *
+ * @author Framework Team
+ * @version 3.0.0
+ * @license MIT
+ */
+import type { RouteSchema, HandlerContext, HandlerContextWithExtra } from "../types/schema";
+/** 空 schema 的上下文类型 */
+type EmptySchemaContext = {
+    req: Request;
+    body: unknown;
+    query: Record<string, string>;
+    params: Record<string, string>;
+    headers: Record<string, string>;
+    cookies: Record<string, string>;
+};
+/**
+ * 创建类型安全的路由处理器
+ *
+ * @example
+ * ```typescript
+ * // 无 schema - 直接传入 handler
+ * createHandler(({ params }) => `User: ${params.id}`)
+ *
+ * // 有 schema - 传入 schema 和 handler
+ * createHandler(
+ *   { body: Type.Object({ name: Type.String() }) },
+ *   ({ body }) => ({ hello: body.name })
+ * )
+ * ```
+ */
+export declare function createHandler<R>(handler: (ctx: EmptySchemaContext) => R | Promise<R>): (req: Request) => Promise<Response>;
+export declare function createHandler<const T extends RouteSchema, R>(schema: T, handler: (ctx: HandlerContext<T>) => R | Promise<R>): (req: Request) => Promise<Response>;
+/**
+ * 创建带额外上下文的路由处理器
+ *
+ * 用于中间件注入额外数据的场景
+ *
+ * @example
+ * ```typescript
+ * // 定义中间件注入的类型
+ * type AuthContext = { user: { id: string; role: string } };
+ *
+ * // 无 schema
+ * createHandlerWithExtra<AuthContext>(({ user }) => {
+ *   return { userId: user.id };
+ * })
+ *
+ * // 有 schema
+ * createHandlerWithExtra<AuthContext>(
+ *   { body: Type.Object({ action: Type.String() }) },
+ *   ({ body, user }) => ({ success: true, userId: user.id })
+ * )
+ * ```
+ */
+export declare function createHandlerWithExtra<TExtra extends Record<string, unknown> = Record<string, never>, R = unknown>(handler: (ctx: EmptySchemaContext & TExtra) => R | Promise<R>): (req: Request) => Promise<Response>;
+export declare function createHandlerWithExtra<TExtra extends Record<string, unknown> = Record<string, never>, const T extends RouteSchema = RouteSchema, R = unknown>(schema: T, handler: (ctx: HandlerContextWithExtra<T, TExtra>) => R | Promise<R>): (req: Request) => Promise<Response>;
+/**
+ * 简单的路由处理器 (无 schema 验证，只有 req)
+ *
+ * @example
+ * ```typescript
+ * simpleHandler(({ req }) => {
+ *   return { message: "Hello World" };
+ * })
+ * ```
+ */
+export declare function simpleHandler<R>(handler: (ctx: {
+    req: Request;
+}) => R | Promise<R>): (req: Request) => Promise<Response>;
+export {};