befly-tpl 3.0.1

package/addons/admin/scripts/syncApi.ts

@@ -0,0 +1,285 @@
+#!/usr/bin/env bun
+/**
+ * 同步 API 接口数据到数据库
+ * 说明：遍历所有 API 文件，收集接口路由信息并同步到 addon_admin_api 表
+ *
+ * 流程：
+ * 1. 扫描 tpl/apis 目录下所有 API 文件
+ * 2. 扫描 tpl/addons/组件/apis 目录下所有 API 文件
+ * 3. 提取每个 API 的 name、method、auth 等信息
+ * 4. 根据接口路径检查是否存在
+ * 5. 存在则更新，不存在则新增
+ * 6. 删除配置中不存在的接口记录
+ */
+
+import { Env, Logger, initDatabase, closeDatabase } from 'befly';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readdirSync, statSync } from 'node:fs';
+import { scanTsFiles, checkTableExists, deleteObsoleteRecords, logSyncStats, getAddonDirs } from '../util';
+
+// CLI 参数类型
+interface CliArgs {
+    DRY_RUN: boolean;
+}
+
+// API 信息类型
+interface ApiInfo {
+    name: string;
+    path: string;
+    method: string;
+    description: string;
+    addonName: string;
+    addonTitle: string;
+}
+
+// 解析命令行参数
+const CLI: CliArgs = {
+    DRY_RUN: process.argv.includes('--plan')
+};
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const tplDir = path.resolve(__dirname, '../../../');
+
+/**
+ * 从 API 文件中提取接口信息
+ * @param filePath - API 文件路径
+ * @param addonName - 插件名称
+ * @param addonTitle - 插件标题
+ * @returns API 信息对象或 null
+ */
+async function extractApiInfo(filePath: string, addonName: string = '', addonTitle: string = ''): Promise<ApiInfo | null> {
+    try {
+        // 动态导入 API 文件
+        const apiModule = await import(filePath);
+        const apiConfig = apiModule.default;
+
+        if (!apiConfig || !apiConfig.name) {
+            return null;
+        }
+
+        // 构建接口路径
+        let apiPath = '';
+        if (addonName) {
+            // 插件接口：/addon/{addonName}/{fileName}
+            const fileName = path.basename(filePath, '.ts');
+            apiPath = `/addon/${addonName}/${fileName}`;
+        } else {
+            // 项目接口：/api/{dirName}/{fileName}
+            const relativePath = path.relative(path.join(tplDir, 'apis'), filePath);
+            const parts = relativePath.replace(/\\/g, '/').split('/');
+            const dirName = parts[0];
+            const fileName = path.basename(filePath, '.ts');
+            apiPath = `/api/${dirName}/${fileName}`;
+        }
+
+        return {
+            name: apiConfig.name || '',
+            path: apiPath,
+            method: apiConfig.method || 'POST',
+            description: apiConfig.description || '',
+            addonName: addonName,
+            addonTitle: addonTitle || addonName
+        };
+    } catch (error: any) {
+        Logger.warn(`解析 API 文件失败: ${filePath}`, error.message);
+        return null;
+    }
+}
+
+/**
+ * 读取 Addon 配置文件（使用 Bun 原生方法）
+ * @param addonDir - Addon 目录路径
+ * @returns Addon 配置对象或 null
+ */
+async function loadAddonConfig(addonDir: string): Promise<{ name: string; title: string } | null> {
+    try {
+        const configPath = path.join(addonDir, 'addon.config.json');
+        const file = Bun.file(configPath);
+        const config = await file.json();
+        return {
+            name: config.name || '',
+            title: config.title || config.name || ''
+        };
+    } catch (error) {
+        return null;
+    }
+}
+
+/**
+ * 扫描所有 API 文件
+ * @returns API 信息数组
+ */
+async function scanAllApis(): Promise<ApiInfo[]> {
+    const apis: ApiInfo[] = [];
+
+    // 1. 扫描项目 API (tpl/apis)
+    Logger.info('=== 扫描项目 API (tpl/apis) ===');
+    const projectApisDir = path.join(tplDir, 'apis');
+    const projectApiFiles = scanTsFiles(projectApisDir);
+    Logger.info(`  找到 ${projectApiFiles.length} 个项目 API 文件`);
+
+    for (const filePath of projectApiFiles) {
+        const apiInfo = await extractApiInfo(filePath, '', '项目接口');
+        if (apiInfo) {
+            apis.push(apiInfo);
+            Logger.info(`  └ ${apiInfo.path} - ${apiInfo.name}`);
+        }
+    }
+
+    // 2. 扫描插件 API (tpl/addons/*/apis)
+    Logger.info('\n=== 扫描插件 API (tpl/addons/*/apis) ===');
+    const addonsDir = path.join(tplDir, 'addons');
+    const addonDirs = getAddonDirs(addonsDir);
+
+    for (const addonName of addonDirs) {
+        const addonDir = path.join(addonsDir, addonName);
+        const addonApisDir = path.join(addonDir, 'apis');
+
+        // 读取 addon 配置（使用 Bun 原生方法）
+        const addonConfig = await loadAddonConfig(addonDir);
+        const addonTitle = addonConfig?.title || addonName;
+
+        try {
+            const addonApiFiles = scanTsFiles(addonApisDir);
+            Logger.info(`  [${addonName}] 找到 ${addonApiFiles.length} 个 API 文件`);
+
+            for (const filePath of addonApiFiles) {
+                const apiInfo = await extractApiInfo(filePath, addonName, addonTitle);
+                if (apiInfo) {
+                    apis.push(apiInfo);
+                    Logger.info(`    └ ${apiInfo.path} - ${apiInfo.name}`);
+                }
+            }
+        } catch (error: any) {
+            Logger.warn(`  [${addonName}] 扫描失败:`, error.message);
+        }
+    }
+
+    return apis;
+}
+
+/**
+ * 同步 API 数据到数据库
+ * @param helper - DbHelper 实例
+ * @param apis - API 信息数组
+ * @returns 同步统计信息
+ */
+async function syncApis(helper: any, apis: ApiInfo[]): Promise<{ created: number; updated: number }> {
+    const stats = { created: 0, updated: 0 };
+
+    for (const api of apis) {
+        try {
+            const existing = await helper.getOne({
+                table: 'addon_admin_api',
+                where: { path: api.path }
+            });
+
+            if (existing) {
+                // 存在则更新
+                await helper.updData({
+                    table: 'addon_admin_api',
+                    where: { id: existing.id },
+                    data: {
+                        name: api.name,
+                        method: api.method,
+                        description: api.description,
+                        addonName: api.addonName,
+                        addonTitle: api.addonTitle
+                    }
+                });
+                stats.updated++;
+                Logger.info(`  └ 更新接口: ${api.name} (ID: ${existing.id}, Path: ${api.path})`);
+            } else {
+                // 不存在则新增
+                const id = await helper.insData({
+                    table: 'addon_admin_api',
+                    data: {
+                        name: api.name,
+                        path: api.path,
+                        method: api.method,
+                        description: api.description,
+                        addonName: api.addonName,
+                        addonTitle: api.addonTitle
+                    }
+                });
+                stats.created++;
+                Logger.info(`  └ 新增接口: ${api.name} (ID: ${id}, Path: ${api.path})`);
+            }
+        } catch (error: any) {
+            Logger.error(`同步接口 "${api.name}" 失败:`, error.message || String(error));
+        }
+    }
+
+    return stats;
+}
+
+/**
+ * 同步 API 主函数
+ */
+async function syncApi(): Promise<boolean> {
+    let dbInitialized = false;
+
+    try {
+        if (CLI.DRY_RUN) {
+            Logger.info('[计划] 同步 API 接口到数据库（plan 模式不执行）');
+            Logger.info('[计划] 1. 扫描 tpl/apis 和 tpl/addons/*/apis 目录');
+            Logger.info('[计划] 2. 提取每个 API 的配置信息');
+            Logger.info('[计划] 3. 根据 path 检查接口是否存在');
+            Logger.info('[计划] 4. 存在则更新，不存在则新增');
+            Logger.info('[计划] 5. 删除文件中不存在的接口记录');
+            return true;
+        }
+
+        Logger.info('开始同步 API 接口到数据库...\n');
+
+        // 初始化数据库连接
+        const { helper } = await initDatabase({ max: 1 });
+        dbInitialized = true;
+
+        // 1. 检查表是否存在
+        if (!(await checkTableExists(helper, 'addon_admin_api'))) {
+            return false;
+        }
+
+        Logger.info('');
+
+        // 2. 扫描所有 API 文件
+        Logger.info('=== 步骤 2: 扫描 API 文件 ===');
+        const apis = await scanAllApis();
+        const apiPaths = new Set(apis.map((api) => api.path));
+        Logger.info(`\n✅ 共扫描到 ${apis.length} 个 API 接口\n`);
+
+        // 3. 同步 API 数据（新增和更新）
+        Logger.info('=== 步骤 3: 同步 API 数据（新增/更新） ===');
+        const stats = await syncApis(helper, apis);
+
+        // 4. 删除文件中不存在的接口
+        const deletedCount = await deleteObsoleteRecords(helper, 'addon_admin_api', apiPaths);
+
+        // 5. 输出统计信息
+        logSyncStats(stats, deletedCount, '接口');
+        Logger.info(`当前总接口数: ${apis.length} 个`);
+        Logger.info('提示: 接口缓存将在服务器启动时自动完成');
+
+        return true;
+    } catch (error: any) {
+        Logger.error('API 同步失败:', { message: error.message, stack: error.stack });
+        return false;
+    } finally {
+        if (dbInitialized) {
+            await closeDatabase();
+        }
+    }
+}
+
+// 执行同步
+syncApi()
+    .then((success) => {
+        process.exit(success ? 0 : 1);
+    })
+    .catch((error) => {
+        Logger.error('执行失败:', error);
+        process.exit(1);
+    });

