@nest-omni/core 4.1.3-3 → 4.1.3-31

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

@@ -0,0 +1,61 @@
+/**
+ * Email logging transport configuration options
+ * Follows libs/core pattern from CacheModuleOptions
+ */
+export declare class EmailLogOptions {
+    /**
+     * Enable email log transport
+     * @default false
+     */
+    enabled: boolean;
+    /**
+     * Minimum log level to trigger email
+     * Uses Pino log levels: 'trace', 'debug', 'info', 'warn', 'error', 'fatal'
+     * @default 'error'
+     */
+    level: string;
+    /**
+     * Recipient email addresses
+     */
+    to: string[];
+    /**
+     * CC recipient email addresses (optional)
+     */
+    cc?: string[];
+    /**
+     * Sender email address
+     */
+    from: string;
+    /**
+     * Email subject prefix
+     * Final subject: "[prefix] appName - log level"
+     * @default '[Log Alert]'
+     */
+    subjectPrefix?: string;
+    /**
+     * SMTP configuration
+     */
+    smtpHost: string;
+    smtpPort?: number;
+    smtpUsername?: string;
+    smtpPassword?: string;
+    smtpSecure?: boolean;
+    smtpIgnoreTLSError?: boolean;
+    /**
+     * Rate limiting configuration
+     */
+    rateLimitMaxEmails?: number;
+    rateLimitWindowMs?: number;
+    rateLimitBurstSize?: number;
+    /**
+     * Email formatting options
+     */
+    useHtmlFormat?: boolean;
+    /**
+     * Filtering options
+     */
+    includeApps?: string[];
+    excludeApps?: string[];
+    includeErrors?: string[];
+    excludeErrors?: string[];
+}

package/email-log/interfaces/email-log-options.interface.js

