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

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

@@ -1,172 +0,0 @@
-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
-            ]);
-        });
-    });
-});

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

@@ -1,161 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { HybridCache, ApiService } from '@flusys/nestjs-shared/classes';
-import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { applyCompanyFilter, buildCompanyWhereCondition } from '@flusys/nestjs-shared/utils';
-import { ForbiddenException, Inject, Injectable, Scope } from '@nestjs/common';
-import { In, IsNull } from 'typeorm';
-import { STORAGE_CONFIG_MESSAGES, STORAGE_EVENT_ENTITIES, STORAGE_EVENT_MODULE } from '../config';
-import { StorageConfig, StorageConfigWithCompany } from '../entities';
-import { StorageConfigService } from './storage-config.service';
-import { StorageDataSourceProvider } from './storage-datasource.provider';
-export class StorageProviderConfigService extends ApiService {
-    async beforeDeleteOperation(dto, _user, _queryRunner) {
-        const ids = Array.isArray(dto.id) ? dto.id : [
-            dto.id
-        ];
-        await this.ensureDataSourceRepository();
-        const defaultConfigs = await this.repository.find({
-            where: {
-                id: In(ids),
-                isDefault: true,
-                deletedAt: IsNull()
-            }
-        });
-        if (defaultConfigs.length > 0) {
-            const names = defaultConfigs.map((c)=>c.name).join(', ');
-            throw new ForbiddenException({
-                message: `Cannot delete the default storage config(s): ${names}. Set another config as default first.`,
-                messageKey: STORAGE_CONFIG_MESSAGES.DEFAULT_DELETE_FORBIDDEN,
-                messageVariables: {
-                    names
-                }
-            });
-        }
-    }
-    // ─── Override Methods ───────────────────────────────────────────────────────
-    async convertSingleDtoToEntity(dto, user) {
-        const entity = await super.convertSingleDtoToEntity(dto, user);
-        if (this.storageConfig.isCompanyFeatureEnabled()) {
-            entity.companyId = user?.companyId ?? null;
-        }
-        return entity;
-    }
-    async getSelectQuery(query, _user, select) {
-        if (!select?.length) {
-            select = [
-                'id',
-                'name',
-                'storage',
-                'config',
-                'isActive',
-                'isDefault',
-                'createdAt',
-                'updatedAt'
-            ];
-            if (this.storageConfig.isCompanyFeatureEnabled()) {
-                select.push('companyId');
-            }
-        }
-        query.select(select.map((f)=>`${this.entityName}.${f}`));
-        return {
-            query,
-            isRaw: false
-        };
-    }
-    async getExtraManipulateQuery(query, filterDto, user) {
-        const result = await super.getExtraManipulateQuery(query, filterDto, user);
-        applyCompanyFilter(query, {
-            isCompanyFeatureEnabled: this.storageConfig.isCompanyFeatureEnabled(),
-            entityAlias: 'storageConfig'
-        }, user);
-        query.orderBy(`${this.entityName}.createdAt`, 'DESC');
-        return result;
-    }
-    async findByIdDirect(id) {
-        await this.ensureDataSourceRepository();
-        return await this.repository.findOne({
-            where: {
-                id
-            }
-        });
-    }
-    async getDefaultConfig(user) {
-        await this.ensureDataSourceRepository();
-        const baseWhere = buildCompanyWhereCondition({
-            isActive: true
-        }, this.storageConfig.isCompanyFeatureEnabled(), user);
-        const defaultConfig = await this.repository.findOne({
-            where: {
-                ...baseWhere,
-                isDefault: true
-            },
-            order: {
-                createdAt: 'ASC'
-            }
-        });
-        if (defaultConfig) {
-            return defaultConfig;
-        }
-        return await this.repository.findOne({
-            where: baseWhere,
-            order: {
-                createdAt: 'ASC'
-            }
-        });
-    }
-    async getConfigByType(storage, user) {
-        await this.ensureDataSourceRepository();
-        const where = buildCompanyWhereCondition({
-            storage,
-            isActive: true
-        }, this.storageConfig.isCompanyFeatureEnabled(), user);
-        return await this.repository.find({
-            where
-        });
-    }
-    constructor(cacheManager, utilsService, storageConfig, dataSourceProvider){
-        super(STORAGE_EVENT_ENTITIES.STORAGE_CONFIG, cacheManager, utilsService, StorageProviderConfigService.name, true, STORAGE_EVENT_MODULE, dataSourceProvider, storageConfig.isCompanyFeatureEnabled() ? StorageConfigWithCompany : StorageConfig), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "storageConfig", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.storageConfig = storageConfig;
-    }
-}
-StorageProviderConfigService = _ts_decorate([
-    Injectable({
-        scope: Scope.REQUEST
-    }),
-    _ts_param(0, Inject('CACHE_INSTANCE')),
-    _ts_param(1, Inject(UtilsService)),
-    _ts_param(2, Inject(StorageConfigService)),
-    _ts_param(3, Inject(StorageDataSourceProvider)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof HybridCache === "undefined" ? Object : HybridCache,
-        typeof UtilsService === "undefined" ? Object : UtilsService,
-        typeof StorageConfigService === "undefined" ? Object : StorageConfigService,
-        typeof StorageDataSourceProvider === "undefined" ? Object : StorageDataSourceProvider
-    ])
-], StorageProviderConfigService);

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

@@ -1,261 +0,0 @@
-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 module;
-    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')
-        };
-        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('entity selection', ()=>{
-        it('uses StorageConfig when the company feature is disabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(false);
-            const built = await module.resolve(StorageProviderConfigService);
-            expect(built['_entity']).toBe(StorageConfig);
-        });
-        it('uses StorageConfigWithCompany when the company feature is enabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const built = await module.resolve(StorageProviderConfigService);
-            expect(built['_entity']).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([]);
-        });
-    });
-    describe('beforeDeleteOperation', ()=>{
-        it('rejects deleting the default storage config', async ()=>{
-            mockRepo.find.mockResolvedValue([
-                buildStorageConfig({
-                    isDefault: true
-                })
-            ]);
-            await expect(service.beforeDeleteOperation({
-                id: 'config-uuid-1'
-            }, null, {})).rejects.toThrow('Cannot delete the default storage config');
-        });
-        it('allows deleting a non-default storage config', async ()=>{
-            mockRepo.find.mockResolvedValue([]);
-            await expect(service.beforeDeleteOperation({
-                id: 'config-uuid-1'
-            }, null, {})).resolves.toBeUndefined();
-        });
-    });
-});