befly 3.8.19 → 3.8.20

package/sync/syncDb/tableCreate.ts

@@ -0,0 +1,146 @@
+/**
+ * syncDb 表创建模块
+ *
+ * 包含：
+ * - 创建表（包含系统字段和业务字段）
+ * - 添加 PostgreSQL 注释
+ * - 创建表索引
+ *
+ * 注意：此模块从 table.ts 中提取，用于解除循环依赖
+ */
+import { snakeCase } from 'es-toolkit/string';
+import { Logger } from '../../lib/logger.js';
+import { IS_MYSQL, IS_PG, MYSQL_TABLE_CONFIG } from './constants.js';
+import { quoteIdentifier } from './helpers.js';
+import { buildSystemColumnDefs, buildBusinessColumnDefs, buildIndexSQL } from './ddl.js';
+
+import type { SQL } from 'bun';
+import type { FieldDefinition } from 'befly/types/common';
+
+// 是否为计划模式（从环境变量读取）
+const IS_PLAN = process.argv.includes('--plan');
+
+/**
+ * 为 PostgreSQL 表添加列注释
+ *
+ * @param sql - SQL 客户端实例
+ * @param tableName - 表名
+ * @param fields - 字段定义对象
+ */
+async function addPostgresComments(sql: SQL, tableName: string, fields: Record<string, FieldDefinition>): Promise<void> {
+    // 系统字段注释
+    const systemComments = [
+        ['id', '主键ID'],
+        ['created_at', '创建时间'],
+        ['updated_at', '更新时间'],
+        ['deleted_at', '删除时间'],
+        ['state', '状态字段']
+    ];
+
+    for (const [name, comment] of systemComments) {
+        const stmt = `COMMENT ON COLUMN "${tableName}"."${name}" IS '${comment}'`;
+        if (IS_PLAN) {
+            Logger.debug(`[计划] ${stmt}`);
+        } else {
+            await sql.unsafe(stmt);
+        }
+    }
+
+    // 业务字段注释
+    for (const [fieldKey, fieldDef] of Object.entries(fields)) {
+        // 转换字段名为下划线格式
+        const dbFieldName = snakeCase(fieldKey);
+
+        const { name: fieldName } = fieldDef;
+        const stmt = `COMMENT ON COLUMN "${tableName}"."${dbFieldName}" IS '${fieldName}'`;
+        if (IS_PLAN) {
+            Logger.debug(`[计划] ${stmt}`);
+        } else {
+            await sql.unsafe(stmt);
+        }
+    }
+}
+
+/**
+ * 创建表的索引（并行执行以提升性能）
+ *
+ * @param sql - SQL 客户端实例
+ * @param tableName - 表名
+ * @param fields - 字段定义对象
+ * @param systemIndexFields - 系统字段索引列表
+ */
+async function createTableIndexes(sql: SQL, tableName: string, fields: Record<string, FieldDefinition>, systemIndexFields: string[]): Promise<void> {
+    const indexTasks: Promise<void>[] = [];
+
+    // 系统字段索引
+    for (const sysField of systemIndexFields) {
+        const stmt = buildIndexSQL(tableName, `idx_${sysField}`, sysField, 'create');
+        if (IS_PLAN) {
+            Logger.debug(`[计划] ${stmt}`);
+        } else {
+            indexTasks.push(sql.unsafe(stmt));
+        }
+    }
+
+    // 业务字段索引
+    for (const [fieldKey, fieldDef] of Object.entries(fields)) {
+        // 转换字段名为下划线格式
+        const dbFieldName = snakeCase(fieldKey);
+
+        if (fieldDef.index === true) {
+            const stmt = buildIndexSQL(tableName, `idx_${dbFieldName}`, dbFieldName, 'create');
+            if (IS_PLAN) {
+                Logger.debug(`[计划] ${stmt}`);
+            } else {
+                indexTasks.push(sql.unsafe(stmt));
+            }
+        }
+    }
+
+    // 并行执行所有索引创建
+    if (indexTasks.length > 0) {
+        await Promise.all(indexTasks);
+    }
+}
+
+/**
+ * 创建表（包含系统字段和业务字段）
+ *
+ * @param sql - SQL 客户端实例
+ * @param tableName - 表名
+ * @param fields - 字段定义对象
+ * @param systemIndexFields - 系统字段索引列表（可选，默认使用 ['created_at', 'updated_at', 'state']）
+ */
+export async function createTable(sql: SQL, tableName: string, fields: Record<string, FieldDefinition>, systemIndexFields: string[] = ['created_at', 'updated_at', 'state']): Promise<void> {
+    // 构建列定义
+    const colDefs = [...buildSystemColumnDefs(), ...buildBusinessColumnDefs(fields)];
+
+    // 生成 CREATE TABLE 语句
+    const cols = colDefs.join(',\n            ');
+    const tableQuoted = quoteIdentifier(tableName);
+    const { ENGINE, CHARSET, COLLATE } = MYSQL_TABLE_CONFIG;
+    const createSQL = IS_MYSQL
+        ? `CREATE TABLE ${tableQuoted} (
+            ${cols}
+        ) ENGINE=${ENGINE} DEFAULT CHARSET=${CHARSET} COLLATE=${COLLATE}`
+        : `CREATE TABLE ${tableQuoted} (
+            ${cols}
+        )`;
+
+    if (IS_PLAN) {
+        Logger.debug(`[计划] ${createSQL.replace(/\n+/g, ' ')}`);
+    } else {
+        await sql.unsafe(createSQL);
+    }
+
+    // PostgreSQL: 添加列注释
+    if (IS_PG && !IS_PLAN) {
+        await addPostgresComments(sql, tableName, fields);
+    } else if (IS_PG && IS_PLAN) {
+        // 计划模式也要输出注释语句
+        await addPostgresComments(sql, tableName, fields);
+    }
+
+    // 创建索引
+    await createTableIndexes(sql, tableName, fields, systemIndexFields);
+}

