befly 2.2.0 → 2.3.0

package/checks/table.js

@@ -110,14 +110,41 @@ export const checkTable = async () => {
                             continue;
                         }
 
-                        // 第4个值：当类型为 string/array 时，最大长度必须为数字且不可为 null；其他类型允许为 null 或数字
-                        if (type === 'string' || type === 'array') {
+                        // 第4个值与类型联动校验
+                        if (type === 'text') {
+                            // text 类型：不允许设置最小/最大长度与默认值（均需为 null）
+                            if (minStr !== 'null') {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 的 text 类型最小值必须为 null，当前为 "${minStr}"`);
+                                fileValid = false;
+                                continue;
+                            }
+                            if (maxStr !== 'null') {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 的 text 类型最大长度必须为 null，当前为 "${maxStr}"`);
+                                fileValid = false;
+                                continue;
+                            }
+                        } else if (type === 'string') {
+                            // string：最大长度必为具体数字，且 1..65535
+                            if (maxStr === 'null' || !validateMinMax(maxStr)) {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最大长度 "${maxStr}" 格式错误，string 类型必须为具体数字`);
+                                fileValid = false;
+                                continue;
+                            }
+                            const maxVal = parseInt(maxStr, 10);
+                            if (!(maxVal > 0 && maxVal <= 65535)) {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最大长度 ${maxStr} 越界，string 类型长度必须在 1..65535 范围内`);
+                                fileValid = false;
+                                continue;
+                            }
+                        } else if (type === 'array') {
+                            // array：最大长度必为数字（用于JSON字符串长度限制）
                             if (maxStr === 'null' || !validateMinMax(maxStr)) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最大长度 "${maxStr}" 格式错误，string/array 类型必须为具体数字`);
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最大长度 "${maxStr}" 格式错误，array 类型必须为具体数字`);
                                 fileValid = false;
                                 continue;
                             }
                         } else {
+                            // number 等其他：允许 null 或数字
                             if (!validateMinMax(maxStr)) {
                                 Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最大值 "${maxStr}" 格式错误，必须为null或数字`);
                                 fileValid = false;
@@ -125,11 +152,20 @@ export const checkTable = async () => {
                             }
                         }
 
-                        // 第5个值：默认值必须为null、字符串或数字
-                        if (!validateDefaultValue(defaultValue)) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 默认值 "${defaultValue}" 格式错误，必须为null、字符串或数字`);
-                            fileValid = false;
-                            continue;
+                        // 第5个值：默认值校验
+                        if (type === 'text') {
+                            // text 不允许默认值
+                            if (defaultValue !== 'null') {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 为 text 类型，默认值必须为 null，当前为 "${defaultValue}"`);
+                                fileValid = false;
+                                continue;
+                            }
+                        } else {
+                            if (!validateDefaultValue(defaultValue)) {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 默认值 "${defaultValue}" 格式错误，必须为null、字符串或数字`);
+                                fileValid = false;
+                                continue;
+                            }
                         }
 
                         // 第6个值：是否创建索引必须为0或1

package/config/env.js