@@ -0,0 +1,134 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailLogOptions = void 0;
+const decorators_1 = require("../../decorators");
+/**
+ * Email logging transport configuration options
+ * Follows libs/core pattern from CacheModuleOptions
+ */
+class EmailLogOptions {
+}
+exports.EmailLogOptions = EmailLogOptions;
+__decorate([
+    (0, decorators_1.StringField)({ fieldLabel: { zh: '启用邮件日志', en: 'Enable Email Log' } }),
+    __metadata("design:type", Boolean)
+], EmailLogOptions.prototype, "enabled", void 0);
+__decorate([
+    (0, decorators_1.StringField)({ fieldLabel: { zh: '日志级别', en: 'Log Level' } }),
+    __metadata("design:type", String)
+], EmailLogOptions.prototype, "level", void 0);
+__decorate([
+    (0, decorators_1.EmailField)({ each: true, fieldLabel: { zh: '收件人', en: 'Recipients' } }),
+    __metadata("design:type", Array)
+], EmailLogOptions.prototype, "to", void 0);
+__decorate([
+    (0, decorators_1.EmailFieldOptional)({
+        each: true,
+        fieldLabel: { zh: '抄送', en: 'CC Recipients' },
+    }),
+    __metadata("design:type", Array)
+], EmailLogOptions.prototype, "cc", void 0);
+__decorate([
+    (0, decorators_1.EmailField)({ fieldLabel: { zh: '发件人', en: 'Sender Email' } }),
+    __metadata("design:type", String)
+], EmailLogOptions.prototype, "from", void 0);
+__decorate([
+    (0, decorators_1.StringFieldOptional)({
+        fieldLabel: { zh: '邮件主题前缀', en: 'Subject Prefix' },
+    }),
+    __metadata("design:type", String)
+], EmailLogOptions.prototype, "subjectPrefix", void 0);
+__decorate([
+    (0, decorators_1.StringField)({ fieldLabel: { zh: 'SMTP主机', en: 'SMTP Host' } }),
+    __metadata("design:type", String)
+], EmailLogOptions.prototype, "smtpHost", void 0);
+__decorate([
+    (0, decorators_1.NumberFieldOptional)({ fieldLabel: { zh: 'SMTP端口', en: 'SMTP Port' } }),
+    __metadata("design:type", Number)
+], EmailLogOptions.prototype, "smtpPort", void 0);
+__decorate([
+    (0, decorators_1.StringFieldOptional)({
+        fieldLabel: { zh: 'SMTP用户名', en: 'SMTP Username' },
+    }),
+    __metadata("design:type", String)
+], EmailLogOptions.prototype, "smtpUsername", void 0);
+__decorate([
+    (0, decorators_1.StringFieldOptional)({
+        fieldLabel: { zh: 'SMTP密码', en: 'SMTP Password' },
+        sensitive: true,
+    }),
+    __metadata("design:type", String)
+], EmailLogOptions.prototype, "smtpPassword", void 0);
+__decorate([
+    (0, decorators_1.BooleanFieldOptional)({
+        fieldLabel: { zh: 'SSL/TLS加密', en: 'SMTP Secure' },
+    }),
+    __metadata("design:type", Boolean)
+], EmailLogOptions.prototype, "smtpSecure", void 0);
+__decorate([
+    (0, decorators_1.BooleanFieldOptional)({
+        fieldLabel: { zh: '忽略TLS错误', en: 'Ignore TLS Error' },
+    }),
+    __metadata("design:type", Boolean)
+], EmailLogOptions.prototype, "smtpIgnoreTLSError", void 0);
+__decorate([
+    (0, decorators_1.NumberFieldOptional)({
+        fieldLabel: { zh: '速率限制最大邮件数', en: 'Rate Limit Max Emails' },
+    }),
+    __metadata("design:type", Number)
+], EmailLogOptions.prototype, "rateLimitMaxEmails", void 0);
+__decorate([
+    (0, decorators_1.NumberFieldOptional)({
+        fieldLabel: { zh: '速率限制时间窗口(毫秒)', en: 'Rate Limit Window MS' },
+    }),
+    __metadata("design:type", Number)
+], EmailLogOptions.prototype, "rateLimitWindowMs", void 0);
+__decorate([
+    (0, decorators_1.NumberFieldOptional)({
+        fieldLabel: { zh: '突发大小', en: 'Rate Limit Burst Size' },
+    }),
+    __metadata("design:type", Number)
+], EmailLogOptions.prototype, "rateLimitBurstSize", void 0);
+__decorate([
+    (0, decorators_1.BooleanFieldOptional)({
+        fieldLabel: { zh: 'HTML格式', en: 'Use HTML Format' },
+    }),
+    __metadata("design:type", Boolean)
+], EmailLogOptions.prototype, "useHtmlFormat", void 0);
+__decorate([
+    (0, decorators_1.StringFieldOptional)({
+        each: true,
+        fieldLabel: { zh: '包含应用', en: 'Include Apps' },
+    }),
+    __metadata("design:type", Array)
+], EmailLogOptions.prototype, "includeApps", void 0);
+__decorate([
+    (0, decorators_1.StringFieldOptional)({
+        each: true,
+        fieldLabel: { zh: '排除应用', en: 'Exclude Apps' },
+    }),
+    __metadata("design:type", Array)
+], EmailLogOptions.prototype, "excludeApps", void 0);
+__decorate([
+    (0, decorators_1.StringFieldOptional)({
+        each: true,
+        fieldLabel: { zh: '包含错误类型', en: 'Include Errors' },
+    }),
+    __metadata("design:type", Array)
+], EmailLogOptions.prototype, "includeErrors", void 0);
+__decorate([
+    (0, decorators_1.StringFieldOptional)({
+        each: true,
+        fieldLabel: { zh: '排除错误类型', en: 'Exclude Errors' },
+    }),
+    __metadata("design:type", Array)
+], EmailLogOptions.prototype, "excludeErrors", void 0);

package/email-log/interfaces/email-log-transport.interface.d.ts

