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

package/file-upload/interceptors/file-upload.interceptor.js

@@ -28,6 +28,7 @@ const core_1 = require("@nestjs/core");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const file_upload_decorator_1 = require("../decorators/file-upload.decorator");
+const file_entity_interface_1 = require("../interfaces/file-entity.interface");
 const file_service_1 = require("../services/file.service");
 const file_signature_validator_service_1 = require("../services/file-signature-validator.service");
 const malicious_file_detector_service_1 = require("../services/malicious-file-detector.service");
@@ -37,7 +38,7 @@ const file_upload_exception_1 = require("../exceptions/file-upload.exception");
 const fs = require("fs-extra");
 const crypto = require("crypto");
 /**
- * 文件上传拦截器（增强版）
+ * 文件上传拦截器（优化版）
  * 负责创建文件记录、执行钩子、处理器等后置逻辑
  */
 let FileUploadInterceptor = FileUploadInterceptor_1 = class FileUploadInterceptor {
@@ -53,187 +54,186 @@ let FileUploadInterceptor = FileUploadInterceptor_1 = class FileUploadIntercepto
     }
     intercept(context, next) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
             const options = this.reflector.get(file_upload_decorator_1.FILE_UPLOAD_OPTIONS, context.getHandler());
-            this.logger.debug(`FileUploadInterceptor: Received options: ${JSON.stringify(options)}`);
             if (!options) {
-                this.logger.debug('FileUploadInterceptor: No options provided, continuing');
                 return next.handle();
             }
             const request = context.switchToHttp().getRequest();
             const file = request.file;
-            this.logger.debug(`FileUploadInterceptor: File info: ${JSON.stringify({
-                originalname: file === null || file === void 0 ? void 0 : file.originalname,
-                mimetype: file === null || file === void 0 ? void 0 : file.mimetype,
-                size: file === null || file === void 0 ? void 0 : file.size,
-                path: file === null || file === void 0 ? void 0 : file.path,
-            })}`);
             if (!file) {
-                this.logger.debug('FileUploadInterceptor: No file in request, continuing');
                 return next.handle();
             }
