befly 3.8.25 → 3.8.27

package/sync/syncApi.ts

@@ -12,7 +12,7 @@
  */
 import { readdirSync, statSync } from 'node:fs';
 import { join, dirname, relative, basename } from 'pathe';
-import { Database } from '../lib/database.js';
+import { Connect } from '../lib/connect.js';
 import { RedisHelper } from '../lib/redisHelper.js';
 import { scanFiles, scanAddons, addonDirExists, getAddonDir } from 'befly-util';
 
@@ -106,11 +106,11 @@ async function scanAllApis(projectRoot: string): Promise<ApiInfo[]> {
             const addonApisDir = getAddonDir(addonName, 'apis');
 
             // 读取 addon 配置
-            const addonConfigPath = getAddonDir(addonName, 'addon.config.json');
+            const addonPackageJsonPath = getAddonDir(addonName, 'package.json');
             let addonTitle = addonName;
             try {
-                const config = await import(addonConfigPath, { with: { type: 'json' } });
-                addonTitle = config.default.title || addonName;
+                const packageJson = await import(addonPackageJsonPath, { with: { type: 'json' } });
+                addonTitle = packageJson.default?.title || addonName;
             } catch (error) {
                 // 忽略配置读取错误
             }
@@ -220,9 +220,9 @@ export async function syncApiCommand(config: BeflyOptions, options: SyncApiOptio
         }
 
         // 连接数据库（SQL + Redis）
-        await Database.connect();
+        await Connect.connect(config);
 
-        const helper = Database.getDbHelper();
+        const helper = Connect.getDbHelper();
 
         // 1. 检查表是否存在（addon_admin_api 来自 addon-admin 组件）
         const exists = await helper.tableExists('addon_admin_api');
@@ -259,6 +259,6 @@ export async function syncApiCommand(config: BeflyOptions, options: SyncApiOptio
         Logger.error('API 同步失败:', error);
         throw error;
     } finally {
-        await Database?.disconnect();
+        await Connect.disconnect();
     }
 }

package/sync/syncDb/apply.ts

@@ -7,7 +7,7 @@
  */
 
 import { Logger } from '../../lib/logger.js';
-import { IS_MYSQL, IS_PG, IS_SQLITE, CHANGE_TYPE_LABELS, typeMapping } from './constants.js';
+import { IS_MYSQL, IS_PG, IS_SQLITE, IS_PLAN, CHANGE_TYPE_LABELS, typeMapping } from './constants.js';
 import { logFieldChange, resolveDefaultValue, isStringOrArrayType } from './helpers.js';
 import { executeDDLSafely, buildIndexSQL } from './ddl.js';
 import { rebuildSqliteTable } from './sqlite.js';
@@ -15,9 +15,6 @@ import type { FieldChange, IndexAction, TablePlan, ColumnInfo } from '../../type
 import type { SQL } from 'bun';
 import type { FieldDefinition } from 'befly/types/common';
 
-// 是否为计划模式（从环境变量读取）
-const IS_PLAN = process.argv.includes('--plan');
-
 /**
  * 构建 ALTER TABLE SQL 语句
  *

package/sync/syncDb/constants.ts

@@ -60,6 +60,9 @@ export const MYSQL_TABLE_CONFIG = {
     COLLATE: 'utf8mb4_0900_ai_ci'
 } as const;
 
+// 是否为计划模式（仅输出 SQL 不执行）
+export const IS_PLAN = process.argv.includes('--plan');
+
 // 数据库类型判断
 export const DB = (process.env.DB_TYPE || 'mysql').toLowerCase();
 export const IS_MYSQL = DB === 'mysql';

package/sync/syncDb/ddl.ts

@@ -11,7 +11,8 @@
 import { snakeCase } from 'es-toolkit/string';
 import { Logger } from '../../lib/logger.js';
 import { IS_MYSQL, IS_PG, typeMapping } from './constants.js';
-import { quoteIdentifier, resolveDefaultValue, generateDefaultSql, getSqlType, escapeComment } from './helpers.js';
+import { quoteIdentifier, escapeComment } from './helpers.js';
+import { resolveDefaultValue, generateDefaultSql, getSqlType } from './types.js';
 
 import type { SQL } from 'bun';
 import type { FieldDefinition, AnyObject } from 'befly/types/common.js';

package/sync/syncDb/helpers.ts

@@ -3,13 +3,16 @@
  *
  * 包含：
  * - 标识符引用（反引号/双引号转义）
- * - 默认值处理
  * - 日志输出格式化
+ * - 字段默认值应用
  */
 
