@flusys/nestjs-storage 6.0.2 → 6.1.0

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

@@ -0,0 +1,159 @@
+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 { FolderService } from './folder.service';
+import { StorageConfigService } from './storage-config.service';
+import { StorageDataSourceProvider } from './storage-datasource.provider';
+import { Folder, FolderWithCompany } from '../entities';
+describe('FolderService', ()=>{
+    let service;
+    let mockRepo;
+    let mockStorageConfig;
+    beforeEach(async ()=>{
+        mockRepo = createMockRepository();
+        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
+        mockStorageConfig = {
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
+        };
+        const module = await Test.createTestingModule({
+            providers: [
+                FolderService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {}
+                },
+                {
+                    provide: UtilsService,
+                    useValue: {}
+                },
+                {
+                    provide: StorageConfigService,
+                    useValue: mockStorageConfig
+                },
+                {
+                    provide: StorageDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                }
+            ]
+        }).compile();
+        service = await module.resolve(FolderService);
+    });
+    describe('resolveEntity', ()=>{
+        it('resolves to the core Folder entity when company feature is disabled', ()=>{
+            expect(service.resolveEntity()).toBe(Folder);
+        });
+        it('resolves to FolderWithCompany when company feature is enabled', ()=>{
+            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            expect(service.resolveEntity()).toBe(FolderWithCompany);
+        });
+    });
+    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: 'Invoices'
+            }, 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: 'Invoices'
+            }, buildMockUser({
+                companyId: 'company-7'
+            }));
+            expect(entity.companyId).toBe('company-7');
+        });
+        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: 'Invoices'
+            }, null);
+            expect(entity.companyId).toBeNull();
+        });
+        it('loads and merges the existing entity when updating (dto has an id)', async ()=>{
+            const existing = {
+                id: 'folder-1',
+                name: 'Old Name'
+            };
+            mockRepo.findOne.mockResolvedValue(existing);
+            const entity = await service.convertSingleDtoToEntity({
+                id: 'folder-1',
+                name: 'New Name'
+            }, buildMockUser());
+            expect(mockRepo.findOne).toHaveBeenCalledWith({
+                where: {
+                    id: 'folder-1'
+                }
+            });
+            expect(entity.name).toBe('New Name');
+        });
+        it('throws NotFoundException when updating a folder that does not exist', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            await expect(service.convertSingleDtoToEntity({
+                id: 'missing-id',
+                name: 'x'
+            }, buildMockUser())).rejects.toThrow();
+        });
+    });
+    describe('getSelectQuery', ()=>{
+        it('selects the default field set (id, name, slug, createdAt, deletedAt) when none is provided', async ()=>{
+            const query = {
+                select: jest.fn().mockReturnThis()
+            };
+            await service.getSelectQuery(query, buildMockUser());
+            expect(query.select).toHaveBeenCalledWith([
+                'folder.id',
+                'folder.name',
+                'folder.slug',
+                'folder.createdAt',
+                'folder.deletedAt'
+            ]);
+        });
+        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('folder.companyId');
+        });
+        it('respects an explicitly provided select list', async ()=>{
+            const query = {
+                select: jest.fn().mockReturnThis()
+            };
+            await service.getSelectQuery(query, buildMockUser(), [
+                'id'
+            ]);
+            expect(query.select).toHaveBeenCalledWith([
+                'folder.id'
+            ]);
+        });
+    });
+    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('folder.companyId = :companyId', {
+                companyId: 'company-3'
+            });
+        });
+        it('does not apply a company filter when company feature is disabled', async ()=>{
+            const query = {
+                andWhere: jest.fn().mockReturnThis()
+            };
+            await service.getExtraManipulateQuery(query, {}, buildMockUser());
+            expect(query.andWhere).not.toHaveBeenCalled();
+        });
+    });
+});

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

