befly 3.3.4 → 3.4.0

package/apis/menu/ins.ts

@@ -0,0 +1,20 @@
+import { Yes, No } from '../../util.js';
+import adminMenuTable from '../../tables/menu.json';
+
+export default {
+    name: '创建菜单',
+    fields: adminMenuTable,
+    handler: async (befly, ctx) => {
+        try {
+            const menuId = await befly.db.insData({
+                table: 'core_menu',
+                data: ctx.body
+            });
+
+            return Yes('操作成功', { id: menuId });
+        } catch (error) {
+            befly.logger.error('创建菜单失败:', error);
+            return No('操作失败');
+        }
+    }
+};

package/apis/menu/list.ts

@@ -0,0 +1,21 @@
+import { Yes, No } from '../../util.js';
+export default {
+    name: '获取菜单列表',
+    handler: async (befly, ctx) => {
+        try {
+            const menus = await befly.db.getAll({
+                table: 'core_menu',
+                fields: ['id', 'name', 'path', 'icon', 'sort', 'pid', 'type', 'state', 'created_at', 'updated_at'],
+                orderBy: [
+                    { field: 'sort', direction: 'ASC' },
+                    { field: 'id', direction: 'ASC' }
+                ]
+            });
+
+            return Yes('操作成功', menus);
+        } catch (error) {
+            befly.logger.error('获取菜单列表失败:', error);
+            return No('操作失败');
+        }
+    }
+};

package/apis/menu/upd.ts

@@ -0,0 +1,29 @@
+import { Yes, No } from '../../util.js';
+import adminMenuTable from '../../tables/menu.json';
+
+export default {
+    name: '更新菜单',
+    fields: adminMenuTable,
+    handler: async (befly, ctx) => {
+        try {
+            await befly.db.updData({
+                table: 'core_menu',
+                where: { id: ctx.body.id },
+                data: {
+                    name: ctx.body.name,
+                    path: ctx.body.path,
+                    icon: ctx.body.icon,
+                    sort: ctx.body.sort,
+                    pid: ctx.body.pid,
+                    type: ctx.body.type
+                    // state 字段不在此处更新，需要禁用/启用时单独处理
+                }
+            });
+
+            return Yes('操作成功');
+        } catch (error) {
+            befly.logger.error('更新菜单失败:', error);
+            return No('操作失败');
+        }
+    }
+};

package/apis/role/apiDetail.ts

@@ -0,0 +1,30 @@
+/**
+ * 获取角色的接口权限
+ */
+
+import { Yes, No } from '../../util.js';
+
+export default {
+    name: '获取角色接口权限',
+    handler: async (befly, ctx) => {
+        // 查询角色信息
+        const role = await befly.db.getOne({
+            table: 'core_role',
+            where: { id: ctx.body.roleId }
+        });
+
+        if (!role) {
+            return No('角色不存在');
+        }
+
+        // 解析接口ID列表（逗号分隔的字符串转为数组）
+        const apiIds = role.apis
+            ? role.apis
+                  .split(',')
+                  .map((id: string) => parseInt(id.trim()))
+                  .filter((id: number) => !isNaN(id))
+            : [];
+
+        return Yes('操作成功', { apiIds });
+    }
+};

package/apis/role/apiSave.ts

@@ -0,0 +1,41 @@
+/**
+ * 保存角色的接口权限
+ */
+
+import { Yes, No } from '../../util.js';
+import adminRoleTable from '../../tables/role.json';
+
+export default {
+    name: '保存角色接口权限',
+    fields: {
+        apiIds: adminRoleTable.apis
+    },
+    handler: async (befly, ctx) => {
+        // 查询角色是否存在
+        const role = await befly.db.getOne({
+            table: 'core_role',
+            where: { id: ctx.body.roleId }
+        });
+
+        if (!role) {
+            return No('角色不存在');
+        }
+
+        // 将数组转为逗号分隔的字符串存储
+        const apiIdsStr = Array.isArray(ctx.body.apiIds) ? ctx.body.apiIds.join(',') : '';
+
+        // 更新角色的接口权限
+        await befly.db.updData({
+            table: 'core_role',
+            where: { id: ctx.body.roleId },
+            data: {
+                apis: apiIdsStr
+            }
+        });
+
+        // 增量更新 Redis 缓存
+        await befly.cache.cacheRolePermissions(befly, role.code, apiIdsStr);
+
+        return Yes('操作成功');
+    }
+};

