@flusys/nestjs-email 1.1.0-beta

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

@@ -0,0 +1,164 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
+import { Inject, Injectable, Logger, Optional, Scope } from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { Request } from 'express';
+import { EmailModuleOptions } from '../interfaces';
+import { EMAIL_MODULE_OPTIONS } from '../config/email.constants';
+export class EmailDataSourceProvider extends MultiTenantDataSourceService {
+    // ==================== Factory Methods ====================
+    /**
+   * Build parent options from EmailModuleOptions
+   */ static buildParentOptions(options) {
+        return {
+            bootstrapAppConfig: options.bootstrapAppConfig,
+            defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
+            tenantDefaultDatabaseConfig: options.config?.tenantDefaultDatabaseConfig,
+            tenants: options.config?.tenants
+        };
+    }
+    // ==================== Feature Flags ====================
+    /**
+   * Get global enable company feature flag
+   */ getEnableCompanyFeature() {
+        return this.emailOptions.bootstrapAppConfig?.enableCompanyFeature ?? false;
+    }
+    /**
+   * 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) {
+        const currentTenant = this.getCurrentTenant();
+        const enableCompanyFeature = this.getEnableCompanyFeatureForTenant(currentTenant ?? undefined);
+        const entities = await this.getEmailEntities(enableCompanyFeature);
+        return super.createDataSourceFromConfig(config, entities);
+    }
+    /**
+   * Override to use Email-specific static cache
+   */ async getSingleDataSource() {
+        // Return existing initialized connection from Email-specific cache
+        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.');
+        }
+        // Create connection with lock to prevent race conditions
+        const connectionPromise = this.createDataSourceFromConfig(config);
+        EmailDataSourceProvider.singleConnectionLock = connectionPromise;
+        try {
+            const dataSource = await connectionPromise;
+            EmailDataSourceProvider.singleDataSource = dataSource;
+            return dataSource;
+        } finally{
+            EmailDataSourceProvider.singleConnectionLock = null;
+        }
+    }
+    /**
+   * Override to use Email-specific static cache for tenant connections
+   */ async getOrCreateTenantConnection(tenant) {
+        // Return existing initialized connection from Email-specific cache
+        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);
+        try {
+            const dataSource = await connectionPromise;
+            EmailDataSourceProvider.tenantConnections.set(tenant.id, dataSource);
+            return dataSource;
+        } finally{
+            EmailDataSourceProvider.connectionLocks.delete(tenant.id);
+        }
+    }
+    constructor(emailOptions, request){
+        super(EmailDataSourceProvider.buildParentOptions(emailOptions), request), _define_property(this, "emailOptions", void 0), _define_property(this, "logger", void 0), this.emailOptions = emailOptions, this.logger = new Logger(EmailDataSourceProvider.name);
+    }
+}
+// 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());
+_define_property(EmailDataSourceProvider, "initialized", false);
+_define_property(EmailDataSourceProvider, "connectionLocks", new Map());
+_define_property(EmailDataSourceProvider, "singleConnectionLock", null);
+EmailDataSourceProvider = _ts_decorate([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_param(0, Inject(EMAIL_MODULE_OPTIONS)),
+    _ts_param(1, Optional()),
+    _ts_param(1, Inject(REQUEST)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof EmailModuleOptions === "undefined" ? Object : EmailModuleOptions,
+        typeof Request === "undefined" ? Object : Request
+    ])
+], EmailDataSourceProvider);

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

@@ -0,0 +1,170 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { RequestScopedApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { Inject, Injectable, Scope } from '@nestjs/common';
+import { EmailConfigService } from '../config';
+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;
+    }
+    /**
+   * Get DataSource provider for this service
+   */ getDataSourceProvider() {
+        return this.dataSourceProvider;
+    }
+    async convertSingleDtoToEntity(dto, user) {
+        let emailConfigEntity = {
+            ...dto
+        };
+        // Set company fields if company feature is enabled
+        if (this.emailConfig.isCompanyFeatureEnabled()) {
+            emailConfigEntity.companyId = user?.companyId ?? null;
+        }
+        return emailConfigEntity;
+    }
+    async getSelectQuery(query, _user, select) {
+        if (!select || !select.length) {
+            select = [
+                'id',
+                'name',
+                'provider',
+                'config',
+                'fromEmail',
+                'fromName',
+                'isActive',
+                'isDefault',
+                'createdAt',
+                'updatedAt'
+            ];
+            if (this.emailConfig.isCompanyFeatureEnabled()) {
+                select.push('companyId');
+            }
+        }
+        const selectFields = select.map((field)=>`${this.entityName}.${field}`);
+        query.select(selectFields);
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    /**
+   * Override: Extra query manipulation - Auto-filter by user's company
+   */ 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
+            });
+        }
+        query.orderBy(`${this.entityName}.createdAt`, 'DESC');
+        return result;
+    }
+    /**
+   * Find config by ID directly (bypasses company filtering)
+   */ async findByIdDirect(id) {
+        await this.ensureRepositoryInitialized();
+        return await 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) {
+        await this.ensureRepositoryInitialized();
+        const baseWhere = {
+            isActive: true
+        };
+        if (this.emailConfig.isCompanyFeatureEnabled() && user?.companyId) {
+            baseWhere.companyId = user.companyId;
+        }
+        // First try to find config marked as default
+        const defaultConfig = await this.repository.findOne({
+            where: {
+                ...baseWhere,
+                isDefault: true
+            },
+            order: {
+                createdAt: 'ASC'
+            }
+        });
+        if (defaultConfig) {
+            return defaultConfig;
+        }
+        // Fall back to any available active config (oldest first for consistency)
+        return await this.repository.findOne({
+            where: baseWhere,
+            order: {
+                createdAt: 'ASC'
+            }
+        });
+    }
+    /**
+   * Get config by provider type
+   */ async getConfigByProvider(provider, user) {
+        await this.ensureRepositoryInitialized();
+        const where = {
+            provider,
+            isActive: true
+        };
+        if (this.emailConfig.isCompanyFeatureEnabled() && user?.companyId) {
+            where.companyId = user.companyId;
+        }
+        return await this.repository.find({
+            where
+        });
+    }
+    constructor(cacheManager, utilsService, emailConfig, dataSourceProvider){
+        super('emailConfig', null, cacheManager, utilsService, EmailProviderConfigService.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;
+    }
+}
+EmailProviderConfigService = _ts_decorate([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_param(0, Inject('CACHE_INSTANCE')),
+    _ts_param(1, Inject(UtilsService)),
+    _ts_param(2, Inject(EmailConfigService)),
+    _ts_param(3, Inject(EmailDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof HybridCache === "undefined" ? Object : HybridCache,
+        typeof UtilsService === "undefined" ? Object : UtilsService,
+        typeof EmailConfigService === "undefined" ? Object : EmailConfigService,
+        typeof EmailDataSourceProvider === "undefined" ? Object : EmailDataSourceProvider
+    ])
+], EmailProviderConfigService);

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

