befly 3.15.27 → 3.16.1

package/dist/checks/checkTable.js

@@ -1,5 +1,6 @@
 import { Logger } from "../lib/logger";
 import { CoreError } from "../types/coreError";
+import { isDecimalDbType as isDecimalDbTypeRule, isEnumDbType as isEnumDbTypeRule, isFloatDbType as isFloatDbTypeRule, isIntDbType as isIntDbTypeRule, isJsonDbType as isJsonDbTypeRule, isNumericDbType as isNumericDbTypeRule, isStringDbType as isStringDbTypeRule, isTextDbType as isTextDbTypeRule, normalizeTypeAndInput, parseEnumRuleValues } from "../utils/dbFieldRules";
 import { formatValuePreview, isAliasInput, isEnumInput, isJsonValue, isRegexInput, snakeCase } from "../utils/util";
 /**
  * 保留字段列表
@@ -9,54 +10,13 @@ const RESERVED_FIELD_SET = new Set(RESERVED_FIELDS);
 /**
  * 允许的数据库字段类型
  */
-const FIELD_TYPES = ["tinyint", "smallint", "mediumint", "int", "bigint", "decimal", "float", "double", "char", "varchar", "tinytext", "text", "mediumtext", "longtext", "datetime", "json"];
+const FIELD_TYPES = ["tinyint", "smallint", "mediumint", "int", "bigint", "decimal", "float", "double", "char", "varchar", "enum", "tinytext", "text", "mediumtext", "longtext", "datetime", "timestamp", "json"];
 const FIELD_TYPE_SET = new Set(FIELD_TYPES);
 /**
  * 允许的输入类型
  */
 const INPUT_TYPES = ["number", "integer", "string", "char", "array", "array_number", "array_integer", "json", "json_number", "json_integer"];
 const INPUT_TYPE_SET = new Set(INPUT_TYPES);
-/**
- * 根据数据库类型推导默认 input 类型。
- */
-function inferInputByType(dbType) {
-    switch (dbType.toLowerCase()) {
-        case "tinyint":
-        case "smallint":
-        case "mediumint":
-        case "int":
-        case "bigint":
-            return "integer";
-        case "decimal":
-        case "float":
-        case "double":
-            return "number";
-        case "char":
-        case "varchar":
-        case "tinytext":
-        case "text":
-        case "mediumtext":
-        case "longtext":
-            return "string";
-        case "datetime":
-            return "string";
-        case "json":
-            return "json";
-        default:
-            return "string";
-    }
-}
-/**
- * 归一化 type 与 input，input 为空时使用推导值。
- */
-function normalizeTypeAndInput(type, input) {
-    const rawType = String(type || "").trim();
-    const rawInput = String(input || "").trim();
-    return {
-        type: rawType,
-        input: rawInput || inferInputByType(rawType)
-    };
-}
 /**
  * 允许的字段属性列表
  */
