@nest-omni/core 4.1.3-3 → 4.1.3-31

package/file-upload/utils/filename.util.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileNameUtil = void 0;
+const path = require("path");
+/**
+ * 文件名处理工具类
+ * 统一管理文件名的编码、清理、截取等操作
+ */
+class FileNameUtil {
+    /**
+     * 解码并标准化文件名
+     * 1. Multer 默认使用 Latin1 解码，需要转换为 UTF-8
+     * 2. 移除特殊字符和控制字符
+     * 3. 截取超长文件名到指定长度
+     *
+     * @param filename 原始文件名
+     * @param maxLength 最大长度（默认 100 字符）
+     * @returns 处理后的文件名
+     */
+    static decodeAndNormalize(filename, maxLength = 100) {
+        if (!filename) {
+            return 'unknown';
+        }
+        let decoded;
+        // 尝试从 Latin1 转换（这是 Multer 的常见情况）
+        try {
+            const buffer = Buffer.from(filename, 'latin1');
+            decoded = buffer.toString('utf8');
+            // 检查转换结果是否包含 UTF-8 替换字符（表示可能有乱码）
+            if (!decoded.includes('\uFFFD') && this.hasValidCharacters(decoded)) {
+                // 转换成功且看起来有效
+            }
+            else {
+                // 可能不是 Latin1 编码，保持原始字符串
+                decoded = filename;
+            }
+        }
+        catch (_a) {
+            // 转换失败，保持原始字符串
+            decoded = filename;
+        }
+        // 移除不可见控制字符（但保留换行符）
+        decoded = decoded.replace(/[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F-\x9F]/g, '');
+        // 移除常见乱码字符（替换符）
+        decoded = decoded.replace(/\uFFFD/g, '');
+        // 移除前后空格
+        decoded = decoded.trim();
+        // 截取长度（按字符数，不是字节数）
+        if (decoded.length > maxLength) {
+            return this.truncateWithExtension(decoded, maxLength);
+        }
+        return decoded;
+    }
+    /**
+     * 智能截取文件名（保留扩展名）
+     *
+     * @param filename 文件名
+     * @param maxLength 最大长度
+     * @returns 截取后的文件名
+     */
+    static truncateWithExtension(filename, maxLength) {
+        // 如果文件名长度不超过限制，直接返回
+        if (filename.length <= maxLength) {
+            return filename;
+        }
+        // 保留文件扩展名
+        const extMatch = filename.match(/\.[^.]+$/);
+        const ext = extMatch ? extMatch[0] : '';
+        const nameWithoutExt = ext ? filename.slice(0, -ext.length) : filename;
+        // 如果没有扩展名，直接截断到指定长度
+        if (!ext) {
+            return filename.slice(0, maxLength);
+        }
+        // 计算可用的文件名长度
+        const availableLength = maxLength - ext.length - 3; // 预留 3 个字符用于 "..."
+        if (availableLength > 0) {
+            return nameWithoutExt.slice(0, availableLength) + '...' + ext;
+        }
+        else {
+            // 如果扩展名本身就超过限制，直接截取
+            return filename.slice(0, maxLength);
+        }
+    }
+    /**
+     * 清理文件名（移除危险字符）
+     * 移除路径遍历、路径分隔符、控制字符等
+     *
+     * @param filename 文件名
+     * @returns 清理后的文件名
+     */
+    static sanitize(filename) {
+        // 移除路径遍历字符
+        let sanitized = filename.replace(/\.\./g, '');
+        // 移除路径分隔符
+        sanitized = sanitized.replace(/[\/\\]/g, '');
+        // 移除控制字符
+        sanitized = sanitized.replace(/[\x00-\x1f\x80-\x9f]/g, '');
+        // 保留空格，只替换其他特殊字符
+        sanitized = sanitized.replace(/[^a-zA-Z0-9.\-_\s\u4e00-\u9fa5]/g, '_');
+        // 移除前导/尾随空格和点
+        sanitized = sanitized
+            .trim()
+            .replace(/^\.+|\.+$/g, '')
+            .replace(/^_+|_+$/g, '');
+        return sanitized;
+    }
+    /**
+     * 清理并保留原始文件名结构
+     * 先解码 UTF-8，再清理危险字符
+     *
+     * @param filename 文件名
+     * @returns 清理后的文件名
+     */
+    static sanitizeOriginal(filename) {
+        // 1. 解码 UTF-8
+        const decoded = this.decodeAndNormalize(filename);
+        // 2. 移除路径遍历字符
+        let sanitized = decoded.replace(/\.\./g, '');
+        sanitized = sanitized.replace(/[\/\\]/g, '');
+        // 3. 移除控制字符
+        sanitized = sanitized.replace(/[\x00-\x1f\x80-\x9f]/g, '');
+        // 4. 移除前导/尾随空格和点
+        sanitized = sanitized.trim().replace(/^\.+|\.+$/g, '');
+        return sanitized;
+    }
+    /**
+     * 提取文件扩展名
+     *
+     * @param filename 文件名
+     * @returns 扩展名（包含点）或空字符串
+     */
+    static extractExtension(filename) {
+        const lastDotIndex = filename.lastIndexOf('.');
+        // 如果没有点、点是第一个字符（隐藏文件）、或点是最后一个字符
+        if (lastDotIndex === -1 ||
+            lastDotIndex === 0 ||
+            lastDotIndex === filename.length - 1) {
+            return '';
+        }
+        return filename.substring(lastDotIndex);
+    }
+    /**
+     * 获取不包含扩展名的文件名
+     *
+     * @param filename 文件名
+     * @returns 不包含扩展名的文件名
+     */
+    static getBaseName(filename) {
+        return path.basename(filename, this.extractExtension(filename));
+    }
+    /**
+     * 检查字符串是否包含有效的字符
+     */
+    static hasValidCharacters(str) {
+        // 如果字符串太短，无法判断
+        if (str.length === 0)
+            return true;
+        // 计算有效字符的比例
+        let validCount = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str[i];
+            const code = char.charCodeAt(0);
+            // ASCII 可打印字符
+            if (code >= 0x20 && code <= 0x7e) {
+                validCount++;
+            }
+            // 基本拉丁字母扩展
+            else if (code >= 0xa0 && code <= 0xff) {
+                validCount++;
+            }
+            // 中文、日文、韩文等 CJK 字符
+            else if (code >= 0x4e00 && code <= 0x9fff) {
+                validCount++;
+            }
+            // 其他 Unicode 字符
+            else if (code > 0xff) {
+                validCount++;
+            }
+        }
+        // 如果超过 70% 的字符是有效的，认为是有效的字符串
+        return validCount / str.length > 0.7;
+    }
+}
+exports.FileNameUtil = FileNameUtil;

