befly 3.5.7 → 3.6.0

package/commands/syncDb/tableCreate.ts

@@ -1,149 +0,0 @@
-/**
- * syncDb 表创建模块
- *
- * 包含：
- * - 创建表（包含系统字段和业务字段）
- * - 添加 PostgreSQL 注释
- * - 创建表索引
- *
- * 注意：此模块从 table.ts 中提取，用于解除循环依赖
- */
-import { snakeCase } from 'es-toolkit/string';
-import { parseRule } from '../../util.js';
-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';
-
-// 是否为计划模式（从环境变量读取）
-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, string>): 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.info(`[计划] ${stmt}`);
-        } else {
-            await sql.unsafe(stmt);
-        }
-    }
-
-    // 业务字段注释
-    for (const [fieldKey, fieldRule] of Object.entries(fields)) {
-        // 转换字段名为下划线格式
-        const dbFieldName = snakeCase(fieldKey);
-
-        const parsed = parseRule(fieldRule);
-        const { name: fieldName } = parsed;
-        const stmt = `COMMENT ON COLUMN "${tableName}"."${dbFieldName}" IS '${fieldName}'`;
-        if (IS_PLAN) {
-            Logger.info(`[计划] ${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, string>, 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.info(`[计划] ${stmt}`);
-        } else {
-            indexTasks.push(sql.unsafe(stmt));
-        }
-    }
-
-    // 业务字段索引
-    for (const [fieldKey, fieldRule] of Object.entries(fields)) {
-        // 转换字段名为下划线格式
-        const dbFieldName = snakeCase(fieldKey);
-
-        const parsed = parseRule(fieldRule);
-        if (parsed.index === 1) {
-            const stmt = buildIndexSQL(tableName, `idx_${dbFieldName}`, dbFieldName, 'create');
-            if (IS_PLAN) {
-                Logger.info(`[计划] ${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, string>, 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.info(`[计划] ${createSQL.replace(/\n+/g, ' ')}`);
-    } else {
-        await sql.unsafe(createSQL);
-        Logger.info(`  ✓ 新建表`);
-    }
-
-    // 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/commands/syncDb/types.ts

@@ -1,92 +0,0 @@
-/**
- * syncDb 类型定义模块
- *
- * 集中管理核心类型定义
- */
-
-// ==================== 数据库相关类型 ====================
-
-/**
- * 列信息接口
- */
-export interface ColumnInfo {
-    type: string;
-    columnType: string;
-    length: number | null;
-    nullable: boolean;
-    defaultValue: any;
-    comment: string | null;
-}
-
-/**
- * 索引信息接口（键为索引名，值为列名数组）
- */
-export interface IndexInfo {
-    [indexName: string]: string[];
-}
-
-// ==================== 变更相关类型 ====================
-
-/**
- * 字段变更接口
- */
-export interface FieldChange {
-    type: 'length' | 'datatype' | 'comment' | 'default';
-    current: any;
-    expected: any;
-}
-
-/**
- * 索引操作接口
- */
-export interface IndexAction {
-    action: 'create' | 'drop';
-    indexName: string;
-    fieldName: string;
-}
-
-/**
- * 表变更计划接口
- */
-export interface TablePlan {
-    changed: boolean;
-    addClauses: string[];
-    modifyClauses: string[];
-    defaultClauses: string[];
-    indexActions: IndexAction[];
-    commentActions?: string[];
-}
-
-// ==================== 统计相关类型 ====================
-
-/**
- * 全局统计对象
- */
-export interface GlobalStats {
-    processedTables: number;
-    createdTables: number;
-    modifiedTables: number;
-    addFields: number;
-    nameChanges: number;
-    typeChanges: number;
-    minChanges: number;
-    maxChanges: number;
-    defaultChanges: number;
-    indexCreate: number;
-    indexDrop: number;
-}
-
-// ==================== 解析相关类型 ====================
-
-/**
- * 解析后的字段规则
- */
-export interface ParsedFieldRule {
-    name: string;
-    type: 'string' | 'number' | 'text' | 'array_string' | 'array_text';
-    min: number | null;
-    max: number | null;
-    default: any;
-    index: 0 | 1;
-    regex: string | null;
-}

package/commands/syncDb/version.ts

@@ -1,73 +0,0 @@
-/**
- * syncDb 数据库版本检查模块
- *
- * 包含：
- * - 数据库版本验证（MySQL/PostgreSQL/SQLite）
- */
-
-import { Env } from '../../env.js';
-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.info(`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.info(`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.info(`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/commands/syncDb.ts

@@ -1,34 +0,0 @@
-/**
- * SyncDb 命令 - 同步数据库表结构
- */
-
-import { Command } from 'commander';
-import { join } from 'pathe';
-import { existsSync } from 'node:fs';
-import { Logger } from '../lib/logger.js';
-import { SyncDb, type SyncDbStats } from './syncDb/index.js';
-
-interface SyncDbOptions {
-    table?: string;
-    dryRun: boolean;
-}
-
-export async function syncDbCommand(options: SyncDbOptions): Promise<SyncDbStats> {
-    try {
-        // 设置环境变量
-        if (options.dryRun) {
-            process.env.SYNC_DRY_RUN = '1';
-        }
-
-        if (options.table) {
-            process.env.SYNC_TABLE = options.table;
-        }
-
-        // 执行同步并返回统计
-        const stats = await SyncDb();
-        return stats;
-    } catch (error: any) {
-        Logger.error('数据库同步失败:', error);
-        process.exit(1);
-    }
-}

package/commands/syncDev.ts

@@ -1,237 +0,0 @@
-/**
- * SyncDev 命令 - 同步开发者管理员到数据库
- * - 邮箱: 通过 DEV_EMAIL 环境变量配置（默认 dev@qq.com）
- * - 姓名: 开发者
- * - 密码: 使用 bcrypt 加密，通过 DEV_PASSWORD 环境变量配置
- * - 角色: roleCode=dev, roleType=admin
- * - 表名: core_admin
- */
-
-import { Logger } from '../lib/logger.js';
-import { Cipher } from '../lib/cipher.js';
-import { Database } from '../lib/database.js';
-import { Env } from '../env.js';
-
-interface SyncDevOptions {
-    plan?: boolean;
-}
-
-export interface SyncDevStats {
-    adminCount: number;
-    roleCount: number;
-    cachedRoles: number;
-}
-
-/**
- * SyncDev 命令主函数
- */
-export async function syncDevCommand(options: SyncDevOptions = {}): Promise<SyncDevStats> {
-    try {
-        if (options.plan) {
-            Logger.info('[计划] 同步完成后将初始化/更新开发管理员账号（plan 模式不执行）');
-            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
-        }
-
-        if (!Env.DEV_PASSWORD) {
-            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
-        }
-
-        // 连接数据库（SQL + Redis）
-        await Database.connect();
-
-        const helper = Database.getDbHelper();
-
-        // 检查 core_admin 表是否存在
-        const existAdmin = await helper.tableExists('core_admin');
-        if (!existAdmin) {
-            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
-        }
-
-        // 检查 core_role 表是否存在
-        const existRole = await helper.tableExists('core_role');
-        if (!existRole) {
-            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
-        }
-
-        // 检查 core_menu 表是否存在
-        const existMenu = await helper.tableExists('core_menu');
-        if (!existMenu) {
-            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
-        }
-
-        // 查询所有菜单 ID
-        const allMenus = await helper.getAll({
-            table: 'core_menu',
-            fields: ['id']
-        });
-
-        if (!allMenus || !Array.isArray(allMenus)) {
-            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
-        }
-
-        const menuIds = allMenus.length > 0 ? allMenus.map((m: any) => m.id).join(',') : '';
-
-        // 查询所有接口 ID
-        const existApi = await helper.tableExists('core_api');
-        let apiIds = '';
-        if (existApi) {
-            const allApis = await helper.getAll({
-                table: 'core_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: 'core_role',
-            where: { code: 'dev' }
-        });
-
-        if (devRole) {
-            // 更新 dev 角色的菜单和接口权限
-            await helper.updData({
-                table: 'core_role',
-                where: { code: 'dev' },
-                data: {
-                    name: '开发者角色',
-                    description: '拥有所有菜单和接口权限的开发者角色',
-                    menus: menuIds,
-                    apis: apiIds
-                }
-            });
-        } else {
-            // 创建 dev 角色
-            const roleId = await helper.insData({
-                table: 'core_role',
-                data: {
-                    name: '开发者角色',
-                    code: 'dev',
-                    description: '拥有所有菜单和接口权限的开发者角色',
-                    menus: menuIds,
-                    apis: apiIds,
-                    sort: 0
-                }
-            });
-            devRole = { id: roleId };
-            Logger.info('dev 角色已创建');
-        }
-
-        // 使用 bcrypt 加密密码
-        const hashed = await Cipher.hashPassword(Env.DEV_PASSWORD);
-
-        // 准备开发管理员数据
-        const devData = {
-            name: '开发者',
-            nickname: '开发者',
-            email: Env.DEV_EMAIL,
-            username: 'dev',
-            password: hashed,
-            roleId: devRole.id,
-            roleCode: 'dev',
-            roleType: 'admin'
-        };
-
-        // 查询现有账号
-        const existing = await helper.getOne({
-            table: 'core_admin',
-            where: { email: Env.DEV_EMAIL }
-        });
-
-        let isNew = false;
-        if (existing) {
-            // 更新现有账号
-            await helper.updData({
-                table: 'core_admin',
-                where: { email: Env.DEV_EMAIL },
-                data: devData
-            });
-        } else {
-            // 插入新账号
-            await helper.insData({
-                table: 'core_admin',
-                data: devData
-            });
-            isNew = true;
-        }
-
-        // 缓存角色权限数据到 Redis
-        let cachedRolesCount = 0;
-        try {
-            // 检查必要的表是否存在
-            const apiTableExists = await helper.tableExists('core_api');
-            const roleTableExists = await helper.tableExists('core_role');
-
-            if (apiTableExists && roleTableExists) {
-                // 查询所有角色
-                const roles = await helper.getAll({
-                    table: 'core_role',
-                    fields: ['id', 'code', 'apis']
-                });
-
-                // 查询所有接口
-                const allApis = await helper.getAll({
-                    table: 'core_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（使用扩展运算符展开数组）
-                    const result = await redis.sadd(redisKey, ...roleApiPaths);
-
-                    if (result > 0) {
-                        cachedRolesCount++;
-                    }
-                }
-            }
-        } catch (error: any) {
-            // 忽略缓存错误
-        }
-
-        // 获取统计数据
-        const allAdmins = await helper.getAll({
-            table: 'core_admin',
-            fields: ['id']
-        });
-        const allRoles = await helper.getAll({
-            table: 'core_role',
-            fields: ['id']
-        });
-
-        return {
-            adminCount: allAdmins.length,
-            roleCount: allRoles.length,
-            cachedRoles: cachedRolesCount
-        };
-    } catch (error: any) {
-        Logger.error('开发管理员同步失败:', error);
-        process.exit(1);
-    } finally {
-        await Database?.disconnect();
-    }
-}