@@ -220,21 +180,32 @@ export async function checkTable(tables, config) {
                     Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 input "${normalizedInput}" 不合法，` + `必须为${INPUT_TYPES.join("、")}之一，或正则/枚举/正则别名`);
                     hasError = true;
                 }
-                const isStringDbType = ["char", "varchar", "tinytext", "text", "mediumtext", "longtext"].includes(effectiveType);
-                const isTextDbType = ["tinytext", "text", "mediumtext", "longtext"].includes(effectiveType);
-                const isIntDbType = ["tinyint", "smallint", "mediumint", "int", "bigint"].includes(effectiveType);
-                const isDecimalDbType = effectiveType === "decimal";
-                const isFloatDbType = effectiveType === "float" || effectiveType === "double";
-                const isJsonDbType = effectiveType === "json";
-                const isNumericDbType = isIntDbType || isDecimalDbType || isFloatDbType;
+                const isDecimalDbType = isDecimalDbTypeRule(effectiveType);
+                const isFloatDbType = isFloatDbTypeRule(effectiveType);
+                const isJsonDbType = isJsonDbTypeRule(effectiveType);
+                const isEnumDbType = isEnumDbTypeRule(effectiveType);
+                const isNumericDbType = isNumericDbTypeRule(effectiveType);
+                const isStringDbTypeNormalized = isStringDbTypeRule(effectiveType);
+                const isTextDbTypeNormalized = isTextDbTypeRule(effectiveType);
+                const isIntDbTypeNormalized = isIntDbTypeRule(effectiveType);
+                if (isEnumDbType) {
+                    if (normalizedInput.trim() === "") {
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，必须设置 input 枚举规则（例如 a|b|c）`);
+                        hasError = true;
+                    }
+                    else if (!isEnumInput(normalizedInput)) {
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，input 必须为枚举规则（例如 a|b|c），当前为 ${formatValuePreview(normalizedInput)}`);
+                        hasError = true;
+                    }
+                }
                 if (isRegexInput(normalizedInput) || isEnumInput(normalizedInput) || isAliasInput(normalizedInput)) {
-                    if (!isStringDbType) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 input 使用正则/枚举/正则别名，仅允许字符串类字段（char/varchar/text）`);
+                    if (!isStringDbTypeNormalized) {
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 input 使用正则/枚举/正则别名，仅允许字符串类字段（char/varchar/enum/text）`);
                         hasError = true;
                     }
                 }
                 if (normalizedInput === "number" || normalizedInput === "integer") {
-                    if (normalizedInput === "integer" && !isIntDbType) {
+                    if (normalizedInput === "integer" && !isIntDbTypeNormalized) {
                         Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 input=${normalizedInput} 仅允许整数类字段（tinyint/smallint/mediumint/int/bigint）`);
                         hasError = true;
                     }
@@ -244,13 +215,13 @@ export async function checkTable(tables, config) {
                     }
                 }
                 if (normalizedInput === "array" || normalizedInput === "array_number" || normalizedInput === "array_integer") {
-                    if (!isStringDbType) {
+                    if (!isStringDbTypeNormalized) {
                         Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 input=${normalizedInput} 仅允许字符串类字段（char/varchar/text）`);
                         hasError = true;
                     }
                 }
                 if (normalizedInput === "json" || normalizedInput === "json_number" || normalizedInput === "json_integer") {
-                    if (!(isJsonDbType || isTextDbType)) {
+                    if (!(isJsonDbType || isTextDbTypeNormalized)) {
                         Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 input=${normalizedInput} 仅允许 json 或 text 类字段`);
                         hasError = true;
                     }
@@ -273,7 +244,7 @@ export async function checkTable(tables, config) {
                     }
                 }
                 // 类型联动校验 + 默认值规则
