@flusys/nestjs-storage 3.0.0 → 4.0.0-lts

package/README.md

@@ -1,7 +1,7 @@
 # Storage Package Guide
 
 > **Package:** `@flusys/nestjs-storage`
-> **Version:** 3.0.0
+> **Version:** 3.0.1
 > **Type:** File storage system with pluggable providers and multi-tenant support
 
 This comprehensive guide covers the storage package - flexible file storage with multiple provider support.

package/cjs/config/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 _export_star(require("./storage.constants"), exports);
+_export_star(require("./message-keys"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/cjs/config/message-keys.js

@@ -0,0 +1,90 @@
+// ==================== STORAGE MODULE MESSAGE KEYS ====================
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get FILE_MESSAGES () {
+        return FILE_MESSAGES;
+    },
+    get FOLDER_MESSAGES () {
+        return FOLDER_MESSAGES;
+    },
+    get STORAGE_CONFIG_MESSAGES () {
+        return STORAGE_CONFIG_MESSAGES;
+    },
+    get STORAGE_MODULE_MESSAGES () {
+        return STORAGE_MODULE_MESSAGES;
+    },
+    get UPLOAD_MESSAGES () {
+        return UPLOAD_MESSAGES;
+    }
+});
+const FILE_MESSAGES = {
+    CREATE_SUCCESS: 'file.create.success',
+    CREATE_MANY_SUCCESS: 'file.create.many.success',
+    GET_SUCCESS: 'file.get.success',
+    GET_ALL_SUCCESS: 'file.get.all.success',
+    UPDATE_SUCCESS: 'file.update.success',
+    UPDATE_MANY_SUCCESS: 'file.update.many.success',
+    DELETE_SUCCESS: 'file.delete.success',
+    RESTORE_SUCCESS: 'file.restore.success',
+    NOT_FOUND: 'file.not.found',
+    UPLOAD_SUCCESS: 'file.upload.success',
+    UPLOAD_MANY_SUCCESS: 'file.upload.many.success',
+    DOWNLOAD_SUCCESS: 'file.download.success',
+    MOVE_SUCCESS: 'file.move.success',
+    COPY_SUCCESS: 'file.copy.success'
+};
+const FOLDER_MESSAGES = {
+    CREATE_SUCCESS: 'folder.create.success',
+    CREATE_MANY_SUCCESS: 'folder.create.many.success',
+    GET_SUCCESS: 'folder.get.success',
+    GET_ALL_SUCCESS: 'folder.get.all.success',
+    UPDATE_SUCCESS: 'folder.update.success',
+    UPDATE_MANY_SUCCESS: 'folder.update.many.success',
+    DELETE_SUCCESS: 'folder.delete.success',
+    RESTORE_SUCCESS: 'folder.restore.success',
+    NOT_FOUND: 'folder.not.found',
+    TREE_SUCCESS: 'folder.tree.success',
+    CONTENTS_SUCCESS: 'folder.contents.success'
+};
+const STORAGE_CONFIG_MESSAGES = {
+    CREATE_SUCCESS: 'storage.config.create.success',
+    CREATE_MANY_SUCCESS: 'storage.config.create.many.success',
+    GET_SUCCESS: 'storage.config.get.success',
+    GET_ALL_SUCCESS: 'storage.config.get.all.success',
+    UPDATE_SUCCESS: 'storage.config.update.success',
+    UPDATE_MANY_SUCCESS: 'storage.config.update.many.success',
+    DELETE_SUCCESS: 'storage.config.delete.success',
+    RESTORE_SUCCESS: 'storage.config.restore.success',
+    NOT_FOUND: 'storage.config.not.found',
+    ACTIVE_SUCCESS: 'storage.config.active.success',
+    TEST_SUCCESS: 'storage.config.test.success',
+    TEST_FAILED: 'storage.config.test.failed'
+};
+const UPLOAD_MESSAGES = {
+    SUCCESS: 'upload.success',
+    MANY_SUCCESS: 'upload.many.success',
+    FAILED: 'upload.failed',
+    FILE_TOO_LARGE: 'upload.file.too.large',
+    INVALID_TYPE: 'upload.invalid.type',
+    CHUNK_SUCCESS: 'upload.chunk.success',
+    COMPLETE_SUCCESS: 'upload.complete.success',
+    NO_FILES_PROVIDED: 'upload.no.files.provided',
+    NO_FILE_PATH: 'upload.no.file.path',
+    INVALID_FILE_PATH: 'upload.invalid.file.path',
+    CONFIG_NOT_FOUND: 'upload.config.not.found'
+};
+const STORAGE_MODULE_MESSAGES = {
+    FILE: FILE_MESSAGES,
+    FOLDER: FOLDER_MESSAGES,
+    STORAGE_CONFIG: STORAGE_CONFIG_MESSAGES,
+    UPLOAD: UPLOAD_MESSAGES
+};

