befly 3.24.19 → 3.25.0

package/apis/admin/cacheRefresh.js

@@ -1,122 +0,0 @@
-/**
- * 刷新全部缓存接口
- *
- * 功能：
- * 1. 刷新接口缓存（apis:all）
- * 2. 刷新菜单缓存（menus:all）
- * 3. 刷新角色缓存（role:info:{code}）
- * 4. 重建角色接口权限缓存（版本化 Set + activeVersion 原子切换）
- * 5. 重建角色菜单权限缓存（版本化 Set + activeVersion 原子切换）
- *
- * 使用场景：
- * - 执行数据库同步后
- * - 手动修改配置需要立即生效
- * - 缓存出现异常需要重建
- */
-
-import { isNonEmptyString } from "#root/utils/is.js";
-
-export default {
-    name: "刷新全部缓存",
-    method: "POST",
-    body: "none",
-    auth: true,
-    fields: {},
-    required: [],
-    handler: async (befly) => {
-        try {
-            const results = {
-                apis: { success: false, count: 0 },
-                menus: { success: false, count: 0 },
-                roles: { success: false, count: 0 },
-                roleApiPermissions: { success: false },
-                roleMenuPermissions: { success: false }
-            };
-
-            // 1. 刷新接口缓存
-            try {
-                const apis = await befly.mysql.getAll({
-                    table: "beflyApi"
-                });
-
-                await befly.redis.setObject("apis:all", apis.data.lists);
-                results["apis"] = { success: true, count: apis.data.lists.length };
-            } catch (error) {
-                befly.logger.error("刷新接口缓存失败", error);
-                results["apis"] = { success: false, error: error.message };
-            }
-
-            // 2. 刷新菜单缓存
-            try {
-                const menus = await befly.mysql.getAll({
-                    table: "beflyMenu"
-                });
-
-                await befly.redis.setObject("menus:all", menus.data.lists);
-
-                const parentCount = menus.data.lists.filter((m) => !isNonEmptyString(m.parentPath)).length;
-                const childCount = menus.data.lists.filter((m) => isNonEmptyString(m.parentPath)).length;
-
-                results["menus"] = {
-                    success: true,
-                    count: menus.data.lists.length,
-                    parentCount: parentCount,
-                    childCount: childCount
-                };
-            } catch (error) {
-                befly.logger.error("刷新菜单缓存失败", error);
-                results["menus"] = { success: false, error: error.message };
-            }
-
-            // 3. 刷新角色权限缓存
-            try {
-                const roles = await befly.mysql.getAll({
-                    table: "beflyRole"
-                });
-
-                // 使用 setBatch 批量缓存所有角色
-                const count = await befly.redis.setBatch(
-                    roles.data.lists.map((role) => ({
-                        key: `role:info:${role.code}`,
-                        value: role
-                    }))
-                );
-
-                results["roles"] = { success: true, count: count };
-            } catch (error) {
-                befly.logger.error("刷新角色缓存失败", error);
-                results["roles"] = { success: false, error: error.message };
-            }
-
-            // 4. 重建角色接口权限缓存（版本化 + 原子切换）
-            try {
-                await befly.cache.cacheRoleApis();
-                results["roleApiPermissions"] = { success: true };
-            } catch (error) {
-                befly.logger.error("重建角色接口权限缓存失败", error);
-                results["roleApiPermissions"] = { success: false, error: error.message };
-            }
-
-            // 5. 重建角色菜单权限缓存
-            try {
-                await befly.cache.cacheRoleMenus();
-                results["roleMenuPermissions"] = { success: true };
-            } catch (error) {
-                befly.logger.error("重建角色菜单权限缓存失败", error);
-                results["roleMenuPermissions"] = { success: false, error: error.message };
-            }
-
-            // 检查是否全部成功
-            const allSuccess = results["apis"].success && results["menus"].success && results["roles"].success && results["roleApiPermissions"].success && results["roleMenuPermissions"].success;
-
-            if (allSuccess) {
-                return befly.tool.Yes("全部缓存刷新成功", results);
-            } else {
-                return befly.tool.No("部分缓存刷新失败", results);
-            }
-        } catch (error) {
-            befly.logger.error("刷新全部缓存失败", error);
-            return befly.tool.No("刷新全部缓存失败", { error: error.message });
-        }
-    }
-};

package/apis/dashboard/configStatus.js

