@flusys/nestjs-email 6.0.2 → 6.1.1

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

@@ -0,0 +1,65 @@
+import { DEFAULT_FROM_NAME } from '../config/email.constants';
+import { EmailConfigService } from './email-config.service';
+function buildOptions(overrides = {}) {
+    return {
+        bootstrapAppConfig: undefined,
+        config: undefined,
+        ...overrides
+    };
+}
+describe('EmailConfigService', ()=>{
+    describe('isCompanyFeatureEnabled', ()=>{
+        it('returns false when bootstrapAppConfig is not provided', ()=>{
+            const service = new EmailConfigService(buildOptions());
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+        it('returns false when enableCompanyFeature is explicitly false', ()=>{
+            const service = new EmailConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    enableCompanyFeature: false
+                }
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+        it('returns true when enableCompanyFeature is true', ()=>{
+            const service = new EmailConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    enableCompanyFeature: true
+                }
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(true);
+        });
+    });
+    describe('getDatabaseMode / isMultiTenant', ()=>{
+        it('defaults to "single" when bootstrapAppConfig is missing', ()=>{
+            const service = new EmailConfigService(buildOptions());
+            expect(service.getDatabaseMode()).toBe('single');
+            expect(service.isMultiTenant()).toBe(false);
+        });
+        it('reflects "multi-tenant" mode from bootstrapAppConfig', ()=>{
+            const service = new EmailConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant'
+                }
+            }));
+            expect(service.getDatabaseMode()).toBe('multi-tenant');
+            expect(service.isMultiTenant()).toBe(true);
+        });
+    });
+    describe('getDefaultFromName', ()=>{
+        it('always returns the module-level DEFAULT_FROM_NAME constant', ()=>{
+            const service = new EmailConfigService(buildOptions());
+            expect(service.getDefaultFromName()).toBe(DEFAULT_FROM_NAME);
+            expect(service.getDefaultFromName()).toBe('FLUSYS');
+        });
+    });
+    describe('getOptions', ()=>{
+        it('returns the exact options object injected via the constructor', ()=>{
+            const options = buildOptions({
+                defaultProvider: 'smtp'
+            });
+            const service = new EmailConfigService(options);
+            expect(service.getOptions()).toBe(options);
+        });
+    });
+});

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

