befly 3.15.0 → 3.15.1

package/dist/sync/syncTable.js

@@ -10,6 +10,20 @@ import { getDialectByName, getSyncTableColumnsInfoQuery, getSyncTableIndexesQuer
 import { Logger } from "../lib/logger";
 import { normalizeFieldDefinition } from "../utils/normalizeFieldDefinition";
 import { snakeCase } from "../utils/util";
+function createRuntimeForIO(dbDialect, db, dbName = "") {
+    return {
+        dbDialect: dbDialect,
+        db: db,
+        dbName: dbName
+    };
+}
+function buildRuntimeIoError(operation, tableName, error) {
+    const errMsg = String(error?.message || error);
+    const outErr = new Error(`同步表：读取元信息失败，操作=${operation}，表=${tableName}，错误=${errMsg}`);
+    if (error?.sqlInfo)
+        outErr.sqlInfo = error.sqlInfo;
+    return outErr;
+}
 /**
  * 数据库同步命令入口（函数模式）
  */
@@ -18,39 +32,22 @@ export const syncTable = (async (ctx, items) => {
         // 记录处理过的表名（用于清理缓存）
         const processedTables = [];
         if (!Array.isArray(items)) {
-            throw new Error("syncTable(items) 参数必须是数组");
+            throw new Error("同步表：请传入多个表定义组成的数组");
         }
-        if (!ctx) {
-            throw new Error("syncTable(ctx, items) 缺少 ctx");
-        }
-        if (!ctx.db) {
-            throw new Error("syncTable(ctx, items) 缺少 ctx.db");
+        if (!ctx?.db) {
+            throw new Error("同步表：ctx.db 未初始化");
         }
         if (!ctx.redis) {
-            throw new Error("syncTable(ctx, items) 缺少 ctx.redis");
+            throw new Error("同步表：ctx.redis 未初始化");
         }
         if (!ctx.config) {
-            throw new Error("syncTable(ctx, items) 缺少 ctx.config");
-        }
-        // DbDialect 归一化（允许值与映射关系）：
-        //
-        // | ctx.config.db.type 输入 | 归一化 dbDialect |
-        // |------------------------|------------------|
-        // | mysql / 其他 / 空值    | mysql            |
-        // | postgres / postgresql  | postgresql       |
-        // | sqlite                 | sqlite           |
-        //
-        // 约束：后续若新增方言，必须同步更新：
-        // - 这里的归一化
-        // - ensureDbVersion / runtime I/O / DDL 分支
-        const dbType = String(ctx.config.db?.type || "mysql").toLowerCase();
-        let dbDialect = "mysql";
-        if (dbType === "postgres" || dbType === "postgresql") {
-            dbDialect = "postgresql";
+            throw new Error("同步表：ctx.config 未初始化");
         }
-        else if (dbType === "sqlite") {
-            dbDialect = "sqlite";
+        if (!ctx.config.db?.dialect) {
+            throw new Error("同步表：ctx.config.db.dialect 缺失");
         }
+        // DbDialect（按项目约定：正常启动时会先通过 checkConfig，因此这里直接使用配置值）
+        const dbDialect = ctx.config.db.dialect;
         // 检查数据库版本（复用 ctx.db 的现有连接/事务）
         await ensureDbVersion(dbDialect, ctx.db);
         const databaseName = ctx.config.db?.database || "";
@@ -64,32 +61,17 @@ export const syncTable = (async (ctx, items) => {
             if (!item || item.type !== "table") {
                 continue;
             }
-            if (item.source !== "app" && item.source !== "addon" && item.source !== "core") {
-                Logger.warn(`syncTable 跳过未知来源表定义: source=${String(item.source)} fileName=${String(item.fileName)}`);
-                continue;
-            }
             // 确定表名：
             // - addon 表：addon_{addonName}_{fileName}
             // - app/core 表：{fileName}
-            const baseTableName = snakeCase(item.fileName);
-            let tableName = baseTableName;
-            if (item.source === "addon") {
-                if (!item.addonName || String(item.addonName).trim() === "") {
-                    throw new Error(`syncTable addon 表缺少 addonName: fileName=${String(item.fileName)}`);
-                }
-                tableName = `addon_${snakeCase(item.addonName)}_${baseTableName}`;
-            }
-            const tableDefinition = item.content;
-            if (!tableDefinition || typeof tableDefinition !== "object") {
-                throw new Error(`syncTable 表定义无效: table=${tableName}`);
-            }
+            const tableName = item.source === "addon" ? `addon_${snakeCase(item.addonName)}_${snakeCase(item.fileName)}` : snakeCase(item.fileName);
+            const tableFields = item.content;
             // 为字段属性设置默认值：表定义来自 JSON/扫描结果，字段可能缺省。
             // 缺省会让 diff/DDL 生成出现 undefined vs null 等差异，导致错误的变更判断。
-            for (const fieldDef of Object.values(tableDefinition)) {
-                applyFieldDefaults(fieldDef);
+            for (const fieldDef of Object.values(tableFields)) {
+                normalizeFieldDefinitionInPlace(fieldDef);
             }
             const existsTable = await tableExistsRuntime(runtime, tableName);
-            const tableFields = tableDefinition;
             if (existsTable) {
                 await modifyTableRuntime(runtime, tableName, tableFields);
             }
@@ -205,7 +187,7 @@ const SYNC_TABLE_TEST_KIT = {
     getTypeMapping: getTypeMapping,
     quoteIdentifier: quoteIdentifier,
     escapeComment: escapeComment,
-    applyFieldDefaults: applyFieldDefaults,
+    normalizeFieldDefinitionInPlace: normalizeFieldDefinitionInPlace,
     isStringOrArrayType: isStringOrArrayType,
     getSqlType: getSqlType,
     resolveDefaultValue: resolveDefaultValue,
@@ -219,13 +201,7 @@ const SYNC_TABLE_TEST_KIT = {
     tableExistsRuntime: tableExistsRuntime,
     getTableColumnsRuntime: getTableColumnsRuntime,
     getTableIndexesRuntime: getTableIndexesRuntime,
-    createRuntime: (dbDialect, db, dbName = "") => {
-        return {
-            dbDialect: dbDialect,
-            db: db,
-            dbName: dbName
-        };
-    }
+    createRuntime: createRuntimeForIO
 };
 // 测试能力挂载（避免导出零散函数，同时确保运行时存在）
 syncTable.TestKit = SYNC_TABLE_TEST_KIT;
@@ -282,88 +258,19 @@ function normalizeColumnDefaultValue(value) {
 // 注意：这里刻意不封装“logFieldChange/formatFieldList”之类的一次性工具函数，
 // 以减少抽象层级（按项目要求：能直写就直写）。
 /**
- * 为字段定义应用默认值
+ * 为字段定义应用默认值（就地归一化）
  */
-function isJsonValue(value) {
-    if (value === null)
-        return true;
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
-        return true;
-    if (Array.isArray(value)) {
-        return value.every((v) => isJsonValue(v));
-    }
-    if (typeof value === "object") {
-        for (const v of Object.values(value)) {
-            if (v === undefined)
-                continue;
-            if (!isJsonValue(v))
-                return false;
-        }
-        return true;
-    }
-    return false;
-}
-function applyFieldDefaults(fieldDef) {
-    if (!fieldDef || typeof fieldDef !== "object")
-        return;
-    const record = fieldDef;
-    const name = record["name"];
-    const type = record["type"];
-    if (typeof name !== "string" || typeof type !== "string")
-        return;
-    const minRaw = record["min"];
-    const maxRaw = record["max"];
-    const defaultRaw = record["default"];
-    const detailRaw = record["detail"];
-    const indexRaw = record["index"];
-    const uniqueRaw = record["unique"];
-    const nullableRaw = record["nullable"];
-    const unsignedRaw = record["unsigned"];
-    const regexpRaw = record["regexp"];
-    const input = {
-        name: name,
-        type: type
-    };
-    if (typeof detailRaw === "string") {
-        input.detail = detailRaw;
-    }
-    if (typeof minRaw === "number" || minRaw === null) {
-        input.min = minRaw;
-    }
-    if (typeof maxRaw === "number" || maxRaw === null) {
-        input.max = maxRaw;
-    }
-    if (defaultRaw === null) {
-        input.default = null;
-    }
-    else if (isJsonValue(defaultRaw)) {
-        input.default = defaultRaw;
-    }
-    if (typeof indexRaw === "boolean") {
-        input.index = indexRaw;
-    }
-    if (typeof uniqueRaw === "boolean") {
-        input.unique = uniqueRaw;
-    }
-    if (typeof nullableRaw === "boolean") {
-        input.nullable = nullableRaw;
-    }
-    if (typeof unsignedRaw === "boolean") {
-        input.unsigned = unsignedRaw;
-    }
-    if (typeof regexpRaw === "string" || regexpRaw === null) {
-        input.regexp = regexpRaw;
-    }
-    const normalized = normalizeFieldDefinition(input);
-    record["detail"] = normalized.detail;
-    record["min"] = normalized.min;
-    record["max"] = normalized.max;
-    record["default"] = normalized.default;
-    record["index"] = normalized.index;
-    record["unique"] = normalized.unique;
-    record["nullable"] = normalized.nullable;
-    record["unsigned"] = normalized.unsigned;
-    record["regexp"] = normalized.regexp;
+function normalizeFieldDefinitionInPlace(fieldDef) {
+    const normalized = normalizeFieldDefinition(fieldDef);
+    fieldDef.detail = normalized.detail;
+    fieldDef.min = normalized.min;
+    fieldDef.max = normalized.max;
+    fieldDef.default = normalized.default;
+    fieldDef.index = normalized.index;
+    fieldDef.unique = normalized.unique;
+    fieldDef.nullable = normalized.nullable;
+    fieldDef.unsigned = normalized.unsigned;
+    fieldDef.regexp = normalized.regexp;
 }
 /**
  * 判断是否为字符串或数组类型（需要长度参数）
@@ -620,41 +527,45 @@ function isCompatibleTypeChange(currentType, newType) {
 // 读：表是否存在
 // ---------------------------------------------------------------------------
 async function tableExistsRuntime(runtime, tableName) {
-    const db = runtime.db;
-    if (!db)
-        throw new Error("SQL 执行器未初始化");
     try {
         // 统一交由方言层构造 SQL；syncTable 仅决定“要查哪个 schema/db”。
         // - MySQL：传 runtime.dbName（information_schema.table_schema）
         // - PostgreSQL：固定 public（项目约定）
         // - SQLite：忽略 schema
-        let schema = undefined;
-        if (runtime.dbDialect === "mysql") {
-            schema = runtime.dbName;
-        }
-        else if (runtime.dbDialect === "postgresql") {
-            schema = "public";
-        }
+        const schema = runtime.dbDialect === "mysql" ? runtime.dbName : runtime.dbDialect === "postgresql" ? "public" : undefined;
         const q = getDialectByName(runtime.dbDialect).tableExistsQuery(tableName, schema);
-        const res = await db.unsafe(q.sql, q.params);
+        const res = await runtime.db.unsafe(q.sql, q.params);
         return (res.data?.[0]?.count || 0) > 0;
     }
     catch (error) {
-        const errMsg = String(error?.message || error);
-        const outErr = new Error(`runtime I/O 失败: op=tableExists table=${tableName} err=${errMsg}`);
-        if (error?.sqlInfo)
-            outErr.sqlInfo = error.sqlInfo;
-        throw outErr;
+        throw buildRuntimeIoError("检查表是否存在", tableName, error);
     }
 }
 // ---------------------------------------------------------------------------
 // 读：列信息
 // ---------------------------------------------------------------------------
 async function getTableColumnsRuntime(runtime, tableName) {
+    // 返回的列数据示例
+    // [{
+    //   is_system: {
+    //     type: "bigint",
+    //     columnType: "bigint unsigned",
+    //     length: null,
+    //     max: null,
+    //     nullable: false,
+    //     defaultValue: "0",
+    //     comment: '',
+    // },
+    // description: {
+    //     type: "varchar",
+    //     columnType: "varchar(500)",
+    //     length: 500,
+    //     max: 500,
+    //     nullable: false,
+    //     defaultValue: "",
+    //     comment: '',
+    // }]
     const columns = {};
-    const db = runtime.db;
-    if (!db)
-        throw new Error("SQL 执行器未初始化");
     try {
         // 方言差异说明：
         // - MySQL：information_schema.columns 最完整，包含 COLUMN_TYPE 与 COLUMN_COMMENT。
@@ -662,31 +573,32 @@ async function getTableColumnsRuntime(runtime, tableName) {
         // - SQLite：PRAGMA table_info 仅提供 type/notnull/default 等有限信息，无列注释。
         if (runtime.dbDialect === "mysql") {
             const q = getSyncTableColumnsInfoQuery({ dialect: "mysql", table: tableName, dbName: runtime.dbName });
-            const result = await db.unsafe(q.columns.sql, q.columns.params);
+            const result = await runtime.db.unsafe(q.columns.sql, q.columns.params);
             for (const row of result.data) {
                 const defaultValue = normalizeColumnDefaultValue(row.COLUMN_DEFAULT);
                 columns[row.COLUMN_NAME] = {
-                    type: row.DATA_TYPE,
-                    columnType: row.COLUMN_TYPE,
+                    // 防御性：某些 driver/编码设置可能导致字符串字段不是 string（如 Buffer/number/null）。
+                    type: String(row.DATA_TYPE ?? ""),
+                    columnType: String(row.COLUMN_TYPE ?? ""),
                     length: row.CHARACTER_MAXIMUM_LENGTH,
                     max: row.CHARACTER_MAXIMUM_LENGTH,
                     nullable: row.IS_NULLABLE === "YES",
                     defaultValue: defaultValue,
-                    comment: row.COLUMN_COMMENT
+                    comment: row.COLUMN_COMMENT === null ? null : String(row.COLUMN_COMMENT)
                 };
             }
         }
         else if (runtime.dbDialect === "postgresql") {
             const q = getSyncTableColumnsInfoQuery({ dialect: "postgresql", table: tableName, dbName: runtime.dbName });
-            const result = await db.unsafe(q.columns.sql, q.columns.params);
-            const comments = q.comments ? (await db.unsafe(q.comments.sql, q.comments.params)).data : [];
+            const result = await runtime.db.unsafe(q.columns.sql, q.columns.params);
+            const comments = q.comments ? (await runtime.db.unsafe(q.comments.sql, q.comments.params)).data : [];
             const commentMap = {};
             for (const r of comments)
                 commentMap[r.column_name] = r.column_comment;
             for (const row of result.data) {
                 columns[row.column_name] = {
-                    type: row.data_type,
-                    columnType: row.data_type,
+                    type: String(row.data_type ?? ""),
+                    columnType: String(row.data_type ?? ""),
                     length: row.character_maximum_length,
                     max: row.character_maximum_length,
                     nullable: String(row.is_nullable).toUpperCase() === "YES",
@@ -697,24 +609,18 @@ async function getTableColumnsRuntime(runtime, tableName) {
         }
         else if (runtime.dbDialect === "sqlite") {
             const q = getSyncTableColumnsInfoQuery({ dialect: "sqlite", table: tableName, dbName: runtime.dbName });
-            const result = await db.unsafe(q.columns.sql, q.columns.params);
+            const result = await runtime.db.unsafe(q.columns.sql, q.columns.params);
             for (const row of result.data) {
                 let baseType = String(row.type || "").toUpperCase();
                 let max = null;
                 const m = /^(\w+)\s*\((\d+)\)/.exec(baseType);
-                if (m) {
-                    const base = m[1];
-                    const maxText = m[2];
-                    if (typeof base === "string") {
-                        baseType = base;
-                    }
-                    if (typeof maxText === "string") {
-                        max = Number(maxText);
-                    }
+                if (m && m[1] && m[2]) {
+                    baseType = m[1];
+                    max = Number(m[2]);
                 }
                 columns[row.name] = {
-                    type: baseType.toLowerCase(),
-                    columnType: baseType.toLowerCase(),
+                    type: String(baseType).toLowerCase(),
+                    columnType: String(baseType).toLowerCase(),
                     length: max,
                     max: max,
                     nullable: row.notnull === 0,
@@ -726,21 +632,22 @@ async function getTableColumnsRuntime(runtime, tableName) {
         return columns;
     }
     catch (error) {
-        const errMsg = String(error?.message || error);
-        const outErr = new Error(`runtime I/O 失败: op=getTableColumns table=${tableName} err=${errMsg}`);
-        if (error?.sqlInfo)
-            outErr.sqlInfo = error.sqlInfo;
-        throw outErr;
+        throw buildRuntimeIoError("读取列信息", tableName, error);
     }
 }
 // ---------------------------------------------------------------------------
 // 读：索引信息（单列索引）
 // ---------------------------------------------------------------------------
 async function getTableIndexesRuntime(runtime, tableName) {
+    //  索引返回示例
+    //  {
+    //     code: [ "code" ],
+    //     idx_created_at: [ "created_at" ],
+    //     idx_group: [ "group" ],
+    //     idx_state: [ "state" ],
+    //     idx_updated_at: [ "updated_at" ],
+    // }
     const indexes = {};
-    const db = runtime.db;
-    if (!db)
-        throw new Error("SQL 执行器未初始化");
     try {
         // 方言差异说明：
         // - MySQL：information_schema.statistics 直接给出 index -> column 映射。
@@ -748,7 +655,7 @@ async function getTableIndexesRuntime(runtime, tableName) {
         // - SQLite：PRAGMA index_list + index_info；同样仅收集单列索引，避免多列索引误判。
         if (runtime.dbDialect === "mysql") {
             const q = getSyncTableIndexesQuery({ dialect: "mysql", table: tableName, dbName: runtime.dbName });
-            const result = await db.unsafe(q.sql, q.params);
+            const result = await runtime.db.unsafe(q.sql, q.params);
             for (const row of result.data) {
                 const indexName = row.INDEX_NAME;
                 const current = indexes[indexName];
@@ -762,7 +669,7 @@ async function getTableIndexesRuntime(runtime, tableName) {
         }
         else if (runtime.dbDialect === "postgresql") {
             const q = getSyncTableIndexesQuery({ dialect: "postgresql", table: tableName, dbName: runtime.dbName });
-            const result = await db.unsafe(q.sql, q.params);
+            const result = await runtime.db.unsafe(q.sql, q.params);
             for (const row of result.data) {
                 const m = /\(([^)]+)\)/.exec(row.indexdef);
                 if (m) {
@@ -774,10 +681,10 @@ async function getTableIndexesRuntime(runtime, tableName) {
         }
         else if (runtime.dbDialect === "sqlite") {
             const quotedTable = quoteIdentifier("sqlite", tableName);
-            const list = await db.unsafe(`PRAGMA index_list(${quotedTable})`);
+            const list = await runtime.db.unsafe(`PRAGMA index_list(${quotedTable})`);
             for (const idx of list.data) {
                 const quotedIndex = quoteIdentifier("sqlite", idx.name);
-                const info = await db.unsafe(`PRAGMA index_info(${quotedIndex})`);
+                const info = await runtime.db.unsafe(`PRAGMA index_info(${quotedIndex})`);
                 const cols = info.data.map((r) => r.name);
                 if (cols.length === 1)
                     indexes[idx.name] = cols;
@@ -786,11 +693,7 @@ async function getTableIndexesRuntime(runtime, tableName) {
         return indexes;
     }
     catch (error) {
-        const errMsg = String(error?.message || error);
-        const outErr = new Error(`runtime I/O 失败: op=getTableIndexes table=${tableName} err=${errMsg}`);
-        if (error?.sqlInfo)
-            outErr.sqlInfo = error.sqlInfo;
-        throw outErr;
+        throw buildRuntimeIoError("读取索引信息", tableName, error);
     }
 }
 // ---------------------------------------------------------------------------
@@ -800,39 +703,37 @@ async function getTableIndexesRuntime(runtime, tableName) {
  * 数据库版本检查（按方言）
  */
 async function ensureDbVersion(dbDialect, db) {
-    if (!db)
-        throw new Error("SQL 执行器未初始化");
     if (dbDialect === "mysql") {
         const r = await db.unsafe("SELECT VERSION() AS version");
         if (!r.data || r.data.length === 0 || !r.data[0]?.version) {
-            throw new Error("无法获取 MySQL 版本信息");
+            throw new Error("同步表：无法获取 MySQL 版本信息");
         }
         const version = r.data[0].version;
         const majorPart = String(version).split(".")[0] || "0";
         const majorVersion = parseInt(majorPart, 10);
         if (!Number.isFinite(majorVersion) || majorVersion < DB_VERSION_REQUIREMENTS.MYSQL_MIN_MAJOR) {
-            throw new Error(`此脚本仅支持 MySQL ${DB_VERSION_REQUIREMENTS.MYSQL_MIN_MAJOR}.0+，当前版本: ${version}`);
+            throw new Error(`同步表：仅支持 MySQL ${DB_VERSION_REQUIREMENTS.MYSQL_MIN_MAJOR}.0+（当前版本：${version}）`);
         }
         return;
     }
     if (dbDialect === "postgresql") {
         const r = await db.unsafe("SELECT version() AS version");
         if (!r.data || r.data.length === 0 || !r.data[0]?.version) {
-            throw new Error("无法获取 PostgreSQL 版本信息");
+            throw new Error("同步表：无法获取 PostgreSQL 版本信息");
         }
         const versionText = r.data[0].version;
         const m = /PostgreSQL\s+(\d+)/i.exec(versionText);
         const majorText = m ? m[1] : undefined;
         const major = typeof majorText === "string" ? parseInt(majorText, 10) : NaN;
         if (!Number.isFinite(major) || major < DB_VERSION_REQUIREMENTS.POSTGRES_MIN_MAJOR) {
-            throw new Error(`此脚本要求 PostgreSQL >= ${DB_VERSION_REQUIREMENTS.POSTGRES_MIN_MAJOR}，当前: ${versionText}`);
+            throw new Error(`同步表：要求 PostgreSQL >= ${DB_VERSION_REQUIREMENTS.POSTGRES_MIN_MAJOR}（当前：${versionText}）`);
         }
         return;
     }
     if (dbDialect === "sqlite") {
         const r = await db.unsafe("SELECT sqlite_version() AS version");
         if (!r.data || r.data.length === 0 || !r.data[0]?.version) {
-            throw new Error("无法获取 SQLite 版本信息");
+            throw new Error("同步表：无法获取 SQLite 版本信息");
         }
         const version = r.data[0].version;
         const parts = String(version)
@@ -843,7 +744,7 @@ async function ensureDbVersion(dbDialect, db) {
         const patch = parts[2] ?? 0;
         const vnum = maj * 10000 + min * 100 + patch;
         if (!Number.isFinite(vnum) || vnum < DB_VERSION_REQUIREMENTS.SQLITE_MIN_VERSION_NUM) {
-            throw new Error(`此脚本要求 SQLite >= ${DB_VERSION_REQUIREMENTS.SQLITE_MIN_VERSION}，当前: ${version}`);
+            throw new Error(`同步表：要求 SQLite >= ${DB_VERSION_REQUIREMENTS.SQLITE_MIN_VERSION}（当前：${version}）`);
         }
         return;
     }
@@ -869,7 +770,7 @@ function compareFieldDefinition(dbDialect, existingColumn, fieldDef) {
         }
     }
     if (dbDialect !== "sqlite") {
-        const currentComment = existingColumn.comment || "";
+        const currentComment = existingColumn.comment === null || existingColumn.comment === undefined ? "" : String(existingColumn.comment);
         if (currentComment !== normalized.name) {
             changes.push({
                 type: "comment",
@@ -881,10 +782,26 @@ function compareFieldDefinition(dbDialect, existingColumn, fieldDef) {
     const typeMapping = getTypeMapping(dbDialect);
     const mapped = typeMapping[normalized.type];
     if (typeof mapped !== "string") {
-        throw new Error(`未知字段类型映射：dialect=${dbDialect} type=${String(normalized.type)}`);
+        throw new Error(`同步表：未知字段类型映射（方言=${dbDialect}，类型=${String(normalized.type)}）`);
     }
     const expectedType = mapped.toLowerCase();
-    const currentType = existingColumn.type.toLowerCase();
+    // 防御性：理论上 ColumnInfo.type/columnType 都应为 string，但线上偶发出现 number/null/Buffer 等导致崩溃。
+    // 同时：columnType 可能包含长度/unsigned（如 varchar(255), bigint unsigned），这里归一化为“基础类型”再比较。
+    let rawType = "";
+    if (typeof existingColumn.type === "string" && existingColumn.type.trim() !== "") {
+        rawType = existingColumn.type;
+    }
+    else if (typeof existingColumn.columnType === "string" && existingColumn.columnType.trim() !== "") {
+        rawType = existingColumn.columnType;
+    }
+    else {
+        rawType = String(existingColumn.type ?? "");
+    }
+    const currentType = rawType
+        .toLowerCase()
+        .replace(/\s*unsigned/gi, "")
+        .replace(/\([^)]*\)/g, "")
+        .trim();
     if (currentType !== expectedType) {
         changes.push({
             type: "datatype",
@@ -922,7 +839,7 @@ async function rebuildSqliteTable(runtime, tableName, fields) {
     // - 只复制 targetCols 与 existingCols 的交集，避免因新增列/删除列导致 INSERT 失败。
     // - 不做额外的数据转换/回填：保持迁移路径尽量“纯结构同步”。
     if (runtime.dbDialect !== "sqlite") {
-        throw new Error(`rebuildSqliteTable 仅支持 sqlite 方言，当前: ${String(runtime.dbDialect)}`);
+        throw new Error(`同步表：SQLite 重建表仅支持 sqlite 方言（当前：${String(runtime.dbDialect)}）`);
     }
     const quotedSourceTable = quoteIdentifier("sqlite", tableName);
     const info = await runtime.db.unsafe(`PRAGMA table_info(${quotedSourceTable})`);

package/dist/types/befly.d.ts

@@ -21,8 +21,8 @@ export type BeflyRuntimeEnv = Record<string, string | undefined>;
 export interface DatabaseConfig {
     /** 是否启用数据库 (0: 关闭, 1: 开启) @default 0 */
     enable?: number;
-    /** 数据库类型 ('mysql' | 'postgres' | 'sqlite') @default 'sqlite' */
-    type?: string;
+    /** 数据库方言 ('mysql' | 'postgresql' | 'sqlite') @default 'sqlite' */
+    dialect?: "mysql" | "postgresql" | "sqlite";
     /** 数据库主机 @default '127.0.0.1' */
     host?: string;
     /** 数据库端口 @default 3306 */

package/dist/types/database.d.ts

@@ -18,7 +18,7 @@ export type DbTableName = keyof DbRowMap & string;
 /**
  * 数据库类型
  */
-export type DatabaseType = "mysql" | "postgres" | "sqlite";
+export type DatabaseType = "mysql" | "postgresql" | "sqlite";
 /**
  * 查询选项
  */

package/dist/types/table.d.ts

@@ -28,7 +28,7 @@ export interface CreateTableOptions {
  */
 export interface SqlHelperOptions {
     /** 数据库类型 */
-    type: "mysql" | "postgres" | "sqlite";
+    type: "mysql" | "postgresql" | "sqlite";
     /** 表名前缀 */
     prefix?: string;
 }

package/dist/types/validate.d.ts

@@ -46,7 +46,7 @@ export interface FieldDefinition {
     unique?: boolean;
     /**
      * 是否可为 NULL。
-     * - 缺省默认：true
+     * - 缺省默认：false
      */
     nullable?: boolean;
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "befly",
-    "version": "3.15.0",
-    "gitHead": "3a9dc64d2eb69e646f4fd6eebd5d8dbe6516cb69",
+    "version": "3.15.1",
+    "gitHead": "540d9551c589cb33d711c593e561f0fffc0aac0c",
     "private": false,
     "description": "Befly - 为 Bun 专属打造的 TypeScript API 接口框架核心引擎",
     "keywords": [