@flusys/nestjs-storage 1.0.0-rc → 1.0.1

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

@@ -30,123 +30,130 @@ import { createReadStream, existsSync, statSync } from 'fs';
 import { join, resolve } from 'path';
 import * as mime from 'mime-types';
 import { UploadService } from '../services/upload.service';
+/** MIME type prefixes that can be displayed inline in browser */ const VIEWABLE_TYPE_PREFIXES = [
+    'image/',
+    'video/',
+    'audio/',
+    'text/',
+    'application/pdf',
+    'application/json',
+    'application/xml'
+];
 export 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 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 = join(uploadDir, normalizedPath);
-            let resolvedPath = 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 NotFoundException('Invalid file path');
-            }
-            // Check if file exists
-            if (!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 = join(basePath, remainingPath);
-                        this.logger.debug(`Strategy 2 - basePath + remaining: ${fallbackPath}`);
-                        if (existsSync(fallbackPath)) {
-                            fullPath = fallbackPath;
-                            resolvedPath = resolve(fullPath);
-                        }
-                    } else {
-                        // Old format: key doesn't include basePath, prepend it
-                        const fallbackPath = join(basePath, normalizedPath);
-                        this.logger.debug(`Strategy 3 - basePath + full key (old format): ${fallbackPath}`);
-                        if (existsSync(fallbackPath)) {
-                            fullPath = fallbackPath;
-                            resolvedPath = resolve(fullPath);
-                        }
-                    }
-                }
-                // Final check if file was found
-                if (!existsSync(fullPath)) {
-                    throw new NotFoundException(`File not found: ${normalizedPath}`);
-                }
-            }
+            const normalizedPath = this.extractFilePath(req);
+            const fullPath = await this.resolveFilePath(normalizedPath);
             const stats = statSync(fullPath);
             if (!stats.isFile()) {
                 throw new NotFoundException(`Not a file: ${normalizedPath}`);
             }
-            // Enhanced MIME type detection
-            let mimeType = mime.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 = 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 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 = join(this.uploadDir, normalizedPath);
+        const resolvedPath = resolve(fullPath);
+        this.logger.debug(`Strategy 1 - CWD relative: ${fullPath}`);
+        // Prevent path traversal attacks
+        if (!resolvedPath.startsWith(this.uploadDir)) {
+            throw new NotFoundException('Invalid file path');
+        }
+        if (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 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 = join(basePath, remainingPath);
+            this.logger.debug(`Strategy 2 - basePath + remaining: ${fallbackPath}`);
+            if (existsSync(fallbackPath)) return fallbackPath;
+        } else {
+            // Strategy 3: Old format - prepend basePath
+            const fallbackPath = join(basePath, normalizedPath);
+            this.logger.debug(`Strategy 3 - basePath + full key (old format): ${fallbackPath}`);
+            if (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 mime.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 = 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 NotFoundException ? error.message : `File not found`,
-                    error: 'Not Found',
-                    statusCode: 404
-                });
+                this.sendErrorResponse(res, new 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 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 Logger(FileServeMiddleware.name);
+        this.uploadDir = process.cwd();
     }
 }
 FileServeMiddleware = _ts_decorate([

package/fesm/modules/storage.module.js

@@ -5,9 +5,9 @@ function _ts_decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 import { CacheModule, UtilsModule } from '@flusys/nestjs-shared/modules';
-import { Module, Logger, RequestMethod } from '@nestjs/common';
+import { Logger, Module, RequestMethod } from '@nestjs/common';
 import { FileServeMiddleware } from '../middlewares';
-import { StorageConfigService } from '../config';
+import { StorageConfigService } from '../services';
 import { STORAGE_MODULE_OPTIONS } from '../config/storage.constants';
 import { FileManagerController, FolderController, StorageConfigController, UploadController } from '../controllers';
 import { FileLocationEnum } from '../enums/file-location.enum';
@@ -15,48 +15,62 @@ import { StorageFactoryService, StorageProviderRegistry } from '../providers';
 import { LocalProvider } from '../providers/local-provider';
 import { FileManagerService, FolderService, StorageDataSourceProvider, UploadService } from '../services';
 import { StorageProviderConfigService } from '../services/storage-provider-config.service';
-// Auto-register built-in storage providers
+// ─── Module Constants ─────────────────────────────────────────────────────────
 const logger = new Logger('StorageModule');
-// Register LocalProvider (always available - uses Node.js built-in fs)
+const CONTROLLERS = [
+    FileManagerController,
+    FolderController,
+    StorageConfigController,
+    UploadController
+];
+const EXPORTED_SERVICES = [
+    StorageConfigService,
+    StorageDataSourceProvider,
+    FileManagerService,
+    FolderService,
+    StorageProviderConfigService,
+    UploadService,
+    StorageFactoryService
+];
+// ─── Provider Registration ────────────────────────────────────────────────────
 StorageProviderRegistry.register(FileLocationEnum.LOCAL, LocalProvider);
 logger.log('Registered LocalProvider');
-// Try to register optional providers (only if dependencies are installed)
-try {
-    const { S3Provider } = require('../providers/s3-provider.optional');
-    StorageProviderRegistry.register(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');
-    StorageProviderRegistry.register(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');
-    StorageProviderRegistry.register(FileLocationEnum.SFTP, SftpProvider);
-    logger.log('Registered SftpProvider');
-} catch  {
-    logger.debug('SftpProvider not available (install ssh2-sftp-client to enable)');
+const OPTIONAL_PROVIDERS = [
+    {
+        location: FileLocationEnum.AWS,
+        path: '../providers/s3-provider.optional',
+        name: 'S3Provider',
+        dep: '@aws-sdk/client-s3'
+    },
+    {
+        location: FileLocationEnum.AZURE,
+        path: '../providers/azure-provider.optional',
+        name: 'AzureProvider',
+        dep: '@azure/storage-blob'
+    },
+    {
+        location: FileLocationEnum.SFTP,
+        path: '../providers/sftp-provider.optional',
+        name: 'SftpProvider',
+        dep: 'ssh2-sftp-client'
+    }
+];
+for (const { location, path, name, dep } of OPTIONAL_PROVIDERS){
+    try {
+        StorageProviderRegistry.register(location, require(path)[name]);
+        logger.log(`Registered ${name}`);
+    } catch  {
+        logger.debug(`${name} not available (install ${dep} to enable)`);
+    }
 }
 export class StorageModule {
-    /**
-   * Configure middleware for file serving
-   * This bypasses path-to-regexp issues with wildcard routes
-   */ configure(consumer) {
+    configure(consumer) {
         consumer.apply(FileServeMiddleware).forRoutes({
             path: 'storage/upload/file/*',
             method: 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,
@@ -64,24 +78,12 @@ export class StorageModule {
                 CacheModule,
                 UtilsModule
             ],
-            controllers: options.includeController !== false ? controllers : [],
-            providers,
-            exports: [
-                StorageConfigService,
-                StorageDataSourceProvider,
-                FileManagerService,
-                FolderService,
-                StorageProviderConfigService,
-                UploadService,
-                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,
@@ -90,53 +92,21 @@ export class StorageModule {
                 CacheModule,
                 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: [
-                StorageConfigService,
-                StorageDataSourceProvider,
-                FileManagerService,
-                FolderService,
-                StorageProviderConfigService,
-                UploadService,
-                StorageFactoryService
-            ]
+            exports: EXPORTED_SERVICES
         };
     }
-    // Private Helper Methods
-    /** Get controllers (all controllers always loaded) */ static getControllers(options) {
-        return [
-            FileManagerController,
-            FolderController,
-            StorageConfigController,
-            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 = [
-            StorageConfigService,
-            StorageDataSourceProvider,
-            FileManagerService,
-            FolderService,
-            StorageProviderConfigService,
-            UploadService,
-            StorageFactoryService,
+            ...EXPORTED_SERVICES,
             FileServeMiddleware
         ];
-        // Only include options provider for sync registration
-        // For async registration, createAsyncProviders handles it
-        if (includeOptionsProvider) {
+        if (options) {
             providers.unshift({
                 provide: STORAGE_MODULE_OPTIONS,
                 useValue: options
@@ -144,63 +114,40 @@ export class StorageModule {
         }
         return providers;
     }
-    /**
-   * Create async providers for forRootAsync
-   */ static createAsyncProviders(options) {
+    static createAsyncProviders(options) {
         if (options.useFactory) {
             return [
                 {
                     provide: 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: STORAGE_MODULE_OPTIONS,
+                useFactory: async (factory)=>({
+                        ...options,
+                        config: await factory.createStorageOptions()
+                    }),
+                inject: [
+                    factoryClass
+                ]
+            }
+        ];
         if (options.useClass) {
-            return [
-                {
-                    provide: 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: 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/fesm/providers/azure-provider.optional.js

@@ -1,18 +1,4 @@
-/**
- * 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);
- */ function _define_property(obj, key, value) {
+function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -25,44 +11,30 @@
     }
     return obj;
 }
-import { ImageCompressor } from '../utils/image-compressor.util';
-import { Logger } from '@nestjs/common';
-import { v4 as uuidv4 } from 'uuid';
 /**
- * Azure Blob Storage Provider
- * Requires @azure/storage-blob package to be installed
- */ export class AzureProvider {
-    /**
-   * Initialize Azure provider with configuration
-   */ async initialize(config) {
+ * Optional Azure Blob Storage Provider
+ * Requires: npm install @azure/storage-blob
+ */ import { Logger } from '@nestjs/common';
+import { v4 as uuidv4 } from 'uuid';
+import { ImageCompressor } from '../utils/image-compressor.util';
+export class AzureProvider {
+    async initialize(config) {
         try {
-            // Dynamic import - only loads Azure SDK if this provider is used
-            const { BlobServiceClient } = await import('@azure/storage-blob');
+            const { BlobServiceClient, StorageSharedKeyCredential } = await import('@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 import('@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 = `${uuidv4()}-${file.originalname}`;
-        // Compress image if needed
         if (options.compress && file.mimetype.startsWith('image/')) {
             const result = await ImageCompressor.compress(file.buffer, file.mimetype, {
                 maxWidth: options.maxWidth,
@@ -74,9 +46,7 @@ import { v4 as uuidv4 } from 'uuid';
             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
             }
@@ -92,8 +62,7 @@ import { v4 as uuidv4 } from 'uuid';
         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/fesm/providers/local-provider.js

@@ -171,49 +171,6 @@ import { v4 as uuidv4 } from 'uuid';
             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 fs.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 fs.stat(filePath);
-        return {
-            size: stats.size,
-            createdAt: stats.birthtime,
-            modifiedAt: stats.mtime
-        };
-    }
     constructor(){
         _define_property(this, "logger", new Logger(LocalProvider.name));
         _define_property(this, "basePath", '');