@nest-omni/core 4.1.3-12 → 4.1.3-13

package/{file-upload → dist/file-upload}/services/malicious-file-detector.service.d.ts

@@ -80,6 +80,12 @@ export interface MaliciousDetectorOptions {
     enableStructureAnalysis?: boolean;
     /** 风险阈值 */
     riskThreshold?: number;
+    /** 最大并发扫描数（防止 DoS） */
+    maxConcurrentScans?: number;
+    /** 最大扫描文件大小（字节，默认 10MB） */
+    maxScanSize?: number;
+    /** 扫描超时时间（毫秒，默认 60 秒） */
+    scanTimeout?: number;
 }
 /**
  * 恶意文件检测服务
@@ -180,14 +186,30 @@ export interface MaliciousDetectorOptions {
 export declare class MaliciousFileDetector {
     private readonly options?;
     private readonly logger;
+    private activeScanCount;
+    private readonly maxConcurrentScans;
+    private readonly maxScanSize;
+    private readonly scanTimeout;
     private readonly encodings;
     private readonly maliciousPatterns;
     private readonly suspiciousSignatures;
     constructor(options?: MaliciousDetectorOptions);
     /**
-     * 扫描文件（增强版）
+     * 扫描文件（增强版 - 带并发控制和流式处理）
      */
-    scanFile(filePath: string): Promise<DetectionResult>;
+    scanFile(filePath?: string, buffer?: Buffer): Promise<DetectionResult>;
+    /**
+     * 等待直到有可用的扫描槽位
+     */
+    private waitForScanSlot;
+    /**
+     * 执行实际的扫描操作
+     */
+    private performScan;
+    /**
+     * 使用流式处理读取文件（防止大文件占用过多内存）
+     */
+    private readFileStream;
     /**
      * 检查签名
      */
@@ -227,9 +249,13 @@ export declare class MaliciousFileDetector {
      */
     private scanWithClamAV;
     /**
-     * 本地ClamAV扫描
+     * 本地ClamAV扫描（增强安全性）
      */
     private scanWithLocalClamAV;
+    /**
+     * 验证 ClamAV 命令（仅允许白名单）
+     */
+    private validateClamAVCommand;
     /**
      * 验证文件路径，防止命令注入
      */

package/{file-upload → dist/file-upload}/services/malicious-file-detector.service.js

@@ -129,6 +129,8 @@ let MaliciousFileDetector = MaliciousFileDetector_1 = class MaliciousFileDetecto
     constructor(options) {
         this.options = options;
         this.logger = new common_1.Logger(MaliciousFileDetector_1.name);
+        // 并发控制：当前正在扫描的文件数
+        this.activeScanCount = 0;
         // 支持的编码列表
         this.encodings = ['utf8', 'utf16le', 'latin1', 'ascii', 'base64'];
         // 恶意模式库（多编码）
@@ -269,12 +271,16 @@ let MaliciousFileDetector = MaliciousFileDetector_1 = class MaliciousFileDetecto
             },
         ];
         this.options = Object.assign({ enabled: true, enableClamAV: false, clamavMode: 'local', clamavCommand: 'clamdscan', enableMultiEncoding: true, enableStructureAnalysis: true, riskThreshold: 50 }, options);
-        this.logger.debug(`MaliciousFileDetector constructor - options: ${JSON.stringify(this.options)}`);
+        // 初始化并发控制参数
+        this.maxConcurrentScans = this.options.maxConcurrentScans || 5;
+        this.maxScanSize = this.options.maxScanSize || 10 * 1024 * 1024; // 默认 10MB
+        this.scanTimeout = this.options.scanTimeout || 60000; // 默认 60 秒
+        this.logger.debug(`MaliciousFileDetector initialized - maxConcurrent: ${this.maxConcurrentScans}, maxSize: ${this.maxScanSize}, timeout: ${this.scanTimeout}`);
     }
     /**
-     * 扫描文件（增强版）
+     * 扫描文件（增强版 - 带并发控制和流式处理）
      */
