befly 3.8.25 → 3.8.29

package/sync/syncDb/table.ts

@@ -9,19 +9,15 @@
 
 import { snakeCase } from 'es-toolkit/string';
 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 { isMySQL, isPG, CHANGE_TYPE_LABELS, getTypeMapping } from './constants.js';
+import { logFieldChange, resolveDefaultValue, generateDefaultSql, isStringOrArrayType } from './helpers.js';
+import { generateDDLClause, isPgCompatibleTypeChange } from './ddl.js';
 import { getTableColumns, getTableIndexes } from './schema.js';
 import { compareFieldDefinition, applyTablePlan } from './apply.js';
-import { createTable } from './tableCreate.js';
-import type { TablePlan, ColumnInfo } from '../../types.js';
+import type { TablePlan } from '../../types.js';
 import type { SQL } from 'bun';
 import type { FieldDefinition } from 'befly/types/common';
 
-// 是否为计划模式（从环境变量读取）
-const IS_PLAN = process.argv.includes('--plan');
-
 /**
  * 同步表结构（对比和应用变更）
  *
@@ -33,143 +29,13 @@ const IS_PLAN = process.argv.includes('--plan');
  *
  * @param sql - SQL 客户端实例
  * @param tableName - 表名
- * @param tableDefinition - 表定义（JSON）
+ * @param fields - 字段定义
  * @param force - 是否强制同步（删除多余字段）
  * @param dbName - 数据库名称
  */
