befly 3.15.17 → 3.15.19

package/dist/befly.js

@@ -49,6 +49,84 @@ function isPlainObject(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
 }
+function isJsonPrimitive(value) {
+  if (value === null) {
+    return true;
+  }
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isJsonObject(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (value instanceof Date) {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return false;
+  }
+  return true;
+}
+function isJsonStructure(value) {
+  return Array.isArray(value) || isJsonObject(value);
+}
+function isJsonValue(value) {
+  if (isJsonPrimitive(value)) {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      if (!isJsonValue(item)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (isJsonObject(value)) {
+    for (const v of Object.values(value)) {
+      if (v === undefined) {
+        continue;
+      }
+      if (!isJsonValue(v)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isIntegerNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value);
+}
+function formatValuePreview(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (value === undefined) {
+    return "undefined";
+  }
+  if (typeof value === "string") {
+    const s2 = value.length > 80 ? `${value.slice(0, 80)}...` : value;
+    return JSON.stringify(s2);
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (typeof value === "function") {
+    return "[Function]";
+  }
+  try {
+    const s2 = JSON.stringify(value);
+    if (typeof s2 === "string") {
+      return s2.length > 120 ? `${s2.slice(0, 120)}...` : s2;
+    }
+  } catch {}
+  const s = String(value);
+  return s.length > 120 ? `${s.slice(0, 120)}...` : s;
+}
 function getTypeTag(value) {
   if (value === null)
     return "null";
@@ -71,6 +149,38 @@ function getTypeTag(value) {
     return "function";
   return "object";
 }
+function isRegexLiteral(input) {
+  const trimmed = String(input || "").trim();
+  if (trimmed.length < 2) {
+    return false;
+  }
+  if (!trimmed.startsWith("/")) {
+    return false;
+  }
+  const lastSlash = trimmed.lastIndexOf("/");
+  if (lastSlash <= 0) {
+    return false;
+  }
+  const flags = trimmed.slice(lastSlash + 1);
+  if (flags !== "" && !/^[gimsuy]+$/.test(flags)) {
+    return false;
+  }
+  return true;
+}
+function isRegexInput(input) {
+  const trimmed = String(input || "").trim();
+  return isRegexLiteral(trimmed) || trimmed.startsWith("@");
+}
+function isEnumInput(input) {
+  const trimmed = String(input || "").trim();
+  if (trimmed.length === 0) {
+    return false;
+  }
+  return !trimmed.startsWith("/") && trimmed.includes("|");
+}
+function isAliasInput(input) {
+  return String(input || "").trim().startsWith("@");
+}
 function normalizePositiveInt(value, fallback, min, max) {
   if (typeof value !== "number")
     return fallback;
@@ -8181,79 +8291,13 @@ async function checkPlugin(plugins) {
 
 // checks/checkTable.ts
 init_logger();
-function isJsonPrimitive(value) {
-  if (value === null)
-    return true;
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-}
-function isJsonObject(value) {
-  if (!value || typeof value !== "object")
-    return false;
-  if (value instanceof Date)
-    return false;
-  if (Array.isArray(value))
-    return false;
-  return true;
-}
-function isJsonValue(value) {
-  if (isJsonPrimitive(value))
-    return true;
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      if (!isJsonValue(item))
-        return false;
-    }
-    return true;
-  }
-  if (isJsonObject(value)) {
-    for (const v of Object.values(value)) {
-      if (v === undefined)
-        continue;
-      if (!isJsonValue(v))
-        return false;
-    }
-    return true;
-  }
-  return false;
-}
-function formatValuePreview(value) {
-  if (value === null)
-    return "null";
-  if (value === undefined)
-    return "undefined";
-  if (typeof value === "string") {
-    const s2 = value.length > 80 ? `${value.slice(0, 80)}...` : value;
-    return JSON.stringify(s2);
-  }
-  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-    return String(value);
-  }
-  if (typeof value === "function") {
-    return "[Function]";
-  }
-  try {
-    const s2 = JSON.stringify(value);
-    if (typeof s2 === "string") {
-      return s2.length > 120 ? `${s2.slice(0, 120)}...` : s2;
-    }
-  } catch {}
-  const s = String(value);
-  return s.length > 120 ? `${s.slice(0, 120)}...` : s;
-}
+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", "char", "varchar", "tinytext", "text", "mediumtext", "longtext", "datetime", "json"];
+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 isRegexInput(input) {
-  if (input.startsWith("@"))
-    return true;
-  return /[\\^$.*+?()[\]{}]/.test(input);
-}
-function isEnumInput(input) {
-  return input.includes("|") && !isRegexInput(input);
-}
 function inferInputByType(dbType) {
   switch (dbType.toLowerCase()) {
     case "tinyint":
@@ -8262,6 +8306,10 @@ function inferInputByType(dbType) {
     case "int":
     case "bigint":
       return "integer";
+    case "decimal":
+    case "float":
+    case "double":
+      return "number";
     case "char":
     case "varchar":
     case "tinytext":
@@ -8285,7 +8333,7 @@ function normalizeTypeAndInput(type, input) {
     input: rawInput || inferInputByType(rawType)
   };
 }
-var ALLOWED_FIELD_PROPERTIES = ["name", "type", "input", "min", "max", "default", "detail", "index", "unique", "nullable", "unsigned"];
+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]*)*$/;
 var FIELD_NAME_REGEX = /^[\u4e00-\u9fa5a-zA-Z0-9 _-]+$/;
@@ -8324,8 +8372,9 @@ async function checkTable(tables, config2) {
           hasError = true;
           continue;
         }
-        if (RESERVED_FIELD_SET.has(colKey)) {
-          Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6\u5305\u542B\u4FDD\u7559\u5B57\u6BB5 ${colKey}\uFF0C` + `\u4E0D\u80FD\u5728\u8868\u5B9A\u4E49\u4E2D\u4F7F\u7528\u4EE5\u4E0B\u5B57\u6BB5: ${RESERVED_FIELDS.join(", ")}`);
+        const dbFieldName = snakeCase(colKey);
+        if (RESERVED_FIELD_SET.has(colKey) || RESERVED_FIELD_SET.has(dbFieldName)) {
+          Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6\u5305\u542B\u4FDD\u7559\u5B57\u6BB5 ${colKey}\uFF08\u6620\u5C04\u5217\u540D: ${dbFieldName}\uFF09\uFF0C` + `\u4E0D\u80FD\u5728\u8868\u5B9A\u4E49\u4E2D\u4F7F\u7528\u4EE5\u4E0B\u5B57\u6BB5: ${RESERVED_FIELDS.join(", ")}`);
           hasError = true;
         }
         const field = fieldDef;
@@ -8361,6 +8410,14 @@ async function checkTable(tables, config2) {
           Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u5B57\u6BB5 detail \u7C7B\u578B\u9519\u8BEF\uFF0C\u5FC5\u987B\u4E3A\u5B57\u7B26\u4E32`);
           hasError = true;
         }
+        if (field.precision !== undefined && !(field.precision === null || typeof field.precision === "number")) {
+          Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u5B57\u6BB5 precision \u7C7B\u578B\u9519\u8BEF\uFF0C\u5FC5\u987B\u4E3A null \u6216\u6570\u5B57`);
+          hasError = true;
+        }
+        if (field.scale !== undefined && !(field.scale === null || typeof field.scale === "number")) {
+          Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u5B57\u6BB5 scale \u7C7B\u578B\u9519\u8BEF\uFF0C\u5FC5\u987B\u4E3A null \u6216\u6570\u5B57`);
+          hasError = true;
+        }
         if (field.index !== undefined && typeof field.index !== "boolean") {
           Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u5B57\u6BB5 index \u7C7B\u578B\u9519\u8BEF\uFF0C\u5FC5\u987B\u4E3A\u5E03\u5C14\u503C`);
           hasError = true;
@@ -8398,25 +8455,32 @@ async function checkTable(tables, config2) {
         if (normalizedInput === "") {
           Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u5B57\u6BB5 input \u65E0\u6CD5\u63A8\u5BFC`);
           hasError = true;
-        } else if (!INPUT_TYPE_SET.has(normalizedInput) && !isRegexInput(normalizedInput) && !isEnumInput(normalizedInput)) {
-          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`);
+        } else if (!INPUT_TYPE_SET.has(normalizedInput) && !isRegexInput(normalizedInput) && !isEnumInput(normalizedInput) && !isAliasInput(normalizedInput)) {
+          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";
-        if (isRegexInput(normalizedInput) || isEnumInput(normalizedInput)) {
+        const isNumericDbType = isIntDbType || isDecimalDbType || isFloatDbType;
+        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\uFF0C\u4EC5\u5141\u8BB8\u5B57\u7B26\u4E32\u7C7B\u5B57\u6BB5\uFF08char/varchar/text\uFF09`);
+            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`);
             hasError = true;
           }
         }
         if (normalizedInput === "number" || normalizedInput === "integer") {
-          if (!isIntDbType) {
+          if (normalizedInput === "integer" && !isIntDbType) {
             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) {
+            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) {
@@ -8430,8 +8494,8 @@ async function checkTable(tables, config2) {
             hasError = true;
           }
         }
-        if (!isIntDbType && 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\u6574\u6570\u7C7B\u578B\u6709\u6548\uFF09`);
+        if (!isNumericDbType && 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;
         }
         if (field.unique === true && field.index === true) {
@@ -8482,6 +8546,31 @@ 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) {
+          const precision = field.precision;
+          const scale = field.scale;
+          if (typeof precision !== "number") {
+            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A decimal \u7C7B\u578B\uFF0C\u5FC5\u987B\u8BBE\u7F6E precision\uFF08\u603B\u4F4D\u6570\uFF09`);
+            hasError = true;
+          } else if (precision < 1 || precision > 65) {
+            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A decimal \u7C7B\u578B\uFF0Cprecision \u5FC5\u987B\u5728 1..65 \u8303\u56F4\u5185\uFF0C\u5F53\u524D\u4E3A ${precision}`);
+            hasError = true;
+          }
+          if (typeof scale !== "number") {
+            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A decimal \u7C7B\u578B\uFF0C\u5FC5\u987B\u8BBE\u7F6E scale\uFF08\u5C0F\u6570\u4F4D\u6570\uFF09`);
+            hasError = true;
+          } else if (scale < 0 || scale > 30) {
+            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A decimal \u7C7B\u578B\uFF0Cscale \u5FC5\u987B\u5728 0..30 \u8303\u56F4\u5185\uFF0C\u5F53\u524D\u4E3A ${scale}`);
+            hasError = true;
+          }
+          if (typeof precision === "number" && typeof scale === "number" && scale > precision) {
+            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A decimal \u7C7B\u578B\uFF0Cscale \u4E0D\u80FD\u5927\u4E8E precision\uFF08precision=${precision}, scale=${scale}\uFF09`);
+            hasError = true;
+          }
+          if (field.default !== undefined && field.default !== null && typeof field.default !== "number") {
+            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A decimal \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 (effectiveType === "char" || effectiveType === "varchar") {
           if (field.max === undefined || field.max === null || typeof field.max !== "number") {
             Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A ${effectiveType} \u7C7B\u578B\uFF0C` + `\u5FC5\u987B\u8BBE\u7F6E max \u4E14\u7C7B\u578B\u4E3A\u6570\u5B57\uFF0C\u5F53\u524D\u4E3A "${field.max}"`);
@@ -8512,6 +8601,11 @@ async function checkTable(tables, config2) {
             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) {
+          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;
+          }
         }
       }
     } catch (error) {
@@ -9900,6 +9994,10 @@ function inferInputByType2(dbType) {
     case "int":
     case "bigint":
       return "integer";
+    case "decimal":
+    case "float":
+    case "double":
+      return "number";
     case "char":
     case "varchar":
     case "tinytext":
@@ -9936,6 +10034,8 @@ function normalizeFieldDefinition(fieldDef) {
     detail: fieldDef.detail ?? "",
     min: fieldDef.min ?? null,
     max: fieldDef.max ?? null,
+    precision: fieldDef.precision ?? null,
+    scale: fieldDef.scale ?? null,
     default: normalizedDefault,
     index: fieldDef.index ?? false,
     unique: fieldDef.unique ?? false,
@@ -10093,6 +10193,9 @@ class SyncTable {
     mediumint: "MEDIUMINT",
     int: "INT",
     bigint: "BIGINT",
+    decimal: "DECIMAL",
+    float: "FLOAT",
+    double: "DOUBLE",
     char: "CHAR",
     varchar: "VARCHAR",
     datetime: "DATETIME",
@@ -10104,6 +10207,8 @@ class SyncTable {
   };
   static TEXT_FAMILY = new Set(["tinytext", "text", "mediumtext", "longtext"]);
   static INT_TYPES = new Set(["tinyint", "smallint", "mediumint", "int", "bigint"]);
+  static DECIMAL_TYPES = new Set(["decimal"]);
+  static FLOAT_TYPES = new Set(["float", "double"]);
   db;
   dbName;
   constructor(ctx) {
@@ -10187,6 +10292,8 @@ class SyncTable {
     fieldDef.detail = normalized.detail;
     fieldDef.min = normalized.min;
     fieldDef.max = normalized.max;
+    fieldDef.precision = normalized.precision;
+    fieldDef.scale = normalized.scale;
     fieldDef.default = normalized.default;
     fieldDef.index = normalized.index;
     fieldDef.unique = normalized.unique;
@@ -10207,7 +10314,7 @@ class SyncTable {
     }
     return `\`${trimmed}\``;
   }
-  static getSqlType(fieldType, fieldMax, unsigned = false) {
+  static getSqlType(fieldType, fieldMax, unsigned = false, precision = null, scale = null) {
     const normalizedType = String(fieldType || "").toLowerCase();
     const typeMapping = SyncTable.TYPE_MAPPING;
     if (SyncTable.isStringOrArrayType(normalizedType)) {
@@ -10216,8 +10323,15 @@ class SyncTable {
       }
       return `${typeMapping[normalizedType]}(${fieldMax})`;
     }
+    if (SyncTable.DECIMAL_TYPES.has(normalizedType)) {
+      if (typeof precision !== "number" || typeof scale !== "number") {
+        throw new Error(`\u540C\u6B65\u8868\uFF1A\u5185\u90E8\u9519\u8BEF\uFF1Adecimal \u7C7B\u578B\u7F3A\u5931 precision/scale\uFF08\u5E94\u7531 checkTable \u963B\u65AD\uFF09`);
+      }
+      const base = `${typeMapping[normalizedType]}(${precision},${scale})`;
+      return unsigned ? `${base} UNSIGNED` : base;
+    }
     const baseType = typeMapping[normalizedType] || "TEXT";
-    if (SyncTable.INT_TYPES.has(normalizedType) && unsigned) {
+    if ((SyncTable.INT_TYPES.has(normalizedType) || SyncTable.FLOAT_TYPES.has(normalizedType)) && unsigned) {
       return `${baseType} UNSIGNED`;
     }
     return baseType;
@@ -10233,6 +10347,9 @@ class SyncTable {
       case "mediumint":
       case "int":
       case "bigint":
+      case "decimal":
+      case "float":
+      case "double":
         return 0;
       case "char":
       case "varchar":
@@ -10254,7 +10371,7 @@ class SyncTable {
     if (SyncTable.TEXT_FAMILY.has(normalizedType) || normalizedType === "json" || actualDefault === "null") {
       return "";
     }
-    if (SyncTable.INT_TYPES.has(normalizedType) || SyncTable.isStringOrArrayType(normalizedType)) {
+    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}`;
       } else {
@@ -10276,10 +10393,31 @@ class SyncTable {
     }
     return "";
   }
-  static normalizeDefaultForCompare(value) {
+  static normalizeDefaultForCompare(value, fieldType) {
     if (value === null || value === undefined)
       return "null";
-    return String(value);
+    const normalizedType = String(fieldType || "").toLowerCase();
+    const raw = String(value).trim();
+    if (SyncTable.INT_TYPES.has(normalizedType) || SyncTable.DECIMAL_TYPES.has(normalizedType) || SyncTable.FLOAT_TYPES.has(normalizedType)) {
+      if (/^[+-]?\d+(?:\.\d+)?$/.test(raw)) {
+        let sign = "";
+        let body = raw;
+        if (body.startsWith("+") || body.startsWith("-")) {
+          sign = body.startsWith("-") ? "-" : "";
+          body = body.slice(1);
+        }
+        const parts = body.split(".");
+        const intPart = parts[0] || "0";
+        const fracPart = parts[1] || "";
+        const normalizedInt = intPart.replace(/^0+(\d)/, "$1");
+        const normalizedFrac = fracPart.replace(/0+$/g, "");
+        const mergedInt = normalizedInt === "" ? "0" : normalizedInt;
+        const merged = normalizedFrac.length > 0 ? `${mergedInt}.${normalizedFrac}` : mergedInt;
+        const normalized = sign === "-" && merged !== "0" ? `-${merged}` : merged;
+        return normalized;
+      }
+    }
+    return raw;
   }
   static buildIndexClause(indexName, fieldName, action) {
     const indexQuoted = SyncTable.quoteIdentifier(indexName);
@@ -10337,7 +10475,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);
+    const sqlType = SyncTable.getSqlType(normalized.type, normalized.max, normalized.unsigned, normalized.precision, normalized.scale);
     const actualDefault = SyncTable.resolveDefaultValue(normalized.default, normalized.type);
     const defaultSql = SyncTable.generateDefaultSql(actualDefault, normalized.type);
     const uniqueSql = normalized.unique ? " UNIQUE" : "";
@@ -10381,6 +10519,10 @@ class SyncTable {
         addedSystem,
         modified,
         indexChanges: indexActions.length
+      },
+      details: {
+        fieldChanges: fieldPlan.changeDetails,
+        indexChanges: indexPlan.indexActions
       }
     };
   }
@@ -10388,12 +10530,14 @@ class SyncTable {
     const alterClauses = [];
     let addedBusiness = 0;
     let modified = 0;
+    const changeDetails = [];
     for (const [fieldKey, fieldDef] of Object.entries(options.fields)) {
       const dbFieldName = snakeCase(fieldKey);
       if (options.existingColumns[dbFieldName]) {
         const comparison = SyncTable.compareFieldDefinition(options.existingColumns[dbFieldName], fieldDef);
         if (comparison.length > 0) {
           modified = modified + 1;
+          changeDetails.push({ fieldKey, dbFieldName, changes: comparison });
           SyncTable.assertCompatibleTypeChange(options.tableName, dbFieldName, comparison, fieldDef);
           alterClauses.push(SyncTable.generateDDLClause(fieldKey, fieldDef, false));
         }
@@ -10402,7 +10546,7 @@ class SyncTable {
         alterClauses.push(SyncTable.generateDDLClause(fieldKey, fieldDef, true));
       }
     }
-    return { alterClauses, addedBusiness, modified };
+    return { alterClauses, addedBusiness, modified, changeDetails };
   }
   static buildSystemFieldPlan(options) {
     const alterClauses = [];
@@ -10443,7 +10587,7 @@ class SyncTable {
     if (!typeChange)
       return;
     const currentType = String(typeChange.current || "").toLowerCase();
-    const expectedType = SyncTable.getSqlType(fieldDef.type, fieldDef.max ?? null, fieldDef.unsigned ?? false).toLowerCase();
+    const expectedType = SyncTable.getSqlType(fieldDef.type, fieldDef.max ?? null, fieldDef.unsigned ?? false, fieldDef.precision ?? null, fieldDef.scale ?? null).toLowerCase();
     const currentBase = currentType.replace(/\s*unsigned/gi, "").replace(/\([^)]*\)/g, "").trim();
     const expectedBase = expectedType.replace(/\s*unsigned/gi, "").replace(/\([^)]*\)/g, "").trim();
     if (currentBase !== expectedBase && !SyncTable.isCompatibleTypeChange(currentType, expectedType))
@@ -10554,6 +10698,8 @@ SQL: ${sqlLine}
       if (nIntIdx > cIntIdx)
         return true;
     }
+    if (cBase === "float" && nBase === "double")
+      return true;
     if (cBase === "varchar" && (nBase === "text" || nBase === "mediumtext" || nBase === "longtext"))
       return true;
     if (cBase === "char" && nBase === "varchar" || cBase === "varchar" && nBase === "char") {
@@ -10567,12 +10713,14 @@ SQL: ${sqlLine}
   static compareFieldDefinition(existingColumn, fieldDef) {
     const changes = [];
     const normalized = normalizeFieldDefinition(fieldDef);
-    const expectedType = SyncTable.getSqlType(normalized.type, normalized.max, normalized.unsigned).toLowerCase().replace(/\s+/g, " ").trim();
+    const expectedType = SyncTable.getSqlType(normalized.type, normalized.max, normalized.unsigned, normalized.precision, normalized.scale).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();
-    if (currentType !== expectedType) {
+    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;
+    if (normalizedCurrentType !== expectedType) {
       changes.push({
         type: "datatype",
-        current: currentType,
+        current: normalizedCurrentType,
         expected: expectedType
       });
     }
@@ -10584,12 +10732,26 @@ SQL: ${sqlLine}
         expected: expectedNullable
       });
     }
-    const expectedDefault = SyncTable.resolveDefaultValue(normalized.default, normalized.type);
-    if (SyncTable.normalizeDefaultForCompare(existingColumn.defaultValue) !== SyncTable.normalizeDefaultForCompare(expectedDefault)) {
+    const normalizedType = String(normalized.type || "").toLowerCase();
+    if (!SyncTable.TEXT_FAMILY.has(normalizedType) && normalizedType !== "json") {
+      const expectedDefault = SyncTable.resolveDefaultValue(normalized.default, normalized.type);
+      const currentDefaultNormalized = SyncTable.normalizeDefaultForCompare(existingColumn.defaultValue, normalized.type);
+      const expectedDefaultNormalized = SyncTable.normalizeDefaultForCompare(expectedDefault, normalized.type);
+      if (currentDefaultNormalized !== expectedDefaultNormalized) {
+        changes.push({
+          type: "default",
+          current: existingColumn.defaultValue,
+          expected: expectedDefault
+        });
+      }
+    }
+    const currentComment = String(existingColumn.comment ?? "");
+    const expectedComment = String(normalized.name ?? "");
+    if (currentComment !== expectedComment) {
       changes.push({
-        type: "default",
-        current: existingColumn.defaultValue,
-        expected: expectedDefault
+        type: "comment",
+        current: currentComment,
+        expected: expectedComment
       });
     }
     return changes;
@@ -10703,7 +10865,7 @@ SQL: ${sqlLine}
   static async modifyTable(db, dbName, tableName, fields) {
     const existingColumns = await SyncTable.getTableColumns(db, dbName, tableName);
     const existingIndexes = await SyncTable.getTableIndexes(db, dbName, tableName);
-    const { plan, summary } = SyncTable.buildTablePlan({
+    const { plan, summary, details } = SyncTable.buildTablePlan({
       tableName,
       fields,
       existingColumns,
@@ -10711,7 +10873,23 @@ SQL: ${sqlLine}
     });
     if (plan.changed) {
       const msg = `[\u8868 ${tableName}] \u53D8\u66F4\u6C47\u603B\uFF0C\u65B0\u589E\u5B57\u6BB5=${summary.addedBusiness}\uFF0C\u65B0\u589E\u7CFB\u7EDF\u5B57\u6BB5=${summary.addedSystem}\uFF0C\u4FEE\u6539\u5B57\u6BB5=${summary.modified}\uFF0C\u7D22\u5F15\u53D8\u66F4=${summary.indexChanges}`;
+      const detailLines = details.fieldChanges.flatMap((item) => item.changes.map((change) => {
+        const current = String(change.current ?? "");
+        const expected = String(change.expected ?? "");
+        return `- ${item.dbFieldName}.${change.type}: ${current} -> ${expected}`;
+      }));
+      const indexLines = details.indexChanges.map((change) => {
+        const indexLabel = `idx_${change.fieldName}` === change.indexName ? change.indexName : change.indexName;
+        if (change.action === "create") {
+          return `- index.${indexLabel}: \u65E0 -> ${change.indexName}(${change.fieldName})`;
+        }
+        return `- index.${indexLabel}: ${change.indexName}(${change.fieldName}) -> \u65E0`;
+      });
+      const allLines = [...detailLines, ...indexLines];
       Logger.debug(msg);
+      for (const line of allLines) {
+        Logger.debug(`[\u8868 ${tableName}] \u53D8\u66F4\u660E\u7EC6 ${line}`);
+      }
       await SyncTable.applyTablePlan(db, tableName, plan);
     }
     return plan;
@@ -12473,12 +12651,28 @@ function getRegex(name) {
   }
   return name;
 }
+function parseRegexLiteral(pattern) {
+  const trimmed = String(pattern || "").trim();
+  if (trimmed.length < 2)
+    return null;
+  if (!trimmed.startsWith("/"))
+    return null;
+  const lastSlash = trimmed.lastIndexOf("/");
+  if (lastSlash <= 0)
+    return null;
+  const flags = trimmed.slice(lastSlash + 1);
+  if (flags !== "" && !/^[gimsuy]+$/.test(flags))
+    return null;
+  return { source: trimmed.slice(1, lastSlash), flags };
+}
 function getCompiledRegex(pattern, flags) {
-  const regexStr = getRegex(pattern);
-  const cacheKey = `${regexStr}:${flags || ""}`;
+  const literal = parseRegexLiteral(pattern);
+  const regexStr = literal ? literal.source : getRegex(pattern);
+  const useFlags = literal && literal.flags !== "" ? literal.flags : flags || "";
+  const cacheKey = `${regexStr}:${useFlags}`;
   let cached = regexCache.get(cacheKey);
   if (!cached) {
-    cached = new RegExp(regexStr, flags);
+    cached = new RegExp(regexStr, useFlags);
     regexCache.set(cacheKey, cached);
   }
   return cached;
@@ -12487,39 +12681,8 @@ function getCompiledRegex(pattern, flags) {
 // lib/validator.ts
 init_util();
 var INPUT_TYPE_SET2 = new Set(["number", "integer", "string", "char", "array", "array_number", "array_integer", "json", "json_number", "json_integer"]);
-function isRegexInput2(input) {
-  if (input.startsWith("@"))
-    return true;
-  return /[\\^$.*+?()[\]{}]/.test(input);
-}
-function isEnumInput2(input) {
-  return input.includes("|") && !isRegexInput2(input);
-}
-function isJsonPrimitive3(value) {
-  if (value === null)
-    return true;
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-}
-function isJsonObject3(value) {
-  if (!value || typeof value !== "object")
-    return false;
-  if (value instanceof Date)
-    return false;
-  if (Array.isArray(value))
-    return false;
-  return true;
-}
-function isJsonStructure(value) {
-  return Array.isArray(value) || isJsonObject3(value);
-}
-function isFiniteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value);
-}
-function isIntegerNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value);
-}
 function checkJsonLeaves(value, rule) {
-  if (isJsonPrimitive3(value)) {
+  if (isJsonPrimitive(value)) {
     if (rule === "number")
       return isFiniteNumber(value);
     return isIntegerNumber(value);
@@ -12531,7 +12694,7 @@ function checkJsonLeaves(value, rule) {
     }
     return true;
   }
-  if (isJsonObject3(value)) {
+  if (isJsonObject(value)) {
     for (const v of Object.values(value)) {
       if (v === undefined)
         continue;
@@ -12657,14 +12820,15 @@ class Validator {
     return error ? `${label}${error}` : null;
   }
   static convert(value, input, dbType) {
-    const normalizedInput = String(input || "").toLowerCase();
-    if (!INPUT_TYPE_SET2.has(normalizedInput) && isRegexInput2(normalizedInput)) {
+    const inputRaw = String(input || "").trim();
+    const inputKey = inputRaw.toLowerCase();
+    if (!INPUT_TYPE_SET2.has(inputKey) && isRegexInput(inputRaw)) {
       return typeof value === "string" ? { value, error: null } : { value: null, error: "\u5FC5\u987B\u662F\u5B57\u7B26\u4E32" };
     }
-    if (!INPUT_TYPE_SET2.has(normalizedInput) && isEnumInput2(normalizedInput)) {
+    if (!INPUT_TYPE_SET2.has(inputKey) && isEnumInput(inputRaw)) {
       return typeof value === "string" ? { value, error: null } : { value: null, error: "\u5FC5\u987B\u662F\u5B57\u7B26\u4E32" };
     }
-    switch (normalizedInput) {
+    switch (inputKey) {
       case "number": {
         if (isFiniteNumber(value))
           return { value, error: null };
@@ -12749,43 +12913,44 @@ class Validator {
     const input = normalized.input;
     const min = normalized.min;
     const max = normalized.max;
-    const normalizedInput = String(input || "").toLowerCase();
-    const isRegex = !INPUT_TYPE_SET2.has(normalizedInput) && isRegexInput2(normalizedInput);
-    const isEnum = !INPUT_TYPE_SET2.has(normalizedInput) && isEnumInput2(normalizedInput);
-    if (normalizedInput === "number" || normalizedInput === "integer") {
+    const inputRaw = String(input || "").trim();
+    const inputKey = inputRaw.toLowerCase();
+    const isRegex = !INPUT_TYPE_SET2.has(inputKey) && isRegexInput(inputRaw);
+    const isEnum = !INPUT_TYPE_SET2.has(inputKey) && isEnumInput(inputRaw);
+    if (inputKey === "number" || inputKey === "integer") {
       if (typeof value !== "number")
-        return normalizedInput === "integer" ? "\u5FC5\u987B\u662F\u6574\u6570" : "\u5FC5\u987B\u662F\u6570\u5B57";
+        return inputKey === "integer" ? "\u5FC5\u987B\u662F\u6574\u6570" : "\u5FC5\u987B\u662F\u6570\u5B57";
       if (min !== null && value < min)
         return `\u4E0D\u80FD\u5C0F\u4E8E${min}`;
       if (max !== null && max > 0 && value > max)
         return `\u4E0D\u80FD\u5927\u4E8E${max}`;
-    } else if (normalizedInput === "string" || normalizedInput === "char" || isRegex || isEnum) {
+    } else if (inputKey === "string" || inputKey === "char" || isRegex || isEnum) {
       if (typeof value !== "string")
         return "\u5FC5\u987B\u662F\u5B57\u7B26\u4E32";
-      if (normalizedInput === "char" && value.length !== 1)
+      if (inputKey === "char" && value.length !== 1)
         return "\u5FC5\u987B\u662F\u5355\u5B57\u7B26";
       if (min !== null && value.length < min)
         return `\u957F\u5EA6\u4E0D\u80FD\u5C11\u4E8E${min}\u4E2A\u5B57\u7B26`;
       if (max !== null && max > 0 && value.length > max)
         return `\u957F\u5EA6\u4E0D\u80FD\u8D85\u8FC7${max}\u4E2A\u5B57\u7B26`;
       if (isRegex) {
-        const regex = this.resolveRegex(normalizedInput);
+        const regex = this.resolveRegex(inputRaw);
         if (!this.testRegex(regex, value))
           return "\u683C\u5F0F\u4E0D\u6B63\u786E";
       }
       if (isEnum) {
-        const enums = normalizedInput.split("|").map((item) => item.trim()).filter((item) => item !== "");
+        const enums = inputRaw.split("|").map((item) => item.trim()).filter((item) => item !== "");
         if (!enums.includes(value))
           return "\u503C\u4E0D\u5728\u679A\u4E3E\u8303\u56F4\u5185";
       }
-    } else if (normalizedInput === "array" || normalizedInput === "array_number" || normalizedInput === "array_integer") {
+    } else if (inputKey === "array" || inputKey === "array_number" || inputKey === "array_integer") {
       if (!Array.isArray(value))
         return "\u5FC5\u987B\u662F\u6570\u7EC4";
       if (min !== null && value.length < min)
         return `\u81F3\u5C11\u9700\u8981${min}\u4E2A\u5143\u7D20`;
       if (max !== null && max > 0 && value.length > max)
         return `\u6700\u591A\u53EA\u80FD\u6709${max}\u4E2A\u5143\u7D20`;
-    } else if (normalizedInput === "json" || normalizedInput === "json_number" || normalizedInput === "json_integer") {
+    } else if (inputKey === "json" || inputKey === "json_number" || inputKey === "json_integer") {
       if (!isJsonStructure(value))
         return "\u5FC5\u987B\u662FJSON\u5BF9\u8C61\u6216\u6570\u7EC4";
     }