befly 3.24.18 → 3.24.20

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

@@ -380,6 +380,99 @@ export class RedisHelper {
         }
     }
 
+    /**
+     * 向有序集合添加成员
+     * @param key - 键名
+     * @param items - [{ score, member }] 数组
+     * @returns 成功添加的成员数量
+     */
+    async zadd(key, items) {
+        try {
+            if (items.length === 0) {
+                return 0;
+            }
+
+            const pkey = `${this.prefix}${key}`;
+            const args = [pkey];
+
+            for (const item of items) {
+                const score = Number(item.score);
+                const member = String(item.member);
+
+                if (!Number.isFinite(score) || member.length === 0) {
+                    continue;
+                }
+
+                args.push(score);
+                args.push(member);
+            }
+
+            if (args.length <= 1) {
+                return 0;
+            }
+
+            return await this.client.zadd.apply(this.client, args);
+        } catch (error) {
+            Logger.error("Redis zadd 错误", error);
+            return 0;
+        }
+    }
+
+    /**
+     * 获取有序集合成员数量
+     * @param key - 键名
+     */
+    async zcard(key) {
+        try {
+            const pkey = `${this.prefix}${key}`;
+            return await this.client.zcard(pkey);
+        } catch (error) {
+            Logger.error("Redis zcard 错误", error);
+            return 0;
+        }
+    }
+
+    /**
+     * 按 score 区间删除有序集合成员
+     * @param key - 键名
+     * @param min - 最小分值
+     * @param max - 最大分值
+     */
+    async zremrangebyscore(key, min, max) {
+        try {
+            const pkey = `${this.prefix}${key}`;
+            return await this.client.zremrangebyscore(pkey, min, max);
+        } catch (error) {
+            Logger.error("Redis zremrangebyscore 错误", error);
+            return 0;
+        }
+    }
+
+    /**
+     * 从有序集合删除一个或多个成员
+     * @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.18",
+    "version": "3.24.20",
     "gitHead": "49c39d36695036e85fc64083cc43c1652fff96cb",
     "private": false,
     "description": "Befly - 为 Bun 专属打造的 JavaScript API 接口框架核心引擎",
@@ -56,7 +56,7 @@
     },
     "dependencies": {
         "fast-xml-parser": "^5.8.0",
-        "nodemailer": "^8.0.7",
+        "nodemailer": "^8.0.9",
         "pathe": "^2.0.3",
         "picomatch": "^4.0.4",
         "ua-parser-js": "^2.0.10",

package/plugins/email.js

@@ -5,7 +5,8 @@
 
 import nodemailer from "nodemailer";
 
-import { Logger } from "../lib/logger.js";
+import { Logger } from "#root/lib/logger.js";
+import { hasEmailConfig } from "#root/utils/email.js";
 
 export default {
     order: 7,
@@ -13,12 +14,12 @@ export default {
         const config = befly?.config?.email || {};
         let transporter = null;
 
-        if (config && config.host && config.user) {
+        if (hasEmailConfig(config)) {
             try {
                 transporter = nodemailer.createTransport({
                     host: config.host,
                     port: config.port || 25,
-                    secure: config.ssl,
+                    secure: config.secure ?? config.ssl,
                     auth: {
                         user: config.user,
                         pass: config.pass

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());
+}

package/apis/admin/cacheRefresh.js

@@ -1,122 +0,0 @@
-/**
- * 刷新全部缓存接口
- *
- * 功能：
- * 1. 刷新接口缓存（apis:all）
- * 2. 刷新菜单缓存（menus:all）
- * 3. 刷新角色缓存（role:info:{code}）
- * 4. 重建角色接口权限缓存（role:apis:{code}，Set）
- * 5. 重建角色菜单权限缓存（role:menus:{code}，Set）
- *
- * 使用场景：
- * - 执行数据库同步后
- * - 手动修改配置需要立即生效
- * - 缓存出现异常需要重建
- */
-
-import { isNonEmptyString } from "#root/utils/is.js";
-
-export default {
-    name: "刷新全部缓存",
-    method: "POST",
-    body: "none",
-    auth: true,
-    fields: {},
-    required: [],
-    handler: async (befly) => {
-        try {
-            const results = {
-                apis: { success: false, count: 0 },
-                menus: { success: false, count: 0 },
-                roles: { success: false, count: 0 },
-                roleApiPermissions: { success: false },
-                roleMenuPermissions: { success: false }
-            };
-
-            // 1. 刷新接口缓存
-            try {
-                const apis = await befly.mysql.getAll({
-                    table: "beflyApi"
-                });
-
-                await befly.redis.setObject("apis:all", apis.data.lists);
-                results["apis"] = { success: true, count: apis.data.lists.length };
-            } catch (error) {
-                befly.logger.error("刷新接口缓存失败", error);
-                results["apis"] = { success: false, error: error.message };
-            }
-
-            // 2. 刷新菜单缓存
-            try {
-                const menus = await befly.mysql.getAll({
-                    table: "beflyMenu"
-                });
-
-                await befly.redis.setObject("menus:all", menus.data.lists);
-
-                const parentCount = menus.data.lists.filter((m) => !isNonEmptyString(m.parentPath)).length;
-                const childCount = menus.data.lists.filter((m) => isNonEmptyString(m.parentPath)).length;
-
-                results["menus"] = {
-                    success: true,
-                    count: menus.data.lists.length,
-                    parentCount: parentCount,
-                    childCount: childCount
-                };
-            } catch (error) {
-                befly.logger.error("刷新菜单缓存失败", error);
-                results["menus"] = { success: false, error: error.message };
-            }
-
-            // 3. 刷新角色权限缓存
-            try {
-                const roles = await befly.mysql.getAll({
-                    table: "beflyRole"
-                });
-
-                // 使用 setBatch 批量缓存所有角色
-                const count = await befly.redis.setBatch(
-                    roles.data.lists.map((role) => ({
-                        key: `role:info:${role.code}`,
-                        value: role
-                    }))
-                );
-
-                results["roles"] = { success: true, count: count };
-            } catch (error) {
-                befly.logger.error("刷新角色缓存失败", error);
-                results["roles"] = { success: false, error: error.message };
-            }
-
-            // 4. 重建角色接口权限缓存（版本化 + 原子切换）
-            try {
-                await befly.cache.cacheRoleApis();
-                results["roleApiPermissions"] = { success: true };
-            } catch (error) {
-                befly.logger.error("重建角色接口权限缓存失败", error);
-                results["roleApiPermissions"] = { success: false, error: error.message };
-            }
-
-            // 5. 重建角色菜单权限缓存
-            try {
-                await befly.cache.cacheRoleMenus();
-                results["roleMenuPermissions"] = { success: true };
-            } catch (error) {
-                befly.logger.error("重建角色菜单权限缓存失败", error);
-                results["roleMenuPermissions"] = { success: false, error: error.message };
-            }
-
-            // 检查是否全部成功
-            const allSuccess = results["apis"].success && results["menus"].success && results["roles"].success && results["roleApiPermissions"].success && results["roleMenuPermissions"].success;
-
-            if (allSuccess) {
-                return befly.tool.Yes("全部缓存刷新成功", results);
-            } else {
-                return befly.tool.No("部分缓存刷新失败", results);
-            }
-        } catch (error) {
-            befly.logger.error("刷新全部缓存失败", error);
-            return befly.tool.No("刷新全部缓存失败", { error: error.message });
-        }
-    }
-};