package/sync/syncDb/version.ts

@@ -0,0 +1,72 @@
+/**
+ * syncDb 数据库版本检查模块
+ *
+ * 包含：
+ * - 数据库版本验证（MySQL/PostgreSQL/SQLite）
+ */
+
+import { Logger } from '../../lib/logger.js';
+import { DB_VERSION_REQUIREMENTS, IS_MYSQL, IS_PG, IS_SQLITE } from './constants.js';
+import type { SQL } from 'bun';
+
+/**
+ * 数据库版本检查（按方言）
+ *
+ * 根据当前数据库类型检查版本是否符合最低要求：
+ * - MySQL: >= 8.0
+ * - PostgreSQL: >= 17
+ * - SQLite: >= 3.50.0
+ *
+ * @param sql - SQL 客户端实例
+ * @throws {Error} 如果数据库版本不符合要求或无法获取版本信息
+ */
+export async function ensureDbVersion(sql: SQL): Promise<void> {
+    if (!sql) throw new Error('SQL 客户端未初始化');
+
+    if (IS_MYSQL) {
+        const r = await sql`SELECT VERSION() AS version`;
+        if (!r || r.length === 0 || !r[0]?.version) {
+            throw new Error('无法获取 MySQL 版本信息');
+        }
+        const version = r[0].version;
+        const majorVersion = parseInt(String(version).split('.')[0], 10);
+        if (!Number.isFinite(majorVersion) || majorVersion < DB_VERSION_REQUIREMENTS.MYSQL_MIN_MAJOR) {
+            throw new Error(`此脚本仅支持 MySQL ${DB_VERSION_REQUIREMENTS.MYSQL_MIN_MAJOR}.0+，当前版本: ${version}`);
+        }
+        Logger.debug(`MySQL 版本: ${version}`);
+        return;
+    }
+
+    if (IS_PG) {
+        const r = await sql`SELECT version() AS version`;
+        if (!r || r.length === 0 || !r[0]?.version) {
+            throw new Error('无法获取 PostgreSQL 版本信息');
+        }
+        const versionText = r[0].version;
+        Logger.debug(`PostgreSQL 版本: ${versionText}`);
+        const m = /PostgreSQL\s+(\d+)/i.exec(versionText);
+        const major = m ? parseInt(m[1], 10) : NaN;
+        if (!Number.isFinite(major) || major < DB_VERSION_REQUIREMENTS.POSTGRES_MIN_MAJOR) {
+            throw new Error(`此脚本要求 PostgreSQL >= ${DB_VERSION_REQUIREMENTS.POSTGRES_MIN_MAJOR}，当前: ${versionText}`);
+        }
+        return;
+    }
+
+    if (IS_SQLITE) {
+        const r = await sql`SELECT sqlite_version() AS version`;
+        if (!r || r.length === 0 || !r[0]?.version) {
+            throw new Error('无法获取 SQLite 版本信息');
+        }
+        const version = r[0].version;
+        Logger.debug(`SQLite 版本: ${version}`);
+        // 强制最低版本：SQLite ≥ 3.50.0
+        const [maj, min, patch] = String(version)
+            .split('.')
+            .map((v) => parseInt(v, 10) || 0);
+        const vnum = maj * 10000 + min * 100 + patch; // 3.50.0 -> 35000
+        if (!Number.isFinite(vnum) || vnum < DB_VERSION_REQUIREMENTS.SQLITE_MIN_VERSION_NUM) {
+            throw new Error(`此脚本要求 SQLite >= ${DB_VERSION_REQUIREMENTS.SQLITE_MIN_VERSION}，当前: ${version}`);
+        }
+        return;
+    }
+}

package/sync/syncDb.ts

@@ -0,0 +1,19 @@
+/**
+ * SyncDb 命令 - 同步数据库表结构
+ */
+
+import { join } from 'pathe';
+import { existsSync } from 'node:fs';
+import { Logger } from '../lib/logger.js';
+import { SyncDb } from './syncDb/index.js';
+import type { SyncDbOptions, BeflyOptions } from '../types/index.js';
+
+export async function syncDbCommand(config: BeflyOptions, options: SyncDbOptions): Promise<void> {
+    try {
+        // 执行同步
+        await SyncDb(config, options);
+    } catch (error: any) {
+        Logger.error('数据库同步失败', error);
+        throw error;
+    }
+}