-export async function modifyTable(sql: SQL, tableName: string, tableDefinition: TablePlan, force: boolean, dbName?: string): Promise<void> {
-    try {
-        // 1. 获取现有表结构
-        const currentColumns = await getTableColumns(sql, tableName, dbName);
-        const currentIndexes = await getTableIndexes(sql, tableName, dbName);
-
-        // 2. 对比字段变化
-        const changes: string[] = [];
-        const processedColumns = new Set<string>();
-        const processedIndexes = new Set<string>();
-        const newColumns: string[] = []; // 记录新增的列名，用于后续添加索引
-
-        // 遍历定义中的字段
-        for (const [fieldName, fieldDef] of Object.entries(tableDefinition)) {
-            const snakeFieldName = snakeCase(fieldName);
-            processedColumns.add(snakeFieldName);
-
-            // 检查字段是否存在
-            if (!currentColumns[snakeFieldName]) {
-                // 新增字段
-                changes.push(generateDDLClause('ADD_COLUMN', tableName, snakeFieldName, fieldDef));
-                logFieldChange(tableName, snakeFieldName, 'add', '新增字段');
-                newColumns.push(snakeFieldName);
-            } else {
-                // 修改字段
-                const currentDef = currentColumns[snakeFieldName];
-                const diff = compareFieldDefinition(fieldDef, currentDef);
-                if (diff) {
-                    changes.push(generateDDLClause('MODIFY_COLUMN', tableName, snakeFieldName, fieldDef));
-                    logFieldChange(tableName, snakeFieldName, 'modify', `修改字段: ${diff}`);
-                }
-            }
-        }
-
-        // 检查多余字段（仅在 force 模式下删除）
-        if (force) {
-            for (const colName of Object.keys(currentColumns)) {
-                if (!processedColumns.has(colName)) {
-                    changes.push(generateDDLClause('DROP_COLUMN', tableName, colName));
-                    logFieldChange(tableName, colName, 'drop', '删除多余字段');
-                }
-            }
-        }
-
-        // 3. 对比索引变化
-        // 自动为 _id, _at 结尾的字段添加索引
-        // 以及 unique=true 的字段
-        const expectedIndexes: { [key: string]: string[] } = {};
-
-        for (const [fieldName, fieldDef] of Object.entries(tableDefinition)) {
-            const snakeFieldName = snakeCase(fieldName);
-
-            // 唯一索引
-            if (fieldDef.unique) {
-                const indexName = `uk_${tableName}_${snakeFieldName}`;
-                expectedIndexes[indexName] = [snakeFieldName];
-            }
-            // 普通索引 (index=true 或 _id/_at 结尾)
-            else if (fieldDef.index || snakeFieldName.endsWith('_id') || snakeFieldName.endsWith('_at')) {
-                // 排除主键 id
-                if (snakeFieldName === 'id') continue;
-
-                // 排除大文本类型
-                if (['text', 'longtext', 'json'].includes(fieldDef.type || '')) continue;
-
-                const indexName = `idx_${tableName}_${snakeFieldName}`;
-                expectedIndexes[indexName] = [snakeFieldName];
-            }
-        }
-
-        // 检查新增/修改索引
-        for (const [indexName, columns] of Object.entries(expectedIndexes)) {
-            processedIndexes.add(indexName);
-
-            const currentIndex = currentIndexes[indexName];
-            if (!currentIndex) {
-                // 新增索引
-                changes.push(buildIndexSQL('ADD', tableName, indexName, columns, indexName.startsWith('uk_')));
-                logFieldChange(tableName, indexName, 'add_index', `新增索引 (${columns.join(',')})`);
-            } else {
-                // 索引存在，检查是否一致
-                const isSame = currentIndex.length === columns.length && currentIndex.every((col, i) => col === columns[i]);
-
-                if (!isSame) {
-                    // 修改索引（先删后加）
-                    changes.push(buildIndexSQL('DROP', tableName, indexName));
-                    changes.push(buildIndexSQL('ADD', tableName, indexName, columns, indexName.startsWith('uk_')));
-                    logFieldChange(tableName, indexName, 'modify_index', `修改索引 (${columns.join(',')})`);
-                }
-            }
-        }
-
-        // 检查多余索引（仅在 force 模式下删除）
-        if (force) {
-            for (const indexName of Object.keys(currentIndexes)) {
-                // 跳过系统索引
-                if (SYSTEM_INDEX_FIELDS.includes(indexName)) continue;
-
-                if (!processedIndexes.has(indexName)) {
-                    changes.push(buildIndexSQL('DROP', tableName, indexName));
-                    logFieldChange(tableName, indexName, 'drop_index', '删除多余索引');
-                }
-            }
-        }
-
-        // 4. 执行变更
-        if (changes.length > 0) {
-            if (IS_PLAN) {
-                // 计划模式：只输出 SQL
-                Logger.info(`[PLAN] 表 ${tableName} 变更 SQL:`);
-                for (const sqlStr of changes) {
-                    console.log(sqlStr + ';');
-                }
-            } else {
-                // 执行模式
-                Logger.info(`正在同步表 ${tableName} 结构...`);
-                for (const sqlStr of changes) {
-                    try {
-                        await sql.unsafe(sqlStr);
-                    } catch (error: any) {
-                        Logger.warn(`执行 SQL 失败: ${sqlStr} - ${error.message}`);
-                        // 继续执行后续变更
-                    }
-                }
-            }
-        }
-    } catch (error: any) {
-        throw new Error(`同步表结构失败 [${tableName}]: ${error.message}`);
-    }
-}
-export async function modifyTable(sql: SQL, tableName: string, fields: Record<string, FieldDefinition>, force: boolean = false): Promise<TablePlan> {
-    const existingColumns = await getTableColumns(sql, tableName);
-    const existingIndexes = await getTableIndexes(sql, tableName);
+export async function modifyTable(sql: SQL, tableName: string, fields: Record<string, FieldDefinition>, force: boolean = false, dbName?: string): Promise<TablePlan> {
+    const existingColumns = await getTableColumns(sql, tableName, dbName);
+    const existingIndexes = await getTableIndexes(sql, tableName, dbName);
     let changed = false;
 
     const addClauses = [];
@@ -226,9 +92,9 @@ export async function modifyTable(sql: SQL, tableName: string, fields: Record<st
                     }
 
                     if (v !== null && v !== '') {
-                        if (IS_PG) {
+                        if (isPG()) {
                             defaultClauses.push(`ALTER COLUMN "${dbFieldName}" SET DEFAULT ${v}`);
-                        } else if (IS_MYSQL && onlyDefaultChanged) {
+                        } else if (isMySQL() && onlyDefaultChanged) {
                             // MySQL 的 TEXT/BLOB 不允许 DEFAULT，跳过 text 类型
                             if (fieldDef.type !== 'text') {
                                 defaultClauses.push(`ALTER COLUMN \`${dbFieldName}\` SET DEFAULT ${v}`);
@@ -246,7 +112,8 @@ export async function modifyTable(sql: SQL, tableName: string, fields: Record<st
                     }
 
                     if (hasTypeChange) {
-                        if (IS_PG && isPgCompatibleTypeChange(existingColumns[dbFieldName].type, typeMapping[fieldDef.type].toLowerCase())) {
+                        const typeMapping = getTypeMapping();
+                        if (isPG() && isPgCompatibleTypeChange(existingColumns[dbFieldName].type, typeMapping[fieldDef.type].toLowerCase())) {
                             Logger.debug(`[PG兼容类型变更] ${tableName}.${dbFieldName} ${existingColumns[dbFieldName].type} -> ${typeMapping[fieldDef.type].toLowerCase()} 允许执行`);
                         }
                     }
@@ -289,7 +156,7 @@ export async function modifyTable(sql: SQL, tableName: string, fields: Record<st
 
     // PG 列注释处理
     const commentActions = [];
-    if (IS_PG) {
+    if (isPG()) {
         for (const [fieldKey, fieldDef] of Object.entries(fields)) {
             // 转换字段名为下划线格式
             const dbFieldName = snakeCase(fieldKey);

package/sync/syncDb/tableCreate.ts

@@ -10,16 +10,14 @@
  */
 import { snakeCase } from 'es-toolkit/string';
 import { Logger } from '../../lib/logger.js';
-import { IS_MYSQL, IS_PG, MYSQL_TABLE_CONFIG } from './constants.js';
+import { isMySQL, isPG, IS_PLAN, MYSQL_TABLE_CONFIG } from './constants.js';
 import { quoteIdentifier } from './helpers.js';
 import { buildSystemColumnDefs, buildBusinessColumnDefs, buildIndexSQL } from './ddl.js';
+import { getTableIndexes } from './schema.js';
 
 import type { SQL } from 'bun';
 import type { FieldDefinition } from 'befly/types/common';
 
-// 是否为计划模式（从环境变量读取）
-const IS_PLAN = process.argv.includes('--plan');
-
 /**
  * 为 PostgreSQL 表添加列注释
  *
@@ -68,13 +66,25 @@ async function addPostgresComments(sql: SQL, tableName: string, fields: Record<s
  * @param tableName - 表名
  * @param fields - 字段定义对象
  * @param systemIndexFields - 系统字段索引列表
+ * @param dbName - 数据库名称（用于检查索引是否存在）
  */
-async function createTableIndexes(sql: SQL, tableName: string, fields: Record<string, FieldDefinition>, systemIndexFields: string[]): Promise<void> {
+async function createTableIndexes(sql: SQL, tableName: string, fields: Record<string, FieldDefinition>, systemIndexFields: string[], dbName?: string): Promise<void> {
     const indexTasks: Promise<void>[] = [];
 
+    // 获取现有索引（MySQL 不支持 IF NOT EXISTS，需要先检查）
+    let existingIndexes: Record<string, string[]> = {};
+    if (isMySQL()) {
+        existingIndexes = await getTableIndexes(sql, tableName, dbName);
+    }
+
     // 系统字段索引
     for (const sysField of systemIndexFields) {
-        const stmt = buildIndexSQL(tableName, `idx_${sysField}`, sysField, 'create');
+        const indexName = `idx_${sysField}`;
+        // MySQL 跳过已存在的索引
+        if (isMySQL() && existingIndexes[indexName]) {
+            continue;
+        }
+        const stmt = buildIndexSQL(tableName, indexName, sysField, 'create');
         if (IS_PLAN) {
             Logger.debug(`[计划] ${stmt}`);
         } else {
@@ -88,7 +98,12 @@ async function createTableIndexes(sql: SQL, tableName: string, fields: Record<st
         const dbFieldName = snakeCase(fieldKey);
 
         if (fieldDef.index === true) {
-            const stmt = buildIndexSQL(tableName, `idx_${dbFieldName}`, dbFieldName, 'create');
+            const indexName = `idx_${dbFieldName}`;
+            // MySQL 跳过已存在的索引
+            if (isMySQL() && existingIndexes[indexName]) {
+                continue;
+            }
+            const stmt = buildIndexSQL(tableName, indexName, dbFieldName, 'create');
             if (IS_PLAN) {
                 Logger.debug(`[计划] ${stmt}`);
             } else {
@@ -110,8 +125,9 @@ async function createTableIndexes(sql: SQL, tableName: string, fields: Record<st
  * @param tableName - 表名
  * @param fields - 字段定义对象
  * @param systemIndexFields - 系统字段索引列表（可选，默认使用 ['created_at', 'updated_at', 'state']）
+ * @param dbName - 数据库名称（用于检查索引是否存在）
  */
-export async function createTable(sql: SQL, tableName: string, fields: Record<string, FieldDefinition>, systemIndexFields: string[] = ['created_at', 'updated_at', 'state']): Promise<void> {
+export async function createTable(sql: SQL, tableName: string, fields: Record<string, FieldDefinition>, systemIndexFields: string[] = ['created_at', 'updated_at', 'state'], dbName?: string): Promise<void> {
     // 构建列定义
     const colDefs = [...buildSystemColumnDefs(), ...buildBusinessColumnDefs(fields)];
 
@@ -119,7 +135,7 @@ export async function createTable(sql: SQL, tableName: string, fields: Record<st
     const cols = colDefs.join(',\n            ');
     const tableQuoted = quoteIdentifier(tableName);
     const { ENGINE, CHARSET, COLLATE } = MYSQL_TABLE_CONFIG;
-    const createSQL = IS_MYSQL
+    const createSQL = isMySQL()
         ? `CREATE TABLE ${tableQuoted} (
             ${cols}
         ) ENGINE=${ENGINE} DEFAULT CHARSET=${CHARSET} COLLATE=${COLLATE}`
@@ -134,13 +150,13 @@ export async function createTable(sql: SQL, tableName: string, fields: Record<st
     }
 
     // PostgreSQL: 添加列注释
-    if (IS_PG && !IS_PLAN) {
+    if (isPG() && !IS_PLAN) {
         await addPostgresComments(sql, tableName, fields);
-    } else if (IS_PG && IS_PLAN) {
+    } else if (isPG() && IS_PLAN) {
         // 计划模式也要输出注释语句
         await addPostgresComments(sql, tableName, fields);
     }
 
     // 创建索引
-    await createTableIndexes(sql, tableName, fields, systemIndexFields);
+    await createTableIndexes(sql, tableName, fields, systemIndexFields, dbName);
 }

package/sync/syncDb/types.ts

@@ -0,0 +1,126 @@
+/**
+ * syncDb 类型处理模块
+ *
+ * 包含：
+ * - SQL 类型映射和转换
+ * - 默认值处理
+ * - 类型判断工具
+ */
+
+import { isMySQL, getTypeMapping } from './constants.js';
+
+/**
+ * 判断是否为字符串或数组类型（需要长度参数）
+ *
+ * @param fieldType - 字段类型
+ * @returns 是否为字符串或数组类型
+ *
+ * @example
+ * isStringOrArrayType('string') // => true
+ * isStringOrArrayType('array_string') // => true
+ * isStringOrArrayType('array_text') // => false
+ * isStringOrArrayType('number') // => false
+ * isStringOrArrayType('text') // => false
+ */
+export function isStringOrArrayType(fieldType: string): boolean {
+    return fieldType === 'string' || fieldType === 'array_string';
+}
+
+/**
+ * 获取 SQL 数据类型
+ *
+ * @param fieldType - 字段类型（number/string/text/array_string/array_text）
+ * @param fieldMax - 最大长度（string/array_string 类型需要）
+ * @param unsigned - 是否无符号（仅 MySQL number 类型有效）
+ * @returns SQL 类型字符串
+ *
+ * @example
+ * getSqlType('string', 100) // => 'VARCHAR(100)'
+ * getSqlType('number', null, true) // => 'BIGINT UNSIGNED'
+ * getSqlType('text', null) // => 'MEDIUMTEXT'
+ * getSqlType('array_string', 500) // => 'VARCHAR(500)'
+ * getSqlType('array_text', null) // => 'MEDIUMTEXT'
+ */
+export function getSqlType(fieldType: string, fieldMax: number | null, unsigned: boolean = false): string {
+    const typeMapping = getTypeMapping();
+    if (isStringOrArrayType(fieldType)) {
+        return `${typeMapping[fieldType]}(${fieldMax})`;
+    }
+    // 处理 UNSIGNED 修饰符（仅 MySQL number 类型）
+    const baseType = typeMapping[fieldType] || 'TEXT';
+    if (isMySQL() && fieldType === 'number' && unsigned) {
+        return `${baseType} UNSIGNED`;
+    }
+    return baseType;
+}
+
+/**
+ * 处理默认值：将 null 或 'null' 字符串转换为对应类型的默认值
+ *
+ * @param fieldDefault - 字段默认值（可能是 null 或 'null' 字符串）
+ * @param fieldType - 字段类型（number/string/text/array）
+ * @returns 实际默认值
+ *
+ * @example
+ * resolveDefaultValue(null, 'string') // => ''
+ * resolveDefaultValue(null, 'number') // => 0
+ * resolveDefaultValue('null', 'number') // => 0
+ * resolveDefaultValue(null, 'array') // => '[]'
+ * resolveDefaultValue(null, 'text') // => 'null'
+ * resolveDefaultValue('admin', 'string') // => 'admin'
+ * resolveDefaultValue(0, 'number') // => 0
+ */
+export function resolveDefaultValue(fieldDefault: any, fieldType: 'number' | 'string' | 'text' | 'array'): any {
+    // null 或字符串 'null' 都表示使用类型默认值
+    if (fieldDefault !== null && fieldDefault !== 'null') {
+        return fieldDefault;
+    }
+
+    // null 表示使用类型默认值
+    switch (fieldType) {
+        case 'number':
+            return 0;
+        case 'string':
+            return '';
+        case 'array':
+            return '[]';
+        case 'text':
+            // text 类型不设置默认值，保持 'null'
+            return 'null';
+        default:
+            return fieldDefault;
+    }
+}
+
+/**
+ * 生成 SQL DEFAULT 子句
+ *
+ * @param actualDefault - 实际默认值（已经过 resolveDefaultValue 处理）
+ * @param fieldType - 字段类型
+ * @returns SQL DEFAULT 子句字符串（包含前导空格），如果不需要则返回空字符串
+ *
+ * @example
+ * generateDefaultSql(0, 'number') // => ' DEFAULT 0'
+ * generateDefaultSql('admin', 'string') // => " DEFAULT 'admin'"
+ * generateDefaultSql('', 'string') // => " DEFAULT ''"
+ * generateDefaultSql('null', 'text') // => ''
+ */
+export function generateDefaultSql(actualDefault: any, fieldType: 'number' | 'string' | 'text' | 'array'): string {
+    // text 类型不设置默认值
+    if (fieldType === 'text' || actualDefault === 'null') {
+        return '';
+    }
+
+    // 仅 number/string/array 类型设置默认值
+    if (fieldType === 'number' || fieldType === 'string' || fieldType === 'array') {
+        if (typeof actualDefault === 'number' && !Number.isNaN(actualDefault)) {
+            return ` DEFAULT ${actualDefault}`;
+        } else {
+            // 字符串需要转义单引号：' -> ''
+            const escaped = String(actualDefault).replace(/'/g, "''");
+            return ` DEFAULT '${escaped}'`;
+        }
+    }
+
+    return '';
+}

package/sync/syncDb/version.ts

@@ -6,7 +6,7 @@
  */
 
 import { Logger } from '../../lib/logger.js';
-import { DB_VERSION_REQUIREMENTS, IS_MYSQL, IS_PG, IS_SQLITE } from './constants.js';
+import { DB_VERSION_REQUIREMENTS, isMySQL, isPG, isSQLite } from './constants.js';
 import type { SQL } from 'bun';
 
 /**
@@ -23,7 +23,7 @@ import type { SQL } from 'bun';
 export async function ensureDbVersion(sql: SQL): Promise<void> {
     if (!sql) throw new Error('SQL 客户端未初始化');
 
-    if (IS_MYSQL) {
+    if (isMySQL()) {
         const r = await sql`SELECT VERSION() AS version`;
         if (!r || r.length === 0 || !r[0]?.version) {
             throw new Error('无法获取 MySQL 版本信息');
@@ -33,17 +33,15 @@ export async function ensureDbVersion(sql: SQL): Promise<void> {
         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) {
+    if (isPG()) {
         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) {
@@ -52,13 +50,12 @@ export async function ensureDbVersion(sql: SQL): Promise<void> {
         return;
     }
 
-    if (IS_SQLITE) {
+    if (isSQLite()) {
         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('.')

package/sync/syncDb.ts

@@ -1,19 +1,164 @@
 /**
  * SyncDb 命令 - 同步数据库表结构
+ *
+ * 功能：
+ * - 协调所有模块，执行数据库表结构同步
+ * - 处理核心表、项目表、addon 表
+ * - 提供统计信息和错误处理
  */
 
-import { join } from 'pathe';
+import { resolve } from 'pathe';
 import { existsSync } from 'node:fs';
+import { snakeCase } from 'es-toolkit/string';
+import { Connect } from '../lib/connect.js';
+import { RedisHelper } from '../lib/redisHelper.js';
+import { checkTable } from '../checks/checkTable.js';
+import { scanFiles, scanAddons, addonDirExists, getAddonDir } from 'befly-util';
 import { Logger } from '../lib/logger.js';
-import { SyncDb } from './syncDb/index.js';
-import type { SyncDbOptions, BeflyOptions } from '../types/index.js';
+import { projectDir } from '../paths.js';
 
-export async function syncDbCommand(config: BeflyOptions, options: SyncDbOptions): Promise<void> {
+// 导入模块化的功能
+import { ensureDbVersion } from './syncDb/version.js';
+import { tableExists } from './syncDb/schema.js';
+import { modifyTable } from './syncDb/table.js';
+import { createTable } from './syncDb/tableCreate.js';
+import { applyFieldDefaults } from './syncDb/helpers.js';
+import { setDbType } from './syncDb/constants.js';
+import type { SQL } from 'bun';
+import type { BeflyOptions, SyncDbOptions } from '../types/index.js';
+
+// 全局 SQL 客户端实例
+let sql: SQL | null = null;
+
+// 记录处理过的表名（用于清理缓存）
+const processedTables: string[] = [];
+
+/**
+ * syncDbCommand - 数据库同步命令入口
+ *
+ * 流程：
+ * 1. 验证表定义文件
+ * 2. 建立数据库连接并检查版本
+ * 3. 扫描表定义文件（核心表、项目表、addon表）
+ * 4. 对比并应用表结构变更
+ */
+export async function syncDbCommand(config: BeflyOptions, options: SyncDbOptions = {}): Promise<void> {
     try {
-        // 执行同步
-        await SyncDb(config, options);
+        // 清空处理记录
+        processedTables.length = 0;
+
+        // 设置数据库类型（从配置获取）
+        const dbType = config.db?.type || 'mysql';
+        setDbType(dbType);
+
+        // 验证表定义文件
+        await checkTable();
+
+        // 建立数据库连接并检查版本
+        sql = await Connect.connectSql({ max: 1 });
+        await ensureDbVersion(sql);
+
+        // 初始化 Redis 连接（用于清理缓存）
+        await Connect.connectRedis();
+
+        // 扫描表定义文件
+        const directories: Array<{ path: string; type: 'app' | 'addon'; addonName?: string; addonNameSnake?: string }> = [];
+
+        // 1. 项目表（无前缀）- 如果 tables 目录存在
+        const projectTablesDir = resolve(projectDir, 'tables');
+        if (existsSync(projectTablesDir)) {
+            directories.push({ path: projectTablesDir, type: 'app' });
+        }
+
+        // 添加所有 addon 的 tables 目录（addon_{name}_ 前缀）
+        const addons = scanAddons();
+        for (const addon of addons) {
+            if (addonDirExists(addon, 'tables')) {
+                directories.push({
+                    path: getAddonDir(addon, 'tables'),
+                    type: 'addon',
+                    addonName: addon,
+                    addonNameSnake: snakeCase(addon) // 提前转换，避免每个文件都转换
+                });
+            }
+        }
+
+        // 处理表文件
+        for (const dirConfig of directories) {
+            const { path: dir, type } = dirConfig;
+
+            const files = await scanFiles(dir, '*.json');
+
+            for (const { filePath: file, fileName } of files) {
+                // 确定表名：
+                // - addon 表：{addonName}_{表名}
+                //   例如：admin addon 的 user.json → admin_user
+                // - 项目表：{表名}
+                //   例如：user.json → user
+                let tableName = snakeCase(fileName);
+                if (type === 'addon' && dirConfig.addonNameSnake) {
+                    // addon 表，使用提前转换好的名称
+                    tableName = `addon_${dirConfig.addonNameSnake}_${tableName}`;
+                }
+
+                // 如果指定了表名，则只同步该表
+                if (options.table && options.table !== tableName) {
+                    continue;
+                }
+
+                const tableDefinitionModule = await import(file, { with: { type: 'json' } });
+                const tableDefinition = tableDefinitionModule.default;
+
+                // 为字段属性设置默认值
+                for (const fieldDef of Object.values(tableDefinition)) {
+                    applyFieldDefaults(fieldDef);
+                }
+
+                const dbName = config.db?.database;
+                const existsTable = await tableExists(sql!, tableName, dbName);
+
+                // 读取 force 参数
+                const force = options.force || false;
+
+                if (existsTable) {
+                    await modifyTable(sql!, tableName, tableDefinition, force, dbName);
+                } else {
+                    await createTable(sql!, tableName, tableDefinition, ['created_at', 'updated_at', 'state'], dbName);
+                }
+
+                // 记录处理过的表名（用于清理缓存）
+                processedTables.push(tableName);
+            }
+        }
+
+        // 清理 Redis 缓存（如果有表被处理）
+        if (processedTables.length > 0) {
+            const redisHelper = new RedisHelper();
+            for (const tableName of processedTables) {
+                const cacheKey = `table:columns:${tableName}`;
+                try {
+                    await redisHelper.del(cacheKey);
+                } catch (error: any) {
+                    Logger.warn(`清理表 ${tableName} 的缓存失败: ${error.message}`);
+                }
+            }
+        }
     } catch (error: any) {
         Logger.error('数据库同步失败', error);
         throw error;
+    } finally {
+        if (sql) {
+            try {
+                await Connect.disconnectSql();
+            } catch (error: any) {
+                Logger.warn(`关闭数据库连接时出错: ${error.message}`);
+            }
+        }
+
+        try {
+            await Connect.disconnectRedis();
+        } catch (error: any) {
+            Logger.warn(`关闭 Redis 连接时出错: ${error.message}`);
+        }
     }
 }