@flusys/nestjs-email 1.1.0-beta → 2.0.0

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

@@ -17,93 +17,62 @@ function _ts_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, Logger, NotFoundException } from '@nestjs/common';
-import * as crypto from 'crypto';
-import { EmailConfigService } from '../config/email-config.service';
+import { Injectable, InternalServerErrorException, Logger, NotFoundException } from '@nestjs/common';
+import { createHash } from 'crypto';
 import { EmailProviderRegistry } from './email-provider.registry';
 export class EmailFactoryService {
-    /**
-   * Generate a unique cache key for a provider configuration
-   */ 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}`;
-    }
-    /**
-   * Create or retrieve a cached email provider instance
-   */ async createProvider(config) {
-        const providerKey = this.generateCacheKey(config);
-        // Return cached provider if exists
-        if (this.providerCache.has(providerKey)) {
-            return this.providerCache.get(providerKey);
-        }
-        // Get provider class from registry
+    // ─── Public API ─────────────────────────────────────────────────────────────
+    async createProvider(config) {
+        const cacheKey = this.generateCacheKey(config);
+        const cached = this.providerCache.get(cacheKey);
+        if (cached) return cached;
         const ProviderClass = EmailProviderRegistry.get(config.provider);
         if (!ProviderClass) {
-            throw new NotFoundException(`Email provider '${config.provider}' is not registered. ` + `Available providers: ${EmailProviderRegistry.getAll().join(', ')}`);
+            throw new NotFoundException(`Email provider '${config.provider}' is not registered. Available: ${EmailProviderRegistry.getAll().join(', ')}`);
         }
         try {
-            // Create new instance
             const instance = new ProviderClass();
-            // Initialize if provider has initialize method
-            if ('initialize' in instance && typeof instance.initialize === 'function') {
-                await instance.initialize(config.config);
-            }
-            // Cache the instance
-            this.providerCache.set(providerKey, instance);
-            this.logger.log(`Created email provider: ${config.provider} (key: ${providerKey})`);
+            await instance.initialize?.(config.config);
+            this.providerCache.set(cacheKey, instance);
+            this.logger.log(`Created email provider: ${config.provider} (key: ${cacheKey})`);
             return instance;
         } catch (error) {
             this.logger.error(`Failed to create provider ${config.provider}:`, error);
-            throw new Error(`Failed to initialize email provider '${config.provider}': ${error?.message || 'Unknown error'}`);
+            throw new InternalServerErrorException(`Failed to initialize email provider '${config.provider}': ${this.extractErrorMessage(error)}`);
         }
     }
-    /**
-   * Check if a provider is available (registered)
-   */ isProviderAvailable(providerName) {
-        return EmailProviderRegistry.has(providerName);
-    }
-    /**
-   * Get list of available providers
-   */ getAvailableProviders() {
-        return EmailProviderRegistry.getAll();
-    }
-    /**
-   * Cleanup on module destroy
-   */ async onModuleDestroy() {
+    // ─── Lifecycle ──────────────────────────────────────────────────────────────
+    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}`)));
-            }
-        }
+        const closePromises = Array.from(this.providerCache.entries()).map(([key, provider])=>this.closeProvider(key, provider));
         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();
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    generateCacheKey(config) {
+        const sortedKeys = Object.keys(config.config || {}).sort();
+        const configString = JSON.stringify(config.config, sortedKeys);
+        const hash = createHash('sha256').update(configString).digest('hex').substring(0, 16);
+        return `${config.provider}-${hash}`;
+    }
+    async closeProvider(key, provider) {
+        if (!provider.close) return;
+        try {
+            await provider.close();
+            this.logger.debug(`Closed provider: ${key}`);
+        } catch (err) {
+            this.logger.warn(`Failed to close provider ${key}: ${this.extractErrorMessage(err)}`);
+        }
+    }
+    extractErrorMessage(error) {
+        return error instanceof Error ? error.message : 'Unknown error';
+    }
+    constructor(){
+        _define_property(this, "logger", new Logger(EmailFactoryService.name));
+        _define_property(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
-    ])
+    Injectable()
 ], EmailFactoryService);

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

@@ -11,33 +11,20 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
-/**
- * Registry for email providers
- * Allows dynamic registration of providers at runtime
- */ export class EmailProviderRegistry {
-    /**
-   * Register an email provider
-   */ static register(providerName, providerClass) {
+export class EmailProviderRegistry {
+    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/fesm/providers/mailgun-provider.js

@@ -12,23 +12,17 @@ function _define_property(obj, key, value) {
     return obj;
 }
 import { Logger } from '@nestjs/common';
-/**
- * Mailgun Email Provider
- * Uses mailgun.js package for sending emails
- * Install: npm install mailgun.js form-data
- */ export class MailgunProvider {
-    /**
-   * Initialize the Mailgun provider with configuration
-   */ async initialize(config) {
-        this.config = config;
+const MAILGUN_API_URL = 'https://api.mailgun.net';
+const MAILGUN_EU_API_URL = 'https://api.eu.mailgun.net';
+export class MailgunProvider {
+    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,
@@ -36,84 +30,82 @@ import { Logger } from '@nestjs/common';
             });
             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 Logger(MailgunProvider.name));
         _define_property(this, "client", null);
-        _define_property(this, "config", null);
+        _define_property(this, "domain", null);
     }
 }

package/fesm/providers/sendgrid-provider.js

@@ -12,70 +12,27 @@ function _define_property(obj, key, value) {
     return obj;
 }
 import { Logger } from '@nestjs/common';
-/**
- * SendGrid Email Provider
- * Uses @sendgrid/mail package for sending emails
- * Install: npm install @sendgrid/mail
- */ export class SendGridProvider {
-    /**
-   * Initialize the SendGrid provider with configuration
-   */ async initialize(config) {
-        this.config = config;
+export class SendGridProvider {
+    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}`);
@@ -84,67 +41,82 @@ import { Logger } from '@nestjs/common';
                 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 Logger(SendGridProvider.name));
         _define_property(this, "sgMail", null);
-        _define_property(this, "config", null);
+        _define_property(this, "apiKey", null);
     }
 }