@flusys/nestjs-storage 3.0.1 → 4.0.0-lts

package/cjs/providers/storage-factory.service.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "StorageFactoryService", {
 });
 const _common = require("@nestjs/common");
 const _crypto = /*#__PURE__*/ _interop_require_wildcard(require("crypto"));
+const _constants = require("@flusys/nestjs-shared/constants");
 const _services = require("../services");
 const _storageproviderregistry = require("./storage-provider.registry");
 function _define_property(obj, key, value) {
@@ -87,17 +88,30 @@ let StorageFactoryService = class StorageFactoryService {
         if (cached) return cached;
         const ProviderClass = _storageproviderregistry.StorageProviderRegistry.get(config.provider);
         if (!ProviderClass) {
-            throw new _common.NotFoundException(`Storage provider '${config.provider}' not registered. Available: ${_storageproviderregistry.StorageProviderRegistry.getAll().join(', ')}`);
+            throw new _common.NotFoundException({
+                message: `Storage provider '${config.provider}' not registered. Available: ${_storageproviderregistry.StorageProviderRegistry.getAll().join(', ')}`,
+                messageKey: _constants.SYSTEM_MESSAGES.SERVICE_NOT_AVAILABLE,
+                messageParams: {
+                    provider: config.provider,
+                    available: _storageproviderregistry.StorageProviderRegistry.getAll().join(', ')
+                }
+            });
         }
         try {
             const instance = new ProviderClass();
             await this.initializeProvider(instance, config);
             this.cache.set(cacheKey, instance);
-            this.logger.log(`Created provider: ${config.provider} (${cacheKey})`);
             return instance;
         } catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            throw new Error(`Failed to initialize '${config.provider}': ${message}`);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new _common.InternalServerErrorException({
+                message: `Failed to initialize '${config.provider}': ${errorMessage}`,
+                messageKey: _constants.SYSTEM_MESSAGES.INTERNAL_ERROR,
+                messageParams: {
+                    provider: config.provider,
+                    error: errorMessage
+                }
+            });
         }
     }
     async getProvider(providerName) {
@@ -117,11 +131,9 @@ let StorageFactoryService = class StorageFactoryService {
         this.cache.clear();
     }
     async onModuleDestroy() {
-        this.logger.log('Cleaning up storage providers...');
-        const closePromises = Array.from(this.cache.entries()).filter(([, p])=>'close' in p && typeof p.close === 'function').map(([key, p])=>p.close().then(()=>this.logger.debug(`Closed: ${key}`)).catch((e)=>this.logger.warn(`Failed to close ${key}: ${e.message}`)));
+        const closePromises = Array.from(this.cache.entries()).filter(([, p])=>'close' in p && typeof p.close === 'function').map(([, p])=>p.close().catch(()=>{}));
         await Promise.allSettled(closePromises);
         this.cache.clear();
-        this.logger.log('Storage provider cleanup complete');
     }
     // ─── Private Helpers ──────────────────────────────────────────────────────────
     generateCacheKey(config) {
@@ -142,17 +154,14 @@ let StorageFactoryService = class StorageFactoryService {
                     ...config.config,
                     baseUrl: appUrl
                 };
-                this.logger.debug(`Using appUrl as baseUrl: ${appUrl}`);
             }
         }
         await instance.initialize(initConfig);
     }
     constructor(configService){
         _define_property(this, "configService", void 0);
-        _define_property(this, "logger", void 0);
         _define_property(this, "cache", void 0);
         this.configService = configService;
-        this.logger = new _common.Logger(StorageFactoryService.name);
         this.cache = new Map();
     }
 };

package/cjs/services/file-manager.service.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "FileManagerService", {
 const _classes = require("@flusys/nestjs-shared/classes");
 const _modules = require("@flusys/nestjs-shared/modules");
 const _utils = require("@flusys/nestjs-shared/utils");
+const _config = require("../config");
 const _common = require("@nestjs/common");
 const _typeorm = require("typeorm");
 const _storageconfigservice = require("./storage-config.service");
@@ -118,7 +119,10 @@ let FileManagerService = class FileManagerService extends _classes.RequestScoped
                     id: dto.id
                 }
             });
