@flusys/nestjs-email 1.0.0-rc

package/fesm/providers/email-factory.service.js

@@ -0,0 +1,93 @@
+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, InternalServerErrorException, Logger, NotFoundException } from '@nestjs/common';
+import * as crypto from 'crypto';
+import { EmailConfigService } from '../config/email-config.service';
+import { EmailProviderRegistry } from './email-provider.registry';
+export class EmailFactoryService {
+    generateCacheKey(config) {
+        const configString = JSON.stringify(config.config, Object.keys(config.config || {}).sort());
+        const configHash = crypto.createHash('sha256').update(configString).digest('hex').substring(0, 16);
+        return `${config.provider}-${configHash}`;
+    }
+    async createProvider(config) {
+        const providerKey = this.generateCacheKey(config);
+        if (this.providerCache.has(providerKey)) return this.providerCache.get(providerKey);
+        const ProviderClass = EmailProviderRegistry.get(config.provider);
+        if (!ProviderClass) {
+            throw new NotFoundException(`Email provider '${config.provider}' is not registered. Available: ${EmailProviderRegistry.getAll().join(', ')}`);
+        }
+        try {
+            const instance = new ProviderClass();
+            if ('initialize' in instance && typeof instance.initialize === 'function') {
+                await instance.initialize(config.config);
+            }
+            this.providerCache.set(providerKey, instance);
+            this.logger.log(`Created email provider: ${config.provider} (key: ${providerKey})`);
+            return instance;
+        } catch (error) {
+            this.logger.error(`Failed to create provider ${config.provider}:`, error);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new InternalServerErrorException(`Failed to initialize email provider '${config.provider}': ${errorMessage}`);
+        }
+    }
+    isProviderAvailable(providerName) {
+        return EmailProviderRegistry.has(providerName);
+    }
+    getAvailableProviders() {
+        return EmailProviderRegistry.getAll();
+    }
+    async onModuleDestroy() {
+        this.logger.log('Cleaning up email provider connections...');
+        const closePromises = [];
+        for (const [key, provider] of this.providerCache.entries()){
+            if ('close' in provider && typeof provider.close === 'function') {
+                closePromises.push(provider.close().then(()=>this.logger.debug(`Closed provider: ${key}`)).catch((err)=>this.logger.warn(`Failed to close provider ${key}: ${err.message}`)));
+            }
+        }
+        await Promise.allSettled(closePromises);
+        this.providerCache.clear();
+        this.logger.log('Email provider cleanup complete');
+    }
+    constructor(emailConfigService){
+        _define_property(this, "emailConfigService", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "providerCache", void 0);
+        this.emailConfigService = emailConfigService;
+        this.logger = new Logger(EmailFactoryService.name);
+        this.providerCache = new Map();
+    }
+}
+EmailFactoryService = _ts_decorate([
+    Injectable(),
+    _ts_param(0, Inject(EmailConfigService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof EmailConfigService === "undefined" ? Object : EmailConfigService
+    ])
+], EmailFactoryService);

package/fesm/providers/email-provider.registry.js

@@ -0,0 +1,31 @@
+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;
+}
+export class EmailProviderRegistry {
+    static register(providerName, providerClass) {
+        this.providers.set(providerName.toLowerCase(), providerClass);
+    }
+    static get(providerName) {
+        return this.providers.get(providerName.toLowerCase());
+    }
+    static has(providerName) {
+        return this.providers.has(providerName.toLowerCase());
+    }
+    static getAll() {
+        return Array.from(this.providers.keys());
+    }
+    static clear() {
+        this.providers.clear();
+    }
+}
+_define_property(EmailProviderRegistry, "providers", new Map());

package/fesm/providers/index.js

@@ -0,0 +1,5 @@
+export * from './email-provider.registry';
+export * from './email-factory.service';
+export * from './smtp-provider';
+export * from './sendgrid-provider';
+export * from './mailgun-provider';

package/fesm/providers/mailgun-provider.js