@@ -0,0 +1,131 @@
+import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
+import { EmailCompanyEntities, EmailCoreEntities } from '../entities';
+import { EmailDataSourceProvider } from './email-datasource.provider';
+function buildConfigService(overrides = {}) {
+    const options = {
+        bootstrapAppConfig: {
+            databaseMode: 'single',
+            enableCompanyFeature: false
+        },
+        config: {
+            defaultDatabaseConfig: {
+                type: 'mysql',
+                host: 'localhost',
+                database: 'flusys'
+            },
+            tenants: []
+        },
+        ...overrides
+    };
+    return {
+        isCompanyFeatureEnabled: jest.fn().mockReturnValue(options.bootstrapAppConfig?.enableCompanyFeature ?? false),
+        getDatabaseMode: jest.fn().mockReturnValue(options.bootstrapAppConfig?.databaseMode ?? 'single'),
+        isMultiTenant: jest.fn().mockReturnValue(options.bootstrapAppConfig?.databaseMode === 'multi-tenant'),
+        getDefaultFromName: jest.fn().mockReturnValue('FLUSYS'),
+        getOptions: jest.fn().mockReturnValue(options)
+    };
+}
+describe('EmailDataSourceProvider', ()=>{
+    afterEach(()=>{
+        jest.restoreAllMocks();
+        // Reset static state isolated to this subclass between tests.
+        EmailDataSourceProvider.singleDataSource = null;
+        EmailDataSourceProvider.initialized = false;
+        EmailDataSourceProvider.tenantsRegistry.clear();
+    });
+    it('propagates bootstrapAppConfig from EmailConfigService into the base data source service', ()=>{
+        const configService = buildConfigService({
+            bootstrapAppConfig: {
+                databaseMode: 'multi-tenant',
+                enableCompanyFeature: true
+            }
+        });
+        const provider = new EmailDataSourceProvider(configService);
+        expect(provider.isMultiTenant()).toBe(true);
+        expect(provider.getDatabaseMode()).toBe('multi-tenant');
+    });
+    it('defaults to single-database mode when bootstrapAppConfig is absent', ()=>{
+        const configService = buildConfigService({
+            bootstrapAppConfig: undefined
+        });
+        const provider = new EmailDataSourceProvider(configService);
+        expect(provider.isMultiTenant()).toBe(false);
+        expect(provider.getDatabaseMode()).toBe('single');
+    });
+    describe('getEnableCompanyFeatureForTenant', ()=>{
+        it('falls back to EmailConfigService.isCompanyFeatureEnabled() when no tenant is given', ()=>{
+            const configService = buildConfigService({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: true
+                }
+            });
+            const provider = new EmailDataSourceProvider(configService);
+            expect(provider.getEnableCompanyFeatureForTenant(undefined)).toBe(true);
+        });
+        it('prefers the tenant-level enableCompanyFeature flag over the module default', ()=>{
+            const configService = buildConfigService({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant',
+                    enableCompanyFeature: true
+                }
+            });
+            const provider = new EmailDataSourceProvider(configService);
+            expect(provider.getEnableCompanyFeatureForTenant({
+                id: 'tenant-1',
+                database: 'tenant_db',
+                enableCompanyFeature: false
+            })).toBe(false);
+        });
+        it('uses the module default when the tenant does not specify enableCompanyFeature', ()=>{
+            const configService = buildConfigService({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant',
+                    enableCompanyFeature: true
+                }
+            });
+            const provider = new EmailDataSourceProvider(configService);
+            expect(provider.getEnableCompanyFeatureForTenant({
+                id: 'tenant-1',
+                database: 'tenant_db'
+            })).toBe(true);
+        });
+    });
+    describe('createDataSourceFromConfig', ()=>{
+        it('resolves core (non-company) entities when the company feature is disabled', async ()=>{
+            const configService = buildConfigService({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: false
+                }
+            });
+            const provider = new EmailDataSourceProvider(configService);
+            const fakeDataSource = {};
+            const superSpy = jest.spyOn(MultiTenantDataSourceService.prototype, 'createDataSourceFromConfig').mockResolvedValue(fakeDataSource);
+            const config = {
+                type: 'mysql',
+                database: 'flusys'
+            };
+            const result = await provider.createDataSourceFromConfig(config);
+            expect(result).toBe(fakeDataSource);
+            expect(superSpy).toHaveBeenCalledWith(config, EmailCoreEntities);
+        });
+        it('resolves company-aware entities when the company feature is enabled', async ()=>{
+            const configService = buildConfigService({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: true
+                }
+            });
+            const provider = new EmailDataSourceProvider(configService);
+            const fakeDataSource = {};
+            const superSpy = jest.spyOn(MultiTenantDataSourceService.prototype, 'createDataSourceFromConfig').mockResolvedValue(fakeDataSource);
+            const config = {
+                type: 'mysql',
+                database: 'flusys'
+            };
+            await provider.createDataSourceFromConfig(config);
+            expect(superSpy).toHaveBeenCalledWith(config, EmailCompanyEntities);
+        });
+    });
+});

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

