@flusys/nestjs-storage 7.0.2 → 8.0.0-beta.1

package/fesm/services/upload.service.js

@@ -1,366 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(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;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { LogAction } from '@flusys/nestjs-shared';
-import { publishDomainEvent } from '@flusys/nestjs-shared/classes';
-import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
-import { validateCompanyOwnership } from '@flusys/nestjs-shared/utils';
-import { BadRequestException, Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
-import { STORAGE_EVENT_ACTIONS, STORAGE_EVENT_ENTITIES, STORAGE_EVENT_MODULE, UPLOAD_MESSAGES } from '../config';
-import { UploadOptionsDto } from '../dtos/upload.dto';
-import { FileLocationEnum } from '../enums/file-location.enum';
-import { StorageFactoryService } from '../providers/storage-factory.service';
-import { FileValidator } from '../utils/file-validator.util';
-import { StorageConfigService } from './storage-config.service';
-import { StorageProviderConfigService } from './storage-provider-config.service';
-export class UploadService {
-    /**
-   * Validate file before upload - includes size, type, and content validation.
-   * Uses magic bytes to verify file content matches declared MIME type.
-   */ validateFile(file) {
-        // Validate file size
-        const sizeValidation = this.storageConfigService.validateFileSize(file.size);
-        if (!sizeValidation.valid) {
-            throw new BadRequestException({
-                message: sizeValidation.message,
-                messageKey: sizeValidation.messageKey,
-                messageVariables: sizeValidation.messageVariables
-            });
-        }
-        // Validate declared file type (MIME)
-        const typeValidation = this.storageConfigService.validateFileType(file.mimetype);
-        if (!typeValidation.valid) {
-            throw new BadRequestException({
-                message: typeValidation.message,
-                messageKey: typeValidation.messageKey,
-                messageVariables: typeValidation.messageVariables
-            });
-        }
-        // Validate file content matches declared type (magic bytes check)
-        // This prevents MIME type spoofing attacks
-        const allowedTypes = this.storageConfigService.getAllowedFileTypes();
-        const contentValidation = FileValidator.validateFileContent(file.buffer, file.mimetype, allowedTypes);
-        if (!contentValidation.valid) {
-            throw new BadRequestException({
-                message: contentValidation.message || 'File content validation failed',
-                messageKey: UPLOAD_MESSAGES.INVALID_TYPE,
-                messageVariables: {
-                    mimeType: file.mimetype,
-                    allowedTypes: allowedTypes.join(', ')
-                }
-            });
-        }
-        // Sanitize filename to prevent path traversal attacks
-        file.originalname = FileValidator.sanitizeFilename(file.originalname);
-    }
-    /**
-   * Create provider from storage config entity
-   */ async createProviderFromConfig(config) {
-        return this.storageFactory.createProvider({
-            provider: config.storage,
-            config: config.config
-        });
-    }
-    /**
-   * Create fallback local provider
-   */ async createFallbackLocalProvider() {
-        return this.storageFactory.createProvider({
-            provider: FileLocationEnum.LOCAL,
-            config: {
-                basePath: this.storageConfigService.getDefaultLocalStoragePath()
-            }
-        });
-    }
-    /**
-   * Get storage provider and config info based on storage config ID
-   * Validates company ownership when company feature is enabled
-   */ async getStorageProviderWithConfig(storageConfigId, user) {
-        let storageConfig;
-        // Get storage config from database
-        if (storageConfigId) {
-            // Use direct lookup (bypasses company filtering, returns null instead of throwing)
-            const config = await this.storageProviderConfigService.findByIdDirect(storageConfigId);
-            if (!config) {
-                throw new NotFoundException({
-                    message: 'Storage configuration not found',
-                    messageKey: UPLOAD_MESSAGES.CONFIG_NOT_FOUND
-                });
-            }
-            // Validate company ownership using shared utility
-            validateCompanyOwnership(config, user, this.storageConfigService.isCompanyFeatureEnabled(), 'Storage configuration');
-            storageConfig = config;
-        } else {
-            // Use default config (scoped to user's company/branch)
-            const defaultConfig = await this.storageProviderConfigService.getDefaultConfig(user);
-            if (!defaultConfig) {
-                throw new NotFoundException({
-                    message: 'No default storage configuration found for your company/branch. Please create one.',
-                    messageKey: UPLOAD_MESSAGES.CONFIG_NOT_FOUND
-                });
-            }
-            storageConfig = defaultConfig;
-        }
-        const provider = await this.createProviderFromConfig(storageConfig);
-        return {
-            provider,
-            location: storageConfig.storage,
-            configId: storageConfig.id
-        };
-    }
-    /**
-   * Get storage provider for delete operations with fallback
-   * If the original storage config doesn't exist, falls back based on locationHint
-   */ async getStorageProviderForDelete(storageConfigId, user, locationHint) {
-        // Try to find by storageConfigId
-        if (storageConfigId) {
-            const config = await this.storageProviderConfigService.findByIdDirect(storageConfigId);
-            if (config) {
-                return this.createProviderFromConfig(config);
-            }
-        }
-        // Fallback: Use locationHint to find a matching config
-        if (locationHint) {
-            const matchingConfigs = await this.storageProviderConfigService.getConfigByType(locationHint, user);
-            if (matchingConfigs.length > 0) {
-                return this.createProviderFromConfig(matchingConfigs[0]);
-            }
-            if (locationHint === FileLocationEnum.LOCAL) {
-                return this.createFallbackLocalProvider();
-            }
-        }
-        // Last resort: Try default config
-        const defaultConfig = await this.storageProviderConfigService.getDefaultConfig(user);
-        if (defaultConfig) {
-            return this.createProviderFromConfig(defaultConfig);
-        }
-        return this.createFallbackLocalProvider();
-    }
-    async uploadSingleFile(file, options, user) {
-        this.validateFile(file);
-        const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
-        const result = await provider.uploadFile(file, options);
-        await this.publishFileEvent(STORAGE_EVENT_ACTIONS.UPLOADED, [
-            result.key
-        ], user, {
-            location,
-            storageConfigId: configId,
-            totalSize: result.size,
-            count: 1
-        });
-        return {
-            ...result,
-            location,
-            storageConfigId: configId
-        };
-    }
-    async uploadMultipleFiles(files, options, user) {
-        for (const file of files){
-            this.validateFile(file);
-        }
-        const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
-        const results = await provider.uploadMultipleFiles(files, options);
-        await this.publishFileEvent(STORAGE_EVENT_ACTIONS.UPLOADED, results.map((result)=>result.key), user, {
-            location,
-            storageConfigId: configId,
-            totalSize: results.reduce((sum, result)=>sum + (result.size ?? 0), 0),
-            count: results.length
-        });
-        return results.map((result)=>({
-                ...result,
-                location,
-                storageConfigId: configId
-            }));
-    }
-    async deleteSingleFile(key, storageConfigId, user, locationHint) {
-        if (!key) throw new BadRequestException({
-            message: 'No file path provided',
-            messageKey: UPLOAD_MESSAGES.NO_FILE_PATH
-        });
-        const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
-        await provider.deleteFile(key);
-        await this.publishFileEvent(STORAGE_EVENT_ACTIONS.REMOVED, [
-            key
-        ], user, {
-            storageConfigId,
-            count: 1
-        });
-        return true;
-    }
-    async deleteMultipleFile(keys, storageConfigId, user, locationHint) {
-        if (!keys || !keys.length) throw new BadRequestException({
-            message: 'No file paths provided',
-            messageKey: UPLOAD_MESSAGES.NO_FILE_PATH
-        });
-        const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
-        await provider.deleteMultipleFiles(keys);
-        await this.publishFileEvent(STORAGE_EVENT_ACTIONS.REMOVED, keys, user, {
-            storageConfigId,
-            count: keys.length
-        });
-        return true;
-    }
-    async publishFileEvent(action, keys, user, metadata) {
-        await publishDomainEvent({
-            module: STORAGE_EVENT_MODULE,
-            entity: STORAGE_EVENT_ENTITIES.FILE,
-            action,
-            ids: keys,
-            metadata,
-            user: user ?? null
-        });
-    }
-    bytesToKb(bytes) {
-        return Number((bytes * 0.001).toFixed(2));
-    }
-    /**
-   * Get local storage basePath from DB config
-   * Initializes local provider if not cached, ensuring basePath is from DB
-   */ async getLocalStorageBasePath() {
-        try {
-            // First check if already cached
-            const cachedPath = this.storageFactory.getLocalProviderBasePath();
-            if (cachedPath) {
-                return cachedPath;
-            }
-            // Get local config from DB (without user context for public access)
-            const localConfigs = await this.storageProviderConfigService.getConfigByType(FileLocationEnum.LOCAL);
-            if (localConfigs.length > 0) {
-                const localConfig = localConfigs[0];
-                // Initialize provider to cache it
-                await this.storageFactory.createProvider({
-                    provider: FileLocationEnum.LOCAL,
-                    config: localConfig.config
-                });
-                // Now get the cached basePath
-                return this.storageFactory.getLocalProviderBasePath();
-            }
-            return null;
-        } catch  {
-            return null;
-        }
-    }
-    async makeFileUrl(key, storageConfigId, expiresIn = 3600, user) {
-        const { provider } = await this.getStorageProviderWithConfig(storageConfigId, user);
-        // Check if provider supports presigned URLs
-        if (provider.generatePresignedUrl) {
-            return await provider.generatePresignedUrl(key, expiresIn);
-        }
-        // For SFTP or other providers without presigned URLs
-        return key;
-    }
-    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
-    constructor(storageFactory, storageConfigService, storageProviderConfigService){
-        _define_property(this, "storageFactory", void 0);
-        _define_property(this, "storageConfigService", void 0);
-        _define_property(this, "storageProviderConfigService", void 0);
-        this.storageFactory = storageFactory;
-        this.storageConfigService = storageConfigService;
-        this.storageProviderConfigService = storageProviderConfigService;
-    }
-}
-_ts_decorate([
-    LogAction({
-        action: 'storage.uploadSingle',
-        module: 'storage'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Express === "undefined" || typeof Express.Multer === "undefined" || typeof Express.Multer.File === "undefined" ? Object : Express.Multer.File,
-        typeof UploadOptionsDto === "undefined" ? Object : UploadOptionsDto,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UploadService.prototype, "uploadSingleFile", null);
-_ts_decorate([
-    LogAction({
-        action: 'storage.uploadMultiple',
-        module: 'storage'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Array,
-        typeof UploadOptionsDto === "undefined" ? Object : UploadOptionsDto,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UploadService.prototype, "uploadMultipleFiles", null);
-_ts_decorate([
-    LogAction({
-        action: 'storage.deleteSingle',
-        module: 'storage'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String,
-        String,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo,
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UploadService.prototype, "deleteSingleFile", null);
-_ts_decorate([
-    LogAction({
-        action: 'storage.deleteMultiple',
-        module: 'storage'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Array,
-        String,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo,
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UploadService.prototype, "deleteMultipleFile", null);
-_ts_decorate([
-    LogAction({
-        action: 'storage.makeFileUrl',
-        module: 'storage'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String,
-        String,
-        Number,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UploadService.prototype, "makeFileUrl", null);
-UploadService = _ts_decorate([
-    Injectable({
-        scope: Scope.REQUEST
-    }),
-    _ts_param(0, Inject(StorageFactoryService)),
-    _ts_param(1, Inject(StorageConfigService)),
-    _ts_param(2, Inject(StorageProviderConfigService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof StorageFactoryService === "undefined" ? Object : StorageFactoryService,
-        typeof StorageConfigService === "undefined" ? Object : StorageConfigService,
-        typeof StorageProviderConfigService === "undefined" ? Object : StorageProviderConfigService
-    ])
-], UploadService);