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

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

@@ -0,0 +1,434 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var FileUploadInterceptor_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileUploadInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+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_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");
+const mime_registry_service_1 = require("../services/mime-registry.service");
+const utils_1 = require("../utils");
+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 {
+    constructor(reflector, mimeRegistry, processors, fileService, signatureValidator, maliciousDetector, moduleOptions) {
+        this.reflector = reflector;
+        this.mimeRegistry = mimeRegistry;
+        this.processors = processors;
+        this.fileService = fileService;
+        this.signatureValidator = signatureValidator;
+        this.maliciousDetector = maliciousDetector;
+        this.moduleOptions = moduleOptions;
+        this.logger = new common_1.Logger(FileUploadInterceptor_1.name);
+    }
+    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 (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. 验证访问权限
+            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. 文件名清理（默认启用）
+            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}`);
+                    }
+                }
+            }
+            // 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');
+                }
+                catch (error) {
+                    if (error instanceof file_upload_exception_1.MaliciousFileException) {
+                        throw error;
+                    }
+                    // 检测出错，记录日志但继续
+                    this.logger.error(`FileUploadInterceptor: Malicious detection error: ${error.message}`);
+                }
+            }
+            else {
+                this.logger.debug(`FileUploadInterceptor: Skipping malicious check - detector: ${!!this.maliciousDetector}, file.path: ${!!file.path}`);
+            }
+            // ===== 所有验证完成 =====
+            // 创建文件实体记录（如果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}`);
+                }
+                catch (error) {
+                    this.logger.error(`Failed to create file entity: ${error.message}`);
+                    // 设置fileEntity为null，后续代码会检查并跳过数据库操作
+                    fileEntity = null;
+                }
+            }
+            // 创建上传上下文
+            const uploadContext = this.createUploadContext(request, fileEntity);
+            try {
+                // 执行 before 钩子
+                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;
+                    }
+                }
+                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}`);
+                        }
+                    }
+                })), (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}`);
+                        }
+                    }
+                    return (0, rxjs_1.throwError)(() => error);
+                })));
+            }
+            catch (error) {
+                // 处理过程中的错误
+                if (fileEntity && this.fileService) {
+                    yield this.fileService.update(fileEntity.id, {
+                        status: 'failed',
+                        errorMessage: error.message,
+                    });
+                }
+                throw error;
+            }
+        });
+    }
+    /**
+     * 创建上传上下文
+     */
+    createUploadContext(request, fileEntity) {
+        return {
+            getProcessor: (name) => {
+                return 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)) {
+                            yield this.fileService.addMetadata(fileEntity.id, key, value);
+                        }
+                    }
+                    catch (error) {
+                        this.logger.error(`Failed to save metadata: ${error.message}`);
+                    }
+                }
+                // 也附加到请求对象
+                if (!request['_fileMetadata']) {
+                    request['_fileMetadata'] = {};
+                }
+                request['_fileMetadata'][fileId] = metadata;
+            }),
+            getUser: () => {
+                return request['user'];
+            },
+            getRequest: () => {
+                return request;
+            },
+            shared: request['_shared'] || (request['_shared'] = {}),
+        };
+    }
+    /**
+     * 获取处理器
+     */
+    getProcessor(name) {
+        if (!this.processors) {
+            return null;
+        }
+        return this.processors.get(name) || null;
+    }
+    /**
+     * 生成uploadId
+     */
+    generateUploadId() {
+        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');
+        });
+    }
+    /**
+     * 验证 MIME 类型
+     */
+    validateMimeType(fileMimeType, allowedMimes) {
+        return allowedMimes.some((mime) => {
+            // 支持通配符，如 image/*
+            if (mime.endsWith('/*')) {
+                const prefix = mime.slice(0, -2);
+                return fileMimeType.startsWith(prefix);
+            }
+            return mime === fileMimeType;
+        });
+    }
+    /**
+     * 验证扩展名
+     */
+    validateExtension(fileExt, allowedExts) {
+        const normalizedExt = fileExt.toLowerCase();
+        return allowedExts.some((ext) => ext.toLowerCase() === normalizedExt);
+    }
+};
+exports.FileUploadInterceptor = FileUploadInterceptor;
+exports.FileUploadInterceptor = FileUploadInterceptor = FileUploadInterceptor_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(2, (0, common_1.Optional)()),
+    __param(2, (0, common_1.Inject)('FILE_PROCESSORS')),
+    __param(3, (0, common_1.Optional)()),
+    __param(4, (0, common_1.Optional)()),
+    __param(5, (0, common_1.Optional)()),
+    __param(6, (0, common_1.Optional)()),
+    __param(6, (0, common_1.Inject)('FILE_UPLOAD_OPTIONS')),
+    __metadata("design:paramtypes", [core_1.Reflector,
+        mime_registry_service_1.MimeRegistryService,
+        Map,
+        file_service_1.FileService,
+        file_signature_validator_service_1.FileSignatureValidator,
+        malicious_file_detector_service_1.MaliciousFileDetector, Object])
+], FileUploadInterceptor);

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

