@flusys/nestjs-email 6.0.2 → 6.1.1

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

@@ -0,0 +1,542 @@
+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 { 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>');
+        });
+    });
+});