package/apis/role/del.ts

@@ -0,0 +1,44 @@
+/**
+ * 删除角色
+ */
+
+import { Yes, No } from '../../util.js';
+
+export default {
+    name: '删除角色',
+    handler: async (befly, ctx) => {
+        try {
+            // 检查是否有用户使用此角色（使用 getList 代替 getAll）
+            const adminList = await befly.db.getList({
+                table: 'core_admin',
+                where: { roleId: ctx.body.id }
+            });
+
+            if (adminList.total > 0) {
+                return No('该角色已分配给用户，无法删除');
+            }
+
+            // 获取角色信息（用于删除缓存）
+            const role = await befly.db.getDetail({
+                table: 'core_role',
+                where: { id: ctx.body.id }
+            });
+
+            // 删除角色
+            await befly.db.delData({
+                table: 'core_role',
+                where: { id: ctx.body.id }
+            });
+
+            // 删除角色权限缓存
+            if (role?.code) {
+                await befly.cache.deleteRolePermissions(befly, role.code);
+            }
+
+            return Yes('操作成功');
+        } catch (error) {
+            befly.logger.error('删除角色失败:', error);
+            return No('操作失败');
+        }
+    }
+};

package/apis/role/detail.ts

@@ -0,0 +1,24 @@
+/**
+ * 获取用户的角色（单角色模式）
+ */
+
+import { Yes, No } from '../../util.js';
+
+export default {
+    name: '获取用户角色',
+    handler: async (befly, ctx) => {
+        let roleInfo = null;
+        if (ctx.body.id && ctx.user.roleType === 'admin') {
+            roleInfo = await befly.db.getOne({
+                table: 'core_role',
+                where: { code: ctx.body.id }
+            });
+        }
+
+        return Yes('操作成功', {
+            roleId: ctx.body.id,
+            roleCode: ctx.body.id,
+            role: roleInfo
+        });
+    }
+};

package/apis/role/ins.ts

@@ -0,0 +1,39 @@
+import { Yes, No } from '../../util.js';
+import adminRoleTable from '../../tables/role.json';
+
+/**
+ * 创建角色
+ */
+export default {
+    name: '创建角色',
+    fields: adminRoleTable,
+    handler: async (befly, ctx) => {
+        // 检查角色代码是否已存在
+        const existing = await befly.db.getOne({
+            table: 'core_role',
+            where: { code: ctx.body.code }
+        });
+
+        if (existing) {
+            return No('角色代码已存在');
+        }
+
+        const roleId = await befly.db.insData({
+            table: 'core_role',
+            data: {
+                name: ctx.body.name,
+                code: ctx.body.code,
+                description: ctx.body.description,
+                menus: ctx.body.menus || '',
+                apis: ctx.body.apis || '',
+                sort: ctx.body.sort
+                // state 由框架自动设置为 1
+            }
+        });
+
+        // 增量缓存角色权限到 Redis Set
+        await befly.cache.cacheRolePermissions(befly, ctx.body.code, ctx.body.apis || '');
+
+        return Yes('操作成功', { id: roleId });
+    }
+};

package/apis/role/list.ts

@@ -0,0 +1,14 @@
+import { Yes } from '../../util.js';
+
+export default {
+    name: '获取角色列表',
+    handler: async (befly, ctx) => {
+        const roles = await befly.db.getList({
+            limit: 30,
+            table: 'core_role',
+            orderBy: ['sort#ASC', 'id#ASC']
+        });
+
+        return Yes('操作成功', roles);
+    }
+};

package/apis/role/menuDetail.ts

@@ -0,0 +1,30 @@
+/**
+ * 获取角色的菜单权限
+ */
+
+import { Yes, No } from '../../util.js';
+
+export default {
+    name: '获取角色菜单权限',
+    handler: async (befly, ctx) => {
+        // 查询角色信息
+        const role = await befly.db.getOne({
+            table: 'core_role',
+            where: { id: ctx.body.roleId }
+        });
+
+        if (!role) {
+            return No('角色不存在');
+        }
+
+        // 解析菜单ID列表（逗号分隔的字符串转为数组）
+        const menuIds = role.menus
+            ? role.menus
+                  .split(',')
+                  .map((id: string) => parseInt(id.trim()))
+                  .filter((id: number) => !isNaN(id))
+            : [];
+
+        return Yes('操作成功', menuIds);
+    }
+};

