@eqxjs/nest-logger 3.1.0-beta.9 → 3.1.1-beta.0

package/dist/constants/action-message.constant.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionMessage = void 0;
+/**
+ * ActionMessage - Provides standardized action tags for consistent logging across the application.
+ *
+ * This class contains static methods that return predefined action tags used for categorizing
+ * and filtering log entries. Using these constants ensures consistency in log formatting and
+ * makes it easier to search and analyze logs.
+ *
+ * @example
+ * ```typescript
+ * import { ActionMessage } from '@eqxjs/nest-logger';
+ *
+ * // Use in logging
+ * logger.info('Processing message', ActionMessage.consume());
+ * logger.info('Request received', ActionMessage.httpRequest());
+ * logger.error('Operation failed', ActionMessage.exception());
+ * ```
+ */
+class ActionMessage {
+    /**
+     * Returns the action tag for message consumption in progress.
+     * Used when starting to consume a message from a queue or broker.
+     *
+     * @returns The string '[CONSUMING]'
+     *
+     * @example
+     * ```typescript
+     * logger.info('Starting to consume', ActionMessage.consume());
+     * ```
+     */
+    static consume() {
+        return `[CONSUMING]`;
+    }
+    /**
+     * Returns the action tag for completed message consumption.
+     * Used when a message has been successfully consumed from a queue or broker.
+     *
+     * @returns The string '[CONSUMED]'
+     *
+     * @example
+     * ```typescript
+     * logger.info('Message consumed', ActionMessage.consumed());
+     * ```
+     */
+    static consumed() {
+        return `[CONSUMED]`;
+    }
+    /**
+     * Returns the action tag for message production in progress.
+     * Used when starting to produce/publish a message to a queue or broker.
+     *
+     * @returns The string '[PRODUCING]'
+     *
+     * @example
+     * ```typescript
+     * logger.info('Publishing message', ActionMessage.produce());
+     * ```
+     */
+    static produce() {
+        return `[PRODUCING]`;
+    }
+    /**
+     * Returns the action tag for completed message production.
+     * Used when a message has been successfully produced/published.
+     *
+     * @returns The string '[PRODUCED]'
+     *
+     * @example
+     * ```typescript
+     * logger.info('Message published', ActionMessage.produced());
+     * ```
+     */
+    static produced() {
+        return `[PRODUCED]`;
+    }
+    /**
+     * Returns the action tag for HTTP request operations.
+     * Used when receiving or sending HTTP requests.
+     *
+     * @returns The string '[HTTP_REQUEST]'
+     *
+     * @example
+     * ```typescript
+     * logger.info('HTTP request received', ActionMessage.httpRequest());
+     * ```
+     */
+    static httpRequest() {
+        return `[HTTP_REQUEST]`;
+    }
+    /**
+     * Returns the action tag for HTTP response operations.
+     * Used when sending or receiving HTTP responses.
+     *
+     * @returns The string '[HTTP_RESPONSE]'
+     *
+     * @example
+     * ```typescript
+     * logger.info('Sending response', ActionMessage.httpResponse());
+     * ```
+     */
+    static httpResponse() {
+        return `[HTTP_RESPONSE]`;
+    }
+    /**
+     * Returns the action tag for WebSocket message reception.
+     * Used when receiving messages via WebSocket.
+     *
+     * @returns The string '[WS_RECEIVED]'
+     *
+     * @example
+     * ```typescript
+     * logger.info('WebSocket message received', ActionMessage.wsRecv());
+     * ```
+     */
+    static wsRecv() {
+        return `[WS_RECEIVED]`;
+    }
+    /**
+     * Returns the action tag for WebSocket message sending.
+     * Used when sending messages via WebSocket.
+     *
+     * @returns The string '[WS_SENT]'
+     *
+     * @example
+     * ```typescript
+     * logger.info('WebSocket message sent', ActionMessage.wsSent());
+     * ```
+     */
+    static wsSent() {
+        return `[WS_SENT]`;
+    }
+    /**
+     * Returns the action tag for database request operations.
+     * Used when initiating database queries or operations.
+     *
+     * @returns The string '[DB_REQUEST]'
+     *
+     * @example
+     * ```typescript
+     * logger.debug('Executing query', ActionMessage.dbRequest());
+     * ```
+     */
+    static dbRequest() {
+        return `[DB_REQUEST]`;
+    }
+    /**
+     * Returns the action tag for database response operations.
+     * Used when receiving results from database queries or operations.
+     *
+     * @returns The string '[DB_RESPONSE]'
+     *
+     * @example
+     * ```typescript
+     * logger.debug('Query completed', ActionMessage.dbResponse());
+     * ```
+     */
+    static dbResponse() {
+        return `[DB_RESPONSE]`;
+    }
+    /**
+     * Returns the action tag for application logic operations.
+     * Used for business logic processing and internal operations.
+     *
+     * @returns The string '[APP_LOGIC]'
+     *
+     * @example
+     * ```typescript
+     * logger.info('Processing business logic', ActionMessage.appLogic());
+     * ```
+     */
+    static appLogic() {
+        return `[APP_LOGIC]`;
+    }
+    /**
+     * Returns the action tag for inbound operations.
+     * Used when receiving data from external services or systems.
+     *
+     * @returns The string '[INBOUND]'
+     *
+     * @example
+     * ```typescript
+     * logger.info('Receiving data', ActionMessage.inbound());
+     * ```
+     */
+    static inbound() {
+        return `[INBOUND]`;
+    }
+    /**
+     * Returns the action tag for outbound operations.
+     * Used when sending data to external services or systems.
+     *
+     * @returns The string '[OUTBOUND]'
+     *
+     * @example
+     * ```typescript
+     * logger.info('Sending data to external API', ActionMessage.outbound());
+     * ```
+     */
+    static outbound() {
+        return `[OUTBOUND]`;
+    }
+    /**
+     * Returns the action tag for exception/error conditions.
+     * Used when logging exceptions, errors, or failure scenarios.
+     *
+     * @returns The string '[EXCEPTION]'
+     *
+     * @example
+     * ```typescript
+     * logger.error('Operation failed', ActionMessage.exception());
+     * ```
+     */
+    static exception() {
+        return '[EXCEPTION]';
+    }
+}
+exports.ActionMessage = ActionMessage;
+//# sourceMappingURL=action-message.constant.js.map

