@flusys/nestjs-storage 9.1.2 → 9.2.0

package/fesm/providers/index.js

@@ -1,13 +1,12 @@
 import * as __rspack_external_sharp from "sharp";
-import * as __rspack_external_path from "path";
 import * as __rspack_external_uuid from "uuid";
 import * as __rspack_external_fs_promises_e1851c9c from "fs/promises";
 export const __rspack_esm_id = 467;
 export const __rspack_esm_ids = [467];
 export const __webpack_modules__ = {
-922(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/* import */ var _storage_factory_service_js__rspack_import_0 = __webpack_require__(192);
-/* import */ var _storage_provider_registry_js__rspack_import_1 = __webpack_require__(264);
+1922(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _storage_factory_service_js__rspack_import_0 = __webpack_require__(2192);
+/* import */ var _storage_provider_registry_js__rspack_import_1 = __webpack_require__(9264);
 /* import */ var _local_provider_js__rspack_import_2 = __webpack_require__(632);
 // Core exports
 
@@ -35,15 +34,15 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 // EXTERNAL MODULE: external "@nestjs/common"
-var common_ = __webpack_require__(157);
+var common_ = __webpack_require__(6157);
 // EXTERNAL MODULE: external "@flusys/nestjs-shared/constants"
-var constants_ = __webpack_require__(140);
+var constants_ = __webpack_require__(9140);
 // EXTERNAL MODULE: ./projects/nestjs-storage/src/utils/image-compressor.util.ts + 1 modules
-var image_compressor_util = __webpack_require__(872);
+var image_compressor_util = __webpack_require__(1872);
 ;// CONCATENATED MODULE: external "fs/promises"
 
 // EXTERNAL MODULE: external "path"
-var external_path_ = __webpack_require__(521);
+var external_path_ = __webpack_require__(2521);
 // EXTERNAL MODULE: external "uuid"
 var external_uuid_ = __webpack_require__(37);
 ;// CONCATENATED MODULE: ./projects/nestjs-storage/src/providers/local-provider.ts
@@ -71,20 +70,26 @@ var external_uuid_ = __webpack_require__(37);
     basePath = '';
     baseUrl = '';
     relativeBasePath = '';
+    isWithinBase(targetPath) {
+        const normalizedBasePath = external_path_.resolve(this.basePath);
+        const normalizedTargetPath = external_path_.resolve(targetPath);
+        return normalizedTargetPath.startsWith(normalizedBasePath + external_path_.sep) || normalizedTargetPath === normalizedBasePath;
+    }
     /**
    * SECURITY: Validates that a target path does not escape the base directory
    * Prevents path traversal attacks using ../ sequences
    * @throws Error if path traversal is detected
    */ validatePathWithinBase(targetPath) {
-        const normalizedBasePath = external_path_.resolve(this.basePath);
-        const normalizedTargetPath = external_path_.resolve(targetPath);
-        if (!normalizedTargetPath.startsWith(normalizedBasePath + external_path_.sep) && normalizedTargetPath !== normalizedBasePath) {
-            throw new common_.BadRequestException({
-                message: 'Invalid path: Path traversal attempt detected',
-                messageKey: constants_.SYSTEM_MESSAGES.PATH_TRAVERSAL_DETECTED
-            });
+        if (!this.isWithinBase(targetPath)) {
+            this.throwTraversal();
         }
     }
+    throwTraversal() {
+        throw new common_.BadRequestException({
+            message: 'Invalid path: Path traversal attempt detected',
+            messageKey: constants_.SYSTEM_MESSAGES.PATH_TRAVERSAL_DETECTED
+        });
+    }
     /**
    * SECURITY: Validates file key format to prevent malicious input
    * @throws Error if key contains suspicious patterns
@@ -159,36 +164,27 @@ var external_uuid_ = __webpack_require__(37);
         return Promise.all(files.map((file)=>this.uploadFile(file, options)));
     }
     async deleteFile(key) {
-        try {
-            // SECURITY: Validate key format first
-            this.validateKeyFormat(key);
-            // Key now includes the basePath, resolve from cwd
-            let filePath = external_path_.resolve(key);
-            // SECURITY: Validate resolved path is within base directory
-            this.validatePathWithinBase(filePath);
-            // Check if file exists at the resolved path
+        // SECURITY: Validate key format first
+        this.validateKeyFormat(key);
+        // New keys include the basePath and resolve from cwd; old keys are relative to basePath.
+        // Only candidates inside the base directory are ever touched.
+        const candidates = [
+            external_path_.resolve(key),
+            external_path_.join(this.basePath, key)
+        ].filter((candidate)=>this.isWithinBase(candidate) && external_path_.resolve(candidate) !== this.basePath);
+        if (!candidates.length) this.throwTraversal();
+        for (const candidate of candidates){
             try {
-                await __rspack_external_fs_promises_e1851c9c.access(filePath);
+                await __rspack_external_fs_promises_e1851c9c.access(candidate);
             } catch  {
-                // Fallback: try with basePath prefix (for old keys without basePath)
-                const fallbackPath = external_path_.join(this.basePath, key);
-                // SECURITY: Validate fallback path as well
-                this.validatePathWithinBase(fallbackPath);
-                try {
-                    await __rspack_external_fs_promises_e1851c9c.access(fallbackPath);
-                    filePath = fallbackPath;
-                } catch  {
-                    // File doesn't exist at either location - silent return
-                    return;
-                }
+                continue;
             }
-            await __rspack_external_fs_promises_e1851c9c.unlink(filePath);
-        } catch (error) {
-            // Re-throw security errors
-            if (error instanceof Error && error.message.includes('Invalid')) {
-                throw error;
+            try {
+                await __rspack_external_fs_promises_e1851c9c.unlink(candidate);
+            } catch  {
+            // Silent failure - the file may have been removed concurrently
             }
-        // Silent failure for other errors
+            return;
         }
     }
     async deleteMultipleFiles(keys) {
@@ -217,7 +213,7 @@ var external_uuid_ = __webpack_require__(37);
 
 
 },
-872(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+1872(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -230,6 +226,10 @@ __webpack_require__.d(__webpack_exports__, {
 
 // Handle ESM/CJS interop - sharp exports differently in each module system
 const sharp = __rspack_external_sharp["default"] || __rspack_external_sharp;
+const MULTI_FRAME_FORMATS = [
+    'gif',
+    'webp'
+];
 /**
  * Image Compression Utility
  * Handles image compression and format conversion using sharp
@@ -247,87 +247,87 @@ const sharp = __rspack_external_sharp["default"] || __rspack_external_sharp;
                 format: mimetype
             };
         }
-        // Initialize sharp with improved error handling
-        const image = sharp(buffer, {
-            failOnError: false,
-            density: 300
-        });
-        // Apply initial resize
-        image.resize({
-            width: maxWidth,
-            height: maxHeight,
-            fit: 'inside',
-            withoutEnlargement: true
-        });
-        // Determine target format
-        let targetFormat = format !== 'original' ? format : mimetype.split('/')[1];
-        // Format-specific optimizations
-        switch(targetFormat.toLowerCase()){
-            case 'jpeg':
-            case 'jpg':
-                image.jpeg({
-                    quality,
-                    mozjpeg: true,
-                    chromaSubsampling: '4:4:4'
-                });
-                break;
-            case 'png':
-                image.png({
-                    compressionLevel: 9,
-                    adaptiveFiltering: true,
-                    palette: true,
-                    quality,
-                    colors: 256,
-                    dither: 1.0
-                });
-                break;
-            case 'webp':
-                image.webp({
-                    quality,
-                    smartSubsample: true,
-                    effort: 6,
-                    lossless: quality === 100
-                });
-                break;
-            case 'avif':
-                image.avif({
-                    quality,
-                    effort: 6,
-                    chromaSubsampling: '4:4:4'
-                });
-                break;
-            case 'tiff':
-                image.tiff({
-                    quality,
-                    compression: 'lzw',
-                    predictor: 'horizontal',
-                    pyramid: true
-                });
-                break;
-            case 'gif':
-                image.gif({
-                    colours: 256,
-                    effort: 10,
-                    dither: 1
-                });
-                break;
-            case 'jp2':
-                image.jp2({
-                    quality,
-                    lossless: quality === 100
-                });
-                break;
-            default:
-                // Fallback to WebP for best compression/quality ratio
-                targetFormat = 'webp';
-                image.webp({
-                    quality,
-                    smartSubsample: true,
-                    effort: 6
-                });
-                break;
-        }
+        let targetFormat = (format !== 'original' ? format : mimetype.split('/')[1]).toLowerCase();
         try {
+            // Read every frame only when the output can hold them - a multi-page JPEG/PNG would be one tall strip
+            const image = sharp(buffer, {
+                failOnError: false,
+                density: 300,
+                animated: MULTI_FRAME_FORMATS.includes(targetFormat)
+            });
+            // Apply initial resize
+            image.resize({
+                width: maxWidth,
+                height: maxHeight,
+                fit: 'inside',
+                withoutEnlargement: true
+            });
+            // Format-specific optimizations
+            switch(targetFormat){
+                case 'jpeg':
+                case 'jpg':
+                    image.jpeg({
+                        quality,
+                        mozjpeg: true,
+                        chromaSubsampling: '4:4:4'
+                    });
+                    break;
+                case 'png':
+                    image.png({
+                        compressionLevel: 9,
+                        adaptiveFiltering: true,
+                        palette: true,
+                        quality,
+                        colors: 256,
+                        dither: 1.0
+                    });
+                    break;
+                case 'webp':
+                    image.webp({
+                        quality,
+                        smartSubsample: true,
+                        effort: 6,
+                        lossless: quality === 100
+                    });
+                    break;
+                case 'avif':
+                    image.avif({
+                        quality,
+                        effort: 6,
+                        chromaSubsampling: '4:4:4'
+                    });
+                    break;
+                case 'tiff':
+                    image.tiff({
+                        quality,
+                        compression: 'lzw',
+                        predictor: 'horizontal',
+                        pyramid: true
+                    });
+                    break;
+                case 'gif':
+                    image.gif({
+                        colours: 256,
+                        effort: 10,
+                        dither: 1
+                    });
+                    break;
+                case 'jp2':
+                    image.jp2({
+                        quality,
+                        lossless: quality === 100
+                    });
+                    break;
+                default:
+                    // Fallback to WebP for best compression/quality ratio
+                    targetFormat = 'webp';
+                    image.webp({
+                        quality,
+                        smartSubsample: true,
+                        effort: 6
+                    });
+                    break;
+            }
             const compressedBuffer = await image.toBuffer();
             return {
                 buffer: compressedBuffer,
@@ -343,12 +343,6 @@ const sharp = __rspack_external_sharp["default"] || __rspack_external_sharp;
 }
 
 
-},
-521(module) {
-
-module.exports = __rspack_external_path;
-
-
 },
 37(module) {
 
@@ -364,7 +358,7 @@ import * as __rspack_chunk_1 from '../493.js';
 __webpack_require__.C(__rspack_chunk_1);
 import * as __rspack_chunk_2 from './index.js';
 __webpack_require__.C(__rspack_chunk_2);
-var __webpack_exports__ = __webpack_exec__(922);var __webpack_exports__LocalProvider = __webpack_exports__.TZ;
+var __webpack_exports__ = __webpack_exec__(1922);var __webpack_exports__LocalProvider = __webpack_exports__.TZ;
 var __webpack_exports__StorageFactoryService = __webpack_exports__.Lk;
 var __webpack_exports__StorageProviderRegistry = __webpack_exports__.CG;
 export { __webpack_exports__LocalProvider as LocalProvider, __webpack_exports__StorageFactoryService as StorageFactoryService, __webpack_exports__StorageProviderRegistry as StorageProviderRegistry };

package/fesm/services/index.js

@@ -7,7 +7,7 @@ import * as __rspack_chunk_1 from '../493.js';
 __webpack_require__.C(__rspack_chunk_1);
 import * as __rspack_chunk_2 from './index.js';
 __webpack_require__.C(__rspack_chunk_2);
-var __webpack_exports__ = __webpack_exec__(148);var __webpack_exports__FileManagerService = __webpack_exports__.DL;
+var __webpack_exports__ = __webpack_exec__(4148);var __webpack_exports__FileManagerService = __webpack_exports__.DL;
 var __webpack_exports__FolderService = __webpack_exports__.kh;
 var __webpack_exports__StorageConfigService = __webpack_exports__.tP;
 var __webpack_exports__StorageDataSourceProvider = __webpack_exports__.M0;

package/fesm/utils/index.js

@@ -2,7 +2,7 @@ import * as __rspack_external_sharp from "sharp";
 export const __rspack_esm_id = 152;
 export const __rspack_esm_ids = [152];
 export const __webpack_modules__ = {
-872(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+1872(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -15,6 +15,10 @@ __webpack_require__.d(__webpack_exports__, {
 
 // Handle ESM/CJS interop - sharp exports differently in each module system
 const sharp = __rspack_external_sharp["default"] || __rspack_external_sharp;
+const MULTI_FRAME_FORMATS = [
+    'gif',
+    'webp'
+];
 /**
  * Image Compression Utility
  * Handles image compression and format conversion using sharp
@@ -32,87 +36,87 @@ const sharp = __rspack_external_sharp["default"] || __rspack_external_sharp;
                 format: mimetype
             };
         }
-        // Initialize sharp with improved error handling
-        const image = sharp(buffer, {
-            failOnError: false,
-            density: 300
-        });
-        // Apply initial resize
-        image.resize({
-            width: maxWidth,
-            height: maxHeight,
-            fit: 'inside',
-            withoutEnlargement: true
-        });
-        // Determine target format
-        let targetFormat = format !== 'original' ? format : mimetype.split('/')[1];
-        // Format-specific optimizations
-        switch(targetFormat.toLowerCase()){
-            case 'jpeg':
-            case 'jpg':
-                image.jpeg({
-                    quality,
-                    mozjpeg: true,
-                    chromaSubsampling: '4:4:4'
-                });
-                break;
-            case 'png':
-                image.png({
-                    compressionLevel: 9,
-                    adaptiveFiltering: true,
-                    palette: true,
-                    quality,
-                    colors: 256,
-                    dither: 1.0
-                });
-                break;
-            case 'webp':
-                image.webp({
-                    quality,
-                    smartSubsample: true,
-                    effort: 6,
-                    lossless: quality === 100
-                });
-                break;
-            case 'avif':
-                image.avif({
-                    quality,
-                    effort: 6,
-                    chromaSubsampling: '4:4:4'
-                });
-                break;
-            case 'tiff':
-                image.tiff({
-                    quality,
-                    compression: 'lzw',
-                    predictor: 'horizontal',
-                    pyramid: true
-                });
-                break;
-            case 'gif':
-                image.gif({
-                    colours: 256,
-                    effort: 10,
-                    dither: 1
-                });
-                break;
-            case 'jp2':
-                image.jp2({
-                    quality,
-                    lossless: quality === 100
-                });
-                break;
-            default:
-                // Fallback to WebP for best compression/quality ratio
-                targetFormat = 'webp';
-                image.webp({
-                    quality,
-                    smartSubsample: true,
-                    effort: 6
-                });
-                break;
-        }
+        let targetFormat = (format !== 'original' ? format : mimetype.split('/')[1]).toLowerCase();
         try {
+            // Read every frame only when the output can hold them - a multi-page JPEG/PNG would be one tall strip
+            const image = sharp(buffer, {
+                failOnError: false,
+                density: 300,
+                animated: MULTI_FRAME_FORMATS.includes(targetFormat)
+            });
+            // Apply initial resize
+            image.resize({
+                width: maxWidth,
+                height: maxHeight,
+                fit: 'inside',
+                withoutEnlargement: true
+            });
+            // Format-specific optimizations
+            switch(targetFormat){
+                case 'jpeg':
+                case 'jpg':
+                    image.jpeg({
+                        quality,
+                        mozjpeg: true,
+                        chromaSubsampling: '4:4:4'
+                    });
+                    break;
+                case 'png':
+                    image.png({
+                        compressionLevel: 9,
+                        adaptiveFiltering: true,
+                        palette: true,
+                        quality,
+                        colors: 256,
+                        dither: 1.0
+                    });
+                    break;
+                case 'webp':
+                    image.webp({
+                        quality,
+                        smartSubsample: true,
+                        effort: 6,
+                        lossless: quality === 100
+                    });
+                    break;
+                case 'avif':
+                    image.avif({
+                        quality,
+                        effort: 6,
+                        chromaSubsampling: '4:4:4'
+                    });
+                    break;
+                case 'tiff':
+                    image.tiff({
+                        quality,
+                        compression: 'lzw',
+                        predictor: 'horizontal',
+                        pyramid: true
+                    });
+                    break;
+                case 'gif':
+                    image.gif({
+                        colours: 256,
+                        effort: 10,
+                        dither: 1
+                    });
+                    break;
+                case 'jp2':
+                    image.jp2({
+                        quality,
+                        lossless: quality === 100
+                    });
+                    break;
+                default:
+                    // Fallback to WebP for best compression/quality ratio
+                    targetFormat = 'webp';
+                    image.webp({
+                        quality,
+                        smartSubsample: true,
+                        effort: 6
+                    });
+                    break;
+            }
             const compressedBuffer = await image.toBuffer();
             return {
                 buffer: compressedBuffer,
@@ -129,8 +133,8 @@ const sharp = __rspack_external_sharp["default"] || __rspack_external_sharp;
 
 
 },
-857(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/* import */ var _image_compressor_util_js__rspack_import_0 = __webpack_require__(872);
+8857(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _image_compressor_util_js__rspack_import_0 = __webpack_require__(1872);
 
 
 __webpack_require__.d(__webpack_exports__, {
@@ -145,5 +149,5 @@ import { __webpack_require__ } from '../runtime.js';
 var __webpack_exec__ = function(moduleId) { return __webpack_require__(__webpack_require__.s = moduleId); }
 import * as __rspack_chunk_1 from './index.js';
 __webpack_require__.C(__rspack_chunk_1);
-var __webpack_exports__ = __webpack_exec__(857);var __webpack_exports__ImageCompressor = __webpack_exports__.J;
+var __webpack_exports__ = __webpack_exec__(8857);var __webpack_exports__ImageCompressor = __webpack_exports__.J;
 export { __webpack_exports__ImageCompressor as ImageCompressor };

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

@@ -9,7 +9,9 @@ export declare class FileServeMiddleware implements NestMiddleware {
     private serveFile;
     private extractFilePath;
     private resolveFilePath;
-    private tryFallbackPaths;
+    private findInStorageRoot;
+    private isWithin;
+    private fallbackPaths;
     private getMimeType;
     private setResponseHeaders;
     private streamFile;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-storage",
-  "version": "9.1.2",
+  "version": "9.2.0",
   "description": "Modular storage package with optional AWS S3, Azure Blob, and SFTP providers",
   "type": "module",
   "main": "./fesm/index.js",
@@ -118,7 +118,7 @@
     }
   },
   "dependencies": {
-    "@flusys/nestjs-core": "9.1.2",
-    "@flusys/nestjs-shared": "9.1.2"
+    "@flusys/nestjs-core": "9.2.0",
+    "@flusys/nestjs-shared": "9.2.0"
   }
 }

package/providers/local-provider.d.ts

@@ -4,7 +4,9 @@ export declare class LocalProvider implements IStorageProvider {
     private basePath;
     private baseUrl;
     private relativeBasePath;
+    private isWithinBase;
     private validatePathWithinBase;
+    private throwTraversal;
     private validateKeyFormat;
     initialize(config: {
         basePath?: string;

package/providers/sftp-provider.optional.d.ts

@@ -17,6 +17,7 @@ export declare class SftpProvider implements IStorageProvider {
     uploadFile(file: Express.Multer.File, options: UploadOptionsDto): Promise<IUploadedFileInfo>;
     uploadMultipleFiles(files: Express.Multer.File[], options: UploadOptionsDto): Promise<IUploadedFileInfo[]>;
     deleteFile(key: string): Promise<void>;
+    private resolveWithinBasePath;
     deleteMultipleFiles(keys: string[]): Promise<void>;
     generatePresignedUrl(key: string, _expiresInSeconds?: number): Promise<string>;
     healthCheck(): Promise<boolean>;

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

@@ -7,9 +7,11 @@ export declare class StorageFactoryService implements OnModuleDestroy {
     constructor(configService: StorageConfigService);
     createProvider(config: IStorageProviderConfig): Promise<IStorageProvider>;
     getProvider(providerName: string): Promise<IStorageProvider>;
-    getLocalProviderBasePath(): string | null;
-    clearCache(): void;
+    clearCache(): Promise<void>;
     onModuleDestroy(): Promise<void>;
+    private instantiate;
+    private evict;
+    private closeEntry;
     private generateCacheKey;
     private initializeProvider;
 }

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

@@ -1,5 +1,5 @@
 import { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
-import { DeleteDto, FilterAndPaginationDto } from '@flusys/nestjs-shared/dtos';
+import { DeleteDto } from '@flusys/nestjs-shared/dtos';
 import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { SharedPermissionCacheService, UtilsService } from '@flusys/nestjs-shared/modules';
 import { type QueryRunner, SelectQueryBuilder } from 'typeorm';
@@ -17,8 +17,9 @@ export declare class FileManagerService extends ApiService<CreateFileManagerDto,
     private readonly dataSourceProvider;
     private readonly permissionCacheService;
     constructor(cacheManager: HybridCache, utilsService: UtilsService, uploadService: UploadService, storageConfig: StorageConfigService, dataSourceProvider: StorageDataSourceProvider, permissionCacheService: SharedPermissionCacheService);
+    protected cacheDependencies(): string[];
     convertSingleDtoToEntity(dto: CreateFileManagerDto | UpdateFileManagerDto, user: ILoggedUserInfo | null): Promise<FileManagerBase>;
-    getSelectQuery(query: SelectQueryBuilder<FileManagerBase>, _user: ILoggedUserInfo | null, select?: string[]): Promise<{
+    getSelectQuery(query: SelectQueryBuilder<FileManagerBase>, user: ILoggedUserInfo | null, select?: string[]): Promise<{
         query: SelectQueryBuilder<FileManager>;
         isRaw: boolean;
     }>;
@@ -26,13 +27,11 @@ export declare class FileManagerService extends ApiService<CreateFileManagerDto,
         query: SelectQueryBuilder<FileManagerBase>;
         isRaw: boolean;
     }>;
-    protected getExtraManipulateQuery(query: SelectQueryBuilder<FileManagerBase>, filterDto: FilterAndPaginationDto, user: ILoggedUserInfo | null): Promise<{
-        query: SelectQueryBuilder<FileManagerBase>;
-        isRaw: boolean;
-    }>;
+    protected beforeUpdateOperation(dto: UpdateFileManagerDto | UpdateFileManagerDto[], user: ILoggedUserInfo | null): Promise<void>;
     beforeDeleteOperation(dto: DeleteDto, user: ILoggedUserInfo | null, _qr: QueryRunner): Promise<void>;
     getFiles(dtos: GetFilesRequestDto[], protocol: string, host: string, user?: ILoggedUserInfo): Promise<FilesResponseDto[]>;
     private buildWhereWithCompany;
+    private assertInUserCompany;
     private getStorageConfigRepository;
     private getStorageConfigBasePath;
     private validateFolder;

package/services/folder.service.d.ts

@@ -1,4 +1,5 @@
 import { HybridCache, ApiService } from '@flusys/nestjs-shared/classes';
+import { DeleteDto } from '@flusys/nestjs-shared/dtos';
 import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
 import { SelectQueryBuilder } from 'typeorm';
@@ -13,12 +14,11 @@ export declare class FolderService extends ApiService<CreateFolderDto, UpdateFol
     private readonly storageConfig;
     constructor(cacheManager: HybridCache, utilsService: UtilsService, storageConfig: StorageConfigService, dataSourceProvider: StorageDataSourceProvider);
     convertSingleDtoToEntity(dto: CreateFolderDto | UpdateFolderDto, user: ILoggedUserInfo | null): Promise<FolderBase>;
-    getSelectQuery(query: SelectQueryBuilder<FolderBase>, _user: ILoggedUserInfo | null, select?: string[]): Promise<{
-        query: SelectQueryBuilder<Folder>;
-        isRaw: boolean;
-    }>;
-    protected getExtraManipulateQuery(query: SelectQueryBuilder<FolderBase>, filterDto: any, user: ILoggedUserInfo | null): Promise<{
+    getSelectQuery(query: SelectQueryBuilder<FolderBase>, user: ILoggedUserInfo | null, select?: string[]): Promise<{
         query: SelectQueryBuilder<Folder>;
         isRaw: boolean;
     }>;
+    protected beforeUpdateOperation(dto: UpdateFolderDto | UpdateFolderDto[], user: ILoggedUserInfo | null): Promise<void>;
+    protected beforeDeleteOperation(dto: DeleteDto, user: ILoggedUserInfo | null): Promise<void>;
+    private assertInUserCompany;
 }