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

package/file-upload/file-upload.module.js

@@ -0,0 +1,264 @@
+"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 __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 FileUploadModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileUploadModule = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const file_upload_interceptor_1 = require("./interceptors/file-upload.interceptor");
+const local_storage_provider_1 = require("./providers/local-storage.provider");
+const mime_registry_service_1 = require("./services/mime-registry.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 file_service_1 = require("./services/file.service");
+const file_entity_1 = require("./entities/file.entity");
+const file_metadata_entity_1 = require("./entities/file-metadata.entity");
+const file_access_controller_1 = require("./controllers/file-access.controller");
+/**
+ * 文件上传模块（增强版）
+ */
+let FileUploadModule = FileUploadModule_1 = class FileUploadModule {
+    /**
+     * 同步配置模块
+     */
+    static forRoot(options = {}) {
+        var _a, _b, _c, _d, _e, _f;
+        const providers = [
+            // 核心服务
+            mime_registry_service_1.MimeRegistryService,
+            file_signature_validator_service_1.FileSignatureValidator,
+            // 恶意文件检测器（带配置）
+            {
+                provide: 'MALICIOUS_DETECTOR_OPTIONS',
+                useValue: options.maliciousDetection || {},
+            },
+            malicious_file_detector_service_1.MaliciousFileDetector,
+            // Interceptor
+            file_upload_interceptor_1.FileUploadInterceptor,
+            // 配置
+            {
+                provide: 'FILE_UPLOAD_OPTIONS',
+                useValue: options,
+            },
+        ];
+        // 注册自定义文件类型
+        if (options.customFileTypes) {
+            providers.push({
+                provide: 'CUSTOM_FILE_TYPES',
+                useValue: options.customFileTypes,
+            });
+            // 初始化自定义类型
+            providers.push({
+                provide: 'FILE_TYPE_INITIALIZER',
+                useFactory: (registry) => {
+                    registry.registerCustomFileTypes(options.customFileTypes);
+                    return registry;
+                },
+                inject: [mime_registry_service_1.MimeRegistryService],
+            });
+        }
+        // 注册处理器
+        if (options.processors && options.processors.length > 0) {
+            const processorMap = new Map();
+            for (const ProcessorClass of options.processors) {
+                const processor = new ProcessorClass();
+                processorMap.set(processor.name, processor);
+            }
+            providers.push({
+                provide: 'FILE_PROCESSORS',
+                useValue: processorMap,
+            });
+        }
+        // 注册存储提供者
+        if (options.storage) {
+            const storageProviders = this.createStorageProviders(options.storage);
+            providers.push(...storageProviders);
+        }
+        // TypeORM 配置
+        const imports = [];
+        const databaseEnabled = ((_a = options.database) === null || _a === void 0 ? void 0 : _a.autoCreateTable) !== false;
+        if (databaseEnabled) {
+            imports.push(typeorm_1.TypeOrmModule.forFeature([file_entity_1.FileEntity, file_metadata_entity_1.FileMetadataEntity]));
+            providers.push(file_service_1.FileService);
+        }
+        // Build exports array - only export what's actually provided
+        const exports = [
+            mime_registry_service_1.MimeRegistryService,
+            file_signature_validator_service_1.FileSignatureValidator,
+            malicious_file_detector_service_1.MaliciousFileDetector,
+            file_upload_interceptor_1.FileUploadInterceptor,
+            'FILE_UPLOAD_OPTIONS',
+        ];
+        if (databaseEnabled) {
+            exports.push(file_service_1.FileService);
+        }
+        if (options.processors && options.processors.length > 0) {
+            exports.push('FILE_PROCESSORS');
+        }
+        if (((_b = options.storage) === null || _b === void 0 ? void 0 : _b.local) ||
+            !((_c = options.storage) === null || _c === void 0 ? void 0 : _c.default) ||
+            ((_d = options.storage) === null || _d === void 0 ? void 0 : _d.default) === 'local') {
+            if ((_e = options.storage) === null || _e === void 0 ? void 0 : _e.local) {
+                exports.push('LOCAL_STORAGE_PROVIDER');
+            }
+        }
+        if ((_f = options.storage) === null || _f === void 0 ? void 0 : _f.s3) {
+            exports.push('S3_STORAGE_PROVIDER');
+        }
+        if (options.storage) {
+            exports.push('STORAGE_PROVIDER');
+        }
+        return {
+            module: FileUploadModule_1,
+            imports,
+            controllers: databaseEnabled ? [file_access_controller_1.FileAccessController] : [],
+            providers,
+            exports,
+            global: true,
+        };
+    }
+    /**
+     * 异步配置模块
+     */
+    static forRootAsync(asyncOptions) {
+        const providers = [
+            // 核心服务
+            mime_registry_service_1.MimeRegistryService,
+            file_signature_validator_service_1.FileSignatureValidator,
+            // 恶意文件检测器配置（异步）
+            {
+                provide: 'MALICIOUS_DETECTOR_OPTIONS',
+                useFactory: (...args) => __awaiter(this, void 0, void 0, function* () {
+                    const options = yield asyncOptions.useFactory(...args);
+                    return options.maliciousDetection || {};
+                }),
+                inject: asyncOptions.inject || [],
+            },
+            malicious_file_detector_service_1.MaliciousFileDetector,
+            // Interceptor
+            file_upload_interceptor_1.FileUploadInterceptor,
+            // 异步配置
+            {
+                provide: 'FILE_UPLOAD_OPTIONS',
+                useFactory: asyncOptions.useFactory,
+                inject: asyncOptions.inject || [],
+            },
+            // 异步处理器注册
+            {
+                provide: 'FILE_PROCESSORS',
+                useFactory: (...args) => __awaiter(this, void 0, void 0, function* () {
+                    const options = yield asyncOptions.useFactory(...args);
+                    if (!options.processors || options.processors.length === 0) {
+                        return new Map();
+                    }
+                    const processorMap = new Map();
+                    for (const ProcessorClass of options.processors) {
+                        const processor = new ProcessorClass();
+                        processorMap.set(processor.name, processor);
+                    }
+                    return processorMap;
+                }),
+                inject: asyncOptions.inject || [],
+            },
+            // 异步自定义文件类型初始化
+            {
+                provide: 'FILE_TYPE_INITIALIZER',
+                useFactory: (registry, ...args) => __awaiter(this, void 0, void 0, function* () {
+                    const options = yield asyncOptions.useFactory(...args);
+                    if (options.customFileTypes) {
+                        registry.registerCustomFileTypes(options.customFileTypes);
+                    }
+                    return registry;
+                }),
+                inject: [mime_registry_service_1.MimeRegistryService, ...(asyncOptions.inject || [])],
+            },
+        ];
+        const imports = [
+            // 默认开启 TypeORM
+            typeorm_1.TypeOrmModule.forFeature([file_entity_1.FileEntity, file_metadata_entity_1.FileMetadataEntity]),
+        ];
+        providers.push(file_service_1.FileService);
+        // For async, we always provide FILE_PROCESSORS (with empty Map fallback)
+        // Storage providers need to be handled via the options factory
+        return {
+            module: FileUploadModule_1,
+            imports,
+            controllers: [file_access_controller_1.FileAccessController],
+            providers,
+            exports: [
+                mime_registry_service_1.MimeRegistryService,
+                file_signature_validator_service_1.FileSignatureValidator,
+                malicious_file_detector_service_1.MaliciousFileDetector,
+                file_upload_interceptor_1.FileUploadInterceptor,
+                file_service_1.FileService,
+                'FILE_UPLOAD_OPTIONS',
+                'FILE_PROCESSORS',
+            ],
+            global: true,
+        };
+    }
+    /**
+     * 创建存储提供者
+     */
+    static createStorageProviders(storageConfig) {
+        const providers = [];
+        // 本地存储
+        if (storageConfig.local) {
+            providers.push({
+                provide: 'LOCAL_STORAGE_PROVIDER',
+                useFactory: () => __awaiter(this, void 0, void 0, function* () {
+                    const provider = new local_storage_provider_1.LocalStorageProvider(storageConfig.local);
+                    yield provider.initialize();
+                    return provider;
+                }),
+            });
+            // 如果是默认存储
+            if (storageConfig.default === 'local' || !storageConfig.default) {
+                providers.push({
+                    provide: 'STORAGE_PROVIDER',
+                    useExisting: 'LOCAL_STORAGE_PROVIDER',
+                });
+            }
+        }
+        // S3 存储
+        if (storageConfig.s3) {
+            providers.push({
+                provide: 'S3_STORAGE_PROVIDER',
+                useFactory: () => __awaiter(this, void 0, void 0, function* () {
+                    // Lazy load S3StorageProvider to avoid bundling AWS SDK
+                    const { S3StorageProvider } = yield Promise.resolve().then(() => require('./providers/s3-storage.provider'));
+                    const provider = new S3StorageProvider(storageConfig.s3);
+                    yield provider.initialize();
+                    return provider;
+                }),
+            });
+            // 如果是默认存储
+            if (storageConfig.default === 's3') {
+                providers.push({
+                    provide: 'STORAGE_PROVIDER',
+                    useExisting: 'S3_STORAGE_PROVIDER',
+                });
+            }
+        }
+        // TODO: 添加 OSS, MinIO 存储提供者
+        return providers;
+    }
+};
+exports.FileUploadModule = FileUploadModule;
+exports.FileUploadModule = FileUploadModule = FileUploadModule_1 = __decorate([
+    (0, common_1.Module)({})
+], FileUploadModule);

package/file-upload/index.d.ts

@@ -0,0 +1,26 @@
+export * from './file-upload.module';
+export * from './enums/file-type.enum';
+export * from './interfaces/file-upload-options.interface';
+export * from './interfaces/storage-provider.interface';
+export * from './interfaces/file-buffer.interface';
+export * from './interfaces/file-metadata.interface';
+export * from './interfaces/upload-options.interface';
+export * from './interfaces/custom-file-type.interface';
+export * from './decorators/file-upload.decorator';
+export * from './decorators/excel-data.decorator';
+export * from './decorators/csv-data.decorator';
+export * from './decorators/process.decorator';
+export * from './interceptors/file-upload.interceptor';
+export * from './controllers/file-access.controller';
+export * from './providers/local-storage.provider';
+export * from './services/mime-registry.service';
+export * from './services/file-signature-validator.service';
+export * from './services/malicious-file-detector.service';
+export * from './services/file.service';
+export * from './entities/file.entity';
+export * from './entities/file-metadata.entity';
+export * from './dto/create-file.dto';
+export * from './dto/update-file.dto';
+export * from './dto/find-files.dto';
+export * from './dto/pagination.dto';
+export * from './exceptions/file-upload.exception';

package/file-upload/index.js

@@ -0,0 +1,59 @@
+"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 });
+// Module
+__exportStar(require("./file-upload.module"), exports);
+// Enums
+__exportStar(require("./enums/file-type.enum"), exports);
+// Interfaces
+__exportStar(require("./interfaces/file-upload-options.interface"), exports);
+__exportStar(require("./interfaces/storage-provider.interface"), exports);
+__exportStar(require("./interfaces/file-buffer.interface"), exports);
+__exportStar(require("./interfaces/file-metadata.interface"), exports);
+__exportStar(require("./interfaces/upload-options.interface"), exports);
+__exportStar(require("./interfaces/custom-file-type.interface"), exports);
+// Note: FileEntity interface is not exported to avoid conflict with TypeORM entity
+// Decorators
+__exportStar(require("./decorators/file-upload.decorator"), exports);
+__exportStar(require("./decorators/excel-data.decorator"), exports);
+__exportStar(require("./decorators/csv-data.decorator"), exports);
+__exportStar(require("./decorators/process.decorator"), exports);
+// Interceptors
+__exportStar(require("./interceptors/file-upload.interceptor"), exports);
+// Controllers
+__exportStar(require("./controllers/file-access.controller"), exports);
+// Providers
+__exportStar(require("./providers/local-storage.provider"), exports);
+// Note: S3StorageProvider is not exported to avoid bundling optional AWS SDK dependencies
+// export * from './providers/s3-storage.provider';
+// Services
+__exportStar(require("./services/mime-registry.service"), exports);
+__exportStar(require("./services/file-signature-validator.service"), exports);
+__exportStar(require("./services/malicious-file-detector.service"), exports);
+__exportStar(require("./services/file.service"), exports);
+// Entities
+__exportStar(require("./entities/file.entity"), exports);
+__exportStar(require("./entities/file-metadata.entity"), exports);
+// DTOs
+__exportStar(require("./dto/create-file.dto"), exports);
+__exportStar(require("./dto/update-file.dto"), exports);
+__exportStar(require("./dto/find-files.dto"), exports);
+__exportStar(require("./dto/pagination.dto"), exports);
+// Exceptions
+__exportStar(require("./exceptions/file-upload.exception"), exports);
+// Utils
+// Note: DynamicImportUtil is an internal utility not exported to avoid bundling optional dependencies
+// export * from './utils/dynamic-import.util';

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

@@ -0,0 +1,48 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { Observable } from 'rxjs';
+import { IFileProcessor } from '../interfaces/file-upload-options.interface';
+import { FileService } from '../services/file.service';
+import { FileSignatureValidator } from '../services/file-signature-validator.service';
+import { MaliciousFileDetector } from '../services/malicious-file-detector.service';
+import { MimeRegistryService } from '../services/mime-registry.service';
+/**
+ * 文件上传拦截器（增强版）
+ * 负责创建文件记录、执行钩子、处理器等后置逻辑
+ */
+export declare class FileUploadInterceptor implements NestInterceptor {
+    private readonly reflector;
+    private readonly mimeRegistry;
+    private readonly processors?;
+    private readonly fileService?;
+    private readonly signatureValidator?;
+    private readonly maliciousDetector?;
+    private readonly moduleOptions?;
+    private readonly logger;
+    constructor(reflector: Reflector, mimeRegistry: MimeRegistryService, processors?: Map<string, IFileProcessor>, fileService?: FileService, signatureValidator?: FileSignatureValidator, maliciousDetector?: MaliciousFileDetector, moduleOptions?: any);
+    intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<any>>;
+    /**
+     * 创建上传上下文
+     */
+    private createUploadContext;
+    /**
+     * 获取处理器
+     */
+    private getProcessor;
+    /**
+     * 生成uploadId
+     */
+    private generateUploadId;
+    /**
+     * 计算文件校验和
+     */
+    private calculateChecksum;
+    /**
+     * 验证 MIME 类型
+     */
+    private validateMimeType;
+    /**
+     * 验证扩展名
+     */
+    private validateExtension;
+}