befly 3.21.1 → 3.21.2

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "befly",
-    "version": "3.21.1",
-    "gitHead": "9dd9b9f2547fe46fe861a95c70e160cae1d74b26",
+    "version": "3.21.2",
+    "gitHead": "d134ac529ad22517624353dfcfcc1b598f009a49",
     "private": false,
     "description": "Befly - 为 Bun 专属打造的 JavaScript API 接口框架核心引擎",
     "keywords": [

package/plugins/mysql.js

@@ -19,7 +19,8 @@ export default {
                 redis: befly.redis,
                 dbName: befly.config?.mysql?.database,
                 sql: Connect.getMysql(),
-                beflyMode: befly.config?.mysql?.beflyMode
+                beflyMode: befly.config?.mysql?.beflyMode,
+                tables: befly.tables
             });
 
             return dbManager;

package/scripts/syncDb/context.js

@@ -8,52 +8,30 @@ import { importDefault } from "../../utils/importDefault.js";
 import { isNonEmptyString, isPlainObject } from "../../utils/is.js";
 import { camelCase } from "../../utils/util.js";
 import { buildSyncDbDiff, groupSyncDbColumns } from "./diff.js";
-import { querySyncDbColumns } from "./query.js";
 import { printSyncDbProcessLog } from "./report.js";
 