-import { IS_MYSQL, IS_PG, typeMapping } from './constants.js';
+import { IS_MYSQL, IS_PG } from './constants.js';
 import { Logger } from '../../lib/logger.js';
 
+// 从 types.ts 重新导出，保持向后兼容
+export { isStringOrArrayType, getSqlType, resolveDefaultValue, generateDefaultSql } from './types.js';
+
 /**
  * 根据数据库类型引用标识符
  *
@@ -28,121 +31,6 @@ export function quoteIdentifier(identifier: string): string {
     return identifier; // SQLite 无需引用
 }
 
-/**
- * 处理默认值：将 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 '';
-}
-
-/**
- * 判断是否为字符串或数组类型（需要长度参数）
- *
- * @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 {
-    if (isStringOrArrayType(fieldType)) {
-        return `${typeMapping[fieldType]}(${fieldMax})`;
-    }
-    // 处理 UNSIGNED 修饰符（仅 MySQL number 类型）
-    const baseType = typeMapping[fieldType] || 'TEXT';
-    if (IS_MYSQL && fieldType === 'number' && unsigned) {
-        return `${baseType} UNSIGNED`;
-    }
-    return baseType;
-}
-
 /**
  * 转义 SQL 注释中的双引号
  *

package/sync/syncDb/sqlite.ts

@@ -6,12 +6,10 @@
  */
 
 import { Logger } from '../../lib/logger.js';
+import { IS_PLAN } from './constants.js';
 import { createTable } from './tableCreate.js';
 import type { SQL } from 'bun';
 
-// 是否为计划模式（从环境变量读取）
-const IS_PLAN = process.argv.includes('--plan');
-
 /**
  * SQLite 重建表迁移（简化版）
  *

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 { IS_MYSQL, IS_PG, CHANGE_TYPE_LABELS, typeMapping } 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 = [];

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 { IS_MYSQL, IS_PG, 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 (IS_MYSQL) {
+        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 (IS_MYSQL && 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 (IS_MYSQL && 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)];
 
@@ -142,5 +158,5 @@ export async function createTable(sql: SQL, tableName: string, fields: Record<st
     }
 
     // 创建索引
-    await createTableIndexes(sql, tableName, fields, systemIndexFields);
+    await createTableIndexes(sql, tableName, fields, systemIndexFields, dbName);
 }

package/sync/syncDb/types.ts

@@ -0,0 +1,125 @@
+/**
+ * syncDb 类型处理模块
+ *
+ * 包含：
+ * - SQL 类型映射和转换
+ * - 默认值处理
+ * - 类型判断工具
+ */
+
+import { IS_MYSQL, typeMapping } 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 {
+    if (isStringOrArrayType(fieldType)) {
+        return `${typeMapping[fieldType]}(${fieldMax})`;
+    }
+    // 处理 UNSIGNED 修饰符（仅 MySQL number 类型）
+    const baseType = typeMapping[fieldType] || 'TEXT';
+    if (IS_MYSQL && 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

@@ -33,7 +33,6 @@ 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;
     }
 
@@ -43,7 +42,6 @@ export async function ensureDbVersion(sql: SQL): Promise<void> {
             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) {
@@ -58,7 +56,6 @@ export async function ensureDbVersion(sql: SQL): Promise<void> {
             throw new Error('无法获取 SQLite 版本信息');
         }
         const version = r[0].version;
-        Logger.debug(`SQLite 版本: ${version}`);
         // 强制最低版本：SQLite ≥ 3.50.0
         const [maj, min, patch] = String(version)
             .split('.')