@flusys/nestjs-storage 6.0.2 → 6.1.1

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

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _testing = require("@nestjs/testing");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _repositorymock = require("@test-utils/mocks/repository.mock");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _folderservice = require("./folder.service");
+const _storageconfigservice = require("./storage-config.service");
+const _storagedatasourceprovider = require("./storage-datasource.provider");
+const _entities = require("../entities");
+describe('FolderService', ()=>{
+    let service;
+    let mockRepo;
+    let mockStorageConfig;
+    beforeEach(async ()=>{
+        mockRepo = (0, _repositorymock.createMockRepository)();
+        const mockDataSourceProvider = (0, _repositorymock.createMockDataSourceProvider)(mockRepo);
+        mockStorageConfig = {
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
+        };
+        const module = await _testing.Test.createTestingModule({
+            providers: [
+                _folderservice.FolderService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {}
+                },
+                {
+                    provide: _modules.UtilsService,
+                    useValue: {}
+                },
+                {
+                    provide: _storageconfigservice.StorageConfigService,
+                    useValue: mockStorageConfig
+                },
+                {
+                    provide: _storagedatasourceprovider.StorageDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                }
+            ]
+        }).compile();
+        service = await module.resolve(_folderservice.FolderService);
+    });
+    describe('resolveEntity', ()=>{
+        it('resolves to the core Folder entity when company feature is disabled', ()=>{
+            expect(service.resolveEntity()).toBe(_entities.Folder);
+        });
+        it('resolves to FolderWithCompany when company feature is enabled', ()=>{
+            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            expect(service.resolveEntity()).toBe(_entities.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'
+            }, (0, _loggedusermock.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'
+            }, (0, _loggedusermock.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'
+            }, (0, _loggedusermock.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'
+            }, (0, _loggedusermock.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, (0, _loggedusermock.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, (0, _loggedusermock.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, (0, _loggedusermock.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, {}, (0, _loggedusermock.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, {}, (0, _loggedusermock.buildMockUser)());
+            expect(query.andWhere).not.toHaveBeenCalled();
+        });
+    });
+});

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

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _storageconfigservice = require("./storage-config.service");
+const _config = require("../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.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.StorageConfigService(buildOptions({
+                bootstrapAppConfig: undefined
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+        it('defaults databaseMode to single when bootstrapAppConfig is absent', ()=>{
+            const service = new _storageconfigservice.StorageConfigService(buildOptions({
+                bootstrapAppConfig: undefined
+            }));
+            expect(service.getDatabaseMode()).toBe('single');
+        });
+        it('reports isMultiTenant() true only in multi-tenant mode', ()=>{
+            const service = new _storageconfigservice.StorageConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant',
+                    enableCompanyFeature: true
+                }
+            }));
+            expect(service.isMultiTenant()).toBe(true);
+        });
+        it('reports isMultiTenant() false in single mode', ()=>{
+            const service = new _storageconfigservice.StorageConfigService(buildOptions());
+            expect(service.isMultiTenant()).toBe(false);
+        });
+    });
+    describe('getMaxFileSize', ()=>{
+        it('returns the configured max file size', ()=>{
+            const service = new _storageconfigservice.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.StorageConfigService(buildOptions({
+                config: {}
+            }));
+            expect(service.getMaxFileSize()).toBe(100 * 1024 * 1024);
+        });
+    });
+    describe('getAllowedFileTypes', ()=>{
+        it('returns configured allowed types', ()=>{
+            const service = new _storageconfigservice.StorageConfigService(buildOptions({
+                config: {
+                    allowedFileTypes: [
+                        'image/png'
+                    ]
+                }
+            }));
+            expect(service.getAllowedFileTypes()).toEqual([
+                'image/png'
+            ]);
+        });
+        it('defaults to */* when not configured', ()=>{
+            const service = new _storageconfigservice.StorageConfigService(buildOptions({
+                config: {}
+            }));
+            expect(service.getAllowedFileTypes()).toEqual([
+                '*/*'
+            ]);
+        });
+    });
+    describe('getDefaultLocalStoragePath', ()=>{
+        it('returns the configured local storage path', ()=>{
+            const service = new _storageconfigservice.StorageConfigService(buildOptions({
+                config: {
+                    localStoragePath: './custom-uploads'
+                }
+            }));
+            expect(service.getDefaultLocalStoragePath()).toBe('./custom-uploads');
+        });
+        it('defaults to ./uploads when not configured', ()=>{
+            const service = new _storageconfigservice.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.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.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.StorageConfigService(buildOptions({
+                config: {}
+            }));
+            expect(service.getAppUrl()).toBe('http://localhost:4000');
+        });
+    });
+    describe('isFileTypeAllowed', ()=>{
+        it('allows any type when */* is configured', ()=>{
+            const service = new _storageconfigservice.StorageConfigService(buildOptions({
+                config: {
+                    allowedFileTypes: [
+                        '*/*'
+                    ]
+                }
+            }));
+            expect(service.isFileTypeAllowed('application/pdf')).toBe(true);
+        });
+        it('allows types matching a category wildcard', ()=>{
+            const service = new _storageconfigservice.StorageConfigService(buildOptions({
+                config: {
+                    allowedFileTypes: [
+                        'image/*'
+                    ]
+                }
+            }));
+            expect(service.isFileTypeAllowed('image/png')).toBe(true);
+        });
+        it('rejects types outside the allow-list', ()=>{
+            const service = new _storageconfigservice.StorageConfigService(buildOptions({
+                config: {
+                    allowedFileTypes: [
+                        'image/*'
+                    ]
+                }
+            }));
+            expect(service.isFileTypeAllowed('application/pdf')).toBe(false);
+        });
+        it('allows an exact MIME type match', ()=>{
+            const service = new _storageconfigservice.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.StorageConfigService(buildOptions({
+                config: {
+                    maxFileSize: 1000
+                }
+            }));
+            expect(service.validateFileSize(500)).toEqual({
+                valid: true
+            });
+        });
+        it('passes at the exact boundary size', ()=>{
+            const service = new _storageconfigservice.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.StorageConfigService(buildOptions({
+                config: {
+                    maxFileSize: 1000
+                }
+            }));
+            const result = service.validateFileSize(1001);
+            expect(result.valid).toBe(false);
+            expect(result.messageKey).toBe(_config.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.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.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.StorageConfigService(buildOptions({
+                config: {
+                    allowedFileTypes: [
+                        'image/*'
+                    ]
+                }
+            }));
+            const result = service.validateFileType('application/pdf');
+            expect(result.valid).toBe(false);
+            expect(result.messageKey).toBe(_config.UPLOAD_MESSAGES.INVALID_TYPE);
+            expect(result.message).toContain('application/pdf');
+            expect(result.messageVariables).toEqual({
+                mimeType: 'application/pdf',
+                allowedTypes: 'image/*'
+            });
+        });
+    });
+});

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

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _modules = require("@flusys/nestjs-shared/modules");
+const _storagedatasourceprovider = require("./storage-datasource.provider");
+const _entities = /*#__PURE__*/ _interop_require_wildcard(require("../entities"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+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.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.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.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.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.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.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.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.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.StorageDataSourceProvider(configService);
+            jest.spyOn(provider, 'getCurrentTenant').mockReturnValue(null);
+            const superCreateSpy = jest.spyOn(_modules.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.StorageDataSourceProvider(configService);
+            jest.spyOn(provider, 'getCurrentTenant').mockReturnValue({
+                id: 'tenant-1',
+                enableCompanyFeature: true
+            });
+            const superCreateSpy = jest.spyOn(_modules.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
+            ]);
+        });
+    });
+});