@@ -0,0 +1,20 @@
+import { LogDescriptor } from 'pino';
+/**
+ * Email log transport contract
+ * Defines the interface for Pino email transport
+ */
+export interface IEmailLogTransport {
+    /**
+     * Write log entry to email transport
+     * Implements Writable stream interface for Pino
+     */
+    write(data: LogDescriptor): void;
+    /**
+     * Flush any pending emails
+     */
+    flush?(): Promise<void>;
+    /**
+     * Check if transport is enabled for given log level
+     */
+    shouldSend(level: string): boolean;
+}

package/email-log/interfaces/email-log-transport.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/email-log/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from './email-log-options.interface';
+export * from './email-log-transport.interface';

package/email-log/interfaces/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./email-log-options.interface"), exports);
+__exportStar(require("./email-log-transport.interface"), exports);

package/email-log/providers/email-provider.d.ts

@@ -0,0 +1,42 @@
+interface EmailLogProviderOptions {
+    smtpHost: string;
+    smtpPort?: number;
+    smtpUsername?: string;
+    smtpPassword?: string;
+    smtpSecure?: boolean;
+    smtpIgnoreTLSError?: boolean;
+}
+/**
+ * Email provider for log alerts
+ * Wraps nodemailer for SMTP email sending
+ */
+export declare class EmailLogProvider {
+    private readonly options;
+    private readonly logger;
+    private transporter;
+    constructor(options: EmailLogProviderOptions);
+    /**
+     * Initialize nodemailer transporter
+     */
+    private initializeTransporter;
+    /**
+     * Verify SMTP connection (useful for health checks)
+     */
+    verifyConnection(): Promise<boolean>;
+    /**
+     * Send log email
+     */
+    sendLogEmail(params: {
+        to: string[];
+        cc?: string[];
+        from: string;
+        subject: string;
+        html?: string;
+        text?: string;
+    }): Promise<void>;
+    /**
+     * Close the transporter connection
+     */
+    close(): Promise<void>;
+}
+export {};

package/email-log/providers/email-provider.js

@@ -0,0 +1,127 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var EmailLogProvider_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailLogProvider = void 0;
+const common_1 = require("@nestjs/common");
+const nodemailer = require("nodemailer");
+/**
+ * Email provider for log alerts
+ * Wraps nodemailer for SMTP email sending
+ */
+let EmailLogProvider = EmailLogProvider_1 = class EmailLogProvider {
+    constructor(options) {
+        this.options = options;
+        this.logger = new common_1.Logger(EmailLogProvider_1.name);
+        this.transporter = null;
+        this.initializeTransporter();
+    }
+    /**
+     * Initialize nodemailer transporter
+     */
+    initializeTransporter() {
+        const config = {
+            host: this.options.smtpHost,
+            port: this.options.smtpPort || 587,
+            secure: this.options.smtpSecure || false,
+            tls: {
+                rejectUnauthorized: this.options.smtpIgnoreTLSError !== undefined
+                    ? !this.options.smtpIgnoreTLSError
+                    : true,
+            },
+        };
+        if (this.options.smtpUsername || this.options.smtpPassword) {
+            config.auth = {
+                user: this.options.smtpUsername,
+                pass: this.options.smtpPassword,
+            };
+        }
+        this.transporter = nodemailer.createTransport(config);
+        this.logger.log(`Email transporter initialized: ${this.options.smtpHost}:${this.options.smtpPort || 587}`);
+    }
+    /**
+     * Verify SMTP connection (useful for health checks)
+     */
+    verifyConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.transporter) {
+                return false;
+            }
+            try {
+                yield this.transporter.verify();
+                this.logger.debug('SMTP connection verified successfully');
+                return true;
+            }
+            catch (error) {
+                this.logger.error(`SMTP connection verification failed: ${error.message}`);
+                return false;
+            }
+        });
+    }
+    /**
+     * Send log email
+     */
+    sendLogEmail(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.transporter) {
+                throw new Error('Email transporter not initialized');
+            }
+            try {
+                const mailOptions = {
+                    from: params.from,
+                    to: params.to.join(', '),
+                    subject: params.subject,
+                };
+                if (params.cc && params.cc.length > 0) {
+                    mailOptions.cc = params.cc.join(', ');
+                }
+                if (params.html) {
+                    mailOptions.html = params.html;
+                }
+                else if (params.text) {
+                    mailOptions.text = params.text;
+                }
+                const info = yield this.transporter.sendMail(mailOptions);
+                this.logger.debug(`Log email sent to ${params.to.join(', ')} - Message ID: ${info.messageId}`);
+            }
+            catch (error) {
+                this.logger.error(`Failed to send log email: ${error.message}`, error.stack);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Close the transporter connection
+     */
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.transporter) {
+                this.transporter.close();
+                this.transporter = null;
+                this.logger.debug('Email transporter closed');
+            }
+        });
+    }
+};
+exports.EmailLogProvider = EmailLogProvider;
+exports.EmailLogProvider = EmailLogProvider = EmailLogProvider_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Object])
+], EmailLogProvider);

