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

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

@@ -1,149 +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 { EMAIL_CONFIG_MESSAGES, EMAIL_EVENT_ENTITIES, EMAIL_EVENT_MODULE } from '../config';
-import { EmailConfig, EmailConfigWithCompany } from '../entities';
-import { EmailConfigService } from './email-config.service';
-import { EmailDataSourceProvider } from './email-datasource.provider';
-export class EmailProviderConfigService 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 email config(s): ${names}. Set another config as default first.`,
-                messageKey: EMAIL_CONFIG_MESSAGES.DEFAULT_DELETE_FORBIDDEN,
-                messageVariables: {
-                    names
-                }
-            });
-        }
-    }
-    async convertSingleDtoToEntity(dto, user) {
-        const entity = {
-            ...dto
-        };
-        if (this.emailConfig.isCompanyFeatureEnabled()) {
-            entity.companyId = user?.companyId ?? null;
-        }
-        return entity;
-    }
-    async getSelectQuery(query, _user, select) {
-        if (!select?.length) {
-            select = [
-                'id',
-                'name',
-                'provider',
-                'config',
-                'fromEmail',
-                'fromName',
-                'isActive',
-                'isDefault',
-                'createdAt',
-                'updatedAt'
-            ];
-            if (this.emailConfig.isCompanyFeatureEnabled()) select.push('companyId');
-        }
-        query.select(select.map((field)=>`${this.entityName}.${field}`));
-        return {
-            query,
-            isRaw: false
-        };
-    }
-    async getExtraManipulateQuery(query, filterDto, user) {
-        const result = await super.getExtraManipulateQuery(query, filterDto, user);
-        applyCompanyFilter(query, {
-            isCompanyFeatureEnabled: this.emailConfig.isCompanyFeatureEnabled(),
-            entityAlias: 'emailConfig'
-        }, user);
-        query.orderBy(`${this.entityName}.createdAt`, 'DESC');
-        return result;
-    }
-    async findByIdDirect(id) {
-        await this.ensureDataSourceRepository();
-        return this.repository.findOne({
-            where: {
-                id
-            }
-        });
-    }
-    async getDefaultConfig(user) {
-        await this.ensureDataSourceRepository();
-        const baseWhere = buildCompanyWhereCondition({
-            isActive: true
-        }, this.emailConfig.isCompanyFeatureEnabled(), user);
-        const defaultConfig = await this.repository.findOne({
-            where: {
-                ...baseWhere,
-                isDefault: true
-            },
-            order: {
-                createdAt: 'ASC'
-            }
-        });
-        return defaultConfig || this.repository.findOne({
-            where: baseWhere,
-            order: {
-                createdAt: 'ASC'
-            }
-        });
-    }
-    constructor(cacheManager, utilsService, emailConfig, dataSourceProvider){
-        super(EMAIL_EVENT_ENTITIES.CONFIG, cacheManager, utilsService, EmailProviderConfigService.name, true, EMAIL_EVENT_MODULE, dataSourceProvider, emailConfig.isCompanyFeatureEnabled() ? EmailConfigWithCompany : EmailConfig), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "emailConfig", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.emailConfig = emailConfig;
-    }
-}
-EmailProviderConfigService = _ts_decorate([
-    Injectable({
-        scope: Scope.REQUEST
-    }),
-    _ts_param(0, Inject('CACHE_INSTANCE')),
-    _ts_param(1, Inject(UtilsService)),
-    _ts_param(2, Inject(EmailConfigService)),
-    _ts_param(3, Inject(EmailDataSourceProvider)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof HybridCache === "undefined" ? Object : HybridCache,
-        typeof UtilsService === "undefined" ? Object : UtilsService,
-        typeof EmailConfigService === "undefined" ? Object : EmailConfigService,
-        typeof EmailDataSourceProvider === "undefined" ? Object : EmailDataSourceProvider
-    ])
-], EmailProviderConfigService);

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

@@ -1,265 +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 { 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 module;
-    let mockRepo;
-    let mockEmailConfig;
-    beforeEach(async ()=>{
-        mockRepo = createMockRepository();
-        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
-        mockEmailConfig = {
-            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
-        };
-        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('entity selection', ()=>{
-        it('uses EmailConfig when the company feature is disabled', async ()=>{
-            mockEmailConfig.isCompanyFeatureEnabled.mockReturnValue(false);
-            const built = await module.resolve(EmailProviderConfigService);
-            expect(built['_entity']).toBe(EmailConfig);
-        });
-        it('uses EmailConfigWithCompany when the company feature is enabled', async ()=>{
-            mockEmailConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const built = await module.resolve(EmailProviderConfigService);
-            expect(built['_entity']).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'
-                }
-            });
-        });
-    });
-    describe('beforeDeleteOperation', ()=>{
-        it('rejects deleting the default email config', async ()=>{
-            mockRepo.find.mockResolvedValue([
-                buildEmailConfig({
-                    isDefault: true
-                })
-            ]);
-            await expect(service.beforeDeleteOperation({
-                id: 'config-uuid-1'
-            }, null, {})).rejects.toThrow('Cannot delete the default email config');
-        });
-        it('allows deleting a non-default email config', async ()=>{
-            mockRepo.find.mockResolvedValue([]);
-            await expect(service.beforeDeleteOperation({
-                id: 'config-uuid-1'
-            }, null, {})).resolves.toBeUndefined();
-        });
-    });
-});