package/file-upload/utils/filepath.util.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 文件路径处理工具类
+ * 统一管理文件上传路径、相对路径转换等操作
+ */
+export declare class FilePathUtil {
+    /**
+     * 获取上传根目录
+     * 优先使用环境变量 FILE_UPLOAD_PATH，否则使用 process.cwd()/uploads
+     *
+     * @returns 上传根目录的绝对路径
+     */
+    static getUploadDir(): string;
+    /**
+     * 生成日期子目录格式 (YYYY/MM/DD)
+     *
+     * @returns 日期子目录路径
+     */
+    static getDateSubdirectory(): string;
+    /**
+     * 获取完整的上传目录（包含日期子目录）
+     *
+     * @returns 完整的上传目录路径
+     */
+    static getFullUploadPath(): string;
+    /**
+     * 将绝对路径转换为相对路径（相对于上传根目录）
+     * 例如: /Users/.../uploads/2025/11/30/xxx.txt -> 2025/11/30/xxx.txt
+     *
+     * @param absolutePath 绝对路径
+     * @returns 相对路径
+     */
+    static toRelativePath(absolutePath: string): string;
+    /**
+     * 将相对路径转换为绝对路径（物理路径）
+     * 例如: 2025/11/30/xxx.txt -> /Users/.../uploads/2025/11/30/xxx.txt
+     *
+     * @param relativePath 相对路径
+     * @returns 绝对路径
+     */
+    static toAbsolutePath(relativePath: string): string;
+    /**
+     * 规范化路径（统一使用正斜杠）
+     *
+     * @param filePath 文件路径
+     * @returns 规范化后的路径
+     */
+    static normalize(filePath: string): string;
+    /**
+     * 检查路径是否为绝对路径
+     *
+     * @param filePath 文件路径
+     * @returns 是否为绝对路径
+     */
+    static isAbsolute(filePath: string): boolean;
+    /**
+     * 检查文件是否存在
+     *
+     * @param filePath 文件路径（绝对或相对）
+     * @returns 文件是否存在
+     */
+    static exists(filePath: string): boolean;
+    /**
+     * 获取文件的物理路径（用于文件系统访问）
+     *
+     * @param relativePath 相对路径
+     * @param storageProvider 存储提供商
+     * @returns 物理路径或相对路径（对象存储）
+     */
+    static getPhysicalPath(relativePath: string, storageProvider?: string): string;
+}

