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

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

@@ -0,0 +1,238 @@
+"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.createEmailTransport = createEmailTransport;
+exports.createPinoMultistream = createPinoMultistream;
+exports.createPinoEmailLogger = createPinoEmailLogger;
+exports.attachEmailTransportToLogger = attachEmailTransportToLogger;
+exports.createPinoEmailChildLogger = createPinoEmailChildLogger;
+exports.createEmailTransportFromEnv = createEmailTransportFromEnv;
+const pino_1 = require("pino");
+const pino_email_transport_1 = require("../transports/pino-email.transport");
+/**
+ * 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);
+ * ```
+ */
+function createEmailTransport(options) {
+    return new pino_email_transport_1.PinoEmailTransport(options);
+}
+/**
+ * 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));
+ * ```
+ */
+function createPinoMultistream(options, emailTransport) {
+    const streams = [
+        // Default stdout stream - log everything to console
+        {
+            level: 'trace',
+            stream: process.stdout,
+        },
+    ];
+    // Add email transport if enabled
+    if (options.enabled) {
+        streams.push({
+            level: options.level,
+            stream: emailTransport, // Both EmailLogTransportService and PinoEmailTransport are writable streams
+        });
+    }
+    return streams;
+}
+/**
+ * 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
+ * ```
+ */
+function createPinoEmailLogger(options, baseLogger) {
+    const transport = createEmailTransport(options);
+    if (!options.enabled) {
+        // If disabled, return a basic logger
+        return baseLogger || (0, pino_1.default)({ level: options.level });
+    }
+    const streams = createPinoMultistream(options, transport);
+    if (baseLogger) {
+        // Extend existing logger with email transport
+        return (0, pino_1.default)(Object.assign({}, baseLogger.options), pino_1.default.multistream(streams));
+    }
+    // Create new logger with email transport
+    return (0, pino_1.default)({
+        level: 'trace', // Log everything to console
+    }, pino_1.default.multistream(streams));
+}
+/**
+ * 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);
+ * ```
+ */
+function attachEmailTransportToLogger(logger, options, emailTransport) {
+    var _a;
+    const minLevel = pino_1.default.levels.values[options.level] || pino_1.default.levels.values.error || 50;
+    // Store original write method
+    const loggerInstance = logger;
+    const originalFlush = (_a = loggerInstance.flush) === null || _a === void 0 ? void 0 : _a.bind(loggerInstance);
+    // Override flush to include email transport flush
+    if (originalFlush) {
+        loggerInstance.flush = (cb) => __awaiter(this, void 0, void 0, function* () {
+            yield originalFlush(cb);
+            if (typeof emailTransport.flush === 'function') {
+                yield emailTransport.flush();
+            }
+        });
+    }
+    // Add the email transport as a child stream
+    const transport = {
+        write: (data) => {
+            const level = typeof data.level === 'number'
+                ? data.level
+                : pino_1.default.levels.values[data.level] || 30;
+            if (level >= minLevel) {
+                emailTransport.write(data);
+            }
+        },
+    };
+    // Try to use pino.multistream if available
+    try {
+        const streams = createPinoMultistream(options, emailTransport);
+        const newLogger = (0, pino_1.default)(pino_1.default.multistream(streams));
+        // Copy all properties from old logger to new one
+        Object.assign(loggerInstance, newLogger);
+    }
+    catch (_b) {
+        // pino.multistream not available, use manual approach
+        emailTransport._loggerTransport = transport;
+    }
+}
+/**
+ * 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
+ * ```
+ */
+function createPinoEmailChildLogger(parentLogger, context) {
+    return parentLogger.child(context);
+}
+/**
+ * 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();
+ * ```
+ */
+function createEmailTransportFromEnv() {
+    const enabled = process.env.EMAIL_LOG_ENABLED === 'true';
+    if (!enabled) {
+        return null;
+    }
+    const options = {
+        enabled: true,
+        to: (process.env.EMAIL_LOG_TO || '').split(',').map(e => e.trim()).filter(Boolean),
+        from: process.env.EMAIL_LOG_FROM || 'noreply@example.com',
+        level: process.env.EMAIL_LOG_LEVEL || 'error',
+        subjectPrefix: process.env.EMAIL_LOG_SUBJECT_PREFIX || '[Log Alert]',
+        smtpHost: process.env.EMAIL_LOG_SMTP_HOST || 'localhost',
+        smtpPort: parseInt(process.env.EMAIL_LOG_SMTP_PORT || '587'),
+        smtpUsername: process.env.EMAIL_LOG_SMTP_USERNAME || '',
+        smtpPassword: process.env.EMAIL_LOG_SMTP_PASSWORD || '',
+        smtpSecure: process.env.EMAIL_LOG_SMTP_SECURE === 'true',
+        smtpIgnoreTLSError: process.env.EMAIL_LOG_SMTP_IGNORE_TLS_ERROR === 'true',
+        rateLimitMaxEmails: parseInt(process.env.EMAIL_LOG_RATE_LIMIT_MAX_EMAILS || '10'),
+        rateLimitWindowMs: parseInt(process.env.EMAIL_LOG_RATE_LIMIT_WINDOW_MS || '60000'),
+        rateLimitBurstSize: parseInt(process.env.EMAIL_LOG_RATE_LIMIT_BURST_SIZE || '3'),
+        useHtmlFormat: process.env.EMAIL_LOG_USE_HTML_FORMAT !== 'false',
+    };
+    return new pino_email_transport_1.PinoEmailTransport(options);
+}