package/addons/admin/scripts/syncDev.ts

@@ -0,0 +1,203 @@
+/**
+ * 同步开发者管理员到数据库（使用 dbHelper）
+ * - 邮箱: dev@qq.com
+ * - 姓名: 开发者
+ * - 密码: 使用 bcrypt 加密
+ * - 角色: roleCode=dev, roleType=admin
+ * - 表名: addon_admin_admin
+ */
+
+import { Env, Logger, Crypto2, initDatabase, closeDatabase } from 'befly';
+
+// CLI 参数类型
+interface CliArgs {
+    DRY_RUN: boolean;
+}
+
+// 解析命令行参数
+const ARGV = Array.isArray(process.argv) ? process.argv : [];
+const CLI: CliArgs = { DRY_RUN: ARGV.includes('--plan') };
+
+/**
+ * 同步开发管理员账号（使用统一的 database 工具）
+ * 表名: addon_admin_admin
+ * 邮箱: dev@qq.com
+ * 用户名: dev
+ * 姓名: 开发者
+ * 角色: roleCode=dev, roleType=admin
+ * @returns 是否成功
+ */
+export async function SyncDev(): Promise<boolean> {
+    let dbInitialized = false;
+
+    try {
+        if (CLI.DRY_RUN) {
+            Logger.info('[计划] 同步完成后将初始化/更新开发管理员账号（plan 模式不执行）');
+            return true;
+        }
+
+        if (!Env.DEV_PASSWORD || !Env.MD5_SALT) {
+            Logger.warn('跳过开发管理员初始化：缺少 DEV_PASSWORD 或 MD5_SALT 配置');
+            return false;
+        }
+
+        // 初始化数据库连接（Redis + SQL + DbHelper）
+        const { helper } = await initDatabase({ max: 1 });
+        dbInitialized = true;
+
+        // 检查 addon_admin_admin 表是否存在（使用 helper.query 执行元数据查询）
+        const existAdmin = await helper.tableExists('addon_admin_admin');
+        if (!existAdmin) {
+            Logger.warn('跳过开发管理员初始化：未检测到 addon_admin_admin 表');
+            return false;
+        }
+
+        // 检查 addon_admin_role 表是否存在
+        const existRole = await helper.tableExists('addon_admin_role');
+        if (!existRole) {
+            Logger.warn('跳过开发管理员初始化：未检测到 addon_admin_role 表');
+            return false;
+        }
+
+        // 检查 addon_admin_menu 表是否存在
+        const existMenu = await helper.tableExists('addon_admin_menu');
+        if (!existMenu) {
+            Logger.warn('跳过开发管理员初始化：未检测到 addon_admin_menu 表');
+            return false;
+        }
+
+        // 查询所有菜单 ID
+        const allMenus = await helper.getAll({
+            table: 'addon_admin_menu',
+            fields: ['id']
+        });
+
+        if (!allMenus || !Array.isArray(allMenus)) {
+            Logger.warn('查询菜单失败或菜单表为空');
+            return false;
+        }
+
+        const menuIds = allMenus.length > 0 ? allMenus.map((m: any) => m.id).join(',') : '';
+        Logger.info(`查询到 ${allMenus.length} 个菜单，ID 列表: ${menuIds || '(空)'}`);
+
+        // 查询所有接口 ID
+        const existApi = await helper.tableExists('addon_admin_api');
+        let apiIds = '';
+        if (existApi) {
+            const allApis = await helper.getAll({
+                table: 'addon_admin_api',
+                fields: ['id']
+            });
+
+            if (allApis && Array.isArray(allApis) && allApis.length > 0) {
+                apiIds = allApis.map((a: any) => a.id).join(',');
+                Logger.info(`查询到 ${allApis.length} 个接口，ID 列表: ${apiIds}`);
+            } else {
+                Logger.info('未查询到接口数据');
+            }
+        } else {
+            Logger.info('接口表不存在，跳过接口权限配置');
+        }
+
+        // 查询或创建 dev 角色
+        let devRole = await helper.getOne({
+            table: 'addon_admin_role',
+            where: { code: 'dev' }
+        });
+
+        if (devRole) {
+            // 更新 dev 角色的菜单和接口权限
+            await helper.updData({
+                table: 'addon_admin_role',
+                where: { code: 'dev' },
+                data: {
+                    name: '开发者角色',
+                    description: '拥有所有菜单和接口权限的开发者角色',
+                    menus: menuIds,
+                    apis: apiIds
+                }
+            });
+            Logger.info('dev 角色菜单和接口权限已更新');
+        } else {
+            // 创建 dev 角色
+            const roleId = await helper.insData({
+                table: 'addon_admin_role',
+                data: {
+                    name: '开发者角色',
+                    code: 'dev',
+                    description: '拥有所有菜单和接口权限的开发者角色',
+                    menus: menuIds,
+                    apis: apiIds,
+                    sort: 0
+                }
+            });
+            devRole = { id: roleId };
+            Logger.info('dev 角色已创建');
+        }
+
+        // 使用 bcrypt 加密密码（与登录验证一致）
+        const hashed = await Crypto2.hashPassword(Env.DEV_PASSWORD);
+
+        // 准备开发管理员数据
+        const devData = {
+            name: '开发者',
+            nickname: '开发者',
+            email: 'dev@qq.com',
+            username: 'dev',
+            password: hashed,
+            roleId: devRole.id,
+            roleCode: 'dev',
+            roleType: 'admin' // 小驼峰，自动转换为 role_type
+        };
+
+        // 查询现有账号
+        const existing = await helper.getOne({
+            table: 'addon_admin_admin',
+            where: { email: 'dev@qq.com' }
+        });
+
+        if (existing) {
+            // 更新现有账号
+            await helper.updData({
+                table: 'addon_admin_admin',
+                where: { email: 'dev@qq.com' },
+                data: devData
+            });
+            Logger.info('开发管理员已更新：email=dev@qq.com, username=dev, roleCode=dev, roleType=admin');
+        } else {
+            // 插入新账号
+            await helper.insData({
+                table: 'addon_admin_admin',
+                data: devData
+            });
+            Logger.info('开发管理员已初始化：email=dev@qq.com, username=dev, roleCode=dev, roleType=admin');
+        }
+
+        return true;
+    } catch (error: any) {
+        Logger.warn(`开发管理员初始化步骤出错：${error.message}`);
+        return false;
+    } finally {
+        // 清理资源：关闭所有数据库连接
+        if (dbInitialized) {
+            await closeDatabase();
+        }
+    }
+}
+
+/**
+ * 允许直接运行该脚本
+ */
+if (import.meta.main) {
+    SyncDev()
+        .then((ok: boolean) => {
+            if (CLI.DRY_RUN) {
+                process.exit(0);
+            }
+            process.exit(ok ? 0 : 1);
+        })
+        .catch((err: Error) => {
+            Logger.error('❌ 开发管理员同步失败:', err);
+            process.exit(1);
+        });
+}

