befly 3.21.1 → 3.21.2

package/README.md

@@ -9,3 +9,10 @@
 "bundle:min": "bun build ./index.js --outfile ./befly.min.js --target bun --format esm --packages bundle --minify",
 "build": "rimraf befly.js befly.min.js && bun run bundle && bun run bundle:min"
 ```
+
+我们把要求和实现对齐一下，要符合如下规范：
+
+1. 单表查询，不传fields或fields为空数组，表示查询所有字段。
+2. 单表查询，fields指定查询字段，表示明确只查询这些字段。
+3. 单表查询，fields用!感叹号开头，表示排除不查询这些字段。
+4. 单表查询，不存在明确查询字段又排除某些字段的混合情况。

package/apis/dict/all.js

@@ -12,7 +12,7 @@ export default {
         const result = await befly.mysql.getAll({
             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"],
+            fields: ["beflyDict.id", "beflyDict.typeCode", "beflyDict.key", "beflyDict.label", "beflyDict.sort", "beflyDict.remark", "beflyDict.createdAt", "beflyDict.updatedAt", "beflyDictType.name typeName"],
             orderBy: ["beflyDict.sort#ASC", "beflyDict.id#ASC"]
         });
 

package/apis/dict/detail.js

@@ -11,7 +11,7 @@ export default {
         const dict = await befly.mysql.getOne({
             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"],
+            fields: ["beflyDict.id", "beflyDict.typeCode", "beflyDict.key", "beflyDict.label", "beflyDict.sort", "beflyDict.remark", "beflyDict.createdAt", "beflyDict.updatedAt", "beflyDictType.name typeName"],
             where: { "beflyDict.id": ctx.body.id }
         });
 

package/apis/dict/list.js

@@ -16,7 +16,7 @@ export default {
         const result = await befly.mysql.getList({
             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"],
+            fields: ["beflyDict.id", "beflyDict.typeCode", "beflyDict.key", "beflyDict.label", "beflyDict.sort", "beflyDict.remark", "beflyDict.createdAt", "beflyDict.updatedAt", "beflyDictType.name typeName"],
             where: {
                 "beflyDict.typeCode": ctx.body.typeCode
             },

package/checks/config.js

@@ -29,9 +29,7 @@ const configSchema = z
                 excludeFields: z.array(noTrimString),
                 dir: noTrimString,
                 console: boolIntSchema,
-                maxSize: z.int().min(1),
-                maxStringLen: z.int().min(1),
-                maxArrayItems: z.int().min(1)
+                maxSize: z.int().min(1)
             })
             .strict(),
 

package/checks/table.js

@@ -76,20 +76,7 @@ const fieldDefSchema = z
     });
 
 const tableContentSchema = z.record(z.string().regex(lowerCamelRegex), fieldDefSchema);
-
-const tableItemSchema = z
-    .object({
-        source: noTrimString.min(1),
-        type: noTrimString.min(1),
-        filePath: noTrimString.min(1),
-        relativePath: noTrimString.min(1),
-        apiPath: noTrimString.min(1),
-        fileName: z.string().min(1).regex(lowerCamelRegex),
-        fieldsDef: tableContentSchema
-    })
-    .strict();
-
-const tableListSchema = z.array(tableItemSchema);
+const tableRegistrySchema = z.record(z.string().regex(lowerCamelRegex), tableContentSchema);
 
 /**
  * 检查表定义文件
@@ -99,7 +86,7 @@ export async function checkTable(tables) {
     // 收集所有表文件
     let hasError = false;
 
-    const schemaResult = tableListSchema.safeParse(tables);
+    const schemaResult = tableRegistrySchema.safeParse(tables);
     if (!schemaResult.success) {
         const errors = formatZodIssues(schemaResult.error.issues, { items: tables, itemLabel: "table" });
         Logger.warn("表结构校验失败", { errors: errors }, false);

package/configs/beflyConfig.json

@@ -14,9 +14,7 @@
         "excludeFields": ["password", "token", "secret"],
         "dir": "./logs",
         "console": 1,
-        "maxSize": 20,
-        "maxStringLen": 100,
-        "maxArrayItems": 100
+        "maxSize": 20
     },
 
     "mysql": {

package/index.js

@@ -26,13 +26,14 @@ import { syncApi } from "./sync/api.js";
 import { syncCache } from "./sync/cache.js";
 import { syncDev } from "./sync/dev.js";
 import { syncMenu } from "./sync/menu.js";
-import { syncDbApply, syncDbCheck } from "./scripts/syncDb/index.js";
 // 工具
 import { calcPerfTime } from "./utils/calcPerfTime.js";
 import { scanSources } from "./utils/scanSources.js";
 import { isPrimaryProcess } from "./utils/is.js";
 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) {
@@ -94,14 +95,6 @@ async function ensureSyncPrerequisites(ctx) {
     }
 }
 
-export async function dbCheck(mysqlConfig) {
-    return syncDbCheck(mysqlConfig);
-}
-
-export async function dbApply(mysqlConfig) {
-    return syncDbApply(mysqlConfig);
-}
-
 export async function createBefly(env = {}, config = {}, menus = []) {
     const mergedConfig = deepMerge(beflyConfig, config);
     const mergedMenus = deepMerge(prefixMenuPaths(beflyMenus, "core"), menus);
@@ -127,6 +120,7 @@ export async function createBefly(env = {}, config = {}, menus = []) {
     return new Befly({
         env: env,
         config: mergedConfig,
+        tables: tables,
         menus: mergedMenus,
         apis: apis,
         hooks: hooks,
@@ -143,7 +137,8 @@ export class Befly {
     constructor(init = {}) {
         this.context = {
             env: init.env || {},
-            config: init.config || {}
+            config: init.config || {},
+            tables: init.tables || {}
         };
         this.menus = Array.isArray(init.menus) ? init.menus : [];
         this.hooks = Array.isArray(init.hooks) ? init.hooks : [];

package/lib/dbHelper.js

@@ -614,7 +614,7 @@ function validateDataReadOptions(options, label) {
     validateQueryOptions(options, label);
 
     const hasLeftJoin = Array.isArray(options.leftJoin) && options.leftJoin.length > 0;
-    const classifiedFields = hasLeftJoin ? validateExplicitLeftJoinFields(options.fields) : validateExplicitReadFields(options.fields);
+    const classifiedFields = hasLeftJoin ? validateExplicitLeftJoinFields(options.fields, options.table[0]) : validateExplicitReadFields(options.fields);
 
     return {
         hasLeftJoin: hasLeftJoin,
@@ -661,6 +661,30 @@ class DbHelper {
         this.sql = options.sql || null;
         this.isTransaction = options.isTransaction === true;
         this.beflyMode = options.beflyMode === "manual" ? "manual" : "auto";
+        this.tables = isPlainObject(options.tables) ? options.tables : {};
+    }
+
+    getTableDef(table) {
+        const tableName = parseTableRef(table).table;
+
+        if (!/^_?[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/.test(tableName)) {
+            throw new Error(`表名必须使用小驼峰写法 (table: ${tableName})`, {
+                cause: null,
+                code: "validation"
+            });
+        }
+
+        const tableInfo = this.tables[tableName];
+
+        if (!isPlainObject(tableInfo)) {
+            const sourceLabel = tableName.startsWith("befly") ? "packages/core/tables" : "app tables";
+            throw new Error(`表 ${tableName} 缺少本地 tables 定义，请检查 ${sourceLabel}`, {
+                cause: null,
+                code: "runtime"
+            });
+        }
+
+        return tableInfo;
     }
 
     async execute(sql, params) {
@@ -815,12 +839,45 @@ class DbHelper {
         return normalizeBigIntValues(deserializedList);
     }
 
-    _joinFieldsToSnake(classifiedFields) {
-        if (classifiedFields.type === "include") {
-            return classifiedFields.fields.map((field) => processJoinField(field));
+    async _joinFieldsToSnake(mainTableRef, classifiedFields) {
+        if (classifiedFields.type !== "join") {
+            return [];
+        }
+
+        const processedFields = [];
+        const seenFields = new Set();
+        const pushField = (field) => {
+            if (seenFields.has(field)) {
+                return;
+            }
+            seenFields.add(field);
+            processedFields.push(field);
+        };
+
+        if (classifiedFields.mainAllIncluded) {
+            const mainColumns = await this.getTableColumns(mainTableRef);
+            const excludeFieldSet = new Set(classifiedFields.mainExcludeFields.map((field) => snakeCase(field)));
+
+            for (const column of mainColumns) {
+                if (excludeFieldSet.has(column)) {
+                    continue;
+                }
+                pushField(`${classifiedFields.mainQualifier}.${column}`);
+            }
+        }
+
+        for (const field of classifiedFields.includeFields) {
+            pushField(processJoinField(field));
         }
 
-        return [];
+        if (processedFields.length === 0) {
+            throw new Error(`排除字段后没有剩余字段可查询。表: ${mainTableRef}, 排除: ${classifiedFields.mainExcludeFields.join(", ")}`, {
+                cause: null,
+                code: "validation"
+            });
+        }
+
+        return processedFields;
     }
 
     _cleanAndSnakeAndSerializeWriteData(data, excludeValues = [null, undefined]) {
@@ -874,9 +931,9 @@ class DbHelper {
         return this._prepareWriteUserData(options.data, options.allowState);
     }
 
-    normalizeLeftJoinOptions(options, cleanWhere, classifiedFields) {
-        const processedFields = this._joinFieldsToSnake(classifiedFields);
+    async normalizeLeftJoinOptions(options, cleanWhere, classifiedFields) {
         const mainTableRef = options.table[0];
+        const processedFields = await this._joinFieldsToSnake(mainTableRef, classifiedFields);
         const joinTableRefs = options.table.slice(1);
         const normalizedTableRef = normalizeTableRef(mainTableRef);
         const mainQualifier = getJoinMainQualifier(mainTableRef);
@@ -916,7 +973,7 @@ class DbHelper {
     async normalizeSingleTableOptions(options, cleanWhere, classifiedFields) {
         const tableRef = Array.isArray(options.table) ? options.table[0] : options.table;
         const snakeTable = snakeCase(tableRef);
-        const processedFields = await fieldsToSnake(snakeTable, classifiedFields, this.getTableColumns.bind(this));
+        const processedFields = await fieldsToSnake(tableRef, classifiedFields, this.getTableColumns.bind(this));
 
         return {
             table: snakeTable,
@@ -967,29 +1024,17 @@ class DbHelper {
     }
 
     async getTableColumns(table) {
-        const parsed = parseTableRef(table);
-        const schemaPart = parsed.schema ? `${quoteIdentMySql(snakeCase(parsed.schema))}.` : "";
-        const quotedTable = quoteIdentMySql(snakeCase(parsed.table));
-        const executeRes = await this.execute(`SHOW COLUMNS FROM ${schemaPart}${quotedTable}`, []);
-        const result = executeRes.data;
+        const tableInfo = this.getTableDef(table);
+        const fieldNames = Object.keys(tableInfo);
 
-        if (!result || result.length === 0) {
-            throw new Error(`表 ${table} 不存在或没有字段`, {
+        if (fieldNames.length === 0) {
+            throw new Error(`表 ${table} 的本地 tables 定义为空或没有字段`, {
                 cause: null,
                 code: "runtime"
             });
         }
 
-        const columnNames = [];
-        for (const row of result) {
-            const record = row;
-            const name = record.Field;
-            if (isNonEmptyString(name)) {
-                columnNames.push(name);
-            }
-        }
-
-        return columnNames;
+        return fieldNames.map((fieldName) => snakeCase(fieldName));
     }
 
     applyLeftJoins(builder, leftJoins) {
@@ -1014,7 +1059,7 @@ class DbHelper {
 
     async buildPreparedReadOptions(options, cleanWhere, validation) {
         if (validation.hasLeftJoin) {
-            return this.normalizeLeftJoinOptions(options, cleanWhere, validation.classifiedFields);
+            return await this.normalizeLeftJoinOptions(options, cleanWhere, validation.classifiedFields);
         }
 
         return await this.normalizeSingleTableOptions(options, cleanWhere, validation.classifiedFields);
@@ -1600,7 +1645,8 @@ class DbHelper {
                     dbName: this.dbName,
                     sql: tx,
                     isTransaction: true,
-                    beflyMode: this.beflyMode
+                    beflyMode: this.beflyMode,
+                    tables: this.tables
                 });
                 const result = await callback(trans);
                 if (result?.code !== undefined && result.code !== 0) {

package/lib/dbUtil.js

@@ -299,33 +299,113 @@ export function validateAndClassifyFields(fields) {
 }
 
 export function validateExplicitReadFields(fields) {
-    const classified = validateAndClassifyFields(fields);
-    if (classified.type === "all") {
-        throw new Error("查询必须显式传 fields，不支持空 fields 或查询全部字段", {
-            cause: null,
-            code: "validation"
-        });
+    return validateAndClassifyFields(fields);
+}
+
+function getTableQualifier(tableRef) {
+    const parsed = parseTableRef(tableRef);
+    if (parsed.alias) {
+        return snakeCase(parsed.alias);
     }
 
-    return classified;
+    return snakeCase(parsed.table);
 }
 
-export function validateExplicitLeftJoinFields(fields) {
-    const classified = validateAndClassifyFields(fields);
-    if (classified.type === "all") {
+export function validateExplicitLeftJoinFields(fields, mainTableRef) {
+    if (!fields || fields.length === 0) {
         throw new Error("leftJoin 查询必须显式传 fields，不支持空 fields 或查询全部字段", {
             cause: null,
             code: "validation"
         });
     }
-    if (classified.type === "exclude") {
-        throw new Error("leftJoin 查询不支持排除字段，必须显式指定主表/从表字段", {
+
+    const mainQualifier = getTableQualifier(mainTableRef);
+    const mainWildcard = `${mainQualifier}.*`;
+    const includeFields = [];
+    const mainExcludeFields = [];
+    let mainAllIncluded = false;
+
+    for (const rawField of fields) {
+        if (!isNonEmptyString(rawField)) {
+            throw new Error("fields 不能包含空字符串或无效值", {
+                cause: null,
+                code: "validation"
+            });
+        }
+
+        const trimmed = rawField.trim();
+        if (trimmed === "*") {
+            throw new Error("fields 不支持 * 星号，请使用空数组 [] 或不传参数表示查询所有字段", {
+                cause: null,
+                code: "validation"
+            });
+        }
+
+        if (trimmed.startsWith("!")) {
+            const fieldPart = trimmed.substring(1).trim();
+            if (!isNonEmptyString(fieldPart)) {
+                throw new Error("fields 不能包含空字符串或无效值", {
+                    cause: null,
+                    code: "validation"
+                });
+            }
+            if (/\s/.test(fieldPart)) {
+                throw new Error("leftJoin 排除字段不支持别名", {
+                    cause: null,
+                    code: "validation"
+                });
+            }
+
+            assertNoExprField(fieldPart);
+            const normalizedField = normalizeQualifierField(fieldPart);
+            if (normalizedField === mainWildcard) {
+                throw new Error("leftJoin 主表排除字段不能使用 *", {
+                    cause: null,
+                    code: "validation"
+                });
+            }
+            if (!normalizedField.startsWith(`${mainQualifier}.`)) {
+                throw new Error("leftJoin 排除字段仅支持主表字段，请使用主表限定符", {
+                    cause: null,
+                    code: "validation"
+                });
+            }
+
+            mainExcludeFields.push(normalizedField.substring(mainQualifier.length + 1));
+            continue;
+        }
+
+        assertNoExprField(trimmed);
+        const aliasParts = parseFieldAliasParts(trimmed);
+        const normalizedField = normalizeQualifierField(aliasParts ? aliasParts.fieldPart.trim() : trimmed);
+        if (normalizedField === mainWildcard) {
+            if (aliasParts) {
+                throw new Error("leftJoin 主表全字段不支持别名", {
+                    cause: null,
+                    code: "validation"
+                });
+            }
+            mainAllIncluded = true;
+            continue;
+        }
+
+        includeFields.push(trimmed);
+    }
+
+    if (mainExcludeFields.length > 0 && !mainAllIncluded) {
+        throw new Error("leftJoin 使用主表排除字段时，必须同时传主表限定符.*", {
             cause: null,
             code: "validation"
         });
     }
 
-    return classified;
+    return {
+        type: "join",
+        includeFields: includeFields,
+        mainAllIncluded: mainAllIncluded,
+        mainExcludeFields: mainExcludeFields,
+        mainQualifier: mainQualifier
+    };
 }
 
 function isQuotedIdentPaired(value) {
@@ -390,6 +470,41 @@ export function startsWithQuote(value) {
     return startsWithIdentifierQuote(value);
 }
 
+function parseFieldAliasParts(field) {
+    if (!isString(field)) {
+        return null;
+    }
+
+    const trimmed = field.trim();
+    if (!trimmed) {
+        return null;
+    }
+
+    if (/\s+AS\s+/i.test(trimmed)) {
+        throw new Error(`字段别名不支持 AS，请使用单个空格分隔字段与别名 (field: ${trimmed})`, {
+            cause: null,
+            code: "validation"
+        });
+    }
+
+    if (!/\s/.test(trimmed)) {
+        return null;
+    }
+
+    if (!/^[^\s]+ [^\s]+$/.test(trimmed)) {
+        throw new Error(`字段别名必须使用单个空格分隔字段与别名 (field: ${trimmed})`, {
+            cause: null,
+            code: "validation"
+        });
+    }
+
+    const parts = trimmed.split(" ");
+    return {
+        fieldPart: parts[0],
+        aliasPart: parts[1]
+    };
+}
+
 export function escapeField(field, quoteIdent) {
     if (!isString(field)) {
         return field;
@@ -412,19 +527,10 @@ export function escapeField(field, quoteIdent) {
         });
     }
 
-    if (trimmed.toUpperCase().includes(" AS ")) {
-        const parts = trimmed.split(/\s+AS\s+/i);
-        if (parts.length !== 2) {
-            throw new Error(`字段格式非法，请使用简单字段名或安全引用，复杂表达式请使用 selectRaw/whereRaw (field: ${trimmed})`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-
-        const fieldPart = parts[0];
-        const aliasPart = parts[1];
-        const cleanFieldPart = fieldPart.trim();
-        const cleanAliasPart = aliasPart.trim();
+    const aliasParts = parseFieldAliasParts(trimmed);
+    if (aliasParts) {
+        const cleanFieldPart = aliasParts.fieldPart.trim();
+        const cleanAliasPart = aliasParts.aliasPart.trim();
         if (!isQuotedIdent(cleanAliasPart)) {
             if (!SAFE_IDENTIFIER_RE.test(cleanAliasPart)) {
                 throw new Error(`无效的字段别名: ${cleanAliasPart}`, {
@@ -433,7 +539,7 @@ export function escapeField(field, quoteIdent) {
                 });
             }
         }
-        return `${escapeField(cleanFieldPart, quoteIdent)} AS ${cleanAliasPart}`;
+        return `${escapeField(cleanFieldPart, quoteIdent)} ${cleanAliasPart}`;
     }
 
     if (trimmed.includes(".")) {
@@ -805,14 +911,9 @@ export function processJoinField(field) {
         return field;
     }
 
-    if (field.toUpperCase().includes(" AS ")) {
-        const parts = field.split(/\s+AS\s+/i);
-        const fieldPart = parts[0];
-        const aliasPart = parts[1];
-        if (!isString(fieldPart) || !isString(aliasPart)) {
-            return field;
-        }
-        return `${processJoinField(fieldPart.trim())} AS ${aliasPart.trim()}`;
+    const aliasParts = parseFieldAliasParts(field);
+    if (aliasParts) {
+        return `${processJoinField(aliasParts.fieldPart.trim())} ${aliasParts.aliasPart.trim()}`;
     }
 
     return normalizeQualifierField(field);

package/lib/logger.js

@@ -19,28 +19,12 @@ const RUNTIME_LOG_DIR = nodePathResolve(INITIAL_CWD, "logs");
 const BUILTIN_SENSITIVE_KEYS = ["*password*", "pass", "pwd", "*token*", "access_token", "refresh_token", "accessToken", "refreshToken", "authorization", "cookie", "set-cookie", "*secret*", "apiKey", "api_key", "privateKey", "private_key"];
 
 let sanitizeOptions = {
-    maxStringLen: 200,
-    maxArrayItems: 500,
     sanitizeDepth: 5,
     sanitizeNodes: 5000,
     sanitizeObjectKeys: 500,
     sensitiveKeyMatcher: buildSensitiveKeyMatcher({ builtinPatterns: BUILTIN_SENSITIVE_KEYS, userPatterns: [] })
 };
 
-function buildSanitizeOptionsForWriteOptions(writeOptions) {
-    if (!writeOptions || writeOptions.truncate !== false) return sanitizeOptions;
-
-    // 仅关闭“截断”，仍保留敏感字段掩码与结构化清洗（避免泄露敏感信息）。
-    return {
-        maxStringLen: 200000,
-        maxArrayItems: 5000,
-        sanitizeDepth: sanitizeOptions.sanitizeDepth,
-        sanitizeNodes: sanitizeOptions.sanitizeNodes,
-        sanitizeObjectKeys: sanitizeOptions.sanitizeObjectKeys,
-        sensitiveKeyMatcher: sanitizeOptions.sensitiveKeyMatcher
-    };
-}
-
 let mockInstance = null;
 
 let appFileSink = null;
@@ -381,10 +365,8 @@ export function configure(cfg) {
     appFileSink = null;
     errorFileSink = null;
 
-    // 运行时清洗/截断上限（可配置）
+    // 运行时清洗上限：只保留深度/节点/对象键数量保护。
     sanitizeOptions = {
-        maxStringLen: normalizePositiveInt(config.maxStringLen, 200, 20, 200000),
-        maxArrayItems: normalizePositiveInt(config.maxArrayItems, 500, 10, 5000),
         sanitizeDepth: normalizePositiveInt(config.sanitizeDepth, 5, 1, 10),
         sanitizeNodes: normalizePositiveInt(config.sanitizeNodes, 5000, 50, 20000),
         sanitizeObjectKeys: normalizePositiveInt(config.sanitizeObjectKeys, 500, 10, 5000),
@@ -476,16 +458,15 @@ function ensureSinksReady(kind) {
     return { fileSink: errorFileSink };
 }
 
-function writeJsonl(kind, level, record, options) {
+function writeJsonl(kind, level, record) {
     const sinks = ensureSinksReady(kind);
     const time = Date.now();
-    const effectiveSanitizeOptions = buildSanitizeOptionsForWriteOptions(options);
-    const sanitizedRecord = sanitizeLogObject(record, effectiveSanitizeOptions);
+    const sanitizedRecord = sanitizeLogObject(record, sanitizeOptions);
     const fileLine = buildJsonLine(level, time, sanitizedRecord);
     sinks.fileSink.enqueue(fileLine);
 }
 
-// 对象清洗/脱敏/截断逻辑已下沉到 utils/loggerUtils.ts（减少 logger.ts 复杂度）。
+// 对象清洗/脱敏逻辑已下沉到 utils/loggerUtils.js（减少 logger.js 复杂度）。
 
 // 日志仅接受 1 个入参（任意类型）。
 // - plain object（{}）直接作为 record
@@ -519,16 +500,15 @@ function toRecord(input) {
     }
 }
 
-function logWrite(level, input, options) {
+function logWrite(level, input) {
     // debug!=1/true 则不记录 debug 日志
     if (level === "debug" && config.debug !== 1 && config.debug !== true) return;
 
     const record0 = toRecord(input);
 
-    // 测试场景：mock logger 走同步写入，并在入口进行清洗/脱敏/截断控制
+    // 测试场景：mock logger 走同步写入，并在入口进行清洗/脱敏控制
     if (mockInstance) {
-        const effective = buildSanitizeOptionsForWriteOptions(options);
-        const sanitized = sanitizeLogObject(record0, effective);
+        const sanitized = sanitizeLogObject(record0, sanitizeOptions);
         if (level === "info") {
             mockInstance.info(sanitized);
         } else if (level === "warn") {
@@ -543,9 +523,9 @@ function logWrite(level, input, options) {
 
     if (level === "error") {
         // error 仅写入 error 文件
-        writeJsonl("error", "error", record0, options);
+        writeJsonl("error", "error", record0);
     } else {
-        writeJsonl("app", level, record0, options);
+        writeJsonl("app", level, record0);
     }
 }
 
@@ -553,41 +533,37 @@ function logWrite(level, input, options) {
  * 日志实例（延迟初始化）
  */
 export const Logger = {
-    info(msg, data, truncate) {
-        const options = truncate === false ? { truncate: false } : undefined;
+    info(msg, data) {
         if (isPlainObject(msg)) {
-            logWrite("info", msg, options);
+            logWrite("info", msg);
             return;
         }
 
-        logWrite("info", { msg: msg, data: data }, options);
+        logWrite("info", { msg: msg, data: data });
     },
-    warn(msg, data, truncate) {
-        const options = truncate === false ? { truncate: false } : undefined;
+    warn(msg, data) {
         if (isPlainObject(msg)) {
-            logWrite("warn", msg, options);
+            logWrite("warn", msg);
             return;
         }
 
-        logWrite("warn", { msg: msg, data: data }, options);
+        logWrite("warn", { msg: msg, data: data });
     },
-    error(msg, err, data, truncate) {
-        const options = truncate === false ? { truncate: false } : undefined;
+    error(msg, err, data) {
         if (isPlainObject(msg)) {
-            logWrite("error", msg, options);
+            logWrite("error", msg);
             return;
         }
 
-        logWrite("error", { msg: msg, err: err, data: data }, options);
+        logWrite("error", { msg: msg, err: err, data: data });
     },
-    debug(msg, data, truncate) {
-        const options = truncate === false ? { truncate: false } : undefined;
+    debug(msg, data) {
         if (isPlainObject(msg)) {
-            logWrite("debug", msg, options);
+            logWrite("debug", msg);
             return;
         }
 
-        logWrite("debug", { msg: msg, data: data }, options);
+        logWrite("debug", { msg: msg, data: data });
     },
     async flush() {
         await flush();