package/apis/role/menuSave.ts

@@ -0,0 +1,38 @@
+/**
+ * 保存角色的菜单权限
+ */
+
+import { Yes, No } from '../../util.js';
+import adminRoleTable from '../../tables/role.json';
+
+export default {
+    name: '保存角色菜单权限',
+    fields: {
+        menuIds: adminRoleTable.menus
+    },
+    handler: async (befly, ctx) => {
+        // 查询角色是否存在
+        const role = await befly.db.getOne({
+            table: 'core_role',
+            where: { id: ctx.body.roleId }
+        });
+
+        if (!role) {
+            return No('角色不存在');
+        }
+
+        // 将数组转为逗号分隔的字符串存储
+        const menuIdsStr = Array.isArray(ctx.body.menuIds) ? ctx.body.menuIds.join(',') : '';
+
+        // 更新角色的菜单权限
+        await befly.db.updData({
+            table: 'core_role',
+            where: { id: ctx.body.roleId },
+            data: {
+                menus: menuIdsStr
+            }
+        });
+
+        return Yes('操作成功');
+    }
+};

package/apis/role/save.ts

@@ -0,0 +1,44 @@
+/**
+ * 保存用户的角色（单角色模式）
+ */
+
+import { Yes, No } from '../../util.js';
+
+export default {
+    name: '保存用户角色',
+    fields: {
+        roleCode: '角色编码|string|2|50|null|1|^[a-zA-Z0-9_]+$'
+    },
+    handler: async (befly, ctx) => {
+        try {
+            // 查询角色是否存在（使用 roleCode 而非 roleId）
+            const role = await befly.db.getOne({
+                table: 'core_role',
+                where: { code: ctx.body.roleCode }
+            });
+
+            if (!role) {
+                return No('角色不存在');
+            }
+
+            // 根据角色编码判断角色类型（硬编码规则）
+            const roleType = role.code === 'dev' || role.code === 'admin' ? 'admin' : 'user';
+
+            // 更新管理员的角色ID、角色编码和角色类型
+            await befly.db.updData({
+                table: 'core_admin',
+                where: { id: ctx.body.adminId },
+                data: {
+                    roleId: role.id,
+                    roleCode: role.code,
+                    roleType: roleType
+                }
+            });
+
+            return Yes('操作成功');
+        } catch (error) {
+            befly.logger.error('保存用户角色失败:', error);
+            return No('操作失败');
+        }
+    }
+};

package/apis/role/upd.ts

@@ -0,0 +1,40 @@
+import { Yes, No } from '../../util.js';
+import adminRoleTable from '../../tables/role.json';
+
+export default {
+    name: '更新角色',
+    fields: adminRoleTable,
+    handler: async (befly, ctx) => {
+        // 检查角色代码是否被其他角色占用
+        const existing = await befly.db.getList({
+            table: 'core_role',
+            where: {
+                code: ctx.body.code,
+                id$ne: ctx.body.id
+            }
+        });
+
+        if (existing.total > 0) {
+            return No('角色代码已被其他角色使用');
+        }
+
+        await befly.db.updData({
+            table: 'core_role',
+            where: { id: ctx.body.id },
+            data: {
+                name: ctx.body.name,
+                code: ctx.body.code,
+                description: ctx.body.description,
+                menus: ctx.body.menus || '',
+                apis: ctx.body.apis || '',
+                sort: ctx.body.sort
+                // state 字段不在此处更新，需要禁用/启用时单独处理
+            }
+        });
+
+        // 增量更新角色权限缓存（先删除再重建）
+        await befly.cache.cacheRolePermissions(befly, ctx.body.code, ctx.body.apis || '');
+
+        return Yes('操作成功');
+    }
+};

package/checks/conflict.ts

@@ -5,7 +5,7 @@
 
 import { relative, basename } from 'pathe';
 import { Logger } from '../lib/logger.js';