package/email-log/providers/index.d.ts

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

package/email-log/providers/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./email-provider"), exports);

package/email-log/services/email-log-alert.service.d.ts

@@ -0,0 +1,46 @@
+import type { EmailLogOptions } from '../interfaces';
+import { EmailLogRateLimiterService } from './email-log-rate-limiter.service';
+import { EmailLogFormatterService } from './email-log-formatter.service';
+/**
+ * Email log alert service
+ * Sends email notifications for critical log entries
+ *
+ * This service can be used directly to send email alerts
+ * without requiring Pino transport integration
+ *
+ * Note: Manual email alerts don't include HTTP context.
+ * For HTTP context, use Pino logger which automatically includes it via customProps.
+ */
+export declare class EmailLogAlertService {
+    private readonly options;
+    private readonly rateLimiter;
+    private readonly formatter;
+    private readonly logger;
+    private readonly appName;
+    private emailProvider;
+    constructor(options: EmailLogOptions, rateLimiter: EmailLogRateLimiterService, formatter: EmailLogFormatterService);
+    /**
+     * Send a log alert via email
+     * @param level Log level (error, fatal, etc.)
+     * @param message Log message
+     * @param error Optional error object
+     * @param context Optional additional context
+     */
+    sendAlert(level: string, message: string, error?: Error, context?: Record<string, any>): Promise<void>;
+    /**
+     * Send error alert
+     */
+    error(message: string, error?: Error, context?: Record<string, any>): Promise<void>;
+    /**
+     * Send fatal alert
+     */
+    fatal(message: string, error?: Error, context?: Record<string, any>): Promise<void>;
+    /**
+     * Format and send email
+     */
+    private sendEmail;
+    /**
+     * Cleanup on module destroy
+     */
+    onModuleDestroy(): Promise<void>;
+}

package/email-log/services/email-log-alert.service.js

