@flusys/nestjs-email 6.0.2 → 6.1.1

package/cjs/controllers/email-config.controller.spec.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _emailconfigcontroller = require("./email-config.controller");
+function buildEmailConfig(overrides = {}) {
+    return {
+        id: 'email-config-1',
+        provider: 'smtp',
+        isActive: true,
+        isDefault: true,
+        readOnly: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides
+    };
+}
+describe('EmailConfigController', ()=>{
+    let controller;
+    let mockEmailConfigService;
+    beforeEach(()=>{
+        mockEmailConfigService = {
+            insert: jest.fn(),
+            findById: jest.fn(),
+            getAll: jest.fn(),
+            update: jest.fn(),
+            delete: jest.fn()
+        };
+        controller = new _emailconfigcontroller.EmailConfigController(mockEmailConfigService);
+    });
+    it('wires the injected service onto the generated controller base', ()=>{
+        expect(controller.emailConfigService).toBe(mockEmailConfigService);
+        expect(controller.service).toBe(mockEmailConfigService);
+    });
+    describe('insert', ()=>{
+        it('creates an email config and returns the mapped response', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockEmailConfigService.insert.mockResolvedValue(buildEmailConfig());
+            const result = await controller.insert({
+                provider: 'smtp'
+            }, user);
+            expect(mockEmailConfigService.insert).toHaveBeenCalledWith({
+                provider: 'smtp'
+            }, user);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(expect.objectContaining({
+                id: 'email-config-1'
+            }));
+        });
+    });
+    describe('getAll', ()=>{
+        it('paginates email configs and maps the response list', async ()=>{
+            mockEmailConfigService.getAll.mockResolvedValue({
+                data: [
+                    buildEmailConfig()
+                ],
+                total: 1
+            });
+            const result = await controller.getAll({}, (0, _loggedusermock.buildMockUser)(), '');
+            expect(mockEmailConfigService.getAll).toHaveBeenCalledWith('', {}, (0, _loggedusermock.buildMockUser)());
+            expect(result.data).toHaveLength(1);
+        });
+    });
+    describe('delete', ()=>{
+        it('delegates soft-delete to the service', async ()=>{
+            mockEmailConfigService.delete.mockResolvedValue({
+                count: 1
+            });
+            const result = await controller.delete({
+                id: [
+                    'email-config-1'
+                ],
+                type: 'delete'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(mockEmailConfigService.delete).toHaveBeenCalledWith({
+                id: [
+                    'email-config-1'
+                ],
+                type: 'delete'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result.success).toBe(true);
+        });
+    });
+});

package/cjs/controllers/email-send.controller.spec.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _testing = require("@nestjs/testing");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _emailsendcontroller = require("./email-send.controller");
+const _services = require("../services");
+describe('EmailSendController', ()=>{
+    let controller;
+    let mockService;
+    beforeEach(async ()=>{
+        mockService = {
+            sendEmail: jest.fn(),
+            sendTemplateEmail: jest.fn(),
+            sendTestEmail: jest.fn()
+        };
+        const module = await _testing.Test.createTestingModule({
+            controllers: [
+                _emailsendcontroller.EmailSendController
+            ],
+            providers: [
+                {
+                    provide: _services.EmailSendService,
+                    useValue: mockService
+                }
+            ]
+        }).compile();
+        controller = module.get(_emailsendcontroller.EmailSendController);
+    });
+    describe('sendEmail', ()=>{
+        it('delegates to the service and returns a success response', async ()=>{
+            mockService.sendEmail.mockResolvedValue({
+                success: true,
+                messageId: 'msg-1'
+            });
+            const dto = {
+                to: 'a@example.com',
+                subject: 'Hi',
+                html: '<p/>'
+            };
+            const user = (0, _loggedusermock.buildMockUser)();
+            const result = await controller.sendEmail(dto, user);
+            expect(mockService.sendEmail).toHaveBeenCalledWith(dto, user);
+            expect(result).toEqual({
+                success: true,
+                message: 'Email sent successfully',
+                messageKey: 'email.send.success',
+                data: {
+                    success: true,
+                    messageId: 'msg-1',
+                    error: undefined
+                }
+            });
+        });
+        it('returns a failure response with the FAILED messageKey when the send fails', async ()=>{
+            mockService.sendEmail.mockResolvedValue({
+                success: false,
+                error: 'SMTP down'
+            });
+            const result = await controller.sendEmail({
+                to: 'a@example.com',
+                subject: 'Hi',
+                html: '<p/>'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result).toEqual({
+                success: false,
+                message: 'Failed to send email',
+                messageKey: 'email.send.failed',
+                data: {
+                    success: false,
+                    messageId: undefined,
+                    error: 'SMTP down'
+                }
+            });
+        });
+    });
+    describe('sendTemplateEmail', ()=>{
+        it('delegates to the service and returns a success response', async ()=>{
+            mockService.sendTemplateEmail.mockResolvedValue({
+                success: true,
+                messageId: 'msg-2'
+            });
+            const dto = {
+                to: 'a@example.com',
+                templateSlug: 'welcome'
+            };
+            const user = (0, _loggedusermock.buildMockUser)();
+            const result = await controller.sendTemplateEmail(dto, user);
+            expect(mockService.sendTemplateEmail).toHaveBeenCalledWith(dto, user);
+            expect(result.success).toBe(true);
+            expect(result.messageKey).toBe('email.send.success');
+            expect(result.message).toBe('Template email sent successfully');
+        });
+        it('returns a failure response when the template send fails', async ()=>{
+            mockService.sendTemplateEmail.mockResolvedValue({
+                success: false,
+                error: 'Template error'
+            });
+            const result = await controller.sendTemplateEmail({
+                to: 'a@example.com',
+                templateSlug: 'welcome'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result.success).toBe(false);
+            expect(result.messageKey).toBe('email.send.failed');
+            expect(result.message).toBe('Failed to send template email');
+        });
+    });
+    describe('sendTestEmail', ()=>{
+        it('delegates to the service with the emailConfigId and recipient from the dto', async ()=>{
+            mockService.sendTestEmail.mockResolvedValue({
+                success: true,
+                messageId: 'msg-3'
+            });
+            const dto = {
+                emailConfigId: 'config-1',
+                recipient: 'a@example.com'
+            };
+            const user = (0, _loggedusermock.buildMockUser)();
+            const result = await controller.sendTestEmail(dto, user);
+            expect(mockService.sendTestEmail).toHaveBeenCalledWith('config-1', 'a@example.com', user);
+            expect(result.success).toBe(true);
+            expect(result.message).toBe('Test email sent successfully');
+        });
+        it('returns a failure response when the test send fails', async ()=>{
+            mockService.sendTestEmail.mockResolvedValue({
+                success: false,
+                error: 'Bad config'
+            });
+            const result = await controller.sendTestEmail({
+                emailConfigId: 'config-1',
+                recipient: 'a@example.com'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result.success).toBe(false);
+            expect(result.message).toBe('Failed to send test email');
+            expect(result.messageKey).toBe('email.send.failed');
+        });
+    });
+});

package/cjs/controllers/email-template.controller.spec.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _common = require("@nestjs/common");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _emailtemplatecontroller = require("./email-template.controller");
+function buildTemplate(overrides = {}) {
+    return {
+        id: 'template-1',
+        slug: 'password-reset',
+        subject: 'Reset your password',
+        body: '<p>Hello {{name}}</p>',
+        isActive: true,
+        readOnly: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides
+    };
+}
+describe('EmailTemplateController', ()=>{
+    let controller;
+    let mockEmailTemplateService;
+    beforeEach(()=>{
+        mockEmailTemplateService = {
+            insert: jest.fn(),
+            findById: jest.fn(),
+            getAll: jest.fn(),
+            update: jest.fn(),
+            delete: jest.fn(),
+            findBySlug: jest.fn()
+        };
+        controller = new _emailtemplatecontroller.EmailTemplateController(mockEmailTemplateService);
+    });
+    it('wires the injected service onto the generated controller base', ()=>{
+        expect(controller.emailTemplateService).toBe(mockEmailTemplateService);
+        expect(controller.service).toBe(mockEmailTemplateService);
+    });
+    describe('insert', ()=>{
+        it('creates an email template and returns the mapped response', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockEmailTemplateService.insert.mockResolvedValue(buildTemplate());
+            const result = await controller.insert({
+                slug: 'password-reset'
+            }, user);
+            expect(mockEmailTemplateService.insert).toHaveBeenCalledWith({
+                slug: 'password-reset'
+            }, user);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(expect.objectContaining({
+                id: 'template-1'
+            }));
+        });
+    });
+    describe('getAll', ()=>{
+        it('paginates templates and maps the response list', async ()=>{
+            mockEmailTemplateService.getAll.mockResolvedValue({
+                data: [
+                    buildTemplate()
+                ],
+                total: 1
+            });
+            const result = await controller.getAll({}, (0, _loggedusermock.buildMockUser)(), '');
+            expect(mockEmailTemplateService.getAll).toHaveBeenCalledWith('', {}, (0, _loggedusermock.buildMockUser)());
+            expect(result.data).toHaveLength(1);
+        });
+    });
+    describe('getBySlug', ()=>{
+        it('returns the template matching the given slug', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockEmailTemplateService.findBySlug.mockResolvedValue(buildTemplate());
+            const result = await controller.getBySlug({
+                slug: 'password-reset'
+            }, user);
+            expect(mockEmailTemplateService.findBySlug).toHaveBeenCalledWith('password-reset', user);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(expect.objectContaining({
+                slug: 'password-reset'
+            }));
+        });
+        it('throws NotFoundException when no template matches the slug', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockEmailTemplateService.findBySlug.mockResolvedValue(null);
+            await expect(controller.getBySlug({
+                slug: 'missing'
+            }, user)).rejects.toThrow(_common.NotFoundException);
+        });
+    });
+});

package/cjs/docs/email-swagger.config.spec.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _emailswaggerconfig = require("./email-swagger.config");
+describe('emailSwaggerConfig', ()=>{
+    it('should default to company feature enabled and single-database mode when no config is given', ()=>{
+        const config = (0, _emailswaggerconfig.emailSwaggerConfig)();
+        expect(config.title).toBe('Email API');
+        expect(config.bearerAuth).toBe(true);
+        expect(config.excludeSchemaProperties).toBeUndefined();
+        expect(config.description).not.toContain('Multi-Tenant Mode');
+    });
+    it('should exclude companyId schema properties when the company feature is disabled', ()=>{
+        const config = (0, _emailswaggerconfig.emailSwaggerConfig)({
+            enableCompanyFeature: false
+        });
+        expect(config.excludeSchemaProperties).toEqual([
+            {
+                schemaName: 'EmailConfigResponseDto',
+                properties: [
+                    'companyId'
+                ]
+            },
+            {
+                schemaName: 'EmailTemplateResponseDto',
+                properties: [
+                    'companyId'
+                ]
+            }
+        ]);
+    });
+    it('should not exclude any schema properties when the company feature is enabled', ()=>{
+        const config = (0, _emailswaggerconfig.emailSwaggerConfig)({
+            enableCompanyFeature: true
+        });
+        expect(config.excludeSchemaProperties).toBeUndefined();
+    });
+    it('should describe company isolation and multi-tenant support only when the company feature is enabled', ()=>{
+        const withCompany = (0, _emailswaggerconfig.emailSwaggerConfig)({
+            enableCompanyFeature: true
+        });
+        const withoutCompany = (0, _emailswaggerconfig.emailSwaggerConfig)({
+            enableCompanyFeature: false
+        });
+        expect(withCompany.description).toContain('Company isolation');
+        expect(withCompany.description).toContain('## Multi-Tenant Support');
+        expect(withCompany.description).toContain('with multi-tenant and company support');
+        expect(withoutCompany.description).not.toContain('Company isolation');
+        expect(withoutCompany.description).not.toContain('## Multi-Tenant Support');
+    });
+    it('should mention multi-tenant mode in the description only for multi-tenant database mode', ()=>{
+        const multiTenant = (0, _emailswaggerconfig.emailSwaggerConfig)({
+            databaseMode: 'multi-tenant'
+        });
+        const single = (0, _emailswaggerconfig.emailSwaggerConfig)({
+            databaseMode: 'single'
+        });
+        expect(multiTenant.description).toContain('Multi-Tenant Mode');
+        expect(single.description).not.toContain('Multi-Tenant Mode');
+    });
+});

package/cjs/entities/index.spec.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _index = require("./index");
+describe('getEmailEntitiesByConfig', ()=>{
+    it('returns the core entities when the company feature is disabled', ()=>{
+        expect((0, _index.getEmailEntitiesByConfig)(false)).toBe(_index.EmailCoreEntities);
+    });
+    it('returns the company-scoped entities when the company feature is enabled', ()=>{
+        expect((0, _index.getEmailEntitiesByConfig)(true)).toBe(_index.EmailCompanyEntities);
+    });
+    it('core and company entity sets are disjoint (never mixed)', ()=>{
+        const core = (0, _index.getEmailEntitiesByConfig)(false);
+        const company = (0, _index.getEmailEntitiesByConfig)(true);
+        expect(core.some((e)=>company.includes(e))).toBe(false);
+    });
+});

package/cjs/modules/email.module.spec.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _emailmodule = require("./email.module");
+const _emailconstants = require("../config/email.constants");
+const _controllers = require("../controllers");
+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 providerTokens(providers) {
+    return providers.map((p)=>typeof p === 'function' ? p : p.provide);
+}
+describe('EmailModule', ()=>{
+    describe('forRoot', ()=>{
+        it('should default to a non-global module with all controllers registered', ()=>{
+            const dynamicModule = _emailmodule.EmailModule.forRoot({});
+            expect(dynamicModule.module).toBe(_emailmodule.EmailModule);
+            expect(dynamicModule.global).toBe(false);
+            expect(dynamicModule.controllers).toEqual([
+                _controllers.EmailConfigController,
+                _controllers.EmailTemplateController,
+                _controllers.EmailSendController
+            ]);
+        });
+        it('should respect global: true', ()=>{
+            expect(_emailmodule.EmailModule.forRoot({
+                global: true
+            }).global).toBe(true);
+        });
+        it('should register no controllers when includeController is false', ()=>{
+            expect(_emailmodule.EmailModule.forRoot({
+                includeController: false
+            }).controllers).toEqual([]);
+        });
+        it('should register a EMAIL_MODULE_OPTIONS provider carrying the given options', ()=>{
+            const options = {
+                bootstrapAppConfig: {
+                    enableCompanyFeature: true
+                }
+            };
+            const dynamicModule = _emailmodule.EmailModule.forRoot(options);
+            const provider = dynamicModule.providers.find((p)=>p.provide === _emailconstants.EMAIL_MODULE_OPTIONS);
+            expect(provider.useValue).toBe(options);
+        });
+        it('should always export the same fixed set of services', ()=>{
+            expect(_emailmodule.EmailModule.forRoot({}).exports).toHaveLength(6);
+        });
+    });
+    describe('forRootAsync', ()=>{
+        it('should forward external imports alongside CacheModule/UtilsModule', ()=>{
+            let FakeImportedModule = class FakeImportedModule {
+            };
+            const dynamicModule = _emailmodule.EmailModule.forRootAsync({
+                bootstrapAppConfig: {},
+                imports: [
+                    FakeImportedModule
+                ]
+            });
+            expect(dynamicModule.imports).toEqual(expect.arrayContaining([
+                FakeImportedModule
+            ]));
+        });
+        it('useFactory: builds an EMAIL_MODULE_OPTIONS provider that merges resolved config into the static options', async ()=>{
+            const useFactory = jest.fn().mockResolvedValue({
+                defaultFrom: 'noreply@flusys.io'
+            });
+            const dynamicModule = _emailmodule.EmailModule.forRootAsync({
+                bootstrapAppConfig: {},
+                useFactory,
+                inject: [
+                    'SOME_TOKEN'
+                ]
+            });
+            const provider = dynamicModule.providers.find((p)=>p.provide === _emailconstants.EMAIL_MODULE_OPTIONS);
+            expect(provider.inject).toEqual([
+                'SOME_TOKEN'
+            ]);
+            const resolved = await provider.useFactory('injected');
+            expect(useFactory).toHaveBeenCalledWith('injected');
+            expect(resolved.config).toEqual({
+                defaultFrom: 'noreply@flusys.io'
+            });
+        });
+        it('useClass: registers both the class provider and an options provider calling createEmailOptions()', async ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createEmailOptions", jest.fn().mockResolvedValue({
+                        defaultFrom: 'from-class@flusys.io'
+                    }));
+                }
+            };
+            const dynamicModule = _emailmodule.EmailModule.forRootAsync({
+                bootstrapAppConfig: {},
+                useClass: MyOptionsFactory
+            });
+            const classProvider = dynamicModule.providers.find((p)=>p.provide === MyOptionsFactory);
+            expect(classProvider.useClass).toBe(MyOptionsFactory);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _emailconstants.EMAIL_MODULE_OPTIONS);
+            const instance = new MyOptionsFactory();
+            const resolved = await optionsProvider.useFactory(instance);
+            expect(instance.createEmailOptions).toHaveBeenCalled();
+            expect(resolved.config).toEqual({
+                defaultFrom: 'from-class@flusys.io'
+            });
+        });
+        it('useExisting: registers a single options provider without a duplicate class registration', async ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createEmailOptions", jest.fn().mockResolvedValue({
+                        defaultFrom: 'from-existing@flusys.io'
+                    }));
+                }
+            };
+            const dynamicModule = _emailmodule.EmailModule.forRootAsync({
+                bootstrapAppConfig: {},
+                useExisting: MyOptionsFactory
+            });
+            expect(dynamicModule.providers.filter((p)=>p.provide === MyOptionsFactory)).toHaveLength(0);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _emailconstants.EMAIL_MODULE_OPTIONS);
+            expect(optionsProvider.inject).toEqual([
+                MyOptionsFactory
+            ]);
+        });
+        it('should register no EMAIL_MODULE_OPTIONS provider when neither useFactory, useClass, nor useExisting is given', ()=>{
+            const dynamicModule = _emailmodule.EmailModule.forRootAsync({
+                bootstrapAppConfig: {}
+            });
+            expect(providerTokens(dynamicModule.providers)).not.toContain(_emailconstants.EMAIL_MODULE_OPTIONS);
+        });
+    });
+});