befly 3.10.18 → 3.11.1

package/{hooks/parser.ts → dist/hooks/parser.js}

@@ -1,16 +1,9 @@
-// 类型导入
-import type { Hook } from "../types/hook.ts";
-
 // 外部依赖
-import { isPlainObject, isEmpty } from "es-toolkit/compat";
 import { XMLParser } from "fast-xml-parser";
-
+import { ErrorResponse } from "../utils/response";
 // 相对导入
-import { pickFields } from "../utils/pickFields.ts";
-import { ErrorResponse } from "../utils/response.ts";
-
+import { isEmpty, isPlainObject, pickFields } from "../utils/util";
 const xmlParser = new XMLParser();
-
 /**
  * 请求参数解析钩子
  * - GET 请求：解析 URL 查询参数
@@ -19,48 +12,52 @@ const xmlParser = new XMLParser();
  * - rawBody: true 时跳过解析，由 handler 自行处理原始请求
  */
 export default {
+    name: "parser",
+    enable: true,
     deps: ["auth"],
     handler: async (befly, ctx) => {
-        if (!ctx.api) return;
-
+        if (!ctx.api)
+            return;
         // rawBody 模式：跳过解析，保留原始请求供 handler 自行处理
         // 适用于：微信回调、支付回调、webhook 等需要手动解密/验签的场景
         if (ctx.api.rawBody) {
             ctx.body = {};
             return;
         }
-
         // GET 请求：解析查询参数
         if (ctx.req.method === "GET") {
             const url = new URL(ctx.req.url);
             const params = Object.fromEntries(url.searchParams);
             if (isPlainObject(ctx.api.fields) && !isEmpty(ctx.api.fields)) {
                 ctx.body = pickFields(params, Object.keys(ctx.api.fields));
-            } else {
+            }
+            else {
                 ctx.body = params;
             }
-        } else if (ctx.req.method === "POST") {
+        }
+        else if (ctx.req.method === "POST") {
             // POST 请求：解析请求体
             const contentType = ctx.req.headers.get("content-type") || "";
             // 获取 URL 查询参数（POST 请求也可能带参数）
             const url = new URL(ctx.req.url);
             const queryParams = Object.fromEntries(url.searchParams);
-
             try {
                 // JSON 格式
                 if (contentType.includes("application/json")) {
-                    const body = (await ctx.req.json()) as Record<string, any>;
+                    const body = (await ctx.req.json());
                     // 合并 URL 参数和请求体（请求体优先）
                     const merged = { ...queryParams, ...body };
                     if (isPlainObject(ctx.api.fields) && !isEmpty(ctx.api.fields)) {
                         ctx.body = pickFields(merged, Object.keys(ctx.api.fields));
-                    } else {
+                    }
+                    else {
                         ctx.body = merged;
                     }
-                } else if (contentType.includes("application/xml") || contentType.includes("text/xml")) {
+                }
+                else if (contentType.includes("application/xml") || contentType.includes("text/xml")) {
                     // XML 格式
                     const text = await ctx.req.text();
-                    const parsed = xmlParser.parse(text) as Record<string, any>;
+                    const parsed = xmlParser.parse(text);
                     // 提取根节点内容（如 xml），使 body 扁平化
                     const rootKey = Object.keys(parsed)[0];
                     const body = rootKey && typeof parsed[rootKey] === "object" ? parsed[rootKey] : parsed;
@@ -68,39 +65,28 @@ export default {
                     const merged = { ...queryParams, ...body };
                     if (isPlainObject(ctx.api.fields) && !isEmpty(ctx.api.fields)) {
                         ctx.body = pickFields(merged, Object.keys(ctx.api.fields));
-                    } else {
+                    }
+                    else {
                         ctx.body = merged;
                     }
-                } else {
+                }
+                else {
                     // 不支持的 Content-Type
-                    ctx.response = ErrorResponse(
-                        ctx,
-                        "无效的请求参数格式",
-                        1,
-                        null,
-                        {
-                            location: "content-type",
-                            value: contentType
-                        },
-                        "parser"
-                    );
+                    ctx.response = ErrorResponse(ctx, "无效的请求参数格式", 1, null, {
+                        location: "content-type",
+                        value: contentType
+                    }, "parser");
                     return;
                 }
-            } catch {
+            }
+            catch {
                 // 解析失败：属于客户端输入错误，返回安全 detail（不回传异常栈/原始 body）
-                ctx.response = ErrorResponse(
-                    ctx,
-                    "无效的请求参数格式",
-                    1,
-                    null,
-                    {
-                        location: "body",
-                        reason: contentType.includes("application/json") ? "invalid_json" : contentType.includes("xml") ? "invalid_xml" : "invalid_body"
-                    },
-                    "parser"
-                );
+                ctx.response = ErrorResponse(ctx, "无效的请求参数格式", 1, null, {
+                    location: "body",
+                    reason: contentType.includes("application/json") ? "invalid_json" : contentType.includes("xml") ? "invalid_xml" : "invalid_body"
+                }, "parser");
                 return;
             }
         }
     }
-} satisfies Hook;
+};