package/cjs/controllers/file-manager.controller.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "FileManagerController", {
 });
 const _common = require("@nestjs/common");
 const _classes = require("@flusys/nestjs-shared/classes");
+const _config = require("../config");
 const _decorators = require("@flusys/nestjs-shared/decorators");
 const _dtos = require("@flusys/nestjs-shared/dtos");
 const _guards = require("@flusys/nestjs-shared/guards");
@@ -46,6 +47,7 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let FileManagerController = class FileManagerController extends (0, _classes.createApiController)(_dtos1.CreateFileManagerDto, _dtos1.UpdateFileManagerDto, _dtos1.FileManagerResponseDto, {
+    entityName: 'file',
     security: {
         insert: {
             level: 'permission',
@@ -93,13 +95,17 @@ let FileManagerController = class FileManagerController extends (0, _classes.cre
 }) {
     async getFiles(dto, req, user) {
         if (!dto || !dto.length) {
-            throw new _common.BadRequestException('No files provided');
+            throw new _common.BadRequestException({
+                message: 'No files provided',
+                messageKey: _config.UPLOAD_MESSAGES.NO_FILES_PROVIDED
+            });
         }
         // Fetch files from service
         const files = await this.fileService.getFiles(dto, req.protocol, req.get('host') || req.hostname, user);
         return {
             success: true,
             message: 'Files retrieved successfully',
+            messageKey: _config.FILE_MESSAGES.GET_ALL_SUCCESS,
             data: files
         };
     }

package/cjs/controllers/folder.controller.js

@@ -41,6 +41,7 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let FolderController = class FolderController extends (0, _classes.createApiController)(_dtos.CreateFolderDto, _dtos.UpdateFolderDto, _dtos.FolderResponseDto, {
+    entityName: 'folder',
     security: {
         insert: {
             level: 'permission',

package/cjs/controllers/storage-config.controller.js

@@ -41,6 +41,7 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let StorageConfigController = class StorageConfigController extends (0, _classes.createApiController)(_dtos.CreateStorageConfigDto, _dtos.UpdateStorageConfigDto, _dtos.StorageConfigResponseDto, {
+    entityName: 'storageConfig',
     security: {
         insert: {
             level: 'permission',

package/cjs/controllers/upload.controller.js

@@ -8,8 +8,9 @@ Object.defineProperty(exports, "UploadController", {
         return UploadController;
     }
 });
-const _guards = require("@flusys/nestjs-shared/guards");
+const _config = require("../config");
 const _decorators = require("@flusys/nestjs-shared/decorators");
+const _guards = require("@flusys/nestjs-shared/guards");
 const _interfaces = require("@flusys/nestjs-shared/interfaces");
 const _dtos = require("../dtos");
 const _common = require("@nestjs/common");
@@ -44,7 +45,7 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let UploadController = class UploadController {
-    toFileUploadResponse(file) {
+    buildFileResponse(file) {
         return {
             size: this.uploadService.bytesToKb(file.size),
             name: file.name,
@@ -59,7 +60,8 @@ let UploadController = class UploadController {
         return {
             success: true,
             message: 'File uploaded successfully',
-            data: this.toFileUploadResponse(result)
+            messageKey: _config.UPLOAD_MESSAGES.SUCCESS,
+            data: this.buildFileResponse(result)
         };
     }
     async uploadMultipleFiles(files, options, user) {
@@ -67,7 +69,8 @@ let UploadController = class UploadController {
         return {
             success: true,
             message: 'Files uploaded successfully',
-            data: uploadResponses.map((file)=>this.toFileUploadResponse(file))
+            messageKey: _config.UPLOAD_MESSAGES.MANY_SUCCESS,
+            data: uploadResponses.map((file)=>this.buildFileResponse(file))
         };
     }
     async deleteSingleFile(dto, user) {
@@ -75,6 +78,7 @@ let UploadController = class UploadController {
         return {
             success: true,
             message: 'File deleted successfully',
+            messageKey: _config.FILE_MESSAGES.DELETE_SUCCESS,
             data
         };
     }
@@ -83,6 +87,7 @@ let UploadController = class UploadController {
         return {
             success: true,
             message: 'Files deleted successfully',
+            messageKey: _config.FILE_MESSAGES.DELETE_SUCCESS,
             data
         };
     }

package/cjs/middlewares/file-serve.middleware.js

@@ -12,6 +12,7 @@ const _common = require("@nestjs/common");
 const _fs = require("fs");
 const _path = require("path");
 const _mimetypes = /*#__PURE__*/ _interop_require_wildcard(require("mime-types"));
+const _config = require("../config");
 const _uploadservice = require("../services/upload.service");
 function _define_property(obj, key, value) {
     if (key in obj) {
@@ -97,7 +98,13 @@ let FileServeMiddleware = class FileServeMiddleware {
             const fullPath = await this.resolveFilePath(normalizedPath);
             const stats = (0, _fs.statSync)(fullPath);
             if (!stats.isFile()) {
-                throw new _common.NotFoundException(`Not a file: ${normalizedPath}`);
+                throw new _common.NotFoundException({
+                    message: `Not a file: ${normalizedPath}`,
+                    messageKey: _config.FILE_MESSAGES.NOT_FOUND,
+                    messageParams: {
+                        path: normalizedPath
+                    }
+                });
             }
             const mimeType = this.getMimeType(fullPath);
             this.setResponseHeaders(res, stats.size, mimeType, normalizedPath);
@@ -111,19 +118,23 @@ let FileServeMiddleware = class FileServeMiddleware {
         const match = urlPath.match(/\/storage\/upload\/file\/(.+)/);
         const normalizedPath = match ? match[1] : '';
         if (!normalizedPath) {
-            throw new _common.NotFoundException('File path is required');
+            throw new _common.BadRequestException({
+                message: 'File path is required',
+                messageKey: _config.UPLOAD_MESSAGES.NO_FILE_PATH
+            });
         }
-        this.logger.debug(`Attempting to serve file, normalizedPath: ${normalizedPath}`);
         return normalizedPath;
     }
     /** Resolve file path using multiple fallback strategies */ async resolveFilePath(normalizedPath) {
         // Strategy 1: Path relative to CWD (new format: key includes basePath)
         let fullPath = (0, _path.join)(this.uploadDir, normalizedPath);
         const resolvedPath = (0, _path.resolve)(fullPath);
-        this.logger.debug(`Strategy 1 - CWD relative: ${fullPath}`);
         // Prevent path traversal attacks
         if (!resolvedPath.startsWith(this.uploadDir)) {
-            throw new _common.NotFoundException('Invalid file path');
+            throw new _common.BadRequestException({
+                message: 'Invalid file path',
+                messageKey: _config.UPLOAD_MESSAGES.INVALID_FILE_PATH
+            });
         }
         if ((0, _fs.existsSync)(fullPath)) {
             return fullPath;
@@ -136,7 +147,13 @@ let FileServeMiddleware = class FileServeMiddleware {
                 return fallbackPath;
             }
         }
-        throw new _common.NotFoundException(`File not found: ${normalizedPath}`);
+        throw new _common.NotFoundException({
+            message: `File not found: ${normalizedPath}`,
+            messageKey: _config.FILE_MESSAGES.NOT_FOUND,
+            messageParams: {
+                path: normalizedPath
+            }
+        });
     }
     /** Try basePath-based fallback strategies */ tryFallbackPaths(normalizedPath, basePath) {
         const normalizedBasePath = basePath.replace(/^\.\//, '').replace(/\/$/, '');
@@ -145,12 +162,10 @@ let FileServeMiddleware = class FileServeMiddleware {
             // Strategy 2: basePath + remaining path
             const remainingPath = normalizedPath.substring(normalizedBasePath.length).replace(/^\//, '');
             const fallbackPath = (0, _path.join)(basePath, remainingPath);
-            this.logger.debug(`Strategy 2 - basePath + remaining: ${fallbackPath}`);
             if ((0, _fs.existsSync)(fallbackPath)) return fallbackPath;
         } else {
             // Strategy 3: Old format - prepend basePath
             const fallbackPath = (0, _path.join)(basePath, normalizedPath);
-            this.logger.debug(`Strategy 3 - basePath + full key (old format): ${fallbackPath}`);
             if ((0, _fs.existsSync)(fallbackPath)) return fallbackPath;
         }
         return null;
@@ -179,20 +194,31 @@ let FileServeMiddleware = class FileServeMiddleware {
     /** Stream file to response with error handling */ streamFile(res, fullPath, normalizedPath) {
         const stream = (0, _fs.createReadStream)(fullPath);
         stream.pipe(res);
-        stream.on('error', (err)=>{
-            this.logger.error('File stream error', err);
+        stream.on('error', ()=>{
             if (!res.headersSent) {
-                this.sendErrorResponse(res, new _common.NotFoundException(`Failed to serve file: ${normalizedPath}`));
+                this.sendErrorResponse(res, new _common.NotFoundException({
+                    message: `Failed to serve file: ${normalizedPath}`,
+                    messageKey: _config.FILE_MESSAGES.NOT_FOUND,
+                    messageParams: {
+                        path: normalizedPath
+                    }
+                }));
             }
         });
         res.on('close', ()=>stream.destroy());
     }
     /** Send consistent error response */ sendErrorResponse(res, error) {
-        this.logger.error('File retrieval error:', error);
         if (!res.headersSent) {
-            const message = error instanceof _common.NotFoundException ? error.message : 'File not found';
+            const isNotFound = error instanceof _common.NotFoundException;
+            const response = isNotFound ? error.getResponse() : null;
+            const message = response?.message ?? 'File not found';
+            const messageKey = response?.messageKey ?? _config.FILE_MESSAGES.NOT_FOUND;
+            const messageParams = response?.messageParams;
             res.status(404).json({
+                success: false,
                 message,
+                messageKey,
+                messageParams,
                 error: 'Not Found',
                 statusCode: 404
             });
@@ -200,10 +226,8 @@ let FileServeMiddleware = class FileServeMiddleware {
     }
     constructor(uploadService){
         _define_property(this, "uploadService", void 0);
-        _define_property(this, "logger", void 0);
         _define_property(this, "uploadDir", void 0);
         this.uploadService = uploadService;
-        this.logger = new _common.Logger(FileServeMiddleware.name);
         this.uploadDir = process.cwd();
     }
 };

package/cjs/modules/storage.module.js

@@ -24,7 +24,6 @@ function _ts_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;
 }
-// ─── Module Constants ─────────────────────────────────────────────────────────
 const logger = new _common.Logger('StorageModule');
 const CONTROLLERS = [
     _controllers.FileManagerController,
@@ -41,9 +40,10 @@ const EXPORTED_SERVICES = [
     _services.UploadService,
     _providers.StorageFactoryService
 ];
-// ─── Provider Registration ────────────────────────────────────────────────────
+// Register built-in provider
 _providers.StorageProviderRegistry.register(_filelocationenum.FileLocationEnum.LOCAL, _localprovider.LocalProvider);
 logger.log('Registered LocalProvider');
+// Register optional providers (skip if dependencies not installed)
 const OPTIONAL_PROVIDERS = [
     {
         location: _filelocationenum.FileLocationEnum.AWS,

package/cjs/providers/azure-provider.optional.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "AzureProvider", {
     }
 });
 const _common = require("@nestjs/common");
+const _constants = require("@flusys/nestjs-shared/constants");
 const _uuid = require("uuid");
 const _imagecompressorutil = require("../utils/image-compressor.util");
 function _define_property(obj, key, value) {
@@ -77,9 +78,14 @@ let AzureProvider = class AzureProvider {
             this.blobServiceClient = config.connectionString ? BlobServiceClient.fromConnectionString(config.connectionString) : new BlobServiceClient(`https://${config.accountName}.blob.core.windows.net`, new StorageSharedKeyCredential(config.accountName, config.accountKey));
             this.containerClient = this.blobServiceClient.getContainerClient(config.containerName);
             await this.containerClient.createIfNotExists();
-            this.logger.log(`Azure Provider initialized: account=${config.accountName}, container=${config.containerName}`);
         } catch  {
-            throw new Error('Azure Storage SDK not found. Install: npm install @azure/storage-blob');
+            throw new _common.InternalServerErrorException({
+                message: 'Azure Storage SDK not found',
+                messageKey: _constants.SYSTEM_MESSAGES.SDK_NOT_INSTALLED,
+                messageParams: {
+                    sdk: '@azure/storage-blob'
+                }
+            });
         }
     }
     async uploadFile(file, options) {
@@ -114,11 +120,9 @@ let AzureProvider = class AzureProvider {
     }
     async deleteFile(key) {
         await this.containerClient.getBlockBlobClient(key).deleteIfExists();
-        this.logger.log(`Deleted file from Azure: ${key}`);
     }
     async deleteMultipleFiles(keys) {
         await Promise.all(keys.map((key)=>this.deleteFile(key)));
-        this.logger.log(`Deleted ${keys.length} files from Azure`);
     }
     async generatePresignedUrl(key, expiresInSeconds = 3600) {
         const { BlobSASPermissions, generateBlobSASQueryParameters } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("@azure/storage-blob")));
@@ -143,7 +147,6 @@ let AzureProvider = class AzureProvider {
         }
     }
     constructor(){
-        _define_property(this, "logger", new _common.Logger(AzureProvider.name));
         _define_property(this, "blobServiceClient", void 0);
         _define_property(this, "containerClient", void 0);
         _define_property(this, "containerName", '');

package/cjs/providers/local-provider.js

@@ -19,8 +19,9 @@ Object.defineProperty(exports, "LocalProvider", {
         return LocalProvider;
     }
 });
-const _imagecompressorutil = require("../utils/image-compressor.util");
 const _common = require("@nestjs/common");
+const _constants = require("@flusys/nestjs-shared/constants");
+const _imagecompressorutil = require("../utils/image-compressor.util");
 const _promises = /*#__PURE__*/ _interop_require_wildcard(require("fs/promises"));
 const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
 const _uuid = require("uuid");
@@ -87,8 +88,10 @@ let LocalProvider = class LocalProvider {
         const normalizedBasePath = _path.resolve(this.basePath);
         const normalizedTargetPath = _path.resolve(targetPath);
         if (!normalizedTargetPath.startsWith(normalizedBasePath + _path.sep) && normalizedTargetPath !== normalizedBasePath) {
-            this.logger.warn(`Path traversal attempt detected: ${targetPath}`);
-            throw new Error('Invalid path: Path traversal attempt detected');
+            throw new _common.BadRequestException({
+                message: 'Invalid path: Path traversal attempt detected',
+                messageKey: _constants.SYSTEM_MESSAGES.PATH_TRAVERSAL_DETECTED
+            });
         }
     }
     /**
@@ -96,10 +99,16 @@ let LocalProvider = class LocalProvider {
    * @throws Error if key contains suspicious patterns
    */ validateKeyFormat(key) {
         if (!key || typeof key !== 'string' || key.trim().length === 0) {
-            throw new Error('Invalid file key: empty or invalid');
+            throw new _common.BadRequestException({
+                message: 'Invalid file key: empty or invalid',
+                messageKey: _constants.SYSTEM_MESSAGES.INVALID_FILE_KEY
+            });
         }
         if (key.includes('\0')) {
-            throw new Error('Invalid file key: contains null bytes');
+            throw new _common.BadRequestException({
+                message: 'Invalid file key: contains null bytes',
+                messageKey: _constants.SYSTEM_MESSAGES.INVALID_FILE_KEY
+            });
         }
     }
     /**
@@ -116,7 +125,6 @@ let LocalProvider = class LocalProvider {
         await _promises.mkdir(this.basePath, {
             recursive: true
         });
-        this.logger.log(`Local Provider initialized: ${this.basePath} (relative: ${this.relativeBasePath})`);
     }
     async uploadFile(file, options) {
         let processedBuffer = file.buffer;
@@ -149,7 +157,6 @@ let LocalProvider = class LocalProvider {
         // Generate key that includes the base path (relative to cwd)
         // This makes the key self-contained for serving files
         const relativeKey = _path.join(this.relativeBasePath, options.folderPath || '', fileName).replace(/\\/g, '/'); // Normalize path separators
-        this.logger.log(`Uploaded file to local storage: ${relativeKey}`);
         return {
             name: fileName,
             key: relativeKey,
@@ -179,26 +186,22 @@ let LocalProvider = class LocalProvider {
                 try {
                     await _promises.access(fallbackPath);
                     filePath = fallbackPath;
-                    this.logger.debug(`Using fallback path for delete: ${fallbackPath}`);
                 } catch  {
-                    // File doesn't exist at either location
-                    this.logger.warn(`File not found for deletion: ${key}`);
+                    // File doesn't exist at either location - silent return
                     return;
                 }
             }
             await _promises.unlink(filePath);
-            this.logger.log(`Deleted file from local storage: ${key}`);
         } catch (error) {
             // Re-throw security errors
             if (error instanceof Error && error.message.includes('Invalid')) {
                 throw error;
             }
-            this.logger.warn(`Failed to delete file from local storage: ${key}`);
+        // Silent failure for other errors
         }
     }
     async deleteMultipleFiles(keys) {
         await Promise.all(keys.map((key)=>this.deleteFile(key)));
-        this.logger.log(`Deleted ${keys.length} files from local storage`);
     }
     async generatePresignedUrl(key, _expiresInSeconds) {
         // Return public URL or relative path
@@ -220,7 +223,6 @@ let LocalProvider = class LocalProvider {
         }
     }
     constructor(){
-        _define_property(this, "logger", new _common.Logger(LocalProvider.name));
         _define_property(this, "basePath", '');
         _define_property(this, "baseUrl", '');
         _define_property(this, "relativeBasePath", ''); // Path relative to cwd for key generation

package/cjs/providers/s3-provider.optional.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "S3Provider", {
     }
 });
 const _common = require("@nestjs/common");
+const _constants = require("@flusys/nestjs-shared/constants");
 const _uuid = require("uuid");
 const _imagecompressorutil = require("../utils/image-compressor.util");
 function _define_property(obj, key, value) {
@@ -82,9 +83,14 @@ let S3Provider = class S3Provider {
                     secretAccessKey: config.secretAccessKey
                 } : undefined
             });
-            this.logger.log(`S3 Provider initialized: region=${config.region}, bucket=${config.bucket}`);
         } catch  {
-            throw new Error('AWS SDK not found. Install: npm install @aws-sdk/client-s3 @aws-sdk/lib-storage @aws-sdk/s3-request-presigner');
+            throw new _common.InternalServerErrorException({
+                message: 'AWS SDK not found',
+                messageKey: _constants.SYSTEM_MESSAGES.SDK_NOT_INSTALLED,
+                messageParams: {
+                    sdk: '@aws-sdk/client-s3'
+                }
+            });
         }
     }
     async uploadFile(file, options) {
@@ -128,7 +134,6 @@ let S3Provider = class S3Provider {
             Bucket: this.bucketName,
             Key: key
         }));
-        this.logger.log(`Deleted file from S3: ${key}`);
     }
     async deleteMultipleFiles(keys) {
         const { DeleteObjectsCommand } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("@aws-sdk/client-s3")));
@@ -140,7 +145,6 @@ let S3Provider = class S3Provider {
                     }))
             }
         }));
-        this.logger.log(`Deleted ${keys.length} files from S3`);
     }
     async generatePresignedUrl(key, expiresInSeconds = 3600) {
         const { GetObjectCommand } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("@aws-sdk/client-s3")));
@@ -164,7 +168,6 @@ let S3Provider = class S3Provider {
         }
     }
     constructor(){
-        _define_property(this, "logger", new _common.Logger(S3Provider.name));
         _define_property(this, "s3", void 0);
         _define_property(this, "bucketName", '');
         _define_property(this, "region", '');

package/cjs/providers/sftp-provider.optional.js

@@ -23,8 +23,9 @@ Object.defineProperty(exports, "SftpProvider", {
         return SftpProvider;
     }
 });
-const _imagecompressorutil = require("../utils/image-compressor.util");
 const _common = require("@nestjs/common");
+const _constants = require("@flusys/nestjs-shared/constants");
+const _imagecompressorutil = require("../utils/image-compressor.util");
 const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
 const _uuid = require("uuid");
 function _define_property(obj, key, value) {
@@ -102,10 +103,14 @@ let SftpProvider = class SftpProvider {
             await this.connect();
             // Ensure base directory exists
             await this.ensureDirectory(this.config.basePath);
-            this.logger.log(`SFTP Provider initialized: ${config.username}@${config.host}:${config.port || 22}`);
-        } catch (_error) {
-            this.logger.error('Failed to initialize SftpProvider. Make sure ssh2-sftp-client is installed.');
-            throw new Error('SFTP client not found. Install it with: npm install ssh2-sftp-client');
+        } catch  {
+            throw new _common.InternalServerErrorException({
+                message: 'SFTP client not found',
+                messageKey: _constants.SYSTEM_MESSAGES.SDK_NOT_INSTALLED,
+                messageParams: {
+                    sdk: 'ssh2-sftp-client'
+                }
+            });
         }
     }
     async connect() {
@@ -123,7 +128,7 @@ let SftpProvider = class SftpProvider {
     async ensureDirectory(dirPath) {
         try {
             await this.sftp.mkdir(dirPath, true);
-        } catch (_error) {
+        } catch  {
         // Directory might already exist
         }
     }
@@ -163,14 +168,12 @@ let SftpProvider = class SftpProvider {
         await this.connect();
         try {
             await this.sftp.delete(key);
-            this.logger.log(`Deleted file from SFTP: ${key}`);
-        } catch (_error) {
-            this.logger.warn(`Failed to delete file from SFTP: ${key}`);
+        } catch  {
+        // Silent failure
         }
     }
     async deleteMultipleFiles(keys) {
         await Promise.all(keys.map((key)=>this.deleteFile(key)));
-        this.logger.log(`Deleted ${keys.length} files from SFTP`);
     }
     async generatePresignedUrl(key, _expiresInSeconds) {
         // SFTP doesn't support presigned URLs, return the key
@@ -193,7 +196,6 @@ let SftpProvider = class SftpProvider {
         }
     }
     constructor(){
-        _define_property(this, "logger", new _common.Logger(SftpProvider.name));
         _define_property(this, "sftp", void 0); // SftpClient
         _define_property(this, "config", void 0);
         _define_property(this, "connected", false);