befly 3.22.9 → 3.23.0

package/checks/api.js

@@ -98,14 +98,17 @@ const apiSchema = z
 const apiListSchema = z.array(apiSchema);
 
 export async function checkApi(apis) {
-    let hasError = false;
-
-    const schemaResult = apiListSchema.safeParse(apis);
-    if (!schemaResult.success) {
-        const errors = formatZodIssues(schemaResult.error.issues, { items: apis, itemLabel: "api" });
-        Logger.warn("接口校验失败", { errors: errors }, false);
-        hasError = true;
+    const result = apiListSchema.safeParse(apis);
+    if (result.success) {
+        return false;
     }
 
-    return hasError;
+    Logger.warn(
+        "接口校验失败",
+        {
+            errors: formatZodIssues(result.error.issues, { items: apis, itemLabel: "api" })
+        },
+        false
+    );
+    return true;
 }

package/checks/config.js

@@ -1,7 +1,7 @@
 import * as z from "zod";
 
-import { Logger } from "../lib/logger.js";
 import { RUN_MODE_VALUES } from "../configs/constConfig.js";
+import { Logger } from "../lib/logger.js";
 import { formatZodIssues } from "../utils/formatZodIssues.js";
 import { isNoTrimStringAllowEmpty, isValidTimeZone } from "../utils/is.js";
 
@@ -109,14 +109,17 @@ const configSchema = z
  * - checkConfig 校验的是“最终合并后的运行时配置对象”，用于阻断错误配置带病启动。
  */
 export async function checkConfig(config) {
-    let hasError = false;
-
-    const schemaResult = configSchema.safeParse(config);
-    if (!schemaResult.success) {
-        const errors = formatZodIssues(schemaResult.error.issues, { item: config, itemLabel: "config" });
-        Logger.warn("配置校验失败", { errors: errors }, false);
-        hasError = true;
+    const result = configSchema.safeParse(config);
+    if (result.success) {
+        return false;
     }
 
-    return hasError;
+    Logger.warn(
+        "配置校验失败",
+        {
+            errors: formatZodIssues(result.error.issues, { item: config, itemLabel: "config" })
+        },
+        false
+    );
+    return true;
 }

package/checks/hook.js

@@ -25,12 +25,16 @@ export async function checkHook(hooks) {
     let hasError = false;
 
     for (const hook of hooks) {
-        const schemaResult = hookSchema.safeParse(hook);
-        if (!schemaResult.success) {
-            const errors = formatZodIssues(schemaResult.error.issues, { item: hook, itemLabel: "hook" });
-            Logger.warn("钩子校验失败", { errors: errors }, false);
+        const result = hookSchema.safeParse(hook);
+        if (!result.success) {
+            Logger.warn(
+                "钩子校验失败",
+                {
+                    errors: formatZodIssues(result.error.issues, { item: hook, itemLabel: "hook" })
+                },
+                false
+            );
             hasError = true;
-            continue;
         }
     }
 

package/checks/menu.js

@@ -45,14 +45,17 @@ const menuListSchema = z.array(menuSchema).superRefine((menuList, refineCtx) =>
 });
 
 export const checkMenu = async (menus) => {
-    let hasError = false;
-
-    const schemaResult = menuListSchema.safeParse(menus);
-    if (!schemaResult.success) {
-        const errors = formatZodIssues(schemaResult.error.issues, { items: menus, itemLabel: "menus" });
-        Logger.warn("菜单校验失败", { errors: errors }, false);
-        hasError = true;
+    const result = menuListSchema.safeParse(menus);
+    if (result.success) {
+        return false;
     }
 
-    return hasError;
+    Logger.warn(
+        "菜单校验失败",
+        {
+            errors: formatZodIssues(result.error.issues, { items: menus, itemLabel: "menus" })
+        },
+        false
+    );
+    return true;
 };

package/checks/plugin.js

@@ -25,12 +25,16 @@ export async function checkPlugin(plugins) {
     let hasError = false;
 
     for (const plugin of plugins) {
-        const schemaResult = pluginSchema.safeParse(plugin);
-        if (!schemaResult.success) {
-            const errors = formatZodIssues(schemaResult.error.issues, { item: plugin, itemLabel: "plugin" });
-            Logger.warn("插件校验失败", { errors: errors }, false);
+        const result = pluginSchema.safeParse(plugin);
+        if (!result.success) {
+            Logger.warn(
+                "插件校验失败",
+                {
+                    errors: formatZodIssues(result.error.issues, { item: plugin, itemLabel: "plugin" })
+                },
+                false
+            );
             hasError = true;
-            continue;
         }
     }
 

package/checks/table.js

@@ -4,13 +4,23 @@ import { FIELD_RULE_DEFAULT_MAX, FIELD_RULE_DEFAULT_MIN, FIELD_RULE_INPUT_TYPES
 import { Logger } from "../lib/logger.js";
 import { formatZodIssues } from "../utils/formatZodIssues.js";
 import { isNoTrimStringAllowEmpty, isNullable, isRegexInput } from "../utils/is.js";
+import { snakeCase } from "../utils/util.js";
 
 z.config(z.locales.zhCN());
 
 const lowerCamelRegex = /^_?[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/;
+const lowerSnakeRegex = /^_?[a-z][a-z0-9]*(?:_[a-z0-9]+)+$/;
 const noTrimString = z.string().refine(isNoTrimStringAllowEmpty, "不允许首尾空格");
 const inputSchema = z.enum(FIELD_RULE_INPUT_TYPES);
 
+function isValidFieldName(fieldName) {
+    if (String(fieldName).includes("_")) {
+        return lowerSnakeRegex.test(fieldName);
+    }
+
+    return lowerCamelRegex.test(fieldName);
+}
+
 function addIssue(context, path, message) {
     context.addIssue({
         path: path,
@@ -75,7 +85,21 @@ const fieldDefSchema = z
         }
     });
 
-const tableContentSchema = z.record(z.string().regex(lowerCamelRegex), fieldDefSchema);
+const tableContentSchema = z.record(z.string().refine(isValidFieldName, "字段名必须为 lowerCamelCase 或 snake_case"), fieldDefSchema).superRefine((value, context) => {
+    const fieldNameMap = new Map();
+
+    for (const fieldName of Object.keys(value)) {
+        const dbFieldName = snakeCase(fieldName);
+        const previousFieldName = fieldNameMap.get(dbFieldName);
+
+        if (previousFieldName) {
+            addIssue(context, [fieldName], `字段名 ${fieldName} 与 ${previousFieldName} 指向同一数据库字段 ${dbFieldName}`);
+            continue;
+        }
+
+        fieldNameMap.set(dbFieldName, fieldName);
+    }
+});
 const tableRegistrySchema = z.record(z.string().regex(lowerCamelRegex), tableContentSchema);
 
 /**
@@ -83,15 +107,20 @@ const tableRegistrySchema = z.record(z.string().regex(lowerCamelRegex), tableCon
  * @throws 当检查失败时抛出异常
  */
 export async function checkTable(tables) {
-    // 收集所有表文件
-    let hasError = false;
-
-    const schemaResult = tableRegistrySchema.safeParse(tables);
-    if (!schemaResult.success) {
-        const errors = formatZodIssues(schemaResult.error.issues, { items: tables, itemLabel: "table" });
-        Logger.warn("表结构校验失败", { errors: errors }, false);
-        hasError = true;
+    const result = tableRegistrySchema.safeParse(tables);
+    if (result.success) {
+        return false;
     }
 
-    return hasError;
+    Logger.warn(
+        "表结构校验失败",
+        {
+            errors: formatZodIssues(result.error.issues, {
+                items: tables,
+                itemLabel: "table"
+            })
+        },
+        false
+    );
+    return true;
 }

package/index.js

@@ -35,35 +35,27 @@ import { deepMerge } from "./utils/deepMerge.js";
 export { syncDbApply as syncDb } from "./scripts/syncDb/index.js";
 
 function prefixMenuPaths(menus, prefix) {
-    const output = [];
-    for (const menu of menus) {
-        const nextPath = menu.path === "/" ? `/${prefix}` : `/${prefix}${menu.path}`;
+    return menus.map((menu) => {
         const nextMenu = {
             name: menu.name,
-            path: nextPath,
+            path: menu.path === "/" ? `/${prefix}` : `/${prefix}${menu.path}`,
             sort: menu.sort
         };
+
         if (Array.isArray(menu.children)) {
-            const children = [];
-            for (const child of menu.children) {
-                children.push({
-                    name: child.name,
-                    path: child.path,
-                    sort: child.sort
-                });
-            }
-            nextMenu.children = children;
+            nextMenu.children = menu.children.map((child) => ({
+                name: child.name,
+                path: child.path,
+                sort: child.sort
+            }));
         }
-        output.push(nextMenu);
-    }
-    return output;
+
+        return nextMenu;
+    });
 }
 
 async function ensureSyncPrerequisites(ctx) {
-    const missingCtxKeys = [];
-    if (!ctx.redis) missingCtxKeys.push("ctx.redis");
-    if (!ctx.mysql) missingCtxKeys.push("ctx.mysql");
-    if (!ctx.cache) missingCtxKeys.push("ctx.cache");
+    const missingCtxKeys = ["ctx.redis", "ctx.mysql", "ctx.cache"].filter((key) => !ctx[key.slice(4)]);
     if (missingCtxKeys.length > 0) {
         throw new Error(`启动失败：${missingCtxKeys.join("、")} 未初始化`, {
             cause: null,
@@ -78,8 +70,7 @@ async function ensureSyncPrerequisites(ctx) {
     const missingTables = [];
 
     for (const table of requiredTables) {
-        const tableExistsResult = await ctx.mysql.tableExists(table);
-        if (!tableExistsResult.data) {
+        if (!(await ctx.mysql.tableExists(table)).data) {
             missingTables.push(table);
         }
     }

package/lib/connect.js

@@ -6,6 +6,25 @@
 import { RedisClient, SQL } from "bun";
 import { Logger } from "./logger.js";
 
+function getRunMode() {
+    return Bun.env.RUN_MODE || "unknown";
+}
+
+function buildRedisUrl(config) {
+    if (config.username) {
+        const encodedUser = encodeURIComponent(config.username);
+        const encodedPass = encodeURIComponent(config.password || "");
+        return `redis://${encodedUser}:${encodedPass}@${config.hostname}:${config.port}/${config.db}`;
+    }
+
+    if (config.password) {
+        const encodedPass = encodeURIComponent(config.password);
+        return `redis://:${encodedPass}@${config.hostname}:${config.port}/${config.db}`;
+    }
+
+    return `redis://${config.hostname}:${config.port}/${config.db}`;
+}
+
 /**
  * 连接管理器
  */
@@ -29,13 +48,26 @@ export class Connect {
         return this.redisClient;
     }
 
+    static async handleConnectError(clientKey, label, subsystem, hostname, error) {
+        await this[clientKey]?.close();
+        this[clientKey] = null;
+        Logger.error(`${label} 连接失败 (${hostname} ${getRunMode()})`, error);
+        throw new Error(`${label} 连接失败 (${hostname})`, {
+            cause: error,
+            code: "runtime",
+            subsystem: subsystem,
+            operation: "connect",
+            runMode: getRunMode()
+        });
+    }
+
     /**
      * 连接数据库
      * @param config - 数据库配置
      */
     static async connectMysql(config) {
         try {
-            const sqlConfig = {
+            this.mysqlClient = new SQL({
                 adapter: "mysql",
                 hostname: config.hostname,
                 port: config.port,
@@ -44,23 +76,12 @@ export class Connect {
                 password: config.password,
                 max: config.max,
                 bigint: true
-            };
-
-            this.mysqlClient = new SQL(sqlConfig);
+            });
 
             await this.mysqlClient`SELECT 1`;
             Logger.info(`Mysql 连接成功 (${config.hostname})`);
         } catch (error) {
-            await this.mysqlClient?.close();
-            this.mysqlClient = null;
-            Logger.error(`Mysql 连接失败 (${config.hostname} ${Bun.env.RUN_MODE || "unkonw"})`, error);
-            throw new Error(`Mysql 连接失败 (${config.hostname})`, {
-                cause: error,
-                code: "runtime",
-                subsystem: "mysql",
-                operation: "connect",
-                runMode: Bun.env.RUN_MODE || "unknown"
-            });
+            await this.handleConnectError("mysqlClient", "Mysql", "mysql", config.hostname, error);
         }
     }
 
@@ -70,19 +91,7 @@ export class Connect {
      */
     static async connectRedis(config) {
         try {
-            let authPart = "";
-            if (config.username) {
-                const encodedUser = encodeURIComponent(config.username);
-                const encodedPass = encodeURIComponent(config.password || "");
-                authPart = `${encodedUser}:${encodedPass}@`;
-            } else if (config.password) {
-                const encodedPass = encodeURIComponent(config.password);
-                authPart = `:${encodedPass}@`;
-            }
-
-            const redisUrl = `redis://${authPart}${config.hostname}:${config.port}/${config.db}`;
-
-            this.redisClient = new RedisClient(redisUrl);
+            this.redisClient = new RedisClient(buildRedisUrl(config));
             // Called when successfully connected to Redis server
             this.redisClient.onconnect = () => {
                 Logger.info(`Redis 连接成功 (${config.hostname})`);
@@ -100,16 +109,7 @@ export class Connect {
             // Eagerly verify the connection before returning
             await this.redisClient.ping();
         } catch (error) {
-            await this.redisClient?.close();
-            this.redisClient = null;
-            Logger.error(`Redis 连接失败 (${config.hostname} ${Bun.env.RUN_MODE || "unkonw"})`, error);
-            throw new Error(`Redis 连接失败 (${config.hostname})`, {
-                cause: error,
-                code: "runtime",
-                subsystem: "redis",
-                operation: "connect",
-                runMode: Bun.env.RUN_MODE || "unknown"
-            });
+            await this.handleConnectError("redisClient", "Redis", "redis", config.hostname, error);
         }
     }
 

package/lib/dbHelper.js

@@ -1,6 +1,6 @@
 import { fieldClear } from "../utils/fieldClear.js";
 import { isNonEmptyString, isNullable, isNumber, isPlainObject, isString } from "../utils/is.js";
-import { arrayKeysToCamel, canConvertToNumber, keysToCamel, keysToSnake, snakeCase } from "../utils/util.js";
+import { camelCase, canConvertToNumber, keysToSnake, snakeCase } from "../utils/util.js";
 import { Logger } from "./logger.js";
 import { DbParse } from "./dbParse.js";
 import { SqlBuilder } from "./sqlBuilder.js";
@@ -26,19 +26,7 @@ function quoteIdentMySql(identifier) {
 }
 
 function normalizeSqlMetaNumber(value) {
-    if (isNullable(value)) {
-        return 0;
-    }
-
-    if (typeof value !== "number") {
-        return 0;
-    }
-
-    if (!Number.isFinite(value)) {
-        return 0;
-    }
-
-    return value;
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
 
 function normalizeBigIntValues(value) {
@@ -232,17 +220,8 @@ function assertBatchInsertRowsConsistent(rows, options) {
                     code: "validation"
                 });
             }
-        }
-
-        for (const field of fields) {
-            if (!(field in row)) {
-                throw new Error(`批量插入缺少字段 (table: ${options.table}, rowIndex: ${i}, field: ${field})`, {
-                    cause: null,
-                    code: "validation"
-                });
-            }
-            if (row[field] === undefined) {
-                throw new Error(`批量插入字段值不能为 undefined (table: ${options.table}, rowIndex: ${i}, field: ${field})`, {
+            if (row[key] === undefined) {
+                throw new Error(`批量插入字段值不能为 undefined (table: ${options.table}, rowIndex: ${i}, field: ${key})`, {
                     cause: null,
                     code: "validation"
                 });
@@ -294,6 +273,20 @@ class DbHelper {
         return tableInfo;
     }
 
+    normalizeDbFieldNames(row) {
+        if (!row || !isPlainObject(row)) {
+            return row;
+        }
+
+        const result = {};
+
+        for (const [key, value] of Object.entries(row)) {
+            result[camelCase(key)] = value;
+        }
+
+        return result;
+    }
+
     async execute(sql, params) {
         if (!this.sql) {
             throw new Error("数据库连接未初始化", {
@@ -422,7 +415,7 @@ class DbHelper {
             return {};
         }
 
-        const camelRow = keysToCamel(row);
+        const camelRow = this.normalizeDbFieldNames(row);
         const deserialized = deserializeArrayFields(camelRow);
         if (!deserialized) {
             return {};
@@ -437,7 +430,7 @@ class DbHelper {
     }
 
     normalizeListData(list) {
-        const camelList = arrayKeysToCamel(list);
+        const camelList = list.map((item) => this.normalizeDbFieldNames(item));
         const deserializedList = camelList.map((item) => deserializeArrayFields(item)).filter((item) => item !== null);
         return normalizeBigIntValues(deserializedList);
     }
@@ -709,7 +702,11 @@ class DbHelper {
         const result = listExecuteRes.data || [];
 
         if (result.length >= WARNING_LIMIT) {
-            Logger.warn("getAll 返回数据过多，建议使用 getList 分页查询", { table: options.table, count: result.length, total: total });
+            Logger.warn("getAll 返回数据过多，建议使用 getList 分页查询", {
+                table: options.table,
+                count: result.length,
+                total: total
+            });
         }
 
         if (result.length >= MAX_LIMIT) {
@@ -740,47 +737,6 @@ class DbHelper {
         return { data: exists, sql: executeRes.sql };
     }
 
-    async getFieldValue(options) {
-        const parsed = await this.createDbParse().parseFieldValue(options);
-        const builder = this.createSqlBuilder().select(parsed.prepared.fields).from(parsed.prepared.table).where(parsed.prepared.where);
-        this.applyLeftJoins(builder, parsed.prepared.leftJoins);
-        if (parsed.prepared.orderBy && parsed.prepared.orderBy.length > 0) {
-            builder.orderBy(parsed.prepared.orderBy);
-        }
-        const { sql, params } = builder.toSelectSql();
-        const executeRes = await this.execute(sql, params);
-        const result = this.normalizeRowData(executeRes.data?.[0] || null);
-        let value = null;
-        let hasValue = false;
-
-        if (isPlainObject(result)) {
-            if (Object.hasOwn(result, parsed.field)) {
-                value = result[parsed.field];
-                hasValue = true;
-            }
-
-            if (!hasValue) {
-                const camelField = parsed.field.replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase());
-                if (camelField !== parsed.field && Object.hasOwn(result, camelField)) {
-                    value = result[camelField];
-                    hasValue = true;
-                }
-            }
-
-            if (!hasValue) {
-                const snakeField = parsed.field.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-                if (snakeField !== parsed.field && Object.hasOwn(result, snakeField)) {
-                    value = result[snakeField];
-                }
-            }
-        }
-
-        return {
-            data: value,
-            sql: executeRes.sql
-        };
-    }
-
     async insData(options) {
         const parsed = this.createDbParse().parseInsert(options);
         const { table, snakeTable, data } = parsed;
@@ -939,7 +895,12 @@ class DbHelper {
         const inputData = this._prepareWriteInputData(parsed.data);
         assertWriteDataHasFields(inputData, "更新数据必须至少有一个字段", parsed.snakeTable);
 
-        const processed = this._buildUpdateRow({ data: parsed.data, now: Date.now(), allowState: true, beflyMode: this.beflyMode });
+        const processed = this._buildUpdateRow({
+            data: parsed.data,
+            now: Date.now(),
+            allowState: true,
+            beflyMode: this.beflyMode
+        });
         assertWriteDataHasFields(processed, "更新数据必须至少有一个字段", parsed.snakeTable);
         const builder = this.createSqlBuilder().where(parsed.where);
         const { sql, params } = builder.toUpdateSql(parsed.snakeTable, processed);
@@ -954,14 +915,18 @@ class DbHelper {
 
     async delData(options) {
         const parsed = this.createDbParse().parseDelete(options, false);
-        const now = Date.now();
-        const processed = {
-            state: 0,
-            deleted_at: now
-        };
-
-        if (this.beflyMode === "auto") {
-            processed.updated_at = now;
+        let processed;
+
+        if (parsed.deleteMode === "manual") {
+            processed = this._prepareWriteInputData(parsed.data);
+            assertWriteDataHasFields(processed, "delData 在 beflyMode=manual 时 data 必须至少有一个字段", parsed.snakeTable);
+        } else {
+            const now = Date.now();
+            processed = {
+                state: 0,
+                deleted_at: now,
+                updated_at: now
+            };
         }
 
         const builder = this.createSqlBuilder().where(parsed.where);
@@ -989,30 +954,6 @@ class DbHelper {
         };
     }
 
-    async disableData(options) {
-        const { table, where } = options;
-
-        return await this.updData({
-            table: table,
-            data: {
-                state: 2
-            },
-            where: where
-        });
-    }
-
-    async enableData(options) {
-        const { table, where } = options;
-
-        return await this.updData({
-            table: table,
-            data: {
-                state: 1
-            },
-            where: where
-        });
-    }
-
     async increment(table, field, where, value = 1) {
         const parsed = this.createDbParse().parseIncrement(table, field, where, value, "increment");