-            if (!existing) throw new _common.NotFoundException('Entity not found for update');
+            if (!existing) throw new _common.NotFoundException({
+                message: 'Entity not found for update',
+                messageKey: _config.FILE_MESSAGES.NOT_FOUND
+            });
             entity = existing;
         }
         const validatedFolder = dto.folderId ? await this.validateFolder(dto.folderId, user) : null;
@@ -148,7 +152,7 @@ let FileManagerService = class FileManagerService extends _classes.RequestScoped
     }
     async getFilterQuery(query, filter, _user) {
         for (const [key, value] of Object.entries(filter)){
-            if (key === 'contentType') {
+            if (key === 'contentType' && typeof value === 'string') {
                 this.applyContentTypeFilter(query, value);
             } else {
                 query.andWhere(`${this.entityName}.${key} = :value`, {
@@ -220,8 +224,7 @@ let FileManagerService = class FileManagerService extends _classes.RequestScoped
                     ...item,
                     providerName: item.storageConfigId ? nameMap.get(item.storageConfigId) : undefined
                 }));
-        } catch (error) {
-            this.logger.warn(`Failed to fetch provider names: ${_utils.ErrorHandler.getErrorMessage(error)}`);
+        } catch  {
             return items.map((item)=>({
                     ...item,
                     providerName: undefined
@@ -231,7 +234,10 @@ let FileManagerService = class FileManagerService extends _classes.RequestScoped
     async getFiles(dtos, protocol, host, user) {
         await this.ensureRepositoryInitialized();
         const ids = dtos.map((d)=>d.id).filter(Boolean);
-        if (!ids.length) throw new _common.BadRequestException('No valid file IDs provided');
+        if (!ids.length) throw new _common.BadRequestException({
+            message: 'No valid file IDs provided',
+            messageKey: _config.UPLOAD_MESSAGES.NO_FILES_PROVIDED
+        });
         const files = await this.repository.findBy({
             id: (0, _typeorm.In)(ids)
         });
@@ -245,17 +251,13 @@ let FileManagerService = class FileManagerService extends _classes.RequestScoped
         if (updatedFiles.length) {
             try {
                 await this.repository.save(updatedFiles);
-            } catch (error) {
-                this.logger.error(`Failed to save updated URLs: ${_utils.ErrorHandler.getErrorMessage(error)}`);
+            } catch  {
+            // Silent failure - URL update is non-critical
             }
         }
         return responses;
     }
     // ─── Private Helpers ────────────────────────────────────────────────────────
-    async getStorageConfigRepository() {
-        const entity = this.storageConfig.isCompanyFeatureEnabled() ? (await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../entities")))).StorageConfigWithCompany : (await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../entities")))).StorageConfig;
-        return this.dataSourceProvider.getRepository(entity);
-    }
     buildWhereWithCompany(id, user) {
         const where = {
             id
@@ -265,6 +267,10 @@ let FileManagerService = class FileManagerService extends _classes.RequestScoped
         }
         return where;
     }
+    async getStorageConfigRepository() {
+        const entity = this.storageConfig.isCompanyFeatureEnabled() ? (await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../entities")))).StorageConfigWithCompany : (await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../entities")))).StorageConfig;
+        return this.dataSourceProvider.getRepository(entity);
+    }
     async getStorageConfigBasePath(configId) {
         try {
             const repo = await this.getStorageConfigRepository();
@@ -278,8 +284,7 @@ let FileManagerService = class FileManagerService extends _classes.RequestScoped
                 ]
             });
             return config?.config?.basePath?.replace(/^\.\//, '') ?? null;
-        } catch (error) {
-            this.logger.warn(`Failed to get basePath for ${configId}: ${_utils.ErrorHandler.getErrorMessage(error)}`);
+        } catch  {
             return null;
         }
     }
