befly 3.8.1 → 3.8.2

package/check.ts

@@ -5,9 +5,9 @@
 
 import { basename } from 'pathe';
 import { Logger } from './lib/logger.js';
-import { parseRule } from './util.js';
 import { projectTableDir } from './paths.js';
 import { Addon } from './lib/addon.js';
+import type { FieldDefinition } from './types/common.d.ts';
 
 /**
  * 表文件信息接口
@@ -112,9 +112,9 @@ export const checkDefault = async function (): Promise<void> {
                 let fileRules = 0;
 
                 // 检查 table 中的每个验证规则
-                for (const [colKey, rule] of Object.entries(table)) {
-                    if (typeof rule !== 'string') {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 规则必须为字符串`);
+                for (const [colKey, fieldDef] of Object.entries(table)) {
+                    if (typeof fieldDef !== 'object' || fieldDef === null || Array.isArray(fieldDef)) {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 规则必须为对象`);
                         fileValid = false;
                         continue;
                     }
@@ -129,17 +129,58 @@ export const checkDefault = async function (): Promise<void> {
                         fileValid = false;
                     }
 
-                    // 使用 parseRule 解析字段规则
-                    let parsed;
-                    try {
-                        parsed = parseRule(rule);
-                    } catch (error: any) {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段规则解析失败：${error.message}`);
+                    // 直接使用字段对象
+                    const field = fieldDef as FieldDefinition;
+
+                    // 检查必填字段：name, type, min, max
+                    if (!field.name || typeof field.name !== 'string') {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 缺少必填字段 name 或类型错误`);
+                        fileValid = false;
+                        continue;
+                    }
+                    if (!field.type || typeof field.type !== 'string') {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 缺少必填字段 type 或类型错误`);
+                        fileValid = false;
+                        continue;
+                    }
+                    if (field.min === undefined) {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 缺少必填字段 min`);
+                        fileValid = false;
+                        continue;
+                    }
+                    if (field.max === undefined) {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 缺少必填字段 max`);
                         fileValid = false;
                         continue;
                     }
 
-                    const { name: fieldName, type: fieldType, min: fieldMin, max: fieldMax, default: fieldDefault, index: fieldIndex, regex: fieldRegx } = parsed;
+                    // 检查可选字段的类型
+                    if (field.detail !== undefined && typeof field.detail !== 'string') {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段 detail 类型错误，必须为字符串`);
+                        fileValid = false;
+                    }
+                    if (field.index !== undefined && typeof field.index !== 'boolean') {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段 index 类型错误，必须为布尔值`);
+                        fileValid = false;
+                    }
+                    if (field.unique !== undefined && typeof field.unique !== 'boolean') {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段 unique 类型错误，必须为布尔值`);
+                        fileValid = false;
+                    }
+                    if (field.nullable !== undefined && typeof field.nullable !== 'boolean') {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段 nullable 类型错误，必须为布尔值`);
+                        fileValid = false;
+                    }
+                    if (field.unsigned !== undefined && typeof field.unsigned !== 'boolean') {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段 unsigned 类型错误，必须为布尔值`);
+                        fileValid = false;
+                    }
+                    if (field.regexp !== undefined && field.regexp !== null && typeof field.regexp !== 'string') {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段 regexp 类型错误，必须为 null 或字符串`);
+                        fileValid = false;
+                    }
+
+                    const { name: fieldName, type: fieldType, min: fieldMin, max: fieldMax, default: fieldDefault, index: fieldIndex, regexp: fieldRegexp } = field;
 
                     // 第1个值：名称必须为中文、数字、字母、下划线、短横线、空格
                     if (!FIELD_NAME_REGEX.test(fieldName)) {
@@ -171,18 +212,9 @@ export const checkDefault = async function (): Promise<void> {
                         }
                     }
 
-                    // 第6个值：是否创建索引必须为0或1
-                    if (fieldIndex !== 0 && fieldIndex !== 1) {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 索引标识 "${fieldIndex}" 格式错误，必须为0或1`);
-                        fileValid = false;
-                    }
-
-                    // 第7个值：必须为null或正则表达式（parseRule已经验证过了）
-                    // parseRule 已经将正则字符串转换为 RegExp 或 null，这里不需要再验证
-
                     // 第4个值与类型联动校验 + 默认值规则
                     if (fieldType === 'text') {
-                        // text：min/max 必须为 null，默认值必须为 'null'
+                        // text：min/max 必须为 null，默认值必须为 null
                         if (fieldMin !== null) {
                             Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最小值必须为 null，当前为 "${fieldMin}"`);
                             fileValid = false;
@@ -191,7 +223,7 @@ export const checkDefault = async function (): Promise<void> {
                             Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最大长度必须为 null，当前为 "${fieldMax}"`);
                             fileValid = false;
                         }
-                        if (fieldDefault !== 'null') {
+                        if (fieldDefault !== null) {
                             Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 text 类型，默认值必须为 null，当前为 "${fieldDefault}"`);
                             fileValid = false;
                         }
@@ -204,8 +236,9 @@ export const checkDefault = async function (): Promise<void> {
                             fileValid = false;
                         }
                     } else if (fieldType === 'number') {
-                        if (fieldDefault !== 'null' && typeof fieldDefault !== 'number') {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 number 类型，` + `默认值必须为数字或null，当前为 "${fieldDefault}"`);
+                        // number 类型：default 如果存在，必须为 null 或 number
+                        if (fieldDefault !== undefined && fieldDefault !== null && typeof fieldDefault !== 'number') {
+                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 number 类型，` + `默认值必须为数字或 null，当前为 "${fieldDefault}"`);
                             fileValid = false;
                         }
                     }

package/lib/cacheHelper.ts

@@ -0,0 +1,169 @@
+/**
+ * 缓存助手 - TypeScript 版本
+ * 负责在服务器启动时缓存接口、菜单和角色权限到 Redis
+ */
+
+import { Logger } from './logger.js';
+import type { BeflyContext } from '../types/befly.js';
+
+/**
+ * 缓存助手类
+ */
+export class CacheHelper {
+    private befly: BeflyContext;
+
+    /**
+     * 构造函数
+     * @param befly - Befly 上下文
+     */
+    constructor(befly: BeflyContext) {
+        this.befly = befly;
+    }
+
+    /**
+     * 缓存所有接口到 Redis
+     */
+    async cacheApis(): Promise<void> {
+        try {
+            // 检查表是否存在
+            const tableExists = await this.befly.db.tableExists('core_api');
+            if (!tableExists) {
+                Logger.warn('⚠️ 接口表不存在，跳过接口缓存');
+                return;
+            }
+
+            // 从数据库查询所有接口（与 apiAll.ts 保持一致）
+            const apiList = await this.befly.db.getAll({
+                table: 'core_api',
+                fields: ['id', 'name', 'path', 'method', 'description', 'addonName', 'addonTitle'],
+                orderBy: ['addonName#ASC', 'path#ASC']
+            });
+
+            // 缓存到 Redis
+            const result = await this.befly.redis.setObject('apis:all', apiList);
+
+            if (result === null) {
+                Logger.warn('⚠️ 接口缓存失败');
+            } else {
+                Logger.info(`✅ 已缓存 ${apiList.length} 个接口到 Redis (Key: apis:all)`);
+            }
+        } catch (error: any) {
+            Logger.error('⚠️ 接口缓存异常:', error);
+        }
+    }
+
+    /**
+     * 缓存所有菜单到 Redis（从数据库读取）
+     */
+    async cacheMenus(): Promise<void> {
+        try {
+            // 检查表是否存在
+            const tableExists = await this.befly.db.tableExists('core_menu');
+            if (!tableExists) {
+                Logger.warn('⚠️ 菜单表不存在，跳过菜单缓存');
+                return;
+            }
+
+            // 从数据库查询所有菜单
+            const menus = await this.befly.db.getAll({
+                table: 'core_menu',
+                fields: ['id', 'pid', 'name', 'path', 'icon', 'type', 'sort'],
+                orderBy: ['sort#ASC', 'id#ASC']
+            });
+
+            // 缓存到 Redis
+            const result = await this.befly.redis.setObject('menus:all', menus);
+
+            if (result === null) {
+                Logger.warn('⚠️ 菜单缓存失败');
+            } else {
+                Logger.info(`✅ 已缓存 ${menus.length} 个菜单到 Redis (Key: menus:all)`);
+            }
+        } catch (error: any) {
+            const errorMessage = error?.message || error?.toString?.() || String(error);
+            Logger.warn('⚠️ 菜单缓存异常:', errorMessage);
+        }
+    }
+
+    /**
+     * 缓存所有角色的接口权限到 Redis
+     */
+    async cacheRolePermissions(): Promise<void> {
+        try {
+            // 检查表是否存在
+            const apiTableExists = await this.befly.db.tableExists('core_api');
+            const roleTableExists = await this.befly.db.tableExists('core_role');
+
+            if (!apiTableExists || !roleTableExists) {
+                Logger.warn('⚠️ 接口或角色表不存在，跳过角色权限缓存');
+                return;
+            }
+
+            // 查询所有角色
+            const roles = await this.befly.db.getAll({
+                table: 'core_role',
+                fields: ['id', 'code', 'apis']
+            });
+
+            // 查询所有接口（用于权限映射）
+            const allApis = await this.befly.db.getAll({
+                table: 'core_api',
+                fields: ['id', 'name', 'path', 'method', 'description', 'addonName']
+            });
+
+            // 为每个角色缓存接口权限
+            let cachedRoles = 0;
+            for (const role of roles) {
+                if (!role.apis) continue;
+
+                // 解析角色的接口 ID 列表
+                const apiIds = role.apis
+                    .split(',')
+                    .map((id: string) => parseInt(id.trim()))
+                    .filter((id: number) => !isNaN(id));
+
+                // 根据 ID 过滤出接口路径
+                const roleApiPaths = allApis.filter((api: any) => apiIds.includes(api.id)).map((api: any) => `${api.method}${api.path}`);
+
+                if (roleApiPaths.length === 0) continue;
+
+                // 使用 Redis Set 缓存角色权限（性能优化：SADD + SISMEMBER）
+                const redisKey = `role:apis:${role.code}`;
+
+                // 先删除旧数据
+                await this.befly.redis.del(redisKey);
+
+                // 批量添加到 Set
+                const result = await this.befly.redis.sadd(redisKey, roleApiPaths);
+
+                if (result > 0) {
+                    cachedRoles++;
+                    Logger.debug(`   └ 角色 ${role.code}: ${result} 个接口`);
+                }
+            }
+
+            Logger.info(`✅ 已缓存 ${cachedRoles} 个角色的接口权限`);
+        } catch (error: any) {
+            const errorMessage = error?.message || error?.toString?.() || String(error);
+            Logger.warn('⚠️ 角色权限缓存异常:', errorMessage);
+        }
+    }
+
+    /**
+     * 缓存所有数据
+     */
+    async cacheAll(): Promise<void> {
+        Logger.info('========== 开始缓存数据到 Redis ==========');
+
+        // 1. 缓存接口
+        await this.cacheApis();
+
+        // 2. 缓存菜单
+        await this.cacheMenus();
+
+        // 3. 缓存角色权限
+        await this.cacheRolePermissions();
+
+        Logger.info('========== 数据缓存完成 ==========\n');
+    }
+}

