befly 2.3.3 → 3.0.1

package/scripts/syncDb/index.ts

@@ -0,0 +1,203 @@
+/**
+ * syncDb 主入口文件
+ *
+ * 功能：
+ * - 协调所有模块，执行数据库表结构同步
+ * - 处理核心表、项目表、addon 表
+ * - 提供统计信息和错误处理
+ */
+
+import path from 'node:path';
+import { Logger } from '../../utils/logger.js';
+import { Env } from '../../config/env.js';
+import { createSqlClient } from '../../utils/database.js';
+import { toSnakeCase } from '../../utils/helper.js';
+import checkTable from '../../checks/table.js';
+import { paths } from '../../paths.js';
+import { scanAddons, getAddonDir, addonDirExists } from '../../utils/helper.js';
+
+// 导入模块化的功能
+import { ensureDbVersion } from './version.js';
+import { tableExists } from './schema.js';
+import { createTable, modifyTable } from './table.js';
+import { PerformanceTracker, ProgressLogger } from './state.js';
+import type { SQL } from 'bun';
+
+// 全局 SQL 客户端实例
+let sql: SQL | null = null;
+
+// 全局统计对象
+const globalCount: Record<string, number> = {
+    processedTables: 0,
+    createdTables: 0,
+    modifiedTables: 0,
+    addFields: 0,
+    nameChanges: 0,
+    typeChanges: 0,
+    minChanges: 0,
+    maxChanges: 0,
+    defaultChanges: 0,
+    indexCreate: 0,
+    indexDrop: 0
+};
+
+/**
+ * 主同步函数
+ *
+ * 流程：
+ * 1. 验证表定义文件
+ * 2. 建立数据库连接并检查版本
+ * 3. 扫描表定义文件（核心表、项目表、addon表）
+ * 4. 对比并应用表结构变更
+ * 5. 输出统计信息
+ */
+export const SyncDb = async (): Promise<void> => {
+    const perfTracker = new PerformanceTracker();
+    const progressLogger = new ProgressLogger();
+
+    try {
+        Logger.info('开始数据库表结构同步...');
+
+        // 重置全局统计，避免多次调用累加
+        for (const k of Object.keys(globalCount)) {
+            if (typeof globalCount[k] === 'number') globalCount[k] = 0;
+        }
+
+        // 阶段1：验证表定义文件
+        perfTracker.markPhase('表定义验证');
+        if (!(await checkTable())) {
+            throw new Error('表定义验证失败');
+        }
+        Logger.info(`✓ 表定义验证完成，耗时: ${perfTracker.getPhaseTime('表定义验证')}`);
+
+        // 阶段2：建立数据库连接并检查版本
+        perfTracker.markPhase('数据库连接');
+        sql = await createSqlClient({ max: 1 });
+        await ensureDbVersion(sql);
+        Logger.info(`✓ 数据库连接建立，耗时: ${perfTracker.getPhaseTime('数据库连接')}`);
+
+        // 阶段3：扫描表定义文件
+        perfTracker.markPhase('扫描表文件');
+        const tablesGlob = new Bun.Glob('*.json');
+        const directories: Array<{ path: string; isCore: boolean; addonName?: string }> = [{ path: paths.projectTableDir, isCore: false }];
+
+        // 添加所有 addon 的 tables 目录
+        const addons = scanAddons();
+        for (const addon of addons) {
+            if (addonDirExists(addon, 'tables')) {
+                directories.push({
+                    path: getAddonDir(addon, 'tables'),
+                    isCore: false,
+                    addonName: addon
+                });
+            }
+        }
+
+        // 统计表文件总数
+        let totalTables = 0;
+        for (const dirConfig of directories) {
+            for await (const file of tablesGlob.scan({
+                cwd: dirConfig.path,
+                absolute: true,
+                onlyFiles: true
+            })) {
+                const fileName = path.basename(file, '.json');
+                if (!fileName.startsWith('_')) {
+                    totalTables++;
+                }
+            }
+        }
+        perfTracker.finishPhase('扫描表文件');
+        Logger.info(`✓ 扫描完成，发现 ${totalTables} 个表定义文件，耗时: ${perfTracker.getPhaseTime('扫描表文件')}`);
+
+        // 阶段4：处理表文件
+        perfTracker.markPhase('同步处理');
+        let processedCount = 0;
+
+        for (const dirConfig of directories) {
+            const { path: dir, isCore, addonName } = dirConfig;
+            const dirType = addonName ? `组件${addonName}` : '项目';
+
+            for await (const file of tablesGlob.scan({
+                cwd: dir,
+                absolute: true,
+                onlyFiles: true
+            })) {
+                const fileName = path.basename(file, '.json');
+
+                // 跳过以下划线开头的文件（这些是公共字段规则，不是表定义）
+                if (fileName.startsWith('_')) {
+                    Logger.info(`跳过非表定义文件: ${fileName}.json`);
+                    continue;
+                }
+
+                // 确定表名前缀：
+                // - addon 表：addon_{addonName}_ 前缀
+                // - 项目表：无前缀
+                let tableName = toSnakeCase(fileName);
+                if (addonName) {
+                    tableName = `addon_${addonName}_${tableName}`;
+                }
+
+                processedCount++;
+                progressLogger.logTableProgress(processedCount, totalTables, tableName);
+                Logger.info(`  类型: ${dirType}`);
+
+                const tableDefinition = await Bun.file(file).json();
+                const existsTable = await tableExists(sql!, tableName);
+
+                if (existsTable) {
+                    await modifyTable(sql!, tableName, tableDefinition, globalCount);
+                } else {
+                    await createTable(sql!, tableName, tableDefinition);
+                    globalCount.createdTables++;
+                }
+                globalCount.processedTables++;
+            }
+        }
+
+        perfTracker.finishPhase('同步处理');
+        Logger.info(`✓ 表处理完成，耗时: ${perfTracker.getPhaseTime('同步处理')}`);
+
+        // 阶段5：显示统计信息
+        Logger.info('\n=== 同步统计信息 ===');
+        Logger.info(`总耗时: ${perfTracker.getTotalTime()}`);
+        Logger.info(`处理表总数: ${globalCount.processedTables}`);
+        Logger.info(`创建表: ${globalCount.createdTables}`);
+        Logger.info(`修改表: ${globalCount.modifiedTables}`);
+        Logger.info(`字段新增: ${globalCount.addFields}`);
+        Logger.info(`字段名称变更: ${globalCount.nameChanges}`);
+        Logger.info(`字段类型变更: ${globalCount.typeChanges}`);
+        Logger.info(`字段最小值变更: ${globalCount.minChanges}`);
+        Logger.info(`字段最大值变更: ${globalCount.maxChanges}`);
+        Logger.info(`字段默认值变更: ${globalCount.defaultChanges}`);
+        Logger.info(`索引新增: ${globalCount.indexCreate}`);
+        Logger.info(`索引删除: ${globalCount.indexDrop}`);
+
+        if (globalCount.processedTables === 0) {
+            Logger.warn('没有找到任何表定义文件');
+        }
+
+        // 输出性能统计
+        perfTracker.logStats();
+    } catch (error: any) {
+        Logger.error(`数据库同步失败`, error);
+        process.exit(1);
+    } finally {
+        if (sql) {
+            try {
+                await sql.close();
+            } catch (error: any) {
+                Logger.warn('关闭数据库连接时出错:', error.message);
+            }
+        }
+    }
+};
+
+// 如果直接运行此脚本（Bun 支持 import.meta.main）
+if (import.meta.main) {
+    SyncDb().catch((error) => {
+        Logger.error('数据库同步失败', error);
+        process.exit(1);
+    });
+}