@@ -290,7 +295,13 @@ let FileManagerService = class FileManagerService extends _classes.RequestScoped
             where: this.buildWhereWithCompany(folderId, user)
         });
         if (!folder) {
-            throw new _common.BadRequestException(`Folder ${folderId} not found or access denied`);
+            throw new _common.BadRequestException({
+                message: `Folder "${folderId}" not found or access denied`,
+                messageKey: _config.FOLDER_MESSAGES.NOT_FOUND,
+                messageParams: {
+                    folderId
+                }
+            });
         }
         return folder;
     }
@@ -303,8 +314,7 @@ let FileManagerService = class FileManagerService extends _classes.RequestScoped
                 where: this.buildWhereWithCompany(configId, user)
             });
             return config?.storage || dto.location || _filelocationenum.FileLocationEnum.LOCAL;
-        } catch (error) {
-            this.logger.warn(`Failed to resolve storage location: ${_utils.ErrorHandler.getErrorMessage(error)}`);
+        } catch  {
             return dto.location || _filelocationenum.FileLocationEnum.LOCAL;
         }
     }
@@ -350,12 +360,10 @@ let FileManagerService = class FileManagerService extends _classes.RequestScoped
         return grouped;
     }
     getFileBaseUrl(protocol, host) {
-        return this.storageConfig.getAppUrl()?.replace(/\/$/, '') ?? `${protocol}://${host}`;
+        const appUrl = this.storageConfig.getAppUrl()?.replace(/\/$/, '');
+        return appUrl || `${protocol}://${host}`;
     }
     async refreshFileUrl(file, protocol, host, now, user) {
-        if (!file.storageConfigId) {
-            this.logger.warn(`File ${file.id} has no storageConfigId`);
-        }
         const isCloudProvider = file.location === _filelocationenum.FileLocationEnum.AWS || file.location === _filelocationenum.FileLocationEnum.AZURE;
         const needsNewUrl = !file.url || isCloudProvider && (typeof file.expiresAt !== 'number' || now >= file.expiresAt);
         if (needsNewUrl && file.storageConfigId) {
@@ -363,8 +371,7 @@ let FileManagerService = class FileManagerService extends _classes.RequestScoped
                 file.url = await this.uploadService.makeFileUrl(file.key, file.storageConfigId, URL_EXPIRY_SECONDS, user);
                 file.expiresAt = now + URL_EXPIRY_SECONDS * 1000;
                 return true;
-            } catch (error) {
-                this.logger.error(`Failed to generate URL for ${file.id}: ${_utils.ErrorHandler.getErrorMessage(error)}`);
+            } catch  {
                 file.url = `${this.getFileBaseUrl(protocol, host)}/storage/upload/file/${file.key}`;
             }
         }