package/lib/redisHelper.ts

@@ -14,22 +14,22 @@ import { Database } from './database.js';
 const prefix = Env.REDIS_KEY_PREFIX ? `${Env.REDIS_KEY_PREFIX}:` : '';
 
 /**
- * 获取 Redis 客户端
- * @returns Redis 客户端实例
- * @throws 如果客户端未初始化
+ * Redis 助手类
  */
-function getClient(): RedisClient {
-    const client = Database.getRedis();
-    if (!client) {
-        throw new Error('Redis 客户端未初始化，请先调用 Database.connectRedis()');
+export class RedisHelper {
+    private client: RedisClient;
+
+    /**
+     * 构造函数
+     */
+    constructor() {
+        const client = Database.getRedis();
+        if (!client) {
+            throw new Error('Redis 客户端未初始化，请先调用 Database.connectRedis()');
+        }
+        this.client = client;
     }
-    return client;
-}
 
-/**
- * Redis 助手对象
- */
-export const RedisHelper = {
     /**
      * 设置对象到 Redis
      * @param key - 键名
@@ -39,19 +39,18 @@ export const RedisHelper = {
      */
     async setObject<T = any>(key: string, obj: T, ttl: number | null = null): Promise<string | null> {
         try {
-            const client = getClient();
             const data = JSON.stringify(obj);
             const pkey = `${prefix}${key}`;
 
             if (ttl) {
-                return await client.setex(pkey, ttl, data);
+                return await this.client.setex(pkey, ttl, data);
             }
-            return await client.set(pkey, data);
+            return await this.client.set(pkey, data);
         } catch (error: any) {
             Logger.error('Redis setObject 错误', error);
             return null;
         }
-    },
+    }
 
     /**
      * 从 Redis 获取对象
@@ -60,15 +59,14 @@ export const RedisHelper = {
      */
     async getObject<T = any>(key: string): Promise<T | null> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            const data = await client.get(pkey);
+            const data = await this.client.get(pkey);
             return data ? JSON.parse(data) : null;
         } catch (error: any) {
             Logger.error('Redis getObject 错误', error);
             return null;
         }
-    },
+    }
 
     /**
      * 从 Redis 删除对象
@@ -76,13 +74,12 @@ export const RedisHelper = {
      */
     async delObject(key: string): Promise<void> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            await client.del(pkey);