@@ -0,0 +1,97 @@
+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;
+}
+import { Logger } from '@nestjs/common';
+export class MailgunProvider {
+    async initialize(config) {
+        this.config = config;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-implied-eval
+            const Mailgun = (await new Function('return import("mailgun.js")')()).default;
+            const FormData = (await new Function('return import("form-data")')()).default;
+            const mailgun = new Mailgun(FormData);
+            const url = config.region === 'eu' ? 'https://api.eu.mailgun.net' : 'https://api.mailgun.net';
+            this.client = mailgun.client({
+                username: 'api',
+                key: config.apiKey,
+                url
+            });
+            this.logger.log(`Mailgun Provider initialized for domain: ${config.domain}`);
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.error('Failed to initialize Mailgun:', errorMessage);
+            throw new Error('Mailgun initialization failed. Install: npm install mailgun.js form-data');
+        }
+    }
+    async sendEmail(options) {
+        if (!this.client || !this.config) return {
+            success: false,
+            error: 'Mailgun provider not initialized'
+        };
+        try {
+            const to = Array.isArray(options.to) ? options.to.join(', ') : options.to;
+            const cc = options.cc ? Array.isArray(options.cc) ? options.cc.join(', ') : options.cc : undefined;
+            const bcc = options.bcc ? Array.isArray(options.bcc) ? options.bcc.join(', ') : options.bcc : undefined;
+            const messageData = {
+                from: options.fromName ? `${options.fromName} <${options.from}>` : options.from,
+                to,
+                subject: options.subject
+            };
+            if (options.html) messageData.html = options.html;
+            if (options.text) messageData.text = options.text;
+            if (cc) messageData.cc = cc;
+            if (bcc) messageData.bcc = bcc;
+            if (options.replyTo) messageData['h:Reply-To'] = options.replyTo;
+            if (options.attachments?.length) {
+                messageData.attachment = options.attachments.map((a)=>({
+                        filename: a.filename,
+                        data: typeof a.content === 'string' ? Buffer.from(a.content, 'base64') : a.content,
+                        contentType: a.contentType
+                    }));
+            }
+            const result = await this.client.messages.create(this.config.domain, messageData);
+            this.logger.log(`Email sent via Mailgun: ${result.id}`);
+            return {
+                success: true,
+                messageId: result.id
+            };
+        } catch (error) {
+            this.logger.error('Mailgun send failed:', error);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                success: false,
+                error: errorMessage
+            };
+        }
+    }
+    async sendBulkEmails(options) {
+        return Promise.all(options.map((opt)=>this.sendEmail(opt)));
+    }
+    async healthCheck() {
+        if (!this.client || !this.config) return false;
+        try {
+            await this.client.domains.get(this.config.domain);
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    async close() {
+        this.client = null;
+    }
+    constructor(){
+        _define_property(this, "logger", new Logger(MailgunProvider.name));
+        _define_property(this, "client", null);
+        _define_property(this, "config", null);
+    }
+}

package/fesm/providers/sendgrid-provider.js

@@ -0,0 +1,125 @@
+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;
+}
+import { Logger } from '@nestjs/common';
+export class SendGridProvider {
+    async initialize(config) {
+        this.config = config;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-implied-eval
+            const sgMailModule = await new Function('return import("@sendgrid/mail")')();
+            this.sgMail = sgMailModule.default || sgMailModule;
+            this.sgMail.setApiKey(config.apiKey);
+            this.logger.log('SendGrid Provider initialized');
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.error('Failed to initialize SendGrid:', errorMessage);
+            throw new Error('SendGrid initialization failed. Install: npm install @sendgrid/mail');
+        }
+    }
+    async sendEmail(options) {
+        if (!this.sgMail) return {
+            success: false,
+            error: 'SendGrid provider not initialized'
+        };
+        try {
+            const msg = {
+                to: Array.isArray(options.to) ? options.to : [
+                    options.to
+                ],
+                from: options.fromName ? {
+                    email: options.from,
+                    name: options.fromName
+                } : options.from,
+                subject: options.subject
+            };
+            if (options.html) msg.html = options.html;
+            if (options.text) msg.text = options.text;
+            if (options.cc) msg.cc = Array.isArray(options.cc) ? options.cc : [
+                options.cc
+            ];
+            if (options.bcc) msg.bcc = Array.isArray(options.bcc) ? options.bcc : [
+                options.bcc
+            ];
+            if (options.replyTo) msg.replyTo = options.replyTo;
+            if (options.attachments?.length) {
+                msg.attachments = options.attachments.map((a)=>({
+                        filename: a.filename,
+                        content: typeof a.content === 'string' ? a.content : a.content.toString('base64'),
+                        type: a.contentType,
+                        disposition: 'attachment'
+                    }));
+            }
+            const [response] = await this.sgMail.send(msg);
+            const messageId = response.headers['x-message-id'] || response.headers['X-Message-Id'];
+            this.logger.log(`Email sent via SendGrid: ${messageId}`);
+            return {
+                success: true,
+                messageId
+            };
+        } catch (error) {
+            this.logger.error('SendGrid send failed:', error);
+            const sgError = error;
+            const errorMessage = sgError.response?.body?.errors?.[0]?.message || sgError.message || 'Unknown error';
+            return {
+                success: false,
+                error: errorMessage
+            };
+        }
+    }
+    async sendBulkEmails(options) {
+        if (!this.sgMail) return options.map(()=>({
+                success: false,
+                error: 'SendGrid provider not initialized'
+            }));
+        const messages = options.map((opt)=>{
+            const msg = {
+                to: Array.isArray(opt.to) ? opt.to : [
+                    opt.to
+                ],
+                from: opt.fromName ? {
+                    email: opt.from,
+                    name: opt.fromName
+                } : opt.from,
+                subject: opt.subject
+            };
+            if (opt.html) msg.html = opt.html;
+            if (opt.text) msg.text = opt.text;
+            return msg;
+        });
+        try {
+            await this.sgMail.send(messages);
+            return options.map(()=>({
+                    success: true
+                }));
+        } catch (error) {
+            this.logger.error('SendGrid bulk send failed:', error);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return options.map(()=>({
+                    success: false,
+                    error: errorMessage
+                }));
+        }
+    }
+    async healthCheck() {
+        return !!(this.sgMail && this.config?.apiKey?.startsWith('SG.'));
+    }
+    async close() {
+        this.sgMail = null;
+    }
+    constructor(){
+        _define_property(this, "logger", new Logger(SendGridProvider.name));
+        _define_property(this, "sgMail", null);
+        _define_property(this, "config", null);
+    }
+}