@@ -0,0 +1,243 @@
+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 { EmailConfig, EmailConfigWithCompany } from '../entities';
+import { EmailConfigService } from './email-config.service';
+import { EmailDataSourceProvider } from './email-datasource.provider';
+import { EmailProviderConfigService } from './email-provider-config.service';
+function buildEmailConfig(overrides = {}) {
+    return {
+        id: 'config-uuid-1',
+        name: 'Primary SMTP',
+        provider: 'smtp',
+        config: {
+            host: 'smtp.example.com'
+        },
+        fromEmail: 'noreply@example.com',
+        fromName: 'FLUSYS',
+        isActive: true,
+        isDefault: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+function buildQuery() {
+    return {
+        select: jest.fn().mockReturnThis(),
+        andWhere: jest.fn().mockReturnThis(),
+        orderBy: jest.fn().mockReturnThis()
+    };
+}
+describe('EmailProviderConfigService', ()=>{
+    let service;
+    let mockRepo;
+    let mockEmailConfig;
+    beforeEach(async ()=>{
+        mockRepo = createMockRepository();
+        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
+        mockEmailConfig = {
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
+        };
+        const module = await Test.createTestingModule({
+            providers: [
+                EmailProviderConfigService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {}
+                },
+                {
+                    provide: UtilsService,
+                    useValue: {}
+                },
+                {
+                    provide: EmailConfigService,
+                    useValue: mockEmailConfig
+                },
+                {
+                    provide: EmailDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                }
+            ]
+        }).compile();
+        service = await module.resolve(EmailProviderConfigService);
+    });
+    describe('resolveEntity', ()=>{
+        it('resolves the plain EmailConfig entity when the company feature is disabled', ()=>{
+            expect(service.resolveEntity()).toBe(EmailConfig);
+        });
+        it('resolves EmailConfigWithCompany when the company feature is enabled', ()=>{
+            mockEmailConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            expect(service.resolveEntity()).toBe(EmailConfigWithCompany);
+        });
+    });
+    describe('convertSingleDtoToEntity', ()=>{
+        it('does not attach companyId when the company feature is disabled', async ()=>{
+            const entity = await service.convertSingleDtoToEntity({
+                name: 'X',
+                provider: 'smtp',
+                config: {}
+            }, buildMockUser());
+            expect(entity.companyId).toBeUndefined();
+        });
+        it('attaches the current user companyId when the company feature is enabled', async ()=>{
+            mockEmailConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const entity = await service.convertSingleDtoToEntity({
+                name: 'X',
+                provider: 'smtp',
+                config: {}
+            }, buildMockUser({
+                companyId: 'company-uuid-42'
+            }));
+            expect(entity.companyId).toBe('company-uuid-42');
+        });
+        it('sets companyId to null when the company feature is enabled but no user is provided', async ()=>{
+            mockEmailConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const entity = await service.convertSingleDtoToEntity({
+                name: 'X',
+                provider: 'smtp',
+                config: {}
+            }, null);
+            expect(entity.companyId).toBeNull();
+        });
+    });
+    describe('getSelectQuery', ()=>{
+        it('selects the default whitelisted fields (without companyId) when company feature is disabled', async ()=>{
+            const query = buildQuery();
+            const { isRaw } = await service.getSelectQuery(query, buildMockUser());
+            expect(isRaw).toBe(false);
+            const [selected] = query.select.mock.calls[0];
+            expect(selected).toEqual(expect.arrayContaining([
+                'emailConfig.id',
+                'emailConfig.name',
+                'emailConfig.provider',
+                'emailConfig.config',
+                'emailConfig.fromEmail',
+                'emailConfig.fromName',
+                'emailConfig.isActive',
+                'emailConfig.isDefault',
+                'emailConfig.createdAt',
+                'emailConfig.updatedAt'
+            ]));
+            expect(selected).not.toContain('emailConfig.companyId');
+        });
+        it('appends companyId to the default field list when company feature is enabled', async ()=>{
+            mockEmailConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const query = buildQuery();
+            await service.getSelectQuery(query, buildMockUser());
+            const [selected] = query.select.mock.calls[0];
+            expect(selected).toContain('emailConfig.companyId');
+        });
+        it('respects an explicit select list instead of the defaults', async ()=>{
+            const query = buildQuery();
+            await service.getSelectQuery(query, buildMockUser(), [
+                'name'
+            ]);
+            expect(query.select).toHaveBeenCalledWith([
+                'emailConfig.name'
+            ]);
+        });
+    });
+    describe('getExtraManipulateQuery', ()=>{
+        it('applies the company filter and orders by createdAt DESC when company feature is enabled', async ()=>{
+            mockEmailConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const query = buildQuery();
+            await service.getExtraManipulateQuery(query, {}, buildMockUser({
+                companyId: 'c-1'
+            }));
+            expect(query.andWhere).toHaveBeenCalledWith('emailConfig.companyId = :companyId', {
+                companyId: 'c-1'
+            });
+            expect(query.orderBy).toHaveBeenCalledWith('emailConfig.createdAt', 'DESC');
+        });
+        it('skips the company filter when the company feature is disabled', async ()=>{
+            const query = buildQuery();
+            await service.getExtraManipulateQuery(query, {}, buildMockUser());
+            expect(query.andWhere).not.toHaveBeenCalled();
+            expect(query.orderBy).toHaveBeenCalledWith('emailConfig.createdAt', 'DESC');
+        });
+    });
+    describe('findByIdDirect', ()=>{
+        it('returns the matching config from the repository', async ()=>{
+            const config = buildEmailConfig();
+            mockRepo.findOne.mockResolvedValue(config);
+            const result = await service.findByIdDirect('config-uuid-1');
+            expect(result).toBe(config);
+            expect(mockRepo.findOne).toHaveBeenCalledWith({
+                where: {
+                    id: 'config-uuid-1'
+                }
+            });
+        });
+        it('returns null when no config matches', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            await expect(service.findByIdDirect('missing')).resolves.toBeNull();
+        });
+    });
+    describe('getDefaultConfig', ()=>{
+        it('returns the active default config when one is marked isDefault', async ()=>{
+            const defaultConfig = buildEmailConfig({
+                isDefault: true
+            });
+            mockRepo.findOne.mockResolvedValueOnce(defaultConfig);
+            const result = await service.getDefaultConfig(buildMockUser());
+            expect(result).toBe(defaultConfig);
+            expect(mockRepo.findOne).toHaveBeenCalledTimes(1);
+            expect(mockRepo.findOne).toHaveBeenCalledWith({
+                where: {
+                    isActive: true,
+                    isDefault: true
+                },
+                order: {
+                    createdAt: 'ASC'
+                }
+            });
+        });
+        it('falls back to the oldest active config when no default is marked', async ()=>{
+            const fallbackConfig = buildEmailConfig({
+                isDefault: false
+            });
+            mockRepo.findOne.mockResolvedValueOnce(null).mockResolvedValueOnce(fallbackConfig);
+            const result = await service.getDefaultConfig(buildMockUser());
+            expect(result).toBe(fallbackConfig);
+            expect(mockRepo.findOne).toHaveBeenCalledTimes(2);
+            expect(mockRepo.findOne).toHaveBeenNthCalledWith(2, {
+                where: {
+                    isActive: true
+                },
+                order: {
+                    createdAt: 'ASC'
+                }
+            });
+        });
+        it('returns null when there is no active config at all', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            await expect(service.getDefaultConfig(buildMockUser())).resolves.toBeNull();
+        });
+        it('scopes the lookup to the current company when the company feature is enabled', async ()=>{
+            mockEmailConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const defaultConfig = buildEmailConfig({
+                isDefault: true
+            });
+            mockRepo.findOne.mockResolvedValueOnce(defaultConfig);
+            await service.getDefaultConfig(buildMockUser({
+                companyId: 'company-uuid-9'
+            }));
+            expect(mockRepo.findOne).toHaveBeenCalledWith({
+                where: {
+                    isActive: true,
+                    companyId: 'company-uuid-9',
+                    isDefault: true
+                },
+                order: {
+                    createdAt: 'ASC'
+                }
+            });
+        });
+    });
+});