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

package/fesm/providers/smtp-provider.spec.js

@@ -1,282 +0,0 @@
-const mockTransporter = {
-    verify: jest.fn(),
-    sendMail: jest.fn(),
-    close: jest.fn()
-};
-jest.mock('nodemailer', ()=>({
-        createTransport: jest.fn()
-    }));
-import * as nodemailer from 'nodemailer';
-import { SmtpProvider } from './smtp-provider';
-const createTransport = nodemailer.createTransport;
-createTransport.mockReturnValue(mockTransporter);
-function injectTransporter(provider, transporter) {
-    provider.transporter = transporter;
-}
-describe('SmtpProvider', ()=>{
-    let provider;
-    beforeEach(()=>{
-        provider = new SmtpProvider();
-        jest.clearAllMocks();
-    });
-    describe('initialize', ()=>{
-        it('creates a nodemailer transport with the given config and verifies the connection', async ()=>{
-            mockTransporter.verify.mockResolvedValue(true);
-            await provider.initialize({
-                host: 'smtp.example.com',
-                port: 587,
-                auth: {
-                    user: 'user',
-                    pass: 'pass'
-                }
-            });
-            expect(createTransport).toHaveBeenCalledWith(expect.objectContaining({
-                host: 'smtp.example.com',
-                port: 587,
-                secure: false,
-                auth: {
-                    user: 'user',
-                    pass: 'pass'
-                },
-                tls: expect.objectContaining({
-                    rejectUnauthorized: true,
-                    minVersion: 'TLSv1.2'
-                })
-            }));
-            expect(mockTransporter.verify).toHaveBeenCalled();
-        });
-        it('defaults secure=true when port is 465 and secure is not explicitly set', async ()=>{
-            mockTransporter.verify.mockResolvedValue(true);
-            await provider.initialize({
-                host: 'smtp.example.com',
-                port: 465
-            });
-            expect(createTransport).toHaveBeenCalledWith(expect.objectContaining({
-                secure: true
-            }));
-        });
-        it('honors an explicit secure flag over the port-based default', async ()=>{
-            mockTransporter.verify.mockResolvedValue(true);
-            await provider.initialize({
-                host: 'smtp.example.com',
-                port: 587,
-                secure: true
-            });
-            expect(createTransport).toHaveBeenCalledWith(expect.objectContaining({
-                secure: true
-            }));
-        });
-        it('allows disabling TLS certificate validation via config', async ()=>{
-            mockTransporter.verify.mockResolvedValue(true);
-            await provider.initialize({
-                host: 'smtp.example.com',
-                port: 587,
-                tls: {
-                    rejectUnauthorized: false
-                }
-            });
-            expect(createTransport).toHaveBeenCalledWith(expect.objectContaining({
-                tls: expect.objectContaining({
-                    rejectUnauthorized: false
-                })
-            }));
-        });
-        it('propagates a connection verification failure', async ()=>{
-            mockTransporter.verify.mockRejectedValue(new Error('ECONNREFUSED'));
-            await expect(provider.initialize({
-                host: 'smtp.example.com',
-                port: 587
-            })).rejects.toThrow('ECONNREFUSED');
-        });
-    });
-    describe('sendEmail', ()=>{
-        it('returns a failure result when the provider was never initialized', async ()=>{
-            const result = await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi'
-            });
-            expect(result).toEqual({
-                success: false,
-                error: 'SMTP provider not initialized'
-            });
-        });
-        it('sends mail via the transporter and returns the message id', async ()=>{
-            injectTransporter(provider, mockTransporter);
-            mockTransporter.sendMail.mockResolvedValue({
-                messageId: 'msg-1'
-            });
-            const result = await provider.sendEmail({
-                to: [
-                    'a@example.com',
-                    'b@example.com'
-                ],
-                cc: 'c@example.com',
-                bcc: [
-                    'd@example.com'
-                ],
-                subject: 'Hello',
-                html: '<p>hi</p>',
-                text: 'hi',
-                from: 'sender@example.com',
-                fromName: 'Sender Name',
-                replyTo: 'reply@example.com'
-            });
-            expect(result).toEqual({
-                success: true,
-                messageId: 'msg-1'
-            });
-            expect(mockTransporter.sendMail).toHaveBeenCalledWith(expect.objectContaining({
-                from: '"Sender Name" <sender@example.com>',
-                to: 'a@example.com, b@example.com',
-                cc: 'c@example.com',
-                bcc: 'd@example.com',
-                subject: 'Hello',
-                html: '<p>hi</p>',
-                text: 'hi',
-                replyTo: 'reply@example.com'
-            }));
-        });
-        it('sends the bare "from" address when fromName is not provided', async ()=>{
-            injectTransporter(provider, mockTransporter);
-            mockTransporter.sendMail.mockResolvedValue({
-                messageId: 'msg-1'
-            });
-            await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi',
-                from: 'sender@example.com'
-            });
-            expect(mockTransporter.sendMail).toHaveBeenCalledWith(expect.objectContaining({
-                from: 'sender@example.com'
-            }));
-        });
-        it('maps attachments through to nodemailer mail options', async ()=>{
-            injectTransporter(provider, mockTransporter);
-            mockTransporter.sendMail.mockResolvedValue({
-                messageId: 'msg-1'
-            });
-            await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi',
-                attachments: [
-                    {
-                        filename: 'doc.txt',
-                        content: Buffer.from('hi'),
-                        contentType: 'text/plain'
-                    }
-                ]
-            });
-            const [mailOptions] = mockTransporter.sendMail.mock.calls[0];
-            expect(mailOptions.attachments).toEqual([
-                {
-                    filename: 'doc.txt',
-                    content: Buffer.from('hi'),
-                    contentType: 'text/plain',
-                    encoding: undefined
-                }
-            ]);
-        });
-        it('returns the error message when sendMail rejects with an Error', async ()=>{
-            injectTransporter(provider, mockTransporter);
-            mockTransporter.sendMail.mockRejectedValue(new Error('Connection refused'));
-            const result = await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi'
-            });
-            expect(result).toEqual({
-                success: false,
-                error: 'Connection refused'
-            });
-        });
-        it('returns "Unknown error" when sendMail rejects with a non-Error', async ()=>{
-            injectTransporter(provider, mockTransporter);
-            mockTransporter.sendMail.mockRejectedValue('raw string failure');
-            const result = await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi'
-            });
-            expect(result).toEqual({
-                success: false,
-                error: 'Unknown error'
-            });
-        });
-        it('surfaces a timeout error if sendMail never settles before the send timeout', async ()=>{
-            jest.useFakeTimers();
-            injectTransporter(provider, mockTransporter);
-            mockTransporter.sendMail.mockReturnValue(new Promise(()=>{}));
-            const pending = provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi'
-            });
-            jest.advanceTimersByTime(30_000);
-            const result = await pending;
-            expect(result).toEqual({
-                success: false,
-                error: 'SMTP send timeout'
-            });
-            jest.useRealTimers();
-        });
-    });
-    describe('sendBulkEmails', ()=>{
-        it('sends each message individually and aggregates the results', async ()=>{
-            injectTransporter(provider, mockTransporter);
-            mockTransporter.sendMail.mockResolvedValueOnce({
-                messageId: 'id-1'
-            }).mockRejectedValueOnce(new Error('failed-2'));
-            const results = await provider.sendBulkEmails([
-                {
-                    to: 'a@example.com',
-                    subject: 'A'
-                },
-                {
-                    to: 'b@example.com',
-                    subject: 'B'
-                }
-            ]);
-            expect(results).toEqual([
-                {
-                    success: true,
-                    messageId: 'id-1'
-                },
-                {
-                    success: false,
-                    error: 'failed-2'
-                }
-            ]);
-        });
-    });
-    describe('healthCheck', ()=>{
-        it('returns false when not initialized', async ()=>{
-            await expect(provider.healthCheck()).resolves.toBe(false);
-        });
-        it('returns true when transporter.verify() resolves', async ()=>{
-            injectTransporter(provider, mockTransporter);
-            mockTransporter.verify.mockResolvedValue(true);
-            await expect(provider.healthCheck()).resolves.toBe(true);
-        });
-        it('returns false when transporter.verify() rejects', async ()=>{
-            injectTransporter(provider, mockTransporter);
-            mockTransporter.verify.mockRejectedValue(new Error('down'));
-            await expect(provider.healthCheck()).resolves.toBe(false);
-        });
-    });
-    describe('close', ()=>{
-        it('closes and clears the transporter', async ()=>{
-            injectTransporter(provider, mockTransporter);
-            await provider.close();
-            expect(mockTransporter.close).toHaveBeenCalled();
-            const result = await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi'
-            });
-            expect(result).toEqual({
-                success: false,
-                error: 'SMTP provider not initialized'
-            });
-        });
-        it('is a no-op when no transporter exists', async ()=>{
-            await expect(provider.close()).resolves.toBeUndefined();
-            expect(mockTransporter.close).not.toHaveBeenCalled();
-        });
-    });
-});

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