package/dist/hooks/permission.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 权限检查钩子
+ * - 接口无需权限（auth=false）：直接通过
+ * - 用户未登录：返回 401
+ * - 开发者角色（dev）：最高权限，直接通过
+ * - 其他角色：检查 Redis 中的角色权限集合
+ */
+declare const _default: {
+    name: string;
+    enable: true;
+    deps: string[];
+    handler: (befly: import("../types/befly").BeflyContext, ctx: import("../types/context").RequestContext<Record<string, any>>) => Promise<void>;
+};
+export default _default;

package/{hooks/permission.ts → dist/hooks/permission.js}

@@ -1,11 +1,7 @@
-// 类型导入
-import type { Hook } from "../types/hook.ts";
-
-import { CacheKeys } from "../lib/cacheKeys.ts";
-import { Logger } from "../lib/logger.ts";
+import { CacheKeys } from "../lib/cacheKeys";
+import { Logger } from "../lib/logger";
 // 相对导入
-import { ErrorResponse } from "../utils/response.ts";
-
+import { ErrorResponse } from "../utils/response";
 /**
  * 权限检查钩子
  * - 接口无需权限（auth=false）：直接通过
@@ -14,52 +10,47 @@ import { ErrorResponse } from "../utils/response.ts";
  * - 其他角色：检查 Redis 中的角色权限集合
  */
 export default {
+    name: "permission",
+    enable: true,
     deps: ["validator"],
     handler: async (befly, ctx) => {
-        if (!ctx.api) return;
-
+        if (!ctx.api)
+            return;
         // 1. 接口无需权限
         if (ctx.api.auth === false) {
             return;
         }
-
         // 2. 用户未登录
         if (!ctx.user || !ctx.user.id) {
             ctx.response = ErrorResponse(ctx, "未登录", 1, null, null, "auth");
             return;
         }
-
         // 3. 开发者权限（最高权限）
         if (ctx.user.roleCode === "dev") {
             return;
         }
-
         // 4. 角色权限检查
         // apiPath 在 apiHandler 中已统一生成并写入 ctx.route
         const apiPath = ctx.route;
         const roleCode = ctx.user.roleCode;
-
         let hasPermission = false;
         if (roleCode && befly.redis) {
             try {
                 // 极简方案：每个角色一个 Set，直接判断成员是否存在
                 const roleApisKey = CacheKeys.roleApis(roleCode);
                 hasPermission = await befly.redis.sismember(roleApisKey, apiPath);
-            } catch (err: any) {
+            }
+            catch (err) {
                 // Redis 异常：记录到 error 日志文件（不回传给客户端），并降级为拒绝访问
-                Logger.error(
-                    {
-                        event: "hook_permission_redis_error",
-                        apiPath: apiPath,
-                        roleCode: roleCode,
-                        err: err
-                    },
-                    "hook permission redis error"
-                );
+                Logger.error({
+                    event: "hook_permission_redis_error",
+                    apiPath: apiPath,
+                    roleCode: roleCode,
+                    err: err
+                }, "hook permission redis error");
                 hasPermission = false;
             }
         }
-
         if (!hasPermission) {
             const apiNameLabel = typeof ctx.api.name === "string" && ctx.api.name.length > 0 ? ctx.api.name : null;
             const apiPathLabel = typeof apiPath === "string" && apiPath.length > 0 ? apiPath : null;
@@ -68,4 +59,4 @@ export default {
             return;
         }
     }
-} satisfies Hook;
+};