package/file-upload/utils/filepath.util.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilePathUtil = void 0;
+const path = require("path");
+const fs = require("fs");
+/**
+ * 文件路径处理工具类
+ * 统一管理文件上传路径、相对路径转换等操作
+ */
+class FilePathUtil {
+    /**
+     * 获取上传根目录
+     * 优先使用环境变量 FILE_UPLOAD_PATH，否则使用 process.cwd()/uploads
+     *
+     * @returns 上传根目录的绝对路径
+     */
+    static getUploadDir() {
+        const uploadPath = process.env.FILE_UPLOAD_PATH || path.join(process.cwd(), 'uploads');
+        // 确保目录存在
+        if (!fs.existsSync(uploadPath)) {
+            fs.mkdirSync(uploadPath, { recursive: true });
+        }
+        return uploadPath;
+    }
+    /**
+     * 生成日期子目录格式 (YYYY/MM/DD)
+     *
+     * @returns 日期子目录路径
+     */
+    static getDateSubdirectory() {
+        const now = new Date();
+        const year = now.getFullYear();
+        const month = String(now.getMonth() + 1).padStart(2, '0');
+        const day = String(now.getDate()).padStart(2, '0');
+        return path.join(String(year), month, day);
+    }
+    /**
+     * 获取完整的上传目录（包含日期子目录）
+     *
+     * @returns 完整的上传目录路径
+     */
+    static getFullUploadPath() {
+        const basePath = this.getUploadDir();
+        const subDir = this.getDateSubdirectory();
+        const fullPath = path.join(basePath, subDir);
+        // 确保目录存在
+        if (!fs.existsSync(fullPath)) {
+            fs.mkdirSync(fullPath, { recursive: true });
+        }
+        return fullPath;
+    }
+    /**
+     * 将绝对路径转换为相对路径（相对于上传根目录）
+     * 例如: /Users/.../uploads/2025/11/30/xxx.txt -> 2025/11/30/xxx.txt
+     *
+     * @param absolutePath 绝对路径
+     * @returns 相对路径
+     */
+    static toRelativePath(absolutePath) {
+        if (!absolutePath) {
+            return '';
+        }
+        const uploadDir = this.getUploadDir();
+        // 方法1: 使用 startsWith 精确匹配
+        if (absolutePath.startsWith(uploadDir)) {
+            return absolutePath.substring(uploadDir.length).replace(/^[\/\\]+/, '');
+        }
+        // 方法2: 兼容处理 - 如果包含 /uploads/，从该位置开始截取
+        if (absolutePath.includes('/uploads/')) {
+            const uploadIndex = absolutePath.indexOf('/uploads/');
+            return absolutePath.substring(uploadIndex + '/uploads/'.length);
+        }
+        // 方法3: 兼容 Windows 路径
+        if (absolutePath.includes('\\uploads\\')) {
+            const uploadIndex = absolutePath.indexOf('\\uploads\\');
+            return absolutePath
+                .substring(uploadIndex + '\\uploads\\'.length)
+                .replace(/\\/g, '/');
+        }
+        // 如果都不匹配，返回原路径
+        return absolutePath;
+    }
+    /**
+     * 将相对路径转换为绝对路径（物理路径）
+     * 例如: 2025/11/30/xxx.txt -> /Users/.../uploads/2025/11/30/xxx.txt
+     *
+     * @param relativePath 相对路径
+     * @returns 绝对路径
+     */
+    static toAbsolutePath(relativePath) {
+        if (!relativePath) {
+            return '';
+        }
+        const uploadDir = this.getUploadDir();
+        return path.join(uploadDir, relativePath);
+    }
+    /**
+     * 规范化路径（统一使用正斜杠）
+     *
+     * @param filePath 文件路径
+     * @returns 规范化后的路径
+     */
+    static normalize(filePath) {
+        return filePath.replace(/\\/g, '/');
+    }
+    /**
+     * 检查路径是否为绝对路径
+     *
+     * @param filePath 文件路径
+     * @returns 是否为绝对路径
+     */
+    static isAbsolute(filePath) {
+        return path.isAbsolute(filePath);
+    }
+    /**
+     * 检查文件是否存在
+     *
+     * @param filePath 文件路径（绝对或相对）
+     * @returns 文件是否存在
+     */
+    static exists(filePath) {
+        const absolutePath = this.isAbsolute(filePath)
+            ? filePath
+            : this.toAbsolutePath(filePath);
+        return fs.existsSync(absolutePath);
+    }
+    /**
+     * 获取文件的物理路径（用于文件系统访问）
+     *
+     * @param relativePath 相对路径
+     * @param storageProvider 存储提供商
+     * @returns 物理路径或相对路径（对象存储）
+     */
+    static getPhysicalPath(relativePath, storageProvider = 'local') {
+        if (!relativePath) {
+            return '';
+        }
+        switch (storageProvider) {
+            case 'local':
+                return this.toAbsolutePath(relativePath);
+            case 's3':
+            case 'oss':
+            case 'minio':
+            case 'cdn':
+                // 对象存储返回相对路径，由存储服务处理
+                return relativePath;
+            default:
+                return relativePath;
+        }
+    }
+}
+exports.FilePathUtil = FilePathUtil;

