@flusys/nestjs-email 1.1.0-beta

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

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EmailProviderConfigService", {
+    enumerable: true,
+    get: function() {
+        return EmailProviderConfigService;
+    }
+});
+const _classes = require("@flusys/nestjs-shared/classes");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _common = require("@nestjs/common");
+const _config = require("../config");
+const _entities = require("../entities");
+const _emaildatasourceprovider = require("./email-datasource.provider");
+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);
+    };
+}
+let EmailProviderConfigService = class EmailProviderConfigService extends _classes.RequestScopedApiService {
+    /**
+   * Resolve entity class for this service
+   */ resolveEntity() {
+        const enableCompanyFeature = this.emailConfig.isCompanyFeatureEnabled();
+        return enableCompanyFeature ? _entities.EmailConfigWithCompany : _entities.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([
+    (0, _common.Injectable)({
+        scope: _common.Scope.REQUEST
+    }),
+    _ts_param(0, (0, _common.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0, _common.Inject)(_modules.UtilsService)),
+    _ts_param(2, (0, _common.Inject)(_config.EmailConfigService)),
+    _ts_param(3, (0, _common.Inject)(_emaildatasourceprovider.EmailDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _classes.HybridCache === "undefined" ? Object : _classes.HybridCache,
+        typeof _modules.UtilsService === "undefined" ? Object : _modules.UtilsService,
+        typeof _config.EmailConfigService === "undefined" ? Object : _config.EmailConfigService,
+        typeof _emaildatasourceprovider.EmailDataSourceProvider === "undefined" ? Object : _emaildatasourceprovider.EmailDataSourceProvider
+    ])
+], EmailProviderConfigService);

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

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EmailSendService", {
+    enumerable: true,
+    get: function() {
+        return EmailSendService;
+    }
+});
+const _common = require("@nestjs/common");
+const _config = require("../config");
+const _providers = require("../providers");
+const _emailproviderconfigservice = require("./email-provider-config.service");
+const _emailtemplateservice = require("./email-template.service");
+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);
+    };
+}
+let EmailSendService = 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 _common.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 _common.BadRequestException('Email configuration belongs to another company');
+                }
+            }
+            if (!config.isActive) {
+                throw new _common.BadRequestException('Email configuration is inactive');
+            }
+            emailConfig = config;
+        } else {
+            const defaultConfig = await this.emailProviderConfigService.getDefaultConfig(user);
+            if (!defaultConfig) {
+                throw new _common.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 _common.BadRequestException('templateId or templateSlug is required');
+        }
+        if (!template) {
+            throw new _common.NotFoundException('Email template not found');
+        }
+        if (!template.isActive) {
+            throw new _common.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 _common.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 _common.Logger(EmailSendService.name);
+    }
+};
+EmailSendService = _ts_decorate([
+    (0, _common.Injectable)({
+        scope: _common.Scope.REQUEST
+    }),
+    _ts_param(0, (0, _common.Inject)(_providers.EmailFactoryService)),
+    _ts_param(1, (0, _common.Inject)(_config.EmailConfigService)),
+    _ts_param(2, (0, _common.Inject)(_emailproviderconfigservice.EmailProviderConfigService)),
+    _ts_param(3, (0, _common.Inject)(_emailtemplateservice.EmailTemplateService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _providers.EmailFactoryService === "undefined" ? Object : _providers.EmailFactoryService,
+        typeof _config.EmailConfigService === "undefined" ? Object : _config.EmailConfigService,
+        typeof _emailproviderconfigservice.EmailProviderConfigService === "undefined" ? Object : _emailproviderconfigservice.EmailProviderConfigService,
+        typeof _emailtemplateservice.EmailTemplateService === "undefined" ? Object : _emailtemplateservice.EmailTemplateService
+    ])
+], EmailSendService);

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

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EmailTemplateService", {
+    enumerable: true,
+    get: function() {
+        return EmailTemplateService;
+    }
+});
+const _classes = require("@flusys/nestjs-shared/classes");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _common = require("@nestjs/common");
+const _config = require("../config");
+const _entities = require("../entities");
+const _emaildatasourceprovider = require("./email-datasource.provider");
+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);
+    };
+}
+let EmailTemplateService = class EmailTemplateService extends _classes.RequestScopedApiService {
+    /**
+   * Resolve entity class for this service
+   */ resolveEntity() {
+        const enableCompanyFeature = this.emailConfig.isCompanyFeatureEnabled();
+        return enableCompanyFeature ? _entities.EmailTemplateWithCompany : _entities.EmailTemplate;
+    }
+    /**
+   * Get DataSource provider for this service
+   */ 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
+        if (this.emailConfig.isCompanyFeatureEnabled()) {
+            templateEntity.companyId = user?.companyId ?? null;
+        }
+        return templateEntity;
+    }
+    async getSelectQuery(query, _user, select) {
+        if (!select || !select.length) {
+            select = [
+                'id',
+                'name',
+                'slug',
+                'description',
+                'subject',
+                'schema',
+                'htmlContent',
+                'textContent',
+                'schemaVersion',
+                'isActive',
+                'isHtml',
+                'metadata',
+                '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('emailTemplate.companyId = :companyId', {
+                companyId: user.companyId
+            });
+        }
+        query.orderBy(`${this.entityName}.createdAt`, 'DESC');
+        return result;
+    }
+    /**
+   * Find template by ID directly (bypasses company filtering)
+   */ async findByIdDirect(id) {
+        await this.ensureRepositoryInitialized();
+        return await this.repository.findOne({
+            where: {
+                id
+            }
+        });
+    }
+    /**
+   * Find template by slug (scoped to user's company if enabled)
+   */ async findBySlug(slug, user) {
+        await this.ensureRepositoryInitialized();
+        const where = {
+            slug,
+            isActive: true
+        };
+        if (this.emailConfig.isCompanyFeatureEnabled() && user?.companyId) {
+            where.companyId = user.companyId;
+        }
+        return await this.repository.findOne({
+            where
+        });
+    }
+    /**
+   * Get all active templates (scoped to user's company if enabled)
+   */ async getActiveTemplates(user) {
+        await this.ensureRepositoryInitialized();
+        const where = {
+            isActive: true
+        };
+        if (this.emailConfig.isCompanyFeatureEnabled() && user?.companyId) {
+            where.companyId = user.companyId;
+        }
+        return await 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([
+    (0, _common.Injectable)({
+        scope: _common.Scope.REQUEST
+    }),
+    _ts_param(0, (0, _common.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0, _common.Inject)(_modules.UtilsService)),
+    _ts_param(2, (0, _common.Inject)(_config.EmailConfigService)),
+    _ts_param(3, (0, _common.Inject)(_emaildatasourceprovider.EmailDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _classes.HybridCache === "undefined" ? Object : _classes.HybridCache,
+        typeof _modules.UtilsService === "undefined" ? Object : _modules.UtilsService,
+        typeof _config.EmailConfigService === "undefined" ? Object : _config.EmailConfigService,
+        typeof _emaildatasourceprovider.EmailDataSourceProvider === "undefined" ? Object : _emaildatasourceprovider.EmailDataSourceProvider
+    ])
+], EmailTemplateService);

package/cjs/services/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./email-datasource.provider"), exports);
+_export_star(require("./email-provider-config.service"), exports);
+_export_star(require("./email-template.service"), exports);
+_export_star(require("./email-send.service"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/config/email-config.service.d.ts

@@ -0,0 +1,13 @@
+import { EmailModuleOptions } from '../interfaces';
+export declare class EmailConfigService {
+    private readonly options;
+    constructor(options: EmailModuleOptions);
+    isCompanyFeatureEnabled(): boolean;
+    getDatabaseMode(): 'single' | 'multi-tenant';
+    getRateLimitPerMinute(): number;
+    isLoggingEnabled(): boolean;
+    getDefaultProvider(): string | undefined;
+    getDefaultFromName(): string;
+    getDefaultDatabaseConfig(): import("@flusys/nestjs-core").IDatabaseConfig;
+    getOptions(): EmailModuleOptions;
+}

package/config/email.constants.d.ts

@@ -0,0 +1,11 @@
+export declare const EMAIL_MODULE_OPTIONS = "EMAIL_MODULE_OPTIONS";
+export declare const EMAIL_CONFIG_SERVICE = "EMAIL_CONFIG_SERVICE";
+export declare const EMAIL_DATA_SOURCE_PROVIDER = "EMAIL_DATA_SOURCE_PROVIDER";
+export declare const DEFAULT_FROM_NAME = "FLUSYS";
+export declare const EMAIL_VALIDATION_MESSAGES: {
+    readonly INVALID_RECIPIENT: "Invalid email recipient";
+    readonly TEMPLATE_NOT_FOUND: "Email template not found";
+    readonly CONFIG_NOT_FOUND: "Email configuration not found";
+    readonly PROVIDER_NOT_AVAILABLE: "Email provider not available";
+    readonly SEND_FAILED: "Failed to send email";
+};

package/config/index.d.ts

@@ -0,0 +1,2 @@
+export * from './email.constants';
+export * from './email-config.service';

package/controllers/email-config.controller.d.ts

@@ -0,0 +1,17 @@
+import { CreateEmailConfigDto, EmailConfigResponseDto, UpdateEmailConfigDto } from '../dtos';
+import { EmailProviderConfigService } from '../services';
+declare const EmailConfigController_base: abstract new (service: EmailProviderConfigService) => {
+    service: EmailProviderConfigService;
+    insert(addDto: CreateEmailConfigDto, user: import("@flusys/nestjs-shared/interfaces").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").SingleResponseDto<EmailConfigResponseDto>>;
+    insertMany(addDto: CreateEmailConfigDto[], user: import("@flusys/nestjs-shared/interfaces").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").BulkResponseDto<EmailConfigResponseDto>>;
+    getById(id: string, body: import("@flusys/nestjs-shared/dtos").GetByIdBodyDto, user: import("@flusys/nestjs-shared/interfaces").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").SingleResponseDto<EmailConfigResponseDto>>;
+    update(updateDto: UpdateEmailConfigDto, user: import("@flusys/nestjs-shared/interfaces").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").SingleResponseDto<EmailConfigResponseDto>>;
+    updateMany(updateDtos: UpdateEmailConfigDto[], user: import("@flusys/nestjs-shared/interfaces").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").BulkResponseDto<EmailConfigResponseDto>>;
+    getAll(filterAndPaginationDto: import("@flusys/nestjs-shared/dtos").FilterAndPaginationDto, user: import("@flusys/nestjs-shared/interfaces").ILoggedUserInfo | null, search?: string): Promise<import("@flusys/nestjs-shared/dtos").ListResponseDto<EmailConfigResponseDto>>;
+    delete(deleteDto: import("@flusys/nestjs-shared/dtos").DeleteDto, user: import("@flusys/nestjs-shared/interfaces").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").MessageResponseDto>;
+};
+export declare class EmailConfigController extends EmailConfigController_base {
+    emailConfigService: EmailProviderConfigService;
+    constructor(emailConfigService: EmailProviderConfigService);
+}
+export {};