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

package/email-log/services/index.js

@@ -0,0 +1,21 @@
+"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-transport.service"), exports);
+__exportStar(require("./email-log-formatter.service"), exports);
+__exportStar(require("./email-log-rate-limiter.service"), exports);
+__exportStar(require("./email-log-alert.service"), exports);
+__exportStar(require("./email-log-logger.service"), exports);

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

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

package/email-log/transports/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("./pino-email.transport"), exports);

package/email-log/transports/pino-email.transport.d.ts

@@ -0,0 +1,56 @@
+import { Transform } from 'stream';
+import type { EmailLogOptions } from '../interfaces';
+/**
+ * Pino email transport class
+ * This is a Transform stream that can be used directly with Pino's transport option
+ *
+ * @example
+ * ```typescript
+ * import pino from 'pino';
+ * import { PinoEmailTransport } from '@nest-omni/core';
+ *
+ * const transport = new PinoEmailTransport({
+ *   enabled: true,
+ *   to: ['admin@example.com'],
+ *   from: 'noreply@example.com',
+ *   smtpHost: 'smtp.example.com',
+ *   // ... other options
+ * });
+ *
+ * const logger = pino(transport);
+ * ```
+ */
+export declare class PinoEmailTransport extends Transform {
+    private options;
+    private formatter;
+    private emailProvider;
+    constructor(options: EmailLogOptions);
+    private initDependencies;
+    _transform(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null, data?: any) => void): void;
+    private sendEmail;
+    private checkRateLimit;
+    /**
+     * Close the transport and cleanup resources
+     */
+    close(): Promise<void>;
+}
+/**
+ * Factory function to create a Pino transport configuration
+ * This can be directly used in pino() constructor
+ *
+ * @example
+ * ```typescript
+ * import pino from 'pino';
+ * import { createPinoEmailTransport } from '@nest-omni/core';
+ *
+ * const transport = createPinoEmailTransport({
+ *   enabled: true,
+ *   to: ['admin@example.com'],
+ *   from: 'noreply@example.com',
+ *   smtpHost: 'smtp.example.com',
+ * });
+ *
+ * const logger = pino(transport);
+ * ```
+ */
+export declare function createPinoEmailTransport(options: EmailLogOptions): PinoEmailTransport;

package/email-log/transports/pino-email.transport.js

