@flusys/nestjs-email 1.1.0-beta → 2.0.0

package/fesm/providers/smtp-provider.js

@@ -12,67 +12,38 @@ function _define_property(obj, key, value) {
     return obj;
 }
 import { Logger } from '@nestjs/common';
-/**
- * SMTP Email Provider using nodemailer
- * Default provider - always available
- */ export 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
+const VERIFY_TIMEOUT_MS = 10_000;
+const SEND_TIMEOUT_MS = 30_000;
+export class SmtpProvider {
+    async initialize(config) {
+        this.logger.log(`Initializing SMTP: host=${config.host}, port=${config.port}`);
         const nodemailer = await import('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,
@@ -84,35 +55,20 @@ import { Logger } from '@nestjs/common';
                         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();
@@ -121,17 +77,47 @@ import { Logger } from '@nestjs/common';
             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 Logger(SmtpProvider.name));
         _define_property(this, "transporter", null);
-        _define_property(this, "config", null);
     }
 }

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

@@ -26,47 +26,24 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { Inject, Injectable } from '@nestjs/common';
+import { EMAIL_MODULE_OPTIONS, DEFAULT_FROM_NAME } from '../config/email.constants';
 import { EmailModuleOptions } from '../interfaces';
-import { EMAIL_MODULE_OPTIONS, DEFAULT_FROM_NAME } from './email.constants';
 export 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 DEFAULT_FROM_NAME;
     }