package/dist/hooks/validator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 参数验证钩子
+ * 根据 API 定义的 fields 和 required 验证请求参数
+ */
+declare const _default: {
+    name: string;
+    enable: true;
+    deps: string[];
+    handler: (befly: import("../types/befly").BeflyContext, ctx: import("../types/context").RequestContext<Record<string, any>>) => Promise<void>;
+};
+export default _default;

package/{hooks/validator.ts → dist/hooks/validator.js}

@@ -1,38 +1,33 @@
-// 类型导入
-import type { Hook } from "../types/hook.ts";
-
 // 相对导入
-import { Validator } from "../lib/validator.ts";
-import { ErrorResponse } from "../utils/response.ts";
-
+import { Validator } from "../lib/validator";
+import { ErrorResponse } from "../utils/response";
 /**
  * 参数验证钩子
  * 根据 API 定义的 fields 和 required 验证请求参数
  */
 export default {
+    name: "validator",
+    enable: true,
     deps: ["parser"],
     handler: async (befly, ctx) => {
-        if (!ctx.api) return;
-
+        if (!ctx.api)
+            return;
         // 无需验证
         if (!ctx.api.fields) {
             return;
         }
-
         // 应用字段默认值
         for (const [field, fieldDef] of Object.entries(ctx.api.fields)) {
             // 字段未传值且定义了默认值时，应用默认值
-            if (ctx.body[field] === undefined && (fieldDef as any)?.default !== undefined && (fieldDef as any)?.default !== null) {
-                ctx.body[field] = (fieldDef as any).default;
+            if (ctx.body[field] === undefined && fieldDef?.default !== undefined && fieldDef?.default !== null) {
+                ctx.body[field] = fieldDef.default;
             }
         }
-
         // 验证参数
         const result = Validator.validate(ctx.body, ctx.api.fields, ctx.api.required || []);
-
         if (result.code !== 0) {
             ctx.response = ErrorResponse(ctx, result.firstError || "参数验证失败", 1, null, result.fieldErrors, "validator");
             return;
         }
     }
-} satisfies Hook;
+};

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Befly 框架主入口文件
+ * 提供简洁的框架接口，核心逻辑已提取到 loader 层
+ */
+import type { BeflyContext } from "./types/befly";
+/**
+ * Befly 框架核心类
+ * 职责：管理应用上下文和生命周期
+ */
+export declare class Befly {
+    /** API 路由映射表 */
+    private apis;
+    /** 插件列表 */
+    private plugins;
+    /** 钩子列表 */
+    private hooks;
+    /** 应用上下文 */
+    context: Partial<BeflyContext>;
+    /** 配置引用（延迟加载） */
+    private config;
+    /**
+     * 启动完整的生命周期流程
+     * @returns HTTP 服务器实例
+     */
+    start(): Promise<ReturnType<typeof Bun.serve>>;
+}

package/{main.ts → dist/index.js}

@@ -2,204 +2,165 @@
  * Befly 框架主入口文件
  * 提供简洁的框架接口，核心逻辑已提取到 loader 层
  */