+            await this.client.del(pkey);
         } catch (error: any) {
             Logger.error('Redis delObject 错误', error);
         }
-    },
+    }
 
     /**
      * 生成基于时间的唯一 ID
@@ -92,17 +89,16 @@ export const RedisHelper = {
      * @returns 唯一 ID (14位纯数字)
      */
     async genTimeID(): Promise<number> {
-        const client = getClient();
         const timestamp = Math.floor(Date.now() / 1000); // 秒级时间戳
         const key = `${prefix}time_id_counter:${timestamp}`;
 
-        const counter = await client.incr(key);
-        await client.expire(key, 1);
+        const counter = await this.client.incr(key);
+        await this.client.expire(key, 1);
 
         const counterSuffix = (counter % 10000).toString().padStart(4, '0');
 
         return Number(`${timestamp}${counterSuffix}`);
-    },
+    }
 
     /**
      * 批量生成基于时间的唯一 ID
@@ -121,13 +117,12 @@ export const RedisHelper = {
             throw new Error(`批量大小 ${count} 超过最大限制 ${MAX_BATCH_SIZE}`);
         }
 
-        const client = getClient();
         const timestamp = Math.floor(Date.now() / 1000); // 秒级时间戳
         const key = `${prefix}time_id_counter:${timestamp}`;
 
         // 使用 INCRBY 一次性获取 N 个连续计数
-        const startCounter = await client.incrby(key, count);
-        await client.expire(key, 1);
+        const startCounter = await this.client.incrby(key, count);
+        await this.client.expire(key, 1);
 
         // 生成 ID 数组
         const ids: number[] = [];
@@ -138,7 +133,7 @@ export const RedisHelper = {
         }
 
         return ids;
-    },
+    }
 
     /**
      * 设置字符串值
@@ -148,17 +143,16 @@ export const RedisHelper = {
      */
     async setString(key: string, value: string, ttl: number | null = null): Promise<string | null> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
             if (ttl) {
-                return await client.setex(pkey, ttl, value);
+                return await this.client.setex(pkey, ttl, value);
             }
