befly 3.20.8 → 3.20.10

package/apis/dict/all.js

@@ -10,8 +10,8 @@ export default {
     required: [],
     handler: async (befly) => {
         const result = await befly.mysql.getAll({
-            table: "beflyDict",
-            leftJoin: ["beflyDictType ON beflyDict.typeCode = beflyDictType.code"],
+            table: ["beflyDict", "beflyDictType"],
+            leftJoin: ["beflyDict.typeCode beflyDictType.code"],
             fields: ["beflyDict.id", "beflyDict.typeCode", "beflyDict.key", "beflyDict.label", "beflyDict.sort", "beflyDict.remark", "beflyDict.createdAt", "beflyDict.updatedAt", "beflyDictType.name AS typeName"],
             orderBy: ["beflyDict.sort#ASC", "beflyDict.id#ASC"]
         });

package/apis/dict/detail.js

@@ -9,8 +9,8 @@ export default {
     required: ["id"],
     handler: async (befly, ctx) => {
         const dict = await befly.mysql.getOne({
-            table: "beflyDict",
-            leftJoin: ["beflyDictType ON beflyDict.typeCode = beflyDictType.code"],
+            table: ["beflyDict", "beflyDictType"],
+            leftJoin: ["beflyDict.typeCode beflyDictType.code"],
             fields: ["beflyDict.id", "beflyDict.typeCode", "beflyDict.key", "beflyDict.label", "beflyDict.sort", "beflyDict.remark", "beflyDict.createdAt", "beflyDict.updatedAt", "beflyDictType.name AS typeName"],
             where: { "beflyDict.id": ctx.body.id }
         });

package/apis/dict/list.js

@@ -14,8 +14,8 @@ export default {
     required: [],
     handler: async (befly, ctx) => {
         const result = await befly.mysql.getList({
-            table: "beflyDict",
-            leftJoin: ["beflyDictType ON beflyDict.typeCode = beflyDictType.code"],
+            table: ["beflyDict", "beflyDictType"],
+            leftJoin: ["beflyDict.typeCode beflyDictType.code"],
             fields: ["beflyDict.id", "beflyDict.typeCode", "beflyDict.key", "beflyDict.label", "beflyDict.sort", "beflyDict.remark", "beflyDict.createdAt", "beflyDict.updatedAt", "beflyDictType.name AS typeName"],
             where: {
                 "beflyDict.typeCode": ctx.body.typeCode

package/hooks/permission.js

@@ -1,4 +1,3 @@
-import { CacheKeys } from "../lib/cacheKeys.js";
 // 相对导入
 import { ErrorResponse } from "../utils/response.js";
 import { isValidPositiveInt } from "../utils/is.js";
@@ -50,7 +49,7 @@ export default {
         // apiPath 在 apiHandler 中已统一生成并写入 ctx.apiPath
 
         // 极简方案：每个角色一个 Set，直接判断成员是否存在
-        const hasPermission = await befly.redis.sismember(CacheKeys.roleApis(ctx.roleCode), ctx.apiPath);
+        const hasPermission = await befly.redis.sismember(`role:apis:${ctx.roleCode}`, ctx.apiPath);
 
         if (!hasPermission) {
             ctx.response = ErrorResponse(

package/lib/cacheHelper.js

@@ -3,7 +3,6 @@
  * 负责在服务器启动时缓存接口、菜单和角色权限到 Redis
  */
 
-import { CacheKeys } from "./cacheKeys.js";
 import { Logger } from "./logger.js";
 import { isNonEmptyString, isNullable, isString } from "../utils/is.js";
 
@@ -27,7 +26,7 @@ export class CacheHelper {
             });
 
             // 缓存到 Redis
-            const result = await this.redis.setObject(CacheKeys.apisAll(), apiList.data.lists);
+            const result = await this.redis.setObject("apis:all", apiList.data.lists);
 
             if (result === null) {
                 Logger.warn("⚠️ 接口缓存失败", {
@@ -57,7 +56,7 @@ export class CacheHelper {
             });
 
             // 缓存到 Redis
-            const result = await this.redis.setObject(CacheKeys.menusAll(), menus.data.lists);
+            const result = await this.redis.setObject("menus:all", menus.data.lists);
 
             if (result === null) {
                 Logger.warn("⚠️ 菜单缓存失败", {
@@ -103,7 +102,7 @@ export class CacheHelper {
             }
 
             // 清理所有角色的缓存 key（保证幂等）
-            const roleKeys = roleCodes.map((code) => CacheKeys.roleApis(code));
+            const roleKeys = roleCodes.map((code) => `role:apis:${code}`);
             await this.redis.delBatch(roleKeys);
 
             // 批量写入新缓存（只写入非空权限）
@@ -114,7 +113,7 @@ export class CacheHelper {
                 const members = Array.from(new Set(apiPaths)).sort();
 
                 if (members.length > 0) {
-                    items.push({ key: CacheKeys.roleApis(roleCode), members: members });
+                    items.push({ key: `role:apis:${roleCode}`, members: members });
                 }
             }
 
@@ -161,7 +160,7 @@ export class CacheHelper {
             }
 
             // 清理所有角色的缓存 key（保证幂等）
-            const roleKeys = roleCodes.map((code) => CacheKeys.roleMenus(code));
+            const roleKeys = roleCodes.map((code) => `role:menus:${code}`);
             await this.redis.delBatch(roleKeys);
 
             // 批量写入新缓存（只写入非空权限）
@@ -172,7 +171,7 @@ export class CacheHelper {
                 const members = Array.from(new Set(menuPaths)).sort();
 
                 if (members.length > 0) {
-                    items.push({ key: CacheKeys.roleMenus(roleCode), members: members });
+                    items.push({ key: `role:menus:${roleCode}`, members: members });
                 }
             }
 
@@ -213,7 +212,7 @@ export class CacheHelper {
             });
         }
 
-        const roleKey = CacheKeys.roleApis(roleCode);
+        const roleKey = `role:apis:${roleCode}`;
 
         // 空数组短路：保证清理残留
         if (apiPaths.length === 0) {
@@ -252,7 +251,7 @@ export class CacheHelper {
             });
         }
 
-        const roleKey = CacheKeys.roleMenus(roleCode);
+        const roleKey = `role:menus:${roleCode}`;
 
         // 空数组短路：保证清理残留
         if (menuPaths.length === 0) {
@@ -291,7 +290,7 @@ export class CacheHelper {
      */
     async getApis() {
         try {
-            const apis = await this.redis.getObject(CacheKeys.apisAll());
+            const apis = await this.redis.getObject("apis:all");
             return apis || [];
         } catch (error) {
             Logger.error("获取接口缓存失败", error);
@@ -310,7 +309,7 @@ export class CacheHelper {
      */
     async getMenus() {
         try {
-            const menus = await this.redis.getObject(CacheKeys.menusAll());
+            const menus = await this.redis.getObject("menus:all");
             return menus || [];
         } catch (error) {
             Logger.error("获取菜单缓存失败", error);
@@ -330,7 +329,7 @@ export class CacheHelper {
      */
     async getRoleApis(roleCode) {
         try {
-            const permissions = await this.redis.smembers(CacheKeys.roleApis(roleCode));
+            const permissions = await this.redis.smembers(`role:apis:${roleCode}`);
             return permissions || [];
         } catch (error) {
             Logger.error("获取角色权限缓存失败", error, { roleCode: roleCode });
@@ -351,7 +350,7 @@ export class CacheHelper {
      */
     async getRoleMenus(roleCode) {
         try {
-            const permissions = await this.redis.smembers(CacheKeys.roleMenus(roleCode));
+            const permissions = await this.redis.smembers(`role:menus:${roleCode}`);
             return permissions || [];
         } catch (error) {
             Logger.error("获取角色菜单权限缓存失败", error, { roleCode: roleCode });
@@ -375,7 +374,7 @@ export class CacheHelper {
         try {
             if (isNullable(apiPath)) return false;
             const value = isString(apiPath) ? apiPath : String(apiPath);
-            return await this.redis.sismember(CacheKeys.roleApis(roleCode), value);
+            return await this.redis.sismember(`role:apis:${roleCode}`, value);
         } catch (error) {
             Logger.error("检查角色权限失败", error, { roleCode: roleCode });
             throw new Error("检查角色权限失败", {
@@ -398,7 +397,7 @@ export class CacheHelper {
         try {
             if (isNullable(menuPath)) return false;
             const value = isString(menuPath) ? menuPath : String(menuPath);
-            return await this.redis.sismember(CacheKeys.roleMenus(roleCode), value);
+            return await this.redis.sismember(`role:menus:${roleCode}`, value);
         } catch (error) {
             Logger.error("检查角色菜单权限失败", error, { roleCode: roleCode });
             throw new Error("检查角色菜单权限失败", {
@@ -418,7 +417,7 @@ export class CacheHelper {
      */
     async deleteRoleApis(roleCode) {
         try {
-            const result = await this.redis.del(CacheKeys.roleApis(roleCode));
+            const result = await this.redis.del(`role:apis:${roleCode}`);
             if (result > 0) {
                 Logger.info(`✅ 已删除角色 ${roleCode} 的权限缓存`);
                 return true;
@@ -443,7 +442,7 @@ export class CacheHelper {
      */
     async deleteRoleMenus(roleCode) {
         try {
-            const result = await this.redis.del(CacheKeys.roleMenus(roleCode));
+            const result = await this.redis.del(`role:menus:${roleCode}`);
             if (result > 0) {
                 Logger.info(`✅ 已删除角色 ${roleCode} 的菜单权限缓存`);
                 return true;

package/lib/dbHelper/builders.js

@@ -156,6 +156,29 @@ export async function fieldsToSnake(table, fields, getTableColumns) {
 }
 
 export function orderByToSnake(orderBy) {
+    return normalizeOrderBy(orderBy, (field) => snakeCase(field));
+}
+
+function normalizeQualifierField(field) {
+    const parts = field.split(".");
+    if (parts.length === 1) {
+        return snakeCase(field);
+    }
+
+    const fieldName = parts[parts.length - 1].trim();
+    const qualifier = parts
+        .slice(0, parts.length - 1)
+        .map((item) => snakeCase(item.trim()))
+        .join(".");
+
+    if (fieldName === "*") {
+        return `${qualifier}.*`;
+    }
+
+    return `${qualifier}.${snakeCase(fieldName)}`;
+}
+
+function normalizeOrderBy(orderBy, mapField) {
     if (!orderBy || !Array.isArray(orderBy)) {
         return orderBy;
     }
@@ -170,14 +193,35 @@ export function orderByToSnake(orderBy) {
             return item;
         }
 
-        const field = parts[0];
-        const direction = parts[1];
-        if (!isString(field) || !isString(direction)) {
-            return item;
+        return `${mapField(parts[0].trim())}#${parts[1].trim()}`;
+    });
+}
+
+function mapWhereKeys(where, mapKey) {
+    if (!where || typeof where !== "object") {
+        return where;
+    }
+    if (Array.isArray(where)) {
+        return where.map((item) => mapWhereKeys(item, mapKey));
+    }
+
+    const result = {};
+    for (const [key, value] of Object.entries(where)) {
+        if (key === "$or" || key === "$and") {
+            result[key] = Array.isArray(value) ? value.map((item) => mapWhereKeys(item, mapKey)) : [];
+            continue;
         }
 
-        return `${snakeCase(field.trim())}#${direction.trim()}`;
-    });
+        const normalizedKey = mapKey(key);
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            result[normalizedKey] = mapWhereKeys(value, mapKey);
+            continue;
+        }
+
+        result[normalizedKey] = value;
+    }
+
+    return result;
 }
 
 export function processJoinField(field) {
@@ -196,36 +240,7 @@ export function processJoinField(field) {
         return `${processJoinField(fieldPart.trim())} AS ${aliasPart.trim()}`;
     }
 
-    if (field.includes(".")) {
-        const parts = field.split(".");
-        if (parts.length < 2) {
-            return snakeCase(field);
-        }
-        if (parts.some((p) => !isNonEmptyString(p))) {
-            return field;
-        }
-
-        const fieldName = parts[parts.length - 1];
-        const tableName = parts.slice(0, parts.length - 1).join(".");
-        if (!isString(fieldName) || !isString(tableName)) {
-            return snakeCase(field);
-        }
-
-        const normalizedTableName = tableName
-            .split(".")
-            .map((item) => {
-                const trimmed = item.trim();
-                if (!trimmed) {
-                    return trimmed;
-                }
-                return /[A-Z]/.test(trimmed) ? snakeCase(trimmed) : trimmed;
-            })
-            .join(".");
-
-        return `${normalizedTableName}.${snakeCase(fieldName)}`;
-    }
-
-    return snakeCase(field);
+    return normalizeQualifierField(field);
 }
 
 function processJoinWhereKey(key) {
@@ -239,136 +254,26 @@ function processJoinWhereKey(key) {
         const fieldPart = key.substring(0, lastDollarIndex);
         const operator = key.substring(lastDollarIndex);
 
-        if (fieldPart.includes(".")) {
-            const parts = fieldPart.split(".");
-            if (parts.length < 2) {
-                return `${snakeCase(fieldPart)}${operator}`;
-            }
-            if (parts.some((p) => !isNonEmptyString(p))) {
-                return `${snakeCase(fieldPart)}${operator}`;
-            }
-
-            const fieldName = parts[parts.length - 1];
-            const tableName = parts.slice(0, parts.length - 1).join(".");
-            if (!isString(fieldName) || !isString(tableName)) {
-                return `${snakeCase(fieldPart)}${operator}`;
-            }
-
-            const normalizedTableName = tableName
-                .split(".")
-                .map((item) => {
-                    const trimmed = item.trim();
-                    if (!trimmed) {
-                        return trimmed;
-                    }
-                    return /[A-Z]/.test(trimmed) ? snakeCase(trimmed) : trimmed;
-                })
-                .join(".");
-            return `${normalizedTableName}.${snakeCase(fieldName)}${operator}`;
-        }
-
-        return `${snakeCase(fieldPart)}${operator}`;
-    }
-
-    if (key.includes(".")) {
-        const parts = key.split(".");
-        if (parts.length < 2) {
-            return snakeCase(key);
-        }
-        if (parts.some((p) => !isNonEmptyString(p))) {
-            return snakeCase(key);
-        }
-
-        const fieldName = parts[parts.length - 1];
-        const tableName = parts.slice(0, parts.length - 1).join(".");
-        if (!isString(fieldName) || !isString(tableName)) {
-            return snakeCase(key);
-        }
-
-        const normalizedTableName = tableName
-            .split(".")
-            .map((item) => {
-                const trimmed = item.trim();
-                if (!trimmed) {
-                    return trimmed;
-                }
-                return /[A-Z]/.test(trimmed) ? snakeCase(trimmed) : trimmed;
-            })
-            .join(".");
-        return `${normalizedTableName}.${snakeCase(fieldName)}`;
+        return `${normalizeQualifierField(fieldPart)}${operator}`;
     }
 
-    return snakeCase(key);
+    return normalizeQualifierField(key);
 }
 
 export function processJoinWhere(where) {
-    if (!where || typeof where !== "object") {
-        return where;
-    }
-    if (Array.isArray(where)) {
-        return where.map((item) => processJoinWhere(item));
-    }
-
-    const result = {};
-    for (const [key, value] of Object.entries(where)) {
-        const newKey = processJoinWhereKey(key);
-        if (key === "$or" || key === "$and") {
-            result[newKey] = Array.isArray(value) ? value.map((item) => processJoinWhere(item)) : [];
-        } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-            result[newKey] = processJoinWhere(value);
-        } else {
-            result[newKey] = value;
-        }
-    }
-
-    return result;
+    return mapWhereKeys(where, processJoinWhereKey);
 }
 
 export function processJoinOrderBy(orderBy) {
-    if (!orderBy || !Array.isArray(orderBy)) {
-        return orderBy;
-    }
-
-    return orderBy.map((item) => {
-        if (!isString(item) || !item.includes("#")) {
-            return item;
-        }
-
-        const parts = item.split("#");
-        if (parts.length !== 2) {
-            return item;
-        }
-
-        const field = parts[0];
-        const direction = parts[1];
-        if (!isString(field) || !isString(direction)) {
-            return item;
-        }
-
-        return `${processJoinField(field.trim())}#${direction.trim()}`;
-    });
+    return normalizeOrderBy(orderBy, processJoinField);
 }
 
-export function parseLeftJoinItem(joinItem) {
-    if (!isString(joinItem)) {
-        return null;
-    }
-
-    const parts = joinItem.split(/\s+ON\s+/i);
-    if (parts.length !== 2) {
-        return null;
-    }
-
-    const table = parts[0]?.trim();
-    const on = parts[1]?.trim();
-    if (!isNonEmptyString(table) || !isNonEmptyString(on)) {
-        return null;
-    }
-
+export function parseLeftJoinItem(joinTable, joinItem) {
+    const parts = joinItem.split(" ");
     return {
         type: "left",
-        table: normalizeTableRef(table),
-        on: processJoinOn(on)
+        table: normalizeTableRef(joinTable),
+        on: processJoinOn(`${parts[0]} = ${parts[1]}`)
     };
 }
 
@@ -453,38 +358,17 @@ export function addDefaultStateFilter(where = {}, table, hasLeftJoin = false, be
 }
 
 export function whereKeysToSnake(where) {
-    if (!where || typeof where !== "object") {
-        return where;
-    }
-    if (Array.isArray(where)) {
-        return where.map((item) => whereKeysToSnake(item));
-    }
-
-    const result = {};
-    for (const [key, value] of Object.entries(where)) {
-        if (key === "$or" || key === "$and") {
-            result[key] = Array.isArray(value) ? value.map((item) => whereKeysToSnake(item)) : [];
-            continue;
-        }
-
+    return mapWhereKeys(where, (key) => {
         assertNoExprField(key);
         if (key.includes("$")) {
             const lastDollarIndex = key.lastIndexOf("$");
             const fieldName = key.substring(0, lastDollarIndex);
             const operator = key.substring(lastDollarIndex);
-            result[snakeCase(fieldName) + operator] = value;
-            continue;
+            return `${snakeCase(fieldName)}${operator}`;
         }
 
-        const snakeKey = snakeCase(key);
-        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-            result[snakeKey] = whereKeysToSnake(value);
-        } else {
-            result[snakeKey] = value;
-        }
-    }
-
-    return result;
+        return snakeCase(key);
+    });
 }
 
 function serializeArrayFields(data) {
@@ -537,6 +421,19 @@ function cleanAndSnakeAndSerializeWriteData(data, excludeValues = [null, undefin
     return serializeArrayFields(snakeData);
 }
 
+function cloneRecord(record) {
+    const result = {};
+    for (const [key, value] of Object.entries(record)) {
+        result[key] = value;
+    }
+    return result;
+}
+
+function prepareWriteUserData(data, allowState) {
+    const serializedData = cleanAndSnakeAndSerializeWriteData(data);
+    return stripSystemFieldsForWrite(serializedData, { allowState: allowState });
+}
+
 function stripSystemFieldsForWrite(data, options) {
     const result = {};
     for (const [key, value] of Object.entries(data)) {
@@ -551,13 +448,7 @@ function stripSystemFieldsForWrite(data, options) {
 }
 
 export function buildInsertRow(options) {
-    const serializedData = cleanAndSnakeAndSerializeWriteData(options.data);
-    const userData = stripSystemFieldsForWrite(serializedData, { allowState: false });
-
-    const result = {};
-    for (const [key, value] of Object.entries(userData)) {
-        result[key] = value;
-    }
+    const result = cloneRecord(prepareWriteUserData(options.data, false));
 
     if (options.beflyMode === "auto") {
         validateTimeIdValue(options.id);
@@ -573,13 +464,7 @@ export function buildInsertRow(options) {
 }
 
 export function buildUpdateRow(options) {
-    const serializedData = cleanAndSnakeAndSerializeWriteData(options.data);
-    const userData = stripSystemFieldsForWrite(serializedData, { allowState: options.allowState });
-
-    const result = {};
-    for (const [key, value] of Object.entries(userData)) {
-        result[key] = value;
-    }
+    const result = cloneRecord(prepareWriteUserData(options.data, options.allowState));
     if (options.beflyMode !== "manual") {
         result["updated_at"] = options.now;
     }
@@ -587,8 +472,7 @@ export function buildUpdateRow(options) {
 }
 
 export function buildPartialUpdateData(options) {
-    const serializedData = cleanAndSnakeAndSerializeWriteData(options.data);
-    return stripSystemFieldsForWrite(serializedData, { allowState: options.allowState });
+    return prepareWriteUserData(options.data, options.allowState);
 }
 
 export const builderMethods = {
@@ -649,15 +533,11 @@ export const builderMethods = {
 
     normalizeLeftJoinOptions(options, cleanWhere) {
         const processedFields = (options.fields || []).map((field) => processJoinField(field));
-        const normalizedTableRef = normalizeTableRef(options.table);
-        const mainQualifier = getJoinMainQualifier(options.table);
-        const leftJoins = [];
-        for (const joinItem of options.leftJoin || []) {
-            const parsedJoin = parseLeftJoinItem(joinItem);
-            if (parsedJoin) {
-                leftJoins.push(parsedJoin);
-            }
-        }
+        const mainTableRef = options.table[0];
+        const joinTableRefs = options.table.slice(1);
+        const normalizedTableRef = normalizeTableRef(mainTableRef);
+        const mainQualifier = getJoinMainQualifier(mainTableRef);
+        const leftJoins = options.leftJoin.map((joinItem, index) => parseLeftJoinItem(joinTableRefs[index], joinItem));
 
         return {
             table: normalizedTableRef,
@@ -672,7 +552,8 @@ export const builderMethods = {
     },
 
     async normalizeSingleTableOptions(options, cleanWhere) {
-        const snakeTable = snakeCase(options.table);
+        const tableRef = Array.isArray(options.table) ? options.table[0] : options.table;
+        const snakeTable = snakeCase(tableRef);
         const processedFields = await fieldsToSnake(snakeTable, options.fields || [], this.getTableColumns.bind(this));
 
         return {
@@ -680,7 +561,7 @@ export const builderMethods = {
             tableQualifier: snakeTable,
             fields: processedFields,
             where: whereKeysToSnake(cleanWhere),
-            leftJoins: undefined,
+            leftJoins: [],
             orderBy: orderByToSnake(options.orderBy || []),
             page: options.page || 1,
             limit: options.limit || 10
@@ -750,7 +631,7 @@ export const builderMethods = {
     async prepareQueryOptions(options, label = "queryOptions") {
         validateQueryOptions(options, label);
         const cleanWhere = clearDeep(options.where || {});
-        const hasLeftJoin = options.leftJoin && options.leftJoin.length > 0;
+        const hasLeftJoin = Array.isArray(options.leftJoin) && options.leftJoin.length > 0;
 
         if (hasLeftJoin) {
             return this.normalizeLeftJoinOptions(options, cleanWhere);
@@ -759,6 +640,14 @@ export const builderMethods = {
         return await this.normalizeSingleTableOptions(options, cleanWhere);
     },
 
+    async prepareReadContext(options, label = "queryOptions") {
+        const prepared = await this.prepareQueryOptions(options, label);
+        return {
+            prepared: prepared,
+            whereFiltered: addDefaultStateFilter(prepared.where, prepared.tableQualifier, prepared.leftJoins.length > 0, this.beflyMode)
+        };
+    },
+
     applyLeftJoins(builder, leftJoins) {
         if (!leftJoins || leftJoins.length === 0) return;