logixia 2.0.11 → 2.2.0

package/dist/nest.mjs

@@ -1,9 +1,11 @@
-import { S as DEFAULT_CONFIG, T as LogLevel, _ as serializeError, a as isLogixiaException, o as LogixiaLogger, t as ErrorResponseBuilder } from "./builder-C6kKEVrU.mjs";
-import { a as buildNameSet, c as sanitizeText, l as sensitiveQueryValues, n as DEFAULT_REDACT_QUERY_PARAMS, o as redactUrlQuery, u as assignOwn } from "./sensitive-names-wv27qBQC.mjs";
-import { d as getTraceContextKey, l as extractTraceId, o as TraceContext, p as sanitizeIncomingId, r as DEFAULT_TRACE_HEADERS } from "./request-trace-Dekcnenb.mjs";
-import { n as protectSecrets } from "./secret-config-D1F4MW69.mjs";
+import { a as isLogixiaException, o as LogixiaLogger, t as ErrorResponseBuilder, v as DEFAULT_CONFIG, x as LogLevel } from "./builder-CbttbixM.mjs";
+import { t as assignOwn } from "./own-property-CjFw9qwZ.mjs";
+import { f as getTraceContextKey, i as DEFAULT_TRACE_HEADERS, m as sanitizeIncomingId, s as TraceContext, u as extractTraceId } from "./request-trace-txUhyyre.mjs";
+import { a as buildNameSet, c as sanitizeText, l as sensitiveQueryValues, n as DEFAULT_REDACT_QUERY_PARAMS, o as redactUrlQuery } from "./sensitive-names-BiBM6R1X.mjs";
+import { n as protectSecrets } from "./secret-config-Cng7XPLx.mjs";
 import { r as internalWarn, t as internalError } from "./internal-log-Cy5nF1ZL.mjs";
 import { n as safeToString } from "./csv.utils-ZdxSod5g.mjs";
+import { r as serializeError } from "./error.utils-B8_CwESF.mjs";
 import { Catch, Inject, Injectable, Module, Optional, RequestMethod, Scope } from "@nestjs/common";
 import { EMPTY, Observable } from "rxjs";
 // \0@oxc-project+runtime@0.155.0/helpers/esm/decorateMetadata.js
@@ -19,12 +21,37 @@ function __decorate(decorators, target, key, desc) {
 }
 // src/core/logitron-nestjs.service.ts
 var _LogixiaLoggerService;