-import { paths } from '../paths.js';
+import { projectPluginDir, coreTableDir, projectTableDir, projectApiDir } from '../paths.js';
 import { scanAddons, getAddonDir, addonDirExists } from '../util.js';
 
 /**
@@ -41,7 +41,7 @@ async function collectCorePlugins(registry: ResourceRegistry): Promise<void> {
     try {
         const glob = new Bun.Glob('*.ts');
         for await (const file of glob.scan({
-            cwd: paths.projectPluginDir,
+            cwd: projectPluginDir,
             onlyFiles: true,
             absolute: true
         })) {
@@ -77,7 +77,7 @@ async function collectAddonResources(addonName: string, registry: ResourceRegist
         const glob = new Bun.Glob('*.json');
 
         for await (const file of glob.scan({
-            cwd: paths.rootTableDir,
+            cwd: addonTablesDir,
             onlyFiles: true,
             absolute: true
         })) {
@@ -183,7 +183,7 @@ async function collectUserResources(registry: ResourceRegistry): Promise<string[
     const conflicts: string[] = [];
 
     // 收集用户表定义
-    const userTablesDir = paths.projectTableDir;
+    const userTablesDir = projectTableDir;
     try {
         const glob = new Bun.Glob('*.json');
         for await (const file of glob.scan({
@@ -219,7 +219,7 @@ async function collectUserResources(registry: ResourceRegistry): Promise<string[
     }
 
     // 收集用户 API 路由
-    const userApisDir = paths.projectApiDir;
+    const userApisDir = projectApiDir;
     try {
         const glob = new Bun.Glob('**/*.ts');
         for await (const file of glob.scan({
@@ -255,7 +255,7 @@ async function collectUserResources(registry: ResourceRegistry): Promise<string[
     }
 
     // 收集用户插件
-    const userPluginsDir = paths.projectPluginDir;
+    const userPluginsDir = projectPluginDir;
     try {
         const glob = new Bun.Glob('*.ts');
         for await (const file of glob.scan({

package/checks/table.ts

@@ -6,7 +6,7 @@
 import { basename } from 'pathe';
 import { Logger } from '../lib/logger.js';
 import { parseRule } from '../util.js';
-import { paths } from '../paths.js';
+import { projectTableDir } from '../paths.js';
 import { scanAddons, getAddonDir } from '../util.js';
 
 /**
@@ -69,7 +69,7 @@ export default async function (): Promise<boolean> {
 
         // 收集项目表字段定义文件
         for await (const file of tablesGlob.scan({
-            cwd: paths.projectTableDir,
+            cwd: projectTableDir,
             absolute: true,
             onlyFiles: true
         })) {

package/commands/build.ts

@@ -28,20 +28,24 @@ interface BuildOptions {
 export async function buildCommand(options: BuildOptions) {
     try {
         const projectRoot = getProjectRoot();
-        const mainFile = join(projectRoot, 'main.ts');
 
-        if (!existsSync(mainFile)) {
-            Logger.error('未找到 main.ts 文件');
+        // 验证是否在项目目录下
+        const packageJsonPath = join(projectRoot, 'package.json');
+        if (!existsSync(packageJsonPath)) {
+            Logger.error('未找到 package.json 文件，请确保在项目目录下');
             process.exit(1);
         }
 
+        // 使用内置默认入口文件
+        const entryFile = join(import.meta.dir, '..', 'entry.ts');
+
         const spinner = ora({
             text: '正在构建项目...',
             color: 'cyan',
             spinner: 'dots'
         }).start();
 
-        const args = ['build', mainFile, '--outdir', options.outdir, '--target', 'bun'];
+        const args = ['build', entryFile, '--outdir', options.outdir, '--target', 'bun'];
 
         if (options.minify) {
             args.push('--minify');

package/commands/dev.ts

@@ -5,6 +5,7 @@
 import { join } from 'pathe';
 import { existsSync } from 'node:fs';
 import { Logger } from '../lib/logger.js';
+import { Befly } from '../main.js';
 
 interface DevOptions {
     port: string;
@@ -27,10 +28,11 @@ function getProjectRoot(): string {
 export async function devCommand(options: DevOptions) {
     try {
         const projectRoot = getProjectRoot();
-        const mainFile = join(projectRoot, 'main.ts');
 
-        if (!existsSync(mainFile)) {
-            Logger.error('未找到 main.ts 文件，请确保在 Befly 项目目录下');
+        // 验证是否在 Befly 项目目录下
+        const packageJsonPath = join(projectRoot, 'package.json');
+        if (!existsSync(packageJsonPath)) {
+            Logger.error('未找到 package.json 文件，请确保在项目目录下');
             process.exit(1);
         }
 
@@ -54,38 +56,25 @@ export async function devCommand(options: DevOptions) {
             Logger.info(`环境变量文件: .env.development\n`);
         }
 
-        // 使用 Bun.spawn 启动开发服务器（不使用 --watch 避免监听 node_modules）
+        // 直接启动 Befly 实例
+        const app = new Befly();
+        const server = await app.listen();
 
-        const proc = Bun.spawn(['bun', '--env-file=.env.development', 'run', mainFile], {
-            cwd: projectRoot,
-            stdout: 'inherit',
-            stderr: 'inherit',
-            stdin: 'inherit',
-            env: {
-                // ...process.env,
-                // NODE_ENV: 'development',
-                // APP_PORT: options.port,
-                // APP_HOST: options.host,
-                // LOG_DEBUG: options.verbose ? '1' : process.env.LOG_DEBUG,
-                // FORCE_COLOR: '1'
-            }
-        });
-
-        // 添加信号处理，确保优雅关闭
-        const signals: NodeJS.Signals[] = ['SIGTERM', 'SIGINT', 'SIGHUP'];
+        // 设置信号处理，确保优雅关闭
+        const signals: NodeJS.Signals[] = ['SIGTERM', 'SIGINT'];
         signals.forEach((signal) => {
-            process.on(signal, () => {
-                console.log(`\nShutting down dev server (${signal})...`);
-                proc.kill(signal);
-                setTimeout(() => {
-                    proc.kill('SIGKILL');
+            process.on(signal, async () => {
+                Logger.info(`\n收到 ${signal} 信号，正在关闭开发服务器...`);
+                try {
+                    server.stop(true);
+                    Logger.info('开发服务器已关闭');
+                    process.exit(0);
+                } catch (error) {
+                    Logger.error('关闭开发服务器失败:', error);
                     process.exit(1);
-                }, 5000); // 5 秒强制关闭
+                }
             });
         });
-
-        const exitCode = await proc.exited;
-        process.exit(exitCode || 0);
     } catch (error) {
         Logger.error('启动开发服务器失败:');
         console.error(error);

package/commands/start.ts

@@ -6,6 +6,7 @@ import { join } from 'pathe';
 import { existsSync } from 'node:fs';
 import { Logger } from '../lib/logger.js';
 import { ClusterManager } from '../lifecycle/cluster.js';
+import { Befly } from '../main.js';
 
 function getProjectRoot(): string {
     let current = process.cwd();
@@ -28,10 +29,11 @@ interface StartOptions {
 export async function startCommand(options: StartOptions) {
     try {
         const projectRoot = getProjectRoot();
-        const mainFile = join(projectRoot, 'main.ts');
 
-        if (!existsSync(mainFile)) {
-            Logger.error('未找到 main.ts 文件');
+        // 验证是否在项目目录下
+        const packageJsonPath = join(projectRoot, 'package.json');
+        if (!existsSync(packageJsonPath)) {
+            Logger.error('未找到 package.json 文件，请确保在项目目录下');
             process.exit(1);
         }
 
@@ -49,8 +51,7 @@ export async function startCommand(options: StartOptions) {
                 instances,
                 startPort: parseInt(options.port),
                 host: options.host,
-                projectRoot,
-                mainFile
+                projectRoot
             });
 
             await clusterManager.start();
@@ -67,10 +68,25 @@ export async function startCommand(options: StartOptions) {
                 Logger.info(`环境变量文件: .env.production\n`);
             }
 
-            // 直接导入并运行 main.ts（Bun 会自动加载 .env.production）
-            await import(mainFile);
+            // 直接启动 Befly 实例
+            const app = new Befly();
+            const server = await app.listen();
 
-            // 注意：正常情况下不会执行到这里，因为 main.ts 会启动服务器并持续运行
+            // 设置信号处理，确保优雅关闭
+            const signals: NodeJS.Signals[] = ['SIGTERM', 'SIGINT'];
+            signals.forEach((signal) => {
+                process.on(signal, async () => {
+                    Logger.info(`\n收到 ${signal} 信号，正在关闭生产服务器...`);
+                    try {
+                        server.stop(true);
+                        Logger.info('生产服务器已关闭');
+                        process.exit(0);
+                    } catch (error) {
+                        Logger.error('关闭生产服务器失败:', error);
+                        process.exit(1);
+                    }
+                });
+            });
         }
     } catch (error) {
         Logger.error('启动失败:');