logixia 2.0.11 → 2.2.0

package/dist/nest.js

@@ -1,10 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_secret_config = require("./secret-config-6hdODxBb.js");
-const require_builder = require("./builder-Up4YxX7l.js");
-const require_sensitive_names = require("./sensitive-names-CNgHaqv9.js");
-const require_request_trace = require("./request-trace-C7kXMjx5.js");
+const require_secret_config = require("./secret-config-OqmIPmpV.js");
+const require_builder = require("./builder-Ck1tsC5d.js");
+const require_own_property = require("./own-property-BWkibepN.js");
+const require_request_trace = require("./request-trace-6NBSw5lt.js");
+const require_sensitive_names = require("./sensitive-names-NiKIRhp5.js");
 const require_internal_log = require("./internal-log-DwqTjhpb.js");
 const require_csv_utils = require("./csv.utils-CbVHY1pd.js");
+const require_error_utils = require("./error.utils-fZkRExam.js");
 let _nestjs_common = require("@nestjs/common");
 let rxjs = require("rxjs");
 // \0@oxc-project+runtime@0.155.0/helpers/esm/decorateMetadata.js
@@ -20,12 +22,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: require_builder.LogLevel.ERROR,
+	error: require_builder.LogLevel.ERROR,
+	warn: require_builder.LogLevel.WARN,
+	log: require_builder.LogLevel.INFO,
+	debug: require_builder.LogLevel.DEBUG,
+	verbose: require_builder.LogLevel.TRACE
+};
+const LEVEL_VERBOSITY = [
+	require_builder.LogLevel.ERROR,
+	require_builder.LogLevel.WARN,
+	require_builder.LogLevel.INFO,
+	require_builder.LogLevel.DEBUG,
+	require_builder.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) ? require_csv_utils.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,
@@ -60,37 +87,40 @@ let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService {
 				message: "[message]",
 				payload: "[payload]",
 				timeTaken: "[time_taken_MS]"
-			}
-		};
-		require_secret_config.protectSecrets(this, ["_mergedConfig"]);
-		this._mergedConfig = {
-			...defaultConfig,
+			},
 			...config
 		};
-		this.logger = new require_builder.LogixiaLogger(this._mergedConfig);
+		this._attach(mergedConfig, new require_builder.LogixiaLogger(mergedConfig));
+	}
+	_attach(mergedConfig, logger) {
+		require_secret_config.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) => require_internal_log.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>`.
@@ -100,27 +130,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) => require_internal_log.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) => require_internal_log.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) => require_internal_log.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) => require_internal_log.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.
@@ -157,9 +209,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;
 	}
@@ -179,9 +252,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) => require_internal_log.internalError(`LogixiaLoggerService.${method} failed`, err));
 	}
 	formatMessage(message) {
 		if (typeof message === "string") return message;
@@ -823,7 +945,7 @@ function scrubSerialized(value, clean, depth, seen) {
 	try {
 		if (Array.isArray(value)) return value.map((item) => scrubSerialized(item, clean, depth + 1, seen));
 		const out = {};
-		for (const [key, item] of Object.entries(value)) require_sensitive_names.assignOwn(out, key, scrubSerialized(item, clean, depth + 1, seen));
+		for (const [key, item] of Object.entries(value)) require_own_property.assignOwn(out, key, scrubSerialized(item, clean, depth + 1, seen));
 		return out;
 	} finally {
 		seen.delete(value);
@@ -841,7 +963,7 @@ function fallbackError(exception, clean) {
 	} catch {}
 	const copy = new Error(message);
 	copy.name = name;
-	require_sensitive_names.assignOwn(copy, "serialization", "[Unserializable]");
+	require_own_property.assignOwn(copy, "serialization", "[Unserializable]");
 	return copy;
 }
 /**
@@ -853,7 +975,7 @@ function fallbackError(exception, clean) {
 function sanitizedError(exception, clean) {
 	try {
 		if (!(exception instanceof Error)) return new Error(clean(String(exception)));
-		const scrubbed = scrubSerialized(require_builder.serializeError(exception), clean, 0, /* @__PURE__ */ new WeakSet());
+		const scrubbed = scrubSerialized(require_error_utils.serializeError(exception), clean, 0, /* @__PURE__ */ new WeakSet());
 		const copy = new Error(String(scrubbed["message"] ?? ""));
 		for (const [key, value] of Object.entries(scrubbed)) {
 			if (key === "message") continue;
@@ -862,7 +984,7 @@ function sanitizedError(exception, clean) {
 				writable: true,
 				configurable: true
 			});
-			else require_sensitive_names.assignOwn(copy, key, value);
+			else require_own_property.assignOwn(copy, key, value);
 		}
 		return copy;
 	} catch {