package/filters/bad-request.filter.d.ts

@@ -1,5 +1,14 @@
 import type { ArgumentsHost, ExceptionFilter } from '@nestjs/common';
 import { Response } from 'express';
+import type { Logger } from 'nestjs-pino';
+/**
+ * HTTP Exception Filter
+ *
+ * Catches all exceptions and formats the response
+ * For 500 errors, logs via Pino Logger which will automatically send email alerts if EMAIL_LOG_ENABLED=true
+ */
 export declare class HttpExceptionFilter implements ExceptionFilter {
+    private readonly logger?;
+    constructor(logger?: Logger);
     catch(exception: any, host: ArgumentsHost): Response<any, Record<string, any>>;
 }

package/filters/bad-request.filter.js

@@ -5,13 +5,28 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpExceptionFilter = void 0;
 const common_1 = require("@nestjs/common");
 const typeorm_1 = require("typeorm");
 const nestjs_i18n_1 = require("nestjs-i18n");
 const validation_metadata_helper_1 = require("../common/helpers/validation-metadata-helper");
+/**
+ * HTTP Exception Filter
+ *
+ * Catches all exceptions and formats the response
+ * For 500 errors, logs via Pino Logger which will automatically send email alerts if EMAIL_LOG_ENABLED=true
+ */
 let HttpExceptionFilter = class HttpExceptionFilter {
+    constructor(logger) {
+        this.logger = logger;
+    }
     catch(exception, host) {
         var _a, _b, _c, _d, _e;
         const i18n = nestjs_i18n_1.I18nContext.current(host);
@@ -27,17 +42,25 @@ let HttpExceptionFilter = class HttpExceptionFilter {
             error = 'Entity not found';
         }
         if (statusCode === 500) {
-            console.error({
-                message: exception.message,
-                stack: exception.stack,
-                connection: {
-                    localAddress: (_a = request.socket) === null || _a === void 0 ? void 0 : _a.localAddress,
-                    remoteAddress: (_b = request.socket) === null || _b === void 0 ? void 0 : _b.remoteAddress,
-                    bytesRead: (_c = request.socket) === null || _c === void 0 ? void 0 : _c.bytesRead,
-                    bytesWritten: (_d = request.socket) === null || _d === void 0 ? void 0 : _d.bytesWritten,
-                },
-                headers: request.headers,
-            });
+            const errorObj = exception instanceof Error ? exception : new Error(String(exception));
+            // Use Pino Logger if available (will send email alerts when EMAIL_LOG_ENABLED=true)
+            // Otherwise fallback to console.error
+            if (this.logger) {
+                this.logger.error(errorObj.message, errorObj.stack);
+            }
+            else {
+                console.error({
+                    message: errorObj.message,
+                    stack: errorObj.stack,
+                    connection: {
+                        localAddress: (_a = request.socket) === null || _a === void 0 ? void 0 : _a.localAddress,
+                        remoteAddress: (_b = request.socket) === null || _b === void 0 ? void 0 : _b.remoteAddress,
+                        bytesRead: (_c = request.socket) === null || _c === void 0 ? void 0 : _c.bytesRead,
+                        bytesWritten: (_d = request.socket) === null || _d === void 0 ? void 0 : _d.bytesWritten,
+                    },
+                    headers: request.headers,
+                });
+            }
         }
         const getFirstError = (error, property = '') => {
             var _a;
@@ -82,5 +105,8 @@ let HttpExceptionFilter = class HttpExceptionFilter {
 };
 exports.HttpExceptionFilter = HttpExceptionFilter;
 exports.HttpExceptionFilter = HttpExceptionFilter = __decorate([
-    (0, common_1.Catch)()
+    (0, common_1.Catch)(),
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [Function])
 ], HttpExceptionFilter);

package/index.d.ts

@@ -19,4 +19,5 @@ export * from './setup';
 export * from './health-checker';
 export * from './audit';
 export * from './file-upload';
+export * from './email-log';
 export * from '@nest-omni/transaction';

package/index.js

@@ -44,4 +44,6 @@ __exportStar(require("./health-checker"), exports);
 __exportStar(require("./audit"), exports);
 // File upload module
 __exportStar(require("./file-upload"), exports);
+// Email log module
+__exportStar(require("./email-log"), exports);
 __exportStar(require("@nest-omni/transaction"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-omni/core",
-  "version": "4.1.3-29",
+  "version": "4.1.3-30",
   "description": "A comprehensive NestJS framework for building enterprise-grade applications with best practices",
   "main": "index.js",
   "types": "index.d.ts",
@@ -45,6 +45,7 @@
     "@types/express-session": "^1.18.2",
     "@types/lodash": "^4.17.21",
     "@types/node": "^25.0.3",
+    "@types/nodemailer": "^6.4.17",
     "@types/sharp": "^0.32.0",
     "@types/sprintf-js": "^1.1.4",
     "@types/uuid": "^11.0.0",
@@ -88,6 +89,7 @@
     "moment": "^2.30.1",
     "mysql2": "^3.16.0",
     "nestjs-cls": "^6.2.0",
+    "nodemailer": "^6.9.16",
     "nestjs-i18n": "^10.6.0",
     "nestjs-pino": "^4.5.0",
     "node-vault": "^0.10.9",

package/setup/bootstrap.setup.js

@@ -164,7 +164,7 @@ function bootstrapSetup(AppModule, SetupSwagger) {
         }).use, (0, __1.RequestIdMiddleware)(), (0, __1.PowerByMiddleware)(), (0, __1.OmniAuthMiddleware)(), compression());
         // 全局过滤器
         const reflector = app.get(core_1.Reflector);
-        app.useGlobalFilters(new setup_1.SentryGlobalFilter(), new __1.HttpExceptionFilter(), new __1.QueryFailedFilter(reflector));
+        app.useGlobalFilters(new setup_1.SentryGlobalFilter(), new __1.HttpExceptionFilter(logger), new __1.QueryFailedFilter(reflector));
         // 全局拦截器
         app.useGlobalInterceptors(new __1.LanguageInterceptor(), new __1.TranslationInterceptor(), new nestjs_pino_1.LoggerErrorInterceptor());
         // 全局管道

package/shared/service-registry.module.js

@@ -37,6 +37,7 @@ const typeorm_2 = require("typeorm");
 const vault_1 = require("../vault");
 const validators_1 = require("../validators");
 const transaction_1 = require("@nest-omni/transaction");
+const email_log_1 = require("../email-log");
 const providers = [
     services_1.ApiConfigService,
     services_1.GeneratorService,
@@ -162,6 +163,19 @@ if (services_1.ApiConfigService.toBoolean(process.env.SCHEDULE_ENABLED) &&
 if (services_1.ApiConfigService.toBoolean(process.env.SCHEDULE_ENABLED)) {
     modules.push(schedule_1.ScheduleModule.forRoot());
 }
+// Email log transport for Pino
+if (services_1.ApiConfigService.toBoolean(process.env.EMAIL_LOG_ENABLED, false)) {
+    modules.push(email_log_1.EmailLogModule.forRootAsync({
+        inject: [services_1.ApiConfigService],
+        useFactory: (config) => {
+            const emailConfig = config.emailLogConfig;
+            if (!emailConfig) {
+                throw new Error('EMAIL_LOG_ENABLED is true but emailLogConfig is null');
+            }
+            return emailConfig;
+        },
+    }));
+}
 let ServiceRegistryModule = class ServiceRegistryModule {
 };
 exports.ServiceRegistryModule = ServiceRegistryModule;

package/shared/services/api-config.service.d.ts

@@ -5,6 +5,7 @@ import { Params } from 'nestjs-pino';
 import { BullRootModuleOptions } from '@nestjs/bull/dist/interfaces/bull-module-options.interface';
 import { AxiosProxyConfig } from 'axios';
 import { CorsOptions } from '@nestjs/common/interfaces/external/cors-options.interface';
+import { PinoEmailTransport } from '../../email-log';
 export declare class ApiConfigService {
     private configService;
     static rootPath: string;
@@ -47,7 +48,47 @@ export declare class ApiConfigService {
     get isRedisEnabled(): boolean;
     get bullConfig(): BullRootModuleOptions;
     get pinoConfig(): Params;
+    /**
+     * Get Pino multistream configuration with email transport
+     * This method provides additional stream for email logging
+     * Usage: pass to LoggerModule or use with pino.multistream()
+     */
+    get pinoEmailStream(): {
+        level: string;
+        stream: any;
+    };
     get axiosProxyConfig(): AxiosProxyConfig | false;
+    /**
+     * Email log transport configuration
+     * Returns null if email logging is disabled
+     */
+    get emailLogConfig(): {
+        enabled: boolean;
+        to: string[];
+        from: string;
+        level: string;
+        subjectPrefix: string;
+        smtpHost: string;
+        smtpPort: number;
+        smtpUsername: string;
+        smtpPassword: string;
+        smtpSecure: boolean;
+        smtpIgnoreTLSError: boolean;
+        rateLimitMaxEmails: number;
+        rateLimitWindowMs: number;
+        rateLimitBurstSize: number;
+        useHtmlFormat: boolean;
+        includeApps: string[];
+        excludeApps: string[];
+        includeErrors: string[];
+        excludeErrors: string[];
+    };
+    /**
+     * Get Pino email transport instance
+     * This returns a Pino transport that can be used directly with Pino logger
+     * Usage: pino(transport) or add to multistream
+     */
+    get pinoEmailTransport(): PinoEmailTransport;
     static getRootPath(): string;
     static toBoolean(value: string, defaultValue?: any): boolean;
     getNumber(key: string, defaultValue?: number): number;

package/shared/services/api-config.service.js

@@ -16,7 +16,9 @@ const config_1 = require("@nestjs/config");
 const lodash_1 = require("lodash");
 const connect_redis_1 = require("connect-redis");
 const ioredis_1 = require("ioredis");
+const pino_1 = require("pino");
 const common_2 = require("../../common");
+const email_log_1 = require("../../email-log");
 let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
     constructor(configService) {
         this.configService = configService;
@@ -204,15 +206,68 @@ let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
         };
     }
     get pinoConfig() {
-        const transport = this.isDev
-            ? {
-                target: 'pino-pretty',
+        const emailConfig = this.emailLogConfig;
+        const emailEnabled = (emailConfig === null || emailConfig === void 0 ? void 0 : emailConfig.enabled) || false;
+        // For dev mode without email, use pino-pretty
+        if (this.isDev && !emailEnabled) {
+            return {
+                pinoHttp: {
+                    genReqId: (req) => req.id,
+                    transport: {
+                        target: 'pino-pretty',
+                    },
+                    level: 'debug',
+                    customLogLevel: function (res) {
+                        if (res.statusCode >= 500)
+                            return 'error';
+                        if (res.statusCode >= 400)
+                            return 'warn';
+                        return 'info';
+                    },
+                    wrapSerializers: true,
+                    customProps: (req, res) => {
+                        return {
+                            env: this.nodeEnv,
+                            appName: this.getString('NAME'),
+                            user: req === null || req === void 0 ? void 0 : req.user,
+                            'req.body': req === null || req === void 0 ? void 0 : req.body,
+                            'res.body': res === null || res === void 0 ? void 0 : res.body,
+                        };
+                    },
+                    redact: {
+                        paths: ['req.headers.authorization', 'req.headers.apikey', 'req.headers.cookie'],
+                        remove: true,
+                    },
+                },
+            };
+        }
+        // For production or when email is enabled
+        // Prepare multistream targets
+        const streams = [
+            {
+                level: 'trace',
+                stream: process.stdout,
+            },
+        ];
+        // Add email transport if enabled
+        if (emailEnabled && emailConfig) {
+            try {
+                // Create email transport
+                const emailTransport = new email_log_1.PinoEmailTransport(emailConfig);
+                streams.push({
+                    level: emailConfig.level || 'error',
+                    stream: emailTransport,
+                });
             }
-            : null;
+            catch (error) {
+                console.error('Failed to create Pino email transport:', error);
+            }
+        }
         return {
             pinoHttp: {
                 genReqId: (req) => req.id,
-                transport,
+                // Use multistream for combining console and email output
+                stream: pino_1.default.multistream(streams),
                 level: this.isDev ? 'debug' : 'info',
                 customLogLevel: function (res) {
                     if (res.statusCode >= 500)
@@ -223,11 +278,42 @@ let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
                 },
                 wrapSerializers: true,
                 customProps: (req, res) => {
+                    var _a, _b, _c, _d, _e;
+                    // Get protocol, host and port from request
+                    const protocol = req.protocol || 'http';
+                    const hostHeader = req.get('host') || req.hostname || 'localhost';
+                    const hostname = req.hostname || 'localhost';
+                    const port = ((_a = req.socket) === null || _a === void 0 ? void 0 : _a.localPort) || this.appConfig.port || 3000;
+                    // Build baseUrl - if host already includes port, don't add it again
+                    const hasPortInHost = hostHeader.includes(':');
+                    const baseUrl = hasPortInHost
+                        ? `${protocol}://${hostHeader}`
+                        : `${protocol}://${hostHeader}:${port}`;
                     return {
                         env: this.nodeEnv,
                         appName: this.getString('NAME'),
+                        // User information
                         user: req === null || req === void 0 ? void 0 : req.user,
-                        'req.body': req === null || req === void 0 ? void 0 : req.body,
+                        // Request information (for email alerts)
+                        request: req ? {
+                            id: req.id,
+                            method: req.method,
+                            url: req.originalUrl || req.url,
+                            query: req.query,
+                            params: req.params,
+                            body: req.body,
+                            ip: req.ip,
+                            protocol,
+                            host: hostname,
+                            port,
+                            baseUrl,
+                            headers: {
+                                'user-agent': (_b = req.headers) === null || _b === void 0 ? void 0 : _b['user-agent'],
+                                referer: ((_c = req.headers) === null || _c === void 0 ? void 0 : _c.referer) || ((_d = req.headers) === null || _d === void 0 ? void 0 : _d.referrer),
+                                host: (_e = req.headers) === null || _e === void 0 ? void 0 : _e.host,
+                            },
+                        } : undefined,
+                        // Response body
                         'res.body': res === null || res === void 0 ? void 0 : res.body,
                     };
                 },
@@ -238,6 +324,24 @@ let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
             },
         };
     }
+    /**
+     * Get Pino multistream configuration with email transport
+     * This method provides additional stream for email logging
+     * Usage: pass to LoggerModule or use with pino.multistream()
+     */
+    get pinoEmailStream() {
+        const emailConfig = this.emailLogConfig;
+        if (!emailConfig || !emailConfig.enabled) {
+            return null;
+        }
+        // Return stream configuration for email transport
+        // The actual stream will be attached by EmailLogModule
+        return {
+            level: emailConfig.level,
+            // This will be replaced with the actual EmailLogTransportService stream
+            stream: null,
+        };
+    }
     get axiosProxyConfig() {
         if (!this.getBoolean('DIRECT_PROXY_ENABLED')) {
             return false;
@@ -247,6 +351,59 @@ let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
             port: this.getNumber('DIRECT_PROXY_PORT'),
         };
     }
+    /**
+     * Email log transport configuration
+     * Returns null if email logging is disabled
+     */
+    get emailLogConfig() {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (!this.getBoolean('EMAIL_LOG_ENABLED', false)) {
+            return null;
+        }
+        return {
+            enabled: true,
+            to: this.getString('EMAIL_LOG_TO')
+                .split(',')
+                .map((e) => e.trim())
+                .filter(Boolean),
+            from: this.getString('EMAIL_LOG_FROM'),
+            level: this.getString('EMAIL_LOG_LEVEL', 'error'),
+            subjectPrefix: this.getString('EMAIL_LOG_SUBJECT_PREFIX', '[Log Alert]'),
+            smtpHost: this.getString('EMAIL_LOG_SMTP_HOST'),
+            smtpPort: this.getNumber('EMAIL_LOG_SMTP_PORT', 587),
+            smtpUsername: this.getString('EMAIL_LOG_SMTP_USERNAME', ''),
+            smtpPassword: this.getString('EMAIL_LOG_SMTP_PASSWORD', ''),
+            smtpSecure: this.getBoolean('EMAIL_LOG_SMTP_SECURE', false),
+            smtpIgnoreTLSError: this.getBoolean('EMAIL_LOG_SMTP_IGNORE_TLS_ERROR', false),
+            rateLimitMaxEmails: this.getNumber('EMAIL_LOG_RATE_LIMIT_MAX_EMAILS', 10),
+            rateLimitWindowMs: this.getNumber('EMAIL_LOG_RATE_LIMIT_WINDOW_MS', 60000),
+            rateLimitBurstSize: this.getNumber('EMAIL_LOG_RATE_LIMIT_BURST_SIZE', 3),
+            useHtmlFormat: this.getBoolean('EMAIL_LOG_USE_HTML_FORMAT', true),
+            includeApps: ((_b = (_a = this.getString('EMAIL_LOG_INCLUDE_APPS', '')) === null || _a === void 0 ? void 0 : _a.split(',')) === null || _b === void 0 ? void 0 : _b.filter(Boolean)) || undefined,
+            excludeApps: ((_d = (_c = this.getString('EMAIL_LOG_EXCLUDE_APPS', '')) === null || _c === void 0 ? void 0 : _c.split(',')) === null || _d === void 0 ? void 0 : _d.filter(Boolean)) || undefined,
+            includeErrors: ((_f = (_e = this.getString('EMAIL_LOG_INCLUDE_ERRORS', '')) === null || _e === void 0 ? void 0 : _e.split(',')) === null || _f === void 0 ? void 0 : _f.filter(Boolean)) || undefined,
+            excludeErrors: ((_h = (_g = this.getString('EMAIL_LOG_EXCLUDE_ERRORS', '')) === null || _g === void 0 ? void 0 : _g.split(',')) === null || _h === void 0 ? void 0 : _h.filter(Boolean)) || undefined,
+        };
+    }
+    /**
+     * Get Pino email transport instance
+     * This returns a Pino transport that can be used directly with Pino logger
+     * Usage: pino(transport) or add to multistream
+     */
+    get pinoEmailTransport() {
+        const config = this.emailLogConfig;
+        if (!config) {
+            return null;
+        }
+        // Create and return email transport
+        try {
+            return new email_log_1.PinoEmailTransport(config);
+        }
+        catch (error) {
+            console.error('Failed to create Pino email transport:', error);
+            return null;
+        }
+    }
     static getRootPath() {
         if (!ApiConfigService_1.rootPath) {
             throw new Error(`rootPath is not set`);