-            // ===== 在拦截器中执行所有验证（文件已上传到磁盘） =====
-            // 1. 验证文件大小（读取真实大小）
+            // 快速路径：如果没有配置验证选项，直接跳过验证
+            if (this.shouldSkipValidation(options, request)) {
+                return this.processFile(file, request, options, next);
+            }
+            // 执行验证
+            yield this.validateFile(file, options, request);
+            // 处理文件
+            return this.processFile(file, request, options, next);
+        });
+    }
+    /**
+     * 判断是否应该跳过验证
+     */
+    shouldSkipValidation(options, request) {
+        var _a, _b;
+        return (!options.maxSize &&
+            !((_a = options.types) === null || _a === void 0 ? void 0 : _a.length) &&
+            !((_b = options.exts) === null || _b === void 0 ? void 0 : _b.length) &&
+            !options.auth &&
+            options.validateSignature === false &&
+            options.maliciousCheck === false);
+    }
+    /**
+     * 验证文件
+     */
+    validateFile(file, options, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 1. 验证文件大小
             if (options.maxSize && file.size > options.maxSize) {
-                this.logger.debug(`FileUploadInterceptor: File size exceeded: ${file.size} > ${options.maxSize}`);
                 throw new file_upload_exception_1.FileSizeExceededException(file.size, options.maxSize);
             }
-            // 2. 验证文件类型和扩展名
-            if (options.types && options.types.length > 0) {
-                const allowedTypes = this.mimeRegistry.resolveFileTypes(options.types);
-                this.logger.debug(`FileUploadInterceptor: Allowed types: ${JSON.stringify(allowedTypes)}`);
-                // 验证 MIME 类型
-                if (!this.validateMimeType(file.mimetype, allowedTypes.mimes)) {
-                    this.logger.debug(`FileUploadInterceptor: File type not allowed: ${file.mimetype}`);
-                    throw new file_upload_exception_1.FileTypeNotAllowedException(file.mimetype, allowedTypes.mimes);
-                }
-                // 验证扩展名
-                if (allowedTypes.exts.length > 0) {
-                    const ext = utils_1.FileNameUtil.extractExtension(file.originalname);
-                    if (!this.validateExtension(ext, allowedTypes.exts)) {
-                        this.logger.debug(`FileUploadInterceptor: File extension not allowed: ${ext}`);
-                        throw new file_upload_exception_1.FileExtensionNotAllowedException(ext, allowedTypes.exts);
-                    }
-                }
-            }
-            // 3. 验证自定义扩展名
-            if (options.exts && options.exts.length > 0) {
-                const ext = utils_1.FileNameUtil.extractExtension(file.originalname);
-                if (!this.validateExtension(ext, options.exts)) {
-                    this.logger.debug(`FileUploadInterceptor: Custom extension not allowed: ${ext}`);
-                    throw new file_upload_exception_1.FileExtensionNotAllowedException(ext, options.exts);
-                }
-            }
-            // 4. 验证访问权限
+            // 2. 验证权限
             if (options.auth && !request.user) {
-                this.logger.debug('FileUploadInterceptor: Authentication required but not provided');
                 throw new common_1.UnauthorizedException('Authentication required for file upload');
             }
-            // 5. 文件名清理（默认启用）
+            // 3. 验证文件名
             if (options.sanitize !== false) {
                 const sanitized = utils_1.FileNameUtil.sanitize(file.originalname);
                 if (!sanitized || sanitized.length === 0) {
-                    this.logger.debug(`FileUploadInterceptor: Invalid filename after sanitization: ${file.originalname}`);
                     throw new file_upload_exception_1.InvalidFilenameException(file.originalname);
                 }
-                // 注意：这里不修改 file.originalname，保持原始文件名用于后续处理
-                this.logger.debug(`FileUploadInterceptor: Filename sanitized to: ${sanitized}`);
             }
-            // 6. 文件签名验证（如果文件已上传到磁盘）
-            if (file.path && options.types && options.types.length > 0) {
-                const validateSignature = options.validateSignature !== undefined
-                    ? options.validateSignature
-                    : ((_a = this.moduleOptions) === null || _a === void 0 ? void 0 : _a.validateSignature) !== false;
-                this.logger.debug(`FileUploadInterceptor: Signature validation - will validate: ${validateSignature}`);
-                if (validateSignature && this.signatureValidator) {
-                    try {
-                        const allowedTypes = this.mimeRegistry.resolveFileTypes(options.types);
-                        if (allowedTypes.signatureTypes.length > 0) {
-                            const signatureResult = yield this.signatureValidator.validateFileSignature(file.path, allowedTypes.signatureTypes, (_b = this.moduleOptions) === null || _b === void 0 ? void 0 : _b.signatureValidation);
-                            if (!signatureResult.valid) {
-                                const detectedType = (_c = signatureResult.detectedTypes[0]) === null || _c === void 0 ? void 0 : _c.type;
-                                this.logger.debug(`FileUploadInterceptor: File signature mismatch: ${signatureResult.errors.join(', ')}`);
-                                throw new file_upload_exception_1.FileSignatureMismatchException(signatureResult.errors.join(', '), file.mimetype, detectedType);
-                            }
-                            // 将验证数据附加到请求
-                            request.fileValidationData = signatureResult;
-                            this.logger.debug('FileUploadInterceptor: File signature validation passed');
-                        }
-                    }
-                    catch (error) {
-                        if (error instanceof file_upload_exception_1.FileSignatureMismatchException) {
-                            throw error;
-                        }
-                        // 签名验证出错
-                        if ((_e = (_d = this.moduleOptions) === null || _d === void 0 ? void 0 : _d.signatureValidation) === null || _e === void 0 ? void 0 : _e.strict) {
-                            this.logger.error(`Signature validation failed in strict mode: ${error.message}`, error.stack);
-                            throw error;
-                        }
-                        this.logger.warn(`Signature validation error (non-strict mode): ${error.message}`);
-                    }
+            // 4. 批量验证文件类型和扩展名
+            yield this.validateFileTypeAndExtension(file, options);
+            // 5. 文件签名验证（可选）
+            if (this.shouldPerformSignatureValidation(options) && file.path) {
+                yield this.validateFileSignature(file, options);
+            }
+            // 6. 恶意文件检测（可选）
+            if (this.shouldPerformMaliciousCheck(options)) {
+                yield this.checkMaliciousFile(file, options);
+            }
+        });
+    }
+    /**
+     * 批量验证文件类型和扩展名
+     */
+    validateFileTypeAndExtension(file, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            if (!((_a = options.types) === null || _a === void 0 ? void 0 : _a.length) && !((_b = options.exts) === null || _b === void 0 ? void 0 : _b.length)) {
+                return;
+            }
+            const allowedTypes = ((_c = options.types) === null || _c === void 0 ? void 0 : _c.length)
+                ? this.mimeRegistry.resolveFileTypes(options.types)
+                : { mimes: [], exts: options.exts || [] };
+            // 获取文件扩展名
+            const ext = utils_1.FileNameUtil.extractExtension(file.originalname);
+            // 同时验证 MIME 类型和扩展名
+            const mimeValid = !allowedTypes.mimes.length ||
+                allowedTypes.mimes.some((mime) => mime.endsWith('/*')
+                    ? file.mimetype.startsWith(mime.slice(0, -2))
+                    : mime === file.mimetype);
+            const extValid = !allowedTypes.exts.length ||
+                allowedTypes.exts.some((allowedExt) => allowedExt.toLowerCase() === ext.toLowerCase());
+            if (!mimeValid || !extValid) {
+                if (!mimeValid) {
+                    throw new file_upload_exception_1.FileTypeNotAllowedException(file.mimetype, allowedTypes.mimes);
+                }
+                if (!extValid) {
+                    throw new file_upload_exception_1.FileExtensionNotAllowedException(ext, allowedTypes.exts);
                 }
             }
-            // 7. 恶意文件检测（如果文件已上传到磁盘）
-            const shouldPerformMaliciousCheck = options.maliciousCheck !== undefined
-                ? options.maliciousCheck
-                : ((_g = (_f = this.moduleOptions) === null || _f === void 0 ? void 0 : _f.maliciousDetection) === null || _g === void 0 ? void 0 : _g.enabled) !== false;
-            this.logger.debug(`FileUploadInterceptor: Malicious check - should perform: ${shouldPerformMaliciousCheck}`);
-            if (shouldPerformMaliciousCheck && this.maliciousDetector && file.path) {
-                this.logger.debug(`FileUploadInterceptor: Performing malicious file detection on: ${file.path}`);
-                try {
-                    const maliciousCheck = yield this.maliciousDetector.scanFile(file.path);
-                    this.logger.debug(`FileUploadInterceptor: Malicious check result: safe=${maliciousCheck.safe}, score=${maliciousCheck.riskScore}, threats=${maliciousCheck.threats.join(', ')}`);
-                    if (!maliciousCheck.safe) {
-                        this.logger.warn(`FileUploadInterceptor: Malicious file detected: ${file.originalname}`, maliciousCheck.threats);
-                        throw new file_upload_exception_1.MaliciousFileException(maliciousCheck.threats);
-                    }
-                    // 附加检测数据到请求
-                    request.fileMaliciousCheck = maliciousCheck;
-                    this.logger.debug('FileUploadInterceptor: Malicious file detection passed');
+        });
+    }
+    /**
+     * 判断是否需要执行文件签名验证
+     */
+    shouldPerformSignatureValidation(options) {
+        var _a, _b;
+        return (options.validateSignature !== false &&
+            ((_a = this.moduleOptions) === null || _a === void 0 ? void 0 : _a.validateSignature) !== false &&
+            this.signatureValidator &&
+            ((_b = options.types) === null || _b === void 0 ? void 0 : _b.length) > 0);
+    }
+    /**
+     * 验证文件签名
+     */
+    validateFileSignature(file, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            try {
+                const allowedTypes = this.mimeRegistry.resolveFileTypes(options.types);
+                if (allowedTypes.signatureTypes.length === 0) {
+                    return;
                 }
-                catch (error) {
-                    if (error instanceof file_upload_exception_1.MaliciousFileException) {
-                        throw error;
-                    }
-                    // 检测出错，记录日志但继续
-                    this.logger.error(`FileUploadInterceptor: Malicious detection error: ${error.message}`);
+                const signatureResult = yield this.signatureValidator.validateFileSignature(file.path, allowedTypes.signatureTypes, (_a = this.moduleOptions) === null || _a === void 0 ? void 0 : _a.signatureValidation);
+                if (!signatureResult.valid) {
+                    const detectedType = (_b = signatureResult.detectedTypes[0]) === null || _b === void 0 ? void 0 : _b.type;
+                    throw new file_upload_exception_1.FileSignatureMismatchException(signatureResult.errors.join(', '), file.mimetype, detectedType);
+                }
+                // 附加验证数据到请求
+                if (signatureResult) {
+                    file._validationData = signatureResult;
                 }
             }
-            else {
-                this.logger.debug(`FileUploadInterceptor: Skipping malicious check - detector: ${!!this.maliciousDetector}, file.path: ${!!file.path}`);
+            catch (error) {
+                if (error instanceof file_upload_exception_1.FileSignatureMismatchException) {
+                    throw error;
+                }
+                if ((_d = (_c = this.moduleOptions) === null || _c === void 0 ? void 0 : _c.signatureValidation) === null || _d === void 0 ? void 0 : _d.strict) {
+                    throw error;
+                }
+                // 非严格模式下只记录警告
+                this.logger.warn(`Signature validation failed: ${error.message}`);
             }
-            // ===== 所有验证完成 =====
-            // 创建文件实体记录（如果FileService可用）
-            let fileEntity = null;
-            let uploadId = null;
-            if (this.fileService) {
-                try {
-                    uploadId = request.body.uploadId || this.generateUploadId();
-                    const checksum = file.path
-                        ? yield this.calculateChecksum(file.path)
-                        : undefined;
-                    // 处理 originalName: UTF-8 编码并截取到 100 字符（使用统一工具类）
-                    const processedOriginalName = utils_1.FileNameUtil.decodeAndNormalize(file.originalname);
-                    fileEntity = yield this.fileService.create({
-                        originalName: processedOriginalName,
-                        filename: file.filename,
-                        mimeType: file.mimetype,
-                        size: file.size,
-                        tempPath: file.path,
-                        storageProvider: 'local',
-                        userId: (_h = request.user) === null || _h === void 0 ? void 0 : _h.id,
-                        uploadId,
-                        status: 'processing',
-                        checksum,
-                    });
-                    // 自动识别并设置文件类型
-                    fileEntity.detectAndSetFileType();
-                    yield this.fileService.update(fileEntity.id, {
-                        fileType: fileEntity.fileType,
-                        extension: fileEntity.extension,
-                    });
-                    // 添加验证数据（如果有）
-                    if (request.fileValidationData) {
-                        fileEntity.addValidationData({
-                            detectedTypes: request.fileValidationData.detectedTypes || [],
-                            signatures: ((_j = request.fileValidationData.metadata) === null || _j === void 0 ? void 0 : _j.signatures) || [],
-                            integrityChecks: [],
-                        });
-                        yield this.fileService.update(fileEntity.id, {
-                            validationData: fileEntity.validationData,
-                        });
-                    }
-                    // 附加到请求对象
-                    request.fileEntity = fileEntity;
-                    request.uploadId = uploadId;
-                    this.logger.debug(`File entity created: ${fileEntity.id}`);
+        });
+    }
+    /**
+     * 判断是否需要执行恶意文件检测
+     */
+    shouldPerformMaliciousCheck(options) {
+        var _a, _b;
+        return (options.maliciousCheck !== false &&
+            ((_b = (_a = this.moduleOptions) === null || _a === void 0 ? void 0 : _a.maliciousDetection) === null || _b === void 0 ? void 0 : _b.enabled) !== false &&
+            !!this.maliciousDetector);
+    }
+    /**
+     * 检测恶意文件
+     */
+    checkMaliciousFile(file, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // For in-memory files, use buffer; for disk files, use path
+                const maliciousCheck = file.path
+                    ? yield this.maliciousDetector.scanFile(file.path)
+                    : yield this.maliciousDetector.scanFile(undefined, file.buffer);
+                if (!maliciousCheck.safe) {
+                    throw new file_upload_exception_1.MaliciousFileException(maliciousCheck.threats);
+                }
+                // 附加检测数据到请求
+                if (maliciousCheck) {
+                    file._maliciousCheck = maliciousCheck;
                 }
-                catch (error) {
-                    this.logger.error(`Failed to create file entity: ${error.message}`);
-                    // 设置fileEntity为null，后续代码会检查并跳过数据库操作
-                    fileEntity = null;
+            }
+            catch (error) {
+                if (error instanceof file_upload_exception_1.MaliciousFileException) {
+                    throw error;
                 }
+                // 检测出错，记录日志但继续
+                this.logger.error(`Malicious detection error: ${error.message}`);
             }
+        });
+    }
+    /**
+     * 处理文件
+     */
+    processFile(file, request, options, next) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 创建文件实体记录（如果可用）
+            const { fileEntity, uploadId } = yield this.createFileEntity(file, request);
             // 创建上传上下文
             const uploadContext = this.createUploadContext(request, fileEntity);
             try {
@@ -241,91 +241,36 @@ let FileUploadInterceptor = FileUploadInterceptor_1 = class FileUploadIntercepto
                 if (options.before) {
                     yield options.before(file, uploadContext);
                 }
-                // 执行装饰器配置的处理器
-                if (options.processor) {
-                    const processorConfig = typeof options.processor === 'string'
-                        ? { name: options.processor, options: undefined }
-                        : options.processor;
-                    const processor = this.getProcessor(processorConfig.name);
-                    if (processor) {
-                        // 记录处理步骤开始
-                        if (fileEntity) {
-                            yield this.fileService.updateProcessingStatus(fileEntity.id, processorConfig.name, 'pending');
-                        }
-                        const result = yield processor.process(file, processorConfig.options);
-                        request._processResult = result;
-                        // 记录处理成功
-                        if (fileEntity) {
-                            yield this.fileService.updateProcessingStatus(fileEntity.id, processorConfig.name, 'completed', result);
-                        }
-                    }
-                }
-                // 执行参数装饰器指定的处理器
-                if (request._processParams) {
-                    const { name, options: procOptions } = request._processParams;
-                    const processor = this.getProcessor(name);
-                    if (processor) {
-                        const result = yield processor.process(file, procOptions);
-                        request._processResult = result;
-                    }
+                // 执行处理器
+                const processResult = yield this.executeProcessors(file, request, options);
+                if (processResult) {
+                    request._processResult = processResult;
                 }
+                // 如果需要，在处理后删除原文件
+                const shouldDeleteFile = this.shouldDeleteAfterProcess(options, processResult);
                 return next.handle().pipe((0, operators_1.tap)((response) => __awaiter(this, void 0, void 0, function* () {
                     // 执行 after 钩子
                     if (options.after) {
                         yield options.after(file, uploadContext);
                     }
-                    // 更新文件实体为完成状态
+                    // 更新文件实体状态
                     if (fileEntity && this.fileService) {
-                        try {
-                            // 计算相对路径（使用统一工具类）
-                            const relativePath = utils_1.FilePathUtil.toRelativePath(file.path);
-                            this.logger.debug(`Saving relative path: ${relativePath}`);
-                            yield this.fileService.update(fileEntity.id, {
-                                path: relativePath || (response === null || response === void 0 ? void 0 : response.path),
-                                status: 'completed',
-                            });
-                            // 将fileId和uploadId添加到响应中
-                            if (typeof response === 'object' && response !== null) {
-                                response.fileId = fileEntity.id;
-                                response.uploadId = uploadId;
-                            }
-                            this.logger.debug(`File upload completed: ${fileEntity.id}`);
-                        }
-                        catch (error) {
-                            this.logger.error(`Error updating file record: ${error.message}`);
-                        }
+                        yield this.updateFileEntityOnSuccess(fileEntity, uploadId, file, response);
+                    }
+                    // 处理完成后删除原文件
+                    if (shouldDeleteFile && file.path) {
+                        yield this.deleteOriginalFile(file, fileEntity);
                     }
                 })), (0, operators_1.catchError)((error) => __awaiter(this, void 0, void 0, function* () {
-                    // 更新文件实体为失败状态
+                    // 清理资源
                     if (fileEntity && this.fileService) {
-                        try {
-                            yield this.fileService.update(fileEntity.id, {
-                                status: 'failed',
-                                errorMessage: error.message || 'Unknown error',
-                            });
-                            // 清理临时文件（避免TOCTOU竞态条件）
-                            if (file.path) {
-                                try {
-                                    yield fs.unlink(file.path);
-                                }
-                                catch (unlinkError) {
-                                    // 文件可能已被删除，忽略ENOENT错误
-                                    if (unlinkError.code !== 'ENOENT') {
-                                        this.logger.error(`Failed to cleanup file: ${unlinkError.message}`);
-                                    }
-                                }
-                            }
-                            this.logger.warn(`File upload failed: ${fileEntity.id}`);
-                        }
-                        catch (cleanupError) {
-                            this.logger.error(`Error during cleanup: ${cleanupError.message}`);
-                        }
+                        yield this.cleanupOnFailure(fileEntity, file, error);
                     }
                     return (0, rxjs_1.throwError)(() => error);
                 })));
             }
             catch (error) {
-                // 处理过程中的错误
+                // 处理失败，更新状态
                 if (fileEntity && this.fileService) {
                     yield this.fileService.update(fileEntity.id, {
                         status: 'failed',
@@ -336,16 +281,182 @@ let FileUploadInterceptor = FileUploadInterceptor_1 = class FileUploadIntercepto
             }
         });
     }
+    /**
+     * 创建文件实体
+     */
+    createFileEntity(file, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!this.fileService) {
+                return { fileEntity: null, uploadId: null };
+            }
+            try {
+                const uploadId = request.body.uploadId || this.generateUploadId();
+                const checksum = file.path
+                    ? yield utils_1.ChecksumUtil.calculate(file.path, 'md5')
+                    : undefined;
+                const originalName = utils_1.FileNameUtil.decodeAndNormalize(file.originalname);
+                const fileEntity = yield this.fileService.create({
+                    originalName,
+                    filename: file.filename,
+                    mimeType: file.mimetype,
+                    size: file.size,
+                    tempPath: file.path,
+                    storageProvider: 'local',
+                    userId: (_a = request.user) === null || _a === void 0 ? void 0 : _a.id,
+                    uploadId,
+                    status: 'processing',
+                    checksum,
+                });
+                // 自动检测并设置文件类型
+                fileEntity.detectAndSetFileType();
+                yield this.fileService.update(fileEntity.id, {
+                    fileType: fileEntity.fileType,
+                    extension: fileEntity.extension,
+                });
+                // 添加验证数据（如果有）
+                const validationData = file._validationData;
+                if (validationData) {
+                    fileEntity.addValidationData({
+                        detectedTypes: validationData.detectedTypes || [],
+                        signatures: ((_b = validationData.metadata) === null || _b === void 0 ? void 0 : _b.signatures) || [],
+                        integrityChecks: [],
+                    });
+                    yield this.fileService.update(fileEntity.id, {
+                        validationData: fileEntity.validationData,
+                    });
+                }
+                // 附加到请求对象
+                request.fileEntity = fileEntity;
+                request.uploadId = uploadId;
+                return { fileEntity, uploadId };
+            }
+            catch (error) {
+                this.logger.error(`Failed to create file entity: ${error.message}`);
+                return { fileEntity: null, uploadId: null };
+            }
+        });
+    }
+    /**
+     * 执行处理器
+     */
+    executeProcessors(file, request, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 装饰器配置的处理器
+            if (options.processor) {
+                const processorConfig = typeof options.processor === 'string'
+                    ? { name: options.processor, options: undefined }
+                    : options.processor;
+                const processor = this.getProcessor(processorConfig.name);
+                if (processor) {
+                    const fileEntity = this.convertToFileEntity(file);
+                    // 使用请求上的 fileEntity（如果有）
+                    const actualFileEntity = request.fileEntity || fileEntity;
+                    if (request.fileEntity) {
+                        fileEntity.id = request.fileEntity.id;
+                    }
+                    // 记录处理开始
+                    if (actualFileEntity.id && this.fileService) {
+                        yield this.fileService.updateProcessingStatus(actualFileEntity.id, processorConfig.name, 'pending');
+                    }
+                    // 合并处理器选项
+                    const mergedOptions = Object.assign(Object.assign({}, processorConfig.options), options.processorOptions);
+                    const result = yield processor.process(fileEntity, mergedOptions);
+                    // 将处理结果保存到 file_metadata 表
+                    if (result && actualFileEntity.id && this.fileService) {
+                        yield this.saveProcessorResultToMetadata(actualFileEntity.id, processorConfig.name, result, mergedOptions);
+                    }
+                    // 记录处理成功
+                    if (actualFileEntity.id && this.fileService) {
+                        yield this.fileService.updateProcessingStatus(actualFileEntity.id, processorConfig.name, 'completed', result);
+                    }
+                    return result;
+                }
+            }
+            // 参数装饰器指定的处理器
+            if (request._processParams) {
+                const { name, options: procOptions } = request._processParams;
+                const processor = this.getProcessor(name);
+                if (processor) {
+                    const fileEntity = this.convertToFileEntity(file);
+                    return yield processor.process(fileEntity, procOptions);
+                }
+            }
+            return null;
+        });
+    }
+    /**
+     * 转换为 FileEntity
+     */
+    convertToFileEntity(file) {
+        return {
+            id: file.filename || '',
+            originalName: file.originalname,
+            fileName: file.filename,
+            mimeType: file.mimetype,
+            size: file.size,
+            hash: '',
+            storage: 'local',
+            path: file.path,
+            uploadedAt: new Date(),
+            status: file_entity_interface_1.FileStatus.PROCESSING,
+        };
+    }
+    /**
+     * 更新成功状态
+     */
+    updateFileEntityOnSuccess(fileEntity, uploadId, file, response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const relativePath = utils_1.FilePathUtil.toRelativePath(file.path);
+                yield this.fileService.update(fileEntity.id, {
+                    path: relativePath || (response === null || response === void 0 ? void 0 : response.path),
+                    status: 'completed',
+                });
+                // 添加文件信息到响应
+                if (typeof response === 'object' && response !== null) {
+                    response.fileId = fileEntity.id;
+                    response.uploadId = uploadId;
+                }
+                // 同时将 fileId 添加到 file 对象，方便 controller 访问
+                file.fileId = fileEntity.id;
+            }
+            catch (error) {
+                this.logger.error(`Error updating file record: ${error.message}`);
+            }
+        });
+    }
+    /**
+     * 清理失败的文件
+     */
+    cleanupOnFailure(fileEntity, file, error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.fileService.update(fileEntity.id, {
+                    status: 'failed',
+                    errorMessage: error.message || 'Unknown error',
+                });
+                // 清理临时文件
+                if (file.path) {
+                    yield fs.unlink(file.path).catch((unlinkError) => {
+                        if (unlinkError.code !== 'ENOENT') {
+                            this.logger.error(`Failed to cleanup file: ${unlinkError.message}`);
+                        }
+                    });
+                }
+            }
+            catch (cleanupError) {
+                this.logger.error(`Error during cleanup: ${cleanupError.message}`);
+            }
+        });
+    }
     /**
      * 创建上传上下文
      */
     createUploadContext(request, fileEntity) {
         return {
-            getProcessor: (name) => {
-                return this.getProcessor(name);
-            },
+            getProcessor: (name) => this.getProcessor(name),
             saveMetadata: (fileId, metadata) => __awaiter(this, void 0, void 0, function* () {
-                // 保存到数据库（如果fileService可用）
                 if (this.fileService && fileEntity) {
                     try {
                         for (const [key, value] of Object.entries(metadata)) {
@@ -356,18 +467,11 @@ let FileUploadInterceptor = FileUploadInterceptor_1 = class FileUploadIntercepto
                         this.logger.error(`Failed to save metadata: ${error.message}`);
                     }
                 }
-                // 也附加到请求对象
-                if (!request['_fileMetadata']) {
-                    request['_fileMetadata'] = {};
-                }
+                request['_fileMetadata'] = request['_fileMetadata'] || {};
                 request['_fileMetadata'][fileId] = metadata;
             }),
-            getUser: () => {
-                return request['user'];
-            },
-            getRequest: () => {
-                return request;
-            },
+            getUser: () => request['user'],
+            getRequest: () => request,
             shared: request['_shared'] || (request['_shared'] = {}),
         };
     }
@@ -375,10 +479,8 @@ let FileUploadInterceptor = FileUploadInterceptor_1 = class FileUploadIntercepto
      * 获取处理器
      */
     getProcessor(name) {
-        if (!this.processors) {
-            return null;
-        }
-        return this.processors.get(name) || null;
+        var _a;
+        return ((_a = this.processors) === null || _a === void 0 ? void 0 : _a.get(name)) || null;
     }
     /**
      * 生成uploadId
@@ -387,32 +489,90 @@ let FileUploadInterceptor = FileUploadInterceptor_1 = class FileUploadIntercepto
         return `upload_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
     }
     /**
-     * 计算文件校验和
+     * 判断是否应该在处理后删除原文件
      */
-    calculateChecksum(filePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return utils_1.ChecksumUtil.calculate(filePath, 'md5');
-        });
+    shouldDeleteAfterProcess(options, processResult) {
+        var _a, _b;
+        // 检查 processorOptions 中的 deleteAfterProcess 选项
+        if (((_a = options.processorOptions) === null || _a === void 0 ? void 0 : _a.deleteAfterProcess) === true) {
+            return true;
+        }
+        // 检查 processor 配置中的 deleteAfterProcess
+        if (typeof options.processor === 'object') {
+            if (((_b = options.processor.options) === null || _b === void 0 ? void 0 : _b.deleteAfterProcess) === true) {
+                return true;
+            }
+        }
+        return false;
     }
     /**
-     * 验证 MIME 类型
+     * 将处理器结果保存到 file_metadata 表
+     * 处理器可以通过返回结果中的 metadata 字段来指定要保存的内容
      */
