@flusys/nestjs-email 1.1.0-beta → 2.0.0

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

@@ -25,64 +25,18 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
+import { escapeHtmlVariables, validateCompanyOwnership } from '@flusys/nestjs-shared/utils';
 import { BadRequestException, Inject, Injectable, Logger, NotFoundException, Scope } from '@nestjs/common';
-import { EmailConfigService } from '../config';
+import { EmailConfigService } from './email-config.service';
 import { EmailFactoryService } from '../providers';
 import { EmailProviderConfigService } from './email-provider-config.service';
 import { EmailTemplateService } from './email-template.service';
+/** Valid identifier pattern for template variables: {{varName}} */ const VARIABLE_PATTERN = /\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g;
 export class EmailSendService {
-    /**
-   * Get email provider based on config ID or default
-   */ async getEmailProviderWithConfig(emailConfigId, user) {
-        let emailConfig;
-        if (emailConfigId) {
-            const config = await this.emailProviderConfigService.findByIdDirect(emailConfigId);
-            if (!config) {
-                throw new NotFoundException('Email configuration not found');
-            }
-            // Validate company ownership
-            if (this.emailConfigService.isCompanyFeatureEnabled() && user?.companyId) {
-                const configWithCompany = config;
-                if (configWithCompany.companyId && configWithCompany.companyId !== user.companyId) {
-                    throw new BadRequestException('Email configuration belongs to another company');
-                }
-            }
-            if (!config.isActive) {
-                throw new BadRequestException('Email configuration is inactive');
-            }
-            emailConfig = config;
-        } else {
-            const defaultConfig = await this.emailProviderConfigService.getDefaultConfig(user);
-            if (!defaultConfig) {
-                throw new NotFoundException('No default email configuration found. Please create one.');
-            }
-            emailConfig = defaultConfig;
-        }
-        const providerConfig = {
-            provider: emailConfig.provider,
-            config: emailConfig.config
-        };
-        const provider = await this.emailFactory.createProvider(providerConfig);
-        return {
-            provider,
-            config: emailConfig
-        };
-    }
-    /**
-   * Interpolate variables in template content
-   * Replaces {{variableName}} with actual values
-   */ interpolateVariables(content, variables) {
-        if (!variables || Object.keys(variables).length === 0) {
-            return content;
-        }
-        return content.replace(/\{\{(\w+)\}\}/g, (match, varName)=>{
-            return variables[varName] !== undefined ? String(variables[varName]) : match;
-        });
-    }
-    /**
-   * Send email directly (without template)
-   */ async sendEmail(dto, user) {
+    // ─── Public API ─────────────────────────────────────────────────────────────
+    async sendEmail(dto, user) {
         const { provider, config } = await this.getEmailProviderWithConfig(dto.emailConfigId, user);
+        const sender = this.resolveSender(dto, config);
         const result = await provider.sendEmail({
             to: dto.to,
             cc: dto.cc,
@@ -90,59 +44,18 @@ export class EmailSendService {
             subject: dto.subject,
             html: dto.html,
             text: dto.text,
-            from: dto.from || config.fromEmail || undefined,
-            fromName: dto.fromName || config.fromName || this.emailConfigService.getDefaultFromName(),
+            ...sender,
             replyTo: dto.replyTo,
-            attachments: dto.attachments?.map((a)=>({
-                    filename: a.filename,
-                    content: Buffer.from(a.content, 'base64'),
-                    contentType: a.contentType
-                }))
+            attachments: this.buildAttachments(dto.attachments)
         });
-        this.logger.log(`Email sent to ${Array.isArray(dto.to) ? dto.to.join(', ') : dto.to}: ${result.success ? 'SUCCESS' : 'FAILED'}`);
+        this.logResult(dto.to, result);
         return result;
     }
-    /**
-   * Send email using template
-   */ async sendTemplateEmail(dto, user) {
-        // Get template by ID or slug
-        let template;
-        if (dto.templateId) {
-            template = await this.emailTemplateService.findByIdDirect(dto.templateId);
-        } else if (dto.templateSlug) {
-            template = await this.emailTemplateService.findBySlug(dto.templateSlug, user);
-        } else {
-            throw new BadRequestException('templateId or templateSlug is required');
-        }
-        if (!template) {
-            throw new NotFoundException('Email template not found');
-        }
-        if (!template.isActive) {
-            throw new BadRequestException('Email template is inactive');
-        }
-        // Validate company ownership
-        if (this.emailConfigService.isCompanyFeatureEnabled() && user?.companyId) {
-            const templateWithCompany = template;
-            if (templateWithCompany.companyId && templateWithCompany.companyId !== user.companyId) {
-                throw new BadRequestException('Email template belongs to another company');
-            }
-        }
-        // Interpolate variables in subject and content
-        const subject = this.interpolateVariables(template.subject, dto.variables || {});
-        // Check isHtml to determine which content to send
-        let html;
-        let text;
-        if (template.isHtml) {
-            // HTML template - send htmlContent, with textContent as fallback
-            html = this.interpolateVariables(template.htmlContent, dto.variables || {});
-            text = template.textContent ? this.interpolateVariables(template.textContent, dto.variables || {}) : undefined;
-        } else {
-            // Plain text template - send only textContent, no HTML
-            text = template.textContent ? this.interpolateVariables(template.textContent, dto.variables || {}) : this.interpolateVariables(template.htmlContent, dto.variables || {}); // fallback to htmlContent if textContent is empty
-            html = undefined;
-        }
-        // Get provider and send
+    async sendTemplateEmail(dto, user) {
+        const template = await this.resolveTemplate(dto, user);
+        const { subject, html, text } = this.buildTemplateContent(template, dto.variables);
         const { provider, config } = await this.getEmailProviderWithConfig(dto.emailConfigId, user);
+        const sender = this.resolveSender(dto, config);
         const result = await provider.sendEmail({
             to: dto.to,
             cc: dto.cc,
@@ -150,43 +63,125 @@ export class EmailSendService {
             subject,
             html,
             text,
-            from: dto.from || config.fromEmail || undefined,
-            fromName: dto.fromName || config.fromName || this.emailConfigService.getDefaultFromName(),
+            ...sender,
             replyTo: dto.replyTo,
-            attachments: dto.attachments?.map((a)=>({
-                    filename: a.filename,
-                    content: Buffer.from(a.content, 'base64'),
-                    contentType: a.contentType
-                }))
+            attachments: this.buildAttachments(dto.attachments)
         });
-        this.logger.log(`Template email sent to ${Array.isArray(dto.to) ? dto.to.join(', ') : dto.to} using template "${template.slug}": ${result.success ? 'SUCCESS' : 'FAILED'}`);
+        this.logResult(dto.to, result, template.slug);
         return result;
     }
-    /**
-   * Send test email (for testing configuration)
-   */ async sendTestEmail(emailConfigId, recipient, user) {
+    async sendTestEmail(emailConfigId, recipient, user) {
         const { provider, config } = await this.getEmailProviderWithConfig(emailConfigId, user);
+        const safeConfig = escapeHtmlVariables({
+            name: config.name,
+            provider: config.provider.toUpperCase()
+        });
         const result = await provider.sendEmail({
             to: recipient,
             subject: 'Test Email from FLUSYS',
-            html: `
-        <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
-          <h1 style="color: #333;">Test Email</h1>
-          <p>This is a test email from FLUSYS Email Service.</p>
-          <p><strong>Configuration:</strong> ${config.name}</p>
-          <p><strong>Provider:</strong> ${config.provider.toUpperCase()}</p>
-          <p style="color: #666; font-size: 12px;">
-            If you received this email, your email configuration is working correctly.
-          </p>
-        </div>
-      `,
+            html: this.buildTestEmailHtml(safeConfig),
             text: `Test Email from FLUSYS\n\nThis is a test email.\nConfiguration: ${config.name}\nProvider: ${config.provider.toUpperCase()}`,
             from: config.fromEmail || undefined,
             fromName: config.fromName || this.emailConfigService.getDefaultFromName()
         });
-        this.logger.log(`Test email sent to ${recipient}: ${result.success ? 'SUCCESS' : 'FAILED'}`);
+        this.logResult(recipient, result);
         return result;
     }
+    // ─── Private: Provider & Config Resolution ──────────────────────────────────
+    async getEmailProviderWithConfig(emailConfigId, user) {
+        const emailConfig = emailConfigId ? await this.resolveConfigById(emailConfigId, user) : await this.resolveDefaultConfig(user);
+        const providerConfig = {
+            provider: emailConfig.provider,
+            config: emailConfig.config
+        };
+        return {
+            provider: await this.emailFactory.createProvider(providerConfig),
+            config: emailConfig
+        };
+    }
+    async resolveConfigById(id, user) {
+        const config = await this.emailProviderConfigService.findByIdDirect(id);
+        if (!config) throw new NotFoundException('Email configuration not found');
+        validateCompanyOwnership(config, user, this.emailConfigService.isCompanyFeatureEnabled(), 'Email configuration');
+        if (!config.isActive) throw new BadRequestException('Email configuration is inactive');
+        return config;
+    }
+    async resolveDefaultConfig(user) {
+        const config = await this.emailProviderConfigService.getDefaultConfig(user);
+        if (!config) throw new NotFoundException('No default email configuration found');
+        return config;
+    }
+    // ─── Private: Template Resolution ───────────────────────────────────────────
+    async resolveTemplate(dto, user) {
+        let template = null;
+        if (dto.templateId) {
+            template = await this.emailTemplateService.findByIdDirect(dto.templateId);
+        } else if (dto.templateSlug) {
+            template = await this.emailTemplateService.findBySlug(dto.templateSlug, user);
+        } else {
+            throw new BadRequestException('templateId or templateSlug is required');
+        }
+        if (!template) throw new NotFoundException('Email template not found');
+        if (!template.isActive) throw new BadRequestException('Email template is inactive');
+        validateCompanyOwnership(template, user, this.emailConfigService.isCompanyFeatureEnabled(), 'Email template');
+        return template;
+    }
+    buildTemplateContent(template, variables) {
+        const vars = variables || {};
+        const subject = this.interpolateVariables(template.subject, vars, false);
+        if (template.isHtml) {
+            return {
+                subject,
+                html: this.interpolateVariables(template.htmlContent, vars, true),
+                text: template.textContent ? this.interpolateVariables(template.textContent, vars, false) : undefined
+            };
+        }
+        return {
+            subject,
+            html: undefined,
+            text: template.textContent ? this.interpolateVariables(template.textContent, vars, false) : this.interpolateVariables(template.htmlContent, vars, false)
+        };
+    }
+    // ─── Private: Helpers ───────────────────────────────────────────────────────
+    resolveSender(dto, config) {
+        return {
+            from: dto.from || config.fromEmail || undefined,
+            fromName: dto.fromName || config.fromName || this.emailConfigService.getDefaultFromName()
+        };
+    }
+    buildAttachments(attachments) {
+        return attachments?.map((a)=>({
+                filename: a.filename,
+                content: Buffer.from(a.content, 'base64'),
+                contentType: a.contentType
+            }));
+    }
+    interpolateVariables(content, variables, escapeHtml) {
+        if (!variables || Object.keys(variables).length === 0) return content;
+        const safeVars = escapeHtml ? escapeHtmlVariables(variables) : variables;
+        return content.replace(VARIABLE_PATTERN, (match, varName)=>{
+            return varName in safeVars && safeVars[varName] !== undefined ? String(safeVars[varName]) : match;
+        });
+    }
+    logResult(to, result, templateSlug) {
+        const recipient = Array.isArray(to) ? to.join(', ') : to;
+        const status = result.success ? 'SUCCESS' : 'FAILED';
+        const message = templateSlug ? `Template email sent to ${recipient} using template "${templateSlug}": ${status}` : `Email sent to ${recipient}: ${status}`;
+        this.logger.log(message);
+    }
+    buildTestEmailHtml(safeConfig) {
+        return `
+      <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
+        <h1 style="color: #333;">Test Email</h1>
+        <p>This is a test email from FLUSYS Email Service.</p>
+        <p><strong>Configuration:</strong> ${safeConfig.name}</p>
+        <p><strong>Provider:</strong> ${safeConfig.provider}</p>
+        <p style="color: #666; font-size: 12px;">
+          If you received this email, your email configuration is working correctly.
+        </p>
+      </div>
+    `;
+    }
     constructor(emailFactory, emailConfigService, emailProviderConfigService, emailTemplateService){
         _define_property(this, "emailFactory", void 0);
         _define_property(this, "emailConfigService", void 0);

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

@@ -27,133 +27,110 @@ function _ts_param(paramIndex, decorator) {
 }
 import { RequestScopedApiService, HybridCache } from '@flusys/nestjs-shared/classes';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { applyCompanyFilter, buildCompanyWhereCondition } from '@flusys/nestjs-shared/utils';
 import { Inject, Injectable, Scope } from '@nestjs/common';
-import { EmailConfigService } from '../config';
+import { EmailConfigService } from './email-config.service';
 import { EmailTemplate, EmailTemplateWithCompany } from '../entities';
 import { EmailDataSourceProvider } from './email-datasource.provider';
+const DEFAULT_SELECT_FIELDS = [
+    'id',
+    'name',
+    'slug',
+    'description',
+    'subject',
+    'schema',
+    'htmlContent',
+    'textContent',
+    'schemaVersion',
+    'isActive',
+    'isHtml',
+    'metadata',
+    'createdAt',
+    'updatedAt'
+];
 export class EmailTemplateService extends RequestScopedApiService {
-    /**
-   * Resolve entity class for this service
-   */ resolveEntity() {
-        const enableCompanyFeature = this.emailConfig.isCompanyFeatureEnabled();
-        return enableCompanyFeature ? EmailTemplateWithCompany : EmailTemplate;
+    resolveEntity() {
+        return this.emailConfig.isCompanyFeatureEnabled() ? EmailTemplateWithCompany : EmailTemplate;
     }
-    /**
-   * Get DataSource provider for this service
-   */ getDataSourceProvider() {
+    getDataSourceProvider() {
         return this.dataSourceProvider;
     }
     async convertSingleDtoToEntity(dto, user) {
-        // For updates, fetch existing template to handle versioning
-        const updateDto = dto;
-        if (updateDto.id) {
-            await this.ensureRepositoryInitialized();
-            const existing = await this.repository.findOne({
-                where: {
-                    id: updateDto.id
-                }
-            });
-            if (existing) {
-                // Auto-increment schema version if schema changed
-                if (dto.schema && JSON.stringify(dto.schema) !== JSON.stringify(existing.schema)) {
-                    dto.schemaVersion = existing.schemaVersion + 1;
-                    this.logger.log(`Schema changed for template ${updateDto.id}, incrementing version from ${existing.schemaVersion} to ${dto.schemaVersion}`);
-                }
-            }
-        }
-        let templateEntity = {
-            ...dto
-        };
-        // Set company fields if company feature is enabled
+        const entity = await super.convertSingleDtoToEntity(dto, user);
+        await this.incrementSchemaVersionIfChanged(dto, entity);
         if (this.emailConfig.isCompanyFeatureEnabled()) {
-            templateEntity.companyId = user?.companyId ?? null;
+            entity.companyId = user?.companyId ?? null;
         }
-        return templateEntity;
+        return entity;
     }
     async getSelectQuery(query, _user, select) {
-        if (!select || !select.length) {
+        if (!select?.length) {
             select = [
-                'id',
-                'name',
-                'slug',
-                'description',
-                'subject',
-                'schema',
-                'htmlContent',
-                'textContent',
-                'schemaVersion',
-                'isActive',
-                'isHtml',
-                'metadata',
-                'createdAt',
-                'updatedAt'
+                ...DEFAULT_SELECT_FIELDS
             ];
-            if (this.emailConfig.isCompanyFeatureEnabled()) {
-                select.push('companyId');
-            }
+            if (this.emailConfig.isCompanyFeatureEnabled()) select.push('companyId');
         }
-        const selectFields = select.map((field)=>`${this.entityName}.${field}`);
-        query.select(selectFields);
+        query.select(select.map((field)=>`${this.entityName}.${field}`));
         return {
             query,
             isRaw: false
         };
     }
-    /**
-   * Override: Extra query manipulation - Auto-filter by user's company
-   */ async getExtraManipulateQuery(query, filterDto, user) {
+    async getExtraManipulateQuery(query, filterDto, user) {
         const result = await super.getExtraManipulateQuery(query, filterDto, user);
-        const enableCompanyFeature = this.emailConfig.isCompanyFeatureEnabled();
-        if (enableCompanyFeature && user?.companyId) {
-            query.andWhere('emailTemplate.companyId = :companyId', {
-                companyId: user.companyId
-            });
-        }
+        applyCompanyFilter(query, {
+            isCompanyFeatureEnabled: this.emailConfig.isCompanyFeatureEnabled(),
+            entityAlias: 'emailTemplate'
+        }, user);
         query.orderBy(`${this.entityName}.createdAt`, 'DESC');
         return result;
     }
-    /**
-   * Find template by ID directly (bypasses company filtering)
-   */ async findByIdDirect(id) {
+    // ─── Public Query Methods ───────────────────────────────────────────────────
+    async findByIdDirect(id) {
         await this.ensureRepositoryInitialized();
-        return await this.repository.findOne({
+        return this.repository.findOne({
             where: {
                 id
             }
         });
     }
-    /**
-   * Find template by slug (scoped to user's company if enabled)
-   */ async findBySlug(slug, user) {
+    async findBySlug(slug, user) {
         await this.ensureRepositoryInitialized();
-        const where = {
+        const where = buildCompanyWhereCondition({
             slug,
             isActive: true
-        };
-        if (this.emailConfig.isCompanyFeatureEnabled() && user?.companyId) {
-            where.companyId = user.companyId;
-        }
-        return await this.repository.findOne({
+        }, this.emailConfig.isCompanyFeatureEnabled(), user);
+        return this.repository.findOne({
             where
         });
     }
-    /**
-   * Get all active templates (scoped to user's company if enabled)
-   */ async getActiveTemplates(user) {
+    async getActiveTemplates(user) {
         await this.ensureRepositoryInitialized();
-        const where = {
+        const where = buildCompanyWhereCondition({
             isActive: true
-        };
-        if (this.emailConfig.isCompanyFeatureEnabled() && user?.companyId) {
-            where.companyId = user.companyId;
-        }
-        return await this.repository.find({
+        }, this.emailConfig.isCompanyFeatureEnabled(), user);
+        return this.repository.find({
             where,
             order: {
                 name: 'ASC'
             }
         });
     }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    async incrementSchemaVersionIfChanged(dto, entity) {
+        const updateDto = dto;
+        if (!updateDto.id || !dto.schema) return;
+        await this.ensureRepositoryInitialized();
+        const existing = await this.repository.findOne({
+            where: {
+                id: updateDto.id
+            }
+        });
+        if (existing && JSON.stringify(dto.schema) !== JSON.stringify(existing.schema)) {
+            entity.schemaVersion = existing.schemaVersion + 1;
+            this.logger.log(`Schema version incremented to ${entity.schemaVersion} for template ${updateDto.id}`);
+        }
+    }
     constructor(cacheManager, utilsService, emailConfig, dataSourceProvider){
         super('emailTemplate', null, cacheManager, utilsService, EmailTemplateService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "emailConfig", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.emailConfig = emailConfig, this.dataSourceProvider = dataSourceProvider;
     }

package/fesm/services/index.js

@@ -1,4 +1,5 @@
+export * from './email-config.service';
 export * from './email-datasource.provider';
 export * from './email-provider-config.service';
-export * from './email-template.service';
 export * from './email-send.service';
+export * from './email-template.service';

package/fesm/utils/email-templates.util.js

@@ -0,0 +1,47 @@
+// ─── Shared Styles ───────────────────────────────────────────────────────────
+const BASE_STYLES = `
+  body { font-family: Arial, sans-serif; background-color: #f4f4f7; margin: 0; padding: 0; }
+  .email-container { max-width: 500px; margin: 40px auto; background-color: #ffffff; padding: 30px; border-radius: 8px; box-shadow: 0 2px 6px rgba(0,0,0,0.1); text-align: center; }
+  h1 { color: #333; }
+  p { font-size: 16px; color: #555; }
+  .action-box { display: inline-block; margin: 20px 0; padding: 14px 28px; background-color: #007BFF; color: #ffffff; border-radius: 8px; font-weight: bold; text-decoration: none; }
+`;
+function wrapEmailTemplate(title, extraStyles, content) {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+  <title>${title}</title>
+  <style>${BASE_STYLES}${extraStyles}</style>
+</head>
+<body>
+  <div class="email-container">${content}</div>
+</body>
+</html>`;
+}
+function getGreeting(userName) {
+    return `<p>Hi ${userName || 'Sir/Madam'},</p>`;
+}
+// ─── Public Templates ────────────────────────────────────────────────────────
+export function getOtpEmailFormat(otp, userName) {
+    const extraStyles = `.action-box { font-size: 24px; letter-spacing: 6px; }`;
+    const content = `
+    ${getGreeting(userName)}
+    <p>Use the code below to verify your identity:</p>
+    <div class="action-box">${otp}</div>
+    <p>This OTP is valid for a limited time. Do not share it with anyone.</p>
+    <p>If you didn't request this, please ignore this email.</p>
+  `;
+    return wrapEmailTemplate('Your OTP Code', extraStyles, content);
+}
+export function getResetPasswordEmailFormat(resetLink, userName) {
+    const extraStyles = `.action-box { font-size: 16px; }`;
+    const content = `
+    ${getGreeting(userName)}
+    <p>We received a request to reset your password. Click the button below to reset it:</p>
+    <a href="${resetLink}" class="action-box" target="_blank">Reset Password</a>
+    <p>If you didn't request a password reset, you can safely ignore this email.</p>
+  `;
+    return wrapEmailTemplate('Reset Your Password', extraStyles, content);
+}

package/fesm/utils/index.js

@@ -0,0 +1 @@
+export * from './email-templates.util';

package/index.d.ts

@@ -7,3 +7,4 @@ export * from './dtos';
 export * from './enums';
 export * from './interfaces';
 export * from './providers';
+export * from './utils';

package/interfaces/email-config.interface.d.ts

@@ -7,8 +7,13 @@ export interface IEmailConfig extends IIdentity {
     fromEmail: string | null;
     fromName: string | null;
     isActive: boolean;
+    isDefault: boolean;
     companyId?: string | null;
 }
+export interface ISmtpTlsConfig {
+    rejectUnauthorized?: boolean;
+    minVersion?: 'TLSv1.2' | 'TLSv1.3';
+}
 export interface ISmtpConfig {
     host: string;
     port: number;
@@ -17,6 +22,7 @@ export interface ISmtpConfig {
         user: string;
         pass: string;
     };
+    tls?: ISmtpTlsConfig;
 }
 export interface ISendGridConfig {
     apiKey: string;

package/interfaces/email-module-options.interface.d.ts

@@ -5,17 +5,12 @@ export interface IEmailModuleConfig extends IDataSourceServiceOptions {
     rateLimitPerMinute?: number;
     enableLogging?: boolean;
 }
-export interface IEmailModuleConfigFull {
-    bootstrapAppConfig?: IBootstrapAppConfig;
-    config?: IEmailModuleConfig;
-}
 export interface EmailModuleOptions extends IDynamicModuleConfig {
     bootstrapAppConfig?: IBootstrapAppConfig;
     config?: IEmailModuleConfig;
 }
 export interface EmailOptionsFactory extends IModuleOptionsFactory<IEmailModuleConfig> {
     createEmailOptions(): Promise<IEmailModuleConfig> | IEmailModuleConfig;
-    createOptions(): Promise<IEmailModuleConfig> | IEmailModuleConfig;
 }
 export interface EmailModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'>, IDynamicModuleConfig {
     bootstrapAppConfig: IBootstrapAppConfig;

package/modules/email.module.d.ts

@@ -3,7 +3,6 @@ import { EmailModuleAsyncOptions, EmailModuleOptions } from '../interfaces';
 export declare class EmailModule {
     static forRoot(options: EmailModuleOptions): DynamicModule;
     static forRootAsync(options: EmailModuleAsyncOptions): DynamicModule;
-    private static getControllers;
-    private static getProviders;
+    private static buildProviders;
     private static createAsyncProviders;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-email",
-  "version": "1.1.0-beta",
+  "version": "2.0.0",
   "description": "Modular email package with SMTP, SendGrid, and Mailgun providers",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -83,7 +83,7 @@
     "class-transformer": "^0.5.0",
     "class-validator": "^0.14.0",
     "typeorm": "^0.3.0",
-    "nodemailer": "^6.9.0",
+    "nodemailer": "^7.0.0",
     "@sendgrid/mail": "^8.0.0",
     "mailgun.js": "^10.0.0"
   },
@@ -99,7 +99,7 @@
     }
   },
   "dependencies": {
-    "@flusys/nestjs-core": "1.1.0-beta",
-    "@flusys/nestjs-shared": "1.1.0-beta"
+    "@flusys/nestjs-core": "2.0.0",
+    "@flusys/nestjs-shared": "2.0.0"
   }
 }

package/providers/email-factory.service.d.ts

@@ -1,14 +1,11 @@
 import { OnModuleDestroy } from '@nestjs/common';
-import { EmailConfigService } from '../config/email-config.service';
 import { IEmailProvider, IEmailProviderConfig } from '../interfaces';
 export declare class EmailFactoryService implements OnModuleDestroy {
-    private readonly emailConfigService;
     private readonly logger;
-    private providerCache;
-    constructor(emailConfigService: EmailConfigService);
-    private generateCacheKey;
+    private readonly providerCache;
     createProvider(config: IEmailProviderConfig): Promise<IEmailProvider>;
-    isProviderAvailable(providerName: string): boolean;
-    getAvailableProviders(): string[];
     onModuleDestroy(): Promise<void>;
+    private generateCacheKey;
+    private closeProvider;
+    private extractErrorMessage;
 }

package/providers/mailgun-provider.d.ts

@@ -1,11 +1,15 @@
 import { IEmailProvider, IEmailSendOptions, IEmailSendResult, IMailgunConfig } from '../interfaces';
 export declare class MailgunProvider implements IEmailProvider {
-    private logger;
+    private readonly logger;
     private client;
-    private config;
+    private domain;
     initialize(config: IMailgunConfig): Promise<void>;
     sendEmail(options: IEmailSendOptions): Promise<IEmailSendResult>;
     sendBulkEmails(options: IEmailSendOptions[]): Promise<IEmailSendResult[]>;
     healthCheck(): Promise<boolean>;
     close(): Promise<void>;
+    private buildMessageData;
+    private joinAddresses;
+    private extractError;
+    private handleError;
 }