befly 3.76.7 → 3.77.1

package/libs/logger/sanitize.js

@@ -44,17 +44,23 @@ function isSensitiveKey(key, matcher) {
     return matcher.contains.some((part) => lower.includes(part));
 }
 
+// 长字符串截断：超过阈值保留前段并追加统一可 grep 的标记
+function truncateText(text, limit) {
+    if (text.length <= limit) return text;
+    return `${text.slice(0, limit)}[截断，原 ${text.length} 字符]`;
+}
+
 function sanitizeError(error, options, state, depth, visited) {
     if (visited.has(error)) return "[Circular]";
     visited.add(error);
 
     const output = {
         name: error.name || "Error",
-        message: error.message || "",
-        chain: errorChainSummary(error)
+        message: truncateText(error.message || "", options.truncateStringLength),
+        chain: truncateText(errorChainSummary(error), options.truncateStringLength)
     };
 
-    if (typeof error.stack === "string") output.stack = error.stack;
+    if (typeof error.stack === "string") output.stack = truncateText(error.stack, options.truncateStringLength);
     if (error.cause !== undefined) output.cause = sanitizeValue(error.cause, options, state, depth + 1, visited);
 
     for (const key of Object.keys(error)) {
@@ -65,10 +71,11 @@ function sanitizeError(error, options, state, depth, visited) {
     return output;
 }
 
+// 降级预览：整体转字符串并按预览长度截断（深度/节点数超限、非普通对象的统一出口）
 function stringifyPreview(value, options) {
     const seen = new WeakSet();
     try {
-        return JSON.stringify(value, (key, item) => {
+        const text = JSON.stringify(value, (key, item) => {
             if (key && isSensitiveKey(key, options.sensitiveKeyMatcher)) return "[MASKED]";
             if (typeof item === "bigint") return String(item);
             if (item && typeof item === "object") {
@@ -77,17 +84,41 @@ function stringifyPreview(value, options) {
             }
             return item;
         });
+        return truncateText(text, options.truncatePreviewLength);
     } catch {
         try {
-            return String(value);
+            return truncateText(String(value), options.truncatePreviewLength);
         } catch {
-            return "[Unserializable]";
+            return "[无法序列化]";
         }
     }
 }
 
+function sanitizeArray(value, options, state, depth, visited) {
+    const limit = options.truncateArrayLength;
+    const items = value.slice(0, limit).map((item) => sanitizeValue(item, options, state, depth + 1, visited));
+    if (value.length > limit) {
+        items.push(`[截断，显示 ${limit}/共 ${value.length} 项]`);
+    }
+    return items;
+}
+
+function sanitizeObject(value, options, state, depth, visited) {
+    const entries = Object.entries(value);
+    const shown = entries.slice(0, options.sanitizeObjectKeys);
+    const output = {};
+    for (const [key, item] of shown) {
+        output[key] = isSensitiveKey(key, options.sensitiveKeyMatcher) ? "[MASKED]" : sanitizeValue(item, options, state, depth + 1, visited);
+    }
+    if (entries.length > shown.length) {
+        output.__truncated__ = `已省略 ${entries.length - shown.length} 个键`;
+    }
+    return output;
+}
+
 function sanitizeValue(value, options, state, depth, visited) {
-    if (value === null || value === undefined || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+    if (value === null || value === undefined || typeof value === "number" || typeof value === "boolean") return value;
+    if (typeof value === "string") return truncateText(value, options.truncateStringLength);
     if (typeof value === "bigint") return String(value);
     if (value instanceof Error) return sanitizeError(value, options, state, depth, visited);
 
@@ -98,14 +129,8 @@ function sanitizeValue(value, options, state, depth, visited) {
     visited.add(value);
     state.nodes += 1;
 
-    if (Array.isArray(value)) return value.map((item) => sanitizeValue(item, options, state, depth + 1, visited));
-
-    const output = {};
-    const entries = Object.entries(value).slice(0, options.sanitizeObjectKeys);
-    for (const [key, item] of entries) {
-        output[key] = isSensitiveKey(key, options.sensitiveKeyMatcher) ? "[MASKED]" : sanitizeValue(item, options, state, depth + 1, visited);
-    }
-    return output;
+    if (Array.isArray(value)) return sanitizeArray(value, options, state, depth, visited);
+    return sanitizeObject(value, options, state, depth, visited);
 }
 
 export function sanitizeLogRecord(record, options) {

package/libs/memCache.js

@@ -0,0 +1,53 @@
+/**
+ * 进程级 TTL 缓存：存放跨请求复用的短时效数据（角色权限版本号、系统资源快照、统计项目校验等）。
+ *
+ * 边界约定：
+ * - 仅单进程内有效，多实例部署时各进程独立缓存
+ * - 适合可容忍秒级陈旧、读取代价高的数据；不适合需要强一致的数据
+ * - 无常驻定时器，过期条目在读写时惰性清理，写入超过上限时全量清淤，无内存泄漏
+ */
+const MAX_ENTRIES = 1000;
+
+const store = new Map();
+
+function pruneExpired(now) {
+    for (const [key, entry] of store) {
+        if (entry.expireAt <= now) {
+            store.delete(key);
+        }
+    }
+}
+
+export function memGet(key) {
+    const entry = store.get(key);
+    if (!entry) return;
+    if (entry.expireAt <= Date.now()) {
+        store.delete(key);
+        return;
+    }
+    return entry.value;
+}
+
+export function memSet(key, value, ttlMs) {
+    if (store.size >= MAX_ENTRIES) {
+        pruneExpired(Date.now());
+    }
+    store.set(key, {
+        value: value,
+        expireAt: Date.now() + ttlMs
+    });
+}
+
+export function memDelete(key) {
+    store.delete(key);
+}
+
+export async function memRemember(key, ttlMs, loader) {
+    const cached = memGet(key);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const value = await loader();
+    memSet(key, value, ttlMs);
+    return value;
+}

package/libs/mysql/dbHelper.js

@@ -78,39 +78,27 @@ function getExecuteErrorMessage(error) {
         return String(error);
     }
 
-    const message = typeof error.message === "string" && error.message.trim().length > 0 ? error.message.trim() : typeof error.sqlMessage === "string" && error.sqlMessage.trim().length > 0 ? error.sqlMessage.trim() : "";
-    const detail = {};
+    const message = [error.message, error.sqlMessage].find((text) => typeof text === "string" && text.trim().length > 0)?.trim() || "";
+    const detail = {
+        code: error.code,
+        errno: error.errno,
+        sqlState: error.sqlState,
+        sqlMessage: error.sqlMessage,
+        detail: error.detail
+    };
 
-    if (typeof error.code === "string" && error.code.trim().length > 0) {
-        detail.code = error.code;
-    }
-    if (typeof error.errno === "number") {
-        detail.errno = error.errno;
-    }
-    if (typeof error.sqlState === "string" && error.sqlState.trim().length > 0) {
-        detail.sqlState = error.sqlState;
-    }
-    if (typeof error.sqlMessage === "string" && error.sqlMessage.trim().length > 0) {
-        detail.sqlMessage = error.sqlMessage;
-    }
-    if (typeof error.detail === "string" && error.detail.trim().length > 0) {
-        detail.detail = error.detail;
+    for (const key of Object.keys(detail)) {
+        const value = detail[key];
+        if (value === undefined || (typeof value === "string" && value.trim().length === 0)) {
+            delete detail[key];
+        }
     }
 
     const detailText = Object.keys(detail).length > 0 ? safeStringify(detail) : safeStringify(error);
-    if (message && detailText && detailText !== "{}") {
+    if (message && detailText !== "{}") {
         return `${message} | ${detailText}`;
     }
-    if (message) {
-        return message;
-    }
-    return detailText;
-}
-
-function assertGeneratedBatchId(id, table, index) {
-    if (typeof id !== "number") {
-        throw createError(`批量插入生成 ID 失败：ids[${index}] 不是 number (table: ${table})`, { code: "runtime" });
-    }
+    return message || detailText;
 }
 
 function assertTimeIdValue(id) {
@@ -168,14 +156,6 @@ function assertWriteFieldsDefined(tableInfo, data, table, label) {
     assertWriteFieldNamesDefined(tableInfo, Object.keys(data), table, label);
 }
 
-function assertNoUndefinedInRecord(row, label) {
-    for (const [key, value] of Object.entries(row)) {
-        if (value === undefined) {
-            throw validationError(`${label} 存在 undefined 字段值 (field: ${key})`);
-        }
-    }
-}
-
 function assertBatchInsertRowsConsistent(rows, options) {
     if (!Array.isArray(rows)) {
         throw validationError("批量插入 rows 必须是数组");
@@ -338,7 +318,8 @@ class DbHelper {
             const duration = Date.now() - startTime;
             const msg = getExecuteErrorMessage(executeError);
 
-            if (retryOnConnectionClosed && this.isConnectionClosedError(executeError, msg)) {
+            // 事务内连接已中断时重发单条语句可能造成半提交，直接抛出由事务回滚
+            if (retryOnConnectionClosed && !this.isTransaction && this.isConnectionClosedError(executeError, msg)) {
                 return this.execute(sql, params, false);
             }
 
@@ -395,7 +376,8 @@ class DbHelper {
     }
 
     async fetchCount(prepared, alias) {
-        const builder = this.createSqlBuilder().selectRaw(alias).from(prepared.table).where(prepared.where);
+        const countExpr = this.resolveCountExpr(prepared, alias);
+        const builder = this.createSqlBuilder().selectRaw(countExpr).from(prepared.table).where(prepared.where);
         this.applyLeftJoins(builder, prepared.leftJoins);
         const result = builder.toSelectSql();
         const executeRes = await this.execute(result.sql, result.params);
@@ -408,6 +390,17 @@ class DbHelper {
         };
     }
 
+    resolveCountExpr(prepared, alias) {
+        if (!prepared.leftJoins || prepared.leftJoins.length === 0) {
+            return alias;
+        }
+        // leftJoin 一对多时 COUNT(*) 统计的是 join 后行数，按主表主键去重保证 total 与主表条数一致
+        const parts = prepared.table.trim().split(/\s+/);
+        const qualifier = parts.length > 1 ? parts.at(-1) : parts[0].split(".").pop();
+        const primary = snakeCase(this.getTableModel(prepared.codeTable).primary || "id");
+        return `COUNT(DISTINCT ${quoteIdentMySql(qualifier)}.${quoteIdentMySql(primary)}) as total`;
+    }
+
     normalizeRowData(row, tableInfo = {}) {
         if (!row) {
             return {};
@@ -512,38 +505,16 @@ class DbHelper {
             };
         }
 
-        const ids = [];
-        try {
-            for (let i = 0; i < dataList.length; i++) {
-                ids.push(genId());
-            }
-        } catch (error) {
-            if (dataList.length === 1) {
-                throw createError(`生成 ID 失败 (table: ${table})`, {
-                    cause: error,
-                    code: "runtime",
-                    subsystem: "db",
-                    operation: "genId",
-                    table: table
-                });
-            }
-            throw error;
-        }
-
-        const processedList = dataList.map((data, index) => {
-            const id = ids[index];
-            if (dataList.length > 1) {
-                assertGeneratedBatchId(id, snakeTable, index);
-            }
-
-            return this.buildInsertRow({
+        const ids = dataList.map(() => genId());
+        const processedList = dataList.map((data, index) =>
+            this.buildInsertRow({
                 data: data,
-                id: id,
+                id: ids[index],
                 now: now,
                 beflyMode: tableMode,
                 tableInfo: tableInfo
-            });
-        });
+            })
+        );
 
         return {
             ids: ids,
@@ -715,7 +686,9 @@ class DbHelper {
         return {
             data: {
                 lists: lists,
-                total: total
+                total: total,
+                // 达到硬上限被截断时显式告知调用方，避免拿到不完整数据无感知
+                truncated: result.length >= MAX_LIMIT
             },
             sql: {
                 count: countResult.sql,
@@ -743,12 +716,8 @@ class DbHelper {
         const now = Date.now();
         const insertRows = await this.createInsertRows(table, snakeTable, [data], now);
         const processed = insertRows.processedList[0];
-
-        assertWriteDataHasFields(processed, "插入数据必须至少有一个字段", snakeTable);
         assertWriteFieldsDefined(tableInfo, processed, table, "insData.data");
 
-        assertNoUndefinedInRecord(processed, `insData 插入数据 (table: ${snakeTable})`);
-
         const builder = this.createSqlBuilder();
         const { sql, params } = builder.toInsertSql(snakeTable, processed);
         const executeRes = await this.execute(sql, params);
@@ -909,7 +878,6 @@ class DbHelper {
             beflyMode: this.getTableMode(parsed.table),
             tableInfo: tableInfo
         });
-        assertWriteDataHasFields(processed, "更新数据必须至少有一个字段", parsed.snakeTable);
         assertWriteFieldsDefined(tableInfo, processed, parsed.table, "updData.data");
         const builder = this.createSqlBuilder().where(parsed.where);
         const { sql, params } = builder.toUpdateSql(parsed.snakeTable, processed);

package/libs/mysql/dbParse.js

@@ -516,7 +516,11 @@ function applyDefaultStateFilter(where = {}, table, hasLeftJoin = false, beflyMo
         return where;
     }
 
-    const hasStateCondition = Object.keys(where).some((key) => key.startsWith("state") || key.includes(".state"));
+    // 剥离 $op / $or 后缀后精确匹配，避免 stateCode 等业务字段误判为已有 state 条件
+    const hasStateCondition = Object.keys(where).some((key) => {
+        const field = key.split("$")[0];
+        return field === "state" || field.endsWith(".state");
+    });
     if (hasStateCondition) {
         return where;
     }

package/libs/mysql/sql/sqlBuilder.js

@@ -26,6 +26,12 @@
 
 import { escapeField, escapeTable, resolveQuoteIdent } from "./identifier.js";
 
+function assertSafeLimit(value) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`LIMIT/OFFSET 必须是非负整数 (value: ${String(value)})`);
+    }
+}
+
 /**
  * SQL 构建器类
  */
@@ -290,8 +296,11 @@ export class SqlBuilder {
         }
 
         if (this.queryModel.limit !== null) {
+            // LIMIT/OFFSET 直接内插，必须在此断言整型，不信任调用方已校验
+            assertSafeLimit(this.queryModel.limit);
             sql += ` LIMIT ${this.queryModel.limit}`;
             if (this.queryModel.offset !== null && this.queryModel.offset !== undefined) {
+                assertSafeLimit(this.queryModel.offset);
                 sql += ` OFFSET ${this.queryModel.offset}`;
             }
         }

package/libs/redis/redis.js

@@ -14,7 +14,9 @@ function buildRedisUrl(config) {
 }
 
 /**
- * Bun RedisClient 高层操作封装。除 ping 外，操作失败记录日志并返回约定 fallback。
+ * Bun RedisClient 高层操作封装。错误策略分级：
+ * - 读操作失败记录日志并返回约定 fallback，权限等判断按无数据处理（fail-closed）。
+ * - 写操作与计数器失败记录日志后抛出，由调用方决定降级策略，避免故障被静默吞掉。
  */
 export class RedisHelper {
     constructor(options) {
@@ -31,16 +33,21 @@ export class RedisHelper {
         }
     }
 
+    async strictCall(label, operation) {
+        try {
+            return await operation();
+        } catch (error) {
+            Logger.error(`Redis ${label} 错误`, error);
+            throw error;
+        }
+    }
+
     async setObject(key, obj, ttl = null) {
-        return this.safeCall(
-            "setObject",
-            async () => {
-                const data = JSON.stringify(obj);
-                const pkey = `${this.prefix}${key}`;
-                return ttl ? this.client.setex(pkey, ttl, data) : this.client.set(pkey, data);
-            },
-            null
-        );
+        return this.strictCall("setObject", () => {
+            const data = JSON.stringify(obj);
+            const pkey = `${this.prefix}${key}`;
+            return ttl ? this.client.setex(pkey, ttl, data) : this.client.set(pkey, data);
+        });
     }
 
     async getObject(key) {
@@ -55,20 +62,16 @@ export class RedisHelper {
     }
 
     async delObject(key) {
-        return this.safeCall("delObject", async () => {
+        return this.strictCall("delObject", async () => {
             await this.client.del(`${this.prefix}${key}`);
         });
     }
 
     async setString(key, value, ttl = null) {
-        return this.safeCall(
-            "setString",
-            async () => {
-                const pkey = `${this.prefix}${key}`;
-                return ttl ? this.client.setex(pkey, ttl, value) : this.client.set(pkey, value);
-            },
-            null
-        );
+        return this.strictCall("setString", () => {
+            const pkey = `${this.prefix}${key}`;
+            return ttl ? this.client.setex(pkey, ttl, value) : this.client.set(pkey, value);
+        });
     }
 
     async getString(key) {
@@ -84,20 +87,16 @@ export class RedisHelper {
     }
 
     async incrWithExpire(key, seconds) {
-        return this.safeCall(
-            "incrWithExpire",
-            async () => {
-                const pkey = `${this.prefix}${key}`;
-                const result = await this.client.incr(pkey);
-                if (result === 1) await this.client.expire(pkey, seconds);
-                return result;
-            },
-            0
-        );
+        // SET NX EX 先建键并带 TTL，再 INCR，保证计数键自创建起必有过期时间
+        return this.strictCall("incrWithExpire", async () => {
+            const pkey = `${this.prefix}${key}`;
+            await this.client.send("SET", [pkey, "0", "EX", String(seconds), "NX"]);
+            return this.client.incr(pkey);
+        });
     }
 
     async expire(key, seconds) {
-        return this.safeCall("expire", () => this.client.expire(`${this.prefix}${key}`, seconds), 0);
+        return this.strictCall("expire", () => this.client.expire(`${this.prefix}${key}`, seconds));
     }
 
     async ttl(key) {
@@ -105,14 +104,10 @@ export class RedisHelper {
     }
 
     async sadd(key, members) {
-        return this.safeCall(
-            "sadd",
-            async () => {
-                if (members.length === 0) return 0;
-                return this.client.sadd(`${this.prefix}${key}`, ...members);
-            },
-            0
-        );
+        return this.strictCall("sadd", async () => {
+            if (members.length === 0) return 0;
+            return this.client.sadd(`${this.prefix}${key}`, ...members);
+        });
     }
 
     async sismember(key, member) {
@@ -128,31 +123,23 @@ export class RedisHelper {
     }
 
     async saddBatch(items) {
-        return this.safeCall(
-            "saddBatch",
-            async () => {
-                if (items.length === 0) return 0;
-                const results = await Promise.all(items.map((item) => this.sadd(item.key, item.members)));
-                return results.reduce((sum, count) => sum + count, 0);
-            },
-            0
-        );
+        return this.strictCall("saddBatch", async () => {
+            if (items.length === 0) return 0;
+            const results = await Promise.all(items.map((item) => this.sadd(item.key, item.members)));
+            return results.reduce((sum, count) => sum + count, 0);
+        });
     }
 
     async del(key) {
-        return this.safeCall("del", () => this.client.del(`${this.prefix}${key}`), 0);
+        return this.strictCall("del", () => this.client.del(`${this.prefix}${key}`));
     }
 
     async delBatch(keys) {
-        return this.safeCall(
-            "delBatch",
-            async () => {
-                if (keys.length === 0) return 0;
-                const results = await Promise.all(keys.map((key) => this.client.del(`${this.prefix}${key}`)));
-                return results.reduce((sum, count) => sum + count, 0);
-            },
-            0
-        );
+        return this.strictCall("delBatch", async () => {
+            if (keys.length === 0) return 0;
+            const results = await Promise.all(keys.map((key) => this.client.del(`${this.prefix}${key}`)));
+            return results.reduce((sum, count) => sum + count, 0);
+        });
     }
 
     async info(section) {

package/libs/smtpText.js

@@ -30,7 +30,9 @@ function parseAddressList(value) {
         .map(function (item) {
             const trimmed = item.trim();
             const matched = /<([^<>]+)>/.exec(trimmed);
-            return matched ? matched[1].trim() : trimmed;
+            // 收件人最终拼入 RCPT TO 命令，必须剥离 CR/LF 防 SMTP 命令注入
+            const address = matched ? matched[1].trim() : trimmed;
+            return address.replace(/[\r\n]+/g, "");
         })
         .filter(function (item) {
             return item.length > 0;
@@ -198,6 +200,20 @@ function writeCommand(socket, command) {
     socket.write(`${command}\r\n`);
 }
 
+// 连接建立阶段默认 10 秒超时，避免网络黑洞下 sendMail 长时间挂起
+function connectWithTimeout(options, timeoutMs) {
+    let timer;
+    const connectPromise = Bun.connect(options);
+    const timeoutPromise = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+            reject(createError(`SMTP 连接超时（${timeoutMs}ms）：${options.hostname}:${options.port}`, { code: "runtime", subsystem: "smtp", operation: "connect" }));
+            // 超时后才建立的连接直接关闭，避免孤儿 socket
+            connectPromise.then((late) => late.end()).catch(() => {});
+        }, timeoutMs);
+    });
+    return Promise.race([connectPromise, timeoutPromise]).finally(() => clearTimeout(timer));
+}
+
 export async function sendSmtpTextMail(config, options) {
     const mail = createSmtpTextMessage(config, options);
     if (mail.recipients.length === 0) {
@@ -205,28 +221,31 @@ export async function sendSmtpTextMail(config, options) {
     }
 
     const reader = createResponseReader();
-    const socket = await Bun.connect({
-        hostname: config.host,
-        port: config.port || 25,
-        tls: normalizeSecureValue(config.secure),
-        socket: {
-            data: function (_socket, data) {
-                reader.append(data);
-            },
-            close: function (_socket, error) {
-                reader.close(error || null);
-            },
-            error: function (_socket, error) {
-                reader.close(error);
-            },
-            connectError: function (_socket, error) {
-                reader.close(error);
-            },
-            end: function () {
-                reader.close(null);
+    const socket = await connectWithTimeout(
+        {
+            hostname: config.host,
+            port: config.port || 25,
+            tls: normalizeSecureValue(config.secure),
+            socket: {
+                data: function (_socket, data) {
+                    reader.append(data);
+                },
+                close: function (_socket, error) {
+                    reader.close(error || null);
+                },
+                error: function (_socket, error) {
+                    reader.close(error);
+                },
+                connectError: function (_socket, error) {
+                    reader.close(error);
+                },
+                end: function () {
+                    reader.close(null);
+                }
             }
-        }
-    });
+        },
+        10000
+    );
 
     try {
         const timeout = 10000;

package/libs/validator/compiler.js

@@ -23,7 +23,7 @@ function schemaError(path, message) {
 }
 
 function assertBoolean(value, path) {
-    if (value !== undefined && typeof value !== "boolean") schemaError(path, "必须是 boolean");
+    if (value !== undefined && typeof value !== "boolean") schemaError(path, "必须是布尔值");
 }
 
 function assertLimit(value, path) {
@@ -200,6 +200,7 @@ export function compileNode(schema, path, parents) {
         node.maxItem = schema.maxItem;
         node.unique = schema.unique === true;
         node.items = schema.items === undefined ? null : compileNode(schema.items, [...path, "items"], parents);
+        if (node.unique && node.items && node.items.kind === "object") schemaError([...path, "unique"], "对象数组判重请使用 uniqueBy，unique 仅对标量数组有效");
         if (schema.uniqueBy !== undefined) {
             if (typeof schema.uniqueBy !== "string" || !schema.uniqueBy || schema.uniqueBy !== schema.uniqueBy.trim()) schemaError([...path, "uniqueBy"], "必须是非空无首尾空白字符串");
             if (!node.items || node.items.kind !== "object" || !node.items.fieldSet.has(schema.uniqueBy)) schemaError([...path, "uniqueBy"], "必须引用 items.fields 中的字段");
@@ -211,7 +212,7 @@ export function compileNode(schema, path, parents) {
     if (schema.paramType === "object") {
         assertItemBounds(schema, path);
         if (schema.fields !== undefined && !isPlainObject(schema.fields)) schemaError([...path, "fields"], "必须是对象");
-        if (schema.extra !== undefined && typeof schema.extra !== "boolean" && !isPlainObject(schema.extra)) schemaError([...path, "extra"], "必须是 boolean 或 Schema");
+        if (schema.extra !== undefined && typeof schema.extra !== "boolean" && !isPlainObject(schema.extra)) schemaError([...path, "extra"], "必须是布尔值或 Schema 对象");
         node.minItem = schema.minItem;
         node.maxItem = schema.maxItem;
         node.fields = Object.entries(schema.fields || {}).map(([key, child]) => ({ key: key, node: compileNode(child, [...path, "fields", key], parents) }));