-            return await client.set(pkey, value);
+            return await this.client.set(pkey, value);
         } catch (error: any) {
             Logger.error('Redis setString 错误', error);
             return null;
         }
-    },
+    }
 
     /**
      * 获取字符串值
@@ -166,14 +160,13 @@ export const RedisHelper = {
      */
     async getString(key: string): Promise<string | null> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.get(pkey);
+            return await this.client.get(pkey);
         } catch (error: any) {
             Logger.error('Redis getString 错误', error);
             return null;
         }
-    },
+    }
 
     /**
      * 检查键是否存在
@@ -181,14 +174,13 @@ export const RedisHelper = {
      */
     async exists(key: string): Promise<number> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.exists(pkey);
+            return await this.client.exists(pkey);
         } catch (error: any) {
             Logger.error('Redis exists 错误', error);
             return 0;
         }
-    },
+    }
 
     /**
      * 设置过期时间
@@ -197,14 +189,13 @@ export const RedisHelper = {
      */
     async expire(key: string, seconds: number): Promise<number> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.expire(pkey, seconds);
+            return await this.client.expire(pkey, seconds);
         } catch (error: any) {
             Logger.error('Redis expire 错误', error);
             return 0;
         }
-    },
+    }
 
     /**
      * 获取剩余过期时间
@@ -212,14 +203,13 @@ export const RedisHelper = {
      */
     async ttl(key: string): Promise<number> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.ttl(pkey);