-    scanFile(filePath) {
+    scanFile(filePath, buffer) {
         return __awaiter(this, void 0, void 0, function* () {
             // 检查是否启用
             if (this.options.enabled === false) {
@@ -286,42 +292,116 @@ let MaliciousFileDetector = MaliciousFileDetector_1 = class MaliciousFileDetecto
                     isMalware: false,
                 };
             }
-            this.logger.debug(`MaliciousFileDetector: Starting scan for file: ${filePath}`);
-            this.logger.debug(`MaliciousFileDetector: Options: ${JSON.stringify(this.options)}`);
+            // 如果没有文件路径且没有buffer，返回安全
+            if (!filePath && !buffer) {
+                this.logger.debug('No file path or buffer provided for scanning');
+                return {
+                    safe: true,
+                    threats: [],
+                    riskScore: 0,
+                    isMalware: false,
+                };
+            }
+            // 并发控制：等待直到有可用的扫描槽位
+            yield this.waitForScanSlot();
+            try {
+                // 增加活跃扫描计数
+                this.activeScanCount++;
+                this.logger.debug(`MaliciousFileDetector: Starting scan (${this.activeScanCount}/${this.maxConcurrentScans}): ${filePath || '(buffer)'}`);
+                // 设置超时保护
+                const scanPromise = this.performScan(filePath, buffer);
+                const timeoutPromise = new Promise((_, reject) => {
+                    setTimeout(() => {
+                        reject(new Error(`Scan timeout after ${this.scanTimeout}ms`));
+                    }, this.scanTimeout);
+                });
+                // 等待扫描完成或超时
+                return yield Promise.race([scanPromise, timeoutPromise]);
+            }
+            finally {
+                // 释放扫描槽位
+                this.activeScanCount--;
+                this.logger.debug(`MaliciousFileDetector: Scan completed (${this.activeScanCount}/${this.maxConcurrentScans})`);
+            }
+        });
+    }
+    /**
+     * 等待直到有可用的扫描槽位
+     */
+    waitForScanSlot() {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (this.activeScanCount >= this.maxConcurrentScans) {
+                this.logger.debug(`MaliciousFileDetector: Waiting for scan slot (${this.activeScanCount}/${this.maxConcurrentScans})`);
+                // 等待 100ms 后重试
+                yield new Promise((resolve) => setTimeout(resolve, 100));
+            }
+        });
+    }
+    /**
+     * 执行实际的扫描操作
+     */
+    performScan(filePath, inputBuffer) {
+        return __awaiter(this, void 0, void 0, function* () {
             const threats = [];
             let riskScore = 0;
             const details = {};
             try {
-                const stats = yield fs.stat(filePath);
-                this.logger.debug(`MaliciousFileDetector: File stats - size: ${stats.size}`);
-                // 读取文件：只读取前10MB以防止内存耗尽
-                const readSize = Math.min(stats.size, 10 * 1024 * 1024);
-                let buffer;
-                if (stats.size > 10 * 1024 * 1024) {
-                    // 大文件：只读取头部
-                    const fileHandle = yield fs.open(filePath, 'r');
-                    buffer = Buffer.alloc(readSize);
-                    try {
-                        yield fileHandle.read(buffer, 0, readSize, 0);
-                    }
-                    finally {
-                        yield fileHandle.close();
+                let scanBuffer;
+                let fileSize;
+                if (inputBuffer) {
+                    // Use provided buffer directly
+                    scanBuffer = inputBuffer;
+                    fileSize = inputBuffer.length;
+                    this.logger.debug(`MaliciousFileDetector: Using provided buffer - size: ${fileSize}`);
+                }
+                else if (filePath) {
+                    // Read file from disk
+                    const stats = yield fs.stat(filePath);
+                    fileSize = stats.size;
+                    this.logger.debug(`MaliciousFileDetector: File stats - size: ${stats.size}`);
+                    // Skip malicious file detection for very small files (< 100 bytes)
+                    // These are usually test placeholders or empty files
+                    if (fileSize < 100) {
+                        this.logger.debug(`MaliciousFileDetector: Skipping scan for very small file (${fileSize} bytes)`);
+                        return {
+                            safe: true,
+                            threats: [],
+                            riskScore: 0,
+                            isMalware: false,
+                        };
                     }
+                    // 使用流式处理读取文件（防止大文件占用过多内存）
+                    scanBuffer = yield this.readFileStream(filePath, stats.size);
+                    this.logger.debug(`MaliciousFileDetector: File read successfully, buffer size: ${scanBuffer.length}`);
                 }
                 else {
-                    // 小文件：直接读取全部
-                    buffer = yield fs.readFile(filePath);
+                    // No input provided
+                    return {
+                        safe: true,
+                        threats: [],
+                        riskScore: 0,
+                        isMalware: false,
+                    };
+                }
+                // Skip malicious file detection for very small buffers (< 100 bytes)
+                if (scanBuffer.length < 100) {
+                    this.logger.debug(`MaliciousFileDetector: Skipping scan for very small buffer (${scanBuffer.length} bytes)`);
+                    return {
+                        safe: true,
+                        threats: [],
+                        riskScore: 0,
+                        isMalware: false,
+                    };
                 }
-                this.logger.debug(`MaliciousFileDetector: File read successfully, buffer size: ${buffer.length}`);
                 // 1. 检查可疑签名
                 for (const signature of this.suspiciousSignatures) {
-                    if (this.checkSignature(buffer, signature)) {
+                    if (this.checkSignature(scanBuffer, signature)) {
                         threats.push(signature.description);
                         riskScore += signature.riskScore;
                         this.logger.debug(`MaliciousFileDetector: Found suspicious signature: ${signature.description}, risk: ${signature.riskScore}`);
                         // 如果需要检查压缩比
-                        if (signature.checkRatio) {
-                            const ratio = yield this.checkCompressionRatio(filePath, buffer);
+                        if (signature.checkRatio && filePath) {
+                            const ratio = yield this.checkCompressionRatio(filePath, scanBuffer);
                             if (ratio > 100) {
                                 threats.push('Suspicious compression ratio (possible zip bomb)');
                                 riskScore += 50;
@@ -332,7 +412,7 @@ let MaliciousFileDetector = MaliciousFileDetector_1 = class MaliciousFileDetecto
                 }
                 // 2. 多编码检测（新增）
                 if (this.options.enableMultiEncoding) {
-                    const encodingResult = this.detectMultiEncodingThreats(buffer);
+                    const encodingResult = this.detectMultiEncodingThreats(scanBuffer);
                     if (encodingResult.threats.length > 0) {
                         threats.push(...encodingResult.threats);
                         riskScore += encodingResult.riskScore;
@@ -342,7 +422,7 @@ let MaliciousFileDetector = MaliciousFileDetector_1 = class MaliciousFileDetecto
                 }
                 // 3. 文件结构分析（新增）
                 if (this.options.enableStructureAnalysis) {
-                    const structureResult = yield this.analyzeFileStructure(filePath, buffer);
+                    const structureResult = yield this.analyzeFileStructure(filePath, scanBuffer);
                     if (structureResult.anomalies.length > 0) {
                         threats.push(...structureResult.anomalies);
                         riskScore += structureResult.riskScore;
@@ -351,7 +431,7 @@ let MaliciousFileDetector = MaliciousFileDetector_1 = class MaliciousFileDetecto
                     }
                 }
                 // 4. ClamAV扫描（新增，可选）
-                if (this.options.enableClamAV) {
+                if (this.options.enableClamAV && filePath) {
                     const clamavResult = yield this.scanWithClamAV(filePath);
                     details.clamavResult = clamavResult;
                     if (clamavResult.infected) {
@@ -361,32 +441,45 @@ let MaliciousFileDetector = MaliciousFileDetector_1 = class MaliciousFileDetecto
                     }
                 }
                 // 5. 检查文件名
-                const fileName = path.basename(filePath);
-                if (this.hasSuspiciousName(fileName)) {
-                    threats.push('Suspicious filename pattern');
-                    riskScore += 20;
-                    this.logger.debug(`MaliciousFileDetector: Suspicious filename pattern detected: ${fileName}`);
+                if (filePath) {
+                    const fileName = path.basename(filePath);
+                    if (this.hasSuspiciousName(fileName)) {
+                        threats.push('Suspicious filename pattern');
+                        riskScore += 20;
+                        this.logger.debug(`MaliciousFileDetector: Suspicious filename pattern detected: ${fileName}`);
+                    }
+                    // 6. 检查双扩展名
+                    if (this.hasDoubleExtension(fileName)) {
+                        threats.push('Double extension detected');
+                        riskScore += 30;
+                        this.logger.debug(`MaliciousFileDetector: Double extension detected: ${fileName}`);
+                    }
+                    // 7. 检查隐藏扩展名技巧
+                    if (this.hasHiddenExtension(fileName)) {
+                        threats.push('Hidden extension trick detected');
+                        riskScore += 40;
+                        this.logger.debug(`MaliciousFileDetector: Hidden extension trick detected: ${fileName}`);
+                    }
                 }
-                // 6. 检查文件大小异常
-                if (stats.size > 500 * 1024 * 1024) {
+                // 8. 检查文件大小异常
+                if (fileSize > 500 * 1024 * 1024) {
                     // 大于500MB
                     threats.push('Unusually large file size');
                     riskScore += 15;
-                    this.logger.debug(`MaliciousFileDetector: Unusually large file size: ${stats.size}`);
+                    this.logger.debug(`MaliciousFileDetector: Unusually large file size: ${fileSize}`);
                 }
-                // 7. 检查双扩展名
-                if (this.hasDoubleExtension(fileName)) {
-                    threats.push('Double extension detected');
-                    riskScore += 30;
-                    this.logger.debug(`MaliciousFileDetector: Double extension detected: ${fileName}`);
+                // 9. 动态阈值调整（小文件更宽松）
+                let threshold = this.options.riskThreshold || 50;
+                if (fileSize < 1024) {
+                    // 小于1KB的文件，提高阈值（减少误报）
+                    threshold = Math.max(threshold, 80);
+                    this.logger.debug(`MaliciousFileDetector: Using increased threshold for small file (${fileSize} bytes): ${threshold}`);
                 }
-                // 8. 检查隐藏扩展名技巧
-                if (this.hasHiddenExtension(fileName)) {
-                    threats.push('Hidden extension trick detected');
-                    riskScore += 40;
-                    this.logger.debug(`MaliciousFileDetector: Hidden extension trick detected: ${fileName}`);
+                else if (fileSize < 10 * 1024) {
+                    // 小于10KB的文件，适当提高阈值
+                    threshold = Math.max(threshold, 65);
+                    this.logger.debug(`MaliciousFileDetector: Using increased threshold for medium-small file (${fileSize} bytes): ${threshold}`);
                 }
-                const threshold = this.options.riskThreshold || 50;
                 const isSafe = riskScore < threshold;
                 this.logger.debug(`MaliciousFileDetector: Final result - safe: ${isSafe}, riskScore: ${riskScore}, threshold: ${threshold}, threats: ${threats.join(', ')}`);
                 return {
@@ -408,6 +501,46 @@ let MaliciousFileDetector = MaliciousFileDetector_1 = class MaliciousFileDetecto
             }
         });
     }
+    /**
+     * 使用流式处理读取文件（防止大文件占用过多内存）
+     */
+    readFileStream(filePath, fileSize) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 限制读取大小
+            const readSize = Math.min(fileSize, this.maxScanSize);
+            // 如果文件较小，直接读取
+            if (fileSize <= 1024 * 1024) {
+                // 1MB 以下直接读取
+                return fs.readFile(filePath);
+            }
+            // 大文件使用流式处理
+            return new Promise((resolve, reject) => {
+                const chunks = [];
+                let totalRead = 0;
+                const stream = fs.createReadStream(filePath, {
+                    highWaterMark: 64 * 1024, // 每次读取 64KB
+                    end: readSize - 1, // 只读取前 N 字节
+                });
+                stream.on('data', (chunk) => {
+                    chunks.push(chunk);
+                    totalRead += chunk.length;
+                    // 额外的安全检查：如果超过限制，立即停止
+                    if (totalRead > this.maxScanSize) {
+                        stream.destroy();
+                        reject(new Error(`File size exceeds scan limit: ${this.maxScanSize}`));
+                    }
+                });
+                stream.on('end', () => {
+                    const buffer = Buffer.concat(chunks);
+                    this.logger.debug(`Read ${buffer.length} bytes from ${filePath} using stream`);
+                    resolve(buffer);
+                });
+                stream.on('error', (error) => {
+                    reject(error);
+                });
+            });
+        });
+    }
     /**
      * 检查签名
      */
@@ -660,46 +793,84 @@ let MaliciousFileDetector = MaliciousFileDetector_1 = class MaliciousFileDetecto
         });
     }
     /**
-     * 本地ClamAV扫描
+     * 本地ClamAV扫描（增强安全性）
      */
     scanWithLocalClamAV(filePath) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                // 验证文件路径安全性，防止命令注入
+                // 1. 验证 ClamAV 命令（仅允许白名单命令）
+                this.validateClamAVCommand();
+                // 2. 验证文件路径安全性
                 this.validateFilePath(filePath);
+                // 3. 验证文件存在且可读
+                const absoluteFilePath = path.resolve(filePath);
+                if (!fs.existsSync(absoluteFilePath)) {
+                    throw new Error(`File does not exist: ${filePath}`);
+                }
                 // 使用 spawn 和参数数组，避免命令注入
                 const { spawn } = yield Promise.resolve().then(() => require('child_process'));
                 return new Promise((resolve, reject) => {
-                    const args = ['--no-summary', filePath];
-                    const child = spawn(this.options.clamavCommand, args);
+                    const args = ['--no-summary', absoluteFilePath];
+                    // 使用安全选项启动进程
+                    const child = spawn(this.options.clamavCommand, args, {
+                        timeout: 30000, // 进程级超时
+                        windowsHide: true, // Windows 下隐藏窗口
+                        shell: false, // 禁用 shell，防止 shell 注入
+                    });
                     let stdout = '';
                     let stderr = '';
+                    let killed = false;
+                    // 限制输出大小，防止内存溢出
+                    const MAX_OUTPUT_SIZE = 1024 * 1024; // 1MB
                     child.stdout.on('data', (data) => {
+                        if (stdout.length + data.length > MAX_OUTPUT_SIZE) {
+                            this.logger.warn('ClamAV output size exceeded limit');
+                            child.kill('SIGKILL');
+                            killed = true;
+                            reject(new Error('ClamAV output size exceeded limit'));
+                            return;
+                        }
                         stdout += data.toString();
                     });
                     child.stderr.on('data', (data) => {
+                        if (stderr.length + data.length > MAX_OUTPUT_SIZE) {
+                            this.logger.warn('ClamAV error output size exceeded limit');
+                            child.kill('SIGKILL');
+                            killed = true;
+                            reject(new Error('ClamAV error output size exceeded limit'));
+                            return;
+                        }
                         stderr += data.toString();
                     });
                     // 设置超时
                     const timeout = setTimeout(() => {
-                        child.kill('SIGKILL');
-                        reject(new Error('ClamAV scan timeout'));
+                        if (!killed && !child.killed) {
+                            this.logger.warn('ClamAV scan timeout, killing process');
+                            child.kill('SIGKILL');
+                            killed = true;
+                        }
                     }, 30000);
                     child.on('close', (code) => {
                         clearTimeout(timeout);
+                        // 如果已经被 killed，不再处理
+                        if (killed) {
+                            return;
+                        }
+                        // ClamAV 退出码：0=无病毒, 1=发现病毒, 其他=错误
                         if (code !== 0 && code !== 1) {
-                            reject(new Error(`ClamAV process exited with code ${code}`));
+                            reject(new Error(`ClamAV process exited with code ${code}: ${stderr}`));
                             return;
                         }
                         // 解析ClamAV输出
                         const output = stdout + stderr;
                         if (output.includes('FOUND')) {
-                            // 提取病毒名称
+                            // 提取病毒名称（限制长度）
                             const match = output.match(/: ([^:]+) FOUND/);
+                            const virusName = match ? match[1].substring(0, 100) : 'Unknown';
                             resolve({
                                 scanned: true,
                                 infected: true,
-                                virusName: match ? match[1] : 'Unknown',
+                                virusName,
                             });
                         }
                         else {
@@ -711,7 +882,18 @@ let MaliciousFileDetector = MaliciousFileDetector_1 = class MaliciousFileDetecto
                     });
                     child.on('error', (error) => {
                         clearTimeout(timeout);
-                        reject(error);
+                        if (!killed) {
+                            // 尝试清理进程
+                            try {
+                                if (!child.killed) {
+                                    child.kill('SIGKILL');
+                                }
+                            }
+                            catch (killError) {
+                                this.logger.error(`Failed to kill ClamAV process: ${killError.message}`);
+                            }
+                            reject(error);
+                        }
                     });
                 });
             }
@@ -726,6 +908,23 @@ let MaliciousFileDetector = MaliciousFileDetector_1 = class MaliciousFileDetecto
             }
         });
     }
+    /**
+     * 验证 ClamAV 命令（仅允许白名单）
+     */
+    validateClamAVCommand() {
+        const allowedCommands = ['clamscan', 'clamdscan'];
+        const commandBasename = path.basename(this.options.clamavCommand);
+        if (!allowedCommands.includes(commandBasename)) {
+            throw new Error(`Invalid ClamAV command: ${commandBasename}. Allowed: ${allowedCommands.join(', ')}`);
+        }
+        // 检查命令路径不包含危险字符
+        const dangerousChars = [';', '&', '|', '$', '`', '\n', '\r'];
+        for (const char of dangerousChars) {
+            if (this.options.clamavCommand.includes(char)) {
+                throw new Error(`Dangerous character in ClamAV command path: ${char}`);
+            }
+        }
+    }
     /**
      * 验证文件路径，防止命令注入
      */

package/{file-upload → dist/file-upload}/utils/dynamic-import.util.d.ts

@@ -36,9 +36,13 @@ export declare class DynamicImportUtil {
      */
     static importExcelJs(): Promise<any>;
     /**
-     * 动态导入 CSV 处理库
+     * 动态导入 XLSX 处理库
      */
-    static importCsvParse(): Promise<any>;
+    static importXlsx(): Promise<any>;
+    /**
+     * 动态导入 fast-csv 处理库
+     */
+    static importFastCsv(): Promise<any>;
     /**
      * 检查依赖是否已安装
      */

package/{file-upload → dist/file-upload}/utils/dynamic-import.util.js

@@ -108,15 +108,27 @@ class DynamicImportUtil {
         });
     }
     /**
-     * 动态导入 CSV 处理库
+     * 动态导入 XLSX 处理库
      */
-    static importCsvParse() {
+    static importXlsx() {
         return __awaiter(this, void 0, void 0, function* () {
-            const csvModule = yield tryImport('csv-parse');
+            const xlsxModule = yield tryImport('xlsx');
+            if (!xlsxModule) {
+                throw new Error('XLSX is not installed. Please install it using: npm install xlsx');
+            }
+            return xlsxModule.default || xlsxModule;
+        });
+    }
+    /**
+     * 动态导入 fast-csv 处理库
+     */
+    static importFastCsv() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const csvModule = yield tryImport('fast-csv');
             if (!csvModule) {
-                throw new Error('csv-parse is not installed. Please install it using: npm install csv-parse');
+                throw new Error('fast-csv is not installed. Please install it using: npm install fast-csv');
             }
-            return csvModule;
+            return csvModule.default || csvModule;
         });
     }
     /**

package/{http-client → dist/http-client}/decorators/http-client.decorators.d.ts

@@ -75,8 +75,10 @@ export declare const HttpTimeout: (timeoutMs: number) => (target: any, propertyK
  * 代理装饰器
  */
 export declare const HttpUseProxy: (options: {
-    host: string;
-    port: number;
+    enabled?: boolean;
+    fromEnvironment?: boolean;
+    host?: string;
+    port?: number;
     protocol?: "http" | "https";
     auth?: {
         username: string;

package/{http-client → dist/http-client}/decorators/http-client.decorators.js

@@ -183,7 +183,8 @@ exports.HttpTimeout = HttpTimeout;
  */
 const HttpUseProxy = (options) => {
     return (target, propertyKey, descriptor) => {
-        (0, common_1.SetMetadata)(`${exports.PROXY_OPTIONS_KEY}_${propertyKey}`, options)(descriptor.value);
+        const proxyConfig = Object.assign({ enabled: options.enabled !== false }, options);
+        (0, common_1.SetMetadata)(`${exports.PROXY_OPTIONS_KEY}_${propertyKey}`, proxyConfig)(descriptor.value);
         return descriptor;
     };
 };

package/{http-client → dist/http-client}/entities/http-log.entity.js

@@ -21,22 +21,18 @@ let HttpLogEntity = class HttpLogEntity extends common_1.AbstractUuidPrimaryEnti
 exports.HttpLogEntity = HttpLogEntity;
 __decorate([
     (0, typeorm_1.Column)({ type: 'varchar', length: 36, nullable: true }),
-    (0, typeorm_1.Index)(),
     __metadata("design:type", String)
 ], HttpLogEntity.prototype, "requestId", void 0);
 __decorate([
     (0, typeorm_1.Column)({ type: 'varchar', length: 36, nullable: true }),
-    (0, typeorm_1.Index)(),
     __metadata("design:type", String)
 ], HttpLogEntity.prototype, "userId", void 0);
 __decorate([
     (0, typeorm_1.Column)({ type: 'varchar', length: 10 }),
-    (0, typeorm_1.Index)(),
     __metadata("design:type", String)
 ], HttpLogEntity.prototype, "method", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ type: 'text' }),
-    (0, typeorm_1.Index)(),
+    (0, typeorm_1.Column)({ type: 'varchar' }),
     __metadata("design:type", String)
 ], HttpLogEntity.prototype, "url", void 0);
 __decorate([
@@ -53,7 +49,6 @@ __decorate([
 ], HttpLogEntity.prototype, "params", void 0);
 __decorate([
     (0, typeorm_1.Column)({ type: 'int', nullable: true }),
-    (0, typeorm_1.Index)(),
     __metadata("design:type", Number)
 ], HttpLogEntity.prototype, "statusCode", void 0);
 __decorate([
@@ -66,7 +61,6 @@ __decorate([
 ], HttpLogEntity.prototype, "attemptCount", void 0);
 __decorate([
     (0, typeorm_1.Column)({ type: 'boolean', default: false }),
-    (0, typeorm_1.Index)(),
     __metadata("design:type", Boolean)
 ], HttpLogEntity.prototype, "success", void 0);
 __decorate([
@@ -103,7 +97,6 @@ __decorate([
 ], HttpLogEntity.prototype, "serviceName", void 0);
 __decorate([
     (0, typeorm_1.Column)({ type: 'varchar', length: 200, nullable: true }),
-    (0, typeorm_1.Index)(),
     __metadata("design:type", String)
 ], HttpLogEntity.prototype, "operationName", void 0);
 __decorate([
@@ -140,7 +133,6 @@ exports.HttpLogEntity = HttpLogEntity = __decorate([
     (0, typeorm_1.Index)(['requestId']),
     (0, typeorm_1.Index)(['userId']),
     (0, typeorm_1.Index)(['method']),
-    (0, typeorm_1.Index)(['url']),
     (0, typeorm_1.Index)(['statusCode']),
     (0, typeorm_1.Index)(['success']),
     (0, typeorm_1.Index)(['createdAt']),