befly 3.5.7 → 3.7.0

package/commands/syncDb/schema.ts

@@ -1,199 +0,0 @@
-/**
- * syncDb 表结构查询模块
- *
- * 包含：
- * - 判断表是否存在
- * - 获取表的列信息
- * - 获取表的索引信息
- */
-
-import { Env } from '../../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/commands/syncDb/sqlite.ts

@@ -1,50 +0,0 @@
-/**
- * syncDb SQLite 特殊处理模块
- *
- * 包含：
- * - SQLite 重建表迁移（处理列修改等不支持的操作）
- */
-
-import { Logger } from '../../lib/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/commands/syncDb/state.ts

@@ -1,112 +0,0 @@
-/**
- * syncDb 状态管理模块
- *
- * 包含：
- * - 性能统计（阶段耗时、总体计时）
- * - 进度信息记录
- */
-
-import type { SQL } from 'bun';
-import { Logger } from '../../lib/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 {
-    /**
-     * 记录表处理进度（紧凑格式）
-     * @param current 当前进度
-     * @param total 总数
-     * @param tableName 表名
-     * @param dirType 目录类型（核心/项目/组件名）
-     */
-    logTableProgress(current: number, total: number, tableName: string, dirType?: string): void {
-        const typeInfo = dirType ? ` (${dirType})` : '';
-        Logger.info(`[${current}/${total}] ${tableName}${typeInfo}`);
-    }
-
-    /**
-     * 记录字段变更进度
-     */
-    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}`);
-    }
-}

package/commands/syncDb/table.ts

@@ -1,214 +0,0 @@
-/**
- * syncDb 表操作模块
- *
- * 包含：
- * - 修改表结构
- * - 对比字段变化
- * - 应用变更计划
- */
-
-import { snakeCase } from 'es-toolkit/string';
-import { parseRule } from '../../util.js';
-import { Logger } from '../../lib/logger.js';
-import { IS_MYSQL, IS_PG, IS_SQLITE, SYSTEM_INDEX_FIELDS, CHANGE_TYPE_LABELS, typeMapping } from './constants.js';
-import { quoteIdentifier, logFieldChange, resolveDefaultValue, generateDefaultSql, isStringOrArrayType, getSqlType } from './helpers.js';
-import { buildIndexSQL, generateDDLClause, isPgCompatibleTypeChange } from './ddl.js';
-import { getTableColumns, getTableIndexes, type ColumnInfo } from './schema.js';
-import { compareFieldDefinition, applyTablePlan } from './apply.js';
-import { createTable } from './tableCreate.js';
-import type { TablePlan } from './types.js';
-import type { SQL } from 'bun';
-
-// 是否为计划模式（从环境变量读取）
-const IS_PLAN = process.argv.includes('--plan');
-
-// 导出 createTable 供其他模块使用
-export { createTable };
-
-/**
- * 同步表结构（对比和应用变更）
- *
- * 主要逻辑：
- * 1. 获取表的现有列和索引信息
- * 2. 对比每个字段的定义变化
- * 3. 生成 DDL 变更计划
- * 4. 处理索引的增删
- * 5. 应用变更计划
- *
- * 安全策略：
- * - 禁止字段类型变更（除 string<->array）
- * - 跳过危险的长度收缩
- * - 使用在线 DDL（MySQL/PG）
- *
- * @param sql - SQL 客户端实例
- * @param tableName - 表名
- * @param fields - 字段定义对象
- * @param globalCount - 全局统计对象（用于计数）
- * @returns 表结构变更计划
- */
-export async function modifyTable(sql: SQL, tableName: string, fields: Record<string, string>, globalCount: Record<string, number>): Promise<TablePlan> {
-    const existingColumns = await getTableColumns(sql, tableName);
-    const existingIndexes = await getTableIndexes(sql, tableName);
-    let changed = false;
-
-    const addClauses = [];
-    const modifyClauses = [];
-    const defaultClauses = [];
-    const indexActions = [];
-
-    for (const [fieldKey, fieldRule] of Object.entries(fields)) {
-        // 转换字段名为下划线格式（用于与数据库字段对比）
-        const dbFieldName = snakeCase(fieldKey);
-
-        if (existingColumns[dbFieldName]) {
-            const comparison = compareFieldDefinition(existingColumns[dbFieldName], fieldRule, dbFieldName);
-            if (comparison.length > 0) {
-                for (const c of comparison) {
-                    // 使用统一的日志格式函数和常量标签
-                    const changeLabel = CHANGE_TYPE_LABELS[c.type] || '未知';
-                    logFieldChange(tableName, dbFieldName, c.type, c.current, c.expected, changeLabel);
-
-                    // 全量计数：全局累加
-                    if (c.type === 'datatype') globalCount.typeChanges++;
-                    else if (c.type === 'length') globalCount.maxChanges++;
-                    else if (c.type === 'default') globalCount.defaultChanges++;
-                    else if (c.type === 'comment') globalCount.nameChanges++;
-                }
-
-                const parsed = parseRule(fieldRule);
-                const { name: fieldName, type: fieldType, max: fieldMax, default: fieldDefault } = parsed;
-
-                if (isStringOrArrayType(fieldType) && existingColumns[dbFieldName].length) {
-                    if (existingColumns[dbFieldName].length! > fieldMax) {
-                        Logger.warn(`[跳过危险变更] ${tableName}.${dbFieldName} 长度收缩 ${existingColumns[dbFieldName].length} -> ${fieldMax} 已被跳过`);
-                    }
-                }
-
-                const hasTypeChange = comparison.some((c) => c.type === 'datatype');
-                const hasLengthChange = comparison.some((c) => c.type === 'length');
-                const onlyDefaultChanged = comparison.every((c) => c.type === 'default');
-                const defaultChanged = comparison.some((c) => c.type === 'default');
-
-                // 严格限制：除 string/array 互转外，禁止任何字段类型变更；一旦发现，立即终止同步
-                if (hasTypeChange) {
-                    const currentSqlType = String(existingColumns[dbFieldName].type || '').toLowerCase();
-                    const newSqlType = String(typeMapping[fieldType] || '').toLowerCase();
-                    const errorMsg = [`禁止字段类型变更: ${tableName}.${dbFieldName}`, `当前类型: ${currentSqlType}`, `目标类型: ${newSqlType}`, `说明: 仅允许 string<->array 互相切换，其他类型变更需要手动处理`].join('\n');
-                    throw new Error(errorMsg);
-                }
-
-                // 默认值变化处理
-                if (defaultChanged) {
-                    // 使用公共函数处理默认值
-                    const actualDefault = resolveDefaultValue(fieldDefault, fieldType);
-
-                    // 生成 SQL DEFAULT 值（不包含前导空格，因为要用于 ALTER COLUMN）
-                    let v: string | null = null;
-                    if (actualDefault !== 'null') {
-                        const defaultSql = generateDefaultSql(actualDefault, fieldType);
-                        // 移除前导空格 ' DEFAULT ' -> 'DEFAULT '
-                        v = defaultSql.trim().replace(/^DEFAULT\s+/, '');
-                    }
-
-                    if (v !== null && v !== '') {
-                        if (IS_PG) {
-                            defaultClauses.push(`ALTER COLUMN "${dbFieldName}" SET DEFAULT ${v}`);
-                        } else if (IS_MYSQL && onlyDefaultChanged) {
-                            // MySQL 的 TEXT/BLOB 不允许 DEFAULT，跳过 text 类型
-                            if (fieldType !== 'text') {
-                                defaultClauses.push(`ALTER COLUMN \`${dbFieldName}\` SET DEFAULT ${v}`);
-                            }
-                        }
-                    }
-                }
-
-                // 若不仅仅是默认值变化，继续生成修改子句
-                if (!onlyDefaultChanged) {
-                    let skipModify = false;
-                    if (hasLengthChange && isStringOrArrayType(fieldType) && existingColumns[dbFieldName].length) {
-                        const oldLen = existingColumns[dbFieldName].length!;
-                        const isShrink = oldLen > fieldMax;
-                        if (isShrink) skipModify = true;
-                    }
-
-                    if (hasTypeChange) {
-                        if (IS_PG && isPgCompatibleTypeChange(existingColumns[dbFieldName].type, typeMapping[fieldType].toLowerCase())) {
-                            Logger.info(`[PG兼容类型变更] ${tableName}.${dbFieldName} ${existingColumns[dbFieldName].type} -> ${typeMapping[fieldType].toLowerCase()} 允许执行`);
-                        }
-                    }
-
-                    if (!skipModify) modifyClauses.push(generateDDLClause(fieldKey, fieldRule, false));
-                }
-                changed = true;
-            }
-        } else {
-            const parsed = parseRule(fieldRule);
-            const { name: fieldName, type: fieldType, max: fieldMax, default: fieldDefault } = parsed;
-            const lenPart = isStringOrArrayType(fieldType) ? ` 长度:${parseInt(String(fieldMax))}` : '';
-            Logger.info(`  + 新增字段 ${dbFieldName} (${fieldType}${lenPart})`);
-            addClauses.push(generateDDLClause(fieldKey, fieldRule, true));
-            changed = true;
-            globalCount.addFields++;
-        }
-    }
-
-    // 检查系统字段索引
-    for (const sysField of ['created_at', 'updated_at', 'state']) {
-        const idxName = `idx_${sysField}`;
-        if (!existingIndexes[idxName]) {
-            indexActions.push({ action: 'create', indexName: idxName, fieldName: sysField });
-            changed = true;
-            globalCount.indexCreate++;
-        }
-    }
-
-    // 检查业务字段索引
-    for (const [fieldKey, fieldRule] of Object.entries(fields)) {
-        // 转换字段名为下划线格式
-        const dbFieldName = snakeCase(fieldKey);
-
-        const parsed = parseRule(fieldRule);
-        const indexName = `idx_${dbFieldName}`;
-        if (parsed.index === 1 && !existingIndexes[indexName]) {
-            indexActions.push({ action: 'create', indexName, fieldName: dbFieldName });
-            changed = true;
-            globalCount.indexCreate++;
-        } else if (!(parsed.index === 1) && existingIndexes[indexName] && existingIndexes[indexName].length === 1) {
-            indexActions.push({ action: 'drop', indexName, fieldName: dbFieldName });
-            changed = true;
-            globalCount.indexDrop++;
-        }
-    }
-
-    // PG 列注释处理
-    const commentActions = [];
-    if (IS_PG) {
-        for (const [fieldKey, fieldRule] of Object.entries(fields)) {
-            // 转换字段名为下划线格式
-            const dbFieldName = snakeCase(fieldKey);
-
-            if (existingColumns[dbFieldName]) {
-                const parsed = parseRule(fieldRule);
-                const { name: fieldName } = parsed;
-                const curr = existingColumns[dbFieldName].comment || '';
-                const want = fieldName && fieldName !== 'null' ? String(fieldName) : '';
-                if (want !== curr) {
-                    commentActions.push(`COMMENT ON COLUMN "${tableName}"."${dbFieldName}" IS ${want ? `'${want}'` : 'NULL'}`);
-                    changed = true;
-                }
-            }
-        }
-    }
-
-    // 仅当存在实际动作时才认为有变更（避免仅日志的收缩跳过被计为修改）
-    changed = addClauses.length > 0 || modifyClauses.length > 0 || defaultClauses.length > 0 || indexActions.length > 0 || commentActions.length > 0;
-
-    const plan = { changed, addClauses, modifyClauses, defaultClauses, indexActions, commentActions };
-
-    // 将计划应用（包含 --plan 情况下仅输出）
-    if (plan.changed) {
-        await applyTablePlan(sql, tableName, fields, plan, globalCount);
-    }
-
-    return plan;
-}