package/addons/admin/scripts/syncMenu.ts

@@ -0,0 +1,210 @@
+#!/usr/bin/env bun
+/**
+ * 同步菜单数据到数据库
+ * 说明：根据 menu.json 配置文件增量同步菜单数据（最多2级：父级和子级）
+ *
+ * 流程：
+ * 1. 读取 menu.json 配置文件
+ * 2. 根据菜单的 path 字段检查是否存在
+ * 3. 存在则更新其他字段（name、icon、sort、type、pid）
+ * 4. 不存在则新增菜单记录
+ * 5. 处理两层菜单结构（父级和子级，不支持多层嵌套）
+ * 注：state 字段由框架自动管理（1=正常，2=禁用，0=删除）
+ */
+
+import { Env, Logger, initDatabase, closeDatabase } from 'befly';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import menuConfig from '../config/menu.json';
+import { collectPaths, checkTableExists, deleteObsoleteRecords, logSyncStats } from '../util';
+
+// CLI 参数类型
+interface CliArgs {
+    DRY_RUN: boolean;
+}
+
+// 解析命令行参数
+const CLI: CliArgs = {
+    DRY_RUN: process.argv.includes('--plan')
+};
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * 同步菜单（两层结构：父级和子级）
+ * @param helper - DbHelper 实例
+ * @param menus - 菜单数组
+ * @returns 同步统计信息
+ */
+async function syncMenus(helper: any, menus: any[]): Promise<{ created: number; updated: number }> {
+    const stats = { created: 0, updated: 0 };
+
+    for (const menu of menus) {
+        try {
+            // 1. 同步父级菜单
+            const existingParent = await helper.getOne({
+                table: 'addon_admin_menu',
+                where: { path: menu.path || '' }
+            });
+
+            let parentId: number;
+
+            if (existingParent) {
+                // 存在则更新
+                await helper.updData({
+                    table: 'addon_admin_menu',
+                    where: { id: existingParent.id },
+                    data: {
+                        pid: 0,
+                        name: menu.name,
+                        icon: menu.icon || '',
+                        sort: menu.sort || 0,
+                        type: menu.type || 1
+                    }
+                });
+                parentId = existingParent.id;
+                stats.updated++;
+                Logger.info(`  └ 更新父级菜单: ${menu.name} (ID: ${parentId}, Path: ${menu.path})`);
+            } else {
+                // 不存在则新增
+                parentId = await helper.insData({
+                    table: 'addon_admin_menu',
+                    data: {
+                        pid: 0,
+                        name: menu.name,
+                        path: menu.path || '',
+                        icon: menu.icon || '',
+                        sort: menu.sort || 0,
+                        type: menu.type || 1
+                    }
+                });
+                stats.created++;
+                Logger.info(`  └ 新增父级菜单: ${menu.name} (ID: ${parentId}, Path: ${menu.path})`);
+            }
+
+            // 2. 同步子级菜单
+            if (menu.children && menu.children.length > 0) {
+                for (const child of menu.children) {
+                    const existingChild = await helper.getOne({
+                        table: 'addon_admin_menu',
+                        where: { path: child.path || '' }
+                    });
+
+                    if (existingChild) {
+                        // 存在则更新
+                        await helper.updData({
+                            table: 'addon_admin_menu',
+                            where: { id: existingChild.id },
+                            data: {
+                                pid: parentId,
+                                name: child.name,
+                                icon: child.icon || '',
+                                sort: child.sort || 0,
+                                type: child.type || 1
+                            }
+                        });
+                        stats.updated++;
+                        Logger.info(`    └ 更新子级菜单: ${child.name} (ID: ${existingChild.id}, PID: ${parentId}, Path: ${child.path})`);
+                    } else {
+                        // 不存在则新增
+                        const childId = await helper.insData({
+                            table: 'addon_admin_menu',
+                            data: {
+                                pid: parentId,
+                                name: child.name,
+                                path: child.path || '',
+                                icon: child.icon || '',
+                                sort: child.sort || 0,
+                                type: child.type || 1
+                            }
+                        });
+                        stats.created++;
+                        Logger.info(`    └ 新增子级菜单: ${child.name} (ID: ${childId}, PID: ${parentId}, Path: ${child.path})`);
+                    }
+                }
+            }
+        } catch (error: any) {
+            Logger.error(`同步菜单 "${menu.name}" 失败:`, error.message || String(error));
+            throw error;
+        }
+    }
+
+    return stats;
+}
+
+/**
+ * 同步菜单主函数
+ */
+async function syncMenu(): Promise<boolean> {
+    let dbInitialized = false;
+
+    try {
+        if (CLI.DRY_RUN) {
+            Logger.info('[计划] 同步菜单配置到数据库（plan 模式不执行）');
+            Logger.info('[计划] 1. 读取 menu.json 配置文件');
+            Logger.info('[计划] 2. 根据 path 检查菜单是否存在');
+            Logger.info('[计划] 3. 存在则更新，不存在则新增');
+            Logger.info('[计划] 4. 处理两层菜单结构（父级和子级）');
+            Logger.info('[计划] 5. 显示菜单结构预览');
+            return true;
+        }
+
+        Logger.info('开始同步菜单配置到数据库...\n');
+
+        // 初始化数据库连接（Redis + SQL + DbHelper）
+        const { helper } = await initDatabase({ max: 1 });
+        dbInitialized = true;
+
+        // 1. 检查表是否存在
+        if (!(await checkTableExists(helper, 'addon_admin_menu'))) {
+            return false;
+        }
+
+        // 2. 收集配置文件中所有菜单的 path
+        Logger.info('\n=== 步骤 2: 收集配置菜单路径 ===');
+        const configPaths = collectPaths(menuConfig);
+        Logger.info(`✅ 配置文件中共有 ${configPaths.size} 个菜单路径`);
+
+        // 3. 同步菜单（新增和更新）
+        Logger.info('\n=== 步骤 3: 同步菜单数据（新增/更新） ===');
+        const stats = await syncMenus(helper, menuConfig);
+
+        //  4. 删除文件中不存在的菜单
+        const deletedCount = await deleteObsoleteRecords(helper, 'addon_admin_menu', configPaths);
+
+        // 5. 构建树形结构预览
+        Logger.info('\n=== 步骤 5: 菜单结构预览 ===');
+        const allMenus = await helper.getAll({
+            table: 'addon_admin_menu',
+            fields: ['id', 'pid', 'name', 'path', 'type'],
+            orderBy: ['pid#ASC', 'sort#ASC', 'id#ASC']
+        });
+
+        // 6. 输出统计信息
+        logSyncStats(stats, deletedCount, '菜单');
+        Logger.info(`当前父级菜单: ${allMenus.filter((m: any) => m.pid === 0).length} 个`);
+        Logger.info(`当前子级菜单: ${allMenus.filter((m: any) => m.pid !== 0).length} 个`);
+        Logger.info('提示: 菜单缓存将在服务器启动时自动完成');
+
+        return true;
+    } catch (error: any) {
+        console.log('🔥[ error ]-262', error);
+        Logger.error('菜单同步失败:', { message: error.message, stack: error.stack });
+        return false;
+    } finally {
+        if (dbInitialized) {
+            await closeDatabase();
+        }
+    }
+}
+
+// 执行同步
+syncMenu()
+    .then((success) => {
+        process.exit(success ? 0 : 1);
+    })
+    .catch((error) => {
+        Logger.error('执行失败:', error);
+        process.exit(1);
+    });