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

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

@@ -1,610 +0,0 @@
-import { Test } from '@nestjs/testing';
-import { BadRequestException } from '@nestjs/common';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { EmailFactoryService } from '../providers';
-import { EmailConfigService } from './email-config.service';
-import { EmailProviderConfigService } from './email-provider-config.service';
-import { EventBusRegistry } from '@flusys/nestjs-shared/classes';
-import { EmailSendService } from './email-send.service';
-import { EmailTemplateService } from './email-template.service';
-function buildConfig(overrides = {}) {
-    return {
-        id: 'config-uuid-1',
-        name: 'Primary SMTP',
-        provider: 'smtp',
-        config: {},
-        fromEmail: 'noreply@example.com',
-        fromName: 'FLUSYS',
-        isActive: true,
-        isDefault: true,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        deletedAt: null,
-        createdById: null,
-        updatedById: null,
-        deletedById: null,
-        ...overrides
-    };
-}
-function buildTemplate(overrides = {}) {
-    return {
-        id: 'template-uuid-1',
-        name: 'Welcome Email',
-        slug: 'welcome-email',
-        description: null,
-        subject: 'Welcome {{firstName}}!',
-        schema: {},
-        htmlContent: '<h1>Welcome {{firstName}}!</h1>',
-        textContent: 'Welcome {{firstName}}!',
-        schemaVersion: 1,
-        isActive: true,
-        isHtml: true,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        deletedAt: null,
-        createdById: null,
-        updatedById: null,
-        deletedById: null,
-        ...overrides
-    };
-}
-describe('EmailSendService', ()=>{
-    let service;
-    let mockEmailFactory;
-    let mockEmailConfigService;
-    let mockEmailProviderConfigService;
-    let mockEmailTemplateService;
-    let mockProvider;
-    beforeEach(async ()=>{
-        mockProvider = {
-            sendEmail: jest.fn().mockResolvedValue({
-                success: true,
-                messageId: 'msg-1'
-            }),
-            sendBulkEmails: jest.fn(),
-            healthCheck: jest.fn()
-        };
-        mockEmailFactory = {
-            createProvider: jest.fn().mockResolvedValue(mockProvider)
-        };
-        mockEmailConfigService = {
-            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false),
-            getDefaultFromName: jest.fn().mockReturnValue('FLUSYS')
-        };
-        mockEmailProviderConfigService = {
-            findByIdDirect: jest.fn(),
-            getDefaultConfig: jest.fn()
-        };
-        mockEmailTemplateService = {
-            findByIdDirect: jest.fn(),
-            findBySlug: jest.fn()
-        };
-        const module = await Test.createTestingModule({
-            providers: [
-                EmailSendService,
-                {
-                    provide: EmailFactoryService,
-                    useValue: mockEmailFactory
-                },
-                {
-                    provide: EmailConfigService,
-                    useValue: mockEmailConfigService
-                },
-                {
-                    provide: EmailProviderConfigService,
-                    useValue: mockEmailProviderConfigService
-                },
-                {
-                    provide: EmailTemplateService,
-                    useValue: mockEmailTemplateService
-                }
-            ]
-        }).compile();
-        service = await module.resolve(EmailSendService);
-    });
-    describe('sendEmail', ()=>{
-        it('resolves the config by id and forwards the payload to the provider', async ()=>{
-            const config = buildConfig();
-            mockEmailProviderConfigService.findByIdDirect.mockResolvedValue(config);
-            const dto = {
-                to: 'user@example.com',
-                subject: 'Hello',
-                html: '<p>Hi</p>',
-                emailConfigId: 'config-uuid-1'
-            };
-            const result = await service.sendEmail(dto, buildMockUser());
-            expect(result).toEqual({
-                success: true,
-                messageId: 'msg-1'
-            });
-            expect(mockEmailFactory.createProvider).toHaveBeenCalledWith({
-                provider: config.provider,
-                config: config.config
-            });
-            expect(mockProvider.sendEmail).toHaveBeenCalledWith(expect.objectContaining({
-                to: 'user@example.com',
-                subject: 'Hello',
-                html: '<p>Hi</p>',
-                from: 'noreply@example.com',
-                fromName: 'FLUSYS'
-            }));
-        });
-        it('falls back to the default config when no emailConfigId is supplied', async ()=>{
-            const config = buildConfig();
-            mockEmailProviderConfigService.getDefaultConfig.mockResolvedValue(config);
-            await service.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi',
-                html: '<p/>'
-            }, buildMockUser());
-            expect(mockEmailProviderConfigService.getDefaultConfig).toHaveBeenCalledWith(buildMockUser());
-            expect(mockEmailProviderConfigService.findByIdDirect).not.toHaveBeenCalled();
-        });
-        it('prefers dto.from/fromName over the config defaults', async ()=>{
-            const config = buildConfig({
-                fromEmail: 'config@example.com',
-                fromName: 'Config Name'
-            });
-            mockEmailProviderConfigService.getDefaultConfig.mockResolvedValue(config);
-            await service.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi',
-                html: '<p/>',
-                from: 'override@example.com',
-                fromName: 'Override Name'
-            }, buildMockUser());
-            expect(mockProvider.sendEmail).toHaveBeenCalledWith(expect.objectContaining({
-                from: 'override@example.com',
-                fromName: 'Override Name'
-            }));
-        });
-        it('base64-decodes attachment content before forwarding to the provider', async ()=>{
-            mockEmailProviderConfigService.getDefaultConfig.mockResolvedValue(buildConfig());
-            await service.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi',
-                html: '<p/>',
-                attachments: [
-                    {
-                        filename: 'a.txt',
-                        content: Buffer.from('hello').toString('base64')
-                    }
-                ]
-            }, buildMockUser());
-            const [payload] = mockProvider.sendEmail.mock.calls[0];
-            expect(payload.attachments?.[0].content.toString('utf8')).toBe('hello');
-        });
-        it('throws NotFoundException with CONFIG_NOT_FOUND when the referenced config does not exist', async ()=>{
-            mockEmailProviderConfigService.findByIdDirect.mockResolvedValue(null);
-            await expect(service.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi',
-                html: '<p/>',
-                emailConfigId: 'missing'
-            }, buildMockUser())).rejects.toMatchObject({
-                response: expect.objectContaining({
-                    messageKey: 'email.send.config.not.found'
-                })
-            });
-        });
-        it('throws BadRequestException with CONFIG_INACTIVE when the config is inactive', async ()=>{
-            mockEmailProviderConfigService.findByIdDirect.mockResolvedValue(buildConfig({
-                isActive: false
-            }));
-            await expect(service.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi',
-                html: '<p/>',
-                emailConfigId: 'c-1'
-            }, buildMockUser())).rejects.toMatchObject({
-                response: expect.objectContaining({
-                    messageKey: 'email.send.config.inactive'
-                })
-            });
-        });
-        it('rejects a config belonging to another company when the company feature is enabled', async ()=>{
-            mockEmailConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
-            mockEmailProviderConfigService.findByIdDirect.mockResolvedValue(buildConfig({
-                companyId: 'other-company'
-            }));
-            await expect(service.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi',
-                html: '<p/>',
-                emailConfigId: 'c-1'
-            }, buildMockUser({
-                companyId: 'my-company'
-            }))).rejects.toThrow(BadRequestException);
-        });
-        it('throws NotFoundException with CONFIG_DEFAULT_NOT_FOUND when no default config exists', async ()=>{
-            mockEmailProviderConfigService.getDefaultConfig.mockResolvedValue(null);
-            await expect(service.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi',
-                html: '<p/>'
-            }, buildMockUser())).rejects.toMatchObject({
-                response: expect.objectContaining({
-                    messageKey: 'email.send.config.default.not.found'
-                })
-            });
-        });
-    });
-    describe('sendTemplateEmail — template resolution', ()=>{
-        beforeEach(()=>{
-            mockEmailProviderConfigService.getDefaultConfig.mockResolvedValue(buildConfig());
-        });
-        it('resolves the template by templateId when provided', async ()=>{
-            mockEmailTemplateService.findByIdDirect.mockResolvedValue(buildTemplate());
-            await service.sendTemplateEmail({
-                to: 'a@example.com',
-                templateId: 'template-uuid-1'
-            }, buildMockUser());
-            expect(mockEmailTemplateService.findByIdDirect).toHaveBeenCalledWith('template-uuid-1');
-            expect(mockEmailTemplateService.findBySlug).not.toHaveBeenCalled();
-        });
-        it('resolves the template by templateSlug when templateId is absent', async ()=>{
-            mockEmailTemplateService.findBySlug.mockResolvedValue(buildTemplate());
-            const user = buildMockUser();
-            await service.sendTemplateEmail({
-                to: 'a@example.com',
-                templateSlug: 'welcome-email'
-            }, user);
-            expect(mockEmailTemplateService.findBySlug).toHaveBeenCalledWith('welcome-email', user);
-        });
-        it('throws BadRequestException with TEMPLATE_ID_OR_SLUG_REQUIRED when neither is provided', async ()=>{
-            await expect(service.sendTemplateEmail({
-                to: 'a@example.com'
-            }, buildMockUser())).rejects.toMatchObject({
-                response: expect.objectContaining({
-                    messageKey: 'email.send.template.id.or.slug.required'
-                })
-            });
-        });
-        it('throws NotFoundException with TEMPLATE_NOT_FOUND when the template does not exist', async ()=>{
-            mockEmailTemplateService.findByIdDirect.mockResolvedValue(null);
-            await expect(service.sendTemplateEmail({
-                to: 'a@example.com',
-                templateId: 'missing'
-            }, buildMockUser())).rejects.toMatchObject({
-                response: expect.objectContaining({
-                    messageKey: 'email.send.template.not.found'
-                })
-            });
-        });
-        it('throws BadRequestException with TEMPLATE_INACTIVE when the template is inactive', async ()=>{
-            mockEmailTemplateService.findByIdDirect.mockResolvedValue(buildTemplate({
-                isActive: false
-            }));
-            await expect(service.sendTemplateEmail({
-                to: 'a@example.com',
-                templateId: 'template-uuid-1'
-            }, buildMockUser())).rejects.toMatchObject({
-                response: expect.objectContaining({
-                    messageKey: 'email.send.template.inactive'
-                })
-            });
-        });
-        it('rejects a template belonging to another company when the company feature is enabled', async ()=>{
-            mockEmailConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
-            mockEmailTemplateService.findByIdDirect.mockResolvedValue(buildTemplate({
-                companyId: 'other-company'
-            }));
-            await expect(service.sendTemplateEmail({
-                to: 'a@example.com',
-                templateId: 'template-uuid-1'
-            }, buildMockUser({
-                companyId: 'my-company'
-            }))).rejects.toThrow(BadRequestException);
-        });
-    });
-    describe('sendTemplateEmail — variable interpolation & XSS safety', ()=>{
-        beforeEach(()=>{
-            mockEmailProviderConfigService.getDefaultConfig.mockResolvedValue(buildConfig());
-        });
-        it('HTML-escapes untrusted variables in the html body', async ()=>{
-            mockEmailTemplateService.findByIdDirect.mockResolvedValue(buildTemplate({
-                subject: 'Hi {{name}}',
-                htmlContent: '<p>Hi {{name}}</p>',
-                isHtml: true
-            }));
-            await service.sendTemplateEmail({
-                to: 'a@example.com',
-                templateId: 'template-uuid-1',
-                variables: {
-                    name: '<script>alert(1)</script>'
-                }
-            }, buildMockUser());
-            const [payload] = mockProvider.sendEmail.mock.calls[0];
-            expect(payload.html).toBe('<p>Hi &lt;script&gt;alert(1)&lt;&#x2F;script&gt;</p>');
-            expect(payload.html).not.toContain('<script>');
-        });
-        it('does NOT escape variables interpolated into the subject line', async ()=>{
-            mockEmailTemplateService.findByIdDirect.mockResolvedValue(buildTemplate({
-                subject: 'Hi {{name}}',
-                isHtml: true
-            }));
-            await service.sendTemplateEmail({
-                to: 'a@example.com',
-                templateId: 'template-uuid-1',
-                variables: {
-                    name: '<b>Bob</b>'
-                }
-            }, buildMockUser());
-            const [payload] = mockProvider.sendEmail.mock.calls[0];
-            expect(payload.subject).toBe('Hi <b>Bob</b>');
-        });
-        it('does not escape variables interpolated into plain-text content', async ()=>{
-            mockEmailTemplateService.findByIdDirect.mockResolvedValue(buildTemplate({
-                isHtml: false,
-                textContent: 'Hi {{name}}'
-            }));
-            await service.sendTemplateEmail({
-                to: 'a@example.com',
-                templateId: 'template-uuid-1',
-                variables: {
-                    name: '<script>x</script>'
-                }
-            }, buildMockUser());
-            const [payload] = mockProvider.sendEmail.mock.calls[0];
-            expect(payload.text).toBe('Hi <script>x</script>');
-            expect(payload.html).toBeUndefined();
-        });
-        it('falls back to htmlContent as text when isHtml is false and textContent is empty', async ()=>{
-            mockEmailTemplateService.findByIdDirect.mockResolvedValue(buildTemplate({
-                isHtml: false,
-                textContent: null,
-                htmlContent: 'Plain {{name}}'
-            }));
-            await service.sendTemplateEmail({
-                to: 'a@example.com',
-                templateId: 'template-uuid-1',
-                variables: {
-                    name: 'Bob'
-                }
-            }, buildMockUser());
-            const [payload] = mockProvider.sendEmail.mock.calls[0];
-            expect(payload.text).toBe('Plain Bob');
-        });
-        it('leaves unresolved {{variable}} tokens untouched when the variable is missing', async ()=>{
-            mockEmailTemplateService.findByIdDirect.mockResolvedValue(buildTemplate({
-                htmlContent: '<p>Hi {{missing}}</p>',
-                isHtml: true
-            }));
-            await service.sendTemplateEmail({
-                to: 'a@example.com',
-                templateId: 'template-uuid-1',
-                variables: {
-                    unrelated: 'value'
-                }
-            }, buildMockUser());
-            const [payload] = mockProvider.sendEmail.mock.calls[0];
-            expect(payload.html).toBe('<p>Hi {{missing}}</p>');
-        });
-        it('substitutes a repeated variable token every time it appears', async ()=>{
-            mockEmailTemplateService.findByIdDirect.mockResolvedValue(buildTemplate({
-                htmlContent: '<p>{{name}} and {{name}} again</p>',
-                isHtml: true
-            }));
-            await service.sendTemplateEmail({
-                to: 'a@example.com',
-                templateId: 'template-uuid-1',
-                variables: {
-                    name: 'Bob'
-                }
-            }, buildMockUser());
-            const [payload] = mockProvider.sendEmail.mock.calls[0];
-            expect(payload.html).toBe('<p>Bob and Bob again</p>');
-        });
-        it('interpolates multiple distinct variables in the same content string', async ()=>{
-            mockEmailTemplateService.findByIdDirect.mockResolvedValue(buildTemplate({
-                htmlContent: '<p>{{greeting}}, {{name}}!</p>',
-                isHtml: true
-            }));
-            await service.sendTemplateEmail({
-                to: 'a@example.com',
-                templateId: 'template-uuid-1',
-                variables: {
-                    greeting: 'Hello',
-                    name: 'Bob'
-                }
-            }, buildMockUser());
-            const [payload] = mockProvider.sendEmail.mock.calls[0];
-            expect(payload.html).toBe('<p>Hello, Bob!</p>');
-        });
-        it('stringifies and escapes non-string variables (numbers, objects)', async ()=>{
-            mockEmailTemplateService.findByIdDirect.mockResolvedValue(buildTemplate({
-                htmlContent: '<p>Count: {{count}}, Meta: {{meta}}</p>',
-                isHtml: true
-            }));
-            await service.sendTemplateEmail({
-                to: 'a@example.com',
-                templateId: 'template-uuid-1',
-                variables: {
-                    count: 5,
-                    meta: {
-                        a: '<b>'
-                    }
-                }
-            }, buildMockUser());
-            const [payload] = mockProvider.sendEmail.mock.calls[0];
-            expect(payload.html).toContain('Count: 5');
-            expect(payload.html).toContain('&quot;a&quot;');
-            expect(payload.html).not.toContain('<b>');
-        });
-        it('treats null/undefined variables as empty strings', async ()=>{
-            mockEmailTemplateService.findByIdDirect.mockResolvedValue(buildTemplate({
-                htmlContent: '<p>[{{missingVar}}]</p>',
-                isHtml: true
-            }));
-            await service.sendTemplateEmail({
-                to: 'a@example.com',
-                templateId: 'template-uuid-1',
-                variables: {
-                    missingVar: null
-                }
-            }, buildMockUser());
-            const [payload] = mockProvider.sendEmail.mock.calls[0];
-            expect(payload.html).toBe('<p>[]</p>');
-        });
-        it('returns the content unchanged when no variables are supplied', async ()=>{
-            mockEmailTemplateService.findByIdDirect.mockResolvedValue(buildTemplate({
-                htmlContent: '<p>Hi {{name}}</p>',
-                isHtml: true
-            }));
-            await service.sendTemplateEmail({
-                to: 'a@example.com',
-                templateId: 'template-uuid-1'
-            }, buildMockUser());
-            const [payload] = mockProvider.sendEmail.mock.calls[0];
-            expect(payload.html).toBe('<p>Hi {{name}}</p>');
-        });
-    });
-    describe('sendTemplateEmail — provider dispatch', ()=>{
-        it('resolves the provider from the resolved config and sends the interpolated content', async ()=>{
-            const config = buildConfig({
-                id: 'config-uuid-9',
-                provider: 'sendgrid',
-                config: {
-                    apiKey: 'x'
-                }
-            });
-            mockEmailProviderConfigService.findByIdDirect.mockResolvedValue(config);
-            mockEmailTemplateService.findByIdDirect.mockResolvedValue(buildTemplate());
-            const result = await service.sendTemplateEmail({
-                to: 'a@example.com',
-                templateId: 'template-uuid-1',
-                emailConfigId: 'config-uuid-9',
-                variables: {
-                    firstName: 'Bob'
-                }
-            }, buildMockUser());
-            expect(result).toEqual({
-                success: true,
-                messageId: 'msg-1'
-            });
-            expect(mockEmailFactory.createProvider).toHaveBeenCalledWith({
-                provider: 'sendgrid',
-                config: {
-                    apiKey: 'x'
-                }
-            });
-            expect(mockProvider.sendEmail).toHaveBeenCalledWith(expect.objectContaining({
-                subject: 'Welcome Bob!',
-                html: '<h1>Welcome Bob!</h1>'
-            }));
-        });
-        it('propagates a provider-level send failure result without throwing', async ()=>{
-            mockEmailProviderConfigService.getDefaultConfig.mockResolvedValue(buildConfig());
-            mockEmailTemplateService.findByIdDirect.mockResolvedValue(buildTemplate());
-            mockProvider.sendEmail.mockResolvedValue({
-                success: false,
-                error: 'Connection refused'
-            });
-            const result = await service.sendTemplateEmail({
-                to: 'a@example.com',
-                templateId: 'template-uuid-1'
-            }, buildMockUser());
-            expect(result).toEqual({
-                success: false,
-                error: 'Connection refused'
-            });
-        });
-    });
-    describe('sendTestEmail', ()=>{
-        it('sends a test email using the resolved configuration and returns the provider result', async ()=>{
-            const config = buildConfig({
-                name: 'Prod SMTP',
-                provider: 'smtp'
-            });
-            mockEmailProviderConfigService.findByIdDirect.mockResolvedValue(config);
-            const result = await service.sendTestEmail('config-uuid-1', 'recipient@example.com', buildMockUser());
-            expect(result).toEqual({
-                success: true,
-                messageId: 'msg-1'
-            });
-            expect(mockProvider.sendEmail).toHaveBeenCalledWith(expect.objectContaining({
-                to: 'recipient@example.com',
-                subject: 'Test Email from FLUSYS',
-                from: 'noreply@example.com'
-            }));
-        });
-        it('HTML-escapes the config name/provider before embedding them in the test email body', async ()=>{
-            const config = buildConfig({
-                name: '<script>alert(1)</script>',
-                provider: 'smtp'
-            });
-            mockEmailProviderConfigService.findByIdDirect.mockResolvedValue(config);
-            await service.sendTestEmail('config-uuid-1', 'recipient@example.com', buildMockUser());
-            const [payload] = mockProvider.sendEmail.mock.calls[0];
-            expect(payload.html).toContain('&lt;script&gt;alert(1)&lt;&#x2F;script&gt;');
-            expect(payload.html).not.toContain('<script>alert(1)</script>');
-        });
-    });
-    describe('domain events', ()=>{
-        let publish;
-        beforeEach(()=>{
-            publish = jest.fn().mockResolvedValue(undefined);
-            EventBusRegistry.reset();
-            EventBusRegistry.setBus({
-                publish,
-                subscribe: jest.fn(),
-                close: jest.fn()
-            });
-            EventBusRegistry.configureModule('email', {
-                enabled: true
-            });
-            mockEmailProviderConfigService.findByIdDirect.mockResolvedValue(buildConfig());
-        });
-        afterEach(()=>{
-            EventBusRegistry.reset();
-        });
-        it('publishes email.email_message.sent for a successful send', async ()=>{
-            await service.sendEmail({
-                to: 'user@example.com',
-                subject: 'Hi',
-                emailConfigId: 'config-uuid-1'
-            }, buildMockUser());
-            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'email.email_message.sent',
-                payload: expect.objectContaining({
-                    ids: [
-                        'msg-1'
-                    ],
-                    metadata: expect.objectContaining({
-                        recipientCount: 1
-                    })
-                })
-            }));
-        });
-        it('publishes email.email_message.failed when the provider reports a failure', async ()=>{
-            mockProvider.sendEmail.mockResolvedValue({
-                success: false,
-                error: 'smtp refused'
-            });
-            await service.sendEmail({
-                to: 'user@example.com',
-                subject: 'Hi',
-                emailConfigId: 'config-uuid-1'
-            }, buildMockUser());
-            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'email.email_message.failed',
-                payload: expect.objectContaining({
-                    metadata: expect.objectContaining({
-                        error: 'smtp refused'
-                    })
-                })
-            }));
-        });
-        it('does not publish when the email module has events disabled', async ()=>{
-            EventBusRegistry.configureModule('email', {
-                enabled: false
-            });
-            await service.sendEmail({
-                to: 'user@example.com',
-                subject: 'Hi',
-                emailConfigId: 'config-uuid-1'
-            }, buildMockUser());
-            expect(publish).not.toHaveBeenCalled();
-        });
-    });
-});