@flusys/nestjs-storage 6.0.2 → 6.1.1

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

@@ -0,0 +1,239 @@
+import { Test } from '@nestjs/testing';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { createMockDataSourceProvider, createMockRepository } from '@test-utils/mocks/repository.mock';
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { StorageProviderConfigService } from './storage-provider-config.service';
+import { StorageConfigService } from './storage-config.service';
+import { StorageDataSourceProvider } from './storage-datasource.provider';
+import { StorageConfig, StorageConfigWithCompany } from '../entities';
+function buildStorageConfig(overrides = {}) {
+    return {
+        id: 'config-uuid-1',
+        name: 'Default Local',
+        storage: 'local',
+        config: {
+            basePath: './uploads'
+        },
+        isActive: true,
+        isDefault: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+describe('StorageProviderConfigService', ()=>{
+    let service;
+    let mockRepo;
+    let mockStorageConfig;
+    beforeEach(async ()=>{
+        mockRepo = createMockRepository();
+        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
+        mockStorageConfig = {
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false),
+            getAppUrl: jest.fn().mockReturnValue('http://localhost:2002')
+        };
+        const module = await Test.createTestingModule({
+            providers: [
+                StorageProviderConfigService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {}
+                },
+                {
+                    provide: UtilsService,
+                    useValue: {}
+                },
+                {
+                    provide: StorageConfigService,
+                    useValue: mockStorageConfig
+                },
+                {
+                    provide: StorageDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                }
+            ]
+        }).compile();
+        service = await module.resolve(StorageProviderConfigService);
+    });
+    describe('resolveEntity', ()=>{
+        it('resolves to the core StorageConfig entity when company feature is disabled', ()=>{
+            expect(service.resolveEntity()).toBe(StorageConfig);
+        });
+        it('resolves to StorageConfigWithCompany when company feature is enabled', ()=>{
+            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            expect(service.resolveEntity()).toBe(StorageConfigWithCompany);
+        });
+    });
+    describe('convertSingleDtoToEntity', ()=>{
+        beforeEach(async ()=>{
+            mockRepo.create.mockReturnValue({});
+            await service.ensureDataSourceRepository();
+        });
+        it('does not attach companyId when the company feature is disabled', async ()=>{
+            const entity = await service.convertSingleDtoToEntity({
+                name: 'AWS S3',
+                storage: 'aws',
+                config: {}
+            }, buildMockUser());
+            expect(entity.companyId).toBeUndefined();
+        });
+        it('attaches the current user companyId when the company feature is enabled', async ()=>{
+            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const entity = await service.convertSingleDtoToEntity({
+                name: 'AWS S3',
+                storage: 'aws',
+                config: {}
+            }, buildMockUser({
+                companyId: 'company-42'
+            }));
+            expect(entity.companyId).toBe('company-42');
+        });
+        it('defaults companyId to null when company feature is enabled but user has none', async ()=>{
+            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const entity = await service.convertSingleDtoToEntity({
+                name: 'AWS S3',
+                storage: 'aws',
+                config: {}
+            }, null);
+            expect(entity.companyId).toBeNull();
+        });
+    });
+    describe('getSelectQuery', ()=>{
+        it('selects the default field set when none is provided', async ()=>{
+            const query = {
+                select: jest.fn().mockReturnThis()
+            };
+            await service.getSelectQuery(query, buildMockUser());
+            expect(query.select).toHaveBeenCalledWith([
+                'storageConfig.id',
+                'storageConfig.name',
+                'storageConfig.storage',
+                'storageConfig.config',
+                'storageConfig.isActive',
+                'storageConfig.isDefault',
+                'storageConfig.createdAt',
+                'storageConfig.updatedAt'
+            ]);
+        });
+        it('adds companyId to the default select list when company feature is enabled', async ()=>{
+            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const query = {
+                select: jest.fn().mockReturnThis()
+            };
+            await service.getSelectQuery(query, buildMockUser());
+            const selected = query.select.mock.calls[0][0];
+            expect(selected).toContain('storageConfig.companyId');
+        });
+        it('respects an explicitly provided select list', async ()=>{
+            const query = {
+                select: jest.fn().mockReturnThis()
+            };
+            await service.getSelectQuery(query, buildMockUser(), [
+                'id',
+                'name'
+            ]);
+            expect(query.select).toHaveBeenCalledWith([
+                'storageConfig.id',
+                'storageConfig.name'
+            ]);
+        });
+    });
+    describe('findByIdDirect', ()=>{
+        it('bypasses company filtering and returns the raw entity by id', async ()=>{
+            const config = buildStorageConfig();
+            mockRepo.findOne.mockResolvedValue(config);
+            const result = await service.findByIdDirect('config-uuid-1');
+            expect(mockRepo.findOne).toHaveBeenCalledWith({
+                where: {
+                    id: 'config-uuid-1'
+                }
+            });
+            expect(result).toEqual(config);
+        });
+        it('returns null when no config exists for the given id', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            const result = await service.findByIdDirect('missing-id');
+            expect(result).toBeNull();
+        });
+    });
+    describe('getDefaultConfig', ()=>{
+        it('returns the config explicitly flagged isDefault when one exists', async ()=>{
+            const defaultConfig = buildStorageConfig({
+                id: 'default-1',
+                isDefault: true
+            });
+            mockRepo.findOne.mockResolvedValueOnce(defaultConfig);
+            const result = await service.getDefaultConfig(buildMockUser());
+            expect(result).toEqual(defaultConfig);
+            expect(mockRepo.findOne).toHaveBeenCalledTimes(1);
+        });
+        it('falls back to the oldest active config when no default is flagged', async ()=>{
+            const fallbackConfig = buildStorageConfig({
+                id: 'fallback-1'
+            });
+            mockRepo.findOne.mockResolvedValueOnce(null).mockResolvedValueOnce(fallbackConfig);
+            const result = await service.getDefaultConfig(buildMockUser());
+            expect(result).toEqual(fallbackConfig);
+            expect(mockRepo.findOne).toHaveBeenCalledTimes(2);
+        });
+        it('returns null when there is no default and no active config at all', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            const result = await service.getDefaultConfig(buildMockUser());
+            expect(result).toBeNull();
+        });
+        it('scopes the query to the user company when company feature is enabled', async ()=>{
+            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            mockRepo.findOne.mockResolvedValue(null);
+            await service.getDefaultConfig(buildMockUser({
+                companyId: 'company-9'
+            }));
+            expect(mockRepo.findOne).toHaveBeenCalledWith(expect.objectContaining({
+                where: expect.objectContaining({
+                    companyId: 'company-9',
+                    isActive: true
+                })
+            }));
+        });
+    });
+    describe('getConfigByType', ()=>{
+        it('returns active configs matching the requested storage type', async ()=>{
+            const localConfigs = [
+                buildStorageConfig({
+                    storage: 'local'
+                })
+            ];
+            mockRepo.find.mockResolvedValue(localConfigs);
+            const result = await service.getConfigByType('local', buildMockUser());
+            expect(mockRepo.find).toHaveBeenCalledWith({
+                where: {
+                    storage: 'local',
+                    isActive: true
+                }
+            });
+            expect(result).toEqual(localConfigs);
+        });
+        it('scopes the lookup to the current company when company feature is enabled', async ()=>{
+            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            mockRepo.find.mockResolvedValue([]);
+            await service.getConfigByType('aws', buildMockUser({
+                companyId: 'company-5'
+            }));
+            expect(mockRepo.find).toHaveBeenCalledWith({
+                where: {
+                    storage: 'aws',
+                    isActive: true,
+                    companyId: 'company-5'
+                }
+            });
+        });
+        it('returns an empty array when no configs match', async ()=>{
+            mockRepo.find.mockResolvedValue([]);
+            const result = await service.getConfigByType('azure');
+            expect(result).toEqual([]);
+        });
+    });
+});