package/dist/constants/action-message.constant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-message.constant.js","sourceRoot":"","sources":["../../src/constants/action-message.constant.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAa,aAAa;IACxB;;;;;;;;;;OAUG;IACI,MAAM,CAAC,OAAO;QACnB,OAAO,aAAa,CAAC;IACvB,CAAC;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,QAAQ;QACpB,OAAO,YAAY,CAAC;IACtB,CAAC;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,OAAO;QACnB,OAAO,aAAa,CAAC;IACvB,CAAC;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,QAAQ;QACpB,OAAO,YAAY,CAAC;IACtB,CAAC;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,WAAW;QACvB,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,YAAY;QACxB,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,MAAM;QAClB,OAAO,eAAe,CAAC;IACzB,CAAC;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,MAAM;QAClB,OAAO,WAAW,CAAC;IACrB,CAAC;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,SAAS;QACrB,OAAO,cAAc,CAAC;IACxB,CAAC;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,UAAU;QACtB,OAAO,eAAe,CAAC;IACzB,CAAC;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,QAAQ;QACpB,OAAO,aAAa,CAAC;IACvB,CAAC;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,OAAO;QACnB,OAAO,WAAW,CAAC;IACrB,CAAC;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,QAAQ;QACpB,OAAO,YAAY,CAAC;IACtB,CAAC;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,SAAS;QACrB,OAAO,aAAa,CAAC;IACvB,CAAC;CACF;AAlND,sCAkNC"}

