befly 3.24.19 → 3.25.0

package/checks/config.js

@@ -10,6 +10,47 @@ z.config(z.locales.zhCN());
 const boolIntSchema = z.union([z.literal(0), z.literal(1), z.literal(true), z.literal(false)]);
 const noTrimString = z.string().refine(isNoTrimStringAllowEmpty, "不允许首尾空格");
 const beflyModeSchema = z.union([z.literal("manual"), z.literal("auto")]);
+const projectListCodeSchema = z.string().regex(/^[a-z][a-zA-Z0-9]*$/, "必须是小驼峰命名");
+const projectListItemSchema = z
+    .object({
+        code: projectListCodeSchema,
+        name: noTrimString.min(1),
+        productName: noTrimString.min(1),
+        productCode: noTrimString.min(1),
+        productVersion: noTrimString.optional()
+    })
+    .strict();
+const projectListsSchema = z.array(projectListItemSchema).superRefine((projectLists, ctx) => {
+    const codeSet = new Set();
+    const productCodeSet = new Set();
+
+    for (let index = 0; index < projectLists.length; index += 1) {
+        const code = projectLists[index].code;
+        const productCode = projectLists[index].productCode;
+
+        if (codeSet.has(code)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `projectLists[${index}].code 重复`,
+                path: [index, "code"]
+            });
+            continue;
+        }
+
+        codeSet.add(code);
+
+        if (productCodeSet.has(productCode)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `projectLists[${index}].productCode 重复`,
+                path: [index, "productCode"]
+            });
+            continue;
+        }
+
+        productCodeSet.add(productCode);
+    }
+});
 
 const configSchema = z
     .object({
@@ -98,7 +139,9 @@ const configSchema = z
                 skipRoutes: z.array(noTrimString),
                 rules: z.array(z.object({}).passthrough())
             })
-            .strict()
+            .strict(),
+
+        projectLists: projectListsSchema
     })
     .strict();
 

package/configs/beflyConfig.json

@@ -68,5 +68,14 @@
         "key": "ip",
         "skipRoutes": [],
         "rules": []
-    }
+    },
+    "projectLists": [
+        {
+            "code": "beflyCore",
+            "name": "后台管理",
+            "productName": "后台管理",
+            "productCode": "beflyCore",
+            "productVersion": "1.0.0"
+        }
+    ]
 }

package/index.js

@@ -55,6 +55,30 @@ function prefixMenuPaths(menus, prefix) {
     });
 }
 