package/file-upload/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './dynamic-import.util';
+export * from './checksum.util';
+export * from './filename.util';
+export * from './filepath.util';

package/file-upload/utils/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dynamic-import.util"), exports);
+__exportStar(require("./checksum.util"), exports);
+__exportStar(require("./filename.util"), exports);
+__exportStar(require("./filepath.util"), exports);

package/filters/bad-request.filter.d.ts

@@ -1,5 +1,14 @@
 import type { ArgumentsHost, ExceptionFilter } from '@nestjs/common';
 import { Response } from 'express';
+import type { Logger } from 'nestjs-pino';
+/**
+ * HTTP Exception Filter
+ *
+ * Catches all exceptions and formats the response
+ * For 500 errors, logs via Pino Logger which will automatically send email alerts if EMAIL_LOG_ENABLED=true
+ */
 export declare class HttpExceptionFilter implements ExceptionFilter {
+    private readonly logger?;
+    constructor(logger?: Logger);
     catch(exception: any, host: ArgumentsHost): Response<any, Record<string, any>>;
 }

package/filters/bad-request.filter.js

@@ -5,14 +5,30 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpExceptionFilter = void 0;
 const common_1 = require("@nestjs/common");
 const typeorm_1 = require("typeorm");
 const nestjs_i18n_1 = require("nestjs-i18n");
