befly 3.76.0 → 3.76.2

package/hooks/rateLimit.js

@@ -1,95 +1,58 @@
-import picomatch from "picomatch";
-
 import { HOOK_ORDER } from "../configs/constConfig.js";
 import { isValidPositiveInt } from "../utils/is.js";
 import { ErrorResponse } from "../utils/response.js";
 
-const RATE_LIMIT_ENABLED_VALUES = new Set([1, true, "1", "true"]);
-
-function toPositiveInt(value, fallbackValue) {
-    const number = Number(value);
-    return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallbackValue;
-}
+const matcherCache = new WeakMap();
 
-function toSafeString(value, fallbackValue) {
-    return typeof value === "string" && value.trim() ? value.trim() : fallbackValue;
-}
-
-function createMatcher(pattern) {
-    try {
-        return picomatch(pattern);
-    } catch {
-        return null;
+function getSkipMatchers(config) {
+    let matchers = matcherCache.get(config);
+    if (!matchers) {
+        matchers = config.skipRoutes.map((pattern) => new Bun.Glob(pattern));
+        matcherCache.set(config, matchers);
     }
+    return matchers;
 }
 
-function normalizeConfig(config) {
-    const skipMatchers = [];
-    for (const route of Array.isArray(config?.skipRoutes) ? config.skipRoutes : []) {
-        const matcher = createMatcher(toSafeString(route, ""));
-        if (matcher) skipMatchers.push(matcher);
-    }
-
-    return {
-        enabled: RATE_LIMIT_ENABLED_VALUES.has(config?.enable),
-        // failOpen：限流服务（Redis）不可用时是否放行；默认放行（保持兼容），可配置为 failClosed
-        failOpen: config?.failOpen === undefined ? true : RATE_LIMIT_ENABLED_VALUES.has(config?.failOpen),
-        limit: toPositiveInt(config?.defaultLimit, 1000),
-        window: toPositiveInt(config?.defaultWindow, 60),
-        keyType: toSafeString(config?.key, "ip"),
-        skipMatchers: skipMatchers
-    };
-}
-
-function resolveScopeByKeyType(keyType, ctx) {
-    if (keyType === "userId") return isValidPositiveInt(ctx.userId) ? `user:${ctx.userId}` : `ip:${ctx.ip || "unknown"}`;
+function resolveScope(keyType, ctx) {
+    if (keyType === "userId") return isValidPositiveInt(ctx.userId) ? `user:${ctx.userId}` : `ip:${ctx.ip}`;
     if (keyType === "roleCode") return `role:${ctx.roleCode || "guest"}`;
-    if (keyType === "apiPath") return `path:${ctx.apiPath || "unknown"}`;
+    if (keyType === "apiPath") return `path:${ctx.apiPath}`;
     if (keyType === "global") return "global";
-    return `ip:${ctx.ip || "unknown"}`;
-}
-
-function shouldSkipRateLimit(normalized, ctx) {
-    return normalized.skipMatchers.some((matcher) => matcher(ctx.apiPath));
-}
-
-function buildRateLimitRedisKey(ctx, keyType, scope) {
-    return `rate_limit:${ctx.apiPath}:${ctx.method}:${keyType}:${scope}`;
+    return `ip:${ctx.ip}`;
 }
 
 export default {
+    name: "限流",
     order: HOOK_ORDER.RATE_LIMIT,
     handler: async (befly, ctx) => {
-        const rateLimit = normalizeConfig(befly?.config?.rateLimit);
-        if (!rateLimit.enabled || shouldSkipRateLimit(rateLimit, ctx)) return;
+        const config = befly.config.rateLimit;
+        if (!config.enable || getSkipMatchers(config).some((matcher) => matcher.match(ctx.apiPath))) return;
 
-        // 限流服务（Redis）不可用：failOpen 放行（默认），failClosed 直接拒绝
-        if (!befly?.redis || typeof befly.redis.incrWithExpire !== "function") {
-            if (!rateLimit.failOpen) {
-                ctx.corsHeaders ||= {};
-                ctx.corsHeaders["Retry-After"] = String(rateLimit.window);
+        if (!befly.redis?.incrWithExpire) {
+            if (!config.failOpen) {
+                ctx.corsHeaders["Retry-After"] = String(config.defaultWindow);
                 ctx.response = ErrorResponse(ctx, "服务繁忙，请稍后再试", 1, null, { reason: "rate_limit_unavailable" }, "rateLimit");
             }
             return;
         }
 
-        const scope = resolveScopeByKeyType(rateLimit.keyType, ctx);
-        const current = await befly.redis.incrWithExpire(buildRateLimitRedisKey(ctx, rateLimit.keyType, scope), rateLimit.window);
-        if (current <= rateLimit.limit) return;
+        const scope = resolveScope(config.key, ctx);
+        const key = `rate_limit:${ctx.apiPath}:${ctx.method}:${config.key}:${scope}`;
+        const current = await befly.redis.incrWithExpire(key, config.defaultWindow);
+        if (current <= config.defaultLimit) return;
 
-        ctx.corsHeaders ||= {};
-        ctx.corsHeaders["Retry-After"] = String(rateLimit.window);
+        ctx.corsHeaders["Retry-After"] = String(config.defaultWindow);
         ctx.response = ErrorResponse(
             ctx,
             "请求过于频繁，请稍后再试",
             1,
             null,
             {
-                limit: rateLimit.limit,
-                window: rateLimit.window,
+                limit: config.defaultLimit,
+                window: config.defaultWindow,
                 current: current,
                 apiPath: ctx.apiPath,
-                key: rateLimit.keyType
+                key: config.key
             },
             "rateLimit"
         );

package/hooks/validator.js

@@ -1,48 +1,60 @@
+import { compile } from "#befly/libs/validator/index.js";
+
+import { getFieldSchema } from "../checks/field.js";
 import { HOOK_ORDER } from "../configs/constConfig.js";
-// 相对导入
-import { validateFields } from "../lib/validator.js";
-import { isPlainObject, isString } from "../utils/is.js";
+import { isPlainObject } from "../utils/is.js";
 import { ErrorResponse } from "../utils/response.js";
 import { snakeCase } from "../utils/util.js";
 
-/**
- * 参数验证钩子
- * 根据 API 定义的 fields 和 required 验证请求参数
- */
+const validatorCache = new WeakMap();
+
+function getValidator(fields, required, constraints) {
+    let validators = validatorCache.get(fields);
+    if (!validators) {
+        validators = new Map();
+        validatorCache.set(fields, validators);
+    }
+    const cacheKey = JSON.stringify([required, constraints]);
+    let validate = validators.get(cacheKey);
+    if (validate) return validate;
+    const requiredSet = new Set(required);
+    validate = compile({
+        paramType: "object",
+        fields: Object.fromEntries(
+            Object.entries(fields).map(([field, definition]) => [
+                field,
+                {
+                    ...getFieldSchema(definition),
+                    optional: !requiredSet.has(field)
+                }
+            ])
+        ),
+        constraints: constraints
+    });
+    validators.set(cacheKey, validate);
+    return validate;
+}
+
 export default {
+    name: "参数验证",
     order: HOOK_ORDER.VALIDATOR,
     handler: async (befly, ctx) => {
-        // 仅保留 fields 中声明的字段，并支持 snake_case 入参回退（例如 agent_id -> agentId）
         const rawBody = isPlainObject(ctx.body) ? ctx.body : {};
         const nextBody = {};
 
-        for (const [field] of Object.entries(ctx.apiFields)) {
-            let value = rawBody[field];
-
-            if (value === undefined) {
-                const snakeField = snakeCase(field);
-                if (rawBody[snakeField] !== undefined) {
-                    value = rawBody[snakeField];
-                }
-            }
-
-            if (isString(value)) {
-                value = value.trim();
-            }
-
-            if (value !== undefined) {
-                nextBody[field] = value;
-            }
+        for (const field of Object.keys(ctx.apiFields)) {
+            const value = rawBody[field] !== undefined ? rawBody[field] : rawBody[snakeCase(field)];
+            if (value !== undefined) nextBody[field] = value;
         }
 
         ctx.body = nextBody;
-
-        // 验证参数
-        const result = validateFields(ctx.body, ctx.apiFields, ctx.apiRequired);
-
-        if (result.code !== 0) {
-            ctx.response = ErrorResponse(ctx, result.firstError || "参数验证失败", 1, null, result.fieldErrors, "validator");
+        const result = getValidator(ctx.apiFields, ctx.apiRequired, ctx.apiConstraints)(nextBody);
+        if (result.ok) {
+            ctx.body = result.data;
             return;
         }
+
+        const fieldErrors = Object.fromEntries(result.issues.map((issue) => [issue.path[0], `${ctx.apiFields[issue.path[0]]?.name || issue.path[0]}${issue.message}`]));
+        ctx.response = ErrorResponse(ctx, Object.values(fieldErrors)[0] || "参数验证失败", 1, null, fieldErrors, "validator");
     }
 };

package/index.js

@@ -1,98 +1,35 @@
-/**
- * Befly 框架主入口文件
- * 提供简洁的框架接口，核心逻辑已提取到 loader 层
- */
-
-// 检查
-import { checkApi } from "#befly/checks/api.js";
-import { checkConfig } from "#befly/checks/config.js";
-import { checkCorn } from "#befly/checks/corns.js";
-import { checkHook, checkPlugin } from "#befly/checks/items.js";
-import { checkMenu } from "#befly/checks/menu.js";
-import { checkTable } from "#befly/checks/table.js";
-// 配置
-import beflyConfig from "#befly/configs/beflyConfig.json";
-import beflyMenus from "#befly/configs/beflyMenus.json";
-import { BEFLY_ADMIN_TABLE, BEFLY_API_TABLE, BEFLY_MENU_TABLE, BEFLY_ROLE_TABLE } from "#befly/configs/constConfig.js";
-// ========== 相对导入（项目内部文件） ==========
-// 基础设施
-import { Connect } from "#befly/lib/connect.js";
-// oxlint-disable-next-line unicorn/prefer-export-from -- Logger 同时被本文件大量使用，不能合并为 re-export
-import { Logger } from "#befly/lib/logger.js";
-// 定时任务
-import { registerCorns } from "#befly/plugins/cron.js";
-// 路由处理
-import { apiHandler } from "#befly/router/api.js";
-import { staticHandler } from "#befly/router/static.js";
-// 同步
-import { syncApi } from "#befly/sync/api.js";
-import { syncCache } from "#befly/sync/cache.js";
-import { syncDev } from "#befly/sync/dev.js";
-import { syncMenu } from "#befly/sync/menu.js";
-// 工具
-import { calcPerfTime } from "#befly/utils/calcPerfTime.js";
-import { formatYmdHms } from "#befly/utils/datetime.js";
-import { deepMerge } from "#befly/utils/deepMerge.js";
-import { createError } from "#befly/utils/error.js";
-import { isPrimaryProcess } from "#befly/utils/is.js";
-import { scanSources } from "#befly/utils/scanSources.js";
-import { getRunMode, waitFor } from "#befly/utils/util.js";
-
-export { syncDb } from "#befly/scripts/syncDb/index.js";
-export { xmlParse } from "#befly/lib/xmlParse.js";
-export { Logger };
-
-// 主进程同步完成的 Redis 就绪标记（非主进程等待此标记后再对外服务）
-const SYNC_READY_KEY = "befly:syncReady";
+import { Logger } from "#befly/libs/logger/index.js";
+
+import { Befly } from "./Befly.js";
+import { checkApi } from "./checks/api.js";
+import { checkConfig } from "./checks/config.js";
+import { checkCorn } from "./checks/corns.js";
+import { checkHook, checkPlugin } from "./checks/items.js";
+import { checkMenu } from "./checks/menu.js";
+import { checkTable } from "./checks/table.js";
+import beflyConfig from "./configs/beflyConfig.json";
+import beflyMenus from "./configs/beflyMenus.json";
+import { calcPerfTime } from "./utils/calcPerfTime.js";
+import { deepMerge } from "./utils/deepMerge.js";
+import { createError } from "./utils/error.js";
+import { scanSources } from "./utils/scanSources.js";
+import { getRunMode } from "./utils/util.js";
 
 function prefixMenuPaths(menus, prefix) {
-    return menus.map((menu) => {
-        const nextMenu = {
-            name: menu.name,
-            path: menu.path === "/" ? `/${prefix}` : `/${prefix}${menu.path}`,
-            sort: menu.sort
-        };
-
-        if (Array.isArray(menu.children)) {
-            nextMenu.children = menu.children.map((child) => ({
-                name: child.name,
-                path: child.path,
-                sort: child.sort
-            }));
-        }
-
-        return nextMenu;
-    });
-}
-
-async function syncReady(ctx) {
-    const missingCtxKeys = ["ctx.redis", "ctx.mysql", "ctx.cache"].filter((key) => !ctx[key.slice(4)]);
-    if (missingCtxKeys.length > 0) {
-        throw createError(`启动失败：${missingCtxKeys.join("、")} 未初始化`, {
-            code: "runtime",
-            subsystem: "sync",
-            operation: "ctxCheck",
-            missingCtxKeys: missingCtxKeys
-        });
-    }
-
-    const requiredTables = [BEFLY_API_TABLE, BEFLY_MENU_TABLE, BEFLY_ADMIN_TABLE, BEFLY_ROLE_TABLE];
-    const missingTables = [];
-
-    for (const table of requiredTables) {
-        if (!(await ctx.mysql.tableExists(table)).data) {
-            missingTables.push(table);
-        }
-    }
-
-    if (missingTables.length > 0) {
-        throw createError(`同步依赖表缺失: ${missingTables.join("、")}`, {
-            code: "runtime",
-            subsystem: "sync",
-            operation: "tableExists",
-            missingTables: missingTables
-        });
-    }
+    return menus.map((menu) => ({
+        name: menu.name,
+        path: menu.path === "/" ? `/${prefix}` : `/${prefix}${menu.path}`,
+        sort: menu.sort,
+        ...(Array.isArray(menu.children)
+            ? {
+                  children: menu.children.map((child) => ({
+                      name: child.name,
+                      path: child.path,
+                      sort: child.sort
+                  }))
+              }
+            : {})
+    }));
 }
 
 export async function createBefly(config = {}, menus = []) {
@@ -100,10 +37,7 @@ export async function createBefly(config = {}, menus = []) {
     const mergedConfig = deepMerge(beflyConfig, config);
     const mergedMenus = deepMerge(prefixMenuPaths(beflyMenus, "core"), menus);
 
-    Logger.configure({
-        runtimeEnv: getRunMode(),
-        ...mergedConfig.logger
-    });
+    Logger.configure({ runtimeEnv: getRunMode(), ...mergedConfig.logger });
     Logger.info(`启动 合并配置 耗时 ${calcPerfTime(mergeStartTime)}`);
 
     let stageStartTime = Bun.nanoseconds();
@@ -111,43 +45,19 @@ export async function createBefly(config = {}, menus = []) {
     Logger.info(`启动 检查配置 耗时 ${calcPerfTime(stageStartTime)}`);
 
     stageStartTime = Bun.nanoseconds();
-    const { apis, tables, plugins, hooks, corns } = await scanSources();
+    const { apis, tables, plugins, hooks, corns } = await scanSources({ beflyMode: mergedConfig.mysql.beflyMode });
     Logger.info(`启动 扫描源码 耗时 ${calcPerfTime(stageStartTime)}`);
 
-    stageStartTime = Bun.nanoseconds();
-    const apiErrors = await checkApi(apis);
-    Logger.info(`启动 检查接口 耗时 ${calcPerfTime(stageStartTime)}`);
-
-    stageStartTime = Bun.nanoseconds();
-    const tableErrors = await checkTable(tables);
-    Logger.info(`启动 检查表 耗时 ${calcPerfTime(stageStartTime)}`);
-
-    stageStartTime = Bun.nanoseconds();
-    const pluginErrors = await checkPlugin(plugins);
-    Logger.info(`启动 检查插件 耗时 ${calcPerfTime(stageStartTime)}`);
-
-    stageStartTime = Bun.nanoseconds();
-    const hookErrors = await checkHook(hooks);
-    Logger.info(`启动 检查钩子 耗时 ${calcPerfTime(stageStartTime)}`);
-
-    stageStartTime = Bun.nanoseconds();
-    const cornErrors = await checkCorn(corns);
-    Logger.info(`启动 检查定时器 耗时 ${calcPerfTime(stageStartTime)}`);
-
-    stageStartTime = Bun.nanoseconds();
-    const menuErrors = await checkMenu(mergedMenus);
-    Logger.info(`启动 检查菜单 耗时 ${calcPerfTime(stageStartTime)}`);
-
-    // 汇总各检查明细，报错可直接定位到具体文件/路径/配置/字段
-    const failedChecks = [
-        { check: "配置", errors: configErrors },
-        { check: "接口", errors: apiErrors },
-        { check: "表结构", errors: tableErrors },
-        { check: "插件", errors: pluginErrors },
-        { check: "钩子", errors: hookErrors },
-        { check: "定时器", errors: cornErrors },
-        { check: "菜单", errors: menuErrors }
-    ].filter((entry) => entry.errors.length > 0);
+    const checks = [
+        ["配置", configErrors],
+        ["接口", await checkApi(apis)],
+        ["表结构", await checkTable(tables)],
+        ["插件", await checkPlugin(plugins)],
+        ["钩子", await checkHook(hooks)],
+        ["定时器", checkCorn(corns)],
+        ["菜单", await checkMenu(mergedMenus)]
+    ];
+    const failedChecks = checks.filter(([, errors]) => errors.length > 0).map(([check, errors]) => ({ check: check, errors: errors }));
 
     if (failedChecks.length > 0) {
         throw createError("检查失败：存在配置/结构问题", {
@@ -158,10 +68,7 @@ export async function createBefly(config = {}, menus = []) {
         });
     }
 
-    // 运行模式以环境为准（NODE_ENV，线上部署注入 production；本地开发默认 development），
-    // 覆盖配置值，保证 befly.config.runMode 与运行时判断一致
     mergedConfig.runMode = getRunMode();
-
     return new Befly({
         config: mergedConfig,
         tables: tables,
@@ -169,214 +76,6 @@ export async function createBefly(config = {}, menus = []) {
         apis: apis,
         hooks: hooks,
         plugins: plugins,
-        corns: corns,
-        createdByFactory: true
+        corns: corns
     });
 }
-
-/**
- * Befly 框架核心类
- * 职责：管理应用上下文和生命周期
- */
-export class Befly {
-    constructor(init = {}) {
-        this.context = {
-            config: init.config || {},
-            tables: init.tables || {}
-        };
-        this.menus = Array.isArray(init.menus) ? init.menus : [];
-        this.hooks = Array.isArray(init.hooks) ? init.hooks : [];
-        this.apis = Array.isArray(init.apis) ? init.apis : [];
-        this.plugins = Array.isArray(init.plugins) ? init.plugins : [];
-        this.corns = Array.isArray(init.corns) ? init.corns : [];
-        this.createdByFactory = init.createdByFactory === true;
-    }
-
-    ensureCreatedByFactory() {
-        if (this.createdByFactory) {
-            return;
-        }
-
-        throw createError("请使用 createBefly(...) 创建实例后再调用 start", { code: "policy", subsystem: "start", operation: "factoryGuard" });
-    }
-
-    /**
-     * 启动完整的生命周期流程
-     * @returns HTTP 服务器实例
-     */
-    async start() {
-        try {
-            this.ensureCreatedByFactory();
-
-            const serverStartTime = Bun.nanoseconds();
-
-            // 启动期建立基础连接（SQL + Redis）
-            // 说明：连接职责收敛到启动期单点；插件只消费已连接实例（Connect.getSql/getRedis）。
-            let stageStartTime = Bun.nanoseconds();
-            await Connect.connectRedis(this.context.config.redis);
-            Logger.info(`启动 连接 Redis 耗时 ${calcPerfTime(stageStartTime)}`);
-
-            stageStartTime = Bun.nanoseconds();
-            await Connect.connectMysql(this.context.config.mysql);
-            Logger.info(`启动 连接 Mysql 耗时 ${calcPerfTime(stageStartTime)}`);
-
-            // 加载插件
-            for (const item of this.plugins.toSorted((a, b) => a.order - b.order)) {
-                const pluginStartTime = Bun.nanoseconds();
-                this.context[item.fileName] = await item.handler(this.context);
-                Logger.info(`启动 插件 ${item.fileName} 耗时 ${calcPerfTime(pluginStartTime)}`);
-            }
-
-            // 注册定时器（依赖插件加载完成的 ctx.cron，非主进程自动跳过）
-            stageStartTime = Bun.nanoseconds();
-            registerCorns(this.context, this.corns);
-            Logger.info(`启动 注册定时器 耗时 ${calcPerfTime(stageStartTime)}`);
-
-            stageStartTime = Bun.nanoseconds();
-            await syncReady(this.context);
-            Logger.info(`启动 同步就绪 耗时 ${calcPerfTime(stageStartTime)}`);
-
-            // 自动同步（bm2 多实例：主进程执行同步并写就绪标记，其它进程等待同步完成后再对外服务）
-            if (isPrimaryProcess()) {
-                stageStartTime = Bun.nanoseconds();
-                await syncApi(this.context, this.apis);
-                Logger.info(`启动 同步接口 耗时 ${calcPerfTime(stageStartTime)}`);
-
-                stageStartTime = Bun.nanoseconds();
-                await syncMenu(this.context, this.menus);
-                Logger.info(`启动 同步菜单 耗时 ${calcPerfTime(stageStartTime)}`);
-
-                stageStartTime = Bun.nanoseconds();
-                await syncDev(this.context);
-                Logger.info(`启动 同步开发账号 耗时 ${calcPerfTime(stageStartTime)}`);
-
-                stageStartTime = Bun.nanoseconds();
-                await syncCache(this.context);
-                Logger.info(`启动 同步缓存 耗时 ${calcPerfTime(stageStartTime)}`);
-
-                // 同步完成：写入就绪标记（TTL 防崩溃残留），非主进程据此放行
-                await this.context.redis.setString(SYNC_READY_KEY, String(Date.now()), 300);
-            } else {
-                // 非主进程：在监听端口前等待主进程本次同步完成（时间戳判断，同机时钟一致）
-                const startAt = Date.now();
-                await waitFor({
-                    label: "主进程同步完成",
-                    check: async () => {
-                        const ready = await this.context.redis.getString(SYNC_READY_KEY);
-                        return ready !== null && Number(ready) > startAt;
-                    }
-                });
-                Logger.info("启动 等待主进程同步完成 完成");
-            }
-
-            // 加载钩子
-            stageStartTime = Bun.nanoseconds();
-            this.hooks = this.hooks.toSorted((a, b) => a.order - b.order);
-
-            // 加载所有 API
-            this.apis = Object.fromEntries(this.apis.map((api) => [api.apiPath, api]));
-
-            // 启动 HTTP服务器
-            const apiFetch = apiHandler(this.apis, this.hooks, this.context);
-            const staticFetch = staticHandler(this.context.config.cors, this.context.config.upload);
-            Logger.info(`启动 装配接口 耗时 ${calcPerfTime(stageStartTime)}`);
-
-            stageStartTime = Bun.nanoseconds();
-            const server = Bun.serve({
-                port: this.context.config.appPort || 3000,
-                hostname: this.context.config.appHost || "127.0.0.1",
-                // 开发模式下启用详细错误信息
-                development: this.context.config.runMode === "development",
-                // 空闲连接超时时间（秒），防止恶意连接占用资源
-                fetch: async (req, httpServer) => {
-                    const url = new URL(req.url);
-
-                    if (url.pathname.startsWith("/api/")) {
-                        return apiFetch(req, httpServer);
-                    }
-
-                    if (url.pathname.startsWith("/public/")) {
-                        return staticFetch(req);
-                    }
-
-                    // 根路径返回服务基本信息
-                    if (url.pathname === "/") {
-                        return Response.json(
-                            {
-                                code: 0,
-                                msg: "success",
-                                data: {
-                                    name: this.context.config.appName,
-                                    mode: this.context.config.runMode,
-                                    time: formatYmdHms(Date.now())
-                                }
-                            },
-                            { status: 200 }
-                        );
-                    }
-
-                    return Response.json({ code: 1, msg: "路径不存在" }, { status: 200 });
-                },
-                error: (error) => {
-                    Logger.error("服务启动时发生错误", error);
-                    // 开发模式下返回详细错误信息
-                    if (this.context.config.runMode === "development") {
-                        return Response.json(
-                            {
-                                code: 1,
-                                msg: "内部服务器错误",
-                                error: error.message,
-                                stack: error.stack
-                            },
-                            { status: 200 }
-                        );
-                    }
-                    return Response.json({ code: 1, msg: "内部服务器错误" }, { status: 200 });
-                }
-            });
-            Logger.info(`启动 监听服务 耗时 ${calcPerfTime(stageStartTime)}`);
-
-            const finalStartupTime = calcPerfTime(serverStartTime);
-
-            Logger.info(`${this.context.config.appName} 启动成功!`);
-            Logger.info(`服务器启动耗时: ${finalStartupTime}`);
-            Logger.info(`服务器监听地址: ${server.url}`);
-            Logger.info(`Mysql 数据库地址：${this.context.config.mysql.hostname}`);
-            Logger.info(`Redis 缓存地址：${this.context.config.redis.hostname}`);
-            try {
-                process.stdout.write(`${this.context.config.appName} 启动成功!\n`);
-                process.stdout.write(`服务器启动耗时: ${finalStartupTime}\n`);
-                process.stdout.write(`服务器监听地址: ${server.url}\n`);
-                process.stdout.write(`Mysql 数据库地址：${this.context.config.mysql.hostname}\n`);
-                process.stdout.write(`Redis 缓存地址：${this.context.config.redis.hostname}\n`);
-            } catch {
-                // ignore
-            }
-            // 注意：作为库代码，这里不注册 SIGINT/SIGTERM 处理器，也不调用 process.exit。
-            // 宿主应用应自行处理信号并决定退出策略（包括是否调用 server.stop / Connect.disconnect / Logger.flush）。
-            return server;
-        } catch (error) {
-            // 注意：这里不能直接 process.exit(1)
-            // - Logger 是异步缓冲写入，exit 会导致日志来不及 flush（实际项目里表现为“完全没打印”）
-            // - 作为库代码，也不应该强行终止宿主进程
-
-            // 注意：测试要求 start() 失败时必须 Logger.error 一次，所以这里始终调用 error。
-            Logger.error("项目启动失败", error);
-
-            // 尽力把错误日志落盘/输出后再把异常抛给上层。
-            try {
-                await Logger.flush();
-                await Logger.shutdown();
-            } catch {
-                // ignore
-            }
-
-            throw createError("运行时错误", {
-                cause: error,
-                code: error?.code || "runtime",
-                subsystem: "start",
-                operation: "start"
-            });
-        }
-    }
-}

package/{lib → libs}/cacheHelper.js

@@ -2,10 +2,11 @@
  * 负责在服务器启动时缓存接口、菜单和角色权限到 Redis
  */
 
+import { Logger } from "#befly/libs/logger/index.js";
+
 import { BEFLY_API_TABLE, BEFLY_MENU_TABLE, BEFLY_ROLE_TABLE } from "../configs/constConfig.js";
 import { createError } from "../utils/error.js";
 import { isNonEmptyString, isNullable, isString } from "../utils/is.js";
-import { Logger } from "./logger.js";
 
 /**
  * 缓存助手类
@@ -50,12 +51,6 @@ export class CacheHelper {
 
     async rebuildRoleCache(kind, roleValuesMap) {
         const roleCodes = Array.from(roleValuesMap.keys());
-
-        if (roleCodes.length === 0) {
-            Logger.info(`✅ 没有需要缓存的角色 ${kind}`);
-            return;
-        }
-
         const oldVersion = await this.getRoleCacheActiveVersion(kind);
         let nextVersion = String(Date.now());
 
@@ -80,7 +75,7 @@ export class CacheHelper {
         }
 
         await this.redis.del(nextCodesKey);
-        await this.redis.sadd(nextCodesKey, roleCodes);
+        if (roleCodes.length > 0) await this.redis.sadd(nextCodesKey, roleCodes);
 
         if (nextItems.length > 0) {
             await this.redis.saddBatch(nextItems);