-                if (isTextDbType || isJsonDbType) {
+                if (isTextDbTypeNormalized || isJsonDbType) {
                     // text/json：min/max 必须为 null，默认值必须为 null，且不支持索引/唯一约束
                     if (field.min !== undefined && field.min !== null) {
                         Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 的 ${effectiveType} 类型最小值应为 null，当前为 "${field.min}"`);
@@ -296,25 +267,68 @@ export async function checkTable(tables, config) {
                         hasError = true;
                     }
                 }
-                else if (effectiveType === "datetime") {
-                    // datetime：对应 MySQL DATETIME（到秒）
+                else if (effectiveType === "datetime" || effectiveType === "timestamp") {
+                    // datetime/timestamp：对应 MySQL DATETIME/TIMESTAMP（到秒）
                     // - min/max 必须为 null
                     // - default 必须为 null（避免把 DDL 表达式当作运行期默认值）
                     // - 不允许 unsigned
                     if (field.min !== undefined && field.min !== null) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 datetime 类型，min 必须为 null，当前为 "${field.min}"`);
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${effectiveType} 类型，min 必须为 null，当前为 "${field.min}"`);
                         hasError = true;
                     }
                     if (field.max !== undefined && field.max !== null) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 datetime 类型，max 必须为 null，当前为 "${field.max}"`);
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${effectiveType} 类型，max 必须为 null，当前为 "${field.max}"`);
                         hasError = true;
                     }
                     if (field.default !== undefined && field.default !== null) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 datetime 类型，默认值必须为 null（如需当前时间，请在业务写入时赋值）。当前为 ${formatValuePreview(field.default)}`);
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${effectiveType} 类型，默认值必须为 null（如需当前时间，请在业务写入时赋值）。当前为 ${formatValuePreview(field.default)}`);
+                        hasError = true;
+                    }
+                    if (field.unsigned !== undefined) {
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${effectiveType} 类型，不允许设置 unsigned`);
+                        hasError = true;
+                    }
+                }
+                else if (effectiveType === "enum") {
+                    // enum：对应 MySQL ENUM('a','b',...)。
+                    // 约束：必须提供 input 枚举规则（a|b|c），由上方 isEnumDbType 分支保证。
+                    // - min/max/precision/scale 必须为 null
+                    // - default 若提供，必须为枚举值之一
+                    // - 若 nullable!=true，则必须提供 default（避免 NOT NULL 无默认值导致写入失败）
+                    // - 不允许 unsigned
+                    if (field.min !== undefined && field.min !== null) {
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，min 必须为 null，当前为 "${field.min}"`);
+                        hasError = true;
+                    }
+                    if (field.max !== undefined && field.max !== null) {
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，max 必须为 null，当前为 "${field.max}"`);
+                        hasError = true;
+                    }
+                    if (field.precision !== undefined && field.precision !== null) {
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，不允许设置 precision`);
+                        hasError = true;
+                    }
+                    if (field.scale !== undefined && field.scale !== null) {
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，不允许设置 scale`);
                         hasError = true;
                     }
                     if (field.unsigned !== undefined) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 datetime 类型，不允许设置 unsigned`);
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，不允许设置 unsigned`);
+                        hasError = true;
+                    }
+                    const enumValues = parseEnumRuleValues(normalizedInput);
+                    if (field.default === undefined || field.default === null) {
+                        if (field.nullable !== true) {
+                            Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，nullable!=true 时必须设置 default（且 default 必须为枚举值之一）`);
+                            hasError = true;
+                        }
+                    }
+                    else if (typeof field.default !== "string") {
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，默认值必须为字符串或 null` + `（typeof=${typeof field.default}，value=${formatValuePreview(field.default)}）`);
+                        hasError = true;
+                    }
+                    else if (!enumValues.includes(field.default)) {
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，默认值不在枚举范围内（default=${formatValuePreview(field.default)}，enums=${formatValuePreview(normalizedInput)}）`);
                         hasError = true;
                     }
                 }
@@ -382,7 +396,7 @@ export async function checkTable(tables, config) {
                         hasError = true;
                     }
                 }
-                else if (isIntDbType) {
+                else if (isIntDbTypeNormalized) {
                     // 整数类型：default 如果存在，必须为 null 或 number
                     if (field.default !== undefined && field.default !== null && typeof field.default !== "number") {
                         Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${effectiveType} 类型，默认值必须为数字或 null` + `（typeof=${typeof field.default}，value=${formatValuePreview(field.default)}）`);

package/dist/lib/validator.js

@@ -3,6 +3,7 @@
  * 纯静态类设计，简洁易用
  */
 import { RegexAliases, getCompiledRegex } from "../configs/presetRegexp";
+import { parseEnumRuleValues } from "../utils/dbFieldRules";
 import { normalizeFieldDefinition } from "../utils/normalizeFieldDefinition";
 import { isEnumInput, isFiniteNumber, isIntegerNumber, isJsonObject, isJsonPrimitive, isJsonStructure, isPlainObject, isRegexInput } from "../utils/util";
 const INPUT_TYPE_SET = new Set(["number", "integer", "string", "char", "array", "array_number", "array_integer", "json", "json_number", "json_integer"]);