@@ -0,0 +1,253 @@
+import { StorageConfigService } from './storage-config.service';
+import { UPLOAD_MESSAGES } from '../config';
+function buildOptions(overrides = {}) {
+    return {
+        bootstrapAppConfig: {
+            databaseMode: 'single',
+            enableCompanyFeature: false
+        },
+        config: {},
+        ...overrides
+    };
+}
+describe('StorageConfigService', ()=>{
+    describe('bootstrap config getters', ()=>{
+        it('reflects enableCompanyFeature from bootstrap config', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: true
+                }
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(true);
+        });
+        it('defaults enableCompanyFeature to false when bootstrapAppConfig is absent', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                bootstrapAppConfig: undefined
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+        it('defaults databaseMode to single when bootstrapAppConfig is absent', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                bootstrapAppConfig: undefined
+            }));
+            expect(service.getDatabaseMode()).toBe('single');
+        });
+        it('reports isMultiTenant() true only in multi-tenant mode', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant',
+                    enableCompanyFeature: true
+                }
+            }));
+            expect(service.isMultiTenant()).toBe(true);
+        });
+        it('reports isMultiTenant() false in single mode', ()=>{
+            const service = new StorageConfigService(buildOptions());
+            expect(service.isMultiTenant()).toBe(false);
+        });
+    });
+    describe('getMaxFileSize', ()=>{
+        it('returns the configured max file size', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                config: {
+                    maxFileSize: 5000
+                }
+            }));
+            expect(service.getMaxFileSize()).toBe(5000);
+        });
+        it('falls back to the default max file size (100MB) when not configured', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                config: {}
+            }));
+            expect(service.getMaxFileSize()).toBe(100 * 1024 * 1024);
+        });
+    });
+    describe('getAllowedFileTypes', ()=>{
+        it('returns configured allowed types', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                config: {
+                    allowedFileTypes: [
+                        'image/png'
+                    ]
+                }
+            }));
+            expect(service.getAllowedFileTypes()).toEqual([
+                'image/png'
+            ]);
+        });
+        it('defaults to */* when not configured', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                config: {}
+            }));
+            expect(service.getAllowedFileTypes()).toEqual([
+                '*/*'
+            ]);
+        });
+    });
+    describe('getDefaultLocalStoragePath', ()=>{
+        it('returns the configured local storage path', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                config: {
+                    localStoragePath: './custom-uploads'
+                }
+            }));
+            expect(service.getDefaultLocalStoragePath()).toBe('./custom-uploads');
+        });
+        it('defaults to ./uploads when not configured', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                config: {}
+            }));
+            expect(service.getDefaultLocalStoragePath()).toBe('./uploads');
+        });
+    });
+    describe('getAppUrl', ()=>{
+        const originalAppUrl = process.env.APP_URL;
+        const originalPort = process.env.PORT;
+        afterEach(()=>{
+            process.env.APP_URL = originalAppUrl;
+            process.env.PORT = originalPort;
+        });
+        it('returns the explicitly configured appUrl', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                config: {
+                    appUrl: 'https://files.example.com'
+                }
+            }));
+            expect(service.getAppUrl()).toBe('https://files.example.com');
+        });
+        it('falls back to process.env.APP_URL when config.appUrl is absent', ()=>{
+            delete process.env.APP_URL;
+            process.env.APP_URL = 'https://env.example.com';
+            const service = new StorageConfigService(buildOptions({
+                config: {}
+            }));
+            expect(service.getAppUrl()).toBe('https://env.example.com');
+        });
+        it('falls back to localhost with PORT when neither config nor env var is set', ()=>{
+            delete process.env.APP_URL;
+            process.env.PORT = '4000';
+            const service = new StorageConfigService(buildOptions({
+                config: {}
+            }));
+            expect(service.getAppUrl()).toBe('http://localhost:4000');
+        });
+    });
+    describe('isFileTypeAllowed', ()=>{
+        it('allows any type when */* is configured', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                config: {
+                    allowedFileTypes: [
+                        '*/*'
+                    ]
+                }
+            }));
+            expect(service.isFileTypeAllowed('application/pdf')).toBe(true);
+        });
+        it('allows types matching a category wildcard', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                config: {
+                    allowedFileTypes: [
+                        'image/*'
+                    ]
+                }
+            }));
+            expect(service.isFileTypeAllowed('image/png')).toBe(true);
+        });
+        it('rejects types outside the allow-list', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                config: {
+                    allowedFileTypes: [
+                        'image/*'
+                    ]
+                }
+            }));
+            expect(service.isFileTypeAllowed('application/pdf')).toBe(false);
+        });
+        it('allows an exact MIME type match', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                config: {
+                    allowedFileTypes: [
+                        'application/pdf'
+                    ]
+                }
+            }));
+            expect(service.isFileTypeAllowed('application/pdf')).toBe(true);
+        });
+    });
+    describe('validateFileSize', ()=>{
+        it('passes when file size is within the limit', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                config: {
+                    maxFileSize: 1000
+                }
+            }));
+            expect(service.validateFileSize(500)).toEqual({
+                valid: true
+            });
+        });
+        it('passes at the exact boundary size', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                config: {
+                    maxFileSize: 1000
+                }
+            }));
+            expect(service.validateFileSize(1000).valid).toBe(true);
+        });
+        it('fails when file size exceeds the limit by one byte', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                config: {
+                    maxFileSize: 1000
+                }
+            }));
+            const result = service.validateFileSize(1001);
+            expect(result.valid).toBe(false);
+            expect(result.messageKey).toBe(UPLOAD_MESSAGES.FILE_TOO_LARGE);
+            expect(result.messageVariables).toEqual({
+                fileSize: '0.00',
+                maxSize: '0.00'
+            });
+        });
+        it('reports MB-converted size values in the failure message', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                config: {
+                    maxFileSize: 1 * 1024 * 1024
+                }
+            }));
+            const result = service.validateFileSize(2 * 1024 * 1024);
+            expect(result.message).toContain('2.00MB');
+            expect(result.message).toContain('1.00MB');
+        });
+    });
+    describe('validateFileType', ()=>{
+        it('passes for an allowed type', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                config: {
+                    allowedFileTypes: [
+                        'image/*'
+                    ]
+                }
+            }));
+            expect(service.validateFileType('image/png')).toEqual({
+                valid: true
+            });
+        });
+        it('fails for a disallowed type with a descriptive message and messageKey', ()=>{
+            const service = new StorageConfigService(buildOptions({
+                config: {
+                    allowedFileTypes: [
+                        'image/*'
+                    ]
+                }
+            }));
+            const result = service.validateFileType('application/pdf');
+            expect(result.valid).toBe(false);
+            expect(result.messageKey).toBe(UPLOAD_MESSAGES.INVALID_TYPE);
+            expect(result.message).toContain('application/pdf');
+            expect(result.messageVariables).toEqual({
+                mimeType: 'application/pdf',
+                allowedTypes: 'image/*'
+            });
+        });
+    });
+});