@@ -0,0 +1,162 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var EmailLogAlertService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailLogAlertService = void 0;
+const common_1 = require("@nestjs/common");
+const email_log_constants_1 = require("../email-log.constants");
+const email_log_rate_limiter_service_1 = require("./email-log-rate-limiter.service");
+const email_log_formatter_service_1 = require("./email-log-formatter.service");
+const email_provider_1 = require("../providers/email-provider");
+const log_level_helper_1 = require("../utils/log-level.helper");
+/**
+ * Email log alert service
+ * Sends email notifications for critical log entries
+ *
+ * This service can be used directly to send email alerts
+ * without requiring Pino transport integration
+ *
+ * Note: Manual email alerts don't include HTTP context.
+ * For HTTP context, use Pino logger which automatically includes it via customProps.
+ */
+let EmailLogAlertService = EmailLogAlertService_1 = class EmailLogAlertService {
+    constructor(options, rateLimiter, formatter) {
+        this.options = options;
+        this.rateLimiter = rateLimiter;
+        this.formatter = formatter;
+        this.logger = new common_1.Logger(EmailLogAlertService_1.name);
+        this.appName = process.env.NAME || process.env.APP_NAME || 'omni-app';
+        this.emailProvider = new email_provider_1.EmailLogProvider({
+            smtpHost: options.smtpHost,
+            smtpPort: options.smtpPort || 587,
+            smtpUsername: options.smtpUsername,
+            smtpPassword: options.smtpPassword,
+            smtpSecure: options.smtpSecure || false,
+            smtpIgnoreTLSError: options.smtpIgnoreTLSError || false,
+        });
+    }
+    /**
+     * Send a log alert via email
+     * @param level Log level (error, fatal, etc.)
+     * @param message Log message
+     * @param error Optional error object
+     * @param context Optional additional context
+     */
+    sendAlert(level, message, error, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Check if enabled
+            if (!this.options.enabled) {
+                return;
+            }
+            // Check log level threshold
+            const levelValue = (0, log_level_helper_1.getLevelValue)(level);
+            const thresholdValue = (0, log_level_helper_1.getLevelValue)(this.options.level);
+            if (levelValue < thresholdValue) {
+                return;
+            }
+            // Check rate limiting
+            const rateLimitKey = `email-log:${this.appName}:${level}`;
+            if (!this.rateLimiter.canSend(rateLimitKey)) {
+                this.logger.debug(`Rate limited email for log: ${message}`);
+                return;
+            }
+            // Create log entry
+            const logEntry = {
+                level,
+                message,
+                timestamp: Date.now(),
+            };
+            if (error) {
+                logEntry.error = error;
+            }
+            if (context) {
+                logEntry.context = context;
+            }
+            // Send email
+            yield this.sendEmail(logEntry);
+        });
+    }
+    /**
+     * Send error alert
+     */
+    error(message, error, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.sendAlert('error', message, error, context);
+        });
+    }
+    /**
+     * Send fatal alert
+     */
+    fatal(message, error, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.sendAlert('fatal', message, error, context);
+        });
+    }
+    /**
+     * Format and send email
+     */
+    sendEmail(logEntry) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const subjectPrefix = this.options.subjectPrefix || '[Log Alert]';
+            // Convert log entry to Pino format for formatter
+            const pinoLog = Object.assign(Object.assign({ level: (0, log_level_helper_1.getLevelValue)(logEntry.level), time: logEntry.timestamp || Date.now(), msg: logEntry.message }, (logEntry.error
+                ? {
+                    err: {
+                        type: logEntry.error.name,
+                        message: logEntry.error.message,
+                        stack: logEntry.error.stack,
+                    },
+                }
+                : {})), (logEntry.context || {}));
+            const emailContent = this.options.useHtmlFormat
+                ? this.formatter.formatHtml(pinoLog, this.appName, subjectPrefix)
+                : this.formatter.formatText(pinoLog, this.appName, subjectPrefix);
+            yield this.emailProvider.sendLogEmail({
+                to: this.options.to,
+                cc: this.options.cc,
+                from: this.options.from,
+                subject: emailContent.subject,
+                html: 'html' in emailContent ? emailContent.html : undefined,
+                text: 'text' in emailContent ? emailContent.text : undefined,
+            });
+            this.logger.debug(`Log email sent for ${this.appName}: ${logEntry.message}`);
+        });
+    }
+    /**
+     * Cleanup on module destroy
+     */
+    onModuleDestroy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.emailProvider.close();
+        });
+    }
+};
+exports.EmailLogAlertService = EmailLogAlertService;
+exports.EmailLogAlertService = EmailLogAlertService = EmailLogAlertService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(email_log_constants_1.EMAIL_LOG_OPTIONS)),
+    __param(1, (0, common_1.Inject)(email_log_constants_1.EMAIL_LOG_RATE_LIMITER)),
+    __param(2, (0, common_1.Inject)(email_log_constants_1.EMAIL_LOG_FORMATTER)),
+    __metadata("design:paramtypes", [Function, email_log_rate_limiter_service_1.EmailLogRateLimiterService,
+        email_log_formatter_service_1.EmailLogFormatterService])
+], EmailLogAlertService);