logixia 1.13.3 → 2.0.0

package/dist/nest.mjs

@@ -1,10 +1,865 @@
-import "./internal-log-Cm8SOWSV.mjs";
+import { r as internalWarn, t as internalError } from "./internal-log-Cm8SOWSV.mjs";
 import "./safe-stringify-DJ66tW5I.mjs";
 import "./entry-fields-BJkuPnIg.mjs";
-import "./trace.utils-CvXgaiQT.mjs";
+import { d as sanitizeIncomingId, i as TraceContext, l as getTraceContextKey, s as extractTraceId, t as DEFAULT_TRACE_HEADERS } from "./trace.utils-CvXgaiQT.mjs";
 import "./async-context-BzJrbfQs.mjs";
-import { _ as LogixiaLoggerService, d as LOGIXIA_LOGGER_PREFIX, g as KafkaTraceInterceptor, h as TraceMiddleware, i as LogixiaExceptionFilter, m as WebSocketTraceInterceptor, n as LOGIXIA_EXCEPTION_FILTER_OPTIONS, p as LogixiaLoggerModule, u as LOGIXIA_LOGGER_CONFIG } from "./nestjs-extras-ImbuDhs1.mjs";
-import "./coerce.utils-Cu6IUTgX.mjs";
-import "./transport.manager-CpdVHEGP.mjs";
+import { O as LogLevel, T as DEFAULT_CONFIG, a as isLogixiaException, o as LogixiaLogger, t as ErrorResponseBuilder } from "./builder-0gEzRopq.mjs";
+import { t as safeToString } from "./coerce.utils-Cu6IUTgX.mjs";
+import "./transport.manager-BiuCAJd2.mjs";
+import { Catch, Inject, Injectable, Module, Optional, RequestMethod, Scope } from "@nestjs/common";
+import { EMPTY, Observable } from "rxjs";
 