package/fesm/services/storage-datasource.provider.spec.js

@@ -0,0 +1,172 @@
+import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
+import { StorageDataSourceProvider } from './storage-datasource.provider';
+import * as entities from '../entities';
+function buildMockConfigService(overrides = {}) {
+    const options = {
+        bootstrapAppConfig: {
+            databaseMode: 'single',
+            enableCompanyFeature: false
+        },
+        config: {},
+        ...overrides
+    };
+    return {
+        isCompanyFeatureEnabled: jest.fn().mockReturnValue(options.bootstrapAppConfig?.enableCompanyFeature ?? false),
+        getOptions: jest.fn().mockReturnValue(options)
+    };
+}
+describe('StorageDataSourceProvider', ()=>{
+    afterEach(()=>{
+        jest.restoreAllMocks();
+    });
+    describe('construction', ()=>{
+        it('propagates bootstrap options from StorageConfigService into the parent data-source service', ()=>{
+            const configService = buildMockConfigService({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant',
+                    enableCompanyFeature: true
+                }
+            });
+            const provider = new StorageDataSourceProvider(configService);
+            expect(provider.getDatabaseMode()).toBe('multi-tenant');
+            expect(provider.isMultiTenant()).toBe(true);
+        });
+        it('defaults to single database mode when bootstrap config is absent', ()=>{
+            const configService = buildMockConfigService({
+                bootstrapAppConfig: undefined
+            });
+            const provider = new StorageDataSourceProvider(configService);
+            expect(provider.getDatabaseMode()).toBe('single');
+            expect(provider.isMultiTenant()).toBe(false);
+        });
+    });
+    describe('getEnableCompanyFeatureForTenant', ()=>{
+        it('uses the tenant-level override when provided', ()=>{
+            const configService = buildMockConfigService();
+            const provider = new StorageDataSourceProvider(configService);
+            const result = provider.getEnableCompanyFeatureForTenant({
+                id: 'tenant-1',
+                enableCompanyFeature: true
+            });
+            expect(result).toBe(true);
+        });
+        it('falls back to global config when tenant has no override', ()=>{
+            const configService = buildMockConfigService({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: true
+                }
+            });
+            const provider = new StorageDataSourceProvider(configService);
+            const result = provider.getEnableCompanyFeatureForTenant({
+                id: 'tenant-1'
+            });
+            expect(result).toBe(true);
+        });
+        it('falls back to global config when no tenant is provided', ()=>{
+            const configService = buildMockConfigService({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: false
+                }
+            });
+            const provider = new StorageDataSourceProvider(configService);
+            expect(provider.getEnableCompanyFeatureForTenant(undefined)).toBe(false);
+        });
+    });
+    describe('getStorageEntities', ()=>{
+        it('returns company-scoped entities when company feature is enabled', async ()=>{
+            const configService = buildMockConfigService();
+            const provider = new StorageDataSourceProvider(configService);
+            const result = await provider.getStorageEntities(true);
+            expect(result).toEqual([
+                entities.FileManagerWithCompany,
+                entities.FolderWithCompany,
+                entities.StorageConfigWithCompany
+            ]);
+        });
+        it('returns core entities when company feature is disabled', async ()=>{
+            const configService = buildMockConfigService();
+            const provider = new StorageDataSourceProvider(configService);
+            const result = await provider.getStorageEntities(false);
+            expect(result).toEqual([
+                entities.FileManager,
+                entities.Folder,
+                entities.StorageConfig
+            ]);
+        });
+        it('falls back to the config service value when no explicit flag is passed', async ()=>{
+            const configService = buildMockConfigService({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: true
+                }
+            });
+            const provider = new StorageDataSourceProvider(configService);
+            const result = await provider.getStorageEntities();
+            expect(result).toEqual([
+                entities.FileManagerWithCompany,
+                entities.FolderWithCompany,
+                entities.StorageConfigWithCompany
+            ]);
+        });
+    });
+    describe('createDataSourceFromConfig', ()=>{
+        it('resolves storage entities for the current tenant/config and delegates to the parent implementation', async ()=>{
+            const configService = buildMockConfigService({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: false
+                }
+            });
+            const provider = new StorageDataSourceProvider(configService);
+            jest.spyOn(provider, 'getCurrentTenant').mockReturnValue(null);
+            const superCreateSpy = jest.spyOn(MultiTenantDataSourceService.prototype, 'createDataSourceFromConfig').mockResolvedValue({
+                isInitialized: true
+            });
+            const config = {
+                type: 'mysql',
+                host: 'localhost',
+                port: 3306,
+                username: 'root',
+                password: '',
+                database: 'test'
+            };
+            const result = await provider.createDataSourceFromConfig(config);
+            expect(superCreateSpy).toHaveBeenCalledWith(config, [
+                entities.FileManager,
+                entities.Folder,
+                entities.StorageConfig
+            ]);
+            expect(result).toEqual({
+                isInitialized: true
+            });
+        });
+        it('uses the tenant enableCompanyFeature override to pick company-scoped entities', async ()=>{
+            const configService = buildMockConfigService({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant',
+                    enableCompanyFeature: false
+                }
+            });
+            const provider = new StorageDataSourceProvider(configService);
+            jest.spyOn(provider, 'getCurrentTenant').mockReturnValue({
+                id: 'tenant-1',
+                enableCompanyFeature: true
+            });
+            const superCreateSpy = jest.spyOn(MultiTenantDataSourceService.prototype, 'createDataSourceFromConfig').mockResolvedValue({
+                isInitialized: true
+            });
+            const config = {
+                type: 'mysql',
+                database: 'tenant_db'
+            };
+            await provider.createDataSourceFromConfig(config);
+            expect(superCreateSpy).toHaveBeenCalledWith(config, [
+                entities.FileManagerWithCompany,
+                entities.FolderWithCompany,
+                entities.StorageConfigWithCompany
+            ]);
+        });
+    });
+});