befly 3.15.18 → 3.15.20

package/dist/befly.js

@@ -8294,7 +8294,7 @@ 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", "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);
@@ -8307,6 +8307,8 @@ function inferInputByType(dbType) {
     case "bigint":
       return "integer";
     case "decimal":
+    case "float":
+    case "double":
       return "number";
     case "char":
     case "varchar":
@@ -8461,8 +8463,9 @@ async function checkTable(tables, config2) {
         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;
+        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/\u6B63\u5219\u522B\u540D\uFF0C\u4EC5\u5141\u8BB8\u5B57\u7B26\u4E32\u7C7B\u5B57\u6BB5\uFF08char/varchar/text\uFF09`);
@@ -8598,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) {
@@ -9987,6 +9995,8 @@ function inferInputByType2(dbType) {
     case "bigint":
       return "integer";
     case "decimal":
+    case "float":
+    case "double":
       return "number";
     case "char":
     case "varchar":
@@ -10184,6 +10194,8 @@ class SyncTable {
     int: "INT",
     bigint: "BIGINT",
     decimal: "DECIMAL",
+    float: "FLOAT",
+    double: "DOUBLE",
     char: "CHAR",
     varchar: "VARCHAR",
     datetime: "DATETIME",
@@ -10196,6 +10208,7 @@ 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) {
@@ -10214,6 +10227,8 @@ class SyncTable {
         throw new Error("\u540C\u6B65\u8868\uFF1A\u8BF7\u4F20\u5165\u591A\u4E2A\u8868\u5B9A\u4E49\u7EC4\u6210\u7684\u6570\u7EC4");
       }
       await SyncTable.ensureDbVersion(this.db);
+      const tableTasks = [];
+      const incompatibleTypeChanges = [];
       for (const item of items) {
         if (!item || item.type !== "table") {
           continue;
@@ -10224,9 +10239,98 @@ class SyncTable {
           SyncTable.normalizeFieldDefinitionInPlace(fieldDef);
         }
         const existsTable = await SyncTable.tableExists(this.db, this.dbName, tableName);
+        const task = {
+          item,
+          tableName,
+          tableFields,
+          existsTable,
+          existingColumns: null,
+          existingIndexes: null,
+          plan: null,
+          planSummary: null,
+          planDetails: null
+        };
+        if (existsTable) {
+          const existingColumns = await SyncTable.getTableColumns(this.db, this.dbName, tableName);
+          const existingIndexes = await SyncTable.getTableIndexes(this.db, this.dbName, tableName);
+          const changes = SyncTable.collectIncompatibleTypeChanges(tableName, existingColumns, tableFields);
+          for (const change of changes) {
+            incompatibleTypeChanges.push(change);
+          }
+          task.existingColumns = existingColumns;
+          task.existingIndexes = existingIndexes;
+        }
+        tableTasks.push(task);
+      }
+      if (incompatibleTypeChanges.length > 0) {
+        const lines = [];
+        for (const change of incompatibleTypeChanges) {
+          lines.push(`- ${change.tableName}.${change.dbFieldName}: ${change.currentType} -> ${change.expectedType}`);
+        }
+        const msgLines = [];
+        msgLines.push("\u7981\u6B62\u5B57\u6BB5\u7C7B\u578B\u53D8\u66F4\uFF08\u68C0\u6D4B\u5230\u4E0D\u517C\u5BB9/\u6536\u7F29\u53D8\u66F4\uFF09:");
+        for (const line of lines) {
+          msgLines.push(line);
+        }
+        msgLines.push("\u8BF4\u660E: \u4EC5\u5141\u8BB8\u540C\u7C7B\u578B\u7684\u5BBD\u5316\u53D8\u66F4\uFF08\u5982 TINYINT->SMALLINT->INT->BIGINT\uFF09\uFF0C\u4EE5\u53CA\u90E8\u5206\u517C\u5BB9\u53D8\u66F4\uFF08\u5982 VARCHAR->TEXT\u3001CHAR/VARCHAR \u4E92\u8F6C\u3001float->double\uFF09\u3002");
+        msgLines.push("\u63D0\u793A: \u82E5\u786E\u9700\u6536\u7F29\uFF0C\u8BF7\u5148\u624B\u5DE5\u8FC1\u79FB/\u6E05\u6D17\u6570\u636E\u540E\u518D\u6267\u884C\u540C\u6B65\u3002");
+        throw new Error(msgLines.join(`
+`));
+      }
+      for (const task of tableTasks) {
+        if (!task.existsTable) {
+          continue;
+        }
+        if (!task.existingColumns || !task.existingIndexes) {
+          throw new Error(`\u540C\u6B65\u8868\uFF1A\u5185\u90E8\u9519\u8BEF\uFF1A\u9884\u68C0\u9636\u6BB5\u7F3A\u5931\u8868\u5143\u4FE1\u606F\uFF08\u8868=${task.tableName}\uFF09`);
+        }
+        const built = SyncTable.buildTablePlan({
+          tableName: task.tableName,
+          fields: task.tableFields,
+          existingColumns: task.existingColumns,
+          existingIndexes: task.existingIndexes
+        });
+        task.plan = built.plan;
+        task.planSummary = built.summary;
+        task.planDetails = built.details;
+      }
+      for (const task of tableTasks) {
+        const item = task.item;
+        const tableName = task.tableName;
+        const tableFields = task.tableFields;
+        const existsTable = task.existsTable;
         try {
           if (existsTable) {
-            await SyncTable.modifyTable(this.db, this.dbName, tableName, tableFields);
+            const plan = task.plan;
+            const summary = task.planSummary;
+            const details = task.planDetails;
+            if (plan && plan.changed && summary && details) {
+              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((d) => d.changes.map((change) => {
+                const current = String(change.current ?? "");
+                const expected = String(change.expected ?? "");
+                return `- ${d.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 = [];
+              for (const line of detailLines) {
+                allLines.push(line);
+              }
+              for (const line of indexLines) {
+                allLines.push(line);
+              }
+              Logger.debug(msg);
+              for (const line of allLines) {
+                Logger.debug(`[\u8868 ${tableName}] \u53D8\u66F4\u660E\u7EC6 ${line}`);
+              }
+              await SyncTable.applyTablePlan(this.db, tableName, plan);
+            }
           } else {
             await SyncTable.createTable(this.db, tableName, tableFields);
           }
@@ -10318,7 +10422,7 @@ class SyncTable {
       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;
@@ -10335,6 +10439,8 @@ class SyncTable {
       case "int":
       case "bigint":
       case "decimal":
+      case "float":
+      case "double":
         return 0;
       case "char":
       case "varchar":
@@ -10356,7 +10462,7 @@ class SyncTable {
     if (SyncTable.TEXT_FAMILY.has(normalizedType) || normalizedType === "json" || actualDefault === "null") {
       return "";
     }
-    if (SyncTable.INT_TYPES.has(normalizedType) || SyncTable.DECIMAL_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 {
@@ -10383,7 +10489,7 @@ class SyncTable {
       return "null";
     const normalizedType = String(fieldType || "").toLowerCase();
     const raw = String(value).trim();
-    if (SyncTable.INT_TYPES.has(normalizedType) || SyncTable.DECIMAL_TYPES.has(normalizedType)) {
+    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;
@@ -10579,6 +10685,32 @@ class SyncTable {
       throw new Error([`\u7981\u6B62\u5B57\u6BB5\u7C7B\u578B\u53D8\u66F4: ${tableName}.${dbFieldName}`, `\u5F53\u524D\u7C7B\u578B: ${typeChange.current}`, `\u76EE\u6807\u7C7B\u578B: ${typeChange.expected}`, "\u8BF4\u660E: \u4EC5\u5141\u8BB8\u5BBD\u5316\u578B\u53D8\u66F4\uFF08\u5982 INT->BIGINT, VARCHAR->TEXT\uFF09\uFF0C\u4EE5\u53CA CHAR/VARCHAR \u4E92\u8F6C\uFF1BDATETIME \u4E0E BIGINT \u4E0D\u5141\u8BB8\u4E92\u8F6C\uFF08\u9700\u8981\u624B\u52A8\u8FC1\u79FB\u6570\u636E\uFF09"].join(`
 `));
   }
+  static collectIncompatibleTypeChanges(tableName, existingColumns, fields) {
+    const out = [];
+    for (const [fieldKey, fieldDef] of Object.entries(fields)) {
+      const dbFieldName = snakeCase(fieldKey);
+      const existing = existingColumns[dbFieldName];
+      if (!existing)
+        continue;
+      const comparison = SyncTable.compareFieldDefinition(existing, fieldDef);
+      const typeChange = comparison.find((c) => c.type === "datatype");
+      if (!typeChange)
+        continue;
+      const currentType = String(typeChange.current || "").toLowerCase();
+      const expectedType = String(typeChange.expected || "").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)) {
+        out.push({
+          tableName,
+          dbFieldName,
+          currentType: String(typeChange.current ?? ""),
+          expectedType: String(typeChange.expected ?? "")
+        });
+      }
+    }
+    return out;
+  }
   static truncateForLog(input, maxLen) {
     const s = String(input);
     if (maxLen <= 0)
@@ -10683,6 +10815,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") {