+const looksLikeStack = (value) => value.includes("\n    at ");
+const NEST_LEVEL_TO_LOGIXIA = {
+	fatal: LogLevel.ERROR,
+	error: LogLevel.ERROR,
+	warn: LogLevel.WARN,
+	log: LogLevel.INFO,
+	debug: LogLevel.DEBUG,
+	verbose: LogLevel.TRACE
+};
+const LEVEL_VERBOSITY = [
+	LogLevel.ERROR,
+	LogLevel.WARN,
+	LogLevel.INFO,
+	LogLevel.DEBUG,
+	LogLevel.TRACE
+];
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function describeObject(value) {
+	var _value$constructor;
+	return Array.isArray(value) ? safeToString(value) : `[${((_value$constructor = value.constructor) === null || _value$constructor === void 0 ? void 0 : _value$constructor.name) ?? "Object"}]`;
+}
 let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService {
 	logger;
 	context;
 	_mergedConfig;
 	constructor(config) {
-		const defaultConfig = {
+		const mergedConfig = {
 			appName: "NestJS-App",
 			environment: "development",
 			traceId: true,
@@ -59,37 +86,40 @@ let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService {
 				message: "[message]",
 				payload: "[payload]",
 				timeTaken: "[time_taken_MS]"
-			}
-		};
-		protectSecrets(this, ["_mergedConfig"]);
-		this._mergedConfig = {
-			...defaultConfig,
+			},
 			...config
 		};
-		this.logger = new LogixiaLogger(this._mergedConfig);
+		this._attach(mergedConfig, new LogixiaLogger(mergedConfig));
+	}
+	_attach(mergedConfig, logger) {
+		protectSecrets(this, ["_mergedConfig"]);
+		this._mergedConfig = mergedConfig;
+		this.logger = logger;
 		this._createCustomLevelMethods();
 	}
 	_createCustomLevelMethods() {
 		var _this$_mergedConfig$l;
 		const levels = (_this$_mergedConfig$l = this._mergedConfig.levelOptions) === null || _this$_mergedConfig$l === void 0 ? void 0 : _this$_mergedConfig$l.levels;
 		if (!levels) return;
-		for (const levelName of Object.keys(levels)) {
-			const lower = levelName.toLowerCase();
-			if (typeof this[lower] !== "undefined") continue;
-			this[lower] = async (message, data) => {
-				return this.logger.logLevel(lower, message, data);
-			};
-		}
+		const self = this;
+		const define = (method, levelName) => {
+			if (typeof self[method] !== "undefined") return;
+			self[method] = async (message, data) => this.logger.logLevel(levelName, message, data);
+		};
+		const names = Object.keys(levels);
+		for (const levelName of names) define(levelName, levelName);
+		for (const levelName of names) define(levelName.toLowerCase(), levelName);
 	}
 	/**
-	* NestJS `LoggerService.log` — void, string context.
-	* Maps internally to `info`.
+	* NestJS `LoggerService.log` — void. Maps internally to `info`.
+	* A trailing string is the context for this call only; object params are merged into the payload.
 	*
 	* @example `logger.log('User signed up', 'AuthService')`
+	* @example `logger.log('User signed up', { userId: 'u_abc' }, 'AuthService')`
 	*/
-	log(message, context) {
-		this.setContextIfProvided(context);
-		this.logger.info(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.log failed", err));
+	log(message, ...optionalParams) {
+		const { context, data } = this.parseParams(optionalParams);
+		this.reportFailure("log", this.withContext(context, () => this.logger.info(this.formatMessage(message), data)));
 	}
 	/**
 	* Native async `info` — structured data, returns `Promise<void>`.
@@ -99,27 +129,49 @@ let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService {
 	async info(message, data) {
 		return this.logger.info(message, data);
 	}
-	error(message, dataOrTrace, context) {
-		if (typeof dataOrTrace === "object" && dataOrTrace !== null) return message instanceof Error ? this.logger.error(message, dataOrTrace) : this.logger.error(this.formatMessage(message), dataOrTrace);
-		this.setContextIfProvided(context);
-		const errorData = {};
-		if (typeof dataOrTrace === "string" && dataOrTrace) errorData.stack = dataOrTrace;
-		(message instanceof Error ? this.logger.error(message, errorData) : this.logger.error(this.formatMessage(message), errorData)).catch((err) => internalError("LogixiaLoggerService.error failed", err));
+	error(message, ...optionalParams) {
+		const only = optionalParams[0];
+		if (optionalParams.length === 1 && typeof only === "object" && only !== null) {
+			const data = only;
+			return message instanceof Error ? this.logger.error(message, data) : this.logger.error(this.formatMessage(message), data);
+		}
+		const { context, data } = this.parseParams(optionalParams, true);
+		this.reportFailure("error", this.withContext(context, () => message instanceof Error ? this.logger.error(message, data) : this.logger.error(this.formatMessage(message), data)));
 	}
-	warn(message, dataOrContext) {
-		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.warn(this.formatMessage(message), dataOrContext);
-		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.warn(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.warn failed", err));
+	/**
+	* NestJS `LoggerService.fatal`. logixia has no level above `error`, so this logs
+	* at `error` with `fatal: true` in the payload, or at a custom `fatal` level when
+	* one is configured.
+	*
+	* @example `logger.fatal('Cannot reach the database, shutting down', 'Bootstrap')`
+	*/
+	fatal(message, ...optionalParams) {
+		var _this$_mergedConfig$l2;
+		const { context, data } = this.parseParams(optionalParams, true);
+		const text = this.formatMessage(message);
+		const hasFatalLevel = ((_this$_mergedConfig$l2 = this._mergedConfig.levelOptions) === null || _this$_mergedConfig$l2 === void 0 || (_this$_mergedConfig$l2 = _this$_mergedConfig$l2.levels) === null || _this$_mergedConfig$l2 === void 0 ? void 0 : _this$_mergedConfig$l2["fatal"]) !== void 0;
+		this.reportFailure("fatal", this.withContext(context, () => hasFatalLevel ? this.logger.logLevel("fatal", text, data) : this.logger.error(text, {
+			...data,
+			fatal: true
+		})));
 	}
-	debug(message, dataOrContext) {
-		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.debug(this.formatMessage(message), dataOrContext);
-		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.debug(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.debug failed", err));
+	warn(message, ...optionalParams) {
+		const only = optionalParams[0];
+		if (optionalParams.length === 1 && typeof only === "object" && only !== null) return this.logger.warn(this.formatMessage(message), only);
+		const { context, data } = this.parseParams(optionalParams);
+		this.reportFailure("warn", this.withContext(context, () => this.logger.warn(this.formatMessage(message), data)));
 	}
-	verbose(message, dataOrContext) {
-		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.trace(this.formatMessage(message), dataOrContext);
-		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.trace(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.verbose failed", err));
+	debug(message, ...optionalParams) {
+		const only = optionalParams[0];
+		if (optionalParams.length === 1 && typeof only === "object" && only !== null) return this.logger.debug(this.formatMessage(message), only);
+		const { context, data } = this.parseParams(optionalParams);
+		this.reportFailure("debug", this.withContext(context, () => this.logger.debug(this.formatMessage(message), data)));
+	}
+	verbose(message, ...optionalParams) {
+		const only = optionalParams[0];
+		if (optionalParams.length === 1 && typeof only === "object" && only !== null) return this.logger.trace(this.formatMessage(message), only);
+		const { context, data } = this.parseParams(optionalParams);
+		this.reportFailure("verbose", this.withContext(context, () => this.logger.trace(this.formatMessage(message), data)));
 	}
 	/**
 	* Native async `trace` — lowest verbosity level, structured data.
@@ -156,9 +208,30 @@ let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService {
 	getLevel() {
 		return this.logger.getLevel();
 	}
+	/**
+	* NestJS `LoggerService.setLogLevels`. logixia filters by a minimum level, not a
+	* set, so the most verbose of `levels` becomes the threshold and everything more
+	* severe stays on (`['log', 'error']` also enables `warn`). Unknown names are
+	* ignored, and an empty list is ignored too: use `silent` to turn logging off.
+	*
+	* @example `logger.setLogLevels(['error', 'warn'])`
+	*/
+	setLogLevels(levels) {
+		let threshold;
+		let verbosity = -1;
+		for (const name of levels) {
+			const level = NEST_LEVEL_TO_LOGIXIA[name];
+			const rank = level === void 0 ? -1 : LEVEL_VERBOSITY.indexOf(level);
+			if (rank > verbosity) {
+				verbosity = rank;
+				threshold = level;
+			}
+		}
+		if (threshold !== void 0) this.setLevel(threshold);
+	}
 	child(context, data) {
-		const childService = new _LogixiaLoggerService(this._mergedConfig);
-		childService.logger = this.logger.child(context, data);
+		const childService = Object.create(_LogixiaLoggerService.prototype);
+		childService._attach(this._mergedConfig, this.logger.child(context, data));
 		childService.context = context;
 		return childService;
 	}
@@ -178,9 +251,58 @@ let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService {
 	getLogger() {
 		return this.logger;
 	}
-	setContextIfProvided(context) {
-		if (typeof context !== "string" || context.length === 0) return;
-		if (context !== this.context) this.setContext(context);
+	withContext(context, fn) {
+		if (context === void 0 || context === this.logger.getContext()) return fn();
+		const previous = this.logger.getContext() ?? "";
+		this.logger.setContext(context);
+		try {
+			return fn();
+		} finally {
+			this.logger.setContext(previous);
+		}
+	}
+	/**
+	* Split NestJS `...optionalParams` into a per-call context and a payload.
+	* A trailing string is the context; plain objects are merged into the payload and
+	* an Error goes under `error`. For `error()` (`withStack`), a leading string is the stack
+	* trace, and a lone string is the stack only if it looks like one, since Nest's own
+	* `Logger` appends the context as the last param. Anything else is listed under `params`.
+	*/
+	parseParams(params, withStack = false) {
+		if (params.length === 0) return {};
+		let rest = params;
+		let context;
+		const last = params[params.length - 1];
+		if (typeof last === "string" && !(withStack && params.length === 1 && looksLikeStack(last))) {
+			context = last.length > 0 ? last : void 0;
+			rest = params.slice(0, -1);
+		}
+		let data;
+		const extras = [];
+		for (const param of rest) if (withStack && typeof param === "string" && (data === null || data === void 0 ? void 0 : data["stack"]) === void 0) data = {
+			...data,
+			stack: param
+		};
+		else if (param instanceof Error) data = {
+			...data,
+			error: param
+		};
+		else if (isPlainObject(param)) data = {
+			...data,
+			...param
+		};
+		else if (param !== void 0) extras.push(typeof param === "object" && param !== null ? describeObject(param) : param);
+		if (extras.length > 0) data = {
+			...data,
+			params: extras
+		};
+		return context === void 0 ? { data } : {
+			context,
+			data
+		};
+	}
+	reportFailure(method, result) {
+		result.catch((err) => internalError(`LogixiaLoggerService.${method} failed`, err));
 	}
 	formatMessage(message) {
 		if (typeof message === "string") return message;