@@ -1,61 +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 { Inject, Injectable } from '@nestjs/common';
-import { EMAIL_MODULE_OPTIONS, DEFAULT_FROM_NAME } from '../config/email.constants';
-import { EmailModuleOptions } from '../interfaces';
-export class EmailConfigService {
-    // ─── IModuleConfigService Implementation ────────────────────────────────────
-    isCompanyFeatureEnabled() {
-        return this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
-    }
-    getDatabaseMode() {
-        return this.options.bootstrapAppConfig?.databaseMode ?? 'single';
-    }
-    isMultiTenant() {
-        return this.getDatabaseMode() === 'multi-tenant';
-    }
-    // ─── Config Getters ─────────────────────────────────────────────────────────
-    getDefaultFromName() {
-        return DEFAULT_FROM_NAME;
-    }
-    getOptions() {
-        return this.options;
-    }
-    constructor(options){
-        _define_property(this, "options", void 0);
-        this.options = options;
-    }
-}
-EmailConfigService = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Inject(EMAIL_MODULE_OPTIONS)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof EmailModuleOptions === "undefined" ? Object : EmailModuleOptions
-    ])
-], EmailConfigService);

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

@@ -1,65 +0,0 @@
-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.js

@@ -1,74 +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 { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
-import { Inject, Injectable, Optional, Scope } from '@nestjs/common';
-import { REQUEST } from '@nestjs/core';
-import { Request } from 'express';
-import { getEmailEntitiesByConfig } from '../entities';
-import { EmailConfigService } from './email-config.service';
-export class EmailDataSourceProvider extends MultiTenantDataSourceService {
-    static buildParentOptions(options) {
-        return {
-            bootstrapAppConfig: options.bootstrapAppConfig,
-            defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
-            tenantDefaultDatabaseConfig: options.config?.tenantDefaultDatabaseConfig,
-            tenants: options.config?.tenants
-        };
-    }
-    getEnableCompanyFeatureForTenant(tenant) {
-        return tenant?.enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
-    }
-    async createDataSourceFromConfig(config) {
-        const currentTenant = this.getCurrentTenant();
-        const enableCompanyFeature = this.getEnableCompanyFeatureForTenant(currentTenant ?? undefined);
-        const entities = getEmailEntitiesByConfig(enableCompanyFeature);
-        return super.createDataSourceFromConfig(config, entities);
-    }
-    constructor(configService, request){
-        super(EmailDataSourceProvider.buildParentOptions(configService.getOptions()), request), _define_property(this, "configService", void 0), this.configService = configService;
-    }
-}
-_define_property(EmailDataSourceProvider, "tenantConnections", new Map());
-_define_property(EmailDataSourceProvider, "singleDataSource", null);
-_define_property(EmailDataSourceProvider, "tenantsRegistry", new Map());
-_define_property(EmailDataSourceProvider, "initialized", false);
-_define_property(EmailDataSourceProvider, "connectionLocks", new Map());
-_define_property(EmailDataSourceProvider, "singleConnectionLock", null);
-EmailDataSourceProvider = _ts_decorate([
-    Injectable({
-        scope: Scope.REQUEST
-    }),
-    _ts_param(0, Inject(EmailConfigService)),
-    _ts_param(1, Optional()),
-    _ts_param(1, Inject(REQUEST)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof EmailConfigService === "undefined" ? Object : EmailConfigService,
-        typeof Request === "undefined" ? Object : Request
-    ])
-], EmailDataSourceProvider);

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

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