package/scripts/syncDb/schema.ts

@@ -0,0 +1,199 @@
+/**
+ * syncDb 表结构查询模块
+ *
+ * 包含：
+ * - 判断表是否存在
+ * - 获取表的列信息
+ * - 获取表的索引信息
+ */
+
+import { Env } from '../../config/env.js';
+import { IS_MYSQL, IS_PG, IS_SQLITE } from './constants.js';
+import type { ColumnInfo, IndexInfo } from './types.js';
+import type { SQL } from 'bun';
+
+// 重新导出类型供其他模块使用
+export type { ColumnInfo, IndexInfo };
+
+/**
+ * 判断表是否存在（返回布尔值）
+ *
+ * @param sql - SQL 客户端实例
+ * @param tableName - 表名
+ * @returns 表是否存在
+ */
+export async function tableExists(sql: SQL, tableName: string): Promise<boolean> {
+    if (!sql) throw new Error('SQL 客户端未初始化');
+
+    try {
+        if (IS_MYSQL) {
+            const res = await sql`SELECT COUNT(*) AS count FROM information_schema.TABLES WHERE TABLE_SCHEMA = ${Env.DB_NAME} AND TABLE_NAME = ${tableName}`;
+            return (res[0]?.count || 0) > 0;
+        }
+
+        if (IS_PG) {
+            const res = await sql`SELECT COUNT(*)::int AS count FROM information_schema.tables WHERE table_schema = 'public' AND table_name = ${tableName}`;
+            return (res[0]?.count || 0) > 0;
+        }
+
+        if (IS_SQLITE) {
+            const res = await sql`SELECT name FROM sqlite_master WHERE type='table' AND name = ${tableName}`;
+            return res.length > 0;
+        }
+
+        return false;
+    } catch (error: any) {
+        throw new Error(`查询表是否存在失败 [${tableName}]: ${error.message}`);
+    }
+}
+
+/**
+ * 获取表的现有列信息（按方言）
+ *
+ * 查询数据库元数据，获取表的所有列信息，包括：
+ * - 列名
+ * - 数据类型
+ * - 字符最大长度
+ * - 是否可为空
+ * - 默认值
+ * - 列注释（MySQL/PG）
+ *
+ * @param sql - SQL 客户端实例
+ * @param tableName - 表名
+ * @returns 列信息对象，键为列名，值为列详情
+ */
+export async function getTableColumns(sql: SQL, tableName: string): Promise<{ [key: string]: ColumnInfo }> {
+    const columns: { [key: string]: ColumnInfo } = {};
+
+    try {
+        if (IS_MYSQL) {
+            const result = await sql`
+                SELECT COLUMN_NAME, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH, IS_NULLABLE, COLUMN_DEFAULT, COLUMN_COMMENT, COLUMN_TYPE
+                FROM information_schema.COLUMNS
+                WHERE TABLE_SCHEMA = ${Env.DB_NAME} AND TABLE_NAME = ${tableName}
+                ORDER BY ORDINAL_POSITION
+            `;
+            for (const row of result) {
+                // MySQL 的 COLUMN_DEFAULT 已经是解析后的实际值，无需处理：
+                // - 空字符串 DEFAULT '': 返回 '' (空字符串)
+                // - 字符串 DEFAULT 'admin': 返回 admin (无引号)
+                // - 单引号 DEFAULT '''': 返回 ' (单引号字符)
+                // - 数字 DEFAULT 0: 返回 0
+                // - NULL: 返回 null
+                const defaultValue = row.COLUMN_DEFAULT;
+
+                columns[row.COLUMN_NAME] = {
+                    type: row.DATA_TYPE,
+                    columnType: row.COLUMN_TYPE,
+                    length: row.CHARACTER_MAXIMUM_LENGTH,
+                    nullable: row.IS_NULLABLE === 'YES',
+                    defaultValue: defaultValue,
+                    comment: row.COLUMN_COMMENT
+                };
+            }
+        } else if (IS_PG) {
+            const result = await sql`
+                SELECT column_name, data_type, character_maximum_length, is_nullable, column_default
+                FROM information_schema.columns
+                WHERE table_schema = 'public' AND table_name = ${tableName}
+                ORDER BY ordinal_position
+            `;
+            // 获取列注释
+            const comments = await sql`
+                SELECT a.attname AS column_name, col_description(c.oid, a.attnum) AS column_comment
+                FROM pg_class c
+                JOIN pg_attribute a ON a.attrelid = c.oid
+                JOIN pg_namespace n ON n.oid = c.relnamespace
+                WHERE c.relkind = 'r' AND n.nspname = 'public' AND c.relname = ${tableName} AND a.attnum > 0
+            `;
+            const commentMap: { [key: string]: string } = {};
+            for (const r of comments) commentMap[r.column_name] = r.column_comment;
+
+            for (const row of result) {
+                columns[row.column_name] = {
+                    type: row.data_type,
+                    columnType: row.data_type,
+                    length: row.character_maximum_length,
+                    nullable: String(row.is_nullable).toUpperCase() === 'YES',
+                    defaultValue: row.column_default,
+                    comment: commentMap[row.column_name] ?? null
+                };
+            }
+        } else if (IS_SQLITE) {
+            const result = await sql.unsafe(`PRAGMA table_info(${tableName})`);
+            for (const row of result) {
+                let baseType = String(row.type || '').toUpperCase();
+                let length = null;
+                const m = /^(\w+)\s*\((\d+)\)/.exec(baseType);
+                if (m) {
+                    baseType = m[1];
+                    length = Number(m[2]);
+                }
+                columns[row.name] = {
+                    type: baseType.toLowerCase(),
+                    columnType: baseType.toLowerCase(),
+                    length: length,
+                    nullable: row.notnull === 0,
+                    defaultValue: row.dflt_value,
+                    comment: null
+                };
+            }
+        }
+
+        return columns;
+    } catch (error: any) {
+        throw new Error(`获取表列信息失败 [${tableName}]: ${error.message}`);
+    }
+}
+
+/**
+ * 获取表的现有索引信息（单列索引）
+ *
+ * @param sql - SQL 客户端实例
+ * @param tableName - 表名
+ * @returns 索引信息对象，键为索引名，值为列名数组
+ */
+export async function getTableIndexes(sql: SQL, tableName: string): Promise<IndexInfo> {
+    const indexes: IndexInfo = {};
+
+    try {
+        if (IS_MYSQL) {
+            const result = await sql`
+                SELECT INDEX_NAME, COLUMN_NAME
+                FROM information_schema.STATISTICS
+                WHERE TABLE_SCHEMA = ${Env.DB_NAME}
+                    AND TABLE_NAME = ${tableName}
+                    AND INDEX_NAME != 'PRIMARY'
+                ORDER BY INDEX_NAME
+            `;
+            for (const row of result) {
+                if (!indexes[row.INDEX_NAME]) indexes[row.INDEX_NAME] = [];
+                indexes[row.INDEX_NAME].push(row.COLUMN_NAME);
+            }
+        } else if (IS_PG) {
+            const result = await sql`
+                SELECT indexname, indexdef
+                FROM pg_indexes
+                WHERE schemaname = 'public' AND tablename = ${tableName}
+            `;
+            for (const row of result) {
+                const m = /\(([^)]+)\)/.exec(row.indexdef);
+                if (m) {
+                    const col = m[1].replace(/\"/g, '').replace(/"/g, '').trim();
+                    indexes[row.indexname] = [col];
+                }
+            }
+        } else if (IS_SQLITE) {
+            const list = await sql.unsafe(`PRAGMA index_list(${tableName})`);
+            for (const idx of list) {
+                const info = await sql.unsafe(`PRAGMA index_info(${idx.name})`);
+                const cols = info.map((r) => r.name);
+                if (cols.length === 1) indexes[idx.name] = cols;
+            }
+        }
+
+        return indexes;
+    } catch (error: any) {
+        throw new Error(`获取表索引信息失败 [${tableName}]: ${error.message}`);
+    }
+}