package/fesm/services/upload.service.spec.js

@@ -0,0 +1,368 @@
+import { Test } from '@nestjs/testing';
+import { UploadService } from './upload.service';
+import { StorageFactoryService } from '../providers/storage-factory.service';
+import { StorageConfigService } from './storage-config.service';
+import { StorageProviderConfigService } from './storage-provider-config.service';
+import { FileLocationEnum } from '../enums/file-location.enum';
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+function buildMulterFile(overrides = {}) {
+    return {
+        fieldname: 'file',
+        originalname: 'photo.jpg',
+        encoding: '7bit',
+        mimetype: 'image/jpeg',
+        buffer: Buffer.from([
+            0xff,
+            0xd8,
+            0xff,
+            0xe0
+        ]),
+        size: 1024,
+        stream: undefined,
+        destination: '',
+        filename: '',
+        path: '',
+        ...overrides
+    };
+}
+describe('UploadService', ()=>{
+    let service;
+    let mockStorageFactory;
+    let mockStorageConfigService;
+    let mockStorageProviderConfigService;
+    let mockProvider;
+    beforeEach(async ()=>{
+        mockProvider = {
+            uploadFile: jest.fn().mockResolvedValue({
+                name: 'photo.jpg',
+                key: 'uploads/photo.jpg',
+                size: 1024,
+                contentType: 'image/jpeg'
+            }),
+            uploadMultipleFiles: jest.fn().mockResolvedValue([]),
+            deleteFile: jest.fn().mockResolvedValue(undefined),
+            deleteMultipleFiles: jest.fn().mockResolvedValue(undefined),
+            generatePresignedUrl: jest.fn().mockResolvedValue('https://signed.example.com/uploads/photo.jpg')
+        };
+        mockStorageFactory = {
+            createProvider: jest.fn().mockResolvedValue(mockProvider),
+            getLocalProviderBasePath: jest.fn().mockReturnValue(null)
+        };
+        mockStorageConfigService = {
+            validateFileSize: jest.fn().mockReturnValue({
+                valid: true
+            }),
+            validateFileType: jest.fn().mockReturnValue({
+                valid: true
+            }),
+            getAllowedFileTypes: jest.fn().mockReturnValue([
+                '*/*'
+            ]),
+            getDefaultLocalStoragePath: jest.fn().mockReturnValue('./uploads'),
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
+        };
+        mockStorageProviderConfigService = {
+            findByIdDirect: jest.fn(),
+            getDefaultConfig: jest.fn(),
+            getConfigByType: jest.fn()
+        };
+        const module = await Test.createTestingModule({
+            providers: [
+                UploadService,
+                {
+                    provide: StorageFactoryService,
+                    useValue: mockStorageFactory
+                },
+                {
+                    provide: StorageConfigService,
+                    useValue: mockStorageConfigService
+                },
+                {
+                    provide: StorageProviderConfigService,
+                    useValue: mockStorageProviderConfigService
+                }
+            ]
+        }).compile();
+        service = await module.resolve(UploadService);
+    });
+    describe('uploadSingleFile', ()=>{
+        it('validates, resolves the default storage config, and uploads via the resolved provider', async ()=>{
+            mockStorageProviderConfigService.getDefaultConfig.mockResolvedValue({
+                id: 'cfg-default',
+                storage: 'local',
+                config: {}
+            });
+            const result = await service.uploadSingleFile(buildMulterFile(), {}, buildMockUser());
+            expect(mockStorageConfigService.validateFileSize).toHaveBeenCalled();
+            expect(mockStorageConfigService.validateFileType).toHaveBeenCalled();
+            expect(mockProvider.uploadFile).toHaveBeenCalled();
+            expect(result.location).toBe('local');
+            expect(result.storageConfigId).toBe('cfg-default');
+        });
+        it('throws BadRequestException when file size exceeds the configured maximum', async ()=>{
+            mockStorageConfigService.validateFileSize.mockReturnValue({
+                valid: false,
+                message: 'too big',
+                messageKey: 'upload.file.too.large'
+            });
+            await expect(service.uploadSingleFile(buildMulterFile(), {}, buildMockUser())).rejects.toThrow();
+        });
+        it('throws BadRequestException when the declared MIME type is not allowed', async ()=>{
+            mockStorageConfigService.validateFileType.mockReturnValue({
+                valid: false,
+                message: 'not allowed',
+                messageKey: 'upload.invalid.type'
+            });
+            await expect(service.uploadSingleFile(buildMulterFile(), {}, buildMockUser())).rejects.toThrow();
+        });
+        it('rejects a file whose content does not match its declared MIME type (spoofing protection)', async ()=>{
+            const file = buildMulterFile({
+                mimetype: 'application/pdf',
+                buffer: Buffer.from([
+                    0xff,
+                    0xd8,
+                    0xff
+                ])
+            });
+            await expect(service.uploadSingleFile(file, {}, buildMockUser())).rejects.toThrow();
+        });
+        it('sanitizes the original filename to prevent path traversal before uploading', async ()=>{
+            mockStorageProviderConfigService.getDefaultConfig.mockResolvedValue({
+                id: 'cfg-default',
+                storage: 'local',
+                config: {}
+            });
+            const file = buildMulterFile({
+                originalname: '../../etc/passwd.jpg'
+            });
+            await service.uploadSingleFile(file, {}, buildMockUser());
+            expect(file.originalname).toBe('passwd.jpg');
+        });
+        it('uses an explicit storageConfigId when provided and validates company ownership', async ()=>{
+            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue({
+                id: 'cfg-1',
+                storage: 'aws',
+                config: {}
+            });
+            const result = await service.uploadSingleFile(buildMulterFile(), {
+                storageConfigId: 'cfg-1'
+            }, buildMockUser());
+            expect(mockStorageProviderConfigService.findByIdDirect).toHaveBeenCalledWith('cfg-1');
+            expect(result.location).toBe('aws');
+        });
+        it('throws NotFoundException when the explicit storageConfigId does not resolve to a config', async ()=>{
+            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue(null);
+            await expect(service.uploadSingleFile(buildMulterFile(), {
+                storageConfigId: 'missing'
+            }, buildMockUser())).rejects.toThrow();
+        });
+        it('throws NotFoundException when no default storage config exists and none was specified', async ()=>{
+            mockStorageProviderConfigService.getDefaultConfig.mockResolvedValue(null);
+            await expect(service.uploadSingleFile(buildMulterFile(), {}, buildMockUser())).rejects.toThrow();
+        });
+        it('rejects uploading a config belonging to a different company when company feature is enabled', async ()=>{
+            mockStorageConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue({
+                id: 'cfg-1',
+                storage: 'aws',
+                config: {},
+                companyId: 'other-company'
+            });
+            await expect(service.uploadSingleFile(buildMulterFile(), {
+                storageConfigId: 'cfg-1'
+            }, buildMockUser({
+                companyId: 'my-company'
+            }))).rejects.toThrow();
+        });
+    });
+    describe('uploadMultipleFiles', ()=>{
+        it('validates every file before uploading any', async ()=>{
+            mockStorageProviderConfigService.getDefaultConfig.mockResolvedValue({
+                id: 'cfg-default',
+                storage: 'local',
+                config: {}
+            });
+            mockProvider.uploadMultipleFiles.mockResolvedValue([
+                {
+                    name: 'a.jpg',
+                    key: 'a.jpg',
+                    size: 10,
+                    contentType: 'image/jpeg'
+                },
+                {
+                    name: 'b.jpg',
+                    key: 'b.jpg',
+                    size: 20,
+                    contentType: 'image/jpeg'
+                }
+            ]);
+            const files = [
+                buildMulterFile({
+                    originalname: 'a.jpg'
+                }),
+                buildMulterFile({
+                    originalname: 'b.jpg'
+                })
+            ];
+            const result = await service.uploadMultipleFiles(files, {}, buildMockUser());
+            expect(result).toHaveLength(2);
+            expect(mockStorageConfigService.validateFileSize).toHaveBeenCalledTimes(2);
+        });
+        it('rejects the whole batch if any single file fails validation', async ()=>{
+            mockStorageConfigService.validateFileSize.mockReturnValueOnce({
+                valid: true
+            }).mockReturnValueOnce({
+                valid: false,
+                message: 'too big',
+                messageKey: 'upload.file.too.large'
+            });
+            const files = [
+                buildMulterFile({
+                    originalname: 'a.jpg'
+                }),
+                buildMulterFile({
+                    originalname: 'b.jpg'
+                })
+            ];
+            await expect(service.uploadMultipleFiles(files, {}, buildMockUser())).rejects.toThrow();
+            expect(mockProvider.uploadMultipleFiles).not.toHaveBeenCalled();
+        });
+    });
+    describe('deleteSingleFile', ()=>{
+        it('throws BadRequestException when no key is provided', async ()=>{
+            await expect(service.deleteSingleFile('')).rejects.toThrow();
+        });
+        it('resolves a provider by storageConfigId and deletes the file', async ()=>{
+            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue({
+                id: 'cfg-1',
+                storage: 'aws',
+                config: {}
+            });
+            const result = await service.deleteSingleFile('uploads/photo.jpg', 'cfg-1', buildMockUser());
+            expect(mockProvider.deleteFile).toHaveBeenCalledWith('uploads/photo.jpg');
+            expect(result).toBe(true);
+        });
+        it('falls back to a matching config by locationHint when storageConfigId is missing/invalid', async ()=>{
+            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue(null);
+            mockStorageProviderConfigService.getConfigByType.mockResolvedValue([
+                {
+                    id: 'cfg-2',
+                    storage: 'local',
+                    config: {}
+                }
+            ]);
+            const result = await service.deleteSingleFile('uploads/photo.jpg', 'stale-id', buildMockUser(), 'local');
+            expect(mockStorageProviderConfigService.getConfigByType).toHaveBeenCalledWith('local', buildMockUser());
+            expect(result).toBe(true);
+        });
+        it('falls back to a local provider when locationHint is local and no config matches', async ()=>{
+            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue(null);
+            mockStorageProviderConfigService.getConfigByType.mockResolvedValue([]);
+            await service.deleteSingleFile('uploads/photo.jpg', undefined, buildMockUser(), FileLocationEnum.LOCAL);
+            expect(mockStorageFactory.createProvider).toHaveBeenCalledWith(expect.objectContaining({
+                provider: FileLocationEnum.LOCAL
+            }));
+        });
+        it('falls back to the default config as a last resort', async ()=>{
+            mockStorageProviderConfigService.getConfigByType.mockResolvedValue([]);
+            mockStorageProviderConfigService.getDefaultConfig.mockResolvedValue({
+                id: 'cfg-default',
+                storage: 'aws',
+                config: {}
+            });
+            await service.deleteSingleFile('uploads/photo.jpg', undefined, buildMockUser(), 'aws');
+            expect(mockStorageProviderConfigService.getDefaultConfig).toHaveBeenCalled();
+        });
+    });
+    describe('deleteMultipleFile', ()=>{
+        it('throws BadRequestException when no keys are provided', async ()=>{
+            await expect(service.deleteMultipleFile([])).rejects.toThrow();
+        });
+        it('deletes all provided keys via the resolved provider', async ()=>{
+            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue({
+                id: 'cfg-1',
+                storage: 'aws',
+                config: {}
+            });
+            const result = await service.deleteMultipleFile([
+                'a.jpg',
+                'b.jpg'
+            ], 'cfg-1', buildMockUser());
+            expect(mockProvider.deleteMultipleFiles).toHaveBeenCalledWith([
+                'a.jpg',
+                'b.jpg'
+            ]);
+            expect(result).toBe(true);
+        });
+    });
+    describe('bytesToKb', ()=>{
+        it('converts bytes to kilobytes rounded to 2 decimals', ()=>{
+            expect(service.bytesToKb(1024)).toBe(1.02);
+        });
+        it('returns 0 for a 0-byte file', ()=>{
+            expect(service.bytesToKb(0)).toBe(0);
+        });
+    });
+    describe('getLocalStorageBasePath', ()=>{
+        it('returns the cached basePath if already available', async ()=>{
+            mockStorageFactory.getLocalProviderBasePath.mockReturnValue('./cached-uploads');
+            const result = await service.getLocalStorageBasePath();
+            expect(result).toBe('./cached-uploads');
+            expect(mockStorageProviderConfigService.getConfigByType).not.toHaveBeenCalled();
+        });
+        it('initializes the local provider from DB config when not yet cached', async ()=>{
+            mockStorageFactory.getLocalProviderBasePath.mockReturnValueOnce(null).mockReturnValueOnce('./db-uploads');
+            mockStorageProviderConfigService.getConfigByType.mockResolvedValue([
+                {
+                    id: 'cfg-local',
+                    storage: 'local',
+                    config: {
+                        basePath: './db-uploads'
+                    }
+                }
+            ]);
+            const result = await service.getLocalStorageBasePath();
+            expect(result).toBe('./db-uploads');
+        });
+        it('returns null when there is no local config in the database', async ()=>{
+            mockStorageProviderConfigService.getConfigByType.mockResolvedValue([]);
+            const result = await service.getLocalStorageBasePath();
+            expect(result).toBeNull();
+        });
+        it('returns null (swallows errors) instead of throwing when lookup fails', async ()=>{
+            mockStorageProviderConfigService.getConfigByType.mockRejectedValue(new Error('db down'));
+            await expect(service.getLocalStorageBasePath()).resolves.toBeNull();
+        });
+    });
+    describe('makeFileUrl', ()=>{
+        it('delegates to the provider generatePresignedUrl when supported', async ()=>{
+            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue({
+                id: 'cfg-1',
+                storage: 'aws',
+                config: {}
+            });
+            const url = await service.makeFileUrl('uploads/photo.jpg', 'cfg-1', 900, buildMockUser());
+            expect(mockProvider.generatePresignedUrl).toHaveBeenCalledWith('uploads/photo.jpg', 900);
+            expect(url).toBe('https://signed.example.com/uploads/photo.jpg');
+        });
+        it('returns the raw key when the provider does not support presigned URLs', async ()=>{
+            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue({
+                id: 'cfg-1',
+                storage: 'sftp',
+                config: {}
+            });
+            delete mockProvider.generatePresignedUrl;
+            const url = await service.makeFileUrl('uploads/photo.jpg', 'cfg-1', 900, buildMockUser());
+            expect(url).toBe('uploads/photo.jpg');
+        });
+        it('defaults expiry to 3600 seconds when not specified', async ()=>{
+            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue({
+                id: 'cfg-1',
+                storage: 'aws',
+                config: {}
+            });
+            await service.makeFileUrl('uploads/photo.jpg', 'cfg-1');
+            expect(mockProvider.generatePresignedUrl).toHaveBeenCalledWith('uploads/photo.jpg', 3600);
+        });
+    });
+});