@nest-omni/core 4.1.3-29 → 4.1.3-30

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);

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

@@ -0,0 +1,78 @@
+import { LogDescriptor } from 'pino';
+/**
+ * Formats log entries for email delivery
+ * Supports both HTML and plain text formats
+ */
+export declare class EmailLogFormatterService {
+    /**
+     * Format log entry as HTML email
+     */
+    formatHtml(log: LogDescriptor, appName: string, subjectPrefix: string): {
+        subject: string;
+        html: string;
+    };
+    /**
+     * Format log entry as plain text
+     */
+    formatText(log: LogDescriptor, appName: string, subjectPrefix: string): {
+        subject: string;
+        text: string;
+    };
+    /**
+     * Extract HTTP context from log metadata
+     */
+    private extractHttpContext;
+    /**
+     * Exclude HTTP context from general metadata
+     */
+    private excludeHttpContext;
+    /**
+     * Format request information for HTML
+     */
+    private formatRequestInfo;
+    /**
+     * Format request information for text
+     */
+    private formatRequestInfoText;
+    /**
+     * Generate a curl command for the request (single line for easy copying)
+     */
+    private generateCurlCommand;
+    /**
+     * Format user information for HTML
+     */
+    private formatUserInfo;
+    /**
+     * Format user information for text
+     */
+    private formatUserInfoText;
+    /**
+     * Format error object for HTML
+     */
+    private formatError;
+    /**
+     * Format error object for text
+     */
+    private formatErrorText;
+    /**
+     * Format metadata object for HTML
+     */
+    private formatMetadata;
+    /**
+     * Format a value for HTML display
+     */
+    private formatValue;
+    /**
+     * Get human-readable log level label
+     * Uses shared utility from log-level.helper
+     */
+    private getLevelLabel;
+    /**
+     * Get color for log level
+     */
+    private getLevelColor;
+    /**
+     * Escape HTML special characters
+     */
+    private escapeHtml;
+}