+function mergeProjectListsByCode(projectLists) {
+    if (!Array.isArray(projectLists)) {
+        return [];
+    }
+
+    const itemMap = new Map();
+
+    for (const item of projectLists) {
+        const code = String(item?.code || "");
+
+        if (!code) {
+            continue;
+        }
+
+        if (itemMap.has(code)) {
+            itemMap.delete(code);
+        }
+
+        itemMap.set(code, item);
+    }
+
+    return Array.from(itemMap.values());
+}
+
 async function ensureSyncPrerequisites(ctx) {
     const missingCtxKeys = ["ctx.redis", "ctx.mysql", "ctx.cache"].filter((key) => !ctx[key.slice(4)]);
     if (missingCtxKeys.length > 0) {
@@ -90,6 +114,7 @@ async function ensureSyncPrerequisites(ctx) {
 export async function createBefly(env = {}, config = {}, menus = []) {
     const mergedConfig = deepMerge(beflyConfig, config);
     const mergedMenus = deepMerge(prefixMenuPaths(beflyMenus, "core"), menus);
+    mergedConfig.projectLists = mergeProjectListsByCode(mergedConfig.projectLists);
 
     const configHasError = await checkConfig(mergedConfig);
     const { apis, tables, plugins, hooks } = await scanSources();

package/lib/dbHelper.js

@@ -436,7 +436,7 @@ class DbHelper {
     }
 
     prepareWriteInputData(data) {
-        return serializeArrayFields(keysToSnake(fieldClear(data, { excludeValues: [null, undefined] })));
+        return serializeArrayFields(keysToSnake(fieldClear(data, { excludeValues: [undefined] })));
     }
 
     prepareWriteUserData(data, allowState) {

package/lib/dbParse.js

@@ -1,6 +1,6 @@
 import { isNonEmptyString, isNullable, isPlainObject, isString } from "../utils/is.js";
 import { snakeCase } from "../utils/util.js";
-import { assertNoExprField, clearDeep, fieldsToSnake, normalizeQualifierField, orderByToSnake, parseFieldAliasParts, parseTableRef, processJoinField, processJoinOn, processJoinOrderBy, processJoinWhere, whereKeysToSnake } from "./dbUtil.js";
+import { assertNoExprField, clearDeep, fieldsToSnake, normalizeQualifierField, orderByToSnake, parseFieldAliasParts, parseFlatWhereKey, parseTableRef, processJoinField, processJoinOn, processJoinOrderBy, processJoinWhere, whereKeysToSnake } from "./dbUtil.js";
 
 function assertNonEmptyString(value, label) {
     if (!isNonEmptyString(value)) {
@@ -38,48 +38,47 @@ function validateWhereObject(where, label, required = false) {
         });
     }
 
-    const visitWhereMeta = (currentWhere, currentLabel) => {
-        for (const [key, value] of Object.entries(currentWhere)) {
-            if (key === "$exclude") {
-                if (isNullable(value)) {
-                    continue;
-                }
+    for (const [key, value] of Object.entries(where)) {
+        if (key === "$exclude") {
+            if (isNullable(value)) {
+                continue;
+            }
 
-                if (!isPlainObject(value)) {
-                    throw new Error(`${currentLabel}.$exclude 必须是对象`, {
+            if (!isPlainObject(value)) {
+                throw new Error(`${label}.$exclude 必须是对象`, {
+                    cause: null,
+                    code: "validation"
+                });
+            }
+
+            for (const [excludeKey, excludeValue] of Object.entries(value)) {
+                assertNonEmptyString(excludeKey, `${label}.$exclude 的字段名`);
+                if (!Array.isArray(excludeValue)) {
+                    throw new Error(`${label}.$exclude.${excludeKey} 必须是数组`, {
                         cause: null,
                         code: "validation"
                     });
                 }
-
-                for (const [excludeKey, excludeValue] of Object.entries(value)) {
-                    assertNonEmptyString(excludeKey, `${currentLabel}.$exclude 的字段名`);
-                    if (!Array.isArray(excludeValue)) {
-                        throw new Error(`${currentLabel}.$exclude.${excludeKey} 必须是数组`, {
-                            cause: null,
-                            code: "validation"
-                        });
-                    }
-                }
-                continue;
-            }
-
-            if ((key === "$or" || key === "$and") && Array.isArray(value)) {
-                for (let i = 0; i < value.length; i++) {
-                    if (isPlainObject(value[i])) {
-                        visitWhereMeta(value[i], `${currentLabel}.${key}[${i}]`);
-                    }
-                }
-                continue;
             }
+            continue;
+        }
 
-            if (isPlainObject(value)) {
-                visitWhereMeta(value, `${currentLabel}.${key}`);
-            }
+        if (key === "$or" || key === "$and") {
+            throw new Error(`${label} 不再支持 ${key} 嵌套，请改用 field$op$or 扁平写法`, {
+                cause: null,
+                code: "validation"
+            });
         }
-    };
 
-    visitWhereMeta(where, label);
+        parseFlatWhereKey(key);
+
+        if (isPlainObject(value)) {
+            throw new Error(`${label}.${key} 不再支持嵌套对象操作符，请改用 field$op 扁平写法`, {
+                cause: null,
+                code: "validation"
+            });
+        }
+    }
 }
 
 function validateOrderByItems(orderBy, label) {
@@ -563,6 +562,14 @@ function appendWhereNode(root, node) {
     }
 }
 
+function normalizeOrGroupKey(orGroup) {
+    if (orGroup === "or") {
+        return "or1";
+    }
+
+    return orGroup;
+}
+
 function buildArrayOperatorNode(fieldName, operator, value, errorFactory, emptyMessage) {
     if (!Array.isArray(value)) {
         throw new Error(errorFactory(operator), {
@@ -620,69 +627,33 @@ function buildOperatorNode(fieldName, operator, value) {
     }
 }
 
-function appendFieldCondition(group, key, value) {
-    if (key.includes("$")) {
-        const lastDollarIndex = key.lastIndexOf("$");
-        appendWhereNode(group, buildOperatorNode(key.substring(0, lastDollarIndex), `$${key.substring(lastDollarIndex + 1)}`, value));
-        return;
-    }
+function appendFieldCondition(group, orGroups, key, value) {
+    const parsed = parseFlatWhereKey(key);
+    const node = buildOperatorNode(parsed.field, parsed.operator, value);
 
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-        for (const [operator, operatorValue] of Object.entries(value)) {
-            appendWhereNode(group, buildOperatorNode(key, operator, operatorValue));
-        }
-        return;
-    }
-
-    appendWhereNode(group, buildOperatorNode(key, "=", value));
-}
-
-function appendAndConditions(group, value) {
-    if (!Array.isArray(value)) {
+    if (!node) {
         return;
     }
 
-    for (const condition of value) {
-        if (!condition || typeof condition !== "object" || Array.isArray(condition)) {
-            continue;
-        }
-
-        const sub = parseWhereObject(condition);
-        if (sub.items.length === 0) {
-            continue;
-        }
-
-        if (sub.join === "AND") {
-            for (const item of sub.items) {
-                group.items.push(item);
-            }
-            continue;
-        }
-
-        group.items.push(sub);
-    }
-}
-
-function appendOrConditions(group, value) {
-    if (!Array.isArray(value)) {
+    if (!parsed.orGroup) {
+        appendWhereNode(group, node);
         return;
     }
 
-    const orGroup = createWhereRoot("OR");
-    for (const condition of value) {
-        if (!condition || typeof condition !== "object" || Array.isArray(condition)) {
-            continue;
-        }
+    const orGroupKey = normalizeOrGroupKey(parsed.orGroup);
+    let orGroup = orGroups.get(orGroupKey);
 
-        const sub = parseWhereObject(condition);
-        if (sub.items.length > 0) {
-            orGroup.items.push(sub);
-        }
+    if (!orGroup) {
+        orGroup = createWhereRoot("OR");
+        orGroups.set(orGroupKey, orGroup);
+        appendWhereNode(group, orGroup);
     }
 
-    if (orGroup.items.length > 0) {
-        group.items.push(orGroup);
-    }
+    appendWhereNode(orGroup, {
+        type: "group",
+        join: "AND",
+        items: [node]
+    });
 }
 
 function parseWhereObject(whereObj) {
@@ -691,23 +662,14 @@ function parseWhereObject(whereObj) {
     }
 
     const group = createWhereRoot();
+    const orGroups = new Map();
 
     for (const [key, value] of Object.entries(whereObj)) {
-        if (value === undefined) {
-            continue;
-        }
-
-        if (key === "$and") {
-            appendAndConditions(group, value);
-            continue;
-        }
-
-        if (key === "$or") {
-            appendOrConditions(group, value);
+        if (value === undefined || key === "$exclude") {
             continue;
         }
 
-        appendFieldCondition(group, key, value);
+        appendFieldCondition(group, orGroups, key, value);
     }
 
     return group;

package/lib/dbUtil.js

@@ -252,7 +252,17 @@ function shouldExcludeFieldValue(field, value, excludeValueMap) {
         return false;
     }
 
-    const candidateValues = excludeValueMap.get(field);
+    let normalizedField = field;
+
+    if (isString(field) && field !== "$or" && field !== "$and" && field !== "$exclude") {
+        try {
+            normalizedField = parseFlatWhereKey(field).field;
+        } catch {
+            normalizedField = field;
+        }
+    }
+
+    const candidateValues = excludeValueMap.get(normalizedField) || excludeValueMap.get(field);
     if (!candidateValues || candidateValues.length === 0) {
         return false;
     }
@@ -320,7 +330,7 @@ export function clearDeep(value, options) {
                 continue;
             }
 
-            if (isNullable(item)) {
+            if (item === undefined) {
                 continue;
             }
 
@@ -354,7 +364,7 @@ export function clearDeep(value, options) {
                 continue;
             }
 
-            if (typeof item === "object" && !Array.isArray(item)) {
+            if (item !== null && typeof item === "object" && !Array.isArray(item)) {
                 if (!canRecurse) {
                     result[key] = item;
                     continue;
@@ -437,6 +447,89 @@ function normalizeOrderBy(orderBy, mapField) {
     });
 }
 
+const flatWhereOperatorTokens = new Set(["not", "in", "notIn", "like", "leftLike", "rightLike", "notLike", "gt", "gte", "lt", "lte", "between", "notBetween", "null", "notNull"]);
+
+function isFlatWhereOrGroupToken(token) {
+    return token === "or" || /^or\d+$/.test(token);
+}
+
+function buildFlatWhereKey(field, operator, orGroup) {
+    let key = field;
+
+    if (operator && operator !== "=") {
+        key += operator;
+    }
+
+    if (orGroup) {
+        key += `$${orGroup}`;
+    }
+
+    return key;
+}
+
+export function parseFlatWhereKey(key) {
+    if (!isNonEmptyString(key)) {
+        throw new Error("where 字段名不能为空", {
+            cause: null,
+            code: "validation"
+        });
+    }
+
+    assertNoExprField(key);
+
+    const rawParts = key.split("$").map((item) => item.trim());
+    const field = rawParts[0];
+
+    if (!isNonEmptyString(field)) {
+        throw new Error(`where 字段名不能为空 (field: ${key})`, {
+            cause: null,
+            code: "validation"
+        });
+    }
+
+    const suffixParts = rawParts.slice(1);
+    let orGroup = null;
+
+    if (suffixParts.length > 0 && isFlatWhereOrGroupToken(suffixParts[suffixParts.length - 1])) {
+        orGroup = suffixParts.pop();
+    }
+
+    if (suffixParts.length > 1) {
+        throw new Error(`where 字段后缀格式无效，请使用 field、field$op、field$or、field$op$orN (field: ${key})`, {
+            cause: null,
+            code: "validation"
+        });
+    }
+
+    if (suffixParts.length === 0) {
+        return {
+            field: field,
+            operator: "=",
+            orGroup: orGroup
+        };
+    }
+
+    const operatorToken = suffixParts[0];
+
+    if (!flatWhereOperatorTokens.has(operatorToken)) {
+        throw new Error(`where 操作符无效，请使用受支持的扁平操作符 (field: ${key}, operator: ${operatorToken})`, {
+            cause: null,
+            code: "validation"
+        });
+    }
+
+    return {
+        field: field,
+        operator: `$${operatorToken}`,
+        orGroup: orGroup
+    };
+}
+
+function normalizeFlatWhereKey(key, mapField) {
+    const parsed = parseFlatWhereKey(key);
+    return buildFlatWhereKey(mapField(parsed.field), parsed.operator, parsed.orGroup);
+}
+
 function mapWhereKeys(where, mapKey) {
     if (!where || typeof where !== "object") {
         return where;
@@ -483,20 +576,11 @@ export function processJoinField(field) {
 }
 
 function processJoinWhereKey(key) {
-    if (key === "$or" || key === "$and") {
+    if (key === "$or" || key === "$and" || key === "$exclude") {
         return key;
     }
 
-    assertNoExprField(key);
-    if (key.includes("$")) {
-        const lastDollarIndex = key.lastIndexOf("$");
-        const fieldPart = key.substring(0, lastDollarIndex);
-        const operator = key.substring(lastDollarIndex);
-
-        return `${normalizeQualifierField(fieldPart)}${operator}`;
-    }
-
-    return normalizeQualifierField(key);
+    return normalizeFlatWhereKey(key, normalizeQualifierField);
 }
 
 export function processJoinWhere(where) {
@@ -565,15 +649,11 @@ export function processJoinOn(on) {
 
 export function whereKeysToSnake(where) {
     return mapWhereKeys(where, (key) => {
-        assertNoExprField(key);
-        if (key.includes("$")) {
-            const lastDollarIndex = key.lastIndexOf("$");
-            const fieldName = key.substring(0, lastDollarIndex);
-            const operator = key.substring(lastDollarIndex);
-            return `${snakeCase(fieldName)}${operator}`;
+        if (key === "$or" || key === "$and" || key === "$exclude") {
+            return key;
         }
 
-        return snakeCase(key);
+        return normalizeFlatWhereKey(key, (field) => snakeCase(field));
     });
 }
 

package/lib/redisHelper.js

@@ -448,6 +448,31 @@ export class RedisHelper {
         }
     }
 
+    /**
+     * 从有序集合删除一个或多个成员
+     * @param key - 键名
+     * @param members - 成员数组
+     */
+    async zrem(key, members) {
+        try {
+            if (members.length === 0) {
+                return 0;
+            }
+
+            const pkey = `${this.prefix}${key}`;
+            const args = [pkey];
+
+            for (const member of members) {
+                args.push(String(member));
+            }
+
+            return await this.client.zrem.apply(this.client, args);
+        } catch (error) {
+            Logger.error("Redis zrem 错误", error);
+            return 0;
+        }
+    }
+
     /**
      * 删除键
      * @param key - 键名

package/lib/sqlBuilder.js

@@ -47,6 +47,9 @@ export class SqlBuilder {
 
         switch (node.operator) {
             case "$not":
+                if (node.value === null) {
+                    return { sql: `${escapedField} IS NOT NULL`, params: [] };
+                }
                 return { sql: `${escapedField} != ?`, params: [node.value] };
             case "$in":
                 return {
@@ -83,6 +86,9 @@ export class SqlBuilder {
             case "$notNull":
                 return { sql: `${escapedField} IS NOT NULL`, params: [] };
             default:
+                if (node.value === null) {
+                    return { sql: `${escapedField} IS NULL`, params: [] };
+                }
                 return { sql: `${escapedField} = ?`, params: [node.value] };
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.24.19",
+    "version": "3.25.0",
     "gitHead": "49c39d36695036e85fc64083cc43c1652fff96cb",
     "private": false,
     "description": "Befly - 为 Bun 专属打造的 JavaScript API 接口框架核心引擎",

package/plugins/email.js

@@ -5,11 +5,8 @@
 
 import nodemailer from "nodemailer";
 
-import { Logger } from "../lib/logger.js";
-
-function canCreateTransport(config) {
-    return Boolean(String(config?.host || "").trim() && String(config?.user || "").trim() && String(config?.pass || "").trim());
-}
+import { Logger } from "#root/lib/logger.js";
+import { hasEmailConfig } from "#root/utils/email.js";
 
 export default {
     order: 7,
@@ -17,7 +14,7 @@ export default {
         const config = befly?.config?.email || {};
         let transporter = null;
 
-        if (canCreateTransport(config)) {
+        if (hasEmailConfig(config)) {
             try {
                 transporter = nodemailer.createTransport({
                     host: config.host,

package/router/api.js

@@ -6,7 +6,6 @@
 import picomatch from "picomatch";
 
 import { Logger } from "../lib/logger.js";
-import { requestMetrics } from "../lib/requestMetrics.js";
 // 相对导入
 import { setCorsOptions } from "../utils/cors.js";
 import { getClientIp } from "../utils/getClientIp.js";
@@ -95,9 +94,6 @@ export function apiHandler(apis, hooks, context) {
             apiRequired: apiData.required,
             apiFile: apiData.filePath
         };
-        const requestStartTime = Date.now();
-        let requestHasError = false;
-        requestMetrics.onRequestStart();
 
         try {
             // 4. 串联执行所有钩子
@@ -147,7 +143,6 @@ export function apiHandler(apis, hooks, context) {
             // 7. 返回响应（自动处理 response/result/日志）
             return FinalResponse(ctx);
         } catch (err) {
-            requestHasError = true;
             // 全局错误处理
             Logger.error("请求错误", err, {
                 path: ctx.apiPath,
@@ -167,8 +162,6 @@ export function apiHandler(apis, hooks, context) {
                 msg: "内部服务错误"
             };
             return FinalResponse(ctx);
-        } finally {
-            requestMetrics.onRequestEnd(ctx.apiPath, Date.now() - requestStartTime, requestHasError);
         }
     };
 }

package/utils/email.js

@@ -0,0 +1,3 @@
+export function hasEmailConfig(config) {
+    return Boolean(String(config?.host || "").trim() && String(config?.user || "").trim() && String(config?.pass || "").trim());
+}