@flusys/nestjs-email 1.1.0-beta → 1.1.0

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

@@ -22,29 +22,19 @@ function _define_property(obj, key, value) {
     return obj;
 }
 let EmailProviderRegistry = class EmailProviderRegistry {
-    /**
-   * Register an email provider
-   */ static register(providerName, providerClass) {
+    static register(providerName, providerClass) {
         this.providers.set(providerName.toLowerCase(), providerClass);
     }
-    /**
-   * Get a registered provider class
-   */ static get(providerName) {
+    static get(providerName) {
         return this.providers.get(providerName.toLowerCase());
     }
-    /**
-   * Check if a provider is registered
-   */ static has(providerName) {
+    static has(providerName) {
         return this.providers.has(providerName.toLowerCase());
     }
-    /**
-   * Get all registered provider names
-   */ static getAll() {
+    static getAll() {
         return Array.from(this.providers.keys());
     }
-    /**
-   * Clear all providers (useful for testing)
-   */ static clear() {
+    static clear() {
         this.providers.clear();
     }
 };

package/cjs/providers/mailgun-provider.js

@@ -22,19 +22,17 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
+const MAILGUN_API_URL = 'https://api.mailgun.net';
+const MAILGUN_EU_API_URL = 'https://api.eu.mailgun.net';
 let MailgunProvider = class MailgunProvider {
-    /**
-   * Initialize the Mailgun provider with configuration
-   */ async initialize(config) {
-        this.config = config;
+    async initialize(config) {
+        this.domain = config.domain;
         try {
-            // Dynamic import mailgun.js and form-data - use eval to bypass TypeScript module resolution
-            // eslint-disable-next-line @typescript-eslint/no-implied-eval
+            // Dynamic import for optional dependency
             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);
-            // Determine API URL based on region
-            const url = config.region === 'eu' ? 'https://api.eu.mailgun.net' : 'https://api.mailgun.net';
+            const url = config.region === 'eu' ? MAILGUN_EU_API_URL : MAILGUN_API_URL;
             this.client = mailgun.client({
                 username: 'api',
                 key: config.apiKey,
@@ -42,84 +40,82 @@ let MailgunProvider = class MailgunProvider {
             });
             this.logger.log(`Mailgun Provider initialized for domain: ${config.domain}`);
         } catch (error) {
-            this.logger.error('Failed to initialize Mailgun:', error.message);
-            throw new Error('Mailgun initialization failed. Make sure mailgun.js and form-data are installed: npm install mailgun.js form-data');
+            this.logger.error('Failed to initialize Mailgun:', this.extractError(error));
+            throw new Error('Mailgun initialization failed. Install: npm install mailgun.js form-data');
         }
     }
-    /**
-   * Send a single email
-   */ async sendEmail(options) {
-        if (!this.client || !this.config) {
+    async sendEmail(options) {
+        if (!this.client || !this.domain) {
             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
-            };
-            // Only include html/text if they have values (required for plain text templates)
-            if (options.html) messageData.html = options.html;
-            if (options.text) messageData.text = options.text;
-            // Optional fields
-            if (cc) messageData.cc = cc;
-            if (bcc) messageData.bcc = bcc;
-            if (options.replyTo) messageData['h:Reply-To'] = options.replyTo;
-            // Handle attachments
-            if (options.attachments && options.attachments.length > 0) {
-                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);
+            const messageData = this.buildMessageData(options);
+            const result = await this.client.messages.create(this.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);
-            return {
-                success: false,
-                error: error.message
-            };
+            return this.handleError('Mailgun send failed', error);
         }
     }
-    /**
-   * Send multiple emails (batch)
-   */ async sendBulkEmails(options) {
-        // Mailgun supports batch sending with recipient variables
-        // For simplicity, we send individually here
+    async sendBulkEmails(options) {
         return Promise.all(options.map((opt)=>this.sendEmail(opt)));
     }
-    /**
-   * Health check for the provider
-   */ async healthCheck() {
-        if (!this.client || !this.config) return false;
+    async healthCheck() {
+        if (!this.client || !this.domain) return false;
         try {
-            // Verify domain exists
-            await this.client.domains.get(this.config.domain);
+            await this.client.domains.get(this.domain);
             return true;
         } catch  {
             return false;
         }
     }
-    /**
-   * Cleanup
-   */ async close() {
+    async close() {
         this.client = null;
     }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    buildMessageData(options) {
+        const data = {
+            from: options.fromName ? `${options.fromName} <${options.from}>` : options.from,
+            to: this.joinAddresses(options.to),
+            subject: options.subject
+        };
+        if (options.html) data.html = options.html;
+        if (options.text) data.text = options.text;
+        if (options.cc) data.cc = this.joinAddresses(options.cc);
+        if (options.bcc) data.bcc = this.joinAddresses(options.bcc);
+        if (options.replyTo) data['h:Reply-To'] = options.replyTo;
+        if (options.attachments?.length) {
+            data.attachment = options.attachments.map((a)=>({
+                    filename: a.filename,
+                    data: typeof a.content === 'string' ? Buffer.from(a.content, 'base64') : a.content,
+                    contentType: a.contentType
+                }));
+        }
+        return data;
+    }
+    joinAddresses(addresses) {
+        return Array.isArray(addresses) ? addresses.join(', ') : addresses;
+    }
+    extractError(error) {
+        return error instanceof Error ? error.message : 'Unknown error';
+    }
+    handleError(context, error) {
+        const message = this.extractError(error);
+        this.logger.error(`${context}: ${message}`, error);
+        return {
+            success: false,
+            error: message
+        };
+    }
     constructor(){
         _define_property(this, "logger", new _common.Logger(MailgunProvider.name));
         _define_property(this, "client", null);
-        _define_property(this, "config", null);
+        _define_property(this, "domain", null);
     }
 };

package/cjs/providers/sendgrid-provider.js

@@ -23,65 +23,26 @@ function _define_property(obj, key, value) {
     return obj;
 }
 let SendGridProvider = class SendGridProvider {
-    /**
-   * Initialize the SendGrid provider with configuration
-   */ async initialize(config) {
-        this.config = config;
+    async initialize(config) {
+        this.apiKey = config.apiKey;
         try {
-            // Dynamic import @sendgrid/mail - use eval to bypass TypeScript module resolution
-            // eslint-disable-next-line @typescript-eslint/no-implied-eval
+            // Dynamic import to avoid bundling issues
             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) {
-            this.logger.error('Failed to initialize SendGrid:', error.message);
-            throw new Error('SendGrid initialization failed. Make sure @sendgrid/mail is installed: npm install @sendgrid/mail');
+            this.logger.error('Failed to initialize SendGrid:', this.extractError(error));
+            throw new Error('SendGrid initialization failed. Install: npm install @sendgrid/mail');
         }
     }
-    /**
-   * Send a single email
-   */ async sendEmail(options) {
-        if (!this.sgMail) {
-            return {
-                success: false,
-                error: 'SendGrid provider not initialized'
-            };
-        }
+    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
-            };
-            // Only include html/text if they have values (required for plain text templates)
-            if (options.html) msg.html = options.html;
-            if (options.text) msg.text = options.text;
-            // Optional fields
-            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 msg = this.buildMessage(options, true);
             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}`);
@@ -90,67 +51,82 @@ let SendGridProvider = class SendGridProvider {
                 messageId
             };
         } catch (error) {
-            this.logger.error('SendGrid send failed:', error);
-            const errorMessage = error.response?.body?.errors?.[0]?.message || error.message;
-            return {
-                success: false,
-                error: errorMessage
-            };
+            return this.handleError('SendGrid send failed', error);
         }
     }
-    /**
-   * Send multiple emails (batch)
-   */ async sendBulkEmails(options) {
-        if (!this.sgMail) {
-            return options.map(()=>({
-                    success: false,
-                    error: 'SendGrid provider not initialized'
-                }));
-        }
-        // SendGrid supports batch sending with sendMultiple
-        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;
-        });
+    async sendBulkEmails(options) {
+        if (!this.sgMail) return options.map(()=>({
+                success: false,
+                error: 'SendGrid provider not initialized'
+            }));
         try {
+            const messages = options.map((opt)=>this.buildMessage(opt, false));
             await this.sgMail.send(messages);
             return options.map(()=>({
                     success: true
                 }));
         } catch (error) {
             this.logger.error('SendGrid bulk send failed:', error);
+            const errorMessage = this.extractError(error);
             return options.map(()=>({
                     success: false,
-                    error: error.message
+                    error: errorMessage
                 }));
         }
     }
-    /**
-   * Health check for the provider
-   */ async healthCheck() {
-        // SendGrid doesn't have a direct health check API
-        // We verify the API key format is valid
-        return !!(this.sgMail && this.config?.apiKey?.startsWith('SG.'));
+    async healthCheck() {
+        return !!(this.sgMail && this.apiKey?.startsWith('SG.'));
     }
-    /**
-   * Cleanup (no-op for SendGrid)
-   */ async close() {
+    async close() {
         this.sgMail = null;
     }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    buildMessage(options, includeExtras) {
+        const msg = {
+            to: this.toArray(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 (includeExtras) {
+            if (options.cc) msg.cc = this.toArray(options.cc);
+            if (options.bcc) msg.bcc = this.toArray(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'
+                    }));
+            }
+        }
+        return msg;
+    }
+    toArray(value) {
+        return Array.isArray(value) ? value : [
+            value
+        ];
+    }
+    extractError(error) {
+        const sgError = error;
+        return sgError.response?.body?.errors?.[0]?.message || sgError.message || 'Unknown error';
+    }
+    handleError(context, error) {
+        const message = this.extractError(error);
+        this.logger.error(`${context}: ${message}`, error);
+        return {
+            success: false,
+            error: message
+        };
+    }
     constructor(){
         _define_property(this, "logger", new _common.Logger(SendGridProvider.name));
         _define_property(this, "sgMail", null);
-        _define_property(this, "config", null);
+        _define_property(this, "apiKey", null);
     }
 };

package/cjs/providers/smtp-provider.js

@@ -63,64 +63,38 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+const VERIFY_TIMEOUT_MS = 10_000;
+const SEND_TIMEOUT_MS = 30_000;
 let SmtpProvider = class SmtpProvider {
-    /**
-   * Initialize the SMTP provider with configuration
-   */ async initialize(config) {
-        this.config = config;
-        this.logger.log(`Initializing SMTP: host=${config.host}, port=${config.port}, secure=${config.secure}, user=${config.auth?.user}`);
-        // Dynamic import nodemailer
+    async initialize(config) {
+        this.logger.log(`Initializing SMTP: host=${config.host}, port=${config.port}`);
         const nodemailer = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("nodemailer")));
-        // Determine secure mode: port 465 = implicit TLS, port 587 = STARTTLS
-        const isSecure = config.secure ?? config.port === 465;
         this.transporter = nodemailer.createTransport({
             host: config.host,
             port: config.port,
-            secure: isSecure,
+            secure: config.secure ?? config.port === 465,
             auth: config.auth,
-            // Timeout settings to prevent hanging
-            connectionTimeout: 10000,
-            greetingTimeout: 10000,
-            socketTimeout: 30000,
-            // TLS options for better compatibility
+            connectionTimeout: VERIFY_TIMEOUT_MS,
+            greetingTimeout: VERIFY_TIMEOUT_MS,
+            socketTimeout: SEND_TIMEOUT_MS,
             tls: {
-                rejectUnauthorized: false,
-                minVersion: 'TLSv1.2'
+                rejectUnauthorized: config.tls?.rejectUnauthorized ?? true,
+                minVersion: config.tls?.minVersion ?? 'TLSv1.2'
             }
         });
-        this.logger.log(`SMTP transporter created with secure=${isSecure}`);
-        // Verify connection with timeout
-        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 successfully: ${config.host}:${config.port}`);
-        } catch (error) {
-            this.logger.warn(`SMTP verification failed: ${error.message}`);
-        // Don't throw - allow initialization even if verification fails
-        // Connection will be retried on send
-        }
+        await this.verifyConnection(config);
     }
-    /**
-   * Send a single email
-   */ 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;
-        this.logger.log(`Sending email to: ${toAddress}, subject: ${options.subject}`);
+    async sendEmail(options) {
+        if (!this.transporter) return {
+            success: false,
+            error: 'SMTP provider not initialized'
+        };
         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,
+                from: this.formatFrom(options.from, options.fromName),
+                to: this.joinAddresses(options.to),
+                cc: options.cc ? this.joinAddresses(options.cc) : undefined,
+                bcc: options.bcc ? this.joinAddresses(options.bcc) : undefined,
                 subject: options.subject,
                 text: options.text,
                 html: options.html,
@@ -132,35 +106,20 @@ let SmtpProvider = class SmtpProvider {
                         encoding: a.encoding
                     }))
             };
-            this.logger.log(`Mail options: from=${mailOptions.from}, to=${mailOptions.to}`);
-            // Send with timeout
-            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
-            ]);
+            const info = await this.withTimeout(this.transporter.sendMail(mailOptions), SEND_TIMEOUT_MS, 'SMTP send timeout');
             this.logger.log(`Email sent via SMTP: ${info.messageId}`);
             return {
                 success: true,
                 messageId: info.messageId
             };
         } catch (error) {
-            this.logger.error(`SMTP send failed: ${error.message}`, error.stack);
-            return {
-                success: false,
-                error: error.message
-            };
+            return this.handleError('SMTP send failed', error);
         }
     }
-    /**
-   * Send multiple emails (batch)
-   */ async sendBulkEmails(options) {
+    async sendBulkEmails(options) {
         return Promise.all(options.map((opt)=>this.sendEmail(opt)));
     }
-    /**
-   * Health check for the provider
-   */ async healthCheck() {
+    async healthCheck() {
         if (!this.transporter) return false;
         try {
             await this.transporter.verify();
@@ -169,17 +128,47 @@ let SmtpProvider = class SmtpProvider {
             return false;
         }
     }
-    /**
-   * Close the transporter
-   */ async close() {
+    async close() {
         if (this.transporter) {
             this.transporter.close();
             this.transporter = null;
         }
     }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    async verifyConnection(config) {
+        try {
+            await this.withTimeout(this.transporter.verify(), VERIFY_TIMEOUT_MS, 'SMTP verification timeout');
+            this.logger.log(`SMTP Provider verified: ${config.host}:${config.port}`);
+        } catch (error) {
+            this.logger.warn(`SMTP verification failed: ${this.extractError(error)}`);
+        }
+    }
+    formatFrom(from, fromName) {
+        return fromName ? `"${fromName}" <${from}>` : from;
+    }
+    joinAddresses(addresses) {
+        return Array.isArray(addresses) ? addresses.join(', ') : addresses;
+    }
+    async withTimeout(promise, ms, message) {
+        const timeout = new Promise((_, reject)=>setTimeout(()=>reject(new Error(message)), ms));
+        return Promise.race([
+            promise,
+            timeout
+        ]);
+    }
+    extractError(error) {
+        return error instanceof Error ? error.message : 'Unknown error';
+    }
+    handleError(context, error) {
+        const message = this.extractError(error);
+        this.logger.error(`${context}: ${message}`, error instanceof Error ? error.stack : undefined);
+        return {
+            success: false,
+            error: message
+        };
+    }
     constructor(){
         _define_property(this, "logger", new _common.Logger(SmtpProvider.name));
         _define_property(this, "transporter", null);
-        _define_property(this, "config", null);
     }
 };

package/cjs/{config → services}/email-config.service.js

@@ -9,8 +9,8 @@ Object.defineProperty(exports, "EmailConfigService", {
     }
 });
 const _common = require("@nestjs/common");
+const _emailconstants = require("../config/email.constants");
 const _interfaces = require("../interfaces");
-const _emailconstants = require("./email.constants");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -39,44 +39,21 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let EmailConfigService = class EmailConfigService {
-    /**
-   * Check if company feature is enabled
-   */ isCompanyFeatureEnabled() {
+    // ─── IModuleConfigService Implementation ────────────────────────────────────
+    isCompanyFeatureEnabled() {
         return this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
     }
-    /**
-   * Get database mode
-   */ getDatabaseMode() {
+    getDatabaseMode() {
         return this.options.bootstrapAppConfig?.databaseMode ?? 'single';
     }
-    /**
-   * Get rate limit per minute
-   */ getRateLimitPerMinute() {
-        return this.options.config?.rateLimitPerMinute ?? 60;
+    isMultiTenant() {
+        return this.getDatabaseMode() === 'multi-tenant';
     }
-    /**
-   * Check if email logging is enabled
-   */ isLoggingEnabled() {
-        return this.options.config?.enableLogging ?? false;
-    }
-    /**
-   * Get default provider type
-   */ getDefaultProvider() {
-        return this.options.config?.defaultProvider;
-    }
-    /**
-   * Get default from name
-   */ getDefaultFromName() {
+    // ─── Config Getters ─────────────────────────────────────────────────────────
+    getDefaultFromName() {
         return _emailconstants.DEFAULT_FROM_NAME;
     }
-    /**
-   * Get default database config
-   */ getDefaultDatabaseConfig() {
-        return this.options.config?.defaultDatabaseConfig;
-    }
-    /**
-   * Get all options
-   */ getOptions() {
+    getOptions() {
         return this.options;
     }
     constructor(options){