@@ -0,0 +1,218 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { BadRequestException, Inject, Injectable, Logger, NotFoundException, Scope } from '@nestjs/common';
+import { EmailConfigService } from '../config';
+import { EmailFactoryService } from '../providers';
+import { EmailProviderConfigService } from './email-provider-config.service';
+import { EmailTemplateService } from './email-template.service';
+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) {
+        const { provider, config } = await this.getEmailProviderWithConfig(dto.emailConfigId, user);
+        const result = await provider.sendEmail({
+            to: dto.to,
+            cc: dto.cc,
+            bcc: dto.bcc,
+            subject: dto.subject,
+            html: dto.html,
+            text: dto.text,
+            from: dto.from || config.fromEmail || undefined,
+            fromName: dto.fromName || config.fromName || this.emailConfigService.getDefaultFromName(),
+            replyTo: dto.replyTo,
+            attachments: dto.attachments?.map((a)=>({
+                    filename: a.filename,
+                    content: Buffer.from(a.content, 'base64'),
+                    contentType: a.contentType
+                }))
+        });
+        this.logger.log(`Email sent to ${Array.isArray(dto.to) ? dto.to.join(', ') : dto.to}: ${result.success ? 'SUCCESS' : 'FAILED'}`);
+        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
+        const { provider, config } = await this.getEmailProviderWithConfig(dto.emailConfigId, user);
+        const result = await provider.sendEmail({
+            to: dto.to,
+            cc: dto.cc,
+            bcc: dto.bcc,
+            subject,
+            html,
+            text,
+            from: dto.from || config.fromEmail || undefined,
+            fromName: dto.fromName || config.fromName || this.emailConfigService.getDefaultFromName(),
+            replyTo: dto.replyTo,
+            attachments: dto.attachments?.map((a)=>({
+                    filename: a.filename,
+                    content: Buffer.from(a.content, 'base64'),
+                    contentType: a.contentType
+                }))
+        });
+        this.logger.log(`Template email sent to ${Array.isArray(dto.to) ? dto.to.join(', ') : dto.to} using template "${template.slug}": ${result.success ? 'SUCCESS' : 'FAILED'}`);
+        return result;
+    }
+    /**
+   * Send test email (for testing configuration)
+   */ async sendTestEmail(emailConfigId, recipient, user) {
+        const { provider, config } = await this.getEmailProviderWithConfig(emailConfigId, user);
+        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>
+      `,
+            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'}`);
+        return result;
+    }
+    constructor(emailFactory, emailConfigService, emailProviderConfigService, emailTemplateService){
+        _define_property(this, "emailFactory", void 0);
+        _define_property(this, "emailConfigService", void 0);
+        _define_property(this, "emailProviderConfigService", void 0);
+        _define_property(this, "emailTemplateService", void 0);
+        _define_property(this, "logger", void 0);
+        this.emailFactory = emailFactory;
+        this.emailConfigService = emailConfigService;
+        this.emailProviderConfigService = emailProviderConfigService;
+        this.emailTemplateService = emailTemplateService;
+        this.logger = new Logger(EmailSendService.name);
+    }
+}
+EmailSendService = _ts_decorate([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_param(0, Inject(EmailFactoryService)),
+    _ts_param(1, Inject(EmailConfigService)),
+    _ts_param(2, Inject(EmailProviderConfigService)),
+    _ts_param(3, Inject(EmailTemplateService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof EmailFactoryService === "undefined" ? Object : EmailFactoryService,
+        typeof EmailConfigService === "undefined" ? Object : EmailConfigService,
+        typeof EmailProviderConfigService === "undefined" ? Object : EmailProviderConfigService,
+        typeof EmailTemplateService === "undefined" ? Object : EmailTemplateService
+    ])
+], EmailSendService);