package/scripts/syncDb/sqlite.ts

@@ -0,0 +1,50 @@
+/**
+ * syncDb SQLite 特殊处理模块
+ *
+ * 包含：
+ * - SQLite 重建表迁移（处理列修改等不支持的操作）
+ */
+
+import { Logger } from '../../utils/logger.js';
+import { createTable } from './tableCreate.js';
+import type { SQL } from 'bun';
+
+// 是否为计划模式（从环境变量读取）
+const IS_PLAN = process.argv.includes('--plan');
+
+/**
+ * SQLite 重建表迁移（简化版）
+ *
+ * SQLite 不支持修改列类型等操作，需要通过重建表实现：
+ * 1. 创建临时表（新结构）
+ * 2. 拷贝数据（仅公共列）
+ * 3. 删除旧表
+ * 4. 重命名临时表
+ *
+ * 注意：仅处理新增/修改字段，不处理复杂约束与复合索引
+ *
+ * @param sql - SQL 客户端实例
+ * @param tableName - 表名
+ * @param fields - 字段定义对象
+ */
+export async function rebuildSqliteTable(sql: SQL, tableName: string, fields: Record<string, string>): Promise<void> {
+    // 1. 读取现有列顺序
+    const info = await sql.unsafe(`PRAGMA table_info(${tableName})`);
+    const existingCols = info.map((r) => r.name);
+    const targetCols = ['id', 'created_at', 'updated_at', 'deleted_at', 'state', ...Object.keys(fields)];
+    const tmpTable = `${tableName}__tmp__${Date.now()}`;
+
+    // 2. 创建新表（使用当前定义）
+    await createTable(sql, tmpTable, fields);
+
+    // 3. 拷贝数据（按交集列）
+    const commonCols = targetCols.filter((c) => existingCols.includes(c));
+    if (commonCols.length > 0) {
+        const colsSql = commonCols.map((c) => `"${c}"`).join(', ');
+        await sql.unsafe(`INSERT INTO "${tmpTable}" (${colsSql}) SELECT ${colsSql} FROM "${tableName}"`);
+    }
+
+    // 4. 删除旧表并重命名
+    await sql.unsafe(`DROP TABLE "${tableName}"`);
+    await sql.unsafe(`ALTER TABLE "${tmpTable}" RENAME TO "${tableName}"`);
+}

