@flusys/nestjs-storage 7.0.2 → 8.0.0-beta.1

package/fesm/services/file-manager.service.spec.js

@@ -1,576 +0,0 @@
-import { Test } from '@nestjs/testing';
-import { SharedPermissionCacheService, UtilsService } from '@flusys/nestjs-shared/modules';
-import { createMockRepository } from '@test-utils/mocks/repository.mock';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { FileManagerService } from './file-manager.service';
-import { StorageConfigService } from './storage-config.service';
-import { StorageDataSourceProvider } from './storage-datasource.provider';
-import { UploadService } from './upload.service';
-import { FileManager, FileManagerWithCompany, Folder, FolderWithCompany, StorageConfig, StorageConfigWithCompany } from '../entities';
-import { FileLocationEnum } from '../enums/file-location.enum';
-function buildFile(overrides = {}) {
-    return {
-        id: 'file-uuid-1',
-        name: 'photo.jpg',
-        contentType: 'image/jpeg',
-        size: '1024',
-        key: 'uploads/photo.jpg',
-        url: null,
-        location: FileLocationEnum.LOCAL,
-        storageConfigId: null,
-        expiresAt: null,
-        isPrivate: false,
-        folder: null,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        deletedAt: null,
-        createdById: null,
-        updatedById: null,
-        deletedById: null,
-        ...overrides
-    };
-}
-describe('FileManagerService', ()=>{
-    let service;
-    let module;
-    let mockFileRepo;
-    let mockFolderRepo;
-    let mockStorageConfigRepo;
-    let mockStorageConfig;
-    let mockUploadService;
-    let mockCacheManager;
-    let mockSharedPermissionCacheService;
-    const mockUtilsService = {
-        clearCache: jest.fn(),
-        getCacheKey: jest.fn().mockReturnValue('cache-key'),
-        trackCacheKey: jest.fn()
-    };
-    // Call history is shared across tests in this file; reset it so each cache assertion is exact.
-    beforeEach(()=>{
-        mockUtilsService.clearCache.mockClear();
-    });
-    beforeEach(async ()=>{
-        mockFileRepo = createMockRepository();
-        mockFileRepo.findBy = jest.fn();
-        mockFolderRepo = createMockRepository();
-        mockStorageConfigRepo = createMockRepository();
-        const mockDataSourceProvider = {
-            getRepository: jest.fn((entity)=>{
-                if (entity === Folder || entity === FolderWithCompany) {
-                    return Promise.resolve(mockFolderRepo);
-                }
-                if (entity === StorageConfig || entity === StorageConfigWithCompany) {
-                    return Promise.resolve(mockStorageConfigRepo);
-                }
-                return Promise.resolve(mockFileRepo);
-            }),
-            getDataSource: jest.fn()
-        };
-        mockStorageConfig = {
-            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false),
-            getAppUrl: jest.fn().mockReturnValue('http://localhost:2002')
-        };
-        mockUploadService = {
-            deleteMultipleFile: jest.fn().mockResolvedValue(true),
-            makeFileUrl: jest.fn().mockResolvedValue('https://signed.example.com/photo.jpg')
-        };
-        mockCacheManager = {
-            get: jest.fn(),
-            set: jest.fn()
-        };
-        mockSharedPermissionCacheService = {
-            hasPermission: jest.fn().mockResolvedValue(false)
-        };
-        module = await Test.createTestingModule({
-            providers: [
-                FileManagerService,
-                {
-                    provide: 'CACHE_INSTANCE',
-                    useValue: mockCacheManager
-                },
-                {
-                    provide: UtilsService,
-                    useValue: mockUtilsService
-                },
-                {
-                    provide: UploadService,
-                    useValue: mockUploadService
-                },
-                {
-                    provide: StorageConfigService,
-                    useValue: mockStorageConfig
-                },
-                {
-                    provide: StorageDataSourceProvider,
-                    useValue: mockDataSourceProvider
-                },
-                {
-                    provide: SharedPermissionCacheService,
-                    useValue: mockSharedPermissionCacheService
-                }
-            ]
-        }).compile();
-        service = await module.resolve(FileManagerService);
-        await service.ensureDataSourceRepository();
-    });
-    describe('entity selection', ()=>{
-        it('uses FileManager when the company feature is disabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(false);
-            const built = await module.resolve(FileManagerService);
-            expect(built['_entity']).toBe(FileManager);
-        });
-        it('uses FileManagerWithCompany when the company feature is enabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const built = await module.resolve(FileManagerService);
-            expect(built['_entity']).toBe(FileManagerWithCompany);
-        });
-    });
-    describe('convertSingleDtoToEntity', ()=>{
-        it('creates a new entity with location LOCAL by default when no folder/storageConfig given', async ()=>{
-            const entity = await service.convertSingleDtoToEntity({
-                name: 'a.jpg',
-                key: 'k',
-                size: '10',
-                contentType: 'image/jpeg',
-                isPrivate: false
-            }, buildMockUser());
-            expect(entity.location).toBe(FileLocationEnum.LOCAL);
-            expect(entity.folder).toBeNull();
-        });
-        it('preserves an explicitly provided location when no storageConfigId is given', async ()=>{
-            const entity = await service.convertSingleDtoToEntity({
-                name: 'a.jpg',
-                key: 'k',
-                size: '10',
-                contentType: 'image/jpeg',
-                isPrivate: false,
-                location: FileLocationEnum.AWS
-            }, buildMockUser());
-            expect(entity.location).toBe(FileLocationEnum.AWS);
-        });
-        it('resolves the storage location from the referenced storage config', async ()=>{
-            mockStorageConfigRepo.findOne.mockResolvedValue({
-                id: 'cfg-1',
-                storage: 'aws'
-            });
-            const entity = await service.convertSingleDtoToEntity({
-                name: 'a.jpg',
-                key: 'k',
-                size: '10',
-                contentType: 'image/jpeg',
-                isPrivate: false,
-                storageConfigId: 'cfg-1'
-            }, buildMockUser());
-            expect(entity.location).toBe('aws');
-        });
-        it('falls back to dto.location when the storage config lookup throws', async ()=>{
-            mockStorageConfigRepo.findOne.mockRejectedValue(new Error('db down'));
-            const entity = await service.convertSingleDtoToEntity({
-                name: 'a.jpg',
-                key: 'k',
-                size: '10',
-                contentType: 'image/jpeg',
-                isPrivate: false,
-                storageConfigId: 'cfg-1',
-                location: FileLocationEnum.AZURE
-            }, buildMockUser());
-            expect(entity.location).toBe(FileLocationEnum.AZURE);
-        });
-        it('attaches the validated folder when folderId is provided', async ()=>{
-            const folder = {
-                id: 'folder-1',
-                name: 'Docs'
-            };
-            mockFolderRepo.findOne.mockResolvedValue(folder);
-            const entity = await service.convertSingleDtoToEntity({
-                name: 'a.jpg',
-                key: 'k',
-                size: '10',
-                contentType: 'image/jpeg',
-                isPrivate: false,
-                folderId: 'folder-1'
-            }, buildMockUser());
-            expect(entity.folder).toEqual(folder);
-        });
-        it('throws BadRequestException when the referenced folder does not exist or access is denied', async ()=>{
-            mockFolderRepo.findOne.mockResolvedValue(null);
-            await expect(service.convertSingleDtoToEntity({
-                name: 'a.jpg',
-                key: 'k',
-                size: '10',
-                contentType: 'image/jpeg',
-                isPrivate: false,
-                folderId: 'missing-folder'
-            }, buildMockUser())).rejects.toThrow();
-        });
-        it('scopes folder lookup by companyId when company feature is enabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            mockFolderRepo.findOne.mockResolvedValue({
-                id: 'folder-1'
-            });
-            await service.convertSingleDtoToEntity({
-                name: 'a.jpg',
-                key: 'k',
-                size: '10',
-                contentType: 'image/jpeg',
-                isPrivate: false,
-                folderId: 'folder-1'
-            }, buildMockUser({
-                companyId: 'company-9'
-            }));
-            expect(mockFolderRepo.findOne).toHaveBeenCalledWith({
-                where: {
-                    id: 'folder-1',
-                    companyId: 'company-9'
-                }
-            });
-        });
-        it('attaches companyId to the entity when company feature is enabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const entity = await service.convertSingleDtoToEntity({
-                name: 'a.jpg',
-                key: 'k',
-                size: '10',
-                contentType: 'image/jpeg',
-                isPrivate: false
-            }, buildMockUser({
-                companyId: 'company-9'
-            }));
-            expect(entity.companyId).toBe('company-9');
-        });
-        it('loads and merges the existing entity when updating (dto has an id)', async ()=>{
-            const existing = buildFile({
-                id: 'file-1',
-                name: 'old.jpg'
-            });
-            mockFileRepo.findOne.mockResolvedValue(existing);
-            const entity = await service.convertSingleDtoToEntity({
-                id: 'file-1',
-                name: 'new.jpg'
-            }, buildMockUser());
-            expect(entity.name).toBe('new.jpg');
-        });
-        it('throws NotFoundException when updating a file that does not exist', async ()=>{
-            mockFileRepo.findOne.mockResolvedValue(null);
-            await expect(service.convertSingleDtoToEntity({
-                id: 'missing-id',
-                name: 'x'
-            }, buildMockUser())).rejects.toThrow();
-        });
-    });
-    describe('getSelectQuery', ()=>{
-        it('selects the default field set and left-joins the folder relation', async ()=>{
-            const query = {
-                select: jest.fn().mockReturnThis(),
-                leftJoinAndSelect: jest.fn().mockReturnThis()
-            };
-            await service.getSelectQuery(query, buildMockUser());
-            expect(query.leftJoinAndSelect).toHaveBeenCalledWith('file_manager.folder', 'folder');
-            const selectArg = query.select.mock.calls[0][0];
-            expect(selectArg).toEqual(expect.arrayContaining([
-                'file_manager.id',
-                'file_manager.name',
-                'file_manager.key',
-                'folder.id',
-                'folder.name'
-            ]));
-        });
-        it('appends companyId to the field set when company feature is enabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const query = {
-                select: jest.fn().mockReturnThis(),
-                leftJoinAndSelect: jest.fn().mockReturnThis()
-            };
-            await service.getSelectQuery(query, buildMockUser());
-            const selectArg = query.select.mock.calls[0][0];
-            expect(selectArg).toContain('file_manager.companyId');
-        });
-        it('uses a custom select list when explicitly provided', async ()=>{
-            const query = {
-                select: jest.fn().mockReturnThis(),
-                leftJoinAndSelect: jest.fn().mockReturnThis()
-            };
-            await service.getSelectQuery(query, buildMockUser(), [
-                'id',
-                'name'
-            ]);
-            const selectArg = query.select.mock.calls[0][0];
-            expect(selectArg).toEqual(expect.arrayContaining([
-                'file_manager.id',
-                'file_manager.name'
-            ]));
-        });
-    });
-    describe('getFilterQuery', ()=>{
-        it('applies a LIKE-based bracket filter for contentType with wildcard support', async ()=>{
-            const query = {
-                where: jest.fn().mockReturnThis(),
-                andWhere: jest.fn().mockReturnThis()
-            };
-            await service.getFilterQuery(query, {
-                contentType: 'image/*,application/pdf'
-            }, buildMockUser());
-            expect(query.where).toHaveBeenCalled();
-        });
-        it('applies a plain equality filter for non-contentType fields', async ()=>{
-            const query = {
-                where: jest.fn().mockReturnThis(),
-                andWhere: jest.fn().mockReturnThis()
-            };
-            await service.getFilterQuery(query, {
-                isPrivate: true
-            }, buildMockUser());
-            expect(query.andWhere).toHaveBeenCalledWith('file_manager.isPrivate = :value', {
-                value: true
-            });
-        });
-    });
-    describe('getExtraManipulateQuery', ()=>{
-        it('applies the company filter when company feature is enabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const query = {
-                andWhere: jest.fn().mockReturnThis()
-            };
-            await service.getExtraManipulateQuery(query, {}, buildMockUser({
-                companyId: 'company-3'
-            }));
-            expect(query.andWhere).toHaveBeenCalledWith('file_manager.companyId = :companyId', {
-                companyId: 'company-3'
-            });
-        });
-        it('hides private files from anonymous (unauthenticated) requests', async ()=>{
-            const query = {
-                andWhere: jest.fn().mockReturnThis()
-            };
-            await service.getExtraManipulateQuery(query, {}, null);
-            expect(query.andWhere).toHaveBeenCalledWith('file_manager.isPrivate = :isPrivate', {
-                isPrivate: false
-            });
-        });
-        it('hides private files from an authenticated user lacking the viewPrivate permission', async ()=>{
-            mockSharedPermissionCacheService.hasPermission.mockResolvedValue(false);
-            const query = {
-                andWhere: jest.fn().mockReturnThis()
-            };
-            await service.getExtraManipulateQuery(query, {}, buildMockUser());
-            expect(query.andWhere).toHaveBeenCalledWith('file_manager.isPrivate = :isPrivate', {
-                isPrivate: false
-            });
-        });
-        it('does not restrict private files for a user holding the viewPrivate permission', async ()=>{
-            mockSharedPermissionCacheService.hasPermission.mockResolvedValue(true);
-            const query = {
-                andWhere: jest.fn().mockReturnThis()
-            };
-            await service.getExtraManipulateQuery(query, {}, buildMockUser());
-            expect(query.andWhere).not.toHaveBeenCalledWith('file_manager.isPrivate = :isPrivate', expect.anything());
-        });
-    });
-    describe('beforeDeleteOperation', ()=>{
-        it('does nothing for a soft delete (type=delete)', async ()=>{
-            await service.beforeDeleteOperation({
-                id: [
-                    'file-1'
-                ],
-                type: 'delete'
-            }, buildMockUser(), {});
-            expect(mockUploadService.deleteMultipleFile).not.toHaveBeenCalled();
-        });
-        it('deletes underlying storage objects when permanently deleting files', async ()=>{
-            const file = buildFile({
-                id: 'file-1',
-                key: 'uploads/photo.jpg',
-                storageConfigId: null,
-                location: FileLocationEnum.LOCAL
-            });
-            mockFileRepo.findBy.mockResolvedValue([
-                file
-            ]);
-            await service.beforeDeleteOperation({
-                id: [
-                    'file-1'
-                ],
-                type: 'permanent'
-            }, buildMockUser(), {});
-            expect(mockUploadService.deleteMultipleFile).toHaveBeenCalledWith([
-                'uploads/photo.jpg'
-            ], undefined, buildMockUser(), FileLocationEnum.LOCAL);
-        });
-        it('groups files by storageConfigId before issuing delete calls', async ()=>{
-            const fileA = buildFile({
-                id: 'a',
-                key: 'a.jpg',
-                storageConfigId: 'cfg-1',
-                location: FileLocationEnum.AWS
-            });
-            const fileB = buildFile({
-                id: 'b',
-                key: 'b.jpg',
-                storageConfigId: 'cfg-2',
-                location: FileLocationEnum.AZURE
-            });
-            mockFileRepo.findBy.mockResolvedValue([
-                fileA,
-                fileB
-            ]);
-            await service.beforeDeleteOperation({
-                id: [
-                    'a',
-                    'b'
-                ],
-                type: 'permanent'
-            }, buildMockUser(), {});
-            expect(mockUploadService.deleteMultipleFile).toHaveBeenCalledTimes(2);
-            expect(mockUploadService.deleteMultipleFile).toHaveBeenCalledWith([
-                'a.jpg'
-            ], 'cfg-1', buildMockUser(), FileLocationEnum.AWS);
-            expect(mockUploadService.deleteMultipleFile).toHaveBeenCalledWith([
-                'b.jpg'
-            ], 'cfg-2', buildMockUser(), FileLocationEnum.AZURE);
-        });
-        it('prefixes local keys with the resolved storage config basePath when not already nested', async ()=>{
-            const file = buildFile({
-                id: 'a',
-                key: 'plain-key.jpg',
-                storageConfigId: 'cfg-1',
-                location: FileLocationEnum.LOCAL
-            });
-            mockFileRepo.findBy.mockResolvedValue([
-                file
-            ]);
-            mockStorageConfigRepo.findOne.mockResolvedValue({
-                id: 'cfg-1',
-                config: {
-                    basePath: './custom-uploads'
-                }
-            });
-            await service.beforeDeleteOperation({
-                id: [
-                    'a'
-                ],
-                type: 'permanent'
-            }, buildMockUser(), {});
-            expect(mockUploadService.deleteMultipleFile).toHaveBeenCalledWith([
-                'custom-uploads/plain-key.jpg'
-            ], 'cfg-1', buildMockUser(), FileLocationEnum.LOCAL);
-        });
-    });
-    describe('getFiles', ()=>{
-        it('throws BadRequestException when no valid file ids are provided', async ()=>{
-            await expect(service.getFiles([], 'http', 'localhost:2002')).rejects.toThrow();
-        });
-        it('throws BadRequestException when all provided ids are falsy', async ()=>{
-            await expect(service.getFiles([
-                {
-                    id: ''
-                },
-                {
-                    id: undefined
-                }
-            ], 'http', 'localhost:2002')).rejects.toThrow();
-        });
-        it('returns file metadata for the requested ids', async ()=>{
-            const file = buildFile({
-                id: 'file-1',
-                url: 'http://localhost:2002/storage/upload/file/uploads/photo.jpg'
-            });
-            mockFileRepo.findBy.mockResolvedValue([
-                file
-            ]);
-            const result = await service.getFiles([
-                {
-                    id: 'file-1'
-                }
-            ], 'http', 'localhost:2002');
-            expect(result).toHaveLength(1);
-            expect(result[0].id).toBe('file-1');
-            expect(result[0].name).toBe('photo.jpg');
-        });
-        it('refreshes and persists file URLs that changed during the request', async ()=>{
-            const file = buildFile({
-                id: 'file-1',
-                url: null,
-                storageConfigId: 'cfg-1'
-            });
-            mockFileRepo.findBy.mockResolvedValue([
-                file
-            ]);
-            mockUploadService.makeFileUrl.mockResolvedValue('https://cdn.example.com/photo.jpg');
-            await service.getFiles([
-                {
-                    id: 'file-1'
-                }
-            ], 'http', 'localhost:2002');
-            expect(mockFileRepo.save).toHaveBeenCalled();
-        });
-        it('invalidates cached file responses for the files whose URL was refreshed', async ()=>{
-            const file = buildFile({
-                id: 'file-1',
-                url: null,
-                storageConfigId: 'cfg-1'
-            });
-            mockFileRepo.findBy.mockResolvedValue([
-                file
-            ]);
-            mockUploadService.makeFileUrl.mockResolvedValue('https://cdn.example.com/photo.jpg');
-            await service.getFiles([
-                {
-                    id: 'file-1'
-                }
-            ], 'http', 'localhost:2002');
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('file_manager', expect.anything());
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('file_manager', expect.anything(), 'file-1');
-        });
-        it('does not persist when no file URL needed refreshing', async ()=>{
-            const file = buildFile({
-                id: 'file-1',
-                url: 'http://localhost:2002/storage/upload/file/uploads/photo.jpg',
-                location: FileLocationEnum.LOCAL,
-                storageConfigId: null
-            });
-            mockFileRepo.findBy.mockResolvedValue([
-                file
-            ]);
-            await service.getFiles([
-                {
-                    id: 'file-1'
-                }
-            ], 'http', 'localhost:2002');
-            expect(mockFileRepo.save).not.toHaveBeenCalled();
-        });
-        it('silently continues if persisting refreshed URLs fails (non-critical)', async ()=>{
-            const file = buildFile({
-                id: 'file-1',
-                url: null,
-                storageConfigId: 'cfg-1'
-            });
-            mockFileRepo.findBy.mockResolvedValue([
-                file
-            ]);
-            mockFileRepo.save.mockRejectedValue(new Error('db write failed'));
-            await expect(service.getFiles([
-                {
-                    id: 'file-1'
-                }
-            ], 'http', 'localhost:2002')).resolves.toBeDefined();
-        });
-        it('falls back to the direct file-serve URL when makeFileUrl throws (e.g. missing storage config)', async ()=>{
-            const file = buildFile({
-                id: 'file-1',
-                url: null,
-                storageConfigId: 'cfg-missing',
-                location: FileLocationEnum.AWS
-            });
-            mockFileRepo.findBy.mockResolvedValue([
-                file
-            ]);
-            mockUploadService.makeFileUrl.mockRejectedValue(new Error('config not found'));
-            const result = await service.getFiles([
-                {
-                    id: 'file-1'
-                }
-            ], 'http', 'localhost:2002');
-            expect(result[0].url).toContain('/storage/upload/file/');
-        });
-    });
-});

