@flusys/nestjs-email 1.0.0-rc

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

@@ -0,0 +1,140 @@
+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 { applyCompanyFilter, buildCompanyWhereCondition } from '@flusys/nestjs-shared/utils';
+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 {
+    resolveEntity() {
+        return this.emailConfig.isCompanyFeatureEnabled() ? EmailConfigWithCompany : EmailConfig;
+    }
+    getDataSourceProvider() {
+        return this.dataSourceProvider;
+    }
+    async convertSingleDtoToEntity(dto, user) {
+        const entity = {
+            ...dto
+        };
+        if (this.emailConfig.isCompanyFeatureEnabled()) {
+            entity.companyId = user?.companyId ?? null;
+        }
+        return entity;
+    }
+    async getSelectQuery(query, _user, select) {
+        if (!select?.length) {
+            select = [
+                'id',
+                'name',
+                'provider',
+                'config',
+                'fromEmail',
+                'fromName',
+                'isActive',
+                'isDefault',
+                'createdAt',
+                'updatedAt'
+            ];
+            if (this.emailConfig.isCompanyFeatureEnabled()) select.push('companyId');
+        }
+        query.select(select.map((field)=>`${this.entityName}.${field}`));
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async getExtraManipulateQuery(query, filterDto, user) {
+        const result = await super.getExtraManipulateQuery(query, filterDto, user);
+        applyCompanyFilter(query, {
+            isCompanyFeatureEnabled: this.emailConfig.isCompanyFeatureEnabled(),
+            entityAlias: 'emailConfig'
+        }, user);
+        query.orderBy(`${this.entityName}.createdAt`, 'DESC');
+        return result;
+    }
+    async findByIdDirect(id) {
+        await this.ensureRepositoryInitialized();
+        return this.repository.findOne({
+            where: {
+                id
+            }
+        });
+    }
+    async getDefaultConfig(user) {
+        await this.ensureRepositoryInitialized();
+        const baseWhere = buildCompanyWhereCondition({
+            isActive: true
+        }, this.emailConfig.isCompanyFeatureEnabled(), user);
+        const defaultConfig = await this.repository.findOne({
+            where: {
+                ...baseWhere,
+                isDefault: true
+            },
+            order: {
+                createdAt: 'ASC'
+            }
+        });
+        return defaultConfig || this.repository.findOne({
+            where: baseWhere,
+            order: {
+                createdAt: 'ASC'
+            }
+        });
+    }
+    async getConfigByProvider(provider, user) {
+        await this.ensureRepositoryInitialized();
+        const where = buildCompanyWhereCondition({
+            provider,
+            isActive: true
+        }, this.emailConfig.isCompanyFeatureEnabled(), user);
+        return 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,201 @@
+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 { escapeHtmlVariables, validateCompanyOwnership } from '@flusys/nestjs-shared/utils';
+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 {
+    async getEmailProviderWithConfig(emailConfigId, user) {
+        let emailConfig;
+        if (emailConfigId) {
+            const config = await this.emailProviderConfigService.findByIdDirect(emailConfigId);
+            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');
+            emailConfig = config;
+        } else {
+            const defaultConfig = await this.emailProviderConfigService.getDefaultConfig(user);
+            if (!defaultConfig) throw new NotFoundException('No default email configuration found');
+            emailConfig = defaultConfig;
+        }
+        const providerConfig = {
+            provider: emailConfig.provider,
+            config: emailConfig.config
+        };
+        const provider = await this.emailFactory.createProvider(providerConfig);
+        return {
+            provider,
+            config: emailConfig
+        };
+    }
+    /**
+   * Interpolate template variables in content.
+   * Variable names must be valid identifiers (start with letter/underscore).
+   *
+   * @param content - The content with {{variable}} placeholders
+   * @param variables - The variables to interpolate
+   * @param isHtmlContent - Whether to HTML-escape values (prevents XSS)
+   */ interpolateVariables(content, variables, isHtmlContent = false) {
+        if (!variables || Object.keys(variables).length === 0) return content;
+        // Escape HTML entities in variables when inserting into HTML content
+        const safeVariables = isHtmlContent ? escapeHtmlVariables(variables) : variables;
+        // Valid identifier: starts with letter or underscore, followed by word chars
+        const VALID_VARIABLE_PATTERN = /\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g;
+        return content.replace(VALID_VARIABLE_PATTERN, (match, varName)=>{
+            if (varName in safeVariables && safeVariables[varName] !== undefined) {
+                return String(safeVariables[varName]);
+            }
+            return match;
+        });
+    }
+    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;
+    }
+    async sendTemplateEmail(dto, user) {
+        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');
+        validateCompanyOwnership(template, user, this.emailConfigService.isCompanyFeatureEnabled(), 'Email template');
+        // Subject is plain text, no HTML escaping needed
+        const subject = this.interpolateVariables(template.subject, dto.variables || {}, false);
+        let html;
+        let text;
+        if (template.isHtml) {
+            // HTML content - escape variables to prevent XSS
+            html = this.interpolateVariables(template.htmlContent, dto.variables || {}, true);
+            // Text content is plain text, no escaping needed
+            text = template.textContent ? this.interpolateVariables(template.textContent, dto.variables || {}, false) : undefined;
+        } else {
+            // Plain text template - no HTML escaping
+            text = template.textContent ? this.interpolateVariables(template.textContent, dto.variables || {}, false) : this.interpolateVariables(template.htmlContent, dto.variables || {}, false);
+            html = undefined;
+        }
+        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;
+    }
+    async sendTestEmail(emailConfigId, recipient, user) {
+        const { provider, config } = await this.getEmailProviderWithConfig(emailConfigId, user);
+        // Escape config values to prevent XSS in test emails
+        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> ${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>
+      `,
+            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);

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

@@ -0,0 +1,148 @@
+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 { applyCompanyFilter, buildCompanyWhereCondition } from '@flusys/nestjs-shared/utils';
+import { Inject, Injectable, Scope } from '@nestjs/common';
+import { EmailConfigService } from '../config';
+import { EmailTemplate, EmailTemplateWithCompany } from '../entities';
+import { EmailDataSourceProvider } from './email-datasource.provider';
+export class EmailTemplateService extends RequestScopedApiService {
+    resolveEntity() {
+        return this.emailConfig.isCompanyFeatureEnabled() ? EmailTemplateWithCompany : EmailTemplate;
+    }
+    getDataSourceProvider() {
+        return this.dataSourceProvider;
+    }
+    async convertSingleDtoToEntity(dto, user) {
+        const updateDto = dto;
+        if (updateDto.id) {
+            await this.ensureRepositoryInitialized();
+            const existing = await this.repository.findOne({
+                where: {
+                    id: updateDto.id
+                }
+            });
+            if (existing && dto.schema && JSON.stringify(dto.schema) !== JSON.stringify(existing.schema)) {
+                dto.schemaVersion = existing.schemaVersion + 1;
+                this.logger.log(`Schema version incremented to ${dto.schemaVersion} for template ${updateDto.id}`);
+            }
+        }
+        const entity = {
+            ...dto
+        };
+        if (this.emailConfig.isCompanyFeatureEnabled()) {
+            entity.companyId = user?.companyId ?? null;
+        }
+        return entity;
+    }
+    async getSelectQuery(query, _user, select) {
+        if (!select?.length) {
+            select = [
+                'id',
+                'name',
+                'slug',
+                'description',
+                'subject',
+                'schema',
+                'htmlContent',
+                'textContent',
+                'schemaVersion',
+                'isActive',
+                'isHtml',
+                'metadata',
+                'createdAt',
+                'updatedAt'
+            ];
+            if (this.emailConfig.isCompanyFeatureEnabled()) select.push('companyId');
+        }
+        query.select(select.map((field)=>`${this.entityName}.${field}`));
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async getExtraManipulateQuery(query, filterDto, user) {
+        const result = await super.getExtraManipulateQuery(query, filterDto, user);
+        applyCompanyFilter(query, {
+            isCompanyFeatureEnabled: this.emailConfig.isCompanyFeatureEnabled(),
+            entityAlias: 'emailTemplate'
+        }, user);
+        query.orderBy(`${this.entityName}.createdAt`, 'DESC');
+        return result;
+    }
+    async findByIdDirect(id) {
+        await this.ensureRepositoryInitialized();
+        return this.repository.findOne({
+            where: {
+                id
+            }
+        });
+    }
+    async findBySlug(slug, user) {
+        await this.ensureRepositoryInitialized();
+        const where = buildCompanyWhereCondition({
+            slug,
+            isActive: true
+        }, this.emailConfig.isCompanyFeatureEnabled(), user);
+        return this.repository.findOne({
+            where
+        });
+    }
+    async getActiveTemplates(user) {
+        await this.ensureRepositoryInitialized();
+        const where = buildCompanyWhereCondition({
+            isActive: true
+        }, this.emailConfig.isCompanyFeatureEnabled(), user);
+        return this.repository.find({
+            where,
+            order: {
+                name: 'ASC'
+            }
+        });
+    }
+    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;
+    }
+}
+EmailTemplateService = _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
+    ])
+], EmailTemplateService);

package/fesm/services/index.js

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

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

@@ -0,0 +1,111 @@
+export function getOtpEmailFormat(otp, userName) {
+    return `
+  <!DOCTYPE html>
+  <html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+    <title>Your OTP Code</title>
+    <style>
+      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;
+      }
+      .otp-box {
+        display: inline-block;
+        margin: 20px 0;
+        padding: 14px 28px;
+        font-size: 24px;
+        letter-spacing: 6px;
+        background-color: #007BFF;
+        color: white;
+        border-radius: 8px;
+        font-weight: bold;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="email-container">
+      <p>Hi ${userName || 'Sir/Madam'},</p>
+      <p>Use the code below to verify your identity:</p>
+      <div class="otp-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>
+    </div>
+  </body>
+  </html>
+`;
+}
+export function getResetPasswordEmailFormat(resetLink, userName) {
+    return `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+  <title>Reset Your Password</title>
+  <style>
+    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;
+    }
+    .reset-button {
+      display: inline-block;
+      margin: 20px 0;
+      padding: 14px 28px;
+      font-size: 16px;
+      background-color: #007BFF;
+      color: #ffffff !important;
+      text-decoration: none;
+      border-radius: 6px;
+      font-weight: bold;
+    }
+  </style>
+</head>
+<body>
+  <div class="email-container">
+    <p>Hi ${userName || 'Sir/Madam'},</p>
+    <p>We received a request to reset your password. Click the button below to reset it:</p>
+    <a href="${resetLink}" class="reset-button" target="_blank">Reset Password</a>
+    <p>If you didn't request a password reset, you can safely ignore this email.</p>
+  </div>
+</body>
+</html>
+`;
+}

package/fesm/utils/index.js

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

package/index.d.ts

@@ -0,0 +1,10 @@
+export * from './controllers';
+export * from './services';
+export * from './entities';
+export * from './modules';
+export * from './config';
+export * from './dtos';
+export * from './enums';
+export * from './interfaces';
+export * from './providers';
+export * from './utils';

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

@@ -0,0 +1,34 @@
+import { IIdentity } from '@flusys/nestjs-shared/interfaces';
+import { EmailProviderTypeEnum } from '../enums';
+export interface IEmailConfig extends IIdentity {
+    name: string;
+    provider: EmailProviderTypeEnum;
+    config: Record<string, any>;
+    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;
+    secure?: boolean;
+    auth?: {
+        user: string;
+        pass: string;
+    };
+    tls?: ISmtpTlsConfig;
+}
+export interface ISendGridConfig {
+    apiKey: string;
+}
+export interface IMailgunConfig {
+    apiKey: string;
+    domain: string;
+    region?: 'us' | 'eu';
+}

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

@@ -0,0 +1,25 @@
+import { IBootstrapAppConfig, IDataSourceServiceOptions, IDynamicModuleConfig, IModuleOptionsFactory } from '@flusys/nestjs-core';
+import { ModuleMetadata, Type } from '@nestjs/common';
+export interface IEmailModuleConfig extends IDataSourceServiceOptions {
+    defaultProvider?: string;
+    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;
+}
+export interface EmailModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'>, IDynamicModuleConfig {
+    bootstrapAppConfig: IBootstrapAppConfig;
+    useFactory?: (...args: any[]) => Promise<IEmailModuleConfig> | IEmailModuleConfig;
+    inject?: any[];
+    useClass?: Type<EmailOptionsFactory>;
+    useExisting?: Type<EmailOptionsFactory>;
+}