-    /**
-   * Get default database config
-   */ getDefaultDatabaseConfig() {
-        return this.options.config?.defaultDatabaseConfig;
-    }
-    /**
-   * Get all options
-   */ getOptions() {
+    getOptions() {
         return this.options;
     }
     constructor(options){

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

@@ -26,16 +26,14 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
-import { Inject, Injectable, Logger, Optional, Scope } from '@nestjs/common';
+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';
+import { getEmailEntitiesByConfig } from '../entities';
+import { EmailConfigService } from './email-config.service';
 export class EmailDataSourceProvider extends MultiTenantDataSourceService {
-    // ==================== Factory Methods ====================
-    /**
-   * Build parent options from EmailModuleOptions
-   */ static buildParentOptions(options) {
+    // ─── Factory Methods ────────────────────────────────────────────────────────
+    static buildParentOptions(options) {
         return {
             bootstrapAppConfig: options.bootstrapAppConfig,
             defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
@@ -43,66 +41,28 @@ export class EmailDataSourceProvider extends MultiTenantDataSourceService {
             tenants: options.config?.tenants
         };
     }
-    // ==================== Feature Flags ====================
-    /**
-   * Get global enable company feature flag
-   */ getEnableCompanyFeature() {
-        return this.emailOptions.bootstrapAppConfig?.enableCompanyFeature ?? false;
+    // ─── Feature Flags ──────────────────────────────────────────────────────────
+    getEnableCompanyFeatureForTenant(tenant) {
+        return tenant?.enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
     }
-    /**
-   * Get enable company feature for specific tenant
-   * Falls back to global setting if not specified per-tenant
-   */ getEnableCompanyFeatureForTenant(tenant) {
-        return tenant?.enableCompanyFeature ?? this.getEnableCompanyFeature();
-    }
-    /**
-   * Get enable company feature for current request context
-   */ getEnableCompanyFeatureForCurrentTenant() {
-        return this.getEnableCompanyFeatureForTenant(this.getCurrentTenant() ?? undefined);
-    }
-    // ==================== Entity Management ====================
-    /**
-   * Get email entities for migrations based on company feature flag
-   */ 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
-        ];
-    }
-    // ==================== Overrides ====================
-    /**
-   * Override to dynamically set entities based on tenant config
-   */ async createDataSourceFromConfig(config) {
+    // ─── Overrides ──────────────────────────────────────────────────────────────
+    async createDataSourceFromConfig(config) {
         const currentTenant = this.getCurrentTenant();
         const enableCompanyFeature = this.getEnableCompanyFeatureForTenant(currentTenant ?? undefined);
-        const entities = await this.getEmailEntities(enableCompanyFeature);
+        const entities = getEmailEntitiesByConfig(enableCompanyFeature);
         return super.createDataSourceFromConfig(config, entities);
     }
-    /**
-   * Override to use Email-specific static cache
-   */ async getSingleDataSource() {
-        // Return existing initialized connection from Email-specific cache
+    async getSingleDataSource() {
         if (EmailDataSourceProvider.singleDataSource?.isInitialized) {
             return EmailDataSourceProvider.singleDataSource;
         }
-        // If another request is creating the connection, wait for it
         if (EmailDataSourceProvider.singleConnectionLock) {
             return EmailDataSourceProvider.singleConnectionLock;
         }
         const config = this.getDefaultDatabaseConfig();
         if (!config) {
-            throw new Error('No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.');
+            throw new InternalServerErrorException('No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.');
         }
-        // Create connection with lock to prevent race conditions
         const connectionPromise = this.createDataSourceFromConfig(config);
         EmailDataSourceProvider.singleConnectionLock = connectionPromise;
         try {
@@ -113,20 +73,15 @@ export class EmailDataSourceProvider extends MultiTenantDataSourceService {
             EmailDataSourceProvider.singleConnectionLock = null;
         }
     }
-    /**
-   * Override to use Email-specific static cache for tenant connections
-   */ async getOrCreateTenantConnection(tenant) {
-        // Return existing initialized connection from Email-specific cache
+    async getOrCreateTenantConnection(tenant) {
         const existing = EmailDataSourceProvider.tenantConnections.get(tenant.id);
         if (existing?.isInitialized) {
             return existing;
         }
-        // If another request is creating this tenant's connection, wait for it
         const pendingConnection = EmailDataSourceProvider.connectionLocks.get(tenant.id);
         if (pendingConnection) {
             return pendingConnection;
         }
-        // Create connection with lock to prevent race conditions
         const config = this.buildTenantDatabaseConfig(tenant);
         const connectionPromise = this.createDataSourceFromConfig(config);
         EmailDataSourceProvider.connectionLocks.set(tenant.id, connectionPromise);
@@ -138,11 +93,10 @@ export class EmailDataSourceProvider extends MultiTenantDataSourceService {
             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);
+    constructor(configService, request){
+        super(EmailDataSourceProvider.buildParentOptions(configService.getOptions()), request), _define_property(this, "configService", void 0), _define_property(this, "logger", void 0), this.configService = configService, this.logger = new Logger(EmailDataSourceProvider.name);
     }
 }
-// Override parent's static properties to have Email-specific cache
 _define_property(EmailDataSourceProvider, "tenantConnections", new Map());
 _define_property(EmailDataSourceProvider, "singleDataSource", null);
 _define_property(EmailDataSourceProvider, "tenantsRegistry", new Map());
@@ -153,12 +107,12 @@ EmailDataSourceProvider = _ts_decorate([
     Injectable({
         scope: Scope.REQUEST
     }),
-    _ts_param(0, Inject(EMAIL_MODULE_OPTIONS)),
+    _ts_param(0, Inject(EmailConfigService)),
     _ts_param(1, Optional()),
     _ts_param(1, Inject(REQUEST)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof EmailModuleOptions === "undefined" ? Object : EmailModuleOptions,
+        typeof EmailConfigService === "undefined" ? Object : EmailConfigService,
         typeof Request === "undefined" ? Object : Request
     ])
 ], EmailDataSourceProvider);

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

@@ -27,34 +27,29 @@ 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 { EmailConfig, EmailConfigWithCompany } from '../entities';
 import { EmailDataSourceProvider } from './email-datasource.provider';
 export class EmailProviderConfigService extends RequestScopedApiService {
-    /**
-   * Resolve entity class for this service
-   */ resolveEntity() {
-        const enableCompanyFeature = this.emailConfig.isCompanyFeatureEnabled();
-        return enableCompanyFeature ? EmailConfigWithCompany : EmailConfig;
+    resolveEntity() {
+        return this.emailConfig.isCompanyFeatureEnabled() ? EmailConfigWithCompany : EmailConfig;
     }
-    /**
-   * Get DataSource provider for this service
-   */ getDataSourceProvider() {
+    getDataSourceProvider() {
         return this.dataSourceProvider;
     }
     async convertSingleDtoToEntity(dto, user) {
-        let emailConfigEntity = {
+        const entity = {
             ...dto
         };
-        // Set company fields if company feature is enabled
         if (this.emailConfig.isCompanyFeatureEnabled()) {
-            emailConfigEntity.companyId = user?.companyId ?? null;
+            entity.companyId = user?.companyId ?? null;
         }
-        return emailConfigEntity;
+        return entity;
     }
     async getSelectQuery(query, _user, select) {
-        if (!select || !select.length) {
+        if (!select?.length) {
             select = [
                 'id',
                 'name',
@@ -67,52 +62,36 @@ export class EmailProviderConfigService extends RequestScopedApiService {
                 'createdAt',
                 'updatedAt'
             ];
-            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('emailConfig.companyId = :companyId', {
-                companyId: user.companyId
-            });
-        }
+        applyCompanyFilter(query, {
+            isCompanyFeatureEnabled: this.emailConfig.isCompanyFeatureEnabled(),
+            entityAlias: 'emailConfig'
+        }, user);
         query.orderBy(`${this.entityName}.createdAt`, 'DESC');
         return result;
     }
-    /**
-   * Find config by ID directly (bypasses company filtering)
-   */ async findByIdDirect(id) {
+    async findByIdDirect(id) {
         await this.ensureRepositoryInitialized();
-        return await this.repository.findOne({
+        return this.repository.findOne({
             where: {
                 id
             }
         });
     }
-    /**
-   * Get default email configuration (scoped to user's company if enabled)
-   * Priority: isDefault=true > any active config (oldest first)
-   */ async getDefaultConfig(user) {
+    async getDefaultConfig(user) {
         await this.ensureRepositoryInitialized();
-        const baseWhere = {
+        const baseWhere = buildCompanyWhereCondition({
             isActive: true
-        };
-        if (this.emailConfig.isCompanyFeatureEnabled() && user?.companyId) {
-            baseWhere.companyId = user.companyId;
-        }
-        // First try to find config marked as default
+        }, this.emailConfig.isCompanyFeatureEnabled(), user);
         const defaultConfig = await this.repository.findOne({
             where: {
                 ...baseWhere,
@@ -122,29 +101,20 @@ export class EmailProviderConfigService extends RequestScopedApiService {
                 createdAt: 'ASC'
             }
         });
-        if (defaultConfig) {
-            return defaultConfig;
-        }
-        // Fall back to any available active config (oldest first for consistency)
-        return await this.repository.findOne({
+        return defaultConfig || this.repository.findOne({
             where: baseWhere,
             order: {
                 createdAt: 'ASC'
             }
         });
     }
-    /**
-   * Get config by provider type
-   */ async getConfigByProvider(provider, user) {
+    async getConfigByProvider(provider, user) {
         await this.ensureRepositoryInitialized();
-        const where = {
+        const where = buildCompanyWhereCondition({
             provider,
             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
         });
     }