-
-// ========== 类型导入 ==========
-import type { ApiRoute } from "./types/api.ts";
-import type { BeflyContext, BeflyOptions } from "./types/befly.ts";
-import type { Hook } from "./types/hook.ts";
-import type { Plugin } from "./types/plugin.ts";
-
-import { checkApi } from "./checks/checkApi.ts";
-import { checkHook } from "./checks/checkHook.ts";
-import { checkMenu } from "./checks/checkMenu.ts";
-import { checkPlugin } from "./checks/checkPlugin.ts";
-import { checkTable } from "./checks/checkTable.ts";
+import { loadBeflyConfig } from "./befly.config";
+import { checkApi } from "./checks/checkApi";
+import { checkHook } from "./checks/checkHook";
+import { checkMenu } from "./checks/checkMenu";
+import { checkPlugin } from "./checks/checkPlugin";
+import { checkTable } from "./checks/checkTable";
 // ========== 相对导入（项目内部文件） ==========
 // 基础设施
-import { Connect } from "./lib/connect.ts";
-import { Logger } from "./lib/logger.ts";
+import { Connect } from "./lib/connect";
+import { Logger } from "./lib/logger";
 // 加载器
-import { loadApis } from "./loader/loadApis.ts";
-import { loadHooks } from "./loader/loadHooks.ts";
-import { loadPlugins } from "./loader/loadPlugins.ts";
+import { loadApis } from "./loader/loadApis";
+import { loadHooks } from "./loader/loadHooks";
+import { loadPlugins } from "./loader/loadPlugins";
 // 路由处理
-import { apiHandler } from "./router/api.ts";
-import { staticHandler } from "./router/static.ts";
+import { apiHandler } from "./router/api";
+import { staticHandler } from "./router/static";
 // 同步
-import { syncApi } from "./sync/syncApi.ts";
-import { syncCache } from "./sync/syncCache.ts";
-import { syncDev } from "./sync/syncDev.ts";
-import { syncMenu } from "./sync/syncMenu.ts";
-import { syncTable } from "./sync/syncTable.ts";
+import { syncApi } from "./sync/syncApi";
+import { syncCache } from "./sync/syncCache";
+import { syncDev } from "./sync/syncDev";
+import { syncMenu } from "./sync/syncMenu";
+import { syncTable } from "./sync/syncTable";
 // 工具