@@ -0,0 +1,188 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinoEmailTransport = void 0;
+exports.createPinoEmailTransport = createPinoEmailTransport;
+const stream_1 = require("stream");
+const pino_1 = require("pino");
+const log_level_helper_1 = require("../utils/log-level.helper");
+/**
+ * Pino email transport class
+ * This is a Transform stream that can be used directly with Pino's transport option
+ *
+ * @example
+ * ```typescript
+ * import pino from 'pino';
+ * import { PinoEmailTransport } from '@nest-omni/core';
+ *
+ * const transport = new PinoEmailTransport({
+ *   enabled: true,
+ *   to: ['admin@example.com'],
+ *   from: 'noreply@example.com',
+ *   smtpHost: 'smtp.example.com',
+ *   // ... other options
+ * });
+ *
+ * const logger = pino(transport);
+ * ```
+ */
+class PinoEmailTransport extends stream_1.Transform {
+    constructor(options) {
+        super({ objectMode: true });
+        this.options = options;
+        // Import dependencies dynamically
+        this.initDependencies();
+    }
+    initDependencies() {
+        // Import formatter
+        const { EmailLogFormatterService } = require('../services/email-log-formatter.service');
+        this.formatter = new EmailLogFormatterService();
+        // Import email provider
+        const { EmailLogProvider } = require('../providers/email-provider');
+        this.emailProvider = new EmailLogProvider({
+            smtpHost: this.options.smtpHost,
+            smtpPort: this.options.smtpPort || 587,
+            smtpUsername: this.options.smtpUsername,
+            smtpPassword: this.options.smtpPassword,
+            smtpSecure: this.options.smtpSecure || false,
+            smtpIgnoreTLSError: this.options.smtpIgnoreTLSError || false,
+        });
+    }
+    _transform(chunk, encoding, callback) {
+        try {
+            // Parse chunk if it's a string (Pino multistream can send strings)
+            let log = chunk;
+            if (typeof chunk === 'string') {
+                try {
+                    log = JSON.parse(chunk);
+                }
+                catch (e) {
+                    // If not valid JSON, try to extract JSON from the string
+                    const match = chunk.match(/\{.*\}/);
+                    if (match) {
+                        log = JSON.parse(match[0]);
+                    }
+                    else {
+                        console.error('[PinoEmailTransport] Failed to parse log chunk:', chunk.substring(0, 200));
+                        callback();
+                        return;
+                    }
+                }
+            }
+            else if (chunk instanceof Buffer) {
+                try {
+                    log = JSON.parse(chunk.toString('utf-8'));
+                }
+                catch (e) {
+                    console.error('[PinoEmailTransport] Failed to parse buffer chunk');
+                    callback();
+                    return;
+                }
+            }
+            // Check if enabled
+            if (!this.options.enabled) {
+                callback();
+                return;
+            }
+            // Check log level
+            const levelValue = typeof log.level === 'number'
+                ? log.level
+                : pino_1.default.levels.values[log.level] || 30;
+            const thresholdValue = (0, log_level_helper_1.getLevelValue)(this.options.level);
+            if (levelValue < thresholdValue) {
+                callback();
+                return;
+            }
+            // Check rate limiting (in-memory for transport)
+            if (!this.checkRateLimit(log.level)) {
+                callback();
+                return;
+            }
+            // Send email asynchronously (non-blocking)
+            this.sendEmail(log).catch((err) => {
+                console.error('Failed to send log email:', err);
+            });
+            callback();
+        }
+        catch (error) {
+            console.error('Error in PinoEmailTransport:', error);
+            callback(); // Don't fail the stream
+        }
+    }
+    sendEmail(log) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const appName = process.env.NAME || process.env.APP_NAME || 'omni-app';
+            const subjectPrefix = this.options.subjectPrefix || '[Log Alert]';
+            const emailContent = this.options.useHtmlFormat
+                ? this.formatter.formatHtml(log, appName, subjectPrefix)
+                : this.formatter.formatText(log, 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,
+            });
+        });
+    }
+    checkRateLimit(level) {
+        // Simple in-memory rate limiting for transport
+        const now = Date.now();
+        const windowMs = this.options.rateLimitWindowMs || 60000;
+        const maxEmails = this.options.rateLimitMaxEmails || 10;
+        const key = `rate-limit:${level}`;
+        const state = this[key] || { count: 0, resetTime: now + windowMs };
+        if (now > state.resetTime) {
+            state.count = 0;
+            state.resetTime = now + windowMs;
+        }
+        if (state.count >= maxEmails) {
+            return false;
+        }
+        state.count++;
+        this[key] = state;
+        return true;
+    }
+    /**
+     * Close the transport and cleanup resources
+     */
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.emailProvider && typeof this.emailProvider.close === 'function') {
+                yield this.emailProvider.close();
+            }
+        });
+    }
+}
+exports.PinoEmailTransport = PinoEmailTransport;
+/**
+ * Factory function to create a Pino transport configuration
+ * This can be directly used in pino() constructor
+ *
+ * @example
+ * ```typescript
+ * import pino from 'pino';
+ * import { createPinoEmailTransport } from '@nest-omni/core';
+ *
+ * const transport = createPinoEmailTransport({
+ *   enabled: true,
+ *   to: ['admin@example.com'],
+ *   from: 'noreply@example.com',
+ *   smtpHost: 'smtp.example.com',
+ * });
+ *
+ * const logger = pino(transport);
+ * ```
+ */
+function createPinoEmailTransport(options) {
+    return new PinoEmailTransport(options);
+}

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

@@ -0,0 +1,2 @@
+export * from './pino-transport.utils';
+export * from './log-level.helper';

package/email-log/utils/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("./pino-transport.utils"), exports);
+__exportStar(require("./log-level.helper"), exports);

