@flusys/nestjs-storage 1.0.0-rc → 2.0.0

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

@@ -81,123 +81,130 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
+/** MIME type prefixes that can be displayed inline in browser */ const VIEWABLE_TYPE_PREFIXES = [
+    'image/',
+    'video/',
+    'audio/',
+    'text/',
+    'application/pdf',
+    'application/json',
+    'application/xml'
+];
 let FileServeMiddleware = class FileServeMiddleware {
     async use(req, res, next) {
         try {
-            const uploadDir = process.cwd();
-            // Extract path after /storage/upload/file/
-            const urlPath = req.path || req.url;
-            const match = urlPath.match(/\/storage\/upload\/file\/(.+)/);
-            const normalizedPath = match ? match[1] : '';
-            if (!normalizedPath) {
-                throw new _common.NotFoundException('File path is required');
-            }
-            this.logger.debug(`Attempting to serve file, normalizedPath: ${normalizedPath}`);
-            // Get the local storage basePath for fallback lookups
-            const basePath = await this.uploadService.getLocalStorageBasePath();
-            const normalizedBasePath = basePath ? basePath.replace(/^\.\//, '').replace(/\/$/, '') : null;
-            // Strategy 1: Try path relative to CWD (new format: key includes basePath)
-            let fullPath = (0, _path.join)(uploadDir, normalizedPath);
-            let resolvedPath = (0, _path.resolve)(fullPath);
-            this.logger.debug(`Strategy 1 - CWD relative: ${fullPath}`);
-            // Validate path is inside the project directory (prevent path traversal)
-            if (!resolvedPath.startsWith(uploadDir)) {
-                throw new _common.NotFoundException('Invalid file path');
-            }
-            // Check if file exists
-            if (!(0, _fs.existsSync)(fullPath)) {
-                // Strategy 2: If key already starts with basePath, try using basePath directly
-                if (basePath && normalizedBasePath) {
-                    const pathStartsWithBase = normalizedPath.startsWith(normalizedBasePath + '/') || normalizedPath.startsWith(normalizedBasePath);
-                    if (pathStartsWithBase) {
-                        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)) {
-                            fullPath = fallbackPath;
-                            resolvedPath = (0, _path.resolve)(fullPath);
-                        }
-                    } else {
-                        // Old format: key doesn't include basePath, prepend it
-                        const fallbackPath = (0, _path.join)(basePath, normalizedPath);
-                        this.logger.debug(`Strategy 3 - basePath + full key (old format): ${fallbackPath}`);
-                        if ((0, _fs.existsSync)(fallbackPath)) {
-                            fullPath = fallbackPath;
-                            resolvedPath = (0, _path.resolve)(fullPath);
-                        }
-                    }
-                }
-                // Final check if file was found
-                if (!(0, _fs.existsSync)(fullPath)) {
-                    throw new _common.NotFoundException(`File not found: ${normalizedPath}`);
-                }
-            }
+            const normalizedPath = this.extractFilePath(req);
+            const fullPath = await this.resolveFilePath(normalizedPath);
             const stats = (0, _fs.statSync)(fullPath);
             if (!stats.isFile()) {
                 throw new _common.NotFoundException(`Not a file: ${normalizedPath}`);
             }
-            // Enhanced MIME type detection
-            let mimeType = _mimetypes.lookup(fullPath) || 'application/octet-stream';
-            // Special handling for SVG files
-            if (fullPath.toLowerCase().endsWith('.svg')) {
-                mimeType = 'image/svg+xml';
-            }
-            // Determine if file should be displayed inline or downloaded
-            const viewableTypes = [
-                'image/',
-                'video/',
-                'audio/',
-                'text/',
-                'application/pdf',
-                'application/json',
-                'application/xml'
-            ];
-            const isViewable = viewableTypes.some((type)=>mimeType.startsWith(type));
-            const contentDisposition = isViewable ? 'inline' : `attachment; filename="${encodeURIComponent(normalizedPath.split('/').pop() || 'download')}"`;
-            // Set headers
-            res.set({
-                'Content-Type': mimeType,
-                'Content-Length': stats.size,
-                'Content-Disposition': contentDisposition,
-                'Cache-Control': 'public, max-age=3600',
-                'Accept-Ranges': 'bytes',
-                'Cross-Origin-Resource-Policy': 'cross-origin',
-                'Access-Control-Allow-Origin': '*',
-                'X-Content-Type-Options': 'nosniff'
-            });
-            // Stream the file
-            const stream = (0, _fs.createReadStream)(fullPath);
-            stream.pipe(res);
-            stream.on('error', (err)=>{
-                this.logger.error('File stream error', err);
-                if (!res.headersSent) {
-                    res.status(404).json({
-                        message: `Failed to serve file: ${normalizedPath}`,
-                        error: 'Not Found',
-                        statusCode: 404
-                    });
-                }
-            });
-            // Handle client disconnection
-            res.on('close', ()=>{
-                stream.destroy();
-            });
+            const mimeType = this.getMimeType(fullPath);
+            this.setResponseHeaders(res, stats.size, mimeType, normalizedPath);
+            this.streamFile(res, fullPath, normalizedPath);
         } catch (error) {
-            this.logger.error('File retrieval error:', error);
+            this.sendErrorResponse(res, error);
+        }
+    }
+    /** Extract and validate file path from request URL */ extractFilePath(req) {
+        const urlPath = req.path || req.url;
+        const match = urlPath.match(/\/storage\/upload\/file\/(.+)/);
+        const normalizedPath = match ? match[1] : '';
+        if (!normalizedPath) {
+            throw new _common.NotFoundException('File path is required');
+        }
+        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');
+        }
+        if ((0, _fs.existsSync)(fullPath)) {
+            return fullPath;
+        }
+        // Try fallback strategies with basePath
+        const basePath = await this.uploadService.getLocalStorageBasePath();
+        if (basePath) {
+            const fallbackPath = this.tryFallbackPaths(normalizedPath, basePath);
+            if (fallbackPath) {
+                return fallbackPath;
+            }
+        }
+        throw new _common.NotFoundException(`File not found: ${normalizedPath}`);
+    }
+    /** Try basePath-based fallback strategies */ tryFallbackPaths(normalizedPath, basePath) {
+        const normalizedBasePath = basePath.replace(/^\.\//, '').replace(/\/$/, '');
+        const pathStartsWithBase = normalizedPath.startsWith(normalizedBasePath + '/') || normalizedPath.startsWith(normalizedBasePath);
+        if (pathStartsWithBase) {
+            // 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;
+    }
+    /** Get MIME type with SVG special handling */ getMimeType(fullPath) {
+        if (fullPath.toLowerCase().endsWith('.svg')) {
+            return 'image/svg+xml';
+        }
+        return _mimetypes.lookup(fullPath) || 'application/octet-stream';
+    }
+    /** Set response headers for file serving */ setResponseHeaders(res, size, mimeType, normalizedPath) {
+        const isViewable = VIEWABLE_TYPE_PREFIXES.some((type)=>mimeType.startsWith(type));
+        const filename = normalizedPath.split('/').pop() || 'download';
+        const contentDisposition = isViewable ? 'inline' : `attachment; filename="${encodeURIComponent(filename)}"`;
+        res.set({
+            'Content-Type': mimeType,
+            'Content-Length': size,
+            'Content-Disposition': contentDisposition,
+            'Cache-Control': 'public, max-age=3600',
+            'Accept-Ranges': 'bytes',
+            'Cross-Origin-Resource-Policy': 'cross-origin',
+            'Access-Control-Allow-Origin': '*',
+            'X-Content-Type-Options': 'nosniff'
+        });
+    }
+    /** 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);
             if (!res.headersSent) {
-                res.status(404).json({
-                    message: error instanceof _common.NotFoundException ? error.message : `File not found`,
-                    error: 'Not Found',
-                    statusCode: 404
-                });
+                this.sendErrorResponse(res, new _common.NotFoundException(`Failed to serve file: ${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';
+            res.status(404).json({
+                message,
+                error: 'Not Found',
+                statusCode: 404
+            });
         }
     }
     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();
     }
 };
 FileServeMiddleware = _ts_decorate([

package/cjs/modules/storage.module.js

@@ -11,13 +11,12 @@ Object.defineProperty(exports, "StorageModule", {
 const _modules = require("@flusys/nestjs-shared/modules");
 const _common = require("@nestjs/common");
 const _middlewares = require("../middlewares");
-const _config = require("../config");
+const _services = require("../services");
 const _storageconstants = require("../config/storage.constants");
 const _controllers = require("../controllers");
 const _filelocationenum = require("../enums/file-location.enum");
 const _providers = require("../providers");
 const _localprovider = require("../providers/local-provider");
-const _services = require("../services");
 const _storageproviderconfigservice = require("../services/storage-provider-config.service");
 function _ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -25,48 +24,62 @@ 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;
 }
-// Auto-register built-in storage providers
+// ─── Module Constants ─────────────────────────────────────────────────────────
 const logger = new _common.Logger('StorageModule');
-// Register LocalProvider (always available - uses Node.js built-in fs)
+const CONTROLLERS = [
+    _controllers.FileManagerController,
+    _controllers.FolderController,
+    _controllers.StorageConfigController,
+    _controllers.UploadController
+];
+const EXPORTED_SERVICES = [
+    _services.StorageConfigService,
+    _services.StorageDataSourceProvider,
+    _services.FileManagerService,
+    _services.FolderService,
+    _storageproviderconfigservice.StorageProviderConfigService,
+    _services.UploadService,
+    _providers.StorageFactoryService
+];
+// ─── Provider Registration ────────────────────────────────────────────────────
 _providers.StorageProviderRegistry.register(_filelocationenum.FileLocationEnum.LOCAL, _localprovider.LocalProvider);
 logger.log('Registered LocalProvider');
-// Try to register optional providers (only if dependencies are installed)
-try {
-    const { S3Provider } = require('../providers/s3-provider.optional');
-    _providers.StorageProviderRegistry.register(_filelocationenum.FileLocationEnum.AWS, S3Provider);
-    logger.log('Registered S3Provider');
-} catch  {
-    logger.debug('S3Provider not available (install @aws-sdk/client-s3 to enable)');
-}
-try {
-    const { AzureProvider } = require('../providers/azure-provider.optional');
-    _providers.StorageProviderRegistry.register(_filelocationenum.FileLocationEnum.AZURE, AzureProvider);
-    logger.log('Registered AzureProvider');
-} catch  {
-    logger.debug('AzureProvider not available (install @azure/storage-blob to enable)');
-}
-try {
-    const { SftpProvider } = require('../providers/sftp-provider.optional');
-    _providers.StorageProviderRegistry.register(_filelocationenum.FileLocationEnum.SFTP, SftpProvider);
-    logger.log('Registered SftpProvider');
-} catch  {
-    logger.debug('SftpProvider not available (install ssh2-sftp-client to enable)');
+const OPTIONAL_PROVIDERS = [
+    {
+        location: _filelocationenum.FileLocationEnum.AWS,
+        path: '../providers/s3-provider.optional',
+        name: 'S3Provider',
+        dep: '@aws-sdk/client-s3'
+    },
+    {
+        location: _filelocationenum.FileLocationEnum.AZURE,
+        path: '../providers/azure-provider.optional',
+        name: 'AzureProvider',
+        dep: '@azure/storage-blob'
+    },
+    {
+        location: _filelocationenum.FileLocationEnum.SFTP,
+        path: '../providers/sftp-provider.optional',
+        name: 'SftpProvider',
+        dep: 'ssh2-sftp-client'
+    }
+];
+for (const { location, path, name, dep } of OPTIONAL_PROVIDERS){
+    try {
+        _providers.StorageProviderRegistry.register(location, require(path)[name]);
+        logger.log(`Registered ${name}`);
+    } catch  {
+        logger.debug(`${name} not available (install ${dep} to enable)`);
+    }
 }
 let StorageModule = class StorageModule {
-    /**
-   * Configure middleware for file serving
-   * This bypasses path-to-regexp issues with wildcard routes
-   */ configure(consumer) {
+    configure(consumer) {
         consumer.apply(_middlewares.FileServeMiddleware).forRoutes({
             path: 'storage/upload/file/*',
             method: _common.RequestMethod.GET
         });
     }
-    /**
-   * Register StorageModule synchronously
-   */ static forRoot(options) {
-        const controllers = this.getControllers(options);
-        const providers = this.getProviders(options);
+    static forRoot(options) {
         return {
             module: StorageModule,
             global: options.global ?? false,
@@ -74,24 +87,12 @@ let StorageModule = class StorageModule {
                 _modules.CacheModule,
                 _modules.UtilsModule
             ],
-            controllers: options.includeController !== false ? controllers : [],
-            providers,
-            exports: [
-                _config.StorageConfigService,
-                _services.StorageDataSourceProvider,
-                _services.FileManagerService,
-                _services.FolderService,
-                _storageproviderconfigservice.StorageProviderConfigService,
-                _services.UploadService,
-                _providers.StorageFactoryService
-            ]
+            controllers: options.includeController !== false ? CONTROLLERS : [],
+            providers: this.buildProviders(options),
+            exports: EXPORTED_SERVICES
         };
     }
-    /**
-   * Register StorageModule asynchronously
-   */ static forRootAsync(options) {
-        const controllers = this.getControllers(options);
-        const asyncProviders = this.createAsyncProviders(options);
+    static forRootAsync(options) {
         return {
             module: StorageModule,
             global: options.global ?? false,
@@ -100,53 +101,21 @@ let StorageModule = class StorageModule {
                 _modules.CacheModule,
                 _modules.UtilsModule
             ],
-            controllers: options.includeController !== false ? controllers : [],
-            // Pass false to exclude STORAGE_MODULE_OPTIONS - it's already in asyncProviders
+            controllers: options.includeController !== false ? CONTROLLERS : [],
             providers: [
-                ...asyncProviders,
-                ...this.getProviders(options, false)
+                ...this.createAsyncProviders(options),
+                ...this.buildProviders()
             ],
-            exports: [
-                _config.StorageConfigService,
-                _services.StorageDataSourceProvider,
-                _services.FileManagerService,
-                _services.FolderService,
-                _storageproviderconfigservice.StorageProviderConfigService,
-                _services.UploadService,
-                _providers.StorageFactoryService
-            ]
+            exports: EXPORTED_SERVICES
         };
     }
-    // Private Helper Methods
-    /** Get controllers (all controllers always loaded) */ static getControllers(options) {
-        return [
-            _controllers.FileManagerController,
-            _controllers.FolderController,
-            _controllers.StorageConfigController,
-            _controllers.UploadController
-        ];
-    }
-    /**
-   * NOTE: Repository providers removed - services now use StorageDataSourceProvider directly
-   * This ensures dynamic entity loading based on runtime configuration
-   */ /**
-   * Get providers (all providers always loaded)
-   * @param options Module options
-   * @param includeOptionsProvider Whether to include the STORAGE_MODULE_OPTIONS provider (false for async registration)
-   */ static getProviders(options, includeOptionsProvider = true) {
+    // ─── Private Helpers ──────────────────────────────────────────────────────────
+    static buildProviders(options) {
         const providers = [
-            _config.StorageConfigService,
-            _services.StorageDataSourceProvider,
-            _services.FileManagerService,
-            _services.FolderService,
-            _storageproviderconfigservice.StorageProviderConfigService,
-            _services.UploadService,
-            _providers.StorageFactoryService,
+            ...EXPORTED_SERVICES,
             _middlewares.FileServeMiddleware
         ];
-        // Only include options provider for sync registration
-        // For async registration, createAsyncProviders handles it
-        if (includeOptionsProvider) {
+        if (options) {
             providers.unshift({
                 provide: _storageconstants.STORAGE_MODULE_OPTIONS,
                 useValue: options
@@ -154,63 +123,40 @@ let StorageModule = class StorageModule {
         }
         return providers;
     }
-    /**
-   * Create async providers for forRootAsync
-   */ static createAsyncProviders(options) {
+    static createAsyncProviders(options) {
         if (options.useFactory) {
             return [
                 {
                     provide: _storageconstants.STORAGE_MODULE_OPTIONS,
-                    useFactory: async (...args)=>{
-                        const config = await options.useFactory(...args);
-                        return {
+                    useFactory: async (...args)=>({
                             ...options,
-                            config
-                        };
-                    },
+                            config: await options.useFactory(...args)
+                        }),
                     inject: options.inject || []
                 }
             ];
         }
+        const factoryClass = options.useClass || options.useExisting;
+        if (!factoryClass) return [];
+        const providers = [
+            {
+                provide: _storageconstants.STORAGE_MODULE_OPTIONS,
+                useFactory: async (factory)=>({
+                        ...options,
+                        config: await factory.createStorageOptions()
+                    }),
+                inject: [
+                    factoryClass
+                ]
+            }
+        ];
         if (options.useClass) {
-            return [
-                {
-                    provide: _storageconstants.STORAGE_MODULE_OPTIONS,
-                    useFactory: async (optionsFactory)=>{
-                        const config = await optionsFactory.createStorageOptions();
-                        return {
-                            ...options,
-                            config
-                        };
-                    },
-                    inject: [
-                        options.useClass
-                    ]
-                },
-                {
-                    provide: options.useClass,
-                    useClass: options.useClass
-                }
-            ];
-        }
-        if (options.useExisting) {
-            return [
-                {
-                    provide: _storageconstants.STORAGE_MODULE_OPTIONS,
-                    useFactory: async (optionsFactory)=>{
-                        const config = await optionsFactory.createStorageOptions();
-                        return {
-                            ...options,
-                            config
-                        };
-                    },
-                    inject: [
-                        options.useExisting
-                    ]
-                }
-            ];
+            providers.push({
+                provide: options.useClass,
+                useClass: options.useClass
+            });
         }
-        return [];
+        return providers;
     }
 };
 StorageModule = _ts_decorate([

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

@@ -1,17 +1,6 @@
 /**
- * OPTIONAL Azure Blob Storage Provider
- *
- * This provider requires @azure/storage-blob package to be installed.
- * Only import this if you need Azure Blob storage.
- *
- * Installation:
- * npm install @azure/storage-blob
- *
- * Usage:
- * import { AzureProvider } from '@flusys/nestjs-storage/providers/azure-provider.optional';
- * import { StorageProviderRegistry, FileLocationEnum } from '@flusys/nestjs-storage';
- *
- * StorageProviderRegistry.register(FileLocationEnum.AZURE, AzureProvider);
+ * Optional Azure Blob Storage Provider
+ * Requires: npm install @azure/storage-blob
  */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
@@ -22,9 +11,9 @@ Object.defineProperty(exports, "AzureProvider", {
         return AzureProvider;
     }
 });
-const _imagecompressorutil = require("../utils/image-compressor.util");
 const _common = require("@nestjs/common");
 const _uuid = require("uuid");
+const _imagecompressorutil = require("../utils/image-compressor.util");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -80,37 +69,23 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let AzureProvider = class AzureProvider {
-    /**
-   * Initialize Azure provider with configuration
-   */ async initialize(config) {
+    async initialize(config) {
         try {
-            // Dynamic import - only loads Azure SDK if this provider is used
-            const { BlobServiceClient } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("@azure/storage-blob")));
+            const { BlobServiceClient, StorageSharedKeyCredential } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("@azure/storage-blob")));
             this.accountName = config.accountName;
             this.containerName = config.containerName;
-            // Create BlobServiceClient
-            if (config.connectionString) {
-                this.blobServiceClient = BlobServiceClient.fromConnectionString(config.connectionString);
-            } else {
-                const { StorageSharedKeyCredential } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("@azure/storage-blob")));
-                const sharedKeyCredential = new StorageSharedKeyCredential(config.accountName, config.accountKey);
-                this.blobServiceClient = new BlobServiceClient(`https://${config.accountName}.blob.core.windows.net`, sharedKeyCredential);
-            }
-            // Get container client
+            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);
-            // Ensure container exists
             await this.containerClient.createIfNotExists();
             this.logger.log(`Azure Provider initialized: account=${config.accountName}, container=${config.containerName}`);
-        } catch (_error) {
-            this.logger.error('Failed to initialize AzureProvider. Make sure @azure/storage-blob is installed.');
-            throw new Error('Azure Storage SDK not found. Install it with: npm install @azure/storage-blob');
+        } catch  {
+            throw new Error('Azure Storage SDK not found. Install: npm install @azure/storage-blob');
         }
     }
     async uploadFile(file, options) {
         let processedBuffer = file.buffer;
         let contentType = file.mimetype;
         const fileName = `${(0, _uuid.v4)()}-${file.originalname}`;
-        // Compress image if needed
         if (options.compress && file.mimetype.startsWith('image/')) {
             const result = await _imagecompressorutil.ImageCompressor.compress(file.buffer, file.mimetype, {
                 maxWidth: options.maxWidth,
@@ -122,9 +97,7 @@ let AzureProvider = class AzureProvider {
             contentType = result.format;
         }
         const blobName = options.folderPath ? `${options.folderPath}/${fileName}` : fileName;
-        const blockBlobClient = this.containerClient.getBlockBlobClient(blobName);
-        // Upload to Azure
-        await blockBlobClient.upload(processedBuffer, processedBuffer.length, {
+        await this.containerClient.getBlockBlobClient(blobName).upload(processedBuffer, processedBuffer.length, {
             blobHTTPHeaders: {
                 blobContentType: contentType
             }
@@ -140,8 +113,7 @@ let AzureProvider = class AzureProvider {
         return Promise.all(files.map((file)=>this.uploadFile(file, options)));
     }
     async deleteFile(key) {
-        const blockBlobClient = this.containerClient.getBlockBlobClient(key);
-        await blockBlobClient.deleteIfExists();
+        await this.containerClient.getBlockBlobClient(key).deleteIfExists();
         this.logger.log(`Deleted file from Azure: ${key}`);
     }
     async deleteMultipleFiles(keys) {

package/cjs/providers/local-provider.js

@@ -219,49 +219,6 @@ let LocalProvider = class LocalProvider {
             return false;
         }
     }
-    /**
-   * Get the absolute path for a file key
-   * Key now includes basePath, so resolve from cwd
-   */ getAbsolutePath(key) {
-        // SECURITY: Validate key format
-        this.validateKeyFormat(key);
-        const filePath = _path.resolve(key);
-        // SECURITY: Validate path is within base directory
-        this.validatePathWithinBase(filePath);
-        return filePath;
-    }
-    /**
-   * Check if a file exists
-   */ async fileExists(key) {
-        try {
-            // SECURITY: Validate key format
-            this.validateKeyFormat(key);
-            // Key now includes basePath, resolve from cwd
-            const filePath = _path.resolve(key);
-            // SECURITY: Validate path is within base directory
-            this.validatePathWithinBase(filePath);
-            await _promises.access(filePath);
-            return true;
-        } catch  {
-            return false;
-        }
-    }
-    /**
-   * Get file stats
-   */ async getFileStats(key) {
-        // SECURITY: Validate key format
-        this.validateKeyFormat(key);
-        // Key now includes basePath, resolve from cwd
-        const filePath = _path.resolve(key);
-        // SECURITY: Validate path is within base directory
-        this.validatePathWithinBase(filePath);
-        const stats = await _promises.stat(filePath);
-        return {
-            size: stats.size,
-            createdAt: stats.birthtime,
-            modifiedAt: stats.mtime
-        };
-    }
     constructor(){
         _define_property(this, "logger", new _common.Logger(LocalProvider.name));
         _define_property(this, "basePath", '');