package/dist/constants/index.d.ts

@@ -0,0 +1,2 @@
+export { ActionMessage } from './action-message.constant';
+export { DEFAULT_VALUES, LOG_LEVELS, LogLevel } from './logger.constants';

package/dist/constants/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOG_LEVELS = exports.DEFAULT_VALUES = exports.ActionMessage = void 0;
+var action_message_constant_1 = require("./action-message.constant");
+Object.defineProperty(exports, "ActionMessage", { enumerable: true, get: function () { return action_message_constant_1.ActionMessage; } });
+var logger_constants_1 = require("./logger.constants");
+Object.defineProperty(exports, "DEFAULT_VALUES", { enumerable: true, get: function () { return logger_constants_1.DEFAULT_VALUES; } });
+Object.defineProperty(exports, "LOG_LEVELS", { enumerable: true, get: function () { return logger_constants_1.LOG_LEVELS; } });
+//# sourceMappingURL=index.js.map

package/dist/constants/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/constants/index.ts"],"names":[],"mappings":";;;AAAA,qEAA0D;AAAjD,wHAAA,aAAa,OAAA;AACtB,uDAA0E;AAAjE,kHAAA,cAAc,OAAA;AAAE,8GAAA,UAAU,OAAA"}

package/dist/constants/logger.constants.d.ts

@@ -0,0 +1,17 @@
+export declare const DEFAULT_VALUES: {
+    NONE: string;
+    EVENT_SOURCE: string;
+    RECORD_TYPE_DETAIL: string;
+    RECORD_TYPE_SUMMARY: string;
+    MAX_MESSAGE_LENGTH: number;
+    DEFAULT_APP_NAME: string;
+};
+export declare const LOG_LEVELS: {
+    readonly DEBUG: "debug";
+    readonly INFO: "info";
+    readonly LOG: "log";
+    readonly WARN: "warn";
+    readonly ERROR: "error";
+    readonly VERBOSE: "verbose";
+};
+export type LogLevel = (typeof LOG_LEVELS)[keyof typeof LOG_LEVELS];

package/dist/constants/logger.constants.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOG_LEVELS = exports.DEFAULT_VALUES = void 0;
+exports.DEFAULT_VALUES = {
+    NONE: 'none',
+    EVENT_SOURCE: 'Event source',
+    RECORD_TYPE_DETAIL: 'detail',
+    RECORD_TYPE_SUMMARY: 'summary',
+    MAX_MESSAGE_LENGTH: 4096,
+    DEFAULT_APP_NAME: 'EQXJS',
+};
+exports.LOG_LEVELS = {
+    DEBUG: 'debug',
+    INFO: 'info',
+    LOG: 'log',
+    WARN: 'warn',
+    ERROR: 'error',
+    VERBOSE: 'verbose',
+};
+//# sourceMappingURL=logger.constants.js.map

package/dist/constants/logger.constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.constants.js","sourceRoot":"","sources":["../../src/constants/logger.constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,cAAc,GAAG;IAC5B,IAAI,EAAE,MAAM;IACZ,YAAY,EAAE,cAAc;IAC5B,kBAAkB,EAAE,QAAQ;IAC5B,mBAAmB,EAAE,SAAS;IAC9B,kBAAkB,EAAE,IAAI;IACxB,gBAAgB,EAAE,OAAO;CAC1B,CAAC;AAEW,QAAA,UAAU,GAAG;IACxB,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;IACZ,GAAG,EAAE,KAAK;IACV,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,SAAS;CACV,CAAC"}

package/dist/core/formatters/index.d.ts

@@ -0,0 +1 @@
+export { LoggerFormat } from './logger.formatter';

package/dist/core/formatters/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerFormat = void 0;
+var logger_formatter_1 = require("./logger.formatter");
+Object.defineProperty(exports, "LoggerFormat", { enumerable: true, get: function () { return logger_formatter_1.LoggerFormat; } });
+//# sourceMappingURL=index.js.map