-    validateMimeType(fileMimeType, allowedMimes) {
-        return allowedMimes.some((mime) => {
-            // 支持通配符，如 image/*
-            if (mime.endsWith('/*')) {
-                const prefix = mime.slice(0, -2);
-                return fileMimeType.startsWith(prefix);
+    saveProcessorResultToMetadata(fileId, processorName, result, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // 检查是否启用 saveToMetadata
+                if ((options === null || options === void 0 ? void 0 : options.saveToMetadata) === false) {
+                    return;
+                }
+                // 如果结果为空或不是对象，直接返回
+                if (!result || typeof result !== 'object') {
+                    return;
+                }
+                const metadataKey = (options === null || options === void 0 ? void 0 : options.metadataKey) || `${processorName}_parsed_data`;
+                // 准备要保存的数据
+                let metadataValue;
+                // 优先使用处理器返回的 metadata 字段
+                if (result.metadata && typeof result.metadata === 'object') {
+                    // 处理器自己决定要保存的内容
+                    metadataValue = Object.assign(Object.assign({}, result.metadata), { timestamp: result.metadata.timestamp || new Date().toISOString(), processorName: result.metadata.processorName || processorName });
+                }
+                else {
+                    // 备选方案：保存整个结果（向后兼容）
+                    metadataValue = {
+                        timestamp: new Date().toISOString(),
+                        processorName,
+                        result,
+                    };
+                }
+                // 保存到 file_metadata 表
+                yield this.fileService.addMetadata(fileId, metadataKey, metadataValue);
+                this.logger.log(`Processor result saved to metadata: ${metadataKey} for file ${fileId}`);
+            }
+            catch (error) {
+                this.logger.error(`Failed to save processor result to metadata: ${error.message}`);
+                // 不抛出错误，避免影响主流程
             }
-            return mime === fileMimeType;
         });
     }
     /**
-     * 验证扩展名
+     * 删除原文件
      */
-    validateExtension(fileExt, allowedExts) {
-        const normalizedExt = fileExt.toLowerCase();
-        return allowedExts.some((ext) => ext.toLowerCase() === normalizedExt);
+    deleteOriginalFile(file, fileEntity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // 删除物理文件
+                yield fs.unlink(file.path).catch((error) => {
+                    if (error.code !== 'ENOENT') {
+                        throw error;
+                    }
+                });
+                this.logger.log(`Original file deleted after processing: ${file.originalname} (${file.path})`);
+                // 如果有文件实体，更新状态或标记
+                if (fileEntity && this.fileService) {
+                    yield this.fileService.addMetadata(fileEntity.id, 'original_file_deleted', {
+                        deletedAt: new Date().toISOString(),
+                        reason: 'deleted_after_processing',
+                        originalPath: file.path,
+                    });
+                }
+            }
+            catch (error) {
+                this.logger.error(`Failed to delete original file after processing: ${error.message}`);
+                // 不抛出错误，避免影响主流程
+            }
+        });
     }
 };
 exports.FileUploadInterceptor = FileUploadInterceptor;