+            return await this.client.ttl(pkey);
         } catch (error: any) {
             Logger.error('Redis ttl 错误', error);
             return -1;
         }
-    },
+    }
 
     /**
      * 向 Set 中添加一个或多个成员
@@ -231,14 +221,13 @@ export const RedisHelper = {
         try {
             if (members.length === 0) return 0;
 
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.sadd(pkey, ...members);
+            return await this.client.sadd(pkey, ...members);
         } catch (error: any) {
             Logger.error('Redis sadd 错误', error);
             return 0;
         }
-    },
+    }
 
     /**
      * 判断成员是否在 Set 中
@@ -248,14 +237,13 @@ export const RedisHelper = {
      */
     async sismember(key: string, member: string): Promise<number> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.sismember(pkey, member);
+            return await this.client.sismember(pkey, member);
         } catch (error: any) {
             Logger.error('Redis sismember 错误', error);
             return 0;
         }
-    },
+    }
 
     /**
      * 获取 Set 的成员数量
@@ -264,14 +252,13 @@ export const RedisHelper = {
      */
     async scard(key: string): Promise<number> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.scard(pkey);
+            return await this.client.scard(pkey);
         } catch (error: any) {
             Logger.error('Redis scard 错误', error);
             return 0;
         }
-    },
+    }
 
     /**
      * 获取 Set 的所有成员
@@ -280,14 +267,13 @@ export const RedisHelper = {
      */
     async smembers(key: string): Promise<string[]> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.smembers(pkey);
+            return await this.client.smembers(pkey);
         } catch (error: any) {
             Logger.error('Redis smembers 错误', error);
             return [];
         }
-    },
+    }
 
     /**
      * 删除键
@@ -296,14 +282,13 @@ export const RedisHelper = {
      */
     async del(key: string): Promise<number> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.del(pkey);
+            return await this.client.del(pkey);
         } catch (error: any) {
             Logger.error('Redis del 错误', error);
             return 0;
         }
-    },
+    }
 
     /**
      * 测试 Redis 连接
@@ -311,11 +296,10 @@ export const RedisHelper = {
      */
     async ping(): Promise<string> {
         try {
-            const client = getClient();
-            return await client.ping();
+            return await this.client.ping();
         } catch (error: any) {
             Logger.error('Redis ping 错误', error);
             throw error;
         }
     }
-};
+}