@flusys/nestjs-storage 6.0.1 → 6.1.0

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

@@ -0,0 +1,545 @@
+import { Test } from '@nestjs/testing';
+import { 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 mockFileRepo;
+    let mockFolderRepo;
+    let mockStorageConfigRepo;
+    let mockStorageConfig;
+    let mockUploadService;
+    let mockCacheManager;
+    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()
+        };
+        const module = await Test.createTestingModule({
+            providers: [
+                FileManagerService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: mockCacheManager
+                },
+                {
+                    provide: UtilsService,
+                    useValue: {}
+                },
+                {
+                    provide: UploadService,
+                    useValue: mockUploadService
+                },
+                {
+                    provide: StorageConfigService,
+                    useValue: mockStorageConfig
+                },
+                {
+                    provide: StorageDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                }
+            ]
+        }).compile();
+        service = await module.resolve(FileManagerService);
+        await service.ensureDataSourceRepository();
+    });
+    describe('resolveEntity', ()=>{
+        it('resolves to the core FileManager entity when company feature is disabled', ()=>{
+            expect(service.resolveEntity()).toBe(FileManager);
+        });
+        it('resolves to FileManagerWithCompany when company feature is enabled', ()=>{
+            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            expect(service.resolveEntity()).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 ()=>{
+            mockCacheManager.get.mockResolvedValue([
+                {
+                    url: 'storage.file.someOtherAction'
+                }
+            ]);
+            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 ()=>{
+            mockCacheManager.get.mockResolvedValue([
+                {
+                    url: 'storage.file.viewPrivate'
+                }
+            ]);
+            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('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/');
+        });
+    });
+});