+const validation_metadata_helper_1 = require("../common/helpers/validation-metadata-helper");
+/**
+ * HTTP Exception Filter
+ *
+ * Catches all exceptions and formats the response
+ * For 500 errors, logs via Pino Logger which will automatically send email alerts if EMAIL_LOG_ENABLED=true
+ */
 let HttpExceptionFilter = class HttpExceptionFilter {
+    constructor(logger) {
+        this.logger = logger;
+    }
     catch(exception, host) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         const i18n = nestjs_i18n_1.I18nContext.current(host);
         const ctx = host.switchToHttp();
         const response = ctx.getResponse();
@@ -26,17 +42,25 @@ let HttpExceptionFilter = class HttpExceptionFilter {
             error = 'Entity not found';
         }
         if (statusCode === 500) {
-            console.error({
-                message: exception.message,
-                stack: exception.stack,
-                connection: {
-                    localAddress: (_a = request.socket) === null || _a === void 0 ? void 0 : _a.localAddress,
-                    remoteAddress: (_b = request.socket) === null || _b === void 0 ? void 0 : _b.remoteAddress,
-                    bytesRead: (_c = request.socket) === null || _c === void 0 ? void 0 : _c.bytesRead,
-                    bytesWritten: (_d = request.socket) === null || _d === void 0 ? void 0 : _d.bytesWritten,
-                },
-                headers: request.headers,
-            });
+            const errorObj = exception instanceof Error ? exception : new Error(String(exception));
+            // Use Pino Logger if available (will send email alerts when EMAIL_LOG_ENABLED=true)
+            // Otherwise fallback to console.error
+            if (this.logger) {
+                this.logger.error(errorObj.message, errorObj.stack);
+            }
+            else {
+                console.error({
+                    message: errorObj.message,
+                    stack: errorObj.stack,
+                    connection: {
+                        localAddress: (_a = request.socket) === null || _a === void 0 ? void 0 : _a.localAddress,
+                        remoteAddress: (_b = request.socket) === null || _b === void 0 ? void 0 : _b.remoteAddress,
+                        bytesRead: (_c = request.socket) === null || _c === void 0 ? void 0 : _c.bytesRead,
+                        bytesWritten: (_d = request.socket) === null || _d === void 0 ? void 0 : _d.bytesWritten,
+                    },
+                    headers: request.headers,
+                });
+            }
         }
         const getFirstError = (error, property = '') => {
             var _a;
@@ -48,12 +72,26 @@ let HttpExceptionFilter = class HttpExceptionFilter {
             return error;
         };
         if (exception instanceof nestjs_i18n_1.I18nValidationException) {
-            const firstErros = getFirstError(exception.errors[0], exception.errors[0].property);
-            const constraint = Object.values(firstErros.constraints)[0];
+            const firstError = getFirstError(exception.errors[0], exception.errors[0].property);
+            const constraint = Object.values(firstError.constraints)[0];
             const [translationKey, argsString] = constraint.split('|');
             const args = !!argsString ? JSON.parse(argsString) : {};
+            // 获取当前语言
+            const lang = i18n.lang || 'zh';
+            // 在 stringify 之前获取 target
+            // firstError.target 可能是实例而不是构造函数，所以需要获取 constructor
+            let target = ((_e = firstError.target) === null || _e === void 0 ? void 0 : _e.constructor) || firstError.target;
+            if (!target && (firstError === null || firstError === void 0 ? void 0 : firstError.object)) {
+                target = firstError.object.constructor;
+            }
+            // 尝试从验证元数据中获取字段标签
+            const metadata = target ? (0, validation_metadata_helper_1.getValidationMetadata)(target, firstError.property) : undefined;
+            const fieldLabel = metadata
+                ? (0, validation_metadata_helper_1.getFieldLabelForValidation)(metadata, lang)
+                : firstError.property;
+            // 使用字段标签作为 property 参数
             error = i18n.translate(translationKey, {
-                args: Object.assign({ property: firstErros.property, value: firstErros.value, constraints: firstErros.constraints }, args),
+                args: Object.assign({ field: fieldLabel, property: fieldLabel, fieldName: fieldLabel, value: firstError.value, constraints: firstError.constraints }, args),
             });
         }
         const parseJson = {
@@ -67,5 +105,8 @@ let HttpExceptionFilter = class HttpExceptionFilter {
 };
 exports.HttpExceptionFilter = HttpExceptionFilter;
 exports.HttpExceptionFilter = HttpExceptionFilter = __decorate([
-    (0, common_1.Catch)()
+    (0, common_1.Catch)(),
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [Function])
 ], HttpExceptionFilter);

package/http-client/config/http-client.config.d.ts

@@ -1,4 +1,9 @@
 import { HttpClientConfig } from '../interfaces/http-client-config.interface';
+/**
+ * 深度合并配置
+ * 将用户配置与默认配置合并，用户配置会覆盖默认配置
+ */
+export declare function mergeHttpClientConfig(userConfig?: Partial<HttpClientConfig>, defaultConfig?: Partial<HttpClientConfig>): HttpClientConfig;
 /**
  * HTTP客户端默认配置
  */

package/http-client/config/http-client.config.js

@@ -1,8 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TEST_HTTP_CLIENT_CONFIG = exports.PRODUCTION_HTTP_CLIENT_CONFIG = exports.DEVELOPMENT_HTTP_CLIENT_CONFIG = exports.DEFAULT_HTTP_CLIENT_CONFIG = void 0;
+exports.mergeHttpClientConfig = mergeHttpClientConfig;
 exports.getHttpClientConfig = getHttpClientConfig;
-const cache_options_interface_1 = require("../../cache/interfaces/cache-options.interface");
+/**
+ * 深度合并对象
+ * 用于合并用户配置和默认配置
+ */
+function deepMerge(target, source) {
+    const result = Object.assign({}, target);
+    for (const key in source) {
+        if (source[key] instanceof Object &&
+            key in target &&
+            !Array.isArray(source[key])) {
+            result[key] = deepMerge(target[key], source[key]);
+        }
+        else {
+            result[key] = source[key];
+        }
+    }
+    return result;
+}
+/**
+ * 深度合并配置
+ * 将用户配置与默认配置合并，用户配置会覆盖默认配置
+ */
+function mergeHttpClientConfig(userConfig = {}, defaultConfig = exports.DEFAULT_HTTP_CLIENT_CONFIG) {
+    return deepMerge(defaultConfig, userConfig);
+}
 /**
  * HTTP客户端默认配置
  */
@@ -29,15 +54,6 @@ exports.DEFAULT_HTTP_CLIENT_CONFIG = {
         minimumThroughputThreshold: 10,
         countHalfOpenCalls: false,
     },
-    cache: {
-        enabled: true,
-        defaultTtl: 300000, // 5分钟
-        cacheableMethods: ['GET', 'HEAD'],
-        cacheableStatusCodes: [200, 201, 304],
-        options: {
-            layers: [cache_options_interface_1.CacheLayer.CLS, cache_options_interface_1.CacheLayer.MEMORY, cache_options_interface_1.CacheLayer.REDIS],
-        },
-    },
     logging: {
         enabled: true,
         logRequests: true,
@@ -46,12 +62,11 @@ exports.DEFAULT_HTTP_CLIENT_CONFIG = {
         logHeaders: false, // 默认不记录头信息（安全考虑）
         logBody: true,
         maxBodyLength: 1000,
-        sanitizeHeaders: ['authorization', 'apikey', 'password', 'token', 'cookie'],
+        sanitize: ['password', 'secret', 'token', 'apiKey', 'authorization', 'cookie'],
         logLevel: 'info',
         databaseLogging: {
             enabled: false, // 默认不启用数据库日志
             dataSource: 'default',
-            tableName: 'http_logs',
         },
     },
     logCleanup: {
@@ -69,7 +84,6 @@ exports.DEFAULT_HTTP_CLIENT_CONFIG = {
 exports.DEVELOPMENT_HTTP_CLIENT_CONFIG = Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG), { logging: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.logging), { enabled: true, logHeaders: true, logBody: true, logLevel: 'debug', databaseLogging: {
             enabled: true, // 开发环境启用数据库日志
             dataSource: 'default',
-            tableName: 'http_logs',
         } }), logCleanup: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.logCleanup), { enabled: false }) });
 /**
  * 生产环境配置
@@ -77,7 +91,6 @@ exports.DEVELOPMENT_HTTP_CLIENT_CONFIG = Object.assign(Object.assign({}, exports
 exports.PRODUCTION_HTTP_CLIENT_CONFIG = Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG), { timeout: 60000, retry: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.retry), { retries: 5 }), circuitBreaker: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.circuitBreaker), { failureThreshold: 3, recoveryTimeoutMs: 120000 }), logging: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.logging), { enabled: true, logHeaders: false, logBody: false, logLevel: 'warn', databaseLogging: {
             enabled: true, // 生产环境启用数据库日志
             dataSource: 'default',
-            tableName: 'http_logs',
         } }), logCleanup: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.logCleanup), { enabled: true, retentionDays: 7, maxRecords: 50000, schedule: '0 3 * * *' }) });
 /**
  * 测试环境配置