@flusys/nestjs-email 7.0.2 → 8.0.0-beta.1

package/fesm/493.js

@@ -0,0 +1,1723 @@
+import { Identity } from "@flusys/nestjs-shared/entities";
+import { createHash } from "crypto";
+import { SYSTEM_MESSAGES } from "@flusys/nestjs-shared/constants";
+import * as __rspack_external__flusys_nestjs_shared_393d2cae from "@flusys/nestjs-shared";
+import * as __rspack_external__flusys_nestjs_shared_classes_6076a329 from "@flusys/nestjs-shared/classes";
+import * as __rspack_external__flusys_nestjs_shared_modules_24702bee from "@flusys/nestjs-shared/modules";
+import * as __rspack_external__flusys_nestjs_shared_utils_9125c1f1 from "@flusys/nestjs-shared/utils";
+import * as __rspack_external__nestjs_common_a04939da from "@nestjs/common";
+import * as __rspack_external_typeorm from "typeorm";
+import * as __rspack_external__nestjs_core_d7b00a1a from "@nestjs/core";
+export const __rspack_esm_id = 493;
+export const __rspack_esm_ids = [493];
+export const __webpack_modules__ = {
+966(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/**
+ * Email Module Constants
+ */ const EMAIL_MODULE_OPTIONS = 'EMAIL_MODULE_OPTIONS';
+const DEFAULT_FROM_NAME = 'FLUSYS';
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  F: EMAIL_MODULE_OPTIONS
+});
+
+
+},
+399(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/**
+ * Domain event actions published by the email module, alongside the CRUD
+ * lifecycle actions every ApiService emits.
+ */ const EMAIL_EVENT_ACTIONS = {
+    SENT: 'sent',
+    FAILED: 'failed'
+};
+/** Every entity the email module publishes under, ApiService backed or not */ const EMAIL_EVENT_ENTITIES = {
+    MESSAGE: 'email_message',
+    CONFIG: 'emailConfig',
+    TEMPLATE: 'emailTemplate'
+};
+const EMAIL_EVENT_MODULE = 'email';
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  C: EMAIL_EVENT_ACTIONS,
+  y: EMAIL_EVENT_ENTITIES
+});
+
+
+},
+887(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+// ==================== EMAIL MODULE MESSAGE KEYS ====================
+const EMAIL_TEMPLATE_MESSAGES = {
+    GET_SUCCESS: 'email.template.get.success',
+    NOT_FOUND: 'email.template.not.found'
+};
+const EMAIL_CONFIG_MESSAGES = {
+    DEFAULT_DELETE_FORBIDDEN: 'email.config.default.delete.forbidden'
+};
+const EMAIL_SEND_MESSAGES = {
+    SUCCESS: 'email.send.success',
+    FAILED: 'email.send.failed',
+    CONFIG_NOT_FOUND: 'email.send.config.not.found',
+    CONFIG_INACTIVE: 'email.send.config.inactive',
+    CONFIG_DEFAULT_NOT_FOUND: 'email.send.config.default.not.found',
+    TEMPLATE_NOT_FOUND: 'email.send.template.not.found',
+    TEMPLATE_INACTIVE: 'email.send.template.inactive',
+    TEMPLATE_ID_OR_SLUG_REQUIRED: 'email.send.template.id.or.slug.required'
+};
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  T6: EMAIL_CONFIG_MESSAGES,
+  dP: EMAIL_SEND_MESSAGES,
+  xP: EMAIL_TEMPLATE_MESSAGES
+});
+
+
+},
+454(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  BC: () => (/* binding */ EmailCompanyEntities),
+  pG: () => (/* reexport */ EmailConfig),
+  Y5: () => (/* reexport */ EmailConfig),
+  Ed: () => (/* reexport */ EmailConfigWithCompany),
+  BZ: () => (/* binding */ EmailCoreEntities),
+  Fy: () => (/* reexport */ EmailTemplate),
+  An: () => (/* reexport */ EmailTemplate),
+  U7: () => (/* reexport */ EmailTemplateWithCompany),
+  B0: () => (/* binding */ getEmailEntitiesByConfig)
+});
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared"
+var nestjs_shared_ = __webpack_require__(422);
+;// CONCATENATED MODULE: external "@flusys/nestjs-shared/entities"
+
+// EXTERNAL MODULE: external "typeorm"
+var external_typeorm_ = __webpack_require__(158);
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/entities/email-config.entity.ts
+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(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+
+class EmailConfig extends Identity {
+    name;
+    provider;
+    config;
+    fromEmail;
+    fromName;
+    isActive;
+    isDefault;
+}
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 255,
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], EmailConfig.prototype, "name", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 50,
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], EmailConfig.prototype, "provider", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: (0,nestjs_shared_.getJsonColumnType)(),
+        nullable: false
+    }),
+    _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], EmailConfig.prototype, "config", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 255,
+        nullable: true,
+        name: 'from_email'
+    }),
+    _ts_metadata("design:type", Object)
+], EmailConfig.prototype, "fromEmail", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 255,
+        nullable: true,
+        name: 'from_name'
+    }),
+    _ts_metadata("design:type", Object)
+], EmailConfig.prototype, "fromName", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'boolean',
+        default: true,
+        name: 'is_active'
+    }),
+    _ts_metadata("design:type", Boolean)
+], EmailConfig.prototype, "isActive", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'boolean',
+        default: false,
+        name: 'is_default'
+    }),
+    _ts_metadata("design:type", Boolean)
+], EmailConfig.prototype, "isDefault", void 0);
+EmailConfig = _ts_decorate([
+    (0,external_typeorm_.Entity)({
+        name: 'email_config'
+    }),
+    (0,external_typeorm_.Index)([
+        'name'
+    ]),
+    (0,external_typeorm_.Index)([
+        'provider'
+    ]),
+    (0,external_typeorm_.Index)([
+        'isActive'
+    ]),
+    (0,external_typeorm_.Index)([
+        'isDefault'
+    ])
+], EmailConfig);
+
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/entities/email-template.entity.ts
+function email_template_entity_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 email_template_entity_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+
+class EmailTemplate extends Identity {
+    name;
+    slug;
+    description;
+    subject;
+    schema;
+    htmlContent;
+    textContent;
+    schemaVersion;
+    isActive;
+    isHtml;
+}
+email_template_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 255,
+        nullable: false
+    }),
+    email_template_entity_ts_metadata("design:type", String)
+], EmailTemplate.prototype, "name", void 0);
+email_template_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 255,
+        nullable: false
+    }),
+    email_template_entity_ts_metadata("design:type", String)
+], EmailTemplate.prototype, "slug", void 0);
+email_template_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 500,
+        nullable: true
+    }),
+    email_template_entity_ts_metadata("design:type", Object)
+], EmailTemplate.prototype, "description", void 0);
+email_template_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 500,
+        nullable: false
+    }),
+    email_template_entity_ts_metadata("design:type", String)
+], EmailTemplate.prototype, "subject", void 0);
+email_template_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: (0,nestjs_shared_.getJsonColumnType)(),
+        nullable: false
+    }),
+    email_template_entity_ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], EmailTemplate.prototype, "schema", void 0);
+email_template_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'text',
+        nullable: false,
+        name: 'html_content'
+    }),
+    email_template_entity_ts_metadata("design:type", String)
+], EmailTemplate.prototype, "htmlContent", void 0);
+email_template_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'text',
+        nullable: true,
+        name: 'text_content'
+    }),
+    email_template_entity_ts_metadata("design:type", Object)
+], EmailTemplate.prototype, "textContent", void 0);
+email_template_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'int',
+        nullable: false,
+        default: 1,
+        name: 'schema_version'
+    }),
+    email_template_entity_ts_metadata("design:type", Number)
+], EmailTemplate.prototype, "schemaVersion", void 0);
+email_template_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'boolean',
+        default: true,
+        name: 'is_active'
+    }),
+    email_template_entity_ts_metadata("design:type", Boolean)
+], EmailTemplate.prototype, "isActive", void 0);
+email_template_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'boolean',
+        default: true,
+        name: 'is_html'
+    }),
+    email_template_entity_ts_metadata("design:type", Boolean)
+], EmailTemplate.prototype, "isHtml", void 0);
+EmailTemplate = email_template_entity_ts_decorate([
+    (0,external_typeorm_.Entity)({
+        name: 'email_template'
+    }),
+    (0,external_typeorm_.Index)([
+        'name'
+    ]),
+    (0,external_typeorm_.Index)([
+        'slug'
+    ], {
+        unique: true
+    }),
+    (0,external_typeorm_.Index)([
+        'isActive'
+    ])
+], EmailTemplate);
+
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/entities/email-config-with-company.entity.ts
+function email_config_with_company_entity_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 email_config_with_company_entity_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+class EmailConfigWithCompany extends EmailConfig {
+    companyId;
+}
+email_config_with_company_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'uuid',
+        nullable: true,
+        name: 'company_id'
+    }),
+    email_config_with_company_entity_ts_metadata("design:type", Object)
+], EmailConfigWithCompany.prototype, "companyId", void 0);
+EmailConfigWithCompany = email_config_with_company_entity_ts_decorate([
+    (0,external_typeorm_.Entity)({
+        name: 'email_config'
+    }),
+    (0,external_typeorm_.Index)([
+        'companyId'
+    ]),
+    (0,external_typeorm_.Index)([
+        'companyId',
+        'name'
+    ]),
+    (0,external_typeorm_.Index)([
+        'companyId',
+        'isActive'
+    ])
+], EmailConfigWithCompany);
+
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/entities/email-template-with-company.entity.ts
+function email_template_with_company_entity_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 email_template_with_company_entity_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+class EmailTemplateWithCompany extends EmailTemplate {
+    companyId;
+}
+email_template_with_company_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'uuid',
+        nullable: true,
+        name: 'company_id'
+    }),
+    email_template_with_company_entity_ts_metadata("design:type", Object)
+], EmailTemplateWithCompany.prototype, "companyId", void 0);
+EmailTemplateWithCompany = email_template_with_company_entity_ts_decorate([
+    (0,external_typeorm_.Entity)({
+        name: 'email_template'
+    }),
+    (0,external_typeorm_.Index)([
+        'companyId'
+    ]),
+    (0,external_typeorm_.Index)([
+        'companyId',
+        'slug'
+    ], {
+        unique: true
+    }),
+    (0,external_typeorm_.Index)([
+        'companyId',
+        'isActive'
+    ])
+], EmailTemplateWithCompany);
+
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/entities/index.ts
+// Entities without company feature
+
+
+// Entities with company feature
+
+
+
+
+
+
+// Core entities (no company feature)
+const EmailCoreEntities = [
+    EmailConfig,
+    EmailTemplate
+];
+// Company-specific entities
+const EmailCompanyEntities = [
+    EmailConfigWithCompany,
+    EmailTemplateWithCompany
+];
+function getEmailEntitiesByConfig(enableCompanyFeature) {
+    return enableCompanyFeature ? EmailCompanyEntities : EmailCoreEntities;
+}
+// Base type aliases for backwards compatibility with services
+
+
+
+
+},
+603(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  c: () => (/* reexport */ EmailFactoryService),
+  xC: () => (/* reexport */ EmailProviderRegistry),
+  Xp: () => (/* reexport */ MailgunProvider),
+  Iw: () => (/* reexport */ SendGridProvider),
+  Kg: () => (/* reexport */ SmtpProvider)
+});
+
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/providers/email-provider.registry.ts
+class EmailProviderRegistry {
+    static providers = new Map();
+    static register(providerName, providerClass) {
+        this.providers.set(providerName.toLowerCase(), providerClass);
+    }
+    static get(providerName) {
+        return this.providers.get(providerName.toLowerCase());
+    }
+    static has(providerName) {
+        return this.providers.has(providerName.toLowerCase());
+    }
+    static getAll() {
+        return Array.from(this.providers.keys());
+    }
+    static clear() {
+        this.providers.clear();
+    }
+}
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared"
+var nestjs_shared_ = __webpack_require__(422);
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+;// CONCATENATED MODULE: external "crypto"
+
+// EXTERNAL MODULE: ./projects/nestjs-email/src/config/message-keys.ts
+var message_keys = __webpack_require__(887);
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/providers/email-factory.service.ts
+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(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+
+
+
+class EmailFactoryService {
+    providerCache = new Map();
+    // ─── Public API ─────────────────────────────────────────────────────────────
+    async createProvider(config) {
+        const cacheKey = this.generateCacheKey(config);
+        const cached = this.providerCache.get(cacheKey);
+        if (cached) return cached;
+        const ProviderClass = EmailProviderRegistry.get(config.provider);
+        if (!ProviderClass) {
+            throw new common_.NotFoundException({
+                message: `Email provider '${config.provider}' is not registered`,
+                messageKey: message_keys/* .EMAIL_SEND_MESSAGES.CONFIG_NOT_FOUND */.dP.CONFIG_NOT_FOUND,
+                messageVariables: {
+                    provider: config.provider,
+                    available: EmailProviderRegistry.getAll().join(', ')
+                }
+            });
+        }
+        try {
+            const instance = new ProviderClass();
+            await instance.initialize?.(config.config);
+            this.providerCache.set(cacheKey, instance);
+            return instance;
+        } catch (error) {
+            throw new common_.InternalServerErrorException({
+                message: `Email provider '${config.provider}' not initialized successfully: ${this.extractErrorMessage(error)}`,
+                messageKey: nestjs_shared_.SYSTEM_MESSAGES.SERVICE_NOT_AVAILABLE,
+                messageVariables: {
+                    provider: config.provider,
+                    available: EmailProviderRegistry.getAll().join(', ')
+                }
+            });
+        }
+    }
+    // ─── Lifecycle ──────────────────────────────────────────────────────────────
+    async onModuleDestroy() {
+        const closePromises = Array.from(this.providerCache.entries()).map(([, provider])=>this.closeProvider(provider));
+        await Promise.allSettled(closePromises);
+        this.providerCache.clear();
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    generateCacheKey(config) {
+        const sortedKeys = Object.keys(config.config || {}).sort();
+        const configString = JSON.stringify(config.config, sortedKeys);
+        const hash = createHash('sha256').update(configString).digest('hex').substring(0, 16);
+        return `${config.provider}-${hash}`;
+    }
+    async closeProvider(provider) {
+        if (!provider.close) return;
+        try {
+            await provider.close();
+        } catch  {
+        // Silent failure
+        }
+    }
+    extractErrorMessage(error) {
+        return error instanceof Error ? error.message : 'Unknown error';
+    }
+}
+_ts_decorate([
+    (0,nestjs_shared_.LogAction)({
+        action: 'email.createProvider',
+        module: 'email'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof IEmailProviderConfig === "undefined" ? Object : IEmailProviderConfig
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EmailFactoryService.prototype, "createProvider", null);
+EmailFactoryService = _ts_decorate([
+    (0,common_.Injectable)()
+], EmailFactoryService);
+
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/providers/smtp-provider.ts
+const VERIFY_TIMEOUT_MS = 10_000;
+const SEND_TIMEOUT_MS = 30_000;
+class SmtpProvider {
+    transporter = null;
+    async initialize(config) {
+        const nodemailer = await __webpack_require__.e(/* import() */ 99).then(__webpack_require__.bind(__webpack_require__, 982));
+        this.transporter = nodemailer.createTransport({
+            host: config.host,
+            port: config.port,
+            secure: config.secure ?? config.port === 465,
+            auth: config.auth,
+            connectionTimeout: VERIFY_TIMEOUT_MS,
+            greetingTimeout: VERIFY_TIMEOUT_MS,
+            socketTimeout: SEND_TIMEOUT_MS,
+            tls: {
+                rejectUnauthorized: config.tls?.rejectUnauthorized ?? true,
+                minVersion: config.tls?.minVersion ?? 'TLSv1.2'
+            }
+        });
+        await this.withTimeout(this.transporter.verify(), VERIFY_TIMEOUT_MS, 'SMTP verification timeout');
+    }
+    async sendEmail(options) {
+        if (!this.transporter) return {
+            success: false,
+            error: 'SMTP provider not initialized'
+        };
+        try {
+            const mailOptions = {
+                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,
+                replyTo: options.replyTo,
+                attachments: options.attachments?.map((a)=>({
+                        filename: a.filename,
+                        content: a.content,
+                        contentType: a.contentType,
+                        encoding: a.encoding
+                    }))
+            };
+            const info = await this.withTimeout(this.transporter.sendMail(mailOptions), SEND_TIMEOUT_MS, 'SMTP send timeout');
+            return {
+                success: true,
+                messageId: info.messageId
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: this.extractError(error)
+            };
+        }
+    }
+    async sendBulkEmails(options) {
+        return Promise.all(options.map((opt)=>this.sendEmail(opt)));
+    }
+    async healthCheck() {
+        if (!this.transporter) return false;
+        try {
+            await this.transporter.verify();
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    async close() {
+        if (this.transporter) {
+            this.transporter.close();
+            this.transporter = null;
+        }
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    formatFrom(from, fromName) {
+        return fromName ? `"${fromName}" <${from}>` : from;
+    }
+    joinAddresses(addresses) {
+        return Array.isArray(addresses) ? addresses.join(', ') : addresses;
+    }
+    async withTimeout(promise, ms, message) {
+        let timer;
+        const timeout = new Promise((_, reject)=>{
+            timer = setTimeout(()=>reject(new Error(message)), ms);
+        });
+        try {
+            return await Promise.race([
+                promise,
+                timeout
+            ]);
+        } finally{
+            clearTimeout(timer);
+        }
+    }
+    extractError(error) {
+        return error instanceof Error ? error.message : 'Unknown error';
+    }
+}
+
+;// CONCATENATED MODULE: external "@flusys/nestjs-shared/constants"
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/utils"
+var utils_ = __webpack_require__(216);
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/providers/sendgrid-provider.ts
+
+
+
+class SendGridProvider {
+    sgMail = null;
+    apiKey = null;
+    async initialize(config) {
+        this.apiKey = config.apiKey;
+        try {
+            // Optional peer dependency - loaded at runtime so bundlers don't statically resolve it
+            const sgMailModule = await (0,utils_.loadOptionalModule)('@sendgrid/mail');
+            this.sgMail = sgMailModule.default || sgMailModule;
+            this.sgMail.setApiKey(config.apiKey);
+        } catch  {
+            throw new common_.InternalServerErrorException({
+                message: 'SendGrid initialization failed. Install: npm install @sendgrid/mail',
+                messageKey: SYSTEM_MESSAGES.SDK_NOT_INSTALLED,
+                messageVariables: {
+                    sdk: 'sendgrid'
+                }
+            });
+        }
+    }
+    async sendEmail(options) {
+        if (!this.sgMail) return {
+            success: false,
+            error: 'SendGrid provider not initialized'
+        };
+        try {
+            const msg = this.buildMessage(options, true);
+            const [response] = await this.sgMail.send(msg);
+            const messageId = response.headers['x-message-id'] || response.headers['X-Message-Id'];
+            return {
+                success: true,
+                messageId
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: this.extractError(error)
+            };
+        }
+    }
+    async sendBulkEmails(options) {
+        if (!this.sgMail) return options.map(()=>({
+                success: false,
+                error: 'SendGrid provider not initialized'
+            }));
+        try {
+            const messages = options.map((opt)=>this.buildMessage(opt, false));
+            await this.sgMail.send(messages);
+            return options.map(()=>({
+                    success: true
+                }));
+        } catch (error) {
+            const errorMessage = this.extractError(error);
+            return options.map(()=>({
+                    success: false,
+                    error: errorMessage
+                }));
+        }
+    }
+    async healthCheck() {
+        return !!(this.sgMail && this.apiKey?.startsWith('SG.'));
+    }
+    async close() {
+        this.sgMail = null;
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    buildMessage(options, includeExtras) {
+        const msg = {
+            to: this.toArray(options.to),
+            from: options.fromName ? {
+                email: options.from,
+                name: options.fromName
+            } : options.from,
+            subject: options.subject
+        };
+        if (options.html) msg.html = options.html;
+        if (options.text) msg.text = options.text;
+        if (includeExtras) {
+            if (options.cc) msg.cc = this.toArray(options.cc);
+            if (options.bcc) msg.bcc = this.toArray(options.bcc);
+            if (options.replyTo) msg.replyTo = options.replyTo;
+            if (options.attachments?.length) {
+                msg.attachments = options.attachments.map((a)=>({
+                        filename: a.filename,
+                        content: typeof a.content === 'string' ? a.content : a.content.toString('base64'),
+                        type: a.contentType,
+                        disposition: 'attachment'
+                    }));
+            }
+        }
+        return msg;
+    }
+    toArray(value) {
+        return Array.isArray(value) ? value : [
+            value
+        ];
+    }
+    extractError(error) {
+        const sgError = error;
+        return sgError.response?.body?.errors?.[0]?.message || sgError.message || 'Unknown error';
+    }
+}
+
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/providers/mailgun-provider.ts
+
+
+
+const MAILGUN_API_URL = 'https://api.mailgun.net';
+const MAILGUN_EU_API_URL = 'https://api.eu.mailgun.net';
+class MailgunProvider {
+    client = null;
+    domain = null;
+    async initialize(config) {
+        this.domain = config.domain;
+        try {
+            // Optional peer dependency - loaded at runtime so bundlers don't statically resolve it
+            const mailgunModule = await (0,utils_.loadOptionalModule)('mailgun.js');
+            const formDataModule = await (0,utils_.loadOptionalModule)('form-data');
+            const Mailgun = mailgunModule.default || mailgunModule;
+            const FormData = formDataModule.default || formDataModule;
+            const mailgun = new Mailgun(FormData);
+            const url = config.region === 'eu' ? MAILGUN_EU_API_URL : MAILGUN_API_URL;
+            this.client = mailgun.client({
+                username: 'api',
+                key: config.apiKey,
+                url
+            });
+        } catch  {
+            throw new common_.InternalServerErrorException({
+                message: 'Mailgun initialization failed. Install: npm install mailgun.js form-data',
+                messageKey: SYSTEM_MESSAGES.SDK_NOT_INSTALLED,
+                messageVariables: {
+                    sdk: 'mailgun'
+                }
+            });
+        }
+    }
+    async sendEmail(options) {
+        if (!this.client || !this.domain) {
+            return {
+                success: false,
+                error: 'Mailgun provider not initialized'
+            };
+        }
+        try {
+            const messageData = this.buildMessageData(options);
+            const result = await this.client.messages.create(this.domain, messageData);
+            return {
+                success: true,
+                messageId: result.id
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: this.extractError(error)
+            };
+        }
+    }
+    async sendBulkEmails(options) {
+        return Promise.all(options.map((opt)=>this.sendEmail(opt)));
+    }
+    async healthCheck() {
+        if (!this.client || !this.domain) return false;
+        try {
+            await this.client.domains.get(this.domain);
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    async close() {
+        this.client = null;
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    buildMessageData(options) {
+        const data = {
+            from: options.fromName ? `${options.fromName} <${options.from}>` : options.from,
+            to: this.joinAddresses(options.to),
+            subject: options.subject
+        };
+        if (options.html) data.html = options.html;
+        if (options.text) data.text = options.text;
+        if (options.cc) data.cc = this.joinAddresses(options.cc);
+        if (options.bcc) data.bcc = this.joinAddresses(options.bcc);
+        if (options.replyTo) data['h:Reply-To'] = options.replyTo;
+        if (options.attachments?.length) {
+            data.attachment = options.attachments.map((a)=>({
+                    filename: a.filename,
+                    data: typeof a.content === 'string' ? Buffer.from(a.content, 'base64') : a.content,
+                    contentType: a.contentType
+                }));
+        }
+        return data;
+    }
+    joinAddresses(addresses) {
+        return Array.isArray(addresses) ? addresses.join(', ') : addresses;
+    }
+    extractError(error) {
+        return error instanceof Error ? error.message : 'Unknown error';
+    }
+}
+
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/providers/index.ts
+
+
+
+
+
+
+
+},
+676(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  mi: () => (/* reexport */ EmailConfigService),
+  Zt: () => (/* reexport */ EmailDataSourceProvider),
+  jG: () => (/* reexport */ EmailProviderConfigService),
+  yu: () => (/* reexport */ EmailSendService),
+  uS: () => (/* reexport */ EmailTemplateService)
+});
+
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+// EXTERNAL MODULE: ./projects/nestjs-email/src/config/email.constants.ts
+var email_constants = __webpack_require__(966);
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/services/email-config.service.ts
+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(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+class EmailConfigService {
+    options;
+    constructor(options){
+        this.options = options;
+    }
+    // ─── IModuleConfigService Implementation ────────────────────────────────────
+    isCompanyFeatureEnabled() {
+        return this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
+    }
+    getDatabaseMode() {
+        return this.options.bootstrapAppConfig?.databaseMode ?? 'single';
+    }
+    isMultiTenant() {
+        return this.getDatabaseMode() === 'multi-tenant';
+    }
+    // ─── Config Getters ─────────────────────────────────────────────────────────
+    getDefaultFromName() {
+        return (/* inlined export .DEFAULT_FROM_NAME */"FLUSYS");
+    }
+    getOptions() {
+        return this.options;
+    }
+}
+EmailConfigService = _ts_decorate([
+    (0,common_.Injectable)(),
+    _ts_param(0, (0,common_.Inject)(email_constants/* .EMAIL_MODULE_OPTIONS */.F)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof EmailModuleOptions === "undefined" ? Object : EmailModuleOptions
+    ])
+], EmailConfigService);
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/modules"
+var modules_ = __webpack_require__(236);
+;// CONCATENATED MODULE: external "@nestjs/core"
+
+// EXTERNAL MODULE: ./projects/nestjs-email/src/entities/index.ts + 5 modules
+var src_entities = __webpack_require__(454);
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/services/email-datasource.provider.ts
+function email_datasource_provider_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 email_datasource_provider_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function email_datasource_provider_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+class EmailDataSourceProvider extends modules_.MultiTenantDataSourceService {
+    configService;
+    static tenantConnections = new Map();
+    static singleDataSource = null;
+    static tenantsRegistry = new Map();
+    static initialized = false;
+    static connectionLocks = new Map();
+    static singleConnectionLock = null;
+    constructor(configService, request){
+        super(EmailDataSourceProvider.buildParentOptions(configService.getOptions()), request), this.configService = configService;
+    }
+    static buildParentOptions(options) {
+        return {
+            bootstrapAppConfig: options.bootstrapAppConfig,
+            defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
+            tenantDefaultDatabaseConfig: options.config?.tenantDefaultDatabaseConfig,
+            tenants: options.config?.tenants
+        };
+    }
+    getEnableCompanyFeatureForTenant(tenant) {
+        return tenant?.enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
+    }
+    async createDataSourceFromConfig(config) {
+        const currentTenant = this.getCurrentTenant();
+        const enableCompanyFeature = this.getEnableCompanyFeatureForTenant(currentTenant ?? undefined);
+        const entities = (0,src_entities/* .getEmailEntitiesByConfig */.B0)(enableCompanyFeature);
+        return super.createDataSourceFromConfig(config, entities);
+    }
+}
+EmailDataSourceProvider = email_datasource_provider_ts_decorate([
+    (0,common_.Injectable)({
+        scope: common_.Scope.REQUEST
+    }),
+    email_datasource_provider_ts_param(0, (0,common_.Inject)(EmailConfigService)),
+    email_datasource_provider_ts_param(1, (0,common_.Optional)()),
+    email_datasource_provider_ts_param(1, (0,common_.Inject)(__rspack_external__nestjs_core_d7b00a1a.REQUEST)),
+    email_datasource_provider_ts_metadata("design:type", Function),
+    email_datasource_provider_ts_metadata("design:paramtypes", [
+        typeof EmailConfigService === "undefined" ? Object : EmailConfigService,
+        typeof Request === "undefined" ? Object : Request
+    ])
+], EmailDataSourceProvider);
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/classes"
+var classes_ = __webpack_require__(937);
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/utils"
+var utils_ = __webpack_require__(216);
+// EXTERNAL MODULE: external "typeorm"
+var external_typeorm_ = __webpack_require__(158);
+// EXTERNAL MODULE: ./projects/nestjs-email/src/config/event-actions.ts
+var event_actions = __webpack_require__(399);
+// EXTERNAL MODULE: ./projects/nestjs-email/src/config/message-keys.ts
+var message_keys = __webpack_require__(887);
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/services/email-provider-config.service.ts
+function email_provider_config_service_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 email_provider_config_service_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function email_provider_config_service_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+
+
+class EmailProviderConfigService extends classes_.ApiService {
+    cacheManager;
+    utilsService;
+    emailConfig;
+    constructor(cacheManager, utilsService, emailConfig, dataSourceProvider){
+        super(event_actions/* .EMAIL_EVENT_ENTITIES.CONFIG */.y.CONFIG, cacheManager, utilsService, EmailProviderConfigService.name, true, (/* inlined export .EMAIL_EVENT_MODULE */"email"), dataSourceProvider, emailConfig.isCompanyFeatureEnabled() ? src_entities/* .EmailConfigWithCompany */.Ed : src_entities/* .EmailConfig */.pG), this.cacheManager = cacheManager, this.utilsService = utilsService, this.emailConfig = emailConfig;
+    }
+    async beforeDeleteOperation(dto, _user, _queryRunner) {
+        const ids = Array.isArray(dto.id) ? dto.id : [
+            dto.id
+        ];
+        await this.ensureDataSourceRepository();
+        const defaultConfigs = await this.repository.find({
+            where: {
+                id: (0,external_typeorm_.In)(ids),
+                isDefault: true,
+                deletedAt: (0,external_typeorm_.IsNull)()
+            }
+        });
+        if (defaultConfigs.length > 0) {
+            const names = defaultConfigs.map((c)=>c.name).join(', ');
+            throw new common_.ForbiddenException({
+                message: `Cannot delete the default email config(s): ${names}. Set another config as default first.`,
+                messageKey: message_keys/* .EMAIL_CONFIG_MESSAGES.DEFAULT_DELETE_FORBIDDEN */.T6.DEFAULT_DELETE_FORBIDDEN,
+                messageVariables: {
+                    names
+                }
+            });
+        }
+    }
+    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);
+        (0,utils_.applyCompanyFilter)(query, {
+            isCompanyFeatureEnabled: this.emailConfig.isCompanyFeatureEnabled(),
+            entityAlias: 'emailConfig'
+        }, user);
+        query.orderBy(`${this.entityName}.createdAt`, 'DESC');
+        return result;
+    }
+    async findByIdDirect(id) {
+        await this.ensureDataSourceRepository();
+        return this.repository.findOne({
+            where: {
+                id
+            }
+        });
+    }
+    async getDefaultConfig(user) {
+        await this.ensureDataSourceRepository();
+        const baseWhere = (0,utils_.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'
+            }
+        });
+    }
+}
+EmailProviderConfigService = email_provider_config_service_ts_decorate([
+    (0,common_.Injectable)({
+        scope: common_.Scope.REQUEST
+    }),
+    email_provider_config_service_ts_param(0, (0,common_.Inject)('CACHE_INSTANCE')),
+    email_provider_config_service_ts_param(1, (0,common_.Inject)(modules_.UtilsService)),
+    email_provider_config_service_ts_param(2, (0,common_.Inject)(EmailConfigService)),
+    email_provider_config_service_ts_param(3, (0,common_.Inject)(EmailDataSourceProvider)),
+    email_provider_config_service_ts_metadata("design:type", Function),
+    email_provider_config_service_ts_metadata("design:paramtypes", [
+        typeof classes_.HybridCache === "undefined" ? Object : classes_.HybridCache,
+        typeof modules_.UtilsService === "undefined" ? Object : modules_.UtilsService,
+        typeof EmailConfigService === "undefined" ? Object : EmailConfigService,
+        typeof EmailDataSourceProvider === "undefined" ? Object : EmailDataSourceProvider
+    ])
+], EmailProviderConfigService);
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared"
+var nestjs_shared_ = __webpack_require__(422);
+// EXTERNAL MODULE: ./projects/nestjs-email/src/dtos/index.ts + 6 modules
+var dtos = __webpack_require__(684);
+// EXTERNAL MODULE: ./projects/nestjs-email/src/providers/index.ts + 7 modules
+var providers = __webpack_require__(603);
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/services/email-template.service.ts
+function email_template_service_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 email_template_service_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function email_template_service_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+
+const DEFAULT_SELECT_FIELDS = [
+    'id',
+    'name',
+    'slug',
+    'description',
+    'subject',
+    'schema',
+    'htmlContent',
+    'textContent',
+    'schemaVersion',
+    'isActive',
+    'isHtml',
+    'createdAt',
+    'updatedAt'
+];
+class EmailTemplateService extends classes_.ApiService {
+    cacheManager;
+    utilsService;
+    emailConfig;
+    constructor(cacheManager, utilsService, emailConfig, dataSourceProvider){
+        super(event_actions/* .EMAIL_EVENT_ENTITIES.TEMPLATE */.y.TEMPLATE, cacheManager, utilsService, EmailTemplateService.name, true, (/* inlined export .EMAIL_EVENT_MODULE */"email"), dataSourceProvider, emailConfig.isCompanyFeatureEnabled() ? src_entities/* .EmailTemplateWithCompany */.U7 : src_entities/* .EmailTemplate */.Fy), this.cacheManager = cacheManager, this.utilsService = utilsService, this.emailConfig = emailConfig;
+    }
+    async convertSingleDtoToEntity(dto, user) {
+        const entity = await super.convertSingleDtoToEntity(dto, user);
+        await this.incrementSchemaVersionIfChanged(dto, entity);
+        if (this.emailConfig.isCompanyFeatureEnabled()) {
+            entity.companyId = user?.companyId ?? null;
+        }
+        return entity;
+    }
+    async getSelectQuery(query, _user, select) {
+        if (!select?.length) {
+            select = [
+                ...DEFAULT_SELECT_FIELDS
+            ];
+            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);
+        (0,utils_.applyCompanyFilter)(query, {
+            isCompanyFeatureEnabled: this.emailConfig.isCompanyFeatureEnabled(),
+            entityAlias: 'emailTemplate'
+        }, user);
+        query.orderBy(`${this.entityName}.createdAt`, 'DESC');
+        return result;
+    }
+    // ─── Public Query Methods ───────────────────────────────────────────────────
+    async findByIdDirect(id) {
+        await this.ensureDataSourceRepository();
+        return this.repository.findOne({
+            where: {
+                id
+            }
+        });
+    }
+    async findBySlug(slug, user) {
+        await this.ensureDataSourceRepository();
+        const where = (0,utils_.buildCompanyWhereCondition)({
+            slug,
+            isActive: true
+        }, this.emailConfig.isCompanyFeatureEnabled(), user);
+        return this.repository.findOne({
+            where
+        });
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    async incrementSchemaVersionIfChanged(dto, entity) {
+        const updateDto = dto;
+        if (!updateDto.id || !dto.schema) return;
+        await this.ensureDataSourceRepository();
+        const existing = await this.repository.findOne({
+            where: {
+                id: updateDto.id
+            }
+        });
+        if (existing && JSON.stringify(dto.schema) !== JSON.stringify(existing.schema)) {
+            entity.schemaVersion = existing.schemaVersion + 1;
+        }
+    }
+}
+EmailTemplateService = email_template_service_ts_decorate([
+    (0,common_.Injectable)({
+        scope: common_.Scope.REQUEST
+    }),
+    email_template_service_ts_param(0, (0,common_.Inject)('CACHE_INSTANCE')),
+    email_template_service_ts_param(1, (0,common_.Inject)(modules_.UtilsService)),
+    email_template_service_ts_param(2, (0,common_.Inject)(EmailConfigService)),
+    email_template_service_ts_param(3, (0,common_.Inject)(EmailDataSourceProvider)),
+    email_template_service_ts_metadata("design:type", Function),
+    email_template_service_ts_metadata("design:paramtypes", [
+        typeof classes_.HybridCache === "undefined" ? Object : classes_.HybridCache,
+        typeof modules_.UtilsService === "undefined" ? Object : modules_.UtilsService,
+        typeof EmailConfigService === "undefined" ? Object : EmailConfigService,
+        typeof EmailDataSourceProvider === "undefined" ? Object : EmailDataSourceProvider
+    ])
+], EmailTemplateService);
+
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/services/email-send.service.ts
+function email_send_service_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 email_send_service_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function email_send_service_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+
+
+
+/** Valid identifier pattern for template variables: {{varName}} */ const VARIABLE_PATTERN = /\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g;
+class EmailSendService {
+    emailFactory;
+    emailConfigService;
+    emailProviderConfigService;
+    emailTemplateService;
+    constructor(emailFactory, emailConfigService, emailProviderConfigService, emailTemplateService){
+        this.emailFactory = emailFactory;
+        this.emailConfigService = emailConfigService;
+        this.emailProviderConfigService = emailProviderConfigService;
+        this.emailTemplateService = emailTemplateService;
+    }
+    // ─── Public API ─────────────────────────────────────────────────────────────
+    async sendEmail(dto, user) {
+        const { provider, config } = await this.getEmailProviderWithConfig(dto.emailConfigId, user);
+        const sender = this.resolveSender(dto, config);
+        const result = await provider.sendEmail({
+            to: dto.to,
+            cc: dto.cc,
+            bcc: dto.bcc,
+            subject: dto.subject,
+            html: dto.html,
+            text: dto.text,
+            ...sender,
+            replyTo: dto.replyTo,
+            attachments: this.buildAttachments(dto.attachments)
+        });
+        await this.publishSendEvent(result, dto.to, user, {
+            emailConfigId: config.id
+        });
+        return result;
+    }
+    async sendTemplateEmail(dto, user) {
+        const template = await this.resolveTemplate(dto, user);
+        const { subject, html, text } = this.buildTemplateContent(template, dto.variables);
+        const { provider, config } = await this.getEmailProviderWithConfig(dto.emailConfigId, user);
+        const sender = this.resolveSender(dto, config);
+        const result = await provider.sendEmail({
+            to: dto.to,
+            cc: dto.cc,
+            bcc: dto.bcc,
+            subject,
+            html,
+            text,
+            ...sender,
+            replyTo: dto.replyTo,
+            attachments: this.buildAttachments(dto.attachments)
+        });
+        await this.publishSendEvent(result, dto.to, user, {
+            emailConfigId: config.id,
+            templateId: template.id,
+            templateSlug: template.slug
+        });
+        return result;
+    }
+    async sendTestEmail(emailConfigId, recipient, user) {
+        const { provider, config } = await this.getEmailProviderWithConfig(emailConfigId, user);
+        const safeConfig = (0,utils_.escapeHtmlVariables)({
+            name: config.name,
+            provider: config.provider.toUpperCase()
+        });
+        const result = await provider.sendEmail({
+            to: recipient,
+            subject: 'Test Email from FLUSYS',
+            html: this.buildTestEmailHtml(safeConfig),
+            text: `Test Email from FLUSYS\n\nThis is a test email.\nConfiguration: ${config.name}\nProvider: ${config.provider.toUpperCase()}`,
+            from: config.fromEmail || undefined,
+            fromName: config.fromName || this.emailConfigService.getDefaultFromName()
+        });
+        await this.publishSendEvent(result, recipient, user, {
+            emailConfigId: config.id,
+            isTest: true
+        });
+        return result;
+    }
+    // ─── Private: Provider & Config Resolution ──────────────────────────────────
+    async getEmailProviderWithConfig(emailConfigId, user) {
+        const emailConfig = emailConfigId ? await this.resolveConfigById(emailConfigId, user) : await this.resolveDefaultConfig(user);
+        const providerConfig = {
+            provider: emailConfig.provider,
+            config: emailConfig.config
+        };
+        return {
+            provider: await this.emailFactory.createProvider(providerConfig),
+            config: emailConfig
+        };
+    }
+    async resolveConfigById(id, user) {
+        const config = await this.emailProviderConfigService.findByIdDirect(id);
+        if (!config) {
+            throw new common_.NotFoundException({
+                message: 'Email configuration not found',
+                messageKey: message_keys/* .EMAIL_SEND_MESSAGES.CONFIG_NOT_FOUND */.dP.CONFIG_NOT_FOUND
+            });
+        }
+        (0,utils_.validateCompanyOwnership)(config, user, this.emailConfigService.isCompanyFeatureEnabled(), 'Email configuration');
+        if (!config.isActive) {
+            throw new common_.BadRequestException({
+                message: 'Email configuration is inactive',
+                messageKey: message_keys/* .EMAIL_SEND_MESSAGES.CONFIG_INACTIVE */.dP.CONFIG_INACTIVE
+            });
+        }
+        return config;
+    }
+    async resolveDefaultConfig(user) {
+        const config = await this.emailProviderConfigService.getDefaultConfig(user);
+        if (!config) {
+            throw new common_.NotFoundException({
+                message: 'No default email configuration found',
+                messageKey: message_keys/* .EMAIL_SEND_MESSAGES.CONFIG_DEFAULT_NOT_FOUND */.dP.CONFIG_DEFAULT_NOT_FOUND
+            });
+        }
+        return config;
+    }
+    // ─── Private: Template Resolution ───────────────────────────────────────────
+    async resolveTemplate(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 common_.BadRequestException({
+                message: 'templateId or templateSlug is required',
+                messageKey: message_keys/* .EMAIL_SEND_MESSAGES.TEMPLATE_ID_OR_SLUG_REQUIRED */.dP.TEMPLATE_ID_OR_SLUG_REQUIRED
+            });
+        }
+        if (!template) {
+            throw new common_.NotFoundException({
+                message: 'Email template not found',
+                messageKey: message_keys/* .EMAIL_SEND_MESSAGES.TEMPLATE_NOT_FOUND */.dP.TEMPLATE_NOT_FOUND
+            });
+        }
+        if (!template.isActive) {
+            throw new common_.BadRequestException({
+                message: 'Email template is inactive',
+                messageKey: message_keys/* .EMAIL_SEND_MESSAGES.TEMPLATE_INACTIVE */.dP.TEMPLATE_INACTIVE
+            });
+        }
+        (0,utils_.validateCompanyOwnership)(template, user, this.emailConfigService.isCompanyFeatureEnabled(), 'Email template');
+        return template;
+    }
+    buildTemplateContent(template, variables) {
+        const vars = variables || {};
+        const subject = this.interpolateVariables(template.subject, vars, false);
+        if (template.isHtml) {
+            return {
+                subject,
+                html: this.interpolateVariables(template.htmlContent, vars, true),
+                text: template.textContent ? this.interpolateVariables(template.textContent, vars, false) : undefined
+            };
+        }
+        return {
+            subject,
+            html: undefined,
+            text: template.textContent ? this.interpolateVariables(template.textContent, vars, false) : this.interpolateVariables(template.htmlContent, vars, false)
+        };
+    }
+    // ─── Private: Helpers ───────────────────────────────────────────────────────
+    resolveSender(dto, config) {
+        return {
+            from: dto.from || config.fromEmail || undefined,
+            fromName: dto.fromName || config.fromName || this.emailConfigService.getDefaultFromName()
+        };
+    }
+    buildAttachments(attachments) {
+        return attachments?.map((a)=>({
+                filename: a.filename,
+                content: Buffer.from(a.content, 'base64'),
+                contentType: a.contentType
+            }));
+    }
+    interpolateVariables(content, variables, escapeHtml) {
+        if (!variables || Object.keys(variables).length === 0) return content;
+        const safeVars = escapeHtml ? (0,utils_.escapeHtmlVariables)(variables) : variables;
+        return content.replace(VARIABLE_PATTERN, (match, varName)=>{
+            return varName in safeVars && safeVars[varName] !== undefined ? String(safeVars[varName]) : match;
+        });
+    }
+    buildTestEmailHtml(safeConfig) {
+        return `
+      <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
+        <h1 style="color: #333;">Test Email</h1>
+        <p>This is a test email from FLUSYS Email Service.</p>
+        <p><strong>Configuration:</strong> ${safeConfig.name}</p>
+        <p><strong>Provider:</strong> ${safeConfig.provider}</p>
+        <p style="color: #666; font-size: 12px;">
+          If you received this email, your email configuration is working correctly.
+        </p>
+      </div>
+    `;
+    }
+    async publishSendEvent(result, to, user, metadata) {
+        const recipients = Array.isArray(to) ? to : [
+            to
+        ];
+        await (0,classes_.publishDomainEvent)({
+            module: (/* inlined export .EMAIL_EVENT_MODULE */"email"),
+            entity: event_actions/* .EMAIL_EVENT_ENTITIES.MESSAGE */.y.MESSAGE,
+            action: result.success ? event_actions/* .EMAIL_EVENT_ACTIONS.SENT */.C.SENT : event_actions/* .EMAIL_EVENT_ACTIONS.FAILED */.C.FAILED,
+            ids: result.messageId ? [
+                result.messageId
+            ] : [],
+            metadata: {
+                ...metadata,
+                recipientCount: recipients.length,
+                ...result.error ? {
+                    error: result.error
+                } : {}
+            },
+            user: user ?? null
+        });
+    }
+}
+email_send_service_ts_decorate([
+    (0,nestjs_shared_.LogAction)({
+        action: 'email.send',
+        module: 'email'
+    }),
+    email_send_service_ts_metadata("design:type", Function),
+    email_send_service_ts_metadata("design:paramtypes", [
+        typeof dtos/* .SendEmailDto */.m5 === "undefined" ? Object : dtos/* .SendEmailDto */.m5,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    email_send_service_ts_metadata("design:returntype", Promise)
+], EmailSendService.prototype, "sendEmail", null);
+email_send_service_ts_decorate([
+    (0,nestjs_shared_.LogAction)({
+        action: 'email.sendTemplate',
+        module: 'email'
+    }),
+    email_send_service_ts_metadata("design:type", Function),
+    email_send_service_ts_metadata("design:paramtypes", [
+        typeof dtos/* .SendTemplateEmailDto */.iu === "undefined" ? Object : dtos/* .SendTemplateEmailDto */.iu,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    email_send_service_ts_metadata("design:returntype", Promise)
+], EmailSendService.prototype, "sendTemplateEmail", null);
+email_send_service_ts_decorate([
+    (0,nestjs_shared_.LogAction)({
+        action: 'email.sendTest',
+        module: 'email'
+    }),
+    email_send_service_ts_metadata("design:type", Function),
+    email_send_service_ts_metadata("design:paramtypes", [
+        String,
+        String,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    email_send_service_ts_metadata("design:returntype", Promise)
+], EmailSendService.prototype, "sendTestEmail", null);
+EmailSendService = email_send_service_ts_decorate([
+    (0,common_.Injectable)({
+        scope: common_.Scope.REQUEST
+    }),
+    email_send_service_ts_param(0, (0,common_.Inject)(providers/* .EmailFactoryService */.c)),
+    email_send_service_ts_param(1, (0,common_.Inject)(EmailConfigService)),
+    email_send_service_ts_param(2, (0,common_.Inject)(EmailProviderConfigService)),
+    email_send_service_ts_param(3, (0,common_.Inject)(EmailTemplateService)),
+    email_send_service_ts_metadata("design:type", Function),
+    email_send_service_ts_metadata("design:paramtypes", [
+        typeof providers/* .EmailFactoryService */.c === "undefined" ? Object : providers/* .EmailFactoryService */.c,
+        typeof EmailConfigService === "undefined" ? Object : EmailConfigService,
+        typeof EmailProviderConfigService === "undefined" ? Object : EmailProviderConfigService,
+        typeof EmailTemplateService === "undefined" ? Object : EmailTemplateService
+    ])
+], EmailSendService);
+
+;// CONCATENATED MODULE: ./projects/nestjs-email/src/services/index.ts
+
+
+
+
+
+
+
+},
+422(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_393d2cae;
+
+
+},
+937(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_classes_6076a329;
+
+
+},
+236(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_modules_24702bee;
+
+
+},
+216(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_utils_9125c1f1;
+
+
+},
+157(module) {
+
+module.exports = __rspack_external__nestjs_common_a04939da;
+
+
+},
+158(module) {
+
+module.exports = __rspack_external_typeorm;
+
+
+},
+
+};