@@ -53,5 +53,10 @@ export const Env = {
     MAIL_USER: process.env.MAIL_USER,
     MAIL_PASS: process.env.MAIL_PASS,
     MAIL_SENDER: process.env.MAIL_SENDER,
-    MAIL_ADDRESS: process.env.MAIL_ADDRESS
+    MAIL_ADDRESS: process.env.MAIL_ADDRESS,
+    // 同步脚本开关（用于 core/scripts/syncDb.js）
+    SYNC_MERGE_ALTER: process.env.SYNC_MERGE_ALTER,
+    SYNC_ONLINE_INDEX: process.env.SYNC_ONLINE_INDEX,
+    SYNC_DISALLOW_SHRINK: process.env.SYNC_DISALLOW_SHRINK,
+    SYNC_ALLOW_TYPE_CHANGE: process.env.SYNC_ALLOW_TYPE_CHANGE
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "2.2.0",
+    "version": "2.3.0",
     "description": "Buma - 为 Bun 专属打造的 API 接口框架核心引擎",
     "type": "module",
     "private": false,
@@ -13,9 +13,9 @@
         ".": "./main.js"
     },
     "scripts": {
-        "ra": "bun run release.js -a",
-        "rb": "bun run release.js -b",
-        "rc": "bun run release.js -c"
+        "ra": "bun run ../release.js --major",
+        "rb": "bun run ../release.js --minor",
+        "rc": "bun run ../release.js --patch"
     },
     "keywords": [
         "bun",
@@ -59,4 +59,4 @@
         "*.{js,css,scss,less,ts,jsx,vue,html,json,md,yaml}": "bunx --bun prettier --write --cache --ignore-unknown"
     },
     "gitHead": "1dc5f118a723969456559e758e2ba889f4601224"
-}
+}

package/scripts/syncDb.js

@@ -16,6 +16,52 @@ const typeMapping = {
     array: 'VARCHAR'
 };
 