@@ -0,0 +1 @@
+export * from './file-upload.interceptor';

package/file-upload/interceptors/index.js

@@ -0,0 +1,17 @@
+"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("./file-upload.interceptor"), exports);

package/file-upload/interfaces/custom-file-type.interface.d.ts

@@ -0,0 +1,72 @@
+/**
+ * 文件签名定义
+ */
+export interface FileSignature {
+    /** 签名内容 - 字节数组或字符串 */
+    bytes: number[] | string;
+    /** 签名偏移量（默认 0） */
+    offset?: number;
+    /** 是否精确匹配（默认 true） */
+    exact?: boolean;
+    /** 文件尾部签名（可选） */
+    trailer?: FileSignature;
+    /** 签名长度（用于变体检测） */
+    length?: number;
+    /** 掩码（用于忽略某些位） */
+    mask?: number[] | string;
+}
+/**
+ * 自定义文件类型定义
+ */
+export interface CustomFileType {
+    /** MIME 类型 */
+    mime: string | string[];
+    /** 文件扩展名 */
+    extension?: string | string[];
+    /** 文件签名/魔数 */
+    signature?: FileSignature | FileSignature[];
+    /** 文件类型描述 */
+    description?: string;
+    /** 文件类型图标 */
+    icon?: string;
+    /** 是否为图像类型 */
+    isImage?: boolean;
+    /** 是否为文档类型 */
+    isDocument?: boolean;
+    /** 是否为音视频类型 */
+    isMedia?: boolean;
+}
+/**
+ * 自定义文件类型集合
+ */
+export interface CustomFileTypes {
+    [typeName: string]: CustomFileType;
+}
+/**
+ * MIME 配置
+ */
+export interface MimeConfig {
+    /** MIME 类型列表 */
+    mimes: string[];
+    /** 扩展名列表 */
+    extensions: string[];
+    /** 描述 */
+    description?: string;
+    /** 图标 */
+    icon?: string;
+    /** 签名 */
+    signatures?: FileSignature | FileSignature[];
+    /** 文件类型 */
+    fileType?: string;
+}
+/**
+ * 文件类型解析结果
+ */
+export interface ResolvedFileTypes {
+    /** MIME 类型列表 */
+    mimes: string[];
+    /** 扩展名列表 */
+    exts: string[];
+    /** 需要签名验证的类型 */
+    signatureTypes: string[];
+}

package/file-upload/interfaces/custom-file-type.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/file-upload/interfaces/file-buffer.interface.d.ts

@@ -0,0 +1,72 @@
+/** 文件缓冲区接口 */
+export interface FileBuffer {
+    /** 文件二进制内容 */
+    buffer: Buffer;
+    /** 文件大小（字节） */
+    size: number;
+    /** MIME类型 */
+    mimeType: string;
+    /** 原始文件名 */
+    originalName: string;
+    /** 文件编码 */
+    encoding?: string;
+    /** 文件哈希值（SHA-256） */
+    hash?: string;
+    /** 文件流（适用于大文件） */
+    stream?: NodeJS.ReadableStream;
+    /** 分片信息（用于分片上传） */
+    chunk?: {
+        index: number;
+        total: number;
+        size: number;
+        start: number;
+        end: number;
+    };
+    /** 临时文件路径（用于大文件） */
+    tempPath?: string;
+    /** 上传进度回调 */
+    onProgress?: (progress: UploadProgress) => void;
+}
+/** 上传进度 */
+export interface UploadProgress {
+    /** 已上传字节数 */
+    loaded: number;
+    /** 总字节数 */
+    total: number;
+    /** 上传百分比 */
+    percentage: number;
+    /** 上传速度（字节/秒） */
+    speed: number;
+    /** 剩余时间（秒） */
+    eta: number;
+    /** 当前状态 */
+    status: 'uploading' | 'paused' | 'completed' | 'error';
+    /** 错误信息 */
+    error?: string;
+}
+/** 文件块 */
+export interface FileChunk {
+    /** 块索引 */
+    index: number;
+    /** 块数据 */
+    data: Buffer;
+    /** 块大小 */
+    size: number;
+    /** 块哈希 */
+    hash?: string;
+    /** 块在文件中的起始位置 */
+    offset: number;
+}
+/** 文件流选项 */
+export interface FileStreamOptions {
+    /** 分块大小 */
+    chunkSize?: number;
+    /** 是否使用缓冲 */
+    useBuffer?: boolean;
+    /** 缓冲区大小 */
+    bufferSize?: number;
+    /** 是否自动清理临时文件 */
+    autoCleanup?: boolean;
+    /** 临时文件目录 */
+    tempDir?: string;
+}

package/file-upload/interfaces/file-buffer.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });