@flusys/nestjs-storage 0.1.0-beta.2 → 1.0.0-beta

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

@@ -32,34 +32,24 @@ import { StorageConfigService } from '../config';
 import { StorageConfig, StorageConfigWithCompany } from '../entities';
 import { StorageDataSourceProvider } from './storage-datasource.provider';
 export class StorageProviderConfigService extends RequestScopedApiService {
-    /**
-   * Resolve entity class for this service
-   * @returns StorageConfig or StorageConfigWithCompany based on configuration
-   */ resolveEntity() {
-        const enableCompanyFeature = this.storageConfig.isCompanyFeatureEnabled();
-        return enableCompanyFeature ? StorageConfigWithCompany : StorageConfig;
+    resolveEntity() {
+        return this.storageConfig.isCompanyFeatureEnabled() ? StorageConfigWithCompany : StorageConfig;
     }
-    /**
-   * Get DataSource provider for this service
-   * @returns StorageDataSourceProvider instance
-   */ getDataSourceProvider() {
+    getDataSourceProvider() {
         return this.dataSourceProvider;
     }
+    // Entity Conversion
     async convertSingleDtoToEntity(dto, user) {
-        let storageConfig = {};
-        // Set basic fields
-        storageConfig = {
-            ...storageConfig,
-            ...dto
-        };
-        // Only set company fields if they exist on the entity (when company feature is enabled)
-        if ('companyId' in storageConfig) {
-            storageConfig.companyId = user?.companyId ?? null;
+        const entity = await super.convertSingleDtoToEntity(dto, user);
+        // Set companyId from user context if company feature enabled
+        if (this.storageConfig.isCompanyFeatureEnabled()) {
+            entity.companyId = user?.companyId ?? null;
         }
-        return storageConfig;
+        return entity;
     }
+    // Query Customization
     async getSelectQuery(query, _user, select) {
-        if (!select || !select.length) {
+        if (!select?.length) {
             select = [
                 'id',
                 'name',
@@ -68,25 +58,19 @@ export class StorageProviderConfigService extends RequestScopedApiService {
                 'createdAt',
                 'updatedAt'
             ];
-            // Add company fields if company feature is enabled
             if (this.storageConfig.isCompanyFeatureEnabled()) {
                 select.push('companyId');
             }
         }
-        const selectFields = select.map((field)=>`${this.entityName}.${field}`);
-        query.select(selectFields);
+        query.select(select.map((f)=>`${this.entityName}.${f}`));
         return {
             query,
             isRaw: false
         };
     }
-    /**
-   * Override: Extra query manipulation - Auto-filter by user's company
-   */ async getExtraManipulateQuery(query, filterDto, user) {
+    async getExtraManipulateQuery(query, filterDto, user) {
         const result = await super.getExtraManipulateQuery(query, filterDto, user);
-        // If company feature enabled and user has companyId, filter by user's company
-        const enableCompanyFeature = this.storageConfig.isCompanyFeatureEnabled();
-        if (enableCompanyFeature && user?.companyId) {
+        if (this.storageConfig.isCompanyFeatureEnabled() && user?.companyId) {
             query.andWhere('storageConfig.companyId = :companyId', {
                 companyId: user.companyId
             });
@@ -95,6 +79,18 @@ export class StorageProviderConfigService extends RequestScopedApiService {
         return result;
     }
     /**
+   * Find storage config by ID without throwing (returns null if not found)
+   * Uses direct repository query - bypasses company filtering
+   * Use for internal operations like file deletion where config ID is already known
+   */ async findByIdDirect(id) {
+        await this.ensureRepositoryInitialized();
+        return await this.repository.findOne({
+            where: {
+                id
+            }
+        });
+    }
+    /**
    * Get default storage configuration (scoped to user's company if enabled)
    * Falls back to any available config if 'default' not found
    */ async getDefaultConfig(user) {
@@ -140,9 +136,7 @@ export class StorageProviderConfigService extends RequestScopedApiService {
             where
         });
     }
-    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
     constructor(cacheManager, utilsService, storageConfig, dataSourceProvider){
-        // Repository will be set asynchronously by RequestScopedApiService
         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;
     }
 }

package/fesm/services/upload.service.js

@@ -27,6 +27,7 @@ function _ts_param(paramIndex, decorator) {
 }
 import { BadRequestException, Inject, Injectable, InternalServerErrorException, Logger, NotFoundException, Scope } from '@nestjs/common';
 import { StorageConfigService } from '../config';
+import { FileLocationEnum } from '../enums/file-location.enum';
 import { StorageFactoryService } from '../providers/storage-factory.service';
 import { StorageProviderConfigService } from './storage-provider-config.service';
 export class UploadService {
@@ -45,19 +46,14 @@ export class UploadService {
         }
     }
     /**
-   * Get storage provider based on storage config ID
+   * Get storage provider and config info based on storage config ID
    * Validates company ownership when company feature is enabled
-   */ async getStorageProvider(storageConfigId, user) {
+   */ async getStorageProviderWithConfig(storageConfigId, user) {
         let storageConfig;
-        // Get storage config from database (scoped to user's company/branch)
+        // Get storage config from database
         if (storageConfigId) {
-            // Pass user for company-scoped filtering
-            const config = await this.storageProviderConfigService.findById(storageConfigId, user ?? null, [
-                'name',
-                'storage',
-                'config',
-                'companyId'
-            ]);
+            // Use direct lookup (bypasses company filtering, returns null instead of throwing)
+            const config = await this.storageProviderConfigService.findByIdDirect(storageConfigId);
             if (!config) {
                 throw new NotFoundException('Storage configuration not found');
             }
@@ -83,17 +79,98 @@ export class UploadService {
             config: storageConfig.config
         };
         // Get or create provider instance
-        return await this.storageFactory.createProvider(providerConfig);
+        const provider = await this.storageFactory.createProvider(providerConfig);
+        return {
+            provider,
+            location: storageConfig.storage,
+            configId: storageConfig.id
+        };
+    }
+    /**
+   * Get storage provider based on storage config ID (convenience method)
+   */ async getStorageProvider(storageConfigId, user) {
+        const { provider } = await this.getStorageProviderWithConfig(storageConfigId, user);
+        return provider;
+    }
+    /**
+   * Get storage provider for delete operations with fallback
+   * If the original storage config doesn't exist, falls back based on locationHint
+   * This ensures files can still be deleted even if storage config was removed
+   * @param storageConfigId - The storage config ID to look up
+   * @param user - User context for company filtering
+   * @param locationHint - The file's original location type (used for fallback)
+   */ async getStorageProviderForDelete(storageConfigId, user, locationHint) {
+        // If storageConfigId provided, try to find it
+        if (storageConfigId) {
+            const config = await this.storageProviderConfigService.findByIdDirect(storageConfigId);
+            if (config) {
+                const providerConfig = {
+                    provider: config.storage,
+                    config: config.config
+                };
+                return await this.storageFactory.createProvider(providerConfig);
+            }
+            // Config not found, log warning and try fallback
+            this.logger.warn(`Storage config ${storageConfigId} not found, trying fallback for delete`);
+        }
+        // Fallback: Use locationHint to find a matching config or create provider
+        if (locationHint) {
+            // Try to find a config matching the file's original location type
+            const matchingConfigs = await this.storageProviderConfigService.getConfigByType(locationHint, user);
+            if (matchingConfigs.length > 0) {
+                const providerConfig = {
+                    provider: matchingConfigs[0].storage,
+                    config: matchingConfigs[0].config
+                };
+                this.logger.debug(`Using matching ${locationHint} config for delete fallback`);
+                return await this.storageFactory.createProvider(providerConfig);
+            }
+            // No matching config found, create a basic provider based on locationHint
+            if (locationHint === FileLocationEnum.LOCAL) {
+                this.logger.warn('No local config found, using fallback local provider for delete');
+                const localProviderConfig = {
+                    provider: FileLocationEnum.LOCAL,
+                    config: {
+                        basePath: this.storageConfigService.getDefaultLocalStoragePath()
+                    }
+                };
+                return await this.storageFactory.createProvider(localProviderConfig);
+            }
+        }
+        // Last resort: Try default config (might be different provider type)
+        const defaultConfig = await this.storageProviderConfigService.getDefaultConfig(user);
+        if (defaultConfig) {
+            const providerConfig = {
+                provider: defaultConfig.storage,
+                config: defaultConfig.config
+            };
+            return await this.storageFactory.createProvider(providerConfig);
+        }
+        // Final fallback: Create a basic local provider
+        this.logger.warn('No storage config found, using fallback local provider for delete');
+        const localProviderConfig = {
+            provider: FileLocationEnum.LOCAL,
+            config: {
+                basePath: this.storageConfigService.getDefaultLocalStoragePath()
+            }
+        };
+        return await this.storageFactory.createProvider(localProviderConfig);
     }
     async uploadSingleFile(file, options, user) {
         try {
             // Validate file before upload
             this.validateFile(file);
-            const provider = await this.getStorageProvider(options.storageConfigId, user);
-            return await provider.uploadFile(file, options);
+            const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
+            const result = await provider.uploadFile(file, options);
+            // Enrich result with storage info
+            return {
+                ...result,
+                location,
+                storageConfigId: configId
+            };
         } catch (err) {
             this.logger.error('Single file upload failed', err);
-            throw new InternalServerErrorException(err.message);
+            throw new InternalServerErrorException(err?.message || 'Single file upload failed');
         }
     }
     async uploadMultipleFiles(files, options, user) {
@@ -102,39 +179,73 @@ export class UploadService {
             for (const file of files){
                 this.validateFile(file);
             }
-            const provider = await this.getStorageProvider(options.storageConfigId, user);
-            return await provider.uploadMultipleFiles(files, options);
+            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 (err) {
             this.logger.error('Multiple files upload failed', err);
-            throw new InternalServerErrorException(err.message);
+            throw new InternalServerErrorException(err?.message || 'Multiple files upload failed');
         }
     }
-    async deleteSingleFile(key, storageConfigId, user) {
+    async deleteSingleFile(key, storageConfigId, user, locationHint) {
         try {
             if (!key) throw new Error('No file path provided');
-            const provider = await this.getStorageProvider(storageConfigId, user);
+            const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
             await provider.deleteFile(key);
             return true;
         } catch (err) {
             this.logger.error('Delete single file failed', err);
-            throw new InternalServerErrorException(err.message);
+            throw new InternalServerErrorException(err?.message || 'Delete single file failed');
         }
     }
-    async deleteMultipleFile(keys, storageConfigId, user) {
+    async deleteMultipleFile(keys, storageConfigId, user, locationHint) {
         try {
             if (!keys || !keys.length) throw new Error('No file paths provided');
-            const provider = await this.getStorageProvider(storageConfigId, user);
+            const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
             await provider.deleteMultipleFiles(keys);
             return true;
         } catch (err) {
             this.logger.error('Delete multiple files failed', err);
-            throw new InternalServerErrorException(err.message);
+            throw new InternalServerErrorException(err?.message || 'Delete multiple files failed');
         }
     }
     bytesToKb(bytes) {
         return Number((bytes * 0.001).toFixed(2));
     }
     /**
+   * Get local storage basePath from DB config
+   * Initializes local provider if not cached, ensuring basePath is from DB
+   */ async getLocalStorageBasePath() {
+        try {
+            // First check if already cached
+            const cachedPath = this.storageFactory.getLocalProviderBasePath();
+            if (cachedPath) {
+                return cachedPath;
+            }
+            // Get local config from DB (without user context for public access)
+            const localConfigs = await this.storageProviderConfigService.getConfigByType(FileLocationEnum.LOCAL);
+            if (localConfigs.length > 0) {
+                const localConfig = localConfigs[0];
+                // Initialize provider to cache it
+                await this.storageFactory.createProvider({
+                    provider: FileLocationEnum.LOCAL,
+                    config: localConfig.config
+                });
+                // Now get the cached basePath
+                return this.storageFactory.getLocalProviderBasePath();
+            }
+            return null;
+        } catch (error) {
+            this.logger.warn(`Failed to get local storage basePath: ${error.message}`);
+            return null;
+        }
+    }
+    /**
    * Generate a URL for accessing a file
    * For S3/Azure: generates presigned URL
    * For Local/SFTP: returns direct path
@@ -149,7 +260,7 @@ export class UploadService {
             return key;
         } catch (err) {
             this.logger.error('Generate file URL failed', err);
-            throw new InternalServerErrorException(err.message);
+            throw new InternalServerErrorException(err?.message || 'Generate file URL failed');
         }
     }
     // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild

package/fesm/utils/image-compressor.util.js

@@ -1,4 +1,6 @@
-import sharp from 'sharp';
+import * as sharpModule from 'sharp';
+// Handle ESM/CJS interop - sharp exports differently in each module system
+const sharp = sharpModule.default || sharpModule;
 /**
  * Image Compression Utility
  * Handles image compression and format conversion using sharp

package/interfaces/file-manager.interface.d.ts

@@ -8,6 +8,8 @@ export interface IFileManager extends IIdentity {
     expiresAt?: number;
     contentType?: string;
     location?: string;
+    storageConfigId?: string;
+    providerName?: string;
     isPrivate?: boolean;
     companyId?: string | null;
 }

package/interfaces/storage-module-options.interface.d.ts

@@ -4,6 +4,8 @@ export interface IStorageModuleConfig extends IDataSourceServiceOptions {
     maxFileSize?: number;
     allowedFileTypes?: string[];
     defaultStorageProvider?: string;
+    localStoragePath?: string;
+    appUrl?: string;
 }
 export interface IStorageModuleConfigFull {
     bootstrapAppConfig?: IBootstrapAppConfig;

package/interfaces/storage-provider.interface.d.ts

@@ -8,6 +8,8 @@ export interface IUploadedFileInfo {
     contentType: string;
     size: number;
     name: string;
+    location?: string;
+    storageConfigId?: string;
 }
 export interface IStorageProvider {
     uploadFile(file: Express.Multer.File, options: UploadOptionsDto): Promise<IUploadedFileInfo>;

package/middlewares/file-serve.middleware.d.ts

@@ -0,0 +1,9 @@
+import { NestMiddleware } from '@nestjs/common';
+import { Request, Response, NextFunction } from 'express';
+import { UploadService } from '../services/upload.service';
+export declare class FileServeMiddleware implements NestMiddleware {
+    private uploadService;
+    private logger;
+    constructor(uploadService: UploadService);
+    use(req: Request, res: Response, next: NextFunction): Promise<void>;
+}

package/middlewares/index.d.ts

@@ -0,0 +1 @@
+export * from './file-serve.middleware';

package/modules/storage.module.d.ts

@@ -1,6 +1,7 @@
-import { DynamicModule } from '@nestjs/common';
+import { DynamicModule, MiddlewareConsumer, NestModule } from '@nestjs/common';
 import { StorageModuleAsyncOptions, StorageModuleOptions } from '../interfaces';
-export declare class StorageModule {
+export declare class StorageModule implements NestModule {
+    configure(consumer: MiddlewareConsumer): void;
     static forRoot(options: StorageModuleOptions): DynamicModule;
     static forRootAsync(options: StorageModuleAsyncOptions): DynamicModule;
     private static getControllers;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-storage",
-  "version": "0.1.0-beta.2",
+  "version": "1.0.0-beta",
   "description": "Modular storage package with optional AWS S3, Azure Blob, and SFTP providers",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -93,9 +93,16 @@
     "@nestjs/typeorm": "^10.0.0 || ^11.0.0",
     "class-transformer": "^0.5.0",
     "class-validator": "^0.14.0",
+    "typeorm": "^0.3.0",
     "multer": "^1.4.0",
     "sharp": "^0.33.0",
-    "typeorm": "^0.3.0"
+    "mime-types": "^2.1.0",
+    "uuid": "^9.0.0 || ^11.0.0",
+    "@aws-sdk/client-s3": "^3.400.0",
+    "@aws-sdk/lib-storage": "^3.400.0",
+    "@aws-sdk/s3-request-presigner": "^3.400.0",
+    "@azure/storage-blob": "^12.15.0",
+    "ssh2-sftp-client": "^10.0.0"
   },
   "peerDependenciesMeta": {
     "sharp": {
@@ -103,17 +110,25 @@
     },
     "multer": {
       "optional": true
+    },
+    "@aws-sdk/client-s3": {
+      "optional": true
+    },
+    "@aws-sdk/lib-storage": {
+      "optional": true
+    },
+    "@aws-sdk/s3-request-presigner": {
+      "optional": true
+    },
+    "@azure/storage-blob": {
+      "optional": true
+    },
+    "ssh2-sftp-client": {
+      "optional": true
     }
   },
   "dependencies": {
-    "@flusys/nestjs-core": "0.1.0-beta.2",
-    "@flusys/nestjs-shared": "0.1.0-beta.2"
-  },
-  "optionalDependencies": {
-    "@aws-sdk/client-s3": "^3.400.0",
-    "@aws-sdk/lib-storage": "^3.400.0",
-    "@aws-sdk/s3-request-presigner": "^3.400.0",
-    "@azure/storage-blob": "^12.15.0",
-    "ssh2-sftp-client": "^10.0.0"
+    "@flusys/nestjs-core": "1.0.0-beta",
+    "@flusys/nestjs-shared": "1.0.0-beta"
   }
 }

package/providers/local-provider.d.ts

@@ -4,8 +4,9 @@ export declare class LocalProvider implements IStorageProvider {
     private logger;
     private basePath;
     private baseUrl;
+    private relativeBasePath;
     initialize(config: {
-        basePath: string;
+        basePath?: string;
         baseUrl?: string;
     }): Promise<void>;
     uploadFile(file: Express.Multer.File, options: UploadOptionsDto): Promise<IUploadedFileInfo>;

package/providers/storage-factory.service.d.ts

@@ -1,13 +1,17 @@
 import { IStorageProvider, IStorageProviderConfig } from '../interfaces/storage-provider.interface';
 import { OnModuleDestroy } from '@nestjs/common';
+import { StorageConfigService } from '../config';
 export declare class StorageFactoryService implements OnModuleDestroy {
+    private readonly storageConfigService;
     private readonly logger;
     private providerCache;
+    constructor(storageConfigService: StorageConfigService);
     private generateCacheKey;
     createProvider(config: IStorageProviderConfig): Promise<IStorageProvider>;
     getProvider(providerName: string): Promise<IStorageProvider>;
     clearCache(): void;
     isProviderAvailable(providerName: string): boolean;
     getAvailableProviders(): string[];
+    getLocalProviderBasePath(): string | null;
     onModuleDestroy(): Promise<void>;
 }

package/services/file-manager.service.d.ts

@@ -16,6 +16,7 @@ export declare class FileManagerService extends RequestScopedApiService<CreateFi
     private readonly storageConfig;
     private readonly dataSourceProvider;
     private readonly FILE_URL_EXPIRY_SECONDS;
+    private getFileBaseUrl;
     constructor(cacheManager: HybridCache, utilsService: UtilsService, uploadService: UploadService, storageConfig: StorageConfigService, dataSourceProvider: StorageDataSourceProvider);
     protected resolveEntity(): EntityTarget<FileManagerBase>;
     protected getDataSourceProvider(): StorageDataSourceProvider;
@@ -24,6 +25,11 @@ export declare class FileManagerService extends RequestScopedApiService<CreateFi
         query: SelectQueryBuilder<FileManagerBase>;
         isRaw: boolean;
     }>;
+    enrichWithProviderNames<T extends {
+        storageConfigId?: string | null;
+    }>(items: T[]): Promise<(T & {
+        providerName?: string;
+    })[]>;
     protected getFilterQuery(query: SelectQueryBuilder<FileManagerBase>, filter: {
         [key: string]: any;
     }, _user: ILoggedUserInfo | null): Promise<{
@@ -34,6 +40,6 @@ export declare class FileManagerService extends RequestScopedApiService<CreateFi
         query: SelectQueryBuilder<FileManagerBase>;
         isRaw: boolean;
     }>;
-    beforeDeleteOperation(dto: DeleteDto, _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
+    beforeDeleteOperation(dto: DeleteDto, user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
     getFiles(dtos: GetFilesRequestDto[], protocol: string, host: string, user?: ILoggedUserInfo): Promise<FilesResponseDto[]>;
 }

package/services/folder.service.d.ts

@@ -1,5 +1,4 @@
 import { RequestScopedApiService, HybridCache } from '@flusys/nestjs-shared/classes';
-import { FilterAndPaginationDto } from '@flusys/nestjs-shared/dtos';
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
 import { EntityTarget, Repository, SelectQueryBuilder } from 'typeorm';
@@ -21,7 +20,7 @@ export declare class FolderService extends RequestScopedApiService<CreateFolderD
         query: SelectQueryBuilder<FolderBase>;
         isRaw: boolean;
     }>;
-    protected getExtraManipulateQuery(query: SelectQueryBuilder<FolderBase>, filterDto: FilterAndPaginationDto, user: ILoggedUserInfo | null): Promise<{
+    protected getExtraManipulateQuery(query: SelectQueryBuilder<FolderBase>, filterDto: any, user: ILoggedUserInfo | null): Promise<{
         query: SelectQueryBuilder<FolderBase>;
         isRaw: boolean;
     }>;

package/services/storage-provider-config.service.d.ts

@@ -1,5 +1,4 @@
 import { RequestScopedApiService, HybridCache } from '@flusys/nestjs-shared/classes';
-import { FilterAndPaginationDto } from '@flusys/nestjs-shared/dtos';
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
 import { EntityTarget, Repository, SelectQueryBuilder } from 'typeorm';
@@ -22,10 +21,11 @@ export declare class StorageProviderConfigService extends RequestScopedApiServic
         query: SelectQueryBuilder<StorageConfigBase>;
         isRaw: boolean;
     }>;
-    protected getExtraManipulateQuery(query: SelectQueryBuilder<StorageConfigBase>, filterDto: FilterAndPaginationDto, user: ILoggedUserInfo | null): Promise<{
+    protected getExtraManipulateQuery(query: SelectQueryBuilder<StorageConfigBase>, filterDto: any, user: ILoggedUserInfo | null): Promise<{
         query: SelectQueryBuilder<StorageConfigBase>;
         isRaw: boolean;
     }>;
+    findByIdDirect(id: string): Promise<StorageConfigBase | null>;
     getDefaultConfig(user?: ILoggedUserInfo): Promise<StorageConfigBase | null>;
     getConfigByType(storage: FileLocationEnum, user?: ILoggedUserInfo): Promise<StorageConfigBase[]>;
 }

package/services/upload.service.d.ts

@@ -1,6 +1,7 @@
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { StorageConfigService } from '../config';
 import { UploadOptionsDto } from '../dtos/upload.dto';
+import { FileLocationEnum } from '../enums/file-location.enum';
 import { IUploadedFileInfo } from '../interfaces/storage-provider.interface';
 import { StorageFactoryService } from '../providers/storage-factory.service';
 import { StorageProviderConfigService } from './storage-provider-config.service';
@@ -11,11 +12,14 @@ export declare class UploadService {
     private logger;
     constructor(storageFactory: StorageFactoryService, storageConfigService: StorageConfigService, storageProviderConfigService: StorageProviderConfigService);
     private validateFile;
+    private getStorageProviderWithConfig;
     private getStorageProvider;
+    private getStorageProviderForDelete;
     uploadSingleFile(file: Express.Multer.File, options: UploadOptionsDto, user?: ILoggedUserInfo): Promise<IUploadedFileInfo>;
     uploadMultipleFiles(files: Express.Multer.File[], options: UploadOptionsDto, user?: ILoggedUserInfo): Promise<IUploadedFileInfo[]>;
-    deleteSingleFile(key: string, storageConfigId?: string, user?: ILoggedUserInfo): Promise<boolean>;
-    deleteMultipleFile(keys: string[], storageConfigId?: string, user?: ILoggedUserInfo): Promise<boolean>;
+    deleteSingleFile(key: string, storageConfigId?: string, user?: ILoggedUserInfo, locationHint?: FileLocationEnum): Promise<boolean>;
+    deleteMultipleFile(keys: string[], storageConfigId?: string, user?: ILoggedUserInfo, locationHint?: FileLocationEnum): Promise<boolean>;
     bytesToKb(bytes: number): number;
+    getLocalStorageBasePath(): Promise<string | null>;
     makeFileUrl(key: string, storageConfigId: string, expiresIn?: number, user?: ILoggedUserInfo): Promise<string>;
 }