package/scripts/syncDb/state.ts

@@ -0,0 +1,106 @@
+/**
+ * syncDb 状态管理模块
+ *
+ * 包含：
+ * - 性能统计（阶段耗时、总体计时）
+ * - 进度信息记录
+ */
+
+import { Logger } from '../../utils/logger.js';
+
+/**
+ * 阶段统计信息
+ */
+export interface PhaseStats {
+    startTime: number;
+    endTime?: number;
+    duration?: number;
+}
+
+/**
+ * 性能统计器
+ */
+export class PerformanceTracker {
+    private phases = new Map<string, PhaseStats>();
+    private globalStart: number;
+
+    constructor() {
+        this.globalStart = Date.now();
+    }
+
+    /**
+     * 标记阶段开始
+     */
+    markPhase(phase: string): void {
+        this.phases.set(phase, { startTime: Date.now() });
+    }
+
+    /**
+     * 获取阶段耗时
+     */
+    getPhaseTime(phase: string): string {
+        const stats = this.phases.get(phase);
+        if (!stats) return '0ms';
+
+        const duration = stats.duration || Date.now() - stats.startTime;
+        return duration > 1000 ? `${(duration / 1000).toFixed(2)}s` : `${duration}ms`;
+    }
+
+    /**
+     * 完成阶段并记录耗时
+     */
+    finishPhase(phase: string): void {
+        const stats = this.phases.get(phase);
+        if (stats && !stats.endTime) {
+            stats.endTime = Date.now();
+            stats.duration = stats.endTime - stats.startTime;
+        }
+    }
+
+    /**
+     * 获取总耗时
+     */
+    getTotalTime(): string {
+        const duration = Date.now() - this.globalStart;
+        return duration > 1000 ? `${(duration / 1000).toFixed(2)}s` : `${duration}ms`;
+    }
+
+    /**
+     * 输出所有阶段统计
+     */
+    logStats(): void {
+        Logger.info('\n⏱️  性能统计:');
+        for (const [phase, stats] of this.phases) {
+            const duration = stats.duration || Date.now() - stats.startTime;
+            const timeStr = duration > 1000 ? `${(duration / 1000).toFixed(2)}s` : `${duration}ms`;
+            Logger.info(`   ${phase}: ${timeStr}`);
+        }
+        Logger.info(`   总耗时: ${this.getTotalTime()}`);
+    }
+}
+
+/**
+ * 进度记录器
+ */
+export class ProgressLogger {
+    /**
+     * 记录表处理进度
+     */
+    logTableProgress(current: number, total: number, tableName: string): void {
+        Logger.info(`\n[${current}/${total}] 处理表: ${tableName}`);
+    }
+
+    /**
+     * 记录字段变更进度
+     */
+    logFieldChangeProgress(current: number, total: number, fieldName: string, changeType: string): void {
+        Logger.info(`   [${current}/${total}] 修改字段 ${fieldName} (${changeType})`);
+    }
+
+    /**
+     * 记录索引创建进度
+     */
+    logIndexProgress(current: number, total: number, indexName: string): void {
+        Logger.info(`   [${current}/${total}] 创建索引: ${indexName}`);
+    }
+}