befly 3.15.27 → 3.16.0

package/dist/befly.js

@@ -8555,48 +8555,90 @@ async function checkPlugin(plugins) {
 
 // checks/checkTable.ts
 init_logger();
-init_util();
-var RESERVED_FIELDS = ["id", "created_at", "updated_at", "deleted_at", "state"];
-var RESERVED_FIELD_SET = new Set(RESERVED_FIELDS);
-var FIELD_TYPES = ["tinyint", "smallint", "mediumint", "int", "bigint", "decimal", "float", "double", "char", "varchar", "tinytext", "text", "mediumtext", "longtext", "datetime", "json"];
-var FIELD_TYPE_SET = new Set(FIELD_TYPES);
-var INPUT_TYPES = ["number", "integer", "string", "char", "array", "array_number", "array_integer", "json", "json_number", "json_integer"];
-var INPUT_TYPE_SET = new Set(INPUT_TYPES);
-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";
+
+// utils/dbFieldRules.ts
+var STRING_DB_TYPES = new Set(["char", "varchar", "enum", "tinytext", "text", "mediumtext", "longtext"]);
+var TEXT_DB_TYPES = new Set(["tinytext", "text", "mediumtext", "longtext"]);
+var INT_DB_TYPES = new Set(["tinyint", "smallint", "mediumint", "int", "bigint"]);
+var DECIMAL_DB_TYPES = new Set(["decimal"]);
+var FLOAT_DB_TYPES = new Set(["float", "double"]);
+var JSON_DB_TYPES = new Set(["json"]);
+var ENUM_DB_TYPES = new Set(["enum"]);
+function normalizeDbType(dbType) {
+  return String(dbType || "").trim().toLowerCase();
+}
+function isStringDbType(dbType) {
+  return STRING_DB_TYPES.has(normalizeDbType(dbType));
+}
+function isTextDbType(dbType) {
+  return TEXT_DB_TYPES.has(normalizeDbType(dbType));
+}
+function isIntDbType(dbType) {
+  return INT_DB_TYPES.has(normalizeDbType(dbType));
+}
+function isDecimalDbType(dbType) {
+  return DECIMAL_DB_TYPES.has(normalizeDbType(dbType));
+}
+function isFloatDbType(dbType) {
+  return FLOAT_DB_TYPES.has(normalizeDbType(dbType));
+}
+function isJsonDbType(dbType) {
+  return JSON_DB_TYPES.has(normalizeDbType(dbType));
+}
+function isEnumDbType(dbType) {
+  return ENUM_DB_TYPES.has(normalizeDbType(dbType));
+}
+function isNumericDbType(dbType) {
+  const normalized = normalizeDbType(dbType);
+  return INT_DB_TYPES.has(normalized) || DECIMAL_DB_TYPES.has(normalized) || FLOAT_DB_TYPES.has(normalized);
+}
+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") {
+    return "string";
   }
+  if (normalized === "json") {
+    return "json";
+  }
+  return "string";
 }
 function normalizeTypeAndInput(type, input) {
   const rawType = String(type || "").trim();
   const rawInput = String(input || "").trim();
   return {
     type: rawType,
-    input: rawInput || inferInputByType(rawType)
+    input: rawInput || inferInputByDbType(rawType)
   };
 }