package/email-log/utils/log-level.helper.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Log Level Helper
+ *
+ * Shared utilities for log level operations across the email-log module.
+ * This eliminates code duplication and provides consistent behavior.
+ */
+/**
+ * Log level values mapping
+ * Uses Pino's standard level values
+ */
+export declare const LOG_LEVEL_VALUES: Record<string, number>;
+/**
+ * Get numeric level value from level name or number
+ *
+ * @param level - Level name (string) or number
+ * @returns Numeric level value
+ *
+ * @example
+ * getLevelValue('error') // returns 50
+ * getLevelValue(50) // returns 50
+ * getLevelValue('unknown') // returns 30 (info)
+ */
+export declare function getLevelValue(level: string | number): number;
+/**
+ * Get human-readable level label from numeric level
+ *
+ * @param level - Numeric level value
+ * @returns Level label string
+ *
+ * @example
+ * getLevelLabel(50) // returns 'error'
+ * getLevelLabel(30) // returns 'info'
+ */
+export declare function getLevelLabel(level: number | string): string;
+/**
+ * Check if a log level meets a threshold
+ *
+ * @param level - The log level to check
+ * @param threshold - The minimum threshold level
+ * @returns true if level meets or exceeds threshold
+ *
+ * @example
+ * meetsThreshold('error', 'warn') // true (50 >= 40)
+ * meetsThreshold('info', 'error') // false (30 < 50)
+ */
+export declare function meetsThreshold(level: string | number, threshold: string | number): boolean;

package/email-log/utils/log-level.helper.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Log Level Helper
+ *
+ * Shared utilities for log level operations across the email-log module.
+ * This eliminates code duplication and provides consistent behavior.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOG_LEVEL_VALUES = void 0;
+exports.getLevelValue = getLevelValue;
+exports.getLevelLabel = getLevelLabel;
+exports.meetsThreshold = meetsThreshold;
+/**
+ * Log level values mapping
+ * Uses Pino's standard level values
+ */
+exports.LOG_LEVEL_VALUES = {
+    trace: 10,
+    debug: 20,
+    info: 30,
+    warn: 40,
+    error: 50,
+    fatal: 60,
+};
+/**
+ * Get numeric level value from level name or number
+ *
+ * @param level - Level name (string) or number
+ * @returns Numeric level value
+ *
+ * @example
+ * getLevelValue('error') // returns 50
+ * getLevelValue(50) // returns 50
+ * getLevelValue('unknown') // returns 30 (info)
+ */
+function getLevelValue(level) {
+    if (typeof level === 'number') {
+        return level;
+    }
+    return exports.LOG_LEVEL_VALUES[level] || 30; // Default to info level
+}
+/**
+ * Get human-readable level label from numeric level
+ *
+ * @param level - Numeric level value
+ * @returns Level label string
+ *
+ * @example
+ * getLevelLabel(50) // returns 'error'
+ * getLevelLabel(30) // returns 'info'
+ */
+function getLevelLabel(level) {
+    const levelNum = typeof level === 'string' ? getLevelValue(level) : level;
+    for (const [label, value] of Object.entries(exports.LOG_LEVEL_VALUES)) {
+        if (value === levelNum) {
+            return label;
+        }
+    }
+    return 'unknown';
+}
+/**
+ * Check if a log level meets a threshold
+ *
+ * @param level - The log level to check
+ * @param threshold - The minimum threshold level
+ * @returns true if level meets or exceeds threshold
+ *
+ * @example
+ * meetsThreshold('error', 'warn') // true (50 >= 40)
+ * meetsThreshold('info', 'error') // false (30 < 50)
+ */
+function meetsThreshold(level, threshold) {
+    return getLevelValue(level) >= getLevelValue(threshold);
+}

package/email-log/utils/pino-transport.utils.d.ts

