befly 3.8.2 → 3.8.3

package/check.ts

@@ -3,10 +3,13 @@
  * 验证表定义文件的格式和规则
  */
 
-import { basename } from 'pathe';
+import { basename, relative } from 'pathe';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { isPlainObject } from 'es-toolkit/compat';
 import { Logger } from './lib/logger.js';
-import { projectTableDir } from './paths.js';
-import { Addon } from './lib/addon.js';
+import { projectTableDir, projectApiDir } from './paths.js';
+import { scanAddons, getAddonDir, addonDirExists } from './util.js';
 import type { FieldDefinition } from './types/common.d.ts';
 
 /**
@@ -54,16 +57,10 @@ const MAX_VARCHAR_LENGTH = 65535;
  * 检查表定义文件
  * @throws 当检查失败时抛出异常
  */
-export const checkDefault = async function (): Promise<void> {
+export const checkTable = async function (): Promise<boolean> {
     try {
         const tablesGlob = new Bun.Glob('*.json');
 
-        // 统计信息
-        let totalFiles = 0;
-        let totalRules = 0;
-        let validFiles = 0;
-        let invalidFiles = 0;
-
         // 收集所有表文件
         const allTableFiles: TableFileInfo[] = [];
 
@@ -73,60 +70,58 @@ export const checkDefault = async function (): Promise<void> {
             absolute: true,
             onlyFiles: true
         })) {
-            allTableFiles.push({ file: file, type: 'project' });
+            allTableFiles.push({
+                file: file,
+                typeCode: 'project',
+                typeName: '项目'
+            });
         }
 
         // 收集 addon 表字段定义文件
-        const addons = Addon.scan();
+        const addons = scanAddons();
         for (const addonName of addons) {
-            const addonTablesDir = Addon.getDir(addonName, 'tables');
+            const addonTablesDir = getAddonDir(addonName, 'tables');
 
             for await (const file of tablesGlob.scan({
                 cwd: addonTablesDir,
                 absolute: true,
                 onlyFiles: true
             })) {
-                allTableFiles.push({ file: file, type: 'addon', addonName: addonName });
+                allTableFiles.push({
+                    file: file,
+                    typeCode: 'addon',
+                    typeName: `组件${addonName}`,
+                    addonName: addonName
+                });
             }
         }
 
         // 合并进行验证逻辑
-        for (const { file, type, addonName } of allTableFiles) {
-            totalFiles++;
-            const fileName = basename(file);
-            const fileBaseName = basename(file, '.json');
-            const fileType = type === 'project' ? '项目' : `组件${addonName}`;
+        for (const item of allTableFiles) {
+            const fileName = basename(item.file);
+            const fileBaseName = basename(item.file, '.json');
 
             try {
                 // 1) 文件名小驼峰校验
                 if (!LOWER_CAMEL_CASE_REGEX.test(fileBaseName)) {
-                    Logger.warn(`${fileType}表 ${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
-                    // 命名不合规，记录错误并计为无效文件，继续下一个文件
-                    invalidFiles++;
+                    Logger.warn(`${item.typeName}表 ${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
                     continue;
                 }
 
-                // 读取并解析 JSON 文件
-                const table = await Bun.file(file).json();
-                let fileValid = true;
-                let fileRules = 0;
+                // 动态导入 JSON 文件
+                const tableModule = await import(item.file, { with: { type: 'json' } });
+                const table = tableModule.default;
 
                 // 检查 table 中的每个验证规则
                 for (const [colKey, fieldDef] of Object.entries(table)) {
                     if (typeof fieldDef !== 'object' || fieldDef === null || Array.isArray(fieldDef)) {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 规则必须为对象`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 规则必须为对象`);
                         continue;
                     }
 
-                    // 验证规则格式
-                    fileRules++;
-                    totalRules++;
-
                     // 检查是否使用了保留字段
                     if (RESERVED_FIELDS.includes(colKey as any)) {
-                        Logger.warn(`${fileType}表 ${fileName} 文件包含保留字段 ${colKey}，` + `不能在表定义中使用以下字段: ${RESERVED_FIELDS.join(', ')}`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件包含保留字段 ${colKey}，` + `不能在表定义中使用以下字段: ${RESERVED_FIELDS.join(', ')}`);
                     }
 
                     // 直接使用字段对象
@@ -134,81 +129,66 @@ export const checkDefault = async function (): Promise<void> {
 
                     // 检查必填字段：name, type, min, max
                     if (!field.name || typeof field.name !== 'string') {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 缺少必填字段 name 或类型错误`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 缺少必填字段 name 或类型错误`);
                         continue;
                     }
                     if (!field.type || typeof field.type !== 'string') {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 缺少必填字段 type 或类型错误`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 缺少必填字段 type 或类型错误`);
                         continue;
                     }
                     if (field.min === undefined) {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 缺少必填字段 min`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 缺少必填字段 min`);
                         continue;
                     }
                     if (field.max === undefined) {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 缺少必填字段 max`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 缺少必填字段 max`);
                         continue;
                     }
 
                     // 检查可选字段的类型
                     if (field.detail !== undefined && typeof field.detail !== 'string') {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段 detail 类型错误，必须为字符串`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 detail 类型错误，必须为字符串`);
                     }
                     if (field.index !== undefined && typeof field.index !== 'boolean') {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段 index 类型错误，必须为布尔值`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 index 类型错误，必须为布尔值`);
                     }
                     if (field.unique !== undefined && typeof field.unique !== 'boolean') {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段 unique 类型错误，必须为布尔值`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 unique 类型错误，必须为布尔值`);
                     }
                     if (field.nullable !== undefined && typeof field.nullable !== 'boolean') {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段 nullable 类型错误，必须为布尔值`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 nullable 类型错误，必须为布尔值`);
                     }
                     if (field.unsigned !== undefined && typeof field.unsigned !== 'boolean') {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段 unsigned 类型错误，必须为布尔值`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 unsigned 类型错误，必须为布尔值`);
                     }
                     if (field.regexp !== undefined && field.regexp !== null && typeof field.regexp !== 'string') {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段 regexp 类型错误，必须为 null 或字符串`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 regexp 类型错误，必须为 null 或字符串`);
                     }
 
                     const { name: fieldName, type: fieldType, min: fieldMin, max: fieldMax, default: fieldDefault, index: fieldIndex, regexp: fieldRegexp } = field;
 
                     // 第1个值：名称必须为中文、数字、字母、下划线、短横线、空格
                     if (!FIELD_NAME_REGEX.test(fieldName)) {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段名称 "${fieldName}" 格式错误，` + `必须为中文、数字、字母、下划线、短横线、空格`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段名称 "${fieldName}" 格式错误，` + `必须为中文、数字、字母、下划线、短横线、空格`);
                     }
 
                     // 第2个值：字段类型必须为string,number,text,array_string,array_text之一
                     if (!FIELD_TYPES.includes(fieldType as any)) {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段类型 "${fieldType}" 格式错误，` + `必须为${FIELD_TYPES.join('、')}之一`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段类型 "${fieldType}" 格式错误，` + `必须为${FIELD_TYPES.join('、')}之一`);
                     }
 
                     // 第3/4个值：需要是 null 或 数字
                     if (!(fieldMin === null || typeof fieldMin === 'number')) {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 格式错误，必须为null或数字`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 格式错误，必须为null或数字`);
                     }
                     if (!(fieldMax === null || typeof fieldMax === 'number')) {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最大值 "${fieldMax}" 格式错误，必须为null或数字`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 最大值 "${fieldMax}" 格式错误，必须为null或数字`);
                     }
 
                     // 约束：当最小值与最大值均为数字时，要求最小值 <= 最大值
                     if (fieldMin !== null && fieldMax !== null) {
                         if (fieldMin > fieldMax) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 不能大于最大值 "${fieldMax}"`);
-                            fileValid = false;
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 不能大于最大值 "${fieldMax}"`);
                         }
                     }
 
@@ -216,57 +196,150 @@ export const checkDefault = async function (): Promise<void> {
                     if (fieldType === 'text') {
                         // text：min/max 必须为 null，默认值必须为 null
                         if (fieldMin !== null) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最小值必须为 null，当前为 "${fieldMin}"`);
-                            fileValid = false;
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 的 text 类型最小值必须为 null，当前为 "${fieldMin}"`);
                         }
                         if (fieldMax !== null) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最大长度必须为 null，当前为 "${fieldMax}"`);
-                            fileValid = false;
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 的 text 类型最大长度必须为 null，当前为 "${fieldMax}"`);
                         }
                         if (fieldDefault !== null) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 text 类型，默认值必须为 null，当前为 "${fieldDefault}"`);
-                            fileValid = false;
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 为 text 类型，默认值必须为 null，当前为 "${fieldDefault}"`);
                         }
                     } else if (fieldType === 'string' || fieldType === 'array') {
                         if (fieldMax === null || typeof fieldMax !== 'number') {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，` + `最大长度必须为数字，当前为 "${fieldMax}"`);
-                            fileValid = false;
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，` + `最大长度必须为数字，当前为 "${fieldMax}"`);
                         } else if (fieldMax > MAX_VARCHAR_LENGTH) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最大长度 ${fieldMax} 越界，` + `${fieldType} 类型长度必须在 1..${MAX_VARCHAR_LENGTH} 范围内`);
-                            fileValid = false;
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 最大长度 ${fieldMax} 越界，` + `${fieldType} 类型长度必须在 1..${MAX_VARCHAR_LENGTH} 范围内`);
                         }
                     } else if (fieldType === 'number') {
                         // number 类型：default 如果存在，必须为 null 或 number
                         if (fieldDefault !== undefined && fieldDefault !== null && typeof fieldDefault !== 'number') {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 number 类型，` + `默认值必须为数字或 null，当前为 "${fieldDefault}"`);
-                            fileValid = false;
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 为 number 类型，` + `默认值必须为数字或 null，当前为 "${fieldDefault}"`);
                         }
                     }
                 }
+            } catch (error: any) {
+                Logger.error(`${item.typeName}表 ${fileName} 解析失败`, error);
+            }
+        }
+
+        return true;
+    } catch (error: any) {
+        Logger.error('数据表定义检查过程中出错', error);
+        return false;
+    }
+};
+
+/**
+ * 检查所有 API 定义
+ */
+export const checkApi = async function (): Promise<boolean> {
+    try {
+        const apiGlob = new Bun.Glob('**/*.ts');
+
+        // 收集所有 API 文件
+        const allApiFiles: Array<{ file: string; displayName: string }> = [];
+
+        // 收集项目 API 文件
+        if (existsSync(projectApiDir)) {
+            for await (const file of apiGlob.scan({
+                cwd: projectApiDir,
+                onlyFiles: true,
+                absolute: true
+            })) {
+                allApiFiles.push({
+                    file: file,
+                    displayName: '用户'
+                });
+            }
+        }
+
+        // 收集组件 API 文件
+        const addons = scanAddons();
+        for (const addon of addons) {
+            if (!addonDirExists(addon, 'apis')) continue;
+            const addonApiDir = getAddonDir(addon, 'apis');
+
+            for await (const file of apiGlob.scan({
+                cwd: addonApiDir,
+                onlyFiles: true,
+                absolute: true
+            })) {
+                allApiFiles.push({
+                    file: file,
+                    displayName: `组件${addon}`
+                });
+            }
+        }
 
-                if (fileValid) {
-                    validFiles++;
-                    // Logger.info(`${fileType}表 ${fileName} 验证通过（${fileRules} 个字段）`);
-                } else {
-                    invalidFiles++;
+        // 合并进行验证逻辑
+        for (const item of allApiFiles) {
+            const fileName = basename(item.file).replace(/\.ts$/, '');
+            const apiPath = relative(item.displayName === '用户' ? projectApiDir : getAddonDir(item.displayName.replace('组件', ''), 'apis'), item.file).replace(/\.ts$/, '');
+
+            // 跳过以下划线开头的文件
+            if (apiPath.indexOf('_') !== -1) continue;
+
+            try {
+                // Windows 下路径需要转换为正斜杠格式
+                const filePath = item.file.replace(/\\/g, '/');
+                const apiImport = await import(filePath);
+                const api = apiImport.default;
+
+                // 验证必填属性：name 和 handler
+                if (typeof api.name !== 'string' || api.name.trim() === '') {
+                    Logger.warn(`[${item.displayName}] 接口 ${apiPath} 的 name 属性必须是非空字符串`);
+                    continue;
+                }
+                if (typeof api.handler !== 'function') {
+                    Logger.warn(`[${item.displayName}] 接口 ${apiPath} 的 handler 属性必须是函数`);
+                    continue;
+                }
+
+                // 验证可选属性的类型（如果提供了）
+                if (api.method && !['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'].includes(api.method.toUpperCase())) {
+                    Logger.warn(`[${item.displayName}] 接口 ${apiPath} 的 method 属性必须是有效的 HTTP 方法`);
+                }
+                if (api.auth !== undefined && typeof api.auth !== 'boolean') {
+                    Logger.warn(`[${item.displayName}] 接口 ${apiPath} 的 auth 属性必须是布尔值 (true=需登录, false=公开)`);
+                }
+                if (api.fields && !isPlainObject(api.fields)) {
+                    Logger.warn(`[${item.displayName}] 接口 ${apiPath} 的 fields 属性必须是对象`);
+                }
+                if (api.required && !Array.isArray(api.required)) {
+                    Logger.warn(`[${item.displayName}] 接口 ${apiPath} 的 required 属性必须是数组`);
+                }
+                if (api.required && api.required.some((item: any) => typeof item !== 'string')) {
+                    Logger.warn(`[${item.displayName}] 接口 ${apiPath} 的 required 属性必须是字符串数组`);
                 }
             } catch (error: any) {
-                Logger.error(`${fileType}表 ${fileName} 解析失败`, error);
-                invalidFiles++;
+                Logger.error(`[${item.displayName}] 接口 ${apiPath} 解析失败`, error);
             }
         }
 
-        // 输出统计信息
-        // Logger.info(`  总文件数: ${totalFiles}`);
-        // Logger.info(`  总规则数: ${totalRules}`);
-        // Logger.info(`  通过文件: ${validFiles}`);
-        // Logger.info(`  失败文件: ${invalidFiles}`);
+        return true;
+    } catch (error: any) {
+        Logger.error('API 定义检查过程中出错', error);
+        return false;
+    }
+};
 
-        if (invalidFiles > 0) {
-            throw new Error('表定义检查失败，请修复上述错误后重试');
+/**
+ * 检查项目结构
+ */
+export const checkApp = async function (): Promise<boolean> {
+    try {
+        // 检查项目 apis 目录下是否存在名为 addon 的目录
+        if (existsSync(projectApiDir)) {
+            const addonDir = join(projectApiDir, 'addon');
+            if (existsSync(addonDir)) {
+                Logger.error('项目 apis 目录下不能存在名为 addon 的目录，addon 是保留名称，用于组件接口路由');
+                return false;
+            }
         }
+
+        return true;
     } catch (error: any) {
-        Logger.error('数据表定义检查过程中出错', error);
-        throw error;
+        Logger.error('项目结构检查过程中出错', error);
+        return false;
     }
 };

package/env.ts

@@ -18,14 +18,14 @@ const coreEnv: EnvConfig = {
     NODE_ENV: process.env.NODE_ENV || 'development',
     APP_NAME: isProd ? '野蜂飞舞正式环境' : '野蜂飞舞开发环境',
     APP_PORT: 3000,
-    APP_HOST: isProd ? '127.0.0.1' : '0.0.0.0',
+    APP_HOST: '127.0.0.1',
     DEV_EMAIL: 'dev@qq.com',
     DEV_PASSWORD: '123456',
     BODY_LIMIT: 10485760, // 10MB
     PARAMS_CHECK: false,
 
     // ========== 日志配置 ==========
-    LOG_DEBUG: isProd ? 0 : 1,
+    LOG_DEBUG: 0,
     LOG_EXCLUDE_FIELDS: 'password,token,secret',
     LOG_DIR: './logs',
     LOG_TO_CONSOLE: 1,
@@ -55,7 +55,7 @@ const coreEnv: EnvConfig = {
     REDIS_KEY_PREFIX: 'befly',
 
     // ========== JWT 配置 ==========
-    JWT_SECRET: isProd ? 'befly-dev-secret' : 'befly-prod-secret',
+    JWT_SECRET: 'befly-secret',
     JWT_EXPIRES_IN: '7d',
     JWT_ALGORITHM: 'HS256',
 

package/lib/cacheHelper.ts

@@ -166,4 +166,85 @@ export class CacheHelper {
 
         Logger.info('========== 数据缓存完成 ==========\n');
     }
+
+    /**
+     * 获取缓存的所有接口
+     * @returns 接口列表
+     */
+    async getApis(): Promise<any[]> {
+        try {
+            const apis = await this.befly.redis.getObject<any[]>('apis:all');
+            return apis || [];
+        } catch (error: any) {
+            Logger.error('获取接口缓存失败:', error);
+            return [];
+        }
+    }
+
+    /**
+     * 获取缓存的所有菜单
+     * @returns 菜单列表
+     */
+    async getMenus(): Promise<any[]> {
+        try {
+            const menus = await this.befly.redis.getObject<any[]>('menus:all');
+            return menus || [];
+        } catch (error: any) {
+            Logger.error('获取菜单缓存失败:', error);
+            return [];
+        }
+    }
+
+    /**
+     * 获取角色的接口权限
+     * @param roleCode - 角色代码
+     * @returns 接口路径列表
+     */
+    async getRolePermissions(roleCode: string): Promise<string[]> {
+        try {
+            const redisKey = `role:apis:${roleCode}`;
+            const permissions = await this.befly.redis.smembers(redisKey);
+            return permissions || [];
+        } catch (error: any) {
+            Logger.error(`获取角色 ${roleCode} 权限缓存失败:`, error);
+            return [];
+        }
+    }
+
+    /**
+     * 检查角色是否有指定接口权限
+     * @param roleCode - 角色代码
+     * @param apiPath - 接口路径（格式：METHOD/path）
+     * @returns 是否有权限
+     */
+    async checkRolePermission(roleCode: string, apiPath: string): Promise<boolean> {
+        try {
+            const redisKey = `role:apis:${roleCode}`;
+            const result = await this.befly.redis.sismember(redisKey, apiPath);
+            return result === 1;
+        } catch (error: any) {
+            Logger.error(`检查角色 ${roleCode} 权限失败:`, error);
+            return false;
+        }
+    }
+
+    /**
+     * 删除角色的接口权限缓存
+     * @param roleCode - 角色代码
+     * @returns 是否删除成功
+     */
+    async deleteRolePermissions(roleCode: string): Promise<boolean> {
+        try {
+            const redisKey = `role:apis:${roleCode}`;
+            const result = await this.befly.redis.del(redisKey);
+            if (result > 0) {
+                Logger.info(`✅ 已删除角色 ${roleCode} 的权限缓存`);
+                return true;
+            }
+            return false;
+        } catch (error: any) {
+            Logger.error(`删除角色 ${roleCode} 权限缓存失败:`, error);
+            return false;
+        }
+    }
 }