+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;
+}
+
+// checks/checkTable.ts
+init_util();
+var RESERVED_FIELDS = ["id", "created_at", "updated_at", "deleted_at", "state"];
+var RESERVED_FIELD_SET = new Set(RESERVED_FIELDS);
+var FIELD_TYPES = ["tinyint", "smallint", "mediumint", "int", "bigint", "decimal", "float", "double", "char", "varchar", "enum", "tinytext", "text", "mediumtext", "longtext", "datetime", "json"];
+var FIELD_TYPE_SET = new Set(FIELD_TYPES);
+var INPUT_TYPES = ["number", "integer", "string", "char", "array", "array_number", "array_integer", "json", "json_number", "json_integer"];
+var INPUT_TYPE_SET = new Set(INPUT_TYPES);
 var ALLOWED_FIELD_PROPERTIES = ["name", "type", "input", "min", "max", "default", "detail", "precision", "scale", "index", "unique", "nullable", "unsigned"];
 var ALLOWED_FIELD_PROPERTY_SET = new Set(ALLOWED_FIELD_PROPERTIES);
 var LOWER_CAMEL_CASE_REGEX = /^_?[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/;
@@ -8723,42 +8765,52 @@ async function checkTable(tables, config2) {
           Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u5B57\u6BB5 input "${normalizedInput}" \u4E0D\u5408\u6CD5\uFF0C` + `\u5FC5\u987B\u4E3A${INPUT_TYPES.join("\u3001")}\u4E4B\u4E00\uFF0C\u6216\u6B63\u5219/\u679A\u4E3E/\u6B63\u5219\u522B\u540D`);
           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 isDecimalDbType2 = isDecimalDbType(effectiveType);
+        const isFloatDbType2 = isFloatDbType(effectiveType);
+        const isJsonDbType2 = isJsonDbType(effectiveType);
+        const isEnumDbType2 = isEnumDbType(effectiveType);
+        const isNumericDbType2 = isNumericDbType(effectiveType);
+        const isStringDbTypeNormalized = isStringDbType(effectiveType);
+        const isTextDbTypeNormalized = isTextDbType(effectiveType);
+        const isIntDbTypeNormalized = isIntDbType(effectiveType);
+        if (isEnumDbType2) {
+          if (normalizedInput.trim() === "") {
+            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A enum \u7C7B\u578B\uFF0C\u5FC5\u987B\u8BBE\u7F6E input \u679A\u4E3E\u89C4\u5219\uFF08\u4F8B\u5982 a|b|c\uFF09`);
+            hasError = true;
+          } else if (!isEnumInput(normalizedInput)) {
+            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A enum \u7C7B\u578B\uFF0Cinput \u5FC5\u987B\u4E3A\u679A\u4E3E\u89C4\u5219\uFF08\u4F8B\u5982 a|b|c\uFF09\uFF0C\u5F53\u524D\u4E3A ${formatValuePreview(normalizedInput)}`);
+            hasError = true;
+          }
+        }
         if (isRegexInput(normalizedInput) || isEnumInput(normalizedInput) || isAliasInput(normalizedInput)) {
-          if (!isStringDbType) {
-            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u5B57\u6BB5 input \u4F7F\u7528\u6B63\u5219/\u679A\u4E3E/\u6B63\u5219\u522B\u540D\uFF0C\u4EC5\u5141\u8BB8\u5B57\u7B26\u4E32\u7C7B\u5B57\u6BB5\uFF08char/varchar/text\uFF09`);
+          if (!isStringDbTypeNormalized) {
+            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u5B57\u6BB5 input \u4F7F\u7528\u6B63\u5219/\u679A\u4E3E/\u6B63\u5219\u522B\u540D\uFF0C\u4EC5\u5141\u8BB8\u5B57\u7B26\u4E32\u7C7B\u5B57\u6BB5\uFF08char/varchar/enum/text\uFF09`);
             hasError = true;
           }
         }
         if (normalizedInput === "number" || normalizedInput === "integer") {
-          if (normalizedInput === "integer" && !isIntDbType) {
+          if (normalizedInput === "integer" && !isIntDbTypeNormalized) {
             Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u5B57\u6BB5 input=${normalizedInput} \u4EC5\u5141\u8BB8\u6574\u6570\u7C7B\u5B57\u6BB5\uFF08tinyint/smallint/mediumint/int/bigint\uFF09`);
             hasError = true;
           }
-          if (normalizedInput === "number" && !isNumericDbType) {
+          if (normalizedInput === "number" && !isNumericDbType2) {
             Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u5B57\u6BB5 input=${normalizedInput} \u4EC5\u5141\u8BB8\u6570\u503C\u7C7B\u5B57\u6BB5\uFF08tinyint/smallint/mediumint/int/bigint/decimal\uFF09`);
             hasError = true;
           }
         }
         if (normalizedInput === "array" || normalizedInput === "array_number" || normalizedInput === "array_integer") {
-          if (!isStringDbType) {
+          if (!isStringDbTypeNormalized) {
             Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u5B57\u6BB5 input=${normalizedInput} \u4EC5\u5141\u8BB8\u5B57\u7B26\u4E32\u7C7B\u5B57\u6BB5\uFF08char/varchar/text\uFF09`);
             hasError = true;
           }
         }
         if (normalizedInput === "json" || normalizedInput === "json_number" || normalizedInput === "json_integer") {
-          if (!(isJsonDbType || isTextDbType)) {
+          if (!(isJsonDbType2 || isTextDbTypeNormalized)) {
             Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u5B57\u6BB5 input=${normalizedInput} \u4EC5\u5141\u8BB8 json \u6216 text \u7C7B\u5B57\u6BB5`);
             hasError = true;
           }
         }
-        if (!isNumericDbType && field.unsigned !== undefined) {
+        if (!isNumericDbType2 && field.unsigned !== undefined) {
           Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u5B57\u6BB5\u7C7B\u578B\u4E3A ${effectiveType}\uFF0C\u4E0D\u5141\u8BB8\u8BBE\u7F6E unsigned\uFF08\u4EC5\u6570\u503C\u7C7B\u578B\u6709\u6548\uFF09`);
           hasError = true;
         }
@@ -8772,7 +8824,7 @@ async function checkTable(tables, config2) {
             hasError = true;
           }
         }