@@ -209,13 +210,15 @@ export class Validator {
             }
             case "string": {
                 if (typeof value === "string") {
-                    if (String(dbType || "").toLowerCase() === "datetime") {
+                    const dbTypeNormalized = String(dbType || "").toLowerCase();
+                    if (dbTypeNormalized === "datetime" || dbTypeNormalized === "timestamp") {
                         const trimmed = value.trim();
                         return { value: trimmed, error: null };
                     }
                     return { value: value, error: null };
                 }
-                if (String(dbType || "").toLowerCase() === "datetime") {
+                const dbTypeNormalized = String(dbType || "").toLowerCase();
+                if (dbTypeNormalized === "datetime" || dbTypeNormalized === "timestamp") {
                     return { value: null, error: "必须是时间字符串" };
                 }
                 return { value: null, error: "必须是字符串" };
@@ -257,8 +260,9 @@ export class Validator {
                     return { value: null, error: "必须是JSON对象或数组" };
                 return checkJsonLeaves(value, "integer") ? { value: value, error: null } : { value: null, error: "JSON值必须是整数" };
             default: {
-                // 兜底：若 dbType 为 datetime，仍需字符串，且支持 YYYY-MM-DD 补零
-                if (String(dbType || "").toLowerCase() === "datetime") {
+                // 兜底：若 dbType 为 datetime/timestamp，仍需字符串
+                const dbTypeNormalized = String(dbType || "").toLowerCase();
+                if (dbTypeNormalized === "datetime" || dbTypeNormalized === "timestamp") {
                     if (typeof value !== "string")
                         return { value: null, error: "必须是时间字符串" };
                     const trimmed = value.trim();
@@ -302,10 +306,7 @@ export class Validator {
                     return "格式不正确";
             }
             if (isEnum) {
-                const enums = inputRaw
-                    .split("|")
-                    .map((item) => item.trim())
-                    .filter((item) => item !== "");
+                const enums = parseEnumRuleValues(inputRaw);
                 if (!enums.includes(value))
                     return "值不在枚举范围内";
             }
@@ -322,7 +323,8 @@ export class Validator {
             if (!isJsonStructure(value))
                 return "必须是JSON对象或数组";
         }
-        if (String(type || "").toLowerCase() === "datetime") {
+        const normalizedTypeForDb = String(type || "").toLowerCase();
+        if (normalizedTypeForDb === "datetime" || normalizedTypeForDb === "timestamp") {
             if (typeof value !== "string")
                 return "必须是时间字符串";
             if (!/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(value))
@@ -400,7 +402,7 @@ export class Validator {
         }
         // 类型默认值（字段未定义 default 时使用）
         const normalizedType = String(type || "").toLowerCase();
-        if (normalizedType === "datetime" || normalizedType === "json") {
+        if (normalizedType === "datetime" || normalizedType === "timestamp" || normalizedType === "json" || normalizedType === "enum") {
             return null;
         }
         const normalizedInput = String(input || "").toLowerCase();

package/dist/sync/syncTable.d.ts

@@ -69,7 +69,7 @@ export declare class SyncTable {
      * - 若未来需要支持更复杂的标识符（如关键字/点号/反引号转义），应在此处统一扩展并补测试
      */
     static quoteIdentifier(identifier: string): string;
-    static getSqlType(fieldType: string, fieldMax: number | null, unsigned?: boolean, precision?: number | null, scale?: number | null): string;
+    static getSqlType(fieldType: string, fieldMax: number | null, unsigned?: boolean, precision?: number | null, scale?: number | null, enumInput?: string | null): string;
     static resolveDefaultValue(fieldDefault: any, fieldType: string): any;
     static generateDefaultSql(actualDefault: any, fieldType: string): string;
     private static normalizeDefaultForCompare;

package/dist/sync/syncTable.js

@@ -8,6 +8,7 @@
  */
 import { Logger } from "../lib/logger";
 import { CoreError, isCoreError } from "../types/coreError";
+import { parseEnumRuleValues } from "../utils/dbFieldRules";
 import { normalizeFieldDefinition } from "../utils/normalizeFieldDefinition";
 import { escapeComment, normalizeColumnDefaultValue } from "../utils/sqlUtil";
 import { snakeCase } from "../utils/util";
@@ -73,7 +74,9 @@ export class SyncTable {
         double: "DOUBLE",
         char: "CHAR",
         varchar: "VARCHAR",
+        enum: "ENUM",
         datetime: "DATETIME",
+        timestamp: "TIMESTAMP",
         tinytext: "TINYTEXT",
         text: "MEDIUMTEXT",
         mediumtext: "MEDIUMTEXT",
@@ -330,9 +333,21 @@ export class SyncTable {
         }
         return `\`${trimmed}\``;
     }
-    static getSqlType(fieldType, fieldMax, unsigned = false, precision = null, scale = null) {
+    static getSqlType(fieldType, fieldMax, unsigned = false, precision = null, scale = null, enumInput = null) {
         const normalizedType = String(fieldType || "").toLowerCase();
         const typeMapping = SyncTable.TYPE_MAPPING;
+        if (normalizedType === "enum") {
+            const values = parseEnumRuleValues(String(enumInput || ""));
+            if (values.length === 0) {
+                throw new Error(`同步表：内部错误：enum 类型缺失 input 枚举值（应由 checkTable 阻断）`);
+            }
+            const quoted = [];
+            for (const v of values) {
+                const escaped = String(v).replace(/'/g, "''");
+                quoted.push(`'${escaped}'`);
+            }
+            return `${typeMapping[normalizedType]}(${quoted.join(",")})`;
+        }
         if (SyncTable.isStringOrArrayType(normalizedType)) {
             // 约束由 checkTable 统一保证；这里仅做最小断言，避免生成明显无效的 SQL。
             if (typeof fieldMax !== "number") {
@@ -371,9 +386,15 @@ export class SyncTable {
             case "char":
             case "varchar":
                 return "";
+            case "enum":
+                // enum：默认不自动生成 DEFAULT（由表定义/业务决定），用 "null" sentinel 表示不生成。
+                return "null";
             case "datetime":
                 // datetime 默认不生成 DEFAULT；用 "null" 作为 sentinel（与 TEXT 类似）
                 return "null";
+            case "timestamp":
+                // timestamp 默认不生成 DEFAULT；用 "null" 作为 sentinel（与 datetime 一致）
+                return "null";
             case "tinytext":
             case "text":
             case "mediumtext":
@@ -389,6 +410,10 @@ export class SyncTable {
         if (SyncTable.TEXT_FAMILY.has(normalizedType) || normalizedType === "json" || actualDefault === "null") {
             return "";
         }
+        if (normalizedType === "enum") {
+            const escaped = String(actualDefault).replace(/'/g, "''");
+            return ` DEFAULT '${escaped}'`;
+        }
         if (SyncTable.INT_TYPES.has(normalizedType) || SyncTable.DECIMAL_TYPES.has(normalizedType) || SyncTable.FLOAT_TYPES.has(normalizedType) || SyncTable.isStringOrArrayType(normalizedType)) {
             if (typeof actualDefault === "number" && !Number.isNaN(actualDefault)) {
                 return ` DEFAULT ${actualDefault}`;
@@ -398,8 +423,8 @@ export class SyncTable {
                 return ` DEFAULT '${escaped}'`;
             }
         }
-        if (normalizedType === "datetime") {
-            // datetime：默认值仅支持字符串（到秒）或 CURRENT_TIMESTAMP 表达式。
+        if (normalizedType === "datetime" || normalizedType === "timestamp") {
+            // datetime/timestamp：默认值仅支持字符串（到秒）或 CURRENT_TIMESTAMP 表达式。
             // 注意：checkTable 默认要求 default 为 null；这里仍做 DDL 生成兜底，便于测试/内部调用。
             if (typeof actualDefault === "string") {
                 const trimmed = actualDefault.trim();
@@ -500,7 +525,7 @@ export class SyncTable {
         const normalized = normalizeFieldDefinition(fieldDef);
         const dbFieldName = snakeCase(fieldKey);
         const colQuoted = SyncTable.quoteIdentifier(dbFieldName);
-        const sqlType = SyncTable.getSqlType(normalized.type, normalized.max, normalized.unsigned, normalized.precision, normalized.scale);
+        const sqlType = SyncTable.getSqlType(normalized.type, normalized.max, normalized.unsigned, normalized.precision, normalized.scale, normalized.input);
         const actualDefault = SyncTable.resolveDefaultValue(normalized.default, normalized.type);
         const defaultSql = SyncTable.generateDefaultSql(actualDefault, normalized.type);
         const uniqueSql = normalized.unique ? " UNIQUE" : "";
@@ -570,7 +595,8 @@ export class SyncTable {
                     // 统一由 run() 收集所有不兼容项后再一次性抛错。
                     const typeChange = comparison.find((c) => c.type === "datatype");
                     if (typeChange) {
-                        const expectedType = SyncTable.getSqlType(fieldDef.type, fieldDef.max ?? null, fieldDef.unsigned ?? false, fieldDef.precision ?? null, fieldDef.scale ?? null);
+                        const expectedNormalized = normalizeFieldDefinition(fieldDef);
+                        const expectedType = SyncTable.getSqlType(expectedNormalized.type, expectedNormalized.max, expectedNormalized.unsigned, expectedNormalized.precision, expectedNormalized.scale, expectedNormalized.input);
                         const incompatible = SyncTable.getIncompatibleTypeChange(options.tableName, dbFieldName, String(typeChange.current ?? ""), expectedType);
                         if (incompatible) {
                             incompatibleTypeChanges.push(incompatible);
@@ -657,7 +683,8 @@ export class SyncTable {
             const typeChange = comparison.find((c) => c.type === "datatype");
             if (!typeChange)
                 continue;
-            const expectedType = SyncTable.getSqlType(fieldDef.type, fieldDef.max ?? null, fieldDef.unsigned ?? false, fieldDef.precision ?? null, fieldDef.scale ?? null);
+            const expectedNormalized = normalizeFieldDefinition(fieldDef);
+            const expectedType = SyncTable.getSqlType(expectedNormalized.type, expectedNormalized.max, expectedNormalized.unsigned, expectedNormalized.precision, expectedNormalized.scale, expectedNormalized.input);
             const incompatible = SyncTable.getIncompatibleTypeChange(tableName, dbFieldName, String(typeChange.current ?? ""), expectedType);
             if (incompatible) {
                 out.push(incompatible);
@@ -847,7 +874,7 @@ export class SyncTable {
     static compareFieldDefinition(existingColumn, fieldDef) {
         const changes = [];
         const normalized = normalizeFieldDefinition(fieldDef);
-        const expectedType = SyncTable.getSqlType(normalized.type, normalized.max, normalized.unsigned, normalized.precision, normalized.scale).toLowerCase().replace(/\s+/g, " ").trim();
+        const expectedType = SyncTable.getSqlType(normalized.type, normalized.max, normalized.unsigned, normalized.precision, normalized.scale, normalized.input).toLowerCase().replace(/\s+/g, " ").trim();
         const currentType = (typeof existingColumn.columnType === "string" && existingColumn.columnType.trim() !== ""
             ? existingColumn.columnType
             : typeof existingColumn.type === "string" && existingColumn.type.trim() !== ""

package/dist/types/validate.d.ts

@@ -5,7 +5,7 @@ import type { JsonValue } from "./common";
 /**
  * 数据库字段类型
  */
-export type DbFieldType = "tinyint" | "smallint" | "mediumint" | "int" | "bigint" | "decimal" | "float" | "double" | "char" | "varchar" | "tinytext" | "text" | "mediumtext" | "longtext" | "datetime" | "json";
+export type DbFieldType = "tinyint" | "smallint" | "mediumint" | "int" | "bigint" | "decimal" | "float" | "double" | "char" | "varchar" | "enum" | "tinytext" | "text" | "mediumtext" | "longtext" | "datetime" | "timestamp" | "json";
 /**
  * 输入参数类型
  */

package/dist/utils/dbFieldRules.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 数据库字段规则（供 checkTable / normalizeFieldDefinition / validator / syncTable 复用）
+ *
+ * 目标：
+ * - 避免同一套规则在多个模块重复实现导致漂移
+ * - 保持简单直观，不引入过度抽象
+ */
+export declare function normalizeDbType(dbType: string): string;
+export declare function isStringDbType(dbType: string): boolean;
+export declare function isTextDbType(dbType: string): boolean;
+export declare function isIntDbType(dbType: string): boolean;
+export declare function isDecimalDbType(dbType: string): boolean;
+export declare function isFloatDbType(dbType: string): boolean;
+export declare function isJsonDbType(dbType: string): boolean;
+export declare function isEnumDbType(dbType: string): boolean;
+export declare function isNumericDbType(dbType: string): boolean;
+/**
+ * 根据数据库类型推导默认 input 类型。
+ */
+export declare function inferInputByDbType(dbType: string): string;
+/**
+ * 归一化 type 与 input，input 为空时使用推导值。
+ */
+export declare function normalizeTypeAndInput(type: string, input: string): {
+    type: string;
+    input: string;
+};
+/**
+ * 解析枚举规则（a|b|c）为去重后的值列表（保持顺序）。
+ */
+export declare function parseEnumRuleValues(enumInput: string): string[];

package/dist/utils/dbFieldRules.js

@@ -0,0 +1,94 @@
+/**
+ * 数据库字段规则（供 checkTable / normalizeFieldDefinition / validator / syncTable 复用）
+ *
+ * 目标：
+ * - 避免同一套规则在多个模块重复实现导致漂移
+ * - 保持简单直观，不引入过度抽象
+ */
+const STRING_DB_TYPES = new Set(["char", "varchar", "enum", "tinytext", "text", "mediumtext", "longtext"]);
+const TEXT_DB_TYPES = new Set(["tinytext", "text", "mediumtext", "longtext"]);
+const INT_DB_TYPES = new Set(["tinyint", "smallint", "mediumint", "int", "bigint"]);
+const DECIMAL_DB_TYPES = new Set(["decimal"]);
+const FLOAT_DB_TYPES = new Set(["float", "double"]);
+const JSON_DB_TYPES = new Set(["json"]);
+const ENUM_DB_TYPES = new Set(["enum"]);
+export function normalizeDbType(dbType) {
+    return String(dbType || "")
+        .trim()
+        .toLowerCase();
+}
+export function isStringDbType(dbType) {
+    return STRING_DB_TYPES.has(normalizeDbType(dbType));
+}
+export function isTextDbType(dbType) {
+    return TEXT_DB_TYPES.has(normalizeDbType(dbType));
+}
+export function isIntDbType(dbType) {
+    return INT_DB_TYPES.has(normalizeDbType(dbType));
+}
+export function isDecimalDbType(dbType) {
+    return DECIMAL_DB_TYPES.has(normalizeDbType(dbType));
+}
+export function isFloatDbType(dbType) {
+    return FLOAT_DB_TYPES.has(normalizeDbType(dbType));
+}
+export function isJsonDbType(dbType) {
+    return JSON_DB_TYPES.has(normalizeDbType(dbType));
+}
+export function isEnumDbType(dbType) {
+    return ENUM_DB_TYPES.has(normalizeDbType(dbType));
+}
+export function isNumericDbType(dbType) {
+    const normalized = normalizeDbType(dbType);
+    return INT_DB_TYPES.has(normalized) || DECIMAL_DB_TYPES.has(normalized) || FLOAT_DB_TYPES.has(normalized);
+}
+/**
+ * 根据数据库类型推导默认 input 类型。
+ */
+export function inferInputByDbType(dbType) {
+    const normalized = normalizeDbType(dbType);
+    if (INT_DB_TYPES.has(normalized)) {
+        return "integer";
+    }
+    if (DECIMAL_DB_TYPES.has(normalized) || FLOAT_DB_TYPES.has(normalized)) {
+        return "number";
+    }
+    if (STRING_DB_TYPES.has(normalized) || normalized === "datetime" || normalized === "timestamp") {
+        return "string";
+    }
+    if (normalized === "json") {
+        return "json";
+    }
+    return "string";
+}
+/**
+ * 归一化 type 与 input，input 为空时使用推导值。
+ */
+export function normalizeTypeAndInput(type, input) {
+    const rawType = String(type || "").trim();
+    const rawInput = String(input || "").trim();
+    return {
+        type: rawType,
+        input: rawInput || inferInputByDbType(rawType)
+    };
+}
+/**
+ * 解析枚举规则（a|b|c）为去重后的值列表（保持顺序）。
+ */
+export function parseEnumRuleValues(enumInput) {
+    const raw = String(enumInput || "").trim();
+    if (raw === "") {
+        return [];
+    }
+    const parts = raw
+        .split("|")
+        .map((x) => x.trim())
+        .filter((x) => x !== "");
+    const out = [];
+    for (const p of parts) {
+        if (!out.includes(p)) {
+            out.push(p);
+        }
+    }
+    return out;
+}

package/dist/utils/normalizeFieldDefinition.js

@@ -1,38 +1,8 @@
-function inferInputByType(dbType) {
-    switch (dbType.toLowerCase()) {
-        case "tinyint":
-        case "smallint":
-        case "mediumint":
-        case "int":
-        case "bigint":
-            return "integer";
-        case "decimal":
-        case "float":
-        case "double":
-            return "number";
-        case "char":
-        case "varchar":
-        case "tinytext":
-        case "text":
-        case "mediumtext":
-        case "longtext":
-            return "string";
-        case "datetime":
-            return "string";
-        case "json":
-            return "json";
-        default:
-            return "string";
-    }
-}
-function normalizeTypeAndInput(fieldDef) {
+import { normalizeTypeAndInput } from "./dbFieldRules";
+export function normalizeFieldDefinition(fieldDef) {
     const rawType = String(fieldDef.type ?? "").trim();
     const rawInput = typeof fieldDef.input === "string" ? fieldDef.input.trim() : "";
-    const inferredInput = rawInput || inferInputByType(rawType);
-    return { type: rawType, input: inferredInput };
-}
-export function normalizeFieldDefinition(fieldDef) {
-    const typeAndInput = normalizeTypeAndInput(fieldDef);
+    const typeAndInput = normalizeTypeAndInput(rawType, rawInput);
     let normalizedDefault = fieldDef.default ?? null;
     if (normalizedDefault === null) {
         if (typeAndInput.input === "array" || typeAndInput.input === "array_number" || typeAndInput.input === "array_integer") {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "befly",
-    "version": "3.15.27",
-    "gitHead": "de207dd938013c1c5a13cff065439762162596b2",
+    "version": "3.16.1",
+    "gitHead": "effac3f749af5f1395048a1ed528eac7e55eaed5",
     "private": false,
     "description": "Befly - 为 Bun 专属打造的 TypeScript API 接口框架核心引擎",
     "keywords": [