@@ -393,7 +400,7 @@ let FileManagerService = class FileManagerService extends _classes.RequestScoped
         };
     }
     constructor(cacheManager, utilsService, uploadService, storageConfig, dataSourceProvider){
-        super('file_manager', null, cacheManager, utilsService, FileManagerService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "uploadService", void 0), _define_property(this, "storageConfig", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.uploadService = uploadService, this.storageConfig = storageConfig, this.dataSourceProvider = dataSourceProvider;
+        super('file_manager', null, cacheManager, utilsService, FileManagerService.name, true, 'storage'), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "uploadService", void 0), _define_property(this, "storageConfig", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.uploadService = uploadService, this.storageConfig = storageConfig, this.dataSourceProvider = dataSourceProvider;
     }
 };
 FileManagerService = _ts_decorate([

package/cjs/services/folder.service.js

@@ -49,6 +49,7 @@ let FolderService = class FolderService extends _classes.RequestScopedApiService
     getDataSourceProvider() {
         return this.dataSourceProvider;
     }
+    // ─── Override Methods ───────────────────────────────────────────────────────
     async convertSingleDtoToEntity(dto, user) {
         const entity = await super.convertSingleDtoToEntity(dto, user);
         if (this.storageConfig.isCompanyFeatureEnabled()) {
@@ -84,7 +85,7 @@ let FolderService = class FolderService extends _classes.RequestScopedApiService
         return result;
     }
     constructor(cacheManager, utilsService, storageConfig, dataSourceProvider){
-        super('folder', null, cacheManager, utilsService, FolderService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "storageConfig", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.storageConfig = storageConfig, this.dataSourceProvider = dataSourceProvider;
+        super('folder', null, cacheManager, utilsService, FolderService.name, true, 'storage'), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "storageConfig", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.storageConfig = storageConfig, this.dataSourceProvider = dataSourceProvider;
     }
 };
 FolderService = _ts_decorate([

package/cjs/services/storage-datasource.provider.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "StorageDataSourceProvider", {
 });
 const _modules = require("@flusys/nestjs-shared/modules");
 const _common = require("@nestjs/common");
+const _constants = require("@flusys/nestjs-shared/constants");
 const _core = require("@nestjs/core");
 const _express = require("express");
 const _storageconfigservice = require("./storage-config.service");
@@ -141,7 +142,10 @@ let StorageDataSourceProvider = class StorageDataSourceProvider extends _modules
         }
         const config = this.getDefaultDatabaseConfig();
         if (!config) {
-            throw new Error('No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.');
+            throw new _common.InternalServerErrorException({
+                message: 'No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.',
+                messageKey: _constants.SYSTEM_MESSAGES.DATABASE_CONFIG_NOT_AVAILABLE
+            });
         }
         // Create connection with lock to prevent race conditions
         const connectionPromise = this.createDataSourceFromConfig(config);
@@ -180,7 +184,7 @@ let StorageDataSourceProvider = class StorageDataSourceProvider extends _modules
         }
     }
     constructor(configService, request){
-        super(StorageDataSourceProvider.buildParentOptions(configService.getOptions()), request), _define_property(this, "configService", void 0), _define_property(this, "logger", void 0), this.configService = configService, this.logger = new _common.Logger(StorageDataSourceProvider.name);
+        super(StorageDataSourceProvider.buildParentOptions(configService.getOptions()), request), _define_property(this, "configService", void 0), this.configService = configService;
     }
 };
 // Override parent's static properties to have Storage-specific cache

package/cjs/services/storage-provider-config.service.js

@@ -49,6 +49,7 @@ let StorageProviderConfigService = class StorageProviderConfigService extends _c
     getDataSourceProvider() {
         return this.dataSourceProvider;
     }