package/fesm/providers/smtp-provider.js

@@ -0,0 +1,115 @@
+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;
+}
+import { Logger } from '@nestjs/common';
+export class SmtpProvider {
+    async initialize(config) {
+        this.config = config;
+        this.logger.log(`Initializing SMTP: host=${config.host}, port=${config.port}`);
+        const nodemailer = await import('nodemailer');
+        const isSecure = config.secure ?? config.port === 465;
+        this.transporter = nodemailer.createTransport({
+            host: config.host,
+            port: config.port,
+            secure: isSecure,
+            auth: config.auth,
+            connectionTimeout: 10000,
+            greetingTimeout: 10000,
+            socketTimeout: 30000,
+            tls: {
+                // Secure default: validate certificates unless explicitly disabled
+                rejectUnauthorized: config.tls?.rejectUnauthorized ?? true,
+                minVersion: config.tls?.minVersion ?? 'TLSv1.2'
+            }
+        });
+        try {
+            const verifyPromise = this.transporter.verify();
+            const timeoutPromise = new Promise((_, reject)=>setTimeout(()=>reject(new Error('SMTP verification timeout')), 10000));
+            await Promise.race([
+                verifyPromise,
+                timeoutPromise
+            ]);
+            this.logger.log(`SMTP Provider verified: ${config.host}:${config.port}`);
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.warn(`SMTP verification failed: ${errorMessage}`);
+        }
+    }
+    async sendEmail(options) {
+        if (!this.transporter) return {
+            success: false,
+            error: 'SMTP provider not initialized'
+        };
+        const toAddress = Array.isArray(options.to) ? options.to.join(', ') : options.to;
+        try {
+            const mailOptions = {
+                from: options.fromName ? `"${options.fromName}" <${options.from}>` : options.from,
+                to: toAddress,
+                cc: options.cc ? Array.isArray(options.cc) ? options.cc.join(', ') : options.cc : undefined,
+                bcc: options.bcc ? Array.isArray(options.bcc) ? options.bcc.join(', ') : options.bcc : undefined,
+                subject: options.subject,
+                text: options.text,
+                html: options.html,
+                replyTo: options.replyTo,
+                attachments: options.attachments?.map((a)=>({
+                        filename: a.filename,
+                        content: a.content,
+                        contentType: a.contentType,
+                        encoding: a.encoding
+                    }))
+            };
+            const sendPromise = this.transporter.sendMail(mailOptions);
+            const timeoutPromise = new Promise((_, reject)=>setTimeout(()=>reject(new Error('SMTP send timeout after 30 seconds')), 30000));
+            const info = await Promise.race([
+                sendPromise,
+                timeoutPromise
+            ]);
+            this.logger.log(`Email sent via SMTP: ${info.messageId}`);
+            return {
+                success: true,
+                messageId: info.messageId
+            };
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            const errorStack = error instanceof Error ? error.stack : undefined;
+            this.logger.error(`SMTP send failed: ${errorMessage}`, errorStack);
+            return {
+                success: false,
+                error: errorMessage
+            };
+        }
+    }
+    async sendBulkEmails(options) {
+        return Promise.all(options.map((opt)=>this.sendEmail(opt)));
+    }
+    async healthCheck() {
+        if (!this.transporter) return false;
+        try {
+            await this.transporter.verify();
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    async close() {
+        if (this.transporter) {
+            this.transporter.close();
+            this.transporter = null;
+        }
+    }
+    constructor(){
+        _define_property(this, "logger", new Logger(SmtpProvider.name));
+        _define_property(this, "transporter", null);
+        _define_property(this, "config", null);
+    }
+}

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

@@ -0,0 +1,136 @@
+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, InternalServerErrorException, Logger, Optional, Scope } from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { Request } from 'express';
+import { EmailModuleOptions } from '../interfaces';
+import { EMAIL_MODULE_OPTIONS } from '../config/email.constants';
+export class EmailDataSourceProvider extends MultiTenantDataSourceService {
+    static buildParentOptions(options) {
+        return {
+            bootstrapAppConfig: options.bootstrapAppConfig,
+            defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
+            tenantDefaultDatabaseConfig: options.config?.tenantDefaultDatabaseConfig,
+            tenants: options.config?.tenants
+        };
+    }
+    getEnableCompanyFeature() {
+        return this.emailOptions.bootstrapAppConfig?.enableCompanyFeature ?? false;
+    }
+    getEnableCompanyFeatureForTenant(tenant) {
+        return tenant?.enableCompanyFeature ?? this.getEnableCompanyFeature();
+    }
+    getEnableCompanyFeatureForCurrentTenant() {
+        return this.getEnableCompanyFeatureForTenant(this.getCurrentTenant() ?? undefined);
+    }
+    async getEmailEntities(enableCompanyFeature) {
+        const enable = enableCompanyFeature ?? this.getEnableCompanyFeature();
+        const { EmailConfig, EmailTemplate } = await import('../entities');
+        if (enable) {
+            const { EmailConfigWithCompany, EmailTemplateWithCompany } = await import('../entities');
+            return [
+                EmailConfigWithCompany,
+                EmailTemplateWithCompany
+            ];
+        }
+        return [
+            EmailConfig,
+            EmailTemplate
+        ];
+    }
+    async createDataSourceFromConfig(config) {
+        const currentTenant = this.getCurrentTenant();
+        const enableCompanyFeature = this.getEnableCompanyFeatureForTenant(currentTenant ?? undefined);
+        const entities = await this.getEmailEntities(enableCompanyFeature);
+        return super.createDataSourceFromConfig(config, entities);
+    }
+    async getSingleDataSource() {
+        if (EmailDataSourceProvider.singleDataSource?.isInitialized) {
+            return EmailDataSourceProvider.singleDataSource;
+        }
+        if (EmailDataSourceProvider.singleConnectionLock) {
+            return EmailDataSourceProvider.singleConnectionLock;
+        }
+        const config = this.getDefaultDatabaseConfig();
+        if (!config) {
+            throw new InternalServerErrorException('No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.');
+        }
+        const connectionPromise = this.createDataSourceFromConfig(config);
+        EmailDataSourceProvider.singleConnectionLock = connectionPromise;
+        try {
+            const dataSource = await connectionPromise;
+            EmailDataSourceProvider.singleDataSource = dataSource;
+            return dataSource;
+        } finally{
+            EmailDataSourceProvider.singleConnectionLock = null;
+        }
+    }
+    async getOrCreateTenantConnection(tenant) {
+        const existing = EmailDataSourceProvider.tenantConnections.get(tenant.id);
+        if (existing?.isInitialized) {
+            return existing;
+        }
+        const pendingConnection = EmailDataSourceProvider.connectionLocks.get(tenant.id);
+        if (pendingConnection) {
+            return pendingConnection;
+        }
+        const config = this.buildTenantDatabaseConfig(tenant);
+        const connectionPromise = this.createDataSourceFromConfig(config);
+        EmailDataSourceProvider.connectionLocks.set(tenant.id, connectionPromise);
+        try {
+            const dataSource = await connectionPromise;
+            EmailDataSourceProvider.tenantConnections.set(tenant.id, dataSource);
+            return dataSource;
+        } finally{
+            EmailDataSourceProvider.connectionLocks.delete(tenant.id);
+        }
+    }
+    constructor(emailOptions, request){
+        super(EmailDataSourceProvider.buildParentOptions(emailOptions), request), _define_property(this, "emailOptions", void 0), _define_property(this, "logger", void 0), this.emailOptions = emailOptions, this.logger = new Logger(EmailDataSourceProvider.name);
+    }
+}
+_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(EMAIL_MODULE_OPTIONS)),
+    _ts_param(1, Optional()),
+    _ts_param(1, Inject(REQUEST)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof EmailModuleOptions === "undefined" ? Object : EmailModuleOptions,
+        typeof Request === "undefined" ? Object : Request
+    ])
+], EmailDataSourceProvider);