@nest-omni/core 4.1.3-2 → 4.1.3-20

package/file-upload/services/file.service.js

@@ -0,0 +1,638 @@
+"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 FileService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const file_entity_1 = require("../entities/file.entity");
+const file_metadata_entity_1 = require("../entities/file-metadata.entity");
+const fs_1 = require("fs");
+const path = require("path");
+/**
+ * 文件管理服务
+ */
+let FileService = FileService_1 = class FileService {
+    constructor(fileRepository, metadataRepository, storageProvider, localStorageProvider, s3StorageProvider) {
+        this.fileRepository = fileRepository;
+        this.metadataRepository = metadataRepository;
+        this.storageProvider = storageProvider;
+        this.localStorageProvider = localStorageProvider;
+        this.s3StorageProvider = s3StorageProvider;
+        this.logger = new common_1.Logger(FileService_1.name);
+        // 允许的排序字段白名单（防止 SQL 注入）
+        this.ALLOWED_ORDER_FIELDS = [
+            'createdAt',
+            'updatedAt',
+            'size',
+            'originalName',
+            'filename',
+            'mimeType',
+            'status',
+            'fileType',
+            'extension',
+            'uploadId',
+            'userId',
+        ];
+        // 允许的排序方向
+        this.ALLOWED_ORDER_DIRECTIONS = ['ASC', 'DESC'];
+    }
+    /**
+     * 创建文件记录
+     */
+    create(createFileDto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const file = this.fileRepository.create(createFileDto);
+            const saved = yield this.fileRepository.save(file);
+            this.logger.debug(`File record created: ${saved.id}`);
+            return saved;
+        });
+    }
+    /**
+     * 根据ID查找文件
+     */
+    findById(id_1) {
+        return __awaiter(this, arguments, void 0, function* (id, includeDeleted = false) {
+            const query = this.fileRepository
+                .createQueryBuilder('file')
+                .where('file.id = :id', { id });
+            if (!includeDeleted) {
+                query.andWhere('file.deletedAt IS NULL');
+            }
+            return query.getOne();
+        });
+    }
+    /**
+     * 根据uploadId查找文件
+     */
+    findByUploadId(uploadId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fileRepository.find({
+                where: {
+                    uploadId,
+                    status: 'completed',
+                },
+                order: { createdAt: 'ASC' },
+            });
+        });
+    }
+    /**
+     * 查找文件列表
+     */
+    findFiles(query, pagination) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const queryBuilder = this.fileRepository.createQueryBuilder('file');
+            // 应用筛选条件
+            if (query.userId) {
+                queryBuilder.andWhere('file.userId = :userId', { userId: query.userId });
+            }
+            if (query.mimeType) {
+                if (Array.isArray(query.mimeType)) {
+                    queryBuilder.andWhere('file.mimeType IN (:...mimeTypes)', {
+                        mimeTypes: query.mimeType,
+                    });
+                }
+                else {
+                    queryBuilder.andWhere('file.mimeType = :mimeType', {
+                        mimeType: query.mimeType,
+                    });
+                }
+            }
+            if (query.uploadId) {
+                queryBuilder.andWhere('file.uploadId = :uploadId', {
+                    uploadId: query.uploadId,
+                });
+            }
+            if (query.status) {
+                queryBuilder.andWhere('file.status = :status', { status: query.status });
+            }
+            if (query.storageProvider) {
+                queryBuilder.andWhere('file.storageProvider = :storageProvider', {
+                    storageProvider: query.storageProvider,
+                });
+            }
+            if (query.dateFrom) {
+                queryBuilder.andWhere('file.createdAt >= :dateFrom', {
+                    dateFrom: query.dateFrom,
+                });
+            }
+            if (query.dateTo) {
+                queryBuilder.andWhere('file.createdAt <= :dateTo', {
+                    dateTo: query.dateTo,
+                });
+            }
+            if (query.search) {
+                // 转义 LIKE 操作符中的特殊字符
+                const escapedSearch = this.escapeLikeString(query.search);
+                queryBuilder.andWhere('(file.originalName LIKE :search OR file.filename LIKE :search)', {
+                    search: `%${escapedSearch}%`,
+                });
+            }
+            // 排除软删除的记录
+            queryBuilder.andWhere('file.deletedAt IS NULL');
+            // 应用排序（带安全验证）
+            const orderBy = query.orderBy || 'createdAt';
+            const orderDirection = (((_a = query.orderDirection) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'DESC');
+            // 验证排序字段
+            if (!this.ALLOWED_ORDER_FIELDS.includes(orderBy)) {
+                throw new common_1.BadRequestException(`Invalid order field: ${orderBy}. Allowed fields: ${this.ALLOWED_ORDER_FIELDS.join(', ')}`);
+            }
+            // 验证排序方向
+            if (!this.ALLOWED_ORDER_DIRECTIONS.includes(orderDirection)) {
+                throw new common_1.BadRequestException(`Invalid order direction: ${orderDirection}. Allowed: ASC, DESC`);
+            }
+            queryBuilder.orderBy(`file.${orderBy}`, orderDirection);
+            // 应用分页
+            const offset = (pagination.page - 1) * pagination.limit;
+            queryBuilder.skip(offset).take(pagination.limit);
+            const [files, total] = yield queryBuilder.getManyAndCount();
+            return {
+                files,
+                total,
+                page: pagination.page,
+                limit: pagination.limit,
+                totalPages: Math.ceil(total / pagination.limit),
+            };
+        });
+    }
+    /**
+     * 更新文件记录
+     */
+    update(id, updateFileDto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const file = yield this.findById(id);
+            if (!file) {
+                throw new common_1.NotFoundException(`File not found: ${id}`);
+            }
+            Object.assign(file, updateFileDto);
+            const updated = yield this.fileRepository.save(file);
+            this.logger.debug(`File record updated: ${updated.id}`);
+            return updated;
+        });
+    }
+    /**
+     * 软删除文件
+     * @param id 文件ID
+     * @param deletePhysicalFile 是否同时删除物理文件，默认 false
+     */
+    softDelete(id_1) {
+        return __awaiter(this, arguments, void 0, function* (id, deletePhysicalFile = false) {
+            const file = yield this.findById(id);
+            if (!file) {
+                throw new common_1.NotFoundException(`File not found: ${id}`);
+            }
+            file.markAsDeleted();
+            yield this.fileRepository.softRemove(file);
+            // 可选：删除物理文件
+            if (deletePhysicalFile) {
+                yield this.deletePhysicalFile(file);
+            }
+            this.logger.debug(`File soft deleted: ${id}, physicalFile: ${deletePhysicalFile}`);
+        });
+    }
+    /**
+     * 硬删除文件
+     * @param id 文件ID
+     * @param deletePhysicalFile 是否同时删除物理文件，默认 true
+     */
+    hardDelete(id_1) {
+        return __awaiter(this, arguments, void 0, function* (id, deletePhysicalFile = true) {
+            const file = yield this.findById(id);
+            if (!file) {
+                this.logger.warn(`File not found for hard delete: ${id}`);
+                return; // 已删除，幂等操作
+            }
+            // 硬删除默认清理物理文件
+            if (deletePhysicalFile) {
+                yield this.deletePhysicalFile(file);
+            }
+            yield this.fileRepository.delete(id);
+            this.logger.debug(`File hard deleted: ${id}, physicalFile: ${deletePhysicalFile}`);
+        });
+    }
+    /**
+     * 添加元数据
+     */
+    addMetadata(fileId_1, key_1, value_1) {
+        return __awaiter(this, arguments, void 0, function* (fileId, key, value, isPublic = false) {
+            // 检查文件是否存在
+            const file = yield this.findById(fileId);
+            if (!file) {
+                throw new common_1.NotFoundException(`File not found: ${fileId}`);
+            }
+            // 检查是否已存在相同key的元数据
+            const existing = yield this.metadataRepository.findOne({
+                where: { fileId, key },
+            });
+            if (existing) {
+                // 更新现有元数据
+                existing.setValue(value);
+                existing.isPublic = isPublic;
+                return this.metadataRepository.save(existing);
+            }
+            // 创建新元数据
+            const metadata = this.metadataRepository.create({
+                fileId,
+                key,
+                isPublic,
+            });
+            metadata.setValue(value);
+            return this.metadataRepository.save(metadata);
+        });
+    }
+    /**
+     * 获取元数据
+     */
+    getMetadata(fileId, keys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = this.metadataRepository
+                .createQueryBuilder('metadata')
+                .where('metadata.fileId = :fileId', { fileId });
+            if (keys && keys.length > 0) {
+                query.andWhere('metadata.key IN (:...keys)', { keys });
+            }
+            const metadataList = yield query.getMany();
+            const result = new Map();
+            metadataList.forEach((metadata) => {
+                result.set(metadata.key, metadata.getValue());
+            });
+            return result;
+        });
+    }
+    /**
+     * 获取存储统计
+     */
+    getStorageStats(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = this.fileRepository
+                .createQueryBuilder('file')
+                .select('file.storageProvider', 'provider')
+                .addSelect('COUNT(*)', 'count')
+                .addSelect('SUM(file.size)', 'totalSize')
+                .where('file.status = :status', { status: 'completed' })
+                .andWhere('file.deletedAt IS NULL');
+            if (userId) {
+                query.andWhere('file.userId = :userId', { userId });
+            }
+            const results = yield query.groupBy('file.storageProvider').getRawMany();
+            const stats = {
+                totalFiles: 0,
+                totalSize: 0,
+                providers: {},
+            };
+            results.forEach((row) => {
+                const count = parseInt(row.count);
+                const size = parseInt(row.totalSize) || 0;
+                stats.totalFiles += count;
+                stats.totalSize += size;
+                stats.providers[row.provider] = {
+                    count,
+                    size,
+                };
+            });
+            return stats;
+        });
+    }
+    /**
+     * 更新处理状态
+     * 处理状态信息保存到 file_metadata 表
+     */
+    updateProcessingStatus(fileId, processor, status, result, error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const file = yield this.findById(fileId);
+            if (!file) {
+                this.logger.warn(`File not found for processing update: ${fileId}`);
+                return;
+            }
+            // 将处理状态保存到 metadata
+            const processingKey = `processing_${processor}`;
+            yield this.addMetadata(fileId, processingKey, {
+                processor,
+                status,
+                result: result || null,
+                error: error || null,
+                timestamp: new Date().toISOString(),
+            });
+            if (status === 'failed') {
+                file.markAsFailed(`Processor ${processor} failed: ${error}`);
+                yield this.fileRepository.save(file);
+            }
+        });
+    }
+    /**
+     * 清理临时文件（定时任务）
+     */
+    cleanupTempFiles() {
+        return __awaiter(this, arguments, void 0, function* (olderThanHours = 24) {
+            const cutoffDate = new Date();
+            cutoffDate.setHours(cutoffDate.getHours() - olderThanHours);
+            const result = yield this.fileRepository
+                .createQueryBuilder()
+                .delete()
+                .from(file_entity_1.FileEntity)
+                .where('status = :status', { status: 'processing' })
+                .andWhere('createdAt < :cutoffDate', { cutoffDate })
+                .execute();
+            this.logger.log(`Cleaned up ${result.affected || 0} temporary files`);
+            return { deleted: result.affected || 0 };
+        });
+    }
+    /**
+     * 获取文件内容（二进制）
+     * 适用于服务间调用，获取完整文件内容
+     *
+     * @param fileId 文件ID
+     * @returns 文件缓冲区对象
+     * @throws NotFoundException 文件不存在
+     * @throws BadRequestException 文件未完成上传
+     */
+    getFileContent(fileId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const file = yield this.findById(fileId);
+            if (!file) {
+                throw new common_1.NotFoundException(`File not found: ${fileId}`);
+            }
+            if (file.status !== 'completed') {
+                throw new common_1.BadRequestException(`File not ready: ${fileId}, status: ${file.status}`);
+            }
+            const provider = this.getStorageProvider(file.storageProvider);
+            return provider.download(file.path);
+        });
+    }
+    /**
+     * 获取文件流（用于大文件）
+     * 适用于流式处理，避免一次性加载到内存
+     * 注意：仅支持本地存储，对象存储请使用 getSignedUrl
+     *
+     * @param fileId 文件ID
+     * @returns 可读流
+     * @throws NotFoundException 文件不存在或物理文件缺失
+     * @throws BadRequestException 文件未完成或存储类型不支持
+     */
+    getFileStream(fileId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const file = yield this.findById(fileId);
+            if (!file) {
+                throw new common_1.NotFoundException(`File not found: ${fileId}`);
+            }
+            if (file.status !== 'completed') {
+                throw new common_1.BadRequestException(`File not ready: ${fileId}`);
+            }
+            // 本地存储：返回文件流
+            if (file.storageProvider === 'local') {
+                const physicalPath = file.getPhysicalPath();
+                if (!(0, fs_1.existsSync)(physicalPath)) {
+                    throw new common_1.NotFoundException(`Physical file not found: ${fileId}`);
+                }
+                return (0, fs_1.createReadStream)(physicalPath);
+            }
+            // 对象存储：不支持直接流，需要通过预签名 URL
+            throw new common_1.BadRequestException(`Stream access not supported for storage type: ${file.storageProvider}. Use getSignedUrl() instead.`);
+        });
+    }
+    /**
+     * 获取预签名 URL（对象存储）
+     * 适用于客户端直接下载，或临时授权访问
+     *
+     * @param fileId 文件ID
+     * @param expiresIn 过期时间（秒），默认 3600 秒（1小时）
+     * @returns 预签名 URL
+     * @throws NotFoundException 文件不存在
+     */
+    getSignedUrl(fileId_1) {
+        return __awaiter(this, arguments, void 0, function* (fileId, expiresIn = 3600) {
+            const file = yield this.findById(fileId);
+            if (!file) {
+                throw new common_1.NotFoundException(`File not found: ${fileId}`);
+            }
+            if (file.status !== 'completed') {
+                throw new common_1.BadRequestException(`File not ready: ${fileId}`);
+            }
+            const provider = this.getStorageProvider(file.storageProvider);
+            return provider.getSignedUrl(file.path, expiresIn);
+        });
+    }
+    /**
+     * 批量获取文件内容
+     * 适用于需要同时处理多个文件的场景
+     * 失败的文件会被跳过，不会中断整个流程
+     *
+     * @param fileIds 文件ID列表
+     * @returns Map<文件ID, 文件内容>
+     */
+    getFilesContent(fileIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = new Map();
+            yield Promise.allSettled(fileIds.map((id) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const content = yield this.getFileContent(id);
+                    results.set(id, content);
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to get file content for ${id}: ${error.message}`);
+                }
+            })));
+            return results;
+        });
+    }
+    /**
+     * 获取文件访问 URL
+     * 根据存储类型返回不同的 URL
+     *
+     * @param fileId 文件ID
+     * @param baseUrl 基础 URL（可选，用于本地存储）
+     * @returns 文件访问 URL
+     */
+    getFileUrl(fileId, baseUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const file = yield this.findById(fileId);
+            if (!file) {
+                throw new common_1.NotFoundException(`File not found: ${fileId}`);
+            }
+            // 对象存储：使用预签名 URL
+            if (['s3', 'oss', 'minio'].includes(file.storageProvider)) {
+                return this.getSignedUrl(fileId);
+            }
+            // 本地存储：使用 API URL
+            const apiBase = baseUrl || process.env.API_BASE_URL || '';
+            return apiBase ? `${apiBase}/files/${file.id}` : `/files/${file.id}`;
+        });
+    }
+    // ========== 私有辅助方法 ==========
+    /**
+     * 批量删除文件
+     * @param fileIds 文件ID列表
+     * @param deletePhysicalFile 是否同时删除物理文件，默认 true
+     * @returns 删除结果统计
+     */
+    batchDelete(fileIds_1) {
+        return __awaiter(this, arguments, void 0, function* (fileIds, deletePhysicalFile = true) {
+            const success = [];
+            const failed = [];
+            for (const id of fileIds) {
+                try {
+                    yield this.hardDelete(id, deletePhysicalFile);
+                    success.push(id);
+                }
+                catch (error) {
+                    failed.push({ id, error: error.message });
+                    this.logger.warn(`Failed to delete file ${id}: ${error.message}`);
+                }
+            }
+            this.logger.log(`Batch delete completed: ${success.length} success, ${failed.length} failed`);
+            return { success, failed };
+        });
+    }
+    /**
+     * 复制文件（创建新记录）
+     * @param sourceFileId 源文件ID
+     * @param userId 新文件的用户ID（可选）
+     * @returns 新的文件实体
+     */
+    copyFile(sourceFileId, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sourceFile = yield this.findById(sourceFileId);
+            if (!sourceFile) {
+                throw new common_1.NotFoundException(`Source file not found: ${sourceFileId}`);
+            }
+            const provider = this.getStorageProvider(sourceFile.storageProvider);
+            // 生成新路径
+            const ext = path.extname(sourceFile.path);
+            const basePath = sourceFile.path.replace(ext, '');
+            const newPath = `${basePath}-copy-${Date.now()}${ext}`;
+            // 复制物理文件
+            const copyResult = yield provider.copy(sourceFile.path, newPath);
+            // 创建新记录
+            const newFile = yield this.create({
+                originalName: `${sourceFile.originalName} (copy)`,
+                filename: path.basename(newPath),
+                mimeType: sourceFile.mimeType,
+                size: Number(copyResult.size),
+                path: newPath,
+                storageProvider: sourceFile.storageProvider,
+                userId: userId || sourceFile.userId,
+                status: 'completed',
+                checksum: copyResult.etag,
+                metadata: Object.assign(Object.assign({}, sourceFile.metadata), { copiedFrom: sourceFileId }),
+            });
+            // 复制 fileType 和 extension
+            newFile.fileType = sourceFile.fileType;
+            newFile.extension = sourceFile.extension;
+            yield this.fileRepository.save(newFile);
+            this.logger.log(`File copied: ${sourceFileId} -> ${newFile.id}`);
+            return newFile;
+        });
+    }
+    /**
+     * 移动文件到新路径
+     * @param fileId 文件ID
+     * @param newPath 新路径
+     * @returns 更新后的文件实体
+     */
+    moveFile(fileId, newPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const file = yield this.findById(fileId);
+            if (!file) {
+                throw new common_1.NotFoundException(`File not found: ${fileId}`);
+            }
+            const provider = this.getStorageProvider(file.storageProvider);
+            // 移动物理文件
+            const moveResult = yield provider.move(file.path, newPath);
+            // 更新记录
+            const updated = yield this.update(fileId, {
+                path: newPath,
+                filename: path.basename(newPath),
+                checksum: moveResult.etag,
+            });
+            this.logger.log(`File moved: ${file.path} -> ${newPath}`);
+            return updated;
+        });
+    }
+    /**
+     * 删除物理文件
+     * @private
+     */
+    deletePhysicalFile(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const provider = this.getStorageProvider(file.storageProvider);
+                yield provider.delete(file.path);
+                this.logger.debug(`Physical file deleted: ${file.path} (provider: ${file.storageProvider})`);
+            }
+            catch (error) {
+                this.logger.error(`Failed to delete physical file: ${file.path}`, error.stack);
+                // 不抛出异常，避免阻塞删除流程
+            }
+        });
+    }
+    /**
+     * 根据存储类型获取存储提供者
+     *
+     * @param storageType 存储类型
+     * @returns 存储提供者实例
+     * @throws Error 存储提供者未配置或不支持
+     */
+    getStorageProvider(storageType) {
+        switch (storageType) {
+            case 'local':
+                if (!this.localStorageProvider) {
+                    throw new Error('Local storage provider not configured');
+                }
+                return this.localStorageProvider;
+            case 's3':
+                if (!this.s3StorageProvider) {
+                    throw new Error('S3 storage provider not configured');
+                }
+                return this.s3StorageProvider;
+            default:
+                // 回退到默认提供者
+                if (this.storageProvider) {
+                    return this.storageProvider;
+                }
+                throw new Error(`Unsupported storage provider: ${storageType}`);
+        }
+    }
+    /**
+     * 转义 LIKE 操作符中的特殊字符
+     */
+    escapeLikeString(input) {
+        // 转义 LIKE 通配符和反斜杠
+        return input.replace(/[%_\\]/g, '\\$&');
+    }
+};
+exports.FileService = FileService;
+exports.FileService = FileService = FileService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(file_entity_1.FileEntity)),
+    __param(1, (0, typeorm_1.InjectRepository)(file_metadata_entity_1.FileMetadataEntity)),
+    __param(2, (0, common_1.Optional)()),
+    __param(2, (0, common_1.Inject)('STORAGE_PROVIDER')),
+    __param(3, (0, common_1.Optional)()),
+    __param(3, (0, common_1.Inject)('LOCAL_STORAGE_PROVIDER')),
+    __param(4, (0, common_1.Optional)()),
+    __param(4, (0, common_1.Inject)('S3_STORAGE_PROVIDER')),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        typeorm_2.Repository, Object, Object, Object])
+], FileService);

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

@@ -0,0 +1,4 @@
+export * from './mime-registry.service';
+export * from './file-signature-validator.service';
+export * from './malicious-file-detector.service';
+export * from './file.service';

package/file-upload/services/index.js

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