+    // ─── Override Methods ───────────────────────────────────────────────────────
     async convertSingleDtoToEntity(dto, user) {
         const entity = await super.convertSingleDtoToEntity(dto, user);
         if (this.storageConfig.isCompanyFeatureEnabled()) {
@@ -130,7 +131,7 @@ let StorageProviderConfigService = class StorageProviderConfigService extends _c
         });
     }
     constructor(cacheManager, utilsService, storageConfig, dataSourceProvider){
-        super('storageConfig', null, cacheManager, utilsService, StorageProviderConfigService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "storageConfig", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.storageConfig = storageConfig, this.dataSourceProvider = dataSourceProvider;
+        super('storageConfig', null, cacheManager, utilsService, StorageProviderConfigService.name, true, 'storage'), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "storageConfig", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.storageConfig = storageConfig, this.dataSourceProvider = dataSourceProvider;
     }
 };
 StorageProviderConfigService = _ts_decorate([

package/cjs/services/upload.service.js

@@ -8,9 +8,13 @@ Object.defineProperty(exports, "UploadService", {
         return UploadService;
     }
 });
+const _nestjsshared = require("@flusys/nestjs-shared");
+const _config = require("../config");
+const _interfaces = require("@flusys/nestjs-shared/interfaces");
 const _utils = require("@flusys/nestjs-shared/utils");
 const _common = require("@nestjs/common");
 const _storageconfigservice = require("./storage-config.service");
+const _uploaddto = require("../dtos/upload.dto");
 const _filelocationenum = require("../enums/file-location.enum");
 const _storagefactoryservice = require("../providers/storage-factory.service");
 const _storageproviderconfigservice = require("./storage-provider-config.service");
@@ -50,23 +54,28 @@ let UploadService = class UploadService {
         // Validate file size
         const sizeValidation = this.storageConfigService.validateFileSize(file.size);
         if (!sizeValidation.valid) {
-            throw new _common.BadRequestException(sizeValidation.message);
+            throw new _common.BadRequestException({
+                message: sizeValidation.message,
+                messageKey: _config.UPLOAD_MESSAGES.FILE_TOO_LARGE
+            });
         }
         // Validate declared file type (MIME)
         const typeValidation = this.storageConfigService.validateFileType(file.mimetype);
         if (!typeValidation.valid) {
-            throw new _common.BadRequestException(typeValidation.message);
+            throw new _common.BadRequestException({
+                message: typeValidation.message,
+                messageKey: _config.UPLOAD_MESSAGES.INVALID_TYPE
+            });
         }
         // Validate file content matches declared type (magic bytes check)
         // This prevents MIME type spoofing attacks
         const allowedTypes = this.storageConfigService.getAllowedFileTypes();
         const contentValidation = _filevalidatorutil.FileValidator.validateFileContent(file.buffer, file.mimetype, allowedTypes);
         if (!contentValidation.valid) {
-            this.logger.warn(`File content validation failed: ${contentValidation.message}`, {
-                declaredType: file.mimetype,
-                detectedType: contentValidation.detectedType
+            throw new _common.BadRequestException({
+                message: contentValidation.message || 'File content validation failed',
+                messageKey: _config.UPLOAD_MESSAGES.INVALID_TYPE
             });
-            throw new _common.BadRequestException(contentValidation.message || 'File content validation failed');
         }
         // Sanitize filename to prevent path traversal attacks
         file.originalname = _filevalidatorutil.FileValidator.sanitizeFilename(file.originalname);
@@ -82,7 +91,6 @@ let UploadService = class UploadService {
     /**
    * Create fallback local provider
    */ async createFallbackLocalProvider() {
-        this.logger.warn('No storage config found, using fallback local provider');
         return this.storageFactory.createProvider({
             provider: _filelocationenum.FileLocationEnum.LOCAL,
             config: {
@@ -100,7 +108,10 @@ let UploadService = class UploadService {
             // Use direct lookup (bypasses company filtering, returns null instead of throwing)
             const config = await this.storageProviderConfigService.findByIdDirect(storageConfigId);
             if (!config) {
-                throw new _common.NotFoundException('Storage configuration not found');
+                throw new _common.NotFoundException({
+                    message: 'Storage configuration not found',
+                    messageKey: _config.UPLOAD_MESSAGES.CONFIG_NOT_FOUND
+                });
             }
             // Validate company ownership using shared utility
             (0, _utils.validateCompanyOwnership)(config, user, this.storageConfigService.isCompanyFeatureEnabled(), 'Storage configuration');
@@ -109,7 +120,10 @@ let UploadService = class UploadService {
             // Use default config (scoped to user's company/branch)
             const defaultConfig = await this.storageProviderConfigService.getDefaultConfig(user);
             if (!defaultConfig) {
-                throw new _common.NotFoundException('No default storage configuration found for your company/branch. Please create one.');
+                throw new _common.NotFoundException({
+                    message: 'No default storage configuration found for your company/branch. Please create one.',
+                    messageKey: _config.UPLOAD_MESSAGES.CONFIG_NOT_FOUND
+                });
             }
             storageConfig = defaultConfig;
         }
@@ -130,7 +144,6 @@ let UploadService = class UploadService {
             if (config) {
                 return this.createProviderFromConfig(config);
             }
-            this.logger.warn(`Storage config ${storageConfigId} not found, trying fallback`);
         }
         // Fallback: Use locationHint to find a matching config
         if (locationHint) {
@@ -150,62 +163,44 @@ let UploadService = class UploadService {
         return this.createFallbackLocalProvider();
     }
     async uploadSingleFile(file, options, user) {
-        try {
-            // Validate file before upload
+        this.validateFile(file);
+        const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
+        const result = await provider.uploadFile(file, options);
+        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 result = await provider.uploadFile(file, options);
-            // Enrich result with storage info
-            return {
+        }
+        const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
+        const results = await provider.uploadMultipleFiles(files, options);
+        return results.map((result)=>({
                 ...result,
                 location,
                 storageConfigId: configId
-            };
-        } catch (error) {
-            _utils.ErrorHandler.logError(this.logger, error, 'uploadSingleFile');
-            _utils.ErrorHandler.rethrowError(error);
-        }
-    }
-    async uploadMultipleFiles(files, options, user) {
-        try {
-            // Validate each file before upload
-            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);
-            // Enrich results with storage info
-            return results.map((result)=>({
-                    ...result,
-                    location,
-                    storageConfigId: configId
-                }));
-        } catch (error) {
-            _utils.ErrorHandler.logError(this.logger, error, 'uploadMultipleFiles');
-            _utils.ErrorHandler.rethrowError(error);
-        }
+            }));
     }
     async deleteSingleFile(key, storageConfigId, user, locationHint) {
-        try {
-            if (!key) throw new _common.BadRequestException('No file path provided');
-            const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
-            await provider.deleteFile(key);
-            return true;
-        } catch (error) {
-            _utils.ErrorHandler.logError(this.logger, error, 'deleteSingleFile');
-            _utils.ErrorHandler.rethrowError(error);
-        }
+        if (!key) throw new _common.BadRequestException({
+            message: 'No file path provided',
+            messageKey: _config.UPLOAD_MESSAGES.NO_FILE_PATH
+        });
+        const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
+        await provider.deleteFile(key);
+        return true;
     }
     async deleteMultipleFile(keys, storageConfigId, user, locationHint) {
-        try {
-            if (!keys || !keys.length) throw new _common.BadRequestException('No file paths provided');
-            const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
-            await provider.deleteMultipleFiles(keys);
-            return true;
-        } catch (error) {
-            _utils.ErrorHandler.logError(this.logger, error, 'deleteMultipleFiles');
-            _utils.ErrorHandler.rethrowError(error);
-        }
+        if (!keys || !keys.length) throw new _common.BadRequestException({
+            message: 'No file paths provided',
+            messageKey: _config.UPLOAD_MESSAGES.NO_FILE_PATH
+        });
+        const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
+        await provider.deleteMultipleFiles(keys);
+        return true;
     }
     bytesToKb(bytes) {
         return Number((bytes * 0.001).toFixed(2));
@@ -233,42 +228,97 @@ let UploadService = class UploadService {
                 return this.storageFactory.getLocalProviderBasePath();
             }
             return null;
-        } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            this.logger.warn(`Failed to get local storage basePath: ${errorMessage}`);
+        } catch  {
             return null;
         }
     }
-    /**
-   * Generate a URL for accessing a file
-   * For S3/Azure: generates presigned URL
-   * For Local/SFTP: returns direct path
-   */ async makeFileUrl(key, storageConfigId, expiresIn = 3600, user) {
-        try {
-            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;
-        } catch (error) {
-            _utils.ErrorHandler.logError(this.logger, error, 'makeFileUrl');
-            _utils.ErrorHandler.rethrowError(error);
+    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);
-        _define_property(this, "logger", void 0);
         this.storageFactory = storageFactory;
         this.storageConfigService = storageConfigService;
         this.storageProviderConfigService = storageProviderConfigService;
-        this.logger = new _common.Logger(UploadService.name);
     }
 };
+_ts_decorate([
+    (0, _nestjsshared.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 _uploaddto.UploadOptionsDto === "undefined" ? Object : _uploaddto.UploadOptionsDto,
+        typeof _interfaces.ILoggedUserInfo === "undefined" ? Object : _interfaces.ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UploadService.prototype, "uploadSingleFile", null);
+_ts_decorate([
+    (0, _nestjsshared.LogAction)({
+        action: 'storage.uploadMultiple',
+        module: 'storage'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Array,
+        typeof _uploaddto.UploadOptionsDto === "undefined" ? Object : _uploaddto.UploadOptionsDto,
+        typeof _interfaces.ILoggedUserInfo === "undefined" ? Object : _interfaces.ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UploadService.prototype, "uploadMultipleFiles", null);
+_ts_decorate([
+    (0, _nestjsshared.LogAction)({
+        action: 'storage.deleteSingle',
+        module: 'storage'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        String,
+        typeof _interfaces.ILoggedUserInfo === "undefined" ? Object : _interfaces.ILoggedUserInfo,
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UploadService.prototype, "deleteSingleFile", null);
+_ts_decorate([
+    (0, _nestjsshared.LogAction)({
+        action: 'storage.deleteMultiple',
+        module: 'storage'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Array,
+        String,
+        typeof _interfaces.ILoggedUserInfo === "undefined" ? Object : _interfaces.ILoggedUserInfo,
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UploadService.prototype, "deleteMultipleFile", null);
+_ts_decorate([
+    (0, _nestjsshared.LogAction)({
+        action: 'storage.makeFileUrl',
+        module: 'storage'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        String,
+        Number,
+        typeof _interfaces.ILoggedUserInfo === "undefined" ? Object : _interfaces.ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UploadService.prototype, "makeFileUrl", null);
 UploadService = _ts_decorate([
     (0, _common.Injectable)({
         scope: _common.Scope.REQUEST

package/cjs/utils/file-validator.util.js

@@ -1,4 +1,6 @@
-"use strict";
+/**
+ * Result of file content validation.
+ */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
@@ -8,20 +10,6 @@ Object.defineProperty(exports, "FileValidator", {
         return FileValidator;
     }
 });
-const _common = require("@nestjs/common");
-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;
-}
 /**
  * Magic byte signatures for common file types.
  * Each entry maps a hex signature pattern to its MIME type.
@@ -408,7 +396,6 @@ let FileValidator = class FileValidator {
             }
             // Verify detected type matches declared type
             if (!this.mimeTypesMatch(detectedType, declaredMimeType)) {
-                this.logger.warn(`MIME type mismatch: declared=${declaredMimeType}, detected=${detectedType}`);
                 return this.failureResult(`File content does not match declared type. Detected: ${detectedType}, Declared: ${declaredMimeType}`, detectedType, declaredMimeType);
             }
             // Verify type is in allowed list
@@ -416,8 +403,7 @@ let FileValidator = class FileValidator {
                 return this.failureResult(`File type "${detectedType}" is not allowed`, detectedType, declaredMimeType);
             }
             return this.successResult(detectedType, declaredMimeType);
-        } catch (error) {
-            this.logger.error('File validation error:', error);
+        } catch  {
             return this.failureResult('File validation failed');
         }
     }
@@ -428,10 +414,8 @@ let FileValidator = class FileValidator {
         if (this.isDangerousTextType(declaredMimeType)) {
             const explicitlyAllowed = allowedTypes.some((t)=>t === declaredMimeType && t !== '*/*' && !t.endsWith('/*'));
             if (!explicitlyAllowed) {
-                this.logger.warn(`Blocked dangerous file type: ${declaredMimeType} - requires explicit allowlisting`);
                 return this.failureResult(`File type "${declaredMimeType}" is potentially dangerous and not explicitly allowed`, declaredMimeType, declaredMimeType);
             }
-            this.logger.warn(`Allowing explicitly permitted dangerous file type: ${declaredMimeType}`);
         }
         // Safe text-based files don't have magic bytes, trust declared type
         if (this.isTextBasedType(declaredMimeType)) {
@@ -439,7 +423,6 @@ let FileValidator = class FileValidator {
             return isAllowed ? this.successResult(declaredMimeType, declaredMimeType) : this.failureResult(`File type "${declaredMimeType}" is not allowed`, declaredMimeType, declaredMimeType);
         }
         // Binary files without recognized signatures - be cautious
-        this.logger.warn(`Unable to detect file type for declared type: ${declaredMimeType}`);
         return this.failureResult('Unable to verify file type. File may be corrupted or unsupported.', undefined, declaredMimeType);
     }
     /**
@@ -455,4 +438,3 @@ let FileValidator = class FileValidator {
         .substring(0, 255);
     }
 };
-_define_property(FileValidator, "logger", new _common.Logger(FileValidator.name));