package/sync/syncDev.ts

@@ -0,0 +1,206 @@
+/**
+ * SyncDev 命令 - 同步开发者管理员到数据库
+ * - 邮箱: 通过 DEV_EMAIL 环境变量配置（默认 dev@qq.com）
+ * - 姓名: 开发者
+ * - 密码: 使用 bcrypt 加密，通过 DEV_PASSWORD 环境变量配置
+ * - 角色: roleCode=dev, roleType=admin
+ * - 表名: addon_admin_admin
+ */
+
+import { Database } from '../lib/database.js';
+import { Cipher } from '../lib/cipher.js';
+import { Logger } from '../lib/logger.js';
+import type { SyncDevOptions, SyncDevStats, BeflyOptions } from '../types/index.js';
+
+/**
+ * SyncDev 命令主函数
+ */
+export async function syncDevCommand(config: BeflyOptions, options: SyncDevOptions = {}): Promise<void> {
+    try {
+        if (options.plan) {
+            Logger.debug('[计划] 同步完成后将初始化/更新开发管理员账号（plan 模式不执行）');
+            return;
+        }
+
+        const devPassword = config.devPassword;
+        const devEmail = config.devEmail || 'dev@qq.com';
+
+        if (!devPassword) {
+            return;
+        }
+
+        // 连接数据库（SQL + Redis）
+        await Database.connect();
+
+        const helper = Database.getDbHelper();
+
+        // 检查 addon_admin_admin 表是否存在
+        const existAdmin = await helper.tableExists('addon_admin_admin');
+        if (!existAdmin) {
+            return;
+        }
+
+        // 检查 addon_admin_role 表是否存在
+        const existRole = await helper.tableExists('addon_admin_role');
+        if (!existRole) {
+            return;
+        }
+
+        // 检查 addon_admin_menu 表是否存在
+        const existMenu = await helper.tableExists('addon_admin_menu');
+        if (!existMenu) {
+            return;
+        }
+
+        // 查询所有菜单 ID
+        const allMenus = await helper.getAll({
+            table: 'addon_admin_menu',
+            fields: ['id']
+        });
+
+        if (!allMenus || !Array.isArray(allMenus)) {
+            return;
+        }
+
+        const menuIds = allMenus.length > 0 ? allMenus.map((m: any) => m.id).join(',') : '';
+
+        // 查询所有接口 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(',');
+            }
+        }
+
+        // 查询或创建 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
+                }
+            });
+        } 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 };
+        }
+
+        // 使用 bcrypt 加密密码
+        const hashed = await Cipher.hashPassword(devPassword);
+
+        // 准备开发管理员数据
+        const devData = {
+            name: '开发者',
+            nickname: '开发者',
+            email: devEmail,
+            username: 'dev',
+            password: hashed,
+            roleId: devRole.id,
+            roleCode: 'dev',
+            roleType: 'admin'
+        };
+
+        // 查询现有账号
+        const existing = await helper.getOne({
+            table: 'addon_admin_admin',
+            where: { email: devEmail }
+        });
+
+        if (existing) {
+            // 更新现有账号
+            await helper.updData({
+                table: 'addon_admin_admin',
+                where: { email: devEmail },
+                data: devData
+            });
+        } else {
+            // 插入新账号
+            await helper.insData({
+                table: 'addon_admin_admin',
+                data: devData
+            });
+        }
+
+        // 缓存角色权限数据到 Redis
+        try {
+            // 检查必要的表是否存在
+            const apiTableExists = await helper.tableExists('addon_admin_api');
+            const roleTableExists = await helper.tableExists('addon_admin_role');
+
+            if (apiTableExists && roleTableExists) {
+                // 查询所有角色
+                const roles = await helper.getAll({
+                    table: 'addon_admin_role',
+                    fields: ['id', 'code', 'apis']
+                });
+
+                // 查询所有接口
+                const allApis = await helper.getAll({
+                    table: 'addon_admin_api',
+                    fields: ['id', 'name', 'path', 'method', 'description', 'addonName']
+                });
+
+                const redis = Database.getRedis();
+
+                // 为每个角色缓存接口权限
+                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 缓存角色权限
+                    const redisKey = `role:apis:${role.code}`;
+
+                    // 先删除旧数据
+                    await redis.del(redisKey);
+
+                    // 批量添加到 Set（使用扩展运算符展开数组）
+                    await redis.sadd(redisKey, ...roleApiPaths);
+                }
+            }
+        } catch (error: any) {
+            // 忽略缓存错误
+        }
+    } catch (error: any) {
+        Logger.error('同步开发者管理员失败', error);
+        throw error;
+    } finally {
+        await Database?.disconnect();
+    }
+}