-import { calcPerfTime } from "./utils/calcPerfTime.ts";
-import { getProcessRole } from "./utils/process.ts";
-import { scanSources } from "./utils/scanSources.ts";
-
+import { calcPerfTime } from "./utils/calcPerfTime";
+import { getProcessRole } from "./utils/processInfo";
+import { scanSources } from "./utils/scanSources";
 /**
  * Befly 框架核心类
  * 职责：管理应用上下文和生命周期
  */
 export class Befly {
     /** API 路由映射表 */
-    private apis: Map<string, ApiRoute> = new Map();
-
+    apis = new Map();
     /** 插件列表 */
-    private plugins: Plugin[] = [];
-
+    plugins = [];
     /** 钩子列表 */
-    private hooks: Hook[] = [];
-
+    hooks = [];
     /** 应用上下文 */
-    public context: Partial<BeflyContext> = {};
-
+    context = {};
     /** 配置引用（延迟加载） */
-    private config: BeflyOptions | null = null;
-
+    config = null;
     /**
      * 启动完整的生命周期流程
      * @returns HTTP 服务器实例
      */
-    public async start(): Promise<ReturnType<typeof Bun.serve>> {
+    async start() {
         try {
             const serverStartTime = Bun.nanoseconds();
-
-            // 0. 延迟加载配置（避免循环依赖）
-            const { loadBeflyConfig } = await import("./befly.config.ts");
+            // 0. 加载配置
             this.config = await loadBeflyConfig();
-
             // 将配置注入到 ctx，供插件/Hook/sync 等按需读取
             this.context.config = this.config;
-
             const { apis, tables, plugins, hooks, addons } = await scanSources();
-
             // 让后续 syncMenu 能拿到 addon 的 views 路径等信息
             this.context.addons = addons;
-
             await checkApi(apis);
             await checkTable(tables);
             await checkPlugin(plugins);
             await checkHook(hooks);
             const checkedMenus = await checkMenu(addons, { disableMenus: this.config.disableMenus || [] });
-
             // 1. 启动期建立基础连接（SQL + Redis）
             // 说明：连接职责收敛到启动期单点；插件只消费已连接实例（Connect.getSql/getRedis）。
             await Connect.connect({
                 db: this.config.db || {},
                 redis: this.config.redis || {}
             });
-
             // 2. 加载插件
-            this.plugins = await loadPlugins(plugins as any, this.context as BeflyContext, this.config!.disablePlugins || []);
-
+            this.plugins = await loadPlugins(plugins, this.context);
             // 启动期依赖完整性检查：避免 sync 阶段出现 undefined 调用
             // 注意：这里不做兼容别名（例如 dbHelper=db），要求上下文必须注入标准字段。
-            if (!(this.context as any).redis) {
+            if (!this.context.redis) {
                 throw new Error("启动失败：ctx.redis 未初始化（Redis 插件未加载或注入失败）");
             }
-            if (!(this.context as any).db) {
+            if (!this.context.db) {
                 throw new Error("启动失败：ctx.db 未初始化（Db 插件未加载或注入失败）");
             }
-            if (!(this.context as any).cache) {
+            if (!this.context.cache) {
                 throw new Error("启动失败：ctx.cache 未初始化（cache 插件未加载或注入失败）");
             }
-
             // 5. 自动同步 (仅主进程执行，避免集群模式下重复执行)
-            await syncTable(this.context as BeflyContext, tables);
-            await syncApi(this.context as BeflyContext, apis as any);
-
-            await syncMenu(this.context as BeflyContext, checkedMenus);
-            await syncDev(this.context as BeflyContext, { devEmail: this.config.devEmail, devPassword: this.config.devPassword });
-
+            await syncTable(this.context, tables);
+            await syncApi(this.context, apis);
+            await syncMenu(this.context, checkedMenus);
+            await syncDev(this.context, { devEmail: this.config.devEmail, devPassword: this.config.devPassword });
             // 缓存同步：统一在所有同步完成后执行（cacheApis + cacheMenus + rebuildRoleApiPermissions）
-            await syncCache(this.context as BeflyContext);
-
+            await syncCache(this.context);
             // 3. 加载钩子
-            this.hooks = await loadHooks(hooks as any, this.config!.disableHooks || []);
-
+            this.hooks = await loadHooks(hooks);
             // 4. 加载所有 API
-            this.apis = await loadApis(apis as any);
-
+            this.apis = await loadApis(apis);
             // 6. 启动 HTTP服务器
-            const apiFetch = apiHandler(this.apis, this.hooks, this.context as BeflyContext);
-            const staticFetch = staticHandler(this.config!.cors);
-
+            const apiFetch = apiHandler(this.apis, this.hooks, this.context);
+            const staticFetch = staticHandler(this.config.cors);
             const server = Bun.serve({
-                port: this.config!.appPort,
-                hostname: this.config!.appHost,
+                port: this.config.appPort,
+                hostname: this.config.appHost,
                 // 开发模式下启用详细错误信息
-                development: this.config!.nodeEnv === "development",
+                development: this.config.nodeEnv === "development",
                 // 空闲连接超时时间（秒），防止恶意连接占用资源
                 idleTimeout: 30,
                 fetch: async (req, bunServer) => {
                     const url = new URL(req.url);
-
                     if (url.pathname === "/") {
-                        return Response.json({ code: 0, msg: `${this.config!.appName} 接口服务已启动` });
+                        return Response.json({ code: 0, msg: `${this.config.appName} 接口服务已启动` });
                     }
-
                     if (url.pathname.startsWith("/api/")) {
                         return apiFetch(req, bunServer);
                     }
-
                     return staticFetch(req);
                 },
-                error: (error: Error) => {
+                error: (error) => {
                     Logger.error({ err: error }, "服务启动时发生错误");
                     // 开发模式下返回详细错误信息
-                    if (this.config!.nodeEnv === "development") {
-                        return Response.json(
-                            {
-                                code: 1,
-                                msg: "内部服务器错误",
-                                error: error.message,
-                                stack: error.stack
-                            },
-                            { status: 200 }
-                        );
+                    if (this.config.nodeEnv === "development") {
+                        return Response.json({
+                            code: 1,
+                            msg: "内部服务器错误",
+                            error: error.message,
+                            stack: error.stack
+                        }, { status: 200 });
                     }
                     return Response.json({ code: 1, msg: "内部服务器错误" }, { status: 200 });
                 }
             });
-
             const finalStartupTime = calcPerfTime(serverStartTime);
             const processRole = getProcessRole();
             const roleLabel = processRole.role === "primary" ? "主进程" : `工作进程 #${processRole.instanceId}`;
             const envLabel = processRole.env === "standalone" ? "" : ` [${processRole.env}]`;
-
-            Logger.info(`${this.config!.appName} 启动成功! (${roleLabel}${envLabel})`);
+            Logger.info(`${this.config.appName} 启动成功! (${roleLabel}${envLabel})`);
             Logger.info(`服务器启动耗时: ${finalStartupTime}`);
             Logger.info(`服务器监听地址: ${server.url}`);
-
             // 7. 注册优雅关闭处理
-            const gracefulShutdown = async (signal: string) => {
+            const gracefulShutdown = async (signal) => {
                 Logger.info(`收到 ${signal} 信号，开始优雅关闭...`);
-
                 // 优雅停止（等待进行中的请求完成）
                 try {
                     await server.stop();
                     Logger.info("HTTP 服务器已停止");
-                } catch (error: any) {
+                }
+                catch (error) {
                     Logger.error({ err: error }, "停止 HTTP 服务器时出错");
                 }
-
                 // 关闭数据库连接
                 try {
                     await Connect.disconnect();
                     Logger.info("数据库连接已关闭");
-                } catch (error: any) {
+                }
+                catch (error) {
                     Logger.error({ err: error }, "关闭数据库连接时出错");
                 }
-
                 Logger.info("服务器已优雅关闭");
                 process.exit(0);
             };
-
             process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
             process.on("SIGINT", () => gracefulShutdown("SIGINT"));
-
             return server;
-        } catch (error: any) {
+        }
+        catch (error) {
             Logger.error({ err: error }, "项目启动失败");
             process.exit(1);
         }

package/dist/lib/asyncContext.d.ts

@@ -0,0 +1,21 @@
+/**
+ * AsyncLocalStorage 请求级上下文
+ *
+ * 目标：
+ * - 给 Logger/慢查询日志提供 requestId/route/userId 等元信息
+ * - 避免在深层工具函数中层层传参
+ */
+export type RequestMeta = {
+    requestId: string;
+    method: string;
+    route: string;
+    ip: string;
+    userId?: string | number | null;
+    roleCode?: string | null;
+    nickname?: string | null;
+    roleType?: string | null;
+    now: number;
+};
+export declare function withCtx<T>(meta: RequestMeta, fn: () => T): T;
+export declare function getCtx(): RequestMeta | null;
+export declare function setCtxUser(userId: string | number | null | undefined, roleCode?: string | null | undefined, nickname?: string | null | undefined, roleType?: string | null | undefined): void;

package/dist/lib/asyncContext.js

@@ -0,0 +1,27 @@
+/**
+ * AsyncLocalStorage 请求级上下文
+ *
+ * 目标：
+ * - 给 Logger/慢查询日志提供 requestId/route/userId 等元信息
+ * - 避免在深层工具函数中层层传参
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+const storage = new AsyncLocalStorage();
+export function withCtx(meta, fn) {
+    return storage.run(meta, fn);
+}
+export function getCtx() {
+    const store = storage.getStore();
+    if (!store)
+        return null;
+    return store;
+}
+export function setCtxUser(userId, roleCode, nickname, roleType) {
+    const store = storage.getStore();
+    if (!store)
+        return;
+    store.userId = userId;
+    store.roleCode = roleCode;
+    store.nickname = nickname;
+    store.roleType = roleType;
+}