package/dist/core/formatters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/formatters/index.ts"],"names":[],"mappings":";;;AAAA,uDAAkD;AAAzC,gHAAA,YAAY,OAAA"}

package/dist/core/formatters/logger.formatter.d.ts

@@ -0,0 +1,141 @@
+import { BaseAppLogger } from '../loggers/base-app.logger';
+import { LoggerDto } from '../../models/logger.dto';
+import { LoggerOpt } from '../../interfaces/logger-opt.interface';
+import { DataM, DataM1I, DataM2I, DataM3I } from '../../interfaces/data.interface';
+type MessageType = 'M1' | 'M2' | 'M3';
+/**
+ * LoggerFormat - Format-specific logger for M1, M2, and M3 message protocols.
+ *
+ * Provides logging capabilities for different message formats used in distributed systems:
+ * - **M1**: Message broker/queue operations (Kafka, RabbitMQ, etc.)
+ * - **M2**: HTTP/protocol operations (REST APIs, GraphQL, etc.)
+ * - **M3**: Service-to-service operations (gRPC, internal services, databases, etc.)
+ *
+ * Each format requires specific data structures with appropriate header and metadata fields.
+ *
+ * @example
+ * ```typescript
+ * // M1 Format
+ * const loggerM1 = new LoggerFormat(baseLogger, 'M1');
+ * loggerM1.info('order.topic', '[CONSUMING]', dataM1, 'Processing order');
+ *
+ * // M2 Format
+ * const loggerM2 = new LoggerFormat(baseLogger, 'M2');
+ * loggerM2.info('api.users', '[HTTP_REQUEST]', dataM2, 'User creation');
+ *
+ * // M3 Format
+ * const loggerM3 = new LoggerFormat(baseLogger, 'M3');
+ * loggerM3.debug('db.users', '[DB_REQUEST]', dataM3, 'Query users');
+ * ```
+ */
+export declare class LoggerFormat {
+    protected readonly messageType: MessageType;
+    private logger;
+    /**
+     * Creates a new LoggerFormat instance.
+     *
+     * @param logger - BaseAppLogger instance for actual logging
+     * @param messageType - Message format type ('M1', 'M2', or 'M3')
+     */
+    constructor(logger: BaseAppLogger, messageType: MessageType);
+    /**
+     * Internal method to handle log level checking and routing.
+     *
+     * @param level - Log level
+     * @param topic - Topic identifier
+     * @param action - Action tag
+     * @param data - Message data
+     * @param message - Optional message text
+     * @param opt - Optional configuration
+     * @private
+     */
+    private logMethod;
+    /**
+     * Logs a debug-level message for detailed diagnostic information.
+     *
+     * @param topic - Topic or identifier (e.g., 'payment.topic', 'api.users')
+     * @param action - Action tag (e.g., '[CONSUMING]', '[HTTP_REQUEST]')
+     * @param data - Message data (DataM1I, DataM2I, or DataM3I)
+     * @param message - Optional descriptive message
+     * @param opt - Optional logging configuration
+     */
+    debug(topic: string, action: string, data: any, message?: string, opt?: LoggerOpt): void;
+    /**
+     * Logs an info-level message for general information.
+     *
+     * @param topic - Topic or identifier
+     * @param action - Action tag
+     * @param data - Message data (DataM1I, DataM2I, or DataM3I)
+     * @param message - Optional descriptive message
+     * @param opt - Optional logging configuration
+     */
+    info(topic: string, action: string, data: any, message?: string, opt?: LoggerOpt): void;
+    /**
+     * Logs an info-level message (alias for info method).
+     *
+     * @param topic - Topic or identifier
+     * @param action - Action tag
+     * @param data - Message data (DataM1I, DataM2I, or DataM3I)
+     * @param message - Optional descriptive message
+     * @param opt - Optional logging configuration
+     */
+    log(topic: string, action: string, data: any, message?: string, opt?: LoggerOpt): void;
+    /**
+     * Logs an error-level message for error conditions.
+     *
+     * @param topic - Topic or identifier
+     * @param action - Action tag (typically '[EXCEPTION]')
+     * @param data - Message data (DataM1I, DataM2I, or DataM3I)
+     * @param message - Optional error message
+     * @param opt - Optional logging configuration
+     */
+    error(topic: string, action: string, data: any, message?: string, opt?: LoggerOpt): void;
+    /**
+     * Logs a warning-level message for potentially harmful situations.
+     *
+     * @param topic - Topic or identifier
+     * @param action - Action tag
+     * @param data - Message data (DataM1I, DataM2I, or DataM3I)
+     * @param message - Optional warning message
+     * @param opt - Optional logging configuration
+     */
+    warn(topic: string, action: string, data: any, message?: string, opt?: LoggerOpt): void;
+    /**
+     * Logs a verbose-level message for most detailed information.
+     *
+     * @param topic - Topic or identifier
+     * @param action - Action tag
+     * @param data - Message data (DataM1I, DataM2I, or DataM3I)
+     * @param message - Optional verbose message
+     * @param opt - Optional logging configuration
+     */
+    verbose(topic: string, action: string, data: any, message?: string, opt?: LoggerOpt): void;
+    /**
+     * Routes the message to the appropriate format-specific logger (M1/M2/M3).
+     *
+     * @param serverity - Log severity level
+     * @param action - Action tag
+     * @param message - Log message
+     * @param data - Message data
+     * @param topic - Topic identifier
+     * @param opt - Optional configuration
+     * @public
+     */
+    messageLog(serverity: string, action: string, message: any, data: DataM, topic: string, opt?: LoggerOpt): void;
+    summarySuccess(topic: string, appResult: string, appResultCode: string, serviceTime: number, data: DataM, opt?: LoggerOpt): LoggerDto;
+    summaryError(topic: string, appResult: string, appResultCode: string, serviceTime: number, data: DataM, stack?: string[], opt?: LoggerOpt): LoggerDto;
+    protected summaryM1Success(topic: string, appResult: string, appResultCode: string, serviceTime: number, data: DataM1I, opt?: LoggerOpt): LoggerDto;
+    protected summaryM1Error(topic: string, appResult: string, appResultCode: string, serviceTime: number, data: DataM1I, stack?: string[], opt?: LoggerOpt): LoggerDto;
+    protected summaryM2Success(topic: string, appResult: string, appResultCode: string, serviceTime: number, data: DataM2I, opt?: LoggerOpt): LoggerDto;
+    protected summaryM2Error(topic: string, appResult: string, appResultCode: string, serviceTime: number, data: DataM2I, stack?: string[], opt?: LoggerOpt): LoggerDto;
+    protected summaryM3Success(topic: string, appResult: string, appResultCode: string, serviceTime: number, data: DataM3I, opt?: LoggerOpt): LoggerDto;
+    protected summaryM3Error(topic: string, appResult: string, appResultCode: string, serviceTime: number, data: DataM3I, stack?: any[], opt?: LoggerOpt): LoggerDto;
+    private callSummarySuccess;
+    private callSummaryError;
+    protected writeLogCommon(functionName: string, topic: string, action: string, data: any, message?: string, opt?: LoggerOpt): void;
+    protected m1Logger(severity: string, action: string, message: any, data: DataM1I, topic: string, opt?: LoggerOpt): void;
+    protected m2Logger(severity: string, action: string, message: any, data: DataM2I, topic: string, opt?: LoggerOpt): void;
+    protected m3Logger(severity: string, action: string, message: any, data: DataM3I, topic: string, opt?: LoggerOpt): void;
+    private callLogger;
+}
+export {};