-        if (isTextDbType || isJsonDbType) {
+        if (isTextDbTypeNormalized || isJsonDbType2) {
           if (field.min !== undefined && field.min !== null) {
             Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u7684 ${effectiveType} \u7C7B\u578B\u6700\u5C0F\u503C\u5E94\u4E3A null\uFF0C\u5F53\u524D\u4E3A "${field.min}"`);
             hasError = true;
@@ -8810,7 +8862,41 @@ async function checkTable(tables, config2) {
             Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A datetime \u7C7B\u578B\uFF0C\u4E0D\u5141\u8BB8\u8BBE\u7F6E unsigned`);
             hasError = true;
           }
-        } else if (isDecimalDbType) {
+        } else if (effectiveType === "enum") {
+          if (field.min !== undefined && field.min !== null) {
+            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A enum \u7C7B\u578B\uFF0Cmin \u5FC5\u987B\u4E3A null\uFF0C\u5F53\u524D\u4E3A "${field.min}"`);
+            hasError = true;
+          }
+          if (field.max !== undefined && field.max !== null) {
+            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A enum \u7C7B\u578B\uFF0Cmax \u5FC5\u987B\u4E3A null\uFF0C\u5F53\u524D\u4E3A "${field.max}"`);
+            hasError = true;
+          }
+          if (field.precision !== undefined && field.precision !== null) {
+            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A enum \u7C7B\u578B\uFF0C\u4E0D\u5141\u8BB8\u8BBE\u7F6E precision`);
+            hasError = true;
+          }
+          if (field.scale !== undefined && field.scale !== null) {
+            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A enum \u7C7B\u578B\uFF0C\u4E0D\u5141\u8BB8\u8BBE\u7F6E scale`);
+            hasError = true;
+          }
+          if (field.unsigned !== undefined) {
+            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A enum \u7C7B\u578B\uFF0C\u4E0D\u5141\u8BB8\u8BBE\u7F6E unsigned`);
+            hasError = true;
+          }
+          const enumValues = parseEnumRuleValues(normalizedInput);
+          if (field.default === undefined || field.default === null) {
+            if (field.nullable !== true) {
+              Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A enum \u7C7B\u578B\uFF0Cnullable!=true \u65F6\u5FC5\u987B\u8BBE\u7F6E default\uFF08\u4E14 default \u5FC5\u987B\u4E3A\u679A\u4E3E\u503C\u4E4B\u4E00\uFF09`);
+              hasError = true;
+            }
+          } else if (typeof field.default !== "string") {
+            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A enum \u7C7B\u578B\uFF0C\u9ED8\u8BA4\u503C\u5FC5\u987B\u4E3A\u5B57\u7B26\u4E32\u6216 null` + `\uFF08typeof=${typeof field.default}\uFF0Cvalue=${formatValuePreview(field.default)}\uFF09`);
+            hasError = true;
+          } else if (!enumValues.includes(field.default)) {
+            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A enum \u7C7B\u578B\uFF0C\u9ED8\u8BA4\u503C\u4E0D\u5728\u679A\u4E3E\u8303\u56F4\u5185\uFF08default=${formatValuePreview(field.default)}\uFF0Cenums=${formatValuePreview(normalizedInput)}\uFF09`);
+            hasError = true;
+          }
+        } else if (isDecimalDbType2) {
           const precision = field.precision;
           const scale = field.scale;
           if (typeof precision !== "number") {
@@ -8860,12 +8946,12 @@ async function checkTable(tables, config2) {
             Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A ${effectiveType} \u7C7B\u578B\uFF0C\u9ED8\u8BA4\u503C\u5FC5\u987B\u4E3A\u5B57\u7B26\u4E32\u6216 null` + `\uFF08typeof=${typeof field.default}\uFF0Cvalue=${formatValuePreview(field.default)}\uFF09`);
             hasError = true;
           }
-        } else if (isIntDbType) {
+        } else if (isIntDbTypeNormalized) {
           if (field.default !== undefined && field.default !== null && typeof field.default !== "number") {
             Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A ${effectiveType} \u7C7B\u578B\uFF0C\u9ED8\u8BA4\u503C\u5FC5\u987B\u4E3A\u6570\u5B57\u6216 null` + `\uFF08typeof=${typeof field.default}\uFF0Cvalue=${formatValuePreview(field.default)}\uFF09`);
             hasError = true;
           }
-        } else if (isFloatDbType) {
+        } else if (isFloatDbType2) {
           if (field.default !== undefined && field.default !== null && typeof field.default !== "number") {
             Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A ${effectiveType} \u7C7B\u578B\uFF0C\u9ED8\u8BA4\u503C\u5FC5\u987B\u4E3A\u6570\u5B57\u6216 null` + `\uFF08typeof=${typeof field.default}\uFF0Cvalue=${formatValuePreview(field.default)}\uFF09`);
             hasError = true;
@@ -10337,41 +10423,10 @@ async function syncMenu(ctx, mergedMenus) {
 init_logger();
 
 // utils/normalizeFieldDefinition.ts
-function inferInputByType2(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 normalizeTypeAndInput2(fieldDef) {
+function normalizeFieldDefinition(fieldDef) {
   const rawType = String(fieldDef.type ?? "").trim();
   const rawInput = typeof fieldDef.input === "string" ? fieldDef.input.trim() : "";
-  const inferredInput = rawInput || inferInputByType2(rawType);
-  return { type: rawType, input: inferredInput };
-}
-function normalizeFieldDefinition(fieldDef) {
-  const typeAndInput = normalizeTypeAndInput2(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") {
@@ -10549,6 +10604,7 @@ class SyncTable {
     double: "DOUBLE",
     char: "CHAR",
     varchar: "VARCHAR",
+    enum: "ENUM",
     datetime: "DATETIME",
     tinytext: "TINYTEXT",
     text: "MEDIUMTEXT",
@@ -10767,9 +10823,21 @@ 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(`\u540C\u6B65\u8868\uFF1A\u5185\u90E8\u9519\u8BEF\uFF1Aenum \u7C7B\u578B\u7F3A\u5931 input \u679A\u4E3E\u503C\uFF08\u5E94\u7531 checkTable \u963B\u65AD\uFF09`);
+      }
+      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)) {
       if (typeof fieldMax !== "number") {
         throw new Error(`\u540C\u6B65\u8868\uFF1A\u5185\u90E8\u9519\u8BEF\uFF1A${normalizedType} \u7C7B\u578B\u7F3A\u5931 max\uFF08\u5E94\u7531 checkTable \u963B\u65AD\uFF09`);
@@ -10807,6 +10875,8 @@ class SyncTable {
       case "char":
       case "varchar":
         return "";
+      case "enum":
+        return "null";
       case "datetime":
         return "null";
       case "tinytext":
@@ -10824,6 +10894,10 @@ 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}`;
@@ -10928,7 +11002,7 @@ 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" : "";
@@ -10996,7 +11070,8 @@ class SyncTable {
           changeDetails.push({ fieldKey, dbFieldName, changes: comparison });
           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);
@@ -11071,7 +11146,8 @@ 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);
@@ -11225,7 +11301,7 @@ SQL: ${sqlLine}
   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() !== "" ? SyncTable.isStringOrArrayType(normalized.type) && typeof existingColumn.max === "number" ? `${existingColumn.type.trim()}(${existingColumn.max})` : existingColumn.type.trim() : String(existingColumn.type ?? "")).toLowerCase().replace(/\s+/g, " ").trim();
     const currentBase = currentType.replace(/\s*unsigned/gi, "").replace(/\([^)]*\)/g, "").trim();
     const normalizedCurrentType = SyncTable.INT_TYPES.has(currentBase) ? currentType.replace(/\([^)]*\)/g, "").replace(/\s+/g, " ").trim() : currentType;
@@ -13461,7 +13537,7 @@ class Validator {
           return "\u683C\u5F0F\u4E0D\u6B63\u786E";
       }
       if (isEnum) {
-        const enums = inputRaw.split("|").map((item) => item.trim()).filter((item) => item !== "");
+        const enums = parseEnumRuleValues(inputRaw);
         if (!enums.includes(value))
           return "\u503C\u4E0D\u5728\u679A\u4E3E\u8303\u56F4\u5185";
       }
@@ -13545,7 +13621,7 @@ class Validator {
       return defaultValue;
     }
     const normalizedType = String(type || "").toLowerCase();
-    if (normalizedType === "datetime" || normalizedType === "json") {
+    if (normalizedType === "datetime" || normalizedType === "json" || normalizedType === "enum") {
       return null;
     }
     const normalizedInput = String(input || "").toLowerCase();