@@ -1,39 +0,0 @@
-export default {
-    name: "获取配置状态",
-    method: "POST",
-    body: "none",
-    auth: true,
-    fields: {},
-    required: [],
-    handler: async (befly) => {
-        const status = {
-            database: { status: "ok", latency: 0, message: "" },
-            redis: { status: "ok", latency: 0, message: "" },
-            fileSystem: { status: "ok" },
-            email: { status: "warning", message: "未配置" },
-            oss: { status: "warning", message: "未配置" }
-        };
-
-        try {
-            const startTime = Date.now();
-            await befly.mysql.execute("SELECT 1");
-            status.database.latency = Date.now() - startTime;
-            status.database.status = "ok";
-        } catch {
-            status.database.status = "error";
-            status.database.message = "连接失败";
-        }
-
-        try {
-            const startTime = Date.now();
-            await befly.redis.ping();
-            status.redis.latency = Date.now() - startTime;
-            status.redis.status = "ok";
-        } catch {
-            status.redis.status = "error";
-            status.redis.message = "连接失败";
-        }
-
-        return befly.tool.Yes("获取成功", status);
-    }
-};

package/apis/dashboard/performanceMetrics.js

@@ -1,23 +0,0 @@
-import { requestMetrics } from "#root/lib/requestMetrics.js";
-
-export default {
-    name: "获取性能指标",
-    method: "POST",
-    body: "none",
-    auth: true,
-    fields: {},
-    required: [],
-    handler: async (befly) => {
-        const metrics = requestMetrics.getSnapshot();
-
-        return befly.tool.Yes("获取成功", {
-            avgResponseTime: Number(metrics.avgResponseTime || 0),
-            qps: Number(metrics.qps || 0),
-            errorRate: Number(metrics.errorRate || 0),
-            activeRequests: Number(metrics.activeRequests || 0),
-            activeConnections: Number(metrics.activeRequests || 0),
-            slowestApi: metrics.slowestApi || null,
-            slowestApis: Array.isArray(metrics.slowestApis) ? metrics.slowestApis : []
-        });
-    }
-};

package/apis/dashboard/permissionStats.js

@@ -1,27 +0,0 @@
-export default {
-    name: "获取权限统计",
-    method: "POST",
-    body: "none",
-    auth: true,
-    fields: {},
-    required: [],
-    handler: async (befly) => {
-        const menuCount = await befly.mysql.getCount({
-            table: "beflyMenu"
-        });
-
-        const apiCount = await befly.mysql.getCount({
-            table: "beflyApi"
-        });
-
-        const roleCount = await befly.mysql.getCount({
-            table: "beflyRole"
-        });
-
-        return befly.tool.Yes("获取成功", {
-            menuCount: menuCount.data,
-            apiCount: apiCount.data,
-            roleCount: roleCount.data
-        });
-    }
-};

package/apis/dashboard/systemInfo.js

@@ -1,19 +0,0 @@
-export default {
-    name: "获取系统信息",
-    method: "POST",
-    body: "none",
-    auth: true,
-    fields: {},
-    required: [],
-    handler: async (befly) => {
-        const startTime = Date.now() - Math.floor(process.uptime() * 1000);
-        const uptime = Math.floor(process.uptime() * 1000);
-        const environment = process.env.RUN_MODE || "development";
-
-        return befly.tool.Yes("获取成功", {
-            environment: environment,
-            startTime: startTime,
-            uptime: uptime
-        });
-    }
-};

package/lib/requestMetrics.js