+// 环境开关读取（支持未在 Env 显式声明的变量，默认值兜底）
+const getFlag = (val, def = 0) => {
+    if (val === undefined || val === null || val === '') return !!def;
+    const n = Number(val);
+    if (!Number.isNaN(n)) return n !== 0;
+    const s = String(val).toLowerCase();
+    return s === 'true' || s === 'on' || s === 'yes';
+};
+
+// 命令行参数
+const ARGV = Array.isArray(process.argv) ? process.argv : [];
+const CLI = {
+    DRY_RUN: ARGV.includes('--dry-run')
+};
+
+const FLAGS = {
+    // DRY-RUN 改为命令行参数控制，忽略环境变量
+    DRY_RUN: CLI.DRY_RUN, // 仅打印计划，不执行
+    MERGE_ALTER: getFlag(Env.SYNC_MERGE_ALTER, 1), // 合并每表多项 DDL
+    ONLINE_INDEX: getFlag(Env.SYNC_ONLINE_INDEX, 1), // 索引操作使用在线算法
+    DISALLOW_SHRINK: getFlag(Env.SYNC_DISALLOW_SHRINK, 1), // 禁止长度收缩
+    ALLOW_TYPE_CHANGE: getFlag(Env.SYNC_ALLOW_TYPE_CHANGE, 0) // 允许类型变更
+};
+
+// 计算期望的默认值（与 information_schema 返回的值对齐）
+// 规则：当默认值为 'null' 时按类型提供默认值：number→0，string→""，array→"[]"；text 永不设置默认值
+const getExpectedDefault = (fieldType, fieldDefaultValue) => {
+    if (fieldType === 'text') return null; // TEXT 不设置默认
+    if (fieldDefaultValue !== undefined && fieldDefaultValue !== null && fieldDefaultValue !== 'null') {
+        return fieldDefaultValue; // 保留显式默认值（数字或字符串，包含空字符串）
+    }
+    // 规则为 'null' 时的内置默认
+    switch (fieldType) {
+        case 'number':
+            return 0;
+        case 'string':
+            return '';
+        case 'array':
+            return '[]';
+        default:
+            return null;
+    }
+};
+
+const normalizeDefault = (val) => (val === null || val === undefined ? null : String(val));
+
 // 获取字段的SQL定义
 const getColumnDefinition = (fieldName, rule) => {
     const [fieldDisplayName, fieldType, fieldMin, fieldMaxLength, fieldDefaultValue, fieldHasIndex] = parseFieldRule(rule);
@@ -29,21 +75,19 @@ const getColumnDefinition = (fieldName, rule) => {
         sqlType = `VARCHAR(${maxLength})`;
     }
 
+    // 统一强制 NOT NULL
     let columnDef = `\`${fieldName}\` ${sqlType} NOT NULL`;
 
-    // 设置默认值：如果第5个属性为null或字段类型为text，则不设置默认值
-    if (fieldDefaultValue && fieldDefaultValue !== 'null' && fieldType !== 'text') {
+    // 设置默认值：类型非 text 时总是设置（显式默认或内置默认）
+    const expectedDefault = getExpectedDefault(fieldType, fieldDefaultValue);
+    if (fieldType !== 'text' && expectedDefault !== null) {
         if (fieldType === 'number') {
-            columnDef += ` DEFAULT ${fieldDefaultValue}`;
+            columnDef += ` DEFAULT ${expectedDefault}`;
         } else {
-            columnDef += ` DEFAULT "${fieldDefaultValue.replace(/"/g, '\\"')}"`;
+            columnDef += ` DEFAULT \"${String(expectedDefault).replace(/\"/g, '\\"')}\"`;
         }
-    } else if (fieldType === 'string' || fieldType === 'array') {
-        columnDef += ` DEFAULT ""`;
-    } else if (fieldType === 'number') {
-        columnDef += ` DEFAULT 0`;
     }
-    // text类型不设置默认值
+    // text 类型不设置默认值
 
     // 添加字段注释（使用第1个属性作为字段显示名称）
     if (fieldDisplayName && fieldDisplayName !== 'null') {
@@ -101,17 +145,19 @@ const getTableIndexes = async (client, tableName) => {
     return indexes;
 };
 
-// 管理索引
-const manageIndex = async (client, tableName, indexName, fieldName, action) => {
-    const sql = action === 'create' ? `CREATE INDEX \`${indexName}\` ON \`${tableName}\` (\`${fieldName}\`)` : `DROP INDEX \`${indexName}\` ON \`${tableName}\``;
-
-    try {
-        await exec(client, sql);
-        Logger.info(`表 ${tableName} 索引 ${indexName} ${action === 'create' ? '创建' : '删除'}成功`);
-    } catch (error) {
-        Logger.error(`${action === 'create' ? '创建' : '删除'}索引失败: ${error.message}`);
-        throw error;
+// 构建索引操作 SQL（统一使用 ALTER TABLE 并尽量在线）
+const buildIndexSQL = (tableName, indexName, fieldName, action) => {
+    const parts = [];
+    if (action === 'create') {
+        parts.push(`ADD INDEX \`${indexName}\` (\`${fieldName}\`)`);
+    } else {
+        parts.push(`DROP INDEX \`${indexName}\``);
     }
+    if (FLAGS.ONLINE_INDEX) {
+        parts.push('ALGORITHM=INPLACE');
+        parts.push('LOCK=NONE');
+    }
+    return `ALTER TABLE \`${tableName}\` ${parts.join(', ')}`;
 };
 
 // 创建表
@@ -148,11 +194,15 @@ const createTable = async (client, tableName, fields) => {
         CREATE TABLE \`${tableName}\` (
             ${columns.join(',\n            ')},
             ${indexes.join(',\n            ')}
-        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
+        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_as_cs
     `;
 
-    await exec(client, createTableSQL);
-    Logger.info(`表 ${tableName} 创建成功`);
+    if (FLAGS.DRY_RUN) {
+        Logger.info(`[计划] ${createTableSQL.replace(/\n+/g, ' ')}`);
+    } else {
+        await exec(client, createTableSQL);
+        Logger.info(`[新建表] ${tableName}`);
+    }
 };
 
 // 比较字段定义变化
@@ -192,14 +242,33 @@ const compareFieldDefinition = (existingColumn, newRule, fieldName) => {
         changes.push({ type: 'datatype', current: existingColumn.type, new: expectedDbType });
     }
 
+    // 检查默认值变化（按照生成规则推导期望默认值）
+    const expectedDefault = getExpectedDefault(fieldType, fieldDefaultValue);
+    const currDef = normalizeDefault(existingColumn.defaultValue);
+    const newDef = normalizeDefault(expectedDefault);
+    if (currDef !== newDef) {
+        changes.push({ type: 'default', current: existingColumn.defaultValue, new: expectedDefault });
+    }
+
+    // 检查可空性变化（统一期望 NOT NULL）
+    const expectedNullable = false; // 期望 NOT NULL
+    if (existingColumn.nullable !== expectedNullable) {
+        // existingColumn.nullable 为 true 表示可空
+        changes.push({
+            type: 'nullability',
+            current: existingColumn.nullable ? 'NULL' : 'NOT NULL',
+            new: expectedNullable ? 'NULL' : 'NOT NULL'
+        });
+    }
+
     return { hasChanges: changes.length > 0, changes };
 };
 
-// 生成DDL语句
-const generateDDL = (tableName, fieldName, rule, isAdd = false) => {
+// 生成字段 DDL 子句（不含 ALTER TABLE 前缀）
+const generateDDLClause = (fieldName, rule, isAdd = false) => {
     const columnDef = getColumnDefinition(fieldName, rule);
     const operation = isAdd ? 'ADD COLUMN' : 'MODIFY COLUMN';
-    return `ALTER TABLE \`${tableName}\` ${operation} ${columnDef}, ALGORITHM=INSTANT, LOCK=NONE`;
+    return `${operation} ${columnDef}`;
 };
 
 // 安全执行DDL语句
@@ -210,13 +279,16 @@ const executeDDLSafely = async (client, sql) => {
     } catch (error) {
         // INSTANT失败时尝试INPLACE
         if (sql.includes('ALGORITHM=INSTANT')) {
-            const inplaceSql = sql.replace('ALGORITHM=INSTANT', 'ALGORITHM=INPLACE');
+            const inplaceSql = sql.replace(/ALGORITHM=INSTANT/g, 'ALGORITHM=INPLACE');
             try {
                 await exec(client, inplaceSql);
                 return true;
             } catch (inplaceError) {
-                // 最后尝试传统DDL
-                const traditionSql = sql.split(',')[0]; // 移除ALGORITHM和LOCK参数
+                // 最后尝试传统DDL：移除 ALGORITHM/LOCK 附加子句后执行
+                const traditionSql = sql
+                    .replace(/,\s*ALGORITHM=INPLACE/g, '')
+                    .replace(/,\s*ALGORITHM=INSTANT/g, '')
+                    .replace(/,\s*LOCK=(NONE|SHARED|EXCLUSIVE)/g, '');
                 await exec(client, traditionSql);
                 return true;
             }
@@ -231,20 +303,97 @@ const syncTable = async (client, tableName, fields) => {
     const existingColumns = await getTableColumns(client, tableName);
     const existingIndexes = await getTableIndexes(client, tableName);
     const systemFields = ['id', 'created_at', 'updated_at', 'deleted_at', 'state'];
+    let changed = false;
+
+    const addClauses = [];
+    const modifyClauses = [];
+    const defaultClauses = [];
+    const indexActions = [];
+    // 变更统计（按字段粒度）
+    const changeStats = {
+        addFields: 0,
+        datatype: 0,
+        length: 0,
+        default: 0,
+        comment: 0,
+        nullability: 0,
+        indexCreate: 0,
+        indexDrop: 0
+    };
 
     // 同步字段
     for (const [fieldName, rule] of Object.entries(fields)) {
         if (existingColumns[fieldName]) {
             const comparison = compareFieldDefinition(existingColumns[fieldName], rule, fieldName);
             if (comparison.hasChanges) {
-                const sql = generateDDL(tableName, fieldName, rule);
-                await executeDDLSafely(client, sql);
-                Logger.info(`字段 ${tableName}.${fieldName} 更新成功`);
+                // 打印具体变动项并统计
+                for (const c of comparison.changes) {
+                    const label = { length: '长度', datatype: '类型', comment: '注释', default: '默认值' }[c.type] || c.type;
+                    Logger.info(`[字段变更] ${tableName}.${fieldName} ${label}: ${c.current ?? 'NULL'} -> ${c.new ?? 'NULL'}`);
+                    if (c.type in changeStats) changeStats[c.type]++;
+                }
+                // 风险护栏：长度收缩/类型变更
+                const ruleParts = parseFieldRule(rule);
+                const [, fType, , fMax, fDef] = ruleParts;
+                if ((fType === 'string' || fType === 'array') && existingColumns[fieldName].length && fMax !== 'null') {
+                    const newLen = parseInt(fMax);
+                    if (existingColumns[fieldName].length > newLen && FLAGS.DISALLOW_SHRINK) {
+                        Logger.warn(`[跳过危险变更] ${tableName}.${fieldName} 长度收缩 ${existingColumns[fieldName].length} -> ${newLen} 已被跳过（设置 SYNC_DISALLOW_SHRINK=0 可放开）`);
+                        // 如果仅有 shrink 一个变化，仍可能还有默认/注释变化要处理
+                    }
+                }
+                const expectedDbType = {
+                    number: 'bigint',
+                    string: 'varchar',
+                    text: 'mediumtext',
+                    array: 'varchar'
+                }[parseFieldRule(rule)[1]];
+                if (existingColumns[fieldName].type.toLowerCase() !== expectedDbType && !FLAGS.ALLOW_TYPE_CHANGE) {
+                    Logger.warn(`[跳过危险变更] ${tableName}.${fieldName} 类型变更 ${existingColumns[fieldName].type} -> ${expectedDbType} 已被跳过（设置 SYNC_ALLOW_TYPE_CHANGE=1 可放开）`);
+                    // 继续处理默认值/注释等非类型变更
+                }
+
+                // 判断是否“仅默认值变化”
+                const onlyDefaultChanged = comparison.changes.every((c) => c.type === 'default');
+                if (onlyDefaultChanged) {
+                    const expectedDefault = getExpectedDefault(parseFieldRule(rule)[1], parseFieldRule(rule)[4]);
+                    if (expectedDefault === null) {
+                        defaultClauses.push(`ALTER COLUMN \`${fieldName}\` DROP DEFAULT`);
+                    } else {
+                        const isNumber = parseFieldRule(rule)[1] === 'number';
+                        const v = isNumber ? expectedDefault : `"${String(expectedDefault).replace(/"/g, '\\"')}"`;
+                        defaultClauses.push(`ALTER COLUMN \`${fieldName}\` SET DEFAULT ${v}`);
+                    }
+                } else {
+                    // 判断是否需要跳过 MODIFY：包含收缩或类型变更时跳过
+                    let skipModify = false;
+                    const hasLengthChange = comparison.changes.some((c) => c.type === 'length');
+                    if (hasLengthChange && (fType === 'string' || fType === 'array') && existingColumns[fieldName].length && fMax !== 'null') {
+                        const newLen = parseInt(fMax);
+                        if (existingColumns[fieldName].length > newLen && FLAGS.DISALLOW_SHRINK) {
+                            skipModify = true;
+                        }
+                    }
+                    const hasTypeChange = comparison.changes.some((c) => c.type === 'datatype');
+                    if (hasTypeChange && !FLAGS.ALLOW_TYPE_CHANGE) {
+                        skipModify = true;
+                    }
+                    if (!skipModify) {
+                        // 合并到 MODIFY COLUMN 子句
+                        modifyClauses.push(generateDDLClause(fieldName, rule, false));
+                    }
+                }
+                changed = true;
             }
         } else {
-            const sql = generateDDL(tableName, fieldName, rule, true);
-            await executeDDLSafely(client, sql);
-            Logger.info(`字段 ${tableName}.${fieldName} 添加成功`);
+            // 新增字段日志
+            const [disp, fType, fMin, fMax, fDef, fIdx] = parseFieldRule(rule);
+            const lenPart = fType === 'string' || fType === 'array' ? ` 长度:${parseInt(fMax)}` : '';
+            const expectedDefault = getExpectedDefault(fType, fDef);
+            Logger.info(`[新增字段] ${tableName}.${fieldName} 类型:${fType}${lenPart} 默认:${expectedDefault ?? 'NULL'}`);
+            addClauses.push(generateDDLClause(fieldName, rule, true));
+            changed = true;
+            changeStats.addFields++;
         }
     }
 
@@ -255,11 +404,16 @@ const syncTable = async (client, tableName, fields) => {
         const indexName = `idx_${fieldName}`;
 
         if (fieldHasIndex === '1' && !existingIndexes[indexName]) {
-            await manageIndex(client, tableName, indexName, fieldName, 'create');
+            indexActions.push({ action: 'create', indexName, fieldName });
+            changed = true;
+            changeStats.indexCreate++;
         } else if (fieldHasIndex !== '1' && existingIndexes[indexName] && existingIndexes[indexName].length === 1) {
-            await manageIndex(client, tableName, indexName, fieldName, 'drop');
+            indexActions.push({ action: 'drop', indexName, fieldName });
+            changed = true;
+            changeStats.indexDrop++;
         }
     }
+    return { changed, addClauses, modifyClauses, defaultClauses, indexActions, metrics: changeStats };
 };
 
 // 主同步函数
@@ -297,6 +451,17 @@ const SyncDb = async () => {
         let processedCount = 0;
         let createdTables = 0;
         let modifiedTables = 0;
+        // 全局统计
+        const overall = {
+            addFields: 0,
+            typeChanges: 0,
+            maxChanges: 0, // 映射为长度变化
+            minChanges: 0, // 最小值不参与 DDL，比对保留为0
+            defaultChanges: 0,
+            nameChanges: 0, // 字段显示名（注释）变更
+            indexCreate: 0,
+            indexDrop: 0
+        };
 
         for (const dir of directories) {
             try {
@@ -307,13 +472,80 @@ const SyncDb = async () => {
                     const exists = result[0].count > 0;
 
                     if (exists) {
-                        await syncTable(client, tableName, tableDefinition);
+                        const plan = await syncTable(client, tableName, tableDefinition);
+                        if (plan.changed) {
+                            // 汇总统计
+                            if (plan.metrics) {
+                                overall.addFields += plan.metrics.addFields;
+                                overall.typeChanges += plan.metrics.datatype;
+                                overall.maxChanges += plan.metrics.length;
+                                overall.defaultChanges += plan.metrics.default;
+                                overall.indexCreate += plan.metrics.indexCreate;
+                                overall.indexDrop += plan.metrics.indexDrop;
+                                overall.nameChanges += plan.metrics.comment;
+                            }
+                            // 合并执行 ALTER TABLE 子句
+                            if (FLAGS.MERGE_ALTER) {
+                                const clauses = [...plan.addClauses, ...plan.modifyClauses];
+                                if (clauses.length > 0) {
+                                    const sql = `ALTER TABLE \`${tableName}\` ${clauses.join(', ')}, ALGORITHM=INSTANT, LOCK=NONE`;
+                                    if (FLAGS.DRY_RUN) {
+                                        Logger.info(`[计划] ${sql}`);
+                                    } else {
+                                        await executeDDLSafely(client, sql);
+                                    }
+                                }
+                            } else {
+                                // 分别执行
+                                for (const c of plan.addClauses) {
+                                    const sql = `ALTER TABLE \`${tableName}\` ${c}, ALGORITHM=INSTANT, LOCK=NONE`;
+                                    if (FLAGS.DRY_RUN) Logger.info(`[计划] ${sql}`);
+                                    else await executeDDLSafely(client, sql);
+                                }
+                                for (const c of plan.modifyClauses) {
+                                    const sql = `ALTER TABLE \`${tableName}\` ${c}, ALGORITHM=INSTANT, LOCK=NONE`;
+                                    if (FLAGS.DRY_RUN) Logger.info(`[计划] ${sql}`);
+                                    else await executeDDLSafely(client, sql);
+                                }
+                            }
+
+                            // 默认值专用 ALTER
+                            if (plan.defaultClauses.length > 0) {
+                                const sql = `ALTER TABLE \`${tableName}\` ${plan.defaultClauses.join(', ')}, ALGORITHM=INSTANT, LOCK=NONE`;
+                                if (FLAGS.DRY_RUN) Logger.info(`[计划] ${sql}`);
+                                else await executeDDLSafely(client, sql);
+                            }
+
+                            // 索引操作
+                            for (const act of plan.indexActions) {
+                                const sql = buildIndexSQL(tableName, act.indexName, act.fieldName, act.action);
+                                if (FLAGS.DRY_RUN) {
+                                    Logger.info(`[计划] ${sql}`);
+                                } else {
+                                    try {
+                                        await exec(client, sql);
+                                        if (act.action === 'create') {
+                                            Logger.info(`[索引变化] 新建索引 ${tableName}.${act.indexName} (${act.fieldName})`);
+                                        } else {
+                                            Logger.info(`[索引变化] 删除索引 ${tableName}.${act.indexName} (${act.fieldName})`);
+                                        }
+                                    } catch (error) {
+                                        Logger.error(`${act.action === 'create' ? '创建' : '删除'}索引失败: ${error.message}`);
+                                        throw error;
+                                    }
+                                }
+                            }
+
+                            modifiedTables++;
+                        }
                     } else {
                         await createTable(client, tableName, tableDefinition);
+                        createdTables++;
+                        // 新建表已算作变更
+                        modifiedTables += 0;
+                        // 创建表统计：按需求仅汇总创建表数量
                     }
 
-                    Logger.info(`表 ${tableName} 处理完成`);
-                    exists ? modifiedTables++ : createdTables++;
                     processedCount++;
                 }
             } catch (error) {
@@ -321,8 +553,17 @@ const SyncDb = async () => {
             }
         }
 
-        // 显示统计信息
-        Logger.info(`同步完成 - 总计: ${processedCount}, 新建: ${createdTables}, 修改: ${modifiedTables}`);
+        // 显示统计信息（扩展维度）
+        Logger.info(`统计 - 创建表: ${createdTables}`);
+        Logger.info(`统计 - 字段新增: ${overall.addFields}`);
+        Logger.info(`统计 - 字段名称变更: ${overall.nameChanges}`);
+        Logger.info(`统计 - 字段类型变更: ${overall.typeChanges}`);
+        Logger.info(`统计 - 字段最小值变更: ${overall.minChanges}`);
+        Logger.info(`统计 - 字段最大值变更: ${overall.maxChanges}`);
+        Logger.info(`统计 - 字段默认值变更: ${overall.defaultChanges}`);
+        // 索引新增/删除分别打印
+        Logger.info(`统计 - 索引新增: ${overall.indexCreate}`);
+        Logger.info(`统计 - 索引删除: ${overall.indexDrop}`);
 
         if (processedCount === 0) {
             Logger.warn('没有找到任何表定义文件');

package/tables/tool.json

@@ -1,6 +1,6 @@
 {
     "filename": "文件名⚡string⚡1⚡255⚡null⚡1⚡null",
-    "content": "内容⚡string⚡0⚡1000000⚡null⚡0⚡null",
+    "content": "内容⚡string⚡0⚡100⚡null⚡0⚡null",
     "type": "类型⚡string⚡0⚡50⚡file⚡1⚡^(file|folder|link)$",
     "path": "路径⚡string⚡1⚡500⚡null⚡0⚡null"
 }