-async function loadSyncDbTableDefs(tablesDir) {
-    const tableMap = new Map();
-
-    const glob = new Bun.Glob("*.json");
-    const files = await glob.scan({
-        cwd: tablesDir,
-        onlyFiles: true,
-        absolute: true,
-        followSymlinks: true
-    });
-
-    for await (const filePath of files) {
-        const fileName = basename(filePath, ".json");
-        const tableKey = String(camelCase(fileName)).toLowerCase();
-        if (fileName.startsWith("_")) {
-            continue;
-        }
-
-        const loaded = await importDefault(filePath, {});
-        if (!isPlainObject(loaded)) {
-            Logger.warn("tables 定义文件不是对象，已按空对象处理", {
-                filePath: filePath
-            });
-            tableMap.set(tableKey, {
-                filePath: filePath,
-                tableDef: {}
-            });
-            continue;
-        }
-
-        tableMap.set(tableKey, {
-            filePath: filePath,
-            tableDef: loaded
-        });
-    }
-
-    return tableMap;
-}
+const SYNC_DB_COLUMNS_SQL = `
+SELECT
+    c.TABLE_NAME AS tableName,
+    t.TABLE_COMMENT AS tableComment,
+    c.COLUMN_NAME AS columnName,
+    c.DATA_TYPE AS dataType,
+    c.COLUMN_TYPE AS columnType,
+    c.CHARACTER_MAXIMUM_LENGTH AS charLength,
+    c.COLUMN_COMMENT AS columnComment,
+    c.ORDINAL_POSITION AS ordinalPosition
+FROM information_schema.COLUMNS AS c
+LEFT JOIN information_schema.TABLES AS t
+    ON t.TABLE_SCHEMA = c.TABLE_SCHEMA
+    AND t.TABLE_NAME = c.TABLE_NAME
+WHERE c.TABLE_SCHEMA = DATABASE()
+ORDER BY c.TABLE_NAME ASC, c.ORDINAL_POSITION ASC
+`;
 
 export async function prepareSyncDbBaseContext(mysqlConfig) {
     const tablesDir = resolve(join(process.cwd(), "tables"));
     await mkdir(tablesDir, { recursive: true });
-    printSyncDbProcessLog(`tables目录=${tablesDir}`);
+    printSyncDbProcessLog(`表定义目录=${tablesDir}`);
 
     if (!isPlainObject(mysqlConfig)) {
         throw new Error("syncDb 缺少 mysql 配置", {
@@ -64,8 +42,8 @@ export async function prepareSyncDbBaseContext(mysqlConfig) {
         });
     }
 
-    printSyncDbProcessLog(`beflyMode=${mysqlConfig.beflyMode === "manual" ? "manual" : "auto"}`);
-    printSyncDbProcessLog(`连接 MySQL，database=${mysqlConfig.database}`);
+    printSyncDbProcessLog(`同步模式=${mysqlConfig.beflyMode === "manual" ? "手动" : "自动"}`);
+    printSyncDbProcessLog(`连接 MySQL，数据库名=${mysqlConfig.database}`);
     await Connect.connectMysql(mysqlConfig);
     const mysql = new DbHelper({
         redis: null,
@@ -75,8 +53,10 @@ export async function prepareSyncDbBaseContext(mysqlConfig) {
     });
 
     printSyncDbProcessLog("开始读取数据库字段信息");
-    const dbColumns = await querySyncDbColumns(mysql);
-    printSyncDbProcessLog(`数据库字段读取完成，columnCount=${dbColumns.length}`);
+    const queryRes = await mysql.execute(SYNC_DB_COLUMNS_SQL);
+    const dbColumns = Array.isArray(queryRes.data) ? queryRes.data : [];
+    printSyncDbProcessLog(`数据库字段读取完成，字段数量=${dbColumns.length}`);
+
     const skippedBeflyTables = new Set();
     for (const row of dbColumns) {
         const tableName = String(row?.tableName || "");
@@ -93,10 +73,45 @@ export async function prepareSyncDbBaseContext(mysqlConfig) {
     }
 
     const groupedDbColumns = groupSyncDbColumns(dbColumns);
-    const existingTableMap = await loadSyncDbTableDefs(tablesDir);
+    const existingTableMap = new Map();
+    const glob = new Bun.Glob("*.json");
+    const files = await glob.scan({
+        cwd: tablesDir,
+        onlyFiles: true,
+        absolute: true,
+        followSymlinks: true
+    });
+
+    for await (const filePath of files) {
+        const tableFileName = basename(filePath, ".json");
+        if (tableFileName.startsWith("_")) {
+            continue;
+        }
+
+        const tableKey = String(camelCase(tableFileName)).toLowerCase();
+        const loaded = await importDefault(filePath, {});
+        if (!isPlainObject(loaded)) {
+            Logger.warn("tables 定义文件不是对象，已按空对象处理", {
+                filePath: filePath
+            });
+            existingTableMap.set(tableKey, {
+                tableFileName: tableFileName,
+                filePath: filePath,
+                tableDef: {}
+            });
+            continue;
+        }
+
+        existingTableMap.set(tableKey, {
+            tableFileName: tableFileName,
+            filePath: filePath,
+            tableDef: loaded
+        });
+    }
+
     const diff = buildSyncDbDiff(groupedDbColumns, existingTableMap, mysqlConfig.beflyMode);
-    printSyncDbProcessLog(`tables定义文件数量=${existingTableMap.size}`);
-    printSyncDbProcessLog(`差异扫描完成，missingTableCount=${diff.missingTables.length}，missingFieldCount=${Object.values(diff.missingFieldsByTable).reduce((sum, item) => sum + item.fields.length, 0)}`);
+    printSyncDbProcessLog(`表定义文件数量=${existingTableMap.size}`);
+    printSyncDbProcessLog(`差异扫描完成，缺少表数量=${diff.missingTables.length}，缺少字段数量=${diff.missingFieldCount}，多余表数量=${diff.extraTables.length}，多余字段数量=${diff.extraFieldCount}`);
 
     return {
         diff: diff,

package/scripts/syncDb/diff.js

@@ -1,7 +1,7 @@
 import { join } from "node:path";
 
 import { isNonEmptyString, isPlainObject } from "../../utils/is.js";
-import { camelCase } from "../../utils/util.js";
+import { camelCase, snakeCase } from "../../utils/util.js";
 import { printSyncDbProcessLog } from "./report.js";
 import { toSyncDbFieldDef } from "./transform.js";
 
@@ -16,6 +16,25 @@ function shouldSkipSyncDbColumn(columnMeta, beflyMode) {
     return SYNC_DB_MANAGED_FIELD_NAMES.has(columnName);
 }
 
+function shouldSkipSyncDbFieldName(fieldName, beflyMode) {
+    if (beflyMode !== "manual") {
+        return false;
+    }
+
+    return SYNC_DB_MANAGED_FIELD_NAMES.has(snakeCase(String(fieldName || "")));
+}
+
+function sortSyncDbObjectKeys(source) {
+    const entries = Object.entries(source).sort(([left], [right]) => left.localeCompare(right));
+    const output = {};
+
+    for (const [key, value] of entries) {
+        output[key] = value;
+    }
+
+    return output;
+}
+
 export function groupSyncDbColumns(rows) {
     const grouped = new Map();
 
@@ -50,11 +69,18 @@ export function groupSyncDbColumns(rows) {
 
 export function buildSyncDbDiff(groupedDbColumns, existingTableMap, beflyMode = "auto") {
     const missingTables = [];
+    const extraTables = [];
     const missingFieldsByTable = {};
+    const extraFieldsByTable = {};
+    const groupedDbTableKeySet = new Set();
+    let missingFieldCount = 0;
+    let extraFieldCount = 0;
 
     for (const [tableName, columns] of groupedDbColumns.entries()) {
         const tableFileName = camelCase(tableName);
-        const existing = existingTableMap.get(String(tableFileName).toLowerCase());
+        const tableKey = String(tableFileName).toLowerCase();
+        groupedDbTableKeySet.add(tableKey);
+        const existing = existingTableMap.get(tableKey);
         const filteredColumns = columns.filter((columnMeta) => !shouldSkipSyncDbColumn(columnMeta, beflyMode));
 
         if (!existing) {
@@ -72,8 +98,10 @@ export function buildSyncDbDiff(groupedDbColumns, existingTableMap, beflyMode =
 
         const existingFields = isPlainObject(existing.tableDef) ? existing.tableDef : {};
         const missingFields = [];
+        const dbFieldNameSet = new Set();
         for (const columnMeta of filteredColumns) {
             const fieldInfo = toSyncDbFieldDef(columnMeta);
+            dbFieldNameSet.add(fieldInfo.fieldName);
             if (Object.hasOwn(existingFields, fieldInfo.fieldName)) {
                 continue;
             }
@@ -91,18 +119,61 @@ export function buildSyncDbDiff(groupedDbColumns, existingTableMap, beflyMode =
         }
 
         if (missingFields.length > 0) {
+            missingFieldCount = missingFieldCount + missingFields.length;
             missingFieldsByTable[tableFileName] = {
                 tableName: tableName,
-                tableFileName: tableFileName,
+                tableFileName: existing.tableFileName || tableFileName,
                 filePath: existing.filePath,
                 fields: missingFields
             };
         }
+
+        const extraFields = [];
+        for (const fieldName of Object.keys(existingFields)) {
+            if (shouldSkipSyncDbFieldName(fieldName, beflyMode)) {
+                continue;
+            }
+            if (dbFieldNameSet.has(fieldName)) {
+                continue;
+            }
+
+            extraFields.push({
+                tableName: tableName,
+                tableFileName: tableFileName,
+                fieldName: fieldName,
+                fieldDef: existingFields[fieldName]
+            });
+        }
+
+        if (extraFields.length > 0) {
+            extraFieldCount = extraFieldCount + extraFields.length;
+            extraFieldsByTable[tableFileName] = {
+                tableName: tableName,
+                tableFileName: existing.tableFileName || tableFileName,
+                filePath: existing.filePath,
+                fields: extraFields
+            };
+        }
+    }
+
+    for (const [tableKey, existing] of existingTableMap.entries()) {
+        if (groupedDbTableKeySet.has(tableKey)) {
+            continue;
+        }
+
+        extraTables.push({
+            tableFileName: existing.tableFileName || camelCase(tableKey),
+            filePath: existing.filePath
+        });
     }
 
     return {
         missingTables: missingTables,
-        missingFieldsByTable: missingFieldsByTable
+        extraTables: extraTables,
+        missingFieldsByTable: missingFieldsByTable,
+        extraFieldsByTable: extraFieldsByTable,
+        missingFieldCount: missingFieldCount,
+        extraFieldCount: extraFieldCount
     };
 }
 
@@ -118,7 +189,7 @@ export async function applySyncDbDiff(diff, tablesDir, existingTableMap) {
         }
 
         const filePath = join(tablesDir, `${missingTable.tableFileName}.json`);
-        await Bun.write(filePath, `${JSON.stringify(tableDef, null, 4)}\n`);
+        await Bun.write(filePath, `${JSON.stringify(sortSyncDbObjectKeys(tableDef), null, 4)}\n`);
         createdTableFileCount = createdTableFileCount + 1;
         printSyncDbProcessLog(`已生成表映射 ${filePath}`);
     }
@@ -133,8 +204,8 @@ export async function applySyncDbDiff(diff, tablesDir, existingTableMap) {
             appendedFieldCount = appendedFieldCount + 1;
         }
 
-        await Bun.write(targetFilePath, `${JSON.stringify(currentTableDef, null, 4)}\n`);
-        printSyncDbProcessLog(`已补充字段映射 ${targetFilePath}，fieldCount=${tableInfo.fields.length}`);
+        await Bun.write(targetFilePath, `${JSON.stringify(sortSyncDbObjectKeys(currentTableDef), null, 4)}\n`);
+        printSyncDbProcessLog(`已补充字段映射 ${targetFilePath}，补充字段数量=${tableInfo.fields.length}`);
     }
 
     return {
@@ -142,11 +213,3 @@ export async function applySyncDbDiff(diff, tablesDir, existingTableMap) {
         appendedFieldCount: appendedFieldCount
     };
 }
-
-export function countSyncDbMissingFields(diff) {
-    let missingFieldCount = 0;
-    for (const item of Object.values(diff.missingFieldsByTable)) {
-        missingFieldCount = missingFieldCount + item.fields.length;
-    }
-    return missingFieldCount;
-}

package/scripts/syncDb/index.js

@@ -1,55 +1,23 @@
-import { mkdir } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
+import { join, resolve } from "node:path";
 
 import { Connect } from "../../lib/connect.js";
 import { Logger } from "../../lib/logger.js";
-import { applySyncDbDiff, countSyncDbMissingFields } from "./diff.js";
+import { applySyncDbDiff } from "./diff.js";
 import { prepareSyncDbBaseContext } from "./context.js";
-import { printSyncDbDiffSummary, printSyncDbProcessLog, writeSyncDbCheckReport } from "./report.js";
-
-export async function syncDbCheck(mysqlConfig) {
-    try {
-        printSyncDbProcessLog("开始执行 check");
-        const reportPath = resolve(join(process.cwd(), "db.check.md"));
-        await mkdir(dirname(reportPath), { recursive: true });
-        await Bun.write(reportPath, "");
-
-        const { diff, groupedDbColumns, existingTableMap } = await prepareSyncDbBaseContext(mysqlConfig);
-        const missingFieldCount = countSyncDbMissingFields(diff);
-        const writtenReportPath = await writeSyncDbCheckReport(reportPath, diff, groupedDbColumns, existingTableMap);
-        printSyncDbDiffSummary("check", diff);
-        printSyncDbProcessLog(`check完成，missingTableCount=${diff.missingTables.length}，missingFieldCount=${missingFieldCount}`);
-
-        return {
-            mode: "check",
-            createdTableFileCount: 0,
-            appendedFieldCount: 0,
-            missingTableCount: diff.missingTables.length,
-            missingFieldCount: missingFieldCount,
-            hasDiff: diff.missingTables.length > 0 || missingFieldCount > 0,
-            reportPath: writtenReportPath
-        };
-    } catch (error) {
-        throw new Error("执行表定义同步失败", {
-            cause: error,
-            code: "runtime",
-            subsystem: "scripts",
-            operation: "syncDb"
-        });
-    } finally {
-        await Connect.disconnect();
-        await Logger.flush();
-    }
-}
+import { printSyncDbDiffSummary, printSyncDbProcessLog, writeSyncDbReport } from "./report.js";
 
 export async function syncDbApply(mysqlConfig) {
+    const reportPath = resolve(join(process.cwd(), "db.sync.md"));
     try {
-        printSyncDbProcessLog("开始执行 apply");
-        const { diff, tablesDir, existingTableMap } = await prepareSyncDbBaseContext(mysqlConfig);
-        printSyncDbDiffSummary("check", diff);
+        printSyncDbProcessLog("开始执行应用");
+        const { diff, groupedDbColumns, tablesDir, existingTableMap } = await prepareSyncDbBaseContext(mysqlConfig);
+        const extraFieldCount = diff.extraFieldCount;
+        const writtenReportPath = await writeSyncDbReport(reportPath, diff, groupedDbColumns, existingTableMap);
+        printSyncDbDiffSummary(diff);
         const applyResult = await applySyncDbDiff(diff, tablesDir, existingTableMap);
-        printSyncDbDiffSummary("apply", diff);
-        printSyncDbProcessLog(`apply完成，createdTableFileCount=${applyResult.createdTableFileCount}，appendedFieldCount=${applyResult.appendedFieldCount}`);
+        const hasDiff = diff.missingTables.length > 0 || applyResult.appendedFieldCount > 0 || diff.extraTables.length > 0 || extraFieldCount > 0;
+
+        printSyncDbProcessLog(`应用完成，缺少表数量=${diff.missingTables.length}，缺少字段数量=${applyResult.appendedFieldCount}，多余表数量=${diff.extraTables.length}，多余字段数量=${extraFieldCount}，新建表定义文件数量=${applyResult.createdTableFileCount}，补充字段数量=${applyResult.appendedFieldCount}`);
 
         return {
             mode: "apply",
@@ -57,8 +25,10 @@ export async function syncDbApply(mysqlConfig) {
             appendedFieldCount: applyResult.appendedFieldCount,
             missingTableCount: diff.missingTables.length,
             missingFieldCount: applyResult.appendedFieldCount,
-            hasDiff: diff.missingTables.length > 0 || applyResult.appendedFieldCount > 0,
-            reportPath: ""
+            extraTableCount: diff.extraTables.length,
+            extraFieldCount: extraFieldCount,
+            hasDiff: hasDiff,
+            reportPath: writtenReportPath
         };
     } catch (error) {
         throw new Error("执行表定义同步失败", {