@@ -0,0 +1,135 @@
+import pino from 'pino';
+import type { EmailLogTransportService } from '../services/email-log-transport.service';
+import type { EmailLogOptions } from '../interfaces';
+import { PinoEmailTransport } from '../transports/pino-email.transport';
+/**
+ * Pino multistream target interface
+ */
+export interface PinoMultiStreamTarget {
+    level: string | number;
+    stream: NodeJS.WritableStream;
+}
+/**
+ * Create a Pino transport stream for email logging
+ * This function creates a writable stream that can be used with Pino
+ *
+ * @param options Email log options
+ * @returns A Pino transport configuration
+ *
+ * @example
+ * ```typescript
+ * import { createEmailTransport } from '@nest-omni/core';
+ * import pino from 'pino';
+ *
+ * const transport = createEmailTransport({
+ *   enabled: true,
+ *   to: ['admin@example.com'],
+ *   from: 'noreply@example.com',
+ *   smtpHost: 'smtp.example.com',
+ * });
+ *
+ * const logger = pino(transport);
+ * ```
+ */
+export declare function createEmailTransport(options: EmailLogOptions): PinoEmailTransport;
+/**
+ * Create a Pino multistream configuration that includes email transport
+ *
+ * @param options Email log options
+ * @param emailTransport The email transport service instance or PinoEmailTransport
+ * @returns Pino multistream targets array
+ *
+ * @example
+ * ```typescript
+ * import { createPinoMultistream } from '@nest-omni/core';
+ * import pino from 'pino';
+ *
+ * const streams = createPinoMultistream(options, emailTransport);
+ * const logger = pino(pino.multistream(streams));
+ * ```
+ */
+export declare function createPinoMultistream(options: EmailLogOptions, emailTransport: EmailLogTransportService | PinoEmailTransport): PinoMultiStreamTarget[];
+/**
+ * Create a Pino logger with email transport already configured
+ * This is the simplest way to get started with email logging
+ *
+ * @param options Email log options
+ * @param baseLogger Optional base Pino logger to extend
+ * @returns Pino logger with email transport
+ *
+ * @example
+ * ```typescript
+ * import { createPinoEmailLogger } from '@nest-omni/core';
+ *
+ * const logger = createPinoEmailLogger({
+ *   enabled: true,
+ *   to: ['admin@example.com'],
+ *   from: 'noreply@example.com',
+ *   smtpHost: 'smtp.example.com',
+ * });
+ *
+ * logger.error('Something went wrong!', { userId: '123' });
+ * // This will log to console AND send an email
+ * ```
+ */
+export declare function createPinoEmailLogger(options: EmailLogOptions, baseLogger?: pino.Logger): pino.Logger;
+/**
+ * Manually attach email transport to an existing Pino logger
+ * Use this if you want to add email logging to a specific logger instance
+ *
+ * @param logger The Pino logger instance
+ * @param options Email log options
+ * @param emailTransport The email transport service instance
+ *
+ * @example
+ * ```typescript
+ * import { attachEmailTransportToLogger } from '@nest-omni/core';
+ *
+ * attachEmailTransportToLogger(myLogger, options, emailTransport);
+ * ```
+ */
+export declare function attachEmailTransportToLogger(logger: pino.Logger, options: EmailLogOptions, emailTransport: EmailLogTransportService | PinoEmailTransport): void;
+/**
+ * Create a child logger with email context
+ * Useful for adding consistent metadata to all logs from a module
+ *
+ * @param parentLogger The parent Pino logger
+ * @param context Context object to include in all logs
+ * @returns Child Pino logger
+ *
+ * @example
+ * ```typescript
+ * import { createPinoEmailLogger, createPinoEmailChildLogger } from '@nest-omni/core';
+ *
+ * const baseLogger = createPinoEmailLogger(options);
+ * const userServiceLogger = createPinoEmailChildLogger(baseLogger, {
+ *   module: 'UserService',
+ *   version: '1.0.0',
+ * });
+ *
+ * userServiceLogger.error('User creation failed', { userId: '123' });
+ * // Email will include: module, version, userId in context
+ * ```
+ */
+export declare function createPinoEmailChildLogger(parentLogger: pino.Logger, context: Record<string, any>): pino.Logger;
+/**
+ * Configure Pino email transport from environment variables
+ * This is a convenience function that reads from process.env
+ *
+ * @returns PinoEmailTransport instance or null if not configured
+ *
+ * @example
+ * ```typescript
+ * import { createEmailTransportFromEnv } from '@nest-omni/core';
+ * import pino from 'pino';
+ *
+ * const emailTransport = createEmailTransportFromEnv();
+ * const logger = emailTransport
+ *   ? pino(pino.multistream([
+ *       { level: 'trace', stream: process.stdout },
+ *       { level: 'error', stream: emailTransport },
+ *     ]))
+ *   : pino();
+ * ```
+ */
+export declare function createEmailTransportFromEnv(): PinoEmailTransport | null;