package/fesm/services/folder.service.js

@@ -1,91 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.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;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { HybridCache, ApiService } from '@flusys/nestjs-shared/classes';
-import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { applyCompanyFilter } from '@flusys/nestjs-shared/utils';
-import { Inject, Injectable, Scope } from '@nestjs/common';
-import { STORAGE_EVENT_ENTITIES, STORAGE_EVENT_MODULE } from '../config';
-import { Folder, FolderWithCompany } from '../entities';
-import { StorageConfigService } from './storage-config.service';
-import { StorageDataSourceProvider } from './storage-datasource.provider';
-export class FolderService extends ApiService {
-    // ─── Override Methods ───────────────────────────────────────────────────────
-    async convertSingleDtoToEntity(dto, user) {
-        const entity = await super.convertSingleDtoToEntity(dto, user);
-        if (this.storageConfig.isCompanyFeatureEnabled()) {
-            entity.companyId = user?.companyId ?? null;
-        }
-        return entity;
-    }
-    async getSelectQuery(query, _user, select) {
-        if (!select?.length) {
-            select = [
-                'id',
-                'name',
-                'slug',
-                'createdAt',
-                'deletedAt'
-            ];
-            if (this.storageConfig.isCompanyFeatureEnabled()) {
-                select.push('companyId');
-            }
-        }
-        query.select(select.map((f)=>`${this.entityName}.${f}`));
-        return {
-            query,
-            isRaw: false
-        };
-    }
-    async getExtraManipulateQuery(query, filterDto, user) {
-        const result = await super.getExtraManipulateQuery(query, filterDto, user);
-        applyCompanyFilter(query, {
-            isCompanyFeatureEnabled: this.storageConfig.isCompanyFeatureEnabled(),
-            entityAlias: 'folder'
-        }, user);
-        return result;
-    }
-    constructor(cacheManager, utilsService, storageConfig, dataSourceProvider){
-        super(STORAGE_EVENT_ENTITIES.FOLDER, cacheManager, utilsService, FolderService.name, true, STORAGE_EVENT_MODULE, dataSourceProvider, storageConfig.isCompanyFeatureEnabled() ? FolderWithCompany : Folder), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "storageConfig", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.storageConfig = storageConfig;
-    }
-}
-FolderService = _ts_decorate([
-    Injectable({
-        scope: Scope.REQUEST
-    }),
-    _ts_param(0, Inject('CACHE_INSTANCE')),
-    _ts_param(1, Inject(UtilsService)),
-    _ts_param(2, Inject(StorageConfigService)),
-    _ts_param(3, Inject(StorageDataSourceProvider)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof HybridCache === "undefined" ? Object : HybridCache,
-        typeof UtilsService === "undefined" ? Object : UtilsService,
-        typeof StorageConfigService === "undefined" ? Object : StorageConfigService,
-        typeof StorageDataSourceProvider === "undefined" ? Object : StorageDataSourceProvider
-    ])
-], FolderService);