-export { KafkaTraceInterceptor, LOGIXIA_EXCEPTION_FILTER_OPTIONS, LOGIXIA_LOGGER_CONFIG, LOGIXIA_LOGGER_PREFIX, LogixiaExceptionFilter, LogixiaLoggerModule, LogixiaLoggerService, TraceMiddleware, WebSocketTraceInterceptor };
+//#region \0@oxc-project+runtime@0.95.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	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;
+}
+
+//#endregion
+//#region src/core/logitron-nestjs.service.ts
+var _LogixiaLoggerService;
+let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService$1 {
+	constructor(config) {
+		this._mergedConfig = {
+			appName: "NestJS-App",
+			environment: "development",
+			traceId: true,
+			format: {
+				timestamp: true,
+				colorize: true,
+				json: false
+			},
+			silent: false,
+			levelOptions: {
+				level: LogLevel.INFO,
+				levels: {
+					error: 0,
+					warn: 1,
+					log: 2,
+					debug: 3,
+					verbose: 4
+				},
+				colors: {
+					error: "red",
+					warn: "yellow",
+					log: "green",
+					debug: "blue",
+					verbose: "cyan"
+				}
+			},
+			fields: {
+				timestamp: "[yyyy-mm-dd HH:MM:ss.MS]",
+				level: "[log_level]",
+				appName: "[app_name]",
+				traceId: "[trace_id]",
+				message: "[message]",
+				payload: "[payload]",
+				timeTaken: "[time_taken_MS]"
+			},
+			...config
+		};
+		this.logger = new LogixiaLogger(this._mergedConfig);
+		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);
+			};
+		}
+	}
+	/**
+	* NestJS `LoggerService.log` — void, string context.
+	* Maps internally to `info`.
+	*
+	* @example `logger.log('User signed up', 'AuthService')`
+	*/
+	log(message, context) {
+		this.setContextIfProvided(context);
+		this.logger.info(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.log failed", err));
+	}
+	/**
+	* Native async `info` — structured data, returns `Promise<void>`.
+	*
+	* @example `await logger.info('User signed up', { userId: 'u_abc' })`
+	*/
+	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));
+	}
+	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));
+	}
+	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));
+	}
+	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));
+	}
+	/**
+	* Native async `trace` — lowest verbosity level, structured data.
+	*/
+	async trace(message, data) {
+		return this.logger.trace(message, data);
+	}
+	/**
+	* Log at any named level with structured data.
+	*/
+	logLevel(level, message, data) {
+		return this.logger.logLevel(level, message, data);
+	}
+	time(label) {
+		this.logger.time(label);
+	}
+	async timeEnd(label) {
+		return this.logger.timeEnd(label);
+	}
+	async timeAsync(label, fn) {
+		return this.logger.timeAsync(label, fn);
+	}
+	setContext(context) {
+		const coerced = typeof context === "string" ? context : safeToString(context);
+		this.context = coerced;
+		this.logger.setContext(coerced);
+	}
+	getContext() {
+		return this.context;
+	}
+	setLevel(level) {
+		this.logger.setLevel(level);
+	}
+	getLevel() {
+		return this.logger.getLevel();
+	}
+	child(context, data) {
+		const childService = new _LogixiaLoggerService(this._mergedConfig);
+		childService.logger = this.logger.child(context, data);
+		childService.context = context;
+		return childService;
+	}
+	getCurrentTraceId() {
+		return TraceContext.instance.getCurrentTraceId();
+	}
+	/** Returns the AsyncLocalStorage key currently used to store the trace ID. */
+	get traceContextKey() {
+		return getTraceContextKey();
+	}
+	async close() {
+		return this.logger.close();
+	}
+	static create(config) {
+		return new _LogixiaLoggerService(config);
+	}
+	getLogger() {
+		return this.logger;
+	}
+	setContextIfProvided(context) {
+		if (typeof context !== "string" || context.length === 0) return;
+		if (context !== this.context) this.setContext(context);
+	}
+	formatMessage(message) {
+		if (typeof message === "string") return message;
+		return safeToString(message);
+	}
+};
+LogixiaLoggerService = _LogixiaLoggerService = __decorate([Injectable({ scope: Scope.TRANSIENT }), __decorateMetadata("design:paramtypes", [Object])], LogixiaLoggerService);
+
+//#endregion
+//#region src/core/kafka-trace.interceptor.ts
+var _KafkaTraceInterceptor;
+let KafkaTraceInterceptor = class KafkaTraceInterceptor$1 {
+	static {
+		_KafkaTraceInterceptor = this;
+	}
+	static #_ = this.metrics = {
+		accepted: 0,
+		acceptedWithoutTrace: 0,
+		dropped: 0
+	};
+	/** Reset counters (tests). */
+	static resetMetrics() {
+		_KafkaTraceInterceptor.metrics.accepted = 0;
+		_KafkaTraceInterceptor.metrics.acceptedWithoutTrace = 0;
+		_KafkaTraceInterceptor.metrics.dropped = 0;
+	}
+	/**
+	* @param config        - TraceIdConfig options (extractor keys, contextKey, etc.)
+	* @param requireTraceId - When true, messages with no traceId are silently skipped
+	*                         (EMPTY Observable — message is ack'd, consumer stays alive).
+	*                         A WARN is logged AND `KafkaTraceInterceptor.metrics.dropped`
+	*                         increments so the missing traceId is observable end-to-end.
+	*                         Default: false (handler runs without trace context).
+	*/
+	constructor(config, requireTraceId = false) {
+		this.config = config;
+		this.requireTraceId = requireTraceId;
+		this.ctx = TraceContext.instance;
+		this.config = {
+			enabled: true,
+			contextKey: "traceId",
+			extractor: {
+				body: [
+					"traceId",
+					"trace_id",
+					"x-trace-id"
+				],
+				header: ["x-trace-id", "trace-id"]
+			},
+			...config
+		};
+	}
+	intercept(context, next) {
+		var _this$config;
+		if (!((_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enabled)) return next.handle();
+		const rpcContext = context.switchToRpc();
+		const data = rpcContext.getData();
+		const rpcData = rpcContext.getContext();
+		let traceId;
+		if (this.config.extractor) traceId = extractTraceId({
+			body: data,
+			headers: (rpcData === null || rpcData === void 0 ? void 0 : rpcData.headers) ?? {},
+			query: {},
+			params: {}
+		}, this.config.extractor);
+		if (!traceId) traceId = this.ctx.getCurrentTraceId();
+		if (!traceId) {
+			if (this.requireTraceId) {
+				var _LogixiaLoggerModule$;
+				_KafkaTraceInterceptor.metrics.dropped++;
+				(_LogixiaLoggerModule$ = LogixiaLoggerModule.getGlobalLogger()) === null || _LogixiaLoggerModule$ === void 0 || _LogixiaLoggerModule$.warn(`[KafkaTraceInterceptor] Missing traceId on topic "${rpcData === null || rpcData === void 0 ? void 0 : rpcData.topic}" — message skipped.`);
+				return EMPTY;
+			}
+			_KafkaTraceInterceptor.metrics.acceptedWithoutTrace++;
+			return next.handle();
+		}
+		_KafkaTraceInterceptor.metrics.accepted++;
+		const kafkaContext = {
+			messageType: "kafka",
+			topic: rpcData === null || rpcData === void 0 ? void 0 : rpcData.topic,
+			partition: rpcData === null || rpcData === void 0 ? void 0 : rpcData.partition,
+			offset: rpcData === null || rpcData === void 0 ? void 0 : rpcData.offset,
+			key: rpcData === null || rpcData === void 0 ? void 0 : rpcData.key,
+			timestamp: rpcData === null || rpcData === void 0 ? void 0 : rpcData.timestamp
+		};
+		return new Observable((subscriber) => {
+			let inner;
+			this.ctx.run(traceId, () => {
+				inner = next.handle().subscribe({
+					next: (value) => subscriber.next(value),
+					error: (err) => subscriber.error(err),
+					complete: () => subscriber.complete()
+				});
+			}, kafkaContext);
+			return () => inner === null || inner === void 0 ? void 0 : inner.unsubscribe();
+		});
+	}
+};
+KafkaTraceInterceptor = _KafkaTraceInterceptor = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [Object, Boolean])], KafkaTraceInterceptor);
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+
+//#endregion
+//#region src/core/trace.middleware.ts
+/** Default response header used to echo the resolved traceId back to the caller. */
+const DEFAULT_TRACE_RESPONSE_HEADER = "X-Trace-Id";
+/**
+* Resolve the response header name from config.
+* - `undefined`   → default `'X-Trace-Id'`
+* - `string`      → user's custom header
+* - `false`       → `null` (suppress entirely)
+*/
+function resolveResponseHeader(config) {
+	if ((config === null || config === void 0 ? void 0 : config.responseHeader) === false) return null;
+	return (config === null || config === void 0 ? void 0 : config.responseHeader) ?? DEFAULT_TRACE_RESPONSE_HEADER;
+}
+/**
+* Echo the trace ID on the response, tolerating non-Express responses and
+* already-sent headers. NestJS can run on Fastify (reply.header() instead of
+* res.setHeader()), and on a closed/sent response setHeader throws — neither
+* should crash the request. The trace ID is still propagated via async context.
+*/
+function writeTraceHeader(res, header, traceId) {
+	const r = res;
+	if (r.headersSent) return;
+	try {
+		if (typeof r.setHeader === "function") r.setHeader(header, traceId);
+		else if (typeof r.header === "function") r.header(header, traceId);
+	} catch {}
+}
+let TraceMiddleware = class TraceMiddleware$1 {
+	constructor(config) {
+		this.config = config;
+		this.ctx = TraceContext.instance;
+		const defaultExtractor = {
+			header: DEFAULT_TRACE_HEADERS,
+			query: ["traceId", "trace_id"]
+		};
+		this.config = {
+			enabled: true,
+			generator: () => this.ctx.generate(),
+			contextKey: "traceId",
+			...config,
+			extractor: (config === null || config === void 0 ? void 0 : config.extractor) ? {
+				...defaultExtractor,
+				...config.extractor
+			} : defaultExtractor
+		};
+		if (this.config.enabled) this.ctx.setContextKey(this.config.contextKey ?? "traceId");
+	}
+	use(req, res, next) {
+		var _this$config, _req$socket, _req$connection;
+		if (!((_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enabled)) return next();
+		let traceId;
+		if (this.config.extractor) traceId = extractTraceId(req, this.config.extractor);
+		if (!traceId && this.config.generator) {
+			const candidate = this.config.generator();
+			if (typeof candidate === "string" && candidate.trim().length > 0) traceId = candidate;
+			else internalWarn("TraceIdConfig.generator returned a non-string/empty value — using built-in generator.");
+		}
+		if (!traceId) traceId = this.ctx.generate();
+		req.traceId = traceId;
+		const header = resolveResponseHeader(this.config);
+		if (header) writeTraceHeader(res, header, traceId);
+		this.ctx.run(traceId, () => next(), {
+			method: req.method,
+			url: req.url,
+			userAgent: req.get("User-Agent"),
+			ip: req.ip || ((_req$socket = req.socket) === null || _req$socket === void 0 ? void 0 : _req$socket.remoteAddress) || ((_req$connection = req.connection) === null || _req$connection === void 0 ? void 0 : _req$connection.remoteAddress)
+		});
+	}
+};
+TraceMiddleware = __decorate([
+	Injectable(),
+	__decorateParam(0, Optional()),
+	__decorateMetadata("design:paramtypes", [Object])
+], TraceMiddleware);
+
+//#endregion
+//#region src/core/websocket-trace.interceptor.ts
+let WebSocketTraceInterceptor = class WebSocketTraceInterceptor$1 {
+	constructor(config) {
+		this.config = config;
+		this.ctx = TraceContext.instance;
+		this.config = {
+			enabled: true,
+			contextKey: "traceId",
+			extractor: {
+				body: [
+					"traceId",
+					"trace_id",
+					"x-trace-id"
+				],
+				header: ["x-trace-id", "trace-id"],
+				query: ["traceId", "trace_id"]
+			},
+			...config
+		};
+	}
+	intercept(context, next) {
+		var _this$config, _client$handshake3;
+		if (!((_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enabled)) return next.handle();
+		const wsContext = context.switchToWs();
+		const data = wsContext.getData();
+		const client = wsContext.getClient();
+		let traceId;
+		if (this.config.extractor) {
+			var _client$handshake, _client$handshake2;
+			traceId = extractTraceId({
+				body: data,
+				headers: (client === null || client === void 0 || (_client$handshake = client.handshake) === null || _client$handshake === void 0 ? void 0 : _client$handshake.headers) || {},
+				query: (client === null || client === void 0 || (_client$handshake2 = client.handshake) === null || _client$handshake2 === void 0 ? void 0 : _client$handshake2.query) || {},
+				params: {}
+			}, this.config.extractor);
+		}
+		if (!traceId) traceId = this.ctx.getCurrentTraceId();
+		if (!traceId) return next.handle();
+		const wsContextData = {
+			messageType: "websocket",
+			event: data === null || data === void 0 ? void 0 : data.event,
+			socketId: client === null || client === void 0 ? void 0 : client.id,
+			rooms: (client === null || client === void 0 ? void 0 : client.rooms) ? Array.from(client.rooms) : [],
+			clientAddress: client === null || client === void 0 || (_client$handshake3 = client.handshake) === null || _client$handshake3 === void 0 ? void 0 : _client$handshake3.address
+		};
+		return new Observable((observer) => {
+			let inner;
+			this.ctx.run(traceId, () => {
+				inner = next.handle().subscribe({
+					next: (value) => observer.next(value),
+					error: (err) => observer.error(err),
+					complete: () => observer.complete()
+				});
+			}, wsContextData);
+			return () => inner === null || inner === void 0 ? void 0 : inner.unsubscribe();
+		});
+	}
+};
+WebSocketTraceInterceptor = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [Object])], WebSocketTraceInterceptor);
+
+//#endregion
+//#region src/core/logitron-logger.module.ts
+var _LogixiaLoggerModule;
+const DEFAULT_ROUTES = [{
+	path: "*",
+	method: RequestMethod.ALL
+}];
+const LOGIXIA_LOGGER_CONFIG = "LOGIXIA_LOGGER_CONFIG";
+const LOGIXIA_TRACE_CONFIG = "TRACE_CONFIG";
+const LOGIXIA_LOGGER_PREFIX = "LOGIXIA_LOGGER_";
+let LogixiaLoggerModule = class LogixiaLoggerModule$1 {
+	static {
+		_LogixiaLoggerModule = this;
+	}
+	constructor() {
+		this.config = {};
+	}
+	static #_ = this.loggerConfig = {};
+	static #_2 = this._globalLogger = null;
+	/**
+	* @internal Set the global logger exactly once.
+	*
+	* Called from the module's forRoot / forRootAsync factory. If the module is
+	* initialised more than once in the same process (nested DI context, test
+	* harness creating multiple apps, hot reload, etc.) a warning is written to
+	* stderr and the first logger wins — silently overwriting would allow the
+	* newer instance's transport config to replace the live one while the old
+	* one is still being used by registered shutdown hooks, decorators, etc.
+	*
+	* Use {@link _resetGlobalLogger} in tests to reset between runs.
+	*/
+	static _setGlobalLogger(service) {
+		if (_LogixiaLoggerModule._globalLogger !== null) {
+			internalWarn("LogixiaLoggerModule.forRoot() was called more than once — ignoring the second init. If this is intentional (e.g. in tests), call LogixiaLoggerModule._resetGlobalLogger() first.");
+			return;
+		}
+		_LogixiaLoggerModule._globalLogger = service;
+	}
+	/** @internal Clear the global logger. Tests only. */
+	static _resetGlobalLogger() {
+		_LogixiaLoggerModule._globalLogger = null;
+	}
+	/**
+	* Returns the global LogixiaLoggerService instance that was created when the
+	* module booted. Useful for logging outside of NestJS DI — utility functions,
+	* plain scripts, decorators — without injecting the service everywhere.
+	*
+	* Returns `null` if called before `LogixiaLoggerModule.forRoot[Async]()` has
+	* been initialised (i.e. before the NestJS app has started).
+	*
+	* @example
+	* ```ts
+	* // some-util.ts
+	* import { LogixiaLoggerModule } from 'logixia/nest';
+	*
+	* export function doSomething() {
+	*   LogixiaLoggerModule.getGlobalLogger()?.info('doing something');
+	* }
+	* ```
+	*/
+	static getGlobalLogger() {
+		return _LogixiaLoggerModule._globalLogger;
+	}
+	configure(consumer) {
+		const { forRoutes = DEFAULT_ROUTES, exclude } = this.config;
+		let resolvedTraceConfig;
+		if (typeof _LogixiaLoggerModule.loggerConfig.traceId === "object") resolvedTraceConfig = _LogixiaLoggerModule.loggerConfig.traceId;
+		else if (_LogixiaLoggerModule.loggerConfig.traceId === true) resolvedTraceConfig = {
+			enabled: true,
+			contextKey: "traceId",
+			generator: () => TraceContext.instance.generate()
+		};
+		const middleware = new TraceMiddleware(resolvedTraceConfig);
+		const middlewareConfig = (req, res, next) => middleware.use(req, res, next);
+		if (exclude) consumer.apply(middlewareConfig).exclude(...exclude).forRoutes(...forRoutes);
+		else consumer.apply(middlewareConfig).forRoutes(...forRoutes);
+	}
+	/**
+	* Configure the module with synchronous options
+	*/
+	static forRoot(config) {
+		_LogixiaLoggerModule.loggerConfig = config || {};
+		const traceConfig = (config === null || config === void 0 ? void 0 : config.traceId) && typeof config.traceId === "object" ? config.traceId : { enabled: !!(config === null || config === void 0 ? void 0 : config.traceId) };
+		return {
+			module: _LogixiaLoggerModule,
+			providers: [
+				{
+					provide: LOGIXIA_LOGGER_CONFIG,
+					useValue: config || {}
+				},
+				{
+					provide: LOGIXIA_TRACE_CONFIG,
+					useValue: traceConfig
+				},
+				{
+					provide: LogixiaLoggerService,
+					useFactory: (loggerConfig) => {
+						const service = new LogixiaLoggerService({
+							level: "info",
+							service: "NestJSApp",
+							environment: "development",
+							fields: {},
+							formatters: ["text"],
+							outputs: ["console"],
+							levelOptions: {
+								level: "info",
+								levels: {
+									error: 0,
+									warn: 1,
+									info: 2,
+									debug: 3,
+									verbose: 4
+								},
+								colors: {
+									error: "red",
+									warn: "yellow",
+									info: "green",
+									debug: "blue",
+									verbose: "cyan"
+								}
+							},
+							...loggerConfig
+						});
+						_LogixiaLoggerModule._setGlobalLogger(service);
+						return service;
+					},
+					inject: [LOGIXIA_LOGGER_CONFIG]
+				},
+				{
+					provide: KafkaTraceInterceptor,
+					useFactory: (traceConfig$1) => new KafkaTraceInterceptor(traceConfig$1),
+					inject: [LOGIXIA_TRACE_CONFIG]
+				},
+				{
+					provide: WebSocketTraceInterceptor,
+					useFactory: (traceConfig$1) => new WebSocketTraceInterceptor(traceConfig$1),
+					inject: [LOGIXIA_TRACE_CONFIG]
+				}
+			],
+			exports: [
+				LogixiaLoggerService,
+				LOGIXIA_LOGGER_CONFIG,
+				KafkaTraceInterceptor,
+				WebSocketTraceInterceptor
+			],
+			global: true
+		};
+	}
+	/**
+	* Configure the module with asynchronous options
+	*/
+	static forRootAsync(options) {
+		return {
+			module: _LogixiaLoggerModule,
+			imports: options.imports || [],
+			providers: [
+				...this.createAsyncProviders(options),
+				{
+					provide: LOGIXIA_TRACE_CONFIG,
+					useFactory: (loggerConfig) => {
+						return typeof (loggerConfig === null || loggerConfig === void 0 ? void 0 : loggerConfig.traceId) === "object" ? loggerConfig.traceId : { enabled: !!(loggerConfig === null || loggerConfig === void 0 ? void 0 : loggerConfig.traceId) };
+					},
+					inject: [LOGIXIA_LOGGER_CONFIG]
+				},
+				{
+					provide: LogixiaLoggerService,
+					useFactory: (loggerConfig) => {
+						const defaultConfig = {
+							level: "info",
+							service: "NestJSApp",
+							environment: "development",
+							fields: {},
+							formatters: ["text"],
+							outputs: ["console"],
+							levelOptions: {
+								level: "info",
+								levels: {
+									error: 0,
+									warn: 1,
+									info: 2,
+									debug: 3,
+									verbose: 4
+								},
+								colors: {
+									error: "red",
+									warn: "yellow",
+									info: "green",
+									debug: "blue",
+									verbose: "cyan"
+								}
+							},
+							...loggerConfig
+						};
+						_LogixiaLoggerModule.loggerConfig = defaultConfig;
+						const service = new LogixiaLoggerService(defaultConfig);
+						_LogixiaLoggerModule._setGlobalLogger(service);
+						return service;
+					},
+					inject: [LOGIXIA_LOGGER_CONFIG]
+				},
+				{
+					provide: KafkaTraceInterceptor,
+					useFactory: (traceConfig) => new KafkaTraceInterceptor(traceConfig),
+					inject: [LOGIXIA_TRACE_CONFIG]
+				},
+				{
+					provide: WebSocketTraceInterceptor,
+					useFactory: (traceConfig) => new WebSocketTraceInterceptor(traceConfig),
+					inject: [LOGIXIA_TRACE_CONFIG]
+				}
+			],
+			exports: [
+				LogixiaLoggerService,
+				LOGIXIA_LOGGER_CONFIG,
+				KafkaTraceInterceptor,
+				WebSocketTraceInterceptor
+			],
+			global: true
+		};
+	}
+	/**
+	* Create feature-specific logger instances
+	*/
+	static forFeature(context) {
+		const providerToken = `${LOGIXIA_LOGGER_PREFIX}${context.toUpperCase()}`;
+		return {
+			module: _LogixiaLoggerModule,
+			providers: [{
+				provide: providerToken,
+				useFactory: (baseLogger) => {
+					return baseLogger.child(context);
+				},
+				inject: [LogixiaLoggerService]
+			}],
+			exports: [providerToken]
+		};
+	}
+	static createAsyncProviders(options) {
+		if (options.useExisting || options.useFactory) return [this.createAsyncOptionsProvider(options)];
+		return [this.createAsyncOptionsProvider(options), {
+			provide: options.useClass,
+			useClass: options.useClass
+		}];
+	}
+	static createAsyncOptionsProvider(options) {
+		if (options.useFactory) return {
+			provide: LOGIXIA_LOGGER_CONFIG,
+			useFactory: options.useFactory,
+			inject: options.inject || []
+		};
+		return {
+			provide: LOGIXIA_LOGGER_CONFIG,
+			useFactory: async (optionsFactory) => await optionsFactory.createLogixiaOptions(),
+			inject: [options.useExisting || options.useClass]
+		};
+	}
+};
+LogixiaLoggerModule = _LogixiaLoggerModule = __decorate([Module({})], LogixiaLoggerModule);
+
+//#endregion
+//#region src/core/nestjs-extras.ts
+var _ref;
+/**
+* Inject the Logixia logger registered in the current NestJS DI container.
+*
+* Equivalent to `@Inject(LOGIXIA_LOGGER_TOKEN)` but without needing to import
+* the internal token constant yourself.
+*
+* @example
+* ```ts
+* constructor(@InjectLogger() private readonly logger: LogixiaLoggerService) {}
+* ```
+*/
+const InjectLogger = () => Inject(`${LOGIXIA_LOGGER_PREFIX}SERVICE`);
+/**
+* Method decorator that auto-logs entry, exit, duration, and errors.
+*
+* Preserves the original method's sync/async contract: a synchronous method
+* stays synchronous (returns its value directly, with logs emitted
+* fire-and-forget), and an async method is awaited so exit/error logs reflect
+* the resolved result. Attaches to the logger found on the class instance via a
+* `logger` property (the conventional NestJS name).
+*
+* @example
+* ```ts
+* @LogMethod({ level: 'info', logArgs: true })
+* async processPayment(orderId: string): Promise<void> { … }
+* ```
+*/
+function LogMethod(options = {}) {
+	const { level = "debug", logArgs = true, logResult = false, logErrors = true } = options;
+	return function(target, propertyKey, descriptor) {
+		var _constructor;
+		const originalMethod = descriptor.value;
+		if (typeof originalMethod !== "function") return descriptor;
+		const methodName = String(propertyKey);
+		const className = ((_constructor = target.constructor) === null || _constructor === void 0 ? void 0 : _constructor.name) ?? "Unknown";
+		const label = options.label ?? `${className}.${methodName}`;
+		let _warnedNoLogger = false;
+		const reportLogFailure = (phase, err) => {
+			internalError(`@LogMethod(${label}) ${phase} log failed: ${String(err)}`);
+		};
+		const emit = (logger, phase, message, data) => {
+			const logFnRaw = logger[level];
+			const p = (typeof logFnRaw === "function" ? logFnRaw : logger.debug).bind(logger)(message, data);
+			if (p && typeof p.catch === "function") p.catch((e) => reportLogFailure(phase, e));
+		};
+		const emitError = (logger, error, start) => {
+			const err = error instanceof Error ? error : new Error(String(error));
+			const errLog = logger.error(err, {
+				method: label,
+				durationMs: Date.now() - start
+			});
+			if (errLog && typeof errLog.catch === "function") errLog.catch((e) => reportLogFailure("error", e));
+		};
+		descriptor.value = function(...args) {
+			const logger = this.logger ?? LogixiaLoggerModule._globalLogger ?? void 0;
+			if (!logger && !_warnedNoLogger) {
+				_warnedNoLogger = true;
+				internalWarn(`@LogMethod on ${label}: no logger available. Either inject LogixiaLoggerService as this.logger or ensure LogixiaLoggerModule is initialised.`);
+			}
+			const start = Date.now();
+			const entry = { method: label };
+			if (logArgs && args.length > 0) entry["args"] = args;
+			if (logger) emit(logger, "entry", `→ ${label}`, entry);
+			const buildExit = (result$1) => {
+				const exit = {
+					method: label,
+					durationMs: Date.now() - start
+				};
+				if (logResult) exit["result"] = result$1;
+				return exit;
+			};
+			let result;
+			try {
+				result = originalMethod.apply(this, args);
+			} catch (error) {
+				if (logger && logErrors) emitError(logger, error, start);
+				throw error;
+			}
+			if (result && typeof result.then === "function") return result.then((resolved) => {
+				if (logger) emit(logger, "exit", `← ${label}`, buildExit(resolved));
+				return resolved;
+			}, (error) => {
+				if (logger && logErrors) emitError(logger, error, start);
+				throw error;
+			});
+			if (logger) emit(logger, "exit", `← ${label}`, buildExit(result));
+			return result;
+		};
+		return descriptor;
+	};
+}
+/** Injection token for {@link LogixiaExceptionFilterOptions}. */
+const LOGIXIA_EXCEPTION_FILTER_OPTIONS = "LOGIXIA_EXCEPTION_FILTER_OPTIONS";
+let LogixiaExceptionFilter = class LogixiaExceptionFilter$1 {
+	constructor(logger, loggerConfig, options) {
+		this._options = options ?? {};
+		this._logger = logger ?? LogixiaLoggerModule._globalLogger ?? void 0;
+		this._traceConfig = typeof (loggerConfig === null || loggerConfig === void 0 ? void 0 : loggerConfig.traceId) === "object" ? loggerConfig.traceId : void 0;
+	}
+	catch(exception, host) {
+		var _request$headers;
+		const ctx = host.switchToHttp();
+		const request = ctx.getRequest();
+		const response = ctx.getResponse();
+		const traceId = TraceContext.instance.getCurrentTraceId() ?? sanitizeIncomingId((_request$headers = request.headers) === null || _request$headers === void 0 ? void 0 : _request$headers["x-trace-id"]) ?? sanitizeIncomingId(request.id) ?? void 0;
+		const { response: errorResponse, httpStatus } = ErrorResponseBuilder.build({
+			exception,
+			traceId,
+			path: request.url ?? "/",
+			startTime: request.startTime,
+			exposeDebug: this._options.exposeDebug === true,
+			exposeCause: this._options.exposeCause === true
+		});
+		if (this._logger) {
+			const requestMeta = {
+				method: request.method ?? "",
+				url: request.url ?? "",
+				status: httpStatus,
+				...errorResponse.meta.trace_id !== void 0 ? { trace_id: errorResponse.meta.trace_id } : {}
+			};
+			const onLogFailure = (err) => {
+				internalError(`ExceptionFilter failed to write log entry: ${String(err)}`);
+			};
+			let logPromise;
+			if (httpStatus >= 500) {
+				const err = exception instanceof Error ? exception : new Error(String(exception));
+				logPromise = this._logger.error(err, requestMeta);
+			} else if (isLogixiaException(exception)) logPromise = this._logger.warn(`[${errorResponse.error.code}] ${errorResponse.error.message}`, requestMeta);
+			else logPromise = this._logger.warn(`[${httpStatus}] ${errorResponse.error.message}`, requestMeta);
+			if (logPromise && typeof logPromise.catch === "function") logPromise.catch(onLogFailure);
+		}
+		if (errorResponse.meta.trace_id) {
+			const traceHeader = resolveResponseHeader(this._traceConfig);
+			if (traceHeader) try {
+				response.setHeader(traceHeader, errorResponse.meta.trace_id);
+			} catch {}
+		}
+		if (httpStatus === 429) try {
+			response.setHeader("Retry-After", "60");
+		} catch {}
+		response.status(httpStatus).json(errorResponse);
+	}
+};
+LogixiaExceptionFilter = __decorate([
+	Catch(),
+	__decorateParam(0, Optional()),
+	__decorateParam(0, Inject(`${LOGIXIA_LOGGER_PREFIX}SERVICE`)),
+	__decorateParam(1, Optional()),
+	__decorateParam(1, Inject(LOGIXIA_LOGGER_CONFIG)),
+	__decorateParam(2, Optional()),
+	__decorateParam(2, Inject(LOGIXIA_EXCEPTION_FILTER_OPTIONS)),
+	__decorateMetadata("design:paramtypes", [
+		Object,
+		typeof (_ref = typeof Partial !== "undefined" && Partial) === "function" ? _ref : Object,
+		Object
+	])
+], LogixiaExceptionFilter);
+
+//#endregion
+//#region src/nest.ts
+/**
+* Create a new Logixia logger service for NestJS
+* @param config - Logger configuration
+* @returns LogixiaLoggerService instance
+*/
+function createLoggerService(config) {
+	return new LogixiaLoggerService({
+		...DEFAULT_CONFIG,
+		...config
+	});
+}
+
+//#endregion
+export { InjectLogger, KafkaTraceInterceptor, LOGIXIA_EXCEPTION_FILTER_OPTIONS, LOGIXIA_LOGGER_CONFIG, LOGIXIA_LOGGER_PREFIX, LOGIXIA_TRACE_CONFIG, LogMethod, LogixiaExceptionFilter, LogixiaLoggerModule, LogixiaLoggerService, TraceMiddleware, WebSocketTraceInterceptor, createLoggerService };
+//# sourceMappingURL=nest.mjs.map