@@ -1,203 +0,0 @@
-const WINDOW_SECONDS = 60;
-const SLOWEST_WINDOW_MS = 60 * 60 * 1000;
-const SLOWEST_API_LIMIT = 5;
-
-const requestBuckets = new Map();
-const activeRequestState = {
-    count: 0
-};
-const slowestState = {
-    apiPath: "",
-    duration: 0,
-    timestamp: 0
-};
-const slowestListState = [];
-
-function toSecondTimestamp(timestamp) {
-    return Math.floor(timestamp / 1000);
-}
-
-function getOrCreateBucket(secondTimestamp) {
-    let bucket = requestBuckets.get(secondTimestamp);
-
-    if (bucket) {
-        return bucket;
-    }
-
-    bucket = {
-        requestCount: 0,
-        errorCount: 0,
-        durationTotal: 0
-    };
-    requestBuckets.set(secondTimestamp, bucket);
-
-    return bucket;
-}
-
-function cleanupBuckets(nowSecondTimestamp) {
-    const minSecondTimestamp = nowSecondTimestamp - WINDOW_SECONDS + 1;
-
-    for (const key of requestBuckets.keys()) {
-        if (key >= minSecondTimestamp) {
-            continue;
-        }
-
-        requestBuckets.delete(key);
-    }
-}
-
-function cleanupSlowest(nowTimestamp) {
-    if (slowestState.timestamp <= 0) {
-        return;
-    }
-
-    if (nowTimestamp - slowestState.timestamp <= SLOWEST_WINDOW_MS) {
-        return;
-    }
-
-    slowestState.apiPath = "";
-    slowestState.duration = 0;
-    slowestState.timestamp = 0;
-}
-
-function cleanupSlowestList(nowTimestamp) {
-    for (let index = slowestListState.length - 1; index >= 0; index -= 1) {
-        if (nowTimestamp - slowestListState[index].timestamp <= SLOWEST_WINDOW_MS) {
-            continue;
-        }
-
-        slowestListState.splice(index, 1);
-    }
-}
-
-function updateSlowestList(apiPath, duration, nowTimestamp) {
-    const safePath = String(apiPath || "");
-
-    if (!safePath) {
-        return;
-    }
-
-    let existing = null;
-
-    for (const item of slowestListState) {
-        if (item.path !== safePath) {
-            continue;
-        }
-
-        existing = item;
-        break;
-    }
-
-    if (existing) {
-        if (duration > existing.time) {
-            existing.time = duration;
-        }
-
-        existing.timestamp = nowTimestamp;
-    } else {
-        slowestListState.push({
-            path: safePath,
-            time: duration,
-            timestamp: nowTimestamp
-        });
-    }
-
-    slowestListState.sort((left, right) => {
-        if (right.time !== left.time) {
-            return right.time - left.time;
-        }
-
-        return right.timestamp - left.timestamp;
-    });
-
-    if (slowestListState.length > SLOWEST_API_LIMIT) {
-        slowestListState.length = SLOWEST_API_LIMIT;
-    }
-}
-
-export const requestMetrics = {
-    reset: function () {
-        requestBuckets.clear();
-        activeRequestState.count = 0;
-        slowestState.apiPath = "";
-        slowestState.duration = 0;
-        slowestState.timestamp = 0;
-        slowestListState.length = 0;
-    },
-
-    onRequestStart: function () {
-        activeRequestState.count += 1;
-    },
-
-    onRequestEnd: function (apiPath, duration, isError) {
-        const nowTimestamp = Date.now();
-        const secondTimestamp = toSecondTimestamp(nowTimestamp);
-        const safeDuration = Number.isFinite(Number(duration)) ? Number(duration) : 0;
-        const bucket = getOrCreateBucket(secondTimestamp);
-
-        bucket.requestCount += 1;
-        bucket.durationTotal += safeDuration;
-
-        if (isError === true) {
-            bucket.errorCount += 1;
-        }
-
-        if (safeDuration > slowestState.duration || nowTimestamp - slowestState.timestamp > SLOWEST_WINDOW_MS) {
-            slowestState.apiPath = String(apiPath || "");
-            slowestState.duration = safeDuration;
-            slowestState.timestamp = nowTimestamp;
-        }
-
-        updateSlowestList(apiPath, safeDuration, nowTimestamp);
-
-        if (activeRequestState.count > 0) {
-            activeRequestState.count -= 1;
-        } else {
-            activeRequestState.count = 0;
-        }
-    },
-
-    getSnapshot: function () {
-        const nowTimestamp = Date.now();
-        const nowSecondTimestamp = toSecondTimestamp(nowTimestamp);
-
-        cleanupBuckets(nowSecondTimestamp);
-        cleanupSlowest(nowTimestamp);
-        cleanupSlowestList(nowTimestamp);
-
-        let requestCount = 0;
-        let errorCount = 0;
-        let durationTotal = 0;
-
-        for (const bucket of requestBuckets.values()) {
-            requestCount += bucket.requestCount;
-            errorCount += bucket.errorCount;
-            durationTotal += bucket.durationTotal;
-        }
-
-        const qps = Number((requestCount / WINDOW_SECONDS).toFixed(2));
-        const errorRate = requestCount > 0 ? Number(((errorCount / requestCount) * 100).toFixed(2)) : 0;
-        const avgResponseTime = requestCount > 0 ? Math.round(durationTotal / requestCount) : 0;
-        const slowestApi = slowestState.apiPath
-            ? {
-                  path: slowestState.apiPath,
-                  time: slowestState.duration
-              }
-            : null;
-        const slowestApis = slowestListState.map((item) => {
-            return {
-                path: item.path,
-                time: item.time
-            };
-        });
-
-        return {
-            qps: qps,
-            errorRate: errorRate,
-            avgResponseTime: avgResponseTime,
-            activeRequests: activeRequestState.count,
-            slowestApi: slowestApi,
-            slowestApis: slowestApis
-        };
-    }
-};