logixia 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1115 @@
+import { v4 } from "uuid";
+import { AsyncLocalStorage } from "async_hooks";
+import { Injectable, Module, RequestMethod, Scope } from "@nestjs/common";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region src/types/index.ts
+const LogLevel = {
+	ERROR: "error",
+	WARN: "warn",
+	INFO: "info",
+	DEBUG: "debug",
+	TRACE: "trace",
+	VERBOSE: "verbose"
+};
+const DEFAULT_LOG_LEVELS = {
+	error: 0,
+	warn: 1,
+	info: 2,
+	debug: 3,
+	trace: 4,
+	verbose: 5
+};
+const DEFAULT_LOG_COLORS = {
+	error: "red",
+	warn: "yellow",
+	info: "green",
+	debug: "blue",
+	trace: "magenta",
+	verbose: "cyan"
+};
+
+//#endregion
+//#region src/utils/trace.utils.ts
+const traceStorage = new AsyncLocalStorage();
+/**
+* Default trace ID generator using UUID v4
+*/
+function generateTraceId() {
+	return v4().replace(/-/g, "").substring(0, 16);
+}
+/**
+* Get current trace ID from async context
+*/
+function getCurrentTraceId() {
+	const store = traceStorage.getStore();
+	return store === null || store === void 0 ? void 0 : store.traceId;
+}
+/**
+* Set trace ID in async context
+*/
+function setTraceId(traceId, data) {
+	const currentStore = traceStorage.getStore() || {};
+	traceStorage.enterWith({
+		...currentStore,
+		traceId,
+		...data
+	});
+}
+/**
+* Run function with trace ID context
+*/
+function runWithTraceId(traceId, fn, data) {
+	return traceStorage.run({
+		traceId,
+		...data
+	}, fn);
+}
+/**
+* Extract trace ID from request using configuration
+*/
+function extractTraceId(request, config) {
+	if (config.header) {
+		const headers = Array.isArray(config.header) ? config.header : [config.header];
+		for (const header of headers) {
+			var _request$headers;
+			const value = (_request$headers = request.headers) === null || _request$headers === void 0 ? void 0 : _request$headers[header.toLowerCase()];
+			if (value) return Array.isArray(value) ? value[0] : value;
+		}
+	}
+	if (config.query) {
+		const queries = Array.isArray(config.query) ? config.query : [config.query];
+		for (const query of queries) {
+			var _request$query;
+			const value = (_request$query = request.query) === null || _request$query === void 0 ? void 0 : _request$query[query];
+			if (value) return Array.isArray(value) ? value[0] : value;
+		}
+	}
+	if (config.body) {
+		const bodyFields = Array.isArray(config.body) ? config.body : [config.body];
+		for (const field of bodyFields) {
+			var _request$body;
+			const value = (_request$body = request.body) === null || _request$body === void 0 ? void 0 : _request$body[field];
+			if (value) return value;
+		}
+	}
+	if (config.params) {
+		const paramFields = Array.isArray(config.params) ? config.params : [config.params];
+		for (const param of paramFields) {
+			var _request$params;
+			const value = (_request$params = request.params) === null || _request$params === void 0 ? void 0 : _request$params[param];
+			if (value) return value;
+		}
+	}
+}
+/**
+* Create trace ID middleware for Express/NestJS
+*/
+function createTraceMiddleware(config) {
+	return (req, res, next) => {
+		let traceId;
+		if (config.extractor) traceId = extractTraceId(req, config.extractor);
+		if (!traceId) traceId = config.generator ? config.generator() : generateTraceId();
+		req.traceId = traceId;
+		res.setHeader("X-Trace-Id", traceId);
+		runWithTraceId(traceId, () => {
+			next();
+		}, { requestId: req.id || generateTraceId() });
+	};
+}
+
+//#endregion
+//#region src/utils/error.utils.ts
+/**
+* Serialize error object to JSON-safe format
+*/
+function serializeError(error, options = {}) {
+	const { includeStack = true, maxDepth = 3, excludeFields = [] } = options;
+	const serialized = {
+		name: error.name,
+		message: error.message
+	};
+	if (includeStack && error.stack) serialized.stack = error.stack;
+	const errorKeys = Object.getOwnPropertyNames(error);
+	for (const key of errorKeys) if (key !== "name" && key !== "message" && key !== "stack" && !excludeFields.includes(key)) try {
+		const value = error[key];
+		serialized[key] = serializeValue(value, maxDepth);
+	} catch {}
+	return serialized;
+}
+/**
+* Recursively serialize values with depth limit
+*/
+function serializeValue(value, maxDepth, currentDepth = 0) {
+	if (currentDepth >= maxDepth) return "[Max Depth Reached]";
+	if (value === null || value === void 0) return value;
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (value instanceof Date) return value.toISOString();
+	if (value instanceof Error) return serializeError(value, { maxDepth: maxDepth - currentDepth });
+	if (Array.isArray(value)) return value.map((item) => serializeValue(item, maxDepth, currentDepth + 1));
+	if (typeof value === "object") {
+		const serialized = {};
+		for (const [key, val] of Object.entries(value)) try {
+			serialized[key] = serializeValue(val, maxDepth, currentDepth + 1);
+		} catch {
+			serialized[key] = "[Unserializable]";
+		}
+		return serialized;
+	}
+	return String(value);
+}
+/**
+* Check if value is an Error instance
+*/
+function isError(value) {
+	return value instanceof Error || value && typeof value === "object" && "name" in value && "message" in value;
+}
+/**
+* Create error from various input types
+*/
+function normalizeError(error) {
+	if (isError(error)) return error;
+	if (typeof error === "string") return new Error(error);
+	if (typeof error === "object" && error !== null) {
+		const err = new Error(error.message || "Unknown error");
+		Object.assign(err, error);
+		return err;
+	}
+	return new Error(String(error));
+}
+
+//#endregion
+//#region src/core/logitron-logger.ts
+var LogixiaLogger = class LogixiaLogger {
+	constructor(config, context) {
+		this.timers = /* @__PURE__ */ new Map();
+		this.contextData = {};
+		this.config = {
+			appName: "App",
+			environment: "development",
+			traceId: true,
+			format: {
+				timestamp: true,
+				colorize: true,
+				json: false
+			},
+			silent: false,
+			levelOptions: {
+				level: LogLevel.INFO,
+				levels: {
+					[LogLevel.ERROR]: 0,
+					[LogLevel.WARN]: 1,
+					[LogLevel.INFO]: 2,
+					[LogLevel.DEBUG]: 3,
+					[LogLevel.TRACE]: 4,
+					[LogLevel.VERBOSE]: 5
+				},
+				colors: {
+					[LogLevel.ERROR]: "red",
+					[LogLevel.WARN]: "yellow",
+					[LogLevel.INFO]: "blue",
+					[LogLevel.DEBUG]: "green",
+					[LogLevel.TRACE]: "gray",
+					[LogLevel.VERBOSE]: "cyan"
+				}
+			},
+			...config
+		};
+		if (!this.config.fields) this.config.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]"
+		};
+		this.context = context ?? "";
+		this.createCustomLevelMethods();
+	}
+	/**
+	* Create dynamic methods for custom levels
+	*/
+	createCustomLevelMethods() {
+		var _this$config$levelOpt;
+		if ((_this$config$levelOpt = this.config.levelOptions) === null || _this$config$levelOpt === void 0 ? void 0 : _this$config$levelOpt.levels) Object.keys(this.config.levelOptions.levels).forEach((levelName) => {
+			if (!this[levelName.toLowerCase()]) this[levelName.toLowerCase()] = async (message, data) => {
+				await this.log(levelName.toLowerCase(), message, data);
+			};
+		});
+	}
+	/**
+	* Error logging with overloads
+	*/
+	async error(messageOrError, data) {
+		if (isError(messageOrError)) await this.log("error", messageOrError.message, {
+			...data,
+			error: serializeError(messageOrError)
+		});
+		else await this.log("error", messageOrError, data);
+	}
+	async warn(message, data) {
+		await this.log("warn", message, data);
+	}
+	async info(message, data) {
+		await this.log("info", message, data);
+	}
+	async debug(message, data) {
+		await this.log("debug", message, data);
+	}
+	async trace(message, data) {
+		await this.log("trace", message, data);
+	}
+	async verbose(message, data) {
+		await this.log("verbose", message, data);
+	}
+	/**
+	* Log with custom level
+	*/
+	async logLevel(level, message, data) {
+		await this.log(level, message, data);
+	}
+	/**
+	* Timing methods
+	*/
+	time(label) {
+		this.timers.set(label, {
+			label,
+			startTime: Date.now()
+		});
+	}
+	async timeEnd(label) {
+		const timer = this.timers.get(label);
+		if (!timer) {
+			await this.warn(`Timer '${label}' does not exist`);
+			return;
+		}
+		const endTime = Date.now();
+		const duration = endTime - timer.startTime;
+		timer.endTime = endTime;
+		timer.duration = duration;
+		await this.info(`Timer '${label}' finished`, {
+			duration: `${duration}ms`,
+			startTime: new Date(timer.startTime).toISOString(),
+			endTime: new Date(endTime).toISOString()
+		});
+		this.timers.delete(label);
+		return duration;
+	}
+	async timeAsync(label, fn) {
+		this.time(label);
+		try {
+			const result = await fn();
+			await this.timeEnd(label);
+			return result;
+		} catch (error) {
+			await this.timeEnd(label);
+			throw error;
+		}
+	}
+	/**
+	* Level and context management
+	*/
+	setLevel(level) {
+		this.config.levelOptions = this.config.levelOptions || {};
+		this.config.levelOptions.level = level;
+	}
+	getLevel() {
+		var _this$config$levelOpt2;
+		return ((_this$config$levelOpt2 = this.config.levelOptions) === null || _this$config$levelOpt2 === void 0 ? void 0 : _this$config$levelOpt2.level) || LogLevel.INFO;
+	}
+	setContext(context) {
+		this.context = context;
+	}
+	getContext() {
+		return this.context;
+	}
+	/**
+	* Create child logger
+	*/
+	child(context, data) {
+		const childLogger = new LogixiaLogger(this.config, context);
+		if (data) childLogger.contextData = {
+			...this.contextData,
+			...data
+		};
+		return childLogger;
+	}
+	/**
+	* Close logger and cleanup resources
+	*/
+	async close() {
+		for (const [label, timer] of this.timers) await this.warn(`Timer '${label}' was not ended properly`, {
+			startTime: new Date(timer.startTime).toISOString(),
+			duration: `${Date.now() - timer.startTime}ms (incomplete)`
+		});
+		this.timers.clear();
+	}
+	/**
+	* Core logging method
+	*/
+	async log(level, message, data) {
+		if (this.config.silent) return;
+		if (!this.shouldLog(level)) return;
+		const entry = {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			level,
+			appName: this.config.appName ?? "App",
+			message,
+			...this.context && { context: this.context },
+			payload: {
+				...this.contextData,
+				...data
+			}
+		};
+		if (this.config.traceId) entry.traceId = getCurrentTraceId() || generateTraceId();
+		const formattedLog = this.formatLog(entry);
+		this.output(formattedLog, level);
+	}
+	/**
+	* Format log entry according to configuration
+	*/
+	formatLog(entry) {
+		var _this$config$format, _this$config$format2, _this$config$format3, _this$config$levelOpt3;
+		if ((_this$config$format = this.config.format) === null || _this$config$format === void 0 ? void 0 : _this$config$format.json) return JSON.stringify(entry);
+		let formatted = "";
+		if (((_this$config$format2 = this.config.format) === null || _this$config$format2 === void 0 ? void 0 : _this$config$format2.timestamp) !== false) {
+			const timestamp = new Date(entry.timestamp).toLocaleString();
+			formatted += `[${timestamp}] `;
+		}
+		const levelName = entry.level;
+		const coloredLevel = ((_this$config$format3 = this.config.format) === null || _this$config$format3 === void 0 ? void 0 : _this$config$format3.colorize) ? this.colorize(levelName.toUpperCase(), ((_this$config$levelOpt3 = this.config.levelOptions) === null || _this$config$levelOpt3 === void 0 || (_this$config$levelOpt3 = _this$config$levelOpt3.colors) === null || _this$config$levelOpt3 === void 0 ? void 0 : _this$config$levelOpt3[levelName]) || "white") : levelName.toUpperCase();
+		formatted += `[${coloredLevel}] `;
+		formatted += `[${entry.appName}] `;
+		if (entry.traceId) formatted += `[${entry.traceId}] `;
+		if (entry.context) formatted += `[${entry.context}] `;
+		formatted += entry.message;
+		if (entry.payload && Object.keys(entry.payload).length > 0) formatted += ` ${JSON.stringify(entry.payload)}`;
+		return formatted;
+	}
+	/**
+	* Colorize text based on color name
+	*/
+	colorize(text, color) {
+		var _this$config$format4;
+		if (!((_this$config$format4 = this.config.format) === null || _this$config$format4 === void 0 ? void 0 : _this$config$format4.colorize)) return text;
+		const colors = {
+			red: "\x1B[31m",
+			green: "\x1B[32m",
+			yellow: "\x1B[33m",
+			blue: "\x1B[34m",
+			magenta: "\x1B[35m",
+			cyan: "\x1B[36m",
+			white: "\x1B[37m",
+			gray: "\x1B[90m",
+			reset: "\x1B[0m"
+		};
+		return `${colors[color.toLowerCase()] || colors.white}${text}${colors.reset}`;
+	}
+	shouldLog(level) {
+		var _this$config$levelOpt4;
+		const currentLevel = this.getLevel();
+		const levelMap = {
+			[LogLevel.ERROR]: 0,
+			[LogLevel.WARN]: 1,
+			[LogLevel.INFO]: 2,
+			[LogLevel.DEBUG]: 3,
+			[LogLevel.TRACE]: 4,
+			[LogLevel.VERBOSE]: 5,
+			...((_this$config$levelOpt4 = this.config.levelOptions) === null || _this$config$levelOpt4 === void 0 ? void 0 : _this$config$levelOpt4.levels) || {}
+		};
+		const currentLevelValue = levelMap[currentLevel];
+		const messageLevelValue = levelMap[level];
+		return messageLevelValue !== void 0 && currentLevelValue !== void 0 && messageLevelValue <= currentLevelValue;
+	}
+	/**
+	* Output log to console or other destinations
+	*/
+	output(message, level) {
+		switch (level) {
+			case LogLevel.ERROR:
+				console.error(message);
+				break;
+			case LogLevel.WARN:
+				console.warn(message);
+				break;
+			case LogLevel.DEBUG:
+			case LogLevel.TRACE:
+				console.debug(message);
+				break;
+			default: console.log(message);
+		}
+	}
+};
+/**
+* Factory function to create a typed logger with custom levels
+*/
+function createLogger$1(config, context) {
+	var _config$levelOptions;
+	const logger$1 = new LogixiaLogger(config, context);
+	if ((_config$levelOptions = config.levelOptions) === null || _config$levelOptions === void 0 ? void 0 : _config$levelOptions.levels) Object.keys(config.levelOptions.levels).forEach((levelName) => {
+		if (!logger$1[levelName]) logger$1[levelName] = async (message, data) => {
+			await logger$1.log(levelName, message, data);
+		};
+	});
+	return logger$1;
+}
+
+//#endregion
+//#region node_modules/.pnpm/@oxc-project+runtime@0.87.0/node_modules/@oxc-project/runtime/src/helpers/decorateMetadata.js
+var require_decorateMetadata = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/@oxc-project+runtime@0.87.0/node_modules/@oxc-project/runtime/src/helpers/decorateMetadata.js": ((exports, module) => {
+	function __decorateMetadata(k, v) {
+		if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+	}
+	module.exports = __decorateMetadata, module.exports.__esModule = true, module.exports["default"] = module.exports;
+}) });
+
+//#endregion
+//#region node_modules/.pnpm/@oxc-project+runtime@0.87.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js
+var require_decorate = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/@oxc-project+runtime@0.87.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js": ((exports, module) => {
+	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;
+	}
+	module.exports = __decorate, module.exports.__esModule = true, module.exports["default"] = module.exports;
+}) });
+
+//#endregion
+//#region src/core/logitron-nestjs.service.ts
+var import_decorateMetadata$1 = /* @__PURE__ */ __toESM(require_decorateMetadata());
+var import_decorate$2 = /* @__PURE__ */ __toESM(require_decorate());
+var _LogixiaLoggerService;
+let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService$1 {
+	constructor(config) {
+		const defaultConfig = {
+			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]"
+			}
+		};
+		this.logger = new LogixiaLogger({
+			...defaultConfig,
+			...config
+		});
+	}
+	/**
+	* NestJS LoggerService interface implementation
+	*/
+	log(message, context) {
+		this.setContextIfProvided(context);
+		this.logger.info(this.formatMessage(message)).catch(console.error);
+	}
+	error(message, trace, context) {
+		this.setContextIfProvided(context);
+		const errorData = {};
+		if (trace) errorData.stack = trace;
+		if (typeof message === "object" && message instanceof Error) this.logger.error(message, errorData).catch(console.error);
+		else this.logger.error(this.formatMessage(message), errorData).catch(console.error);
+	}
+	warn(message, context) {
+		this.setContextIfProvided(context);
+		this.logger.warn(this.formatMessage(message)).catch(console.error);
+	}
+	debug(message, context) {
+		this.setContextIfProvided(context);
+		this.logger.debug(this.formatMessage(message)).catch(console.error);
+	}
+	verbose(message, context) {
+		this.setContextIfProvided(context);
+		this.logger.trace(this.formatMessage(message)).catch(console.error);
+	}
+	/**
+	* Extended Logitron methods
+	*/
+	async info(message, data) {
+		return this.logger.info(message, data);
+	}
+	async trace(message, data) {
+		return this.logger.trace(message, data);
+	}
+	logLevel(level, message, data) {
+		return this.logger.logLevel(level, message, data);
+	}
+	/**
+	* Timing methods
+	*/
+	time(label) {
+		this.logger.time(label);
+	}
+	async timeEnd(label) {
+		return this.logger.timeEnd(label);
+	}
+	async timeAsync(label, fn) {
+		return this.logger.timeAsync(label, fn);
+	}
+	/**
+	* Context and level management
+	*/
+	setContext(context) {
+		this.context = context;
+		this.logger.setContext(context);
+	}
+	getContext() {
+		return this.context;
+	}
+	setLevel(level) {
+		this.logger.setLevel(level);
+	}
+	getLevel() {
+		return this.logger.getLevel();
+	}
+	/**
+	* Create child logger
+	*/
+	child(context, data) {
+		const childService = new _LogixiaLoggerService();
+		childService.logger = this.logger.child(context, data);
+		childService.context = context;
+		return childService;
+	}
+	/**
+	* Get current trace ID
+	*/
+	getCurrentTraceId() {
+		return getCurrentTraceId();
+	}
+	/**
+	* Close logger
+	*/
+	async close() {
+		return this.logger.close();
+	}
+	/**
+	* Private helper methods
+	*/
+	setContextIfProvided(context) {
+		if (context && context !== this.context) this.setContext(context);
+	}
+	formatMessage(message) {
+		if (typeof message === "string") return message;
+		if (typeof message === "object") return JSON.stringify(message);
+		return String(message);
+	}
+	/**
+	* Static factory method for easy instantiation
+	*/
+	static create(config) {
+		return new _LogixiaLoggerService(config);
+	}
+	/**
+	* Get the underlying Logitron logger instance
+	*/
+	getLogger() {
+		return this.logger;
+	}
+};
+LogixiaLoggerService = _LogixiaLoggerService = (0, import_decorate$2.default)([Injectable({ scope: Scope.TRANSIENT }), (0, import_decorateMetadata$1.default)("design:paramtypes", [Object])], LogixiaLoggerService);
+
+//#endregion
+//#region src/core/trace.middleware.ts
+var import_decorateMetadata = /* @__PURE__ */ __toESM(require_decorateMetadata());
+var import_decorate$1 = /* @__PURE__ */ __toESM(require_decorate());
+let TraceMiddleware = class TraceMiddleware$1 {
+	constructor(config) {
+		this.config = config;
+		this.config = {
+			enabled: true,
+			generator: generateTraceId,
+			contextKey: "traceId",
+			extractor: {
+				header: [
+					"x-trace-id",
+					"x-request-id",
+					"trace-id"
+				],
+				query: ["traceId", "trace_id"]
+			},
+			...config
+		};
+	}
+	use(req, res, next) {
+		var _this$config;
+		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) traceId = this.config.generator ? this.config.generator() : generateTraceId();
+		req.traceId = traceId;
+		req.requestId = req.requestId || generateTraceId();
+		res.setHeader("X-Trace-Id", traceId);
+		res.setHeader("X-Request-Id", req.requestId);
+		runWithTraceId(traceId, () => {
+			next();
+		}, {
+			requestId: req.requestId,
+			method: req.method,
+			url: req.url,
+			userAgent: req.get("User-Agent"),
+			ip: req.ip || req.connection.remoteAddress
+		});
+	}
+};
+TraceMiddleware = (0, import_decorate$1.default)([Injectable(), (0, import_decorateMetadata.default)("design:paramtypes", [Object])], TraceMiddleware);
+
+//#endregion
+//#region src/core/logitron-logger.module.ts
+var import_decorate = /* @__PURE__ */ __toESM(require_decorate());
+var _LogixiaLoggerModule;
+const DEFAULT_ROUTES = [{
+	path: "*",
+	method: RequestMethod.ALL
+}];
+const LOGIXIA_LOGGER_CONFIG = "LOGIXIA_LOGGER_CONFIG";
+const LOGIXIA_LOGGER_PREFIX = "LOGIXIA_LOGGER_";
+let LogixiaLoggerModule = class LogixiaLoggerModule$1 {
+	static {
+		_LogixiaLoggerModule = this;
+	}
+	constructor() {
+		this.config = {};
+	}
+	static #_ = this.loggerConfig = {};
+	configure(consumer) {
+		const { forRoutes = DEFAULT_ROUTES, exclude } = this.config;
+		const middlewareConfig = (req, res, next) => {
+			let traceConfig;
+			if (typeof _LogixiaLoggerModule.loggerConfig.traceId === "object") traceConfig = _LogixiaLoggerModule.loggerConfig.traceId;
+			else if (_LogixiaLoggerModule.loggerConfig.traceId === true) traceConfig = {
+				enabled: true,
+				contextKey: "traceId",
+				generator: () => {
+					const timestamp = Date.now().toString(36);
+					const random = Math.random().toString(36).substring(2, 8);
+					return `${timestamp}-${random}`;
+				}
+			};
+			else traceConfig = void 0;
+			return new TraceMiddleware(traceConfig).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 || {};
+		return {
+			module: _LogixiaLoggerModule,
+			providers: [{
+				provide: LOGIXIA_LOGGER_CONFIG,
+				useValue: 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
+					};
+					return new LogixiaLoggerService(defaultConfig);
+				},
+				inject: [LOGIXIA_LOGGER_CONFIG]
+			}],
+			exports: [LogixiaLoggerService, LOGIXIA_LOGGER_CONFIG],
+			global: true
+		};
+	}
+	/**
+	* Configure the module with asynchronous options
+	*/
+	static forRootAsync(options) {
+		return {
+			module: _LogixiaLoggerModule,
+			imports: options.imports || [],
+			providers: [...this.createAsyncProviders(options), {
+				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;
+					return new LogixiaLoggerService(defaultConfig);
+				},
+				inject: [LOGIXIA_LOGGER_CONFIG]
+			}],
+			exports: [LogixiaLoggerService, LOGIXIA_LOGGER_CONFIG],
+			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 = (0, import_decorate.default)([Module({})], LogixiaLoggerModule);
+
+//#endregion
+//#region src/formatters/json.formatter.ts
+var JsonFormatter = class {
+	constructor(options = {}) {
+		this.includeTimestamp = options.includeTimestamp ?? true;
+		this.includeLevel = options.includeLevel ?? true;
+		this.includeAppName = options.includeAppName ?? true;
+		this.includeTraceId = options.includeTraceId ?? true;
+		this.includeContext = options.includeContext ?? true;
+		this.prettyPrint = options.prettyPrint ?? false;
+	}
+	format(entry) {
+		const formatted = {};
+		if (this.includeTimestamp) formatted.timestamp = entry.timestamp;
+		if (this.includeLevel) {
+			formatted.level = entry.level.toLowerCase();
+			formatted.levelValue = entry.level;
+		}
+		if (this.includeAppName) formatted.appName = entry.appName;
+		if (this.includeTraceId && entry.traceId) formatted.traceId = entry.traceId;
+		if (this.includeContext && entry.context) formatted.context = entry.context;
+		formatted.message = entry.message;
+		if (entry.payload && Object.keys(entry.payload).length > 0) formatted.payload = this.serializePayload(entry.payload);
+		if (entry.error) formatted.error = serializeError(entry.error);
+		formatted.meta = {
+			pid: process.pid,
+			hostname: process.env.HOSTNAME || "unknown",
+			version: process.version
+		};
+		return this.prettyPrint ? JSON.stringify(formatted, null, 2) : JSON.stringify(formatted);
+	}
+	serializePayload(payload) {
+		const serialized = {};
+		for (const [key, value] of Object.entries(payload)) try {
+			if (value instanceof Error) serialized[key] = serializeError(value);
+			else if (value instanceof Date) serialized[key] = value.toISOString();
+			else if (typeof value === "function") serialized[key] = "[Function]";
+			else if (typeof value === "symbol") serialized[key] = value.toString();
+			else if (value === void 0) serialized[key] = null;
+			else serialized[key] = value;
+		} catch {
+			serialized[key] = "[Unserializable]";
+		}
+		return serialized;
+	}
+};
+
+//#endregion
+//#region src/formatters/text.formatter.ts
+var TextFormatter = class TextFormatter {
+	constructor(options = {}) {
+		this.colorize = options.colorize ?? true;
+		this.includeTimestamp = options.includeTimestamp ?? true;
+		this.includeAppName = options.includeAppName ?? true;
+		this.includeTraceId = options.includeTraceId ?? true;
+		this.includeContext = options.includeContext ?? true;
+		this.timestampFormat = options.timestampFormat ?? "locale";
+		this.colors = {
+			error: "\x1B[31m",
+			warn: "\x1B[33m",
+			info: "\x1B[32m",
+			debug: "\x1B[34m",
+			trace: "\x1B[35m",
+			verbose: "\x1B[36m",
+			reset: "\x1B[0m",
+			bold: "\x1B[1m",
+			dim: "\x1B[2m",
+			...options.colors
+		};
+	}
+	format(entry) {
+		const parts = [];
+		if (this.includeTimestamp) {
+			const timestamp = this.formatTimestamp(entry.timestamp);
+			parts.push(this.colorize ? `${this.colors.dim}${timestamp}${this.colors.reset}` : timestamp);
+		}
+		const levelName = entry.level.toLowerCase();
+		const levelColor = this.colors[levelName] || this.colors.reset;
+		const formattedLevel = this.colorize ? `${levelColor}${this.colors.bold}${levelName.toUpperCase().padEnd(5)}${this.colors.reset}` : levelName.toUpperCase().padEnd(5);
+		parts.push(`[${formattedLevel}]`);
+		if (this.includeAppName) {
+			const appName = this.colorize ? `${this.colors.bold}${entry.appName}${this.colors.reset}` : entry.appName;
+			parts.push(`[${appName}]`);
+		}
+		if (this.includeTraceId && entry.traceId) {
+			const traceId = this.colorize ? `${this.colors.dim}${entry.traceId}${this.colors.reset}` : entry.traceId;
+			parts.push(`[${traceId}]`);
+		}
+		if (this.includeContext && entry.context) {
+			const context = this.colorize ? `${this.colors.cyan}${entry.context}${this.colors.reset}` : entry.context;
+			parts.push(`[${context}]`);
+		}
+		const message = this.colorize && entry.level === LogLevel.ERROR ? `${this.colors.error}${entry.message}${this.colors.reset}` : entry.message;
+		parts.push(message);
+		if (entry.payload && Object.keys(entry.payload).length > 0) {
+			const payload = this.formatPayload(entry.payload);
+			if (payload) parts.push(this.colorize ? `${this.colors.dim}${payload}${this.colors.reset}` : payload);
+		}
+		return parts.join(" ");
+	}
+	formatTimestamp(timestamp) {
+		const date = new Date(timestamp);
+		switch (this.timestampFormat) {
+			case "iso": return date.toISOString();
+			case "short": return date.toLocaleTimeString();
+			case "locale":
+			default: return date.toLocaleString();
+		}
+	}
+	formatPayload(payload) {
+		try {
+			if (Object.keys(payload).length === 1) {
+				const entry = Object.entries(payload)[0];
+				if (entry) {
+					const [key, value] = entry;
+					if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return `${key}=${value}`;
+				}
+			}
+			return Object.entries(payload).map(([key, value]) => {
+				if (value === null || value === void 0) return `${key}=${value}`;
+				if (typeof value === "string") return `${key}="${value}"`;
+				if (typeof value === "number" || typeof value === "boolean") return `${key}=${value}`;
+				if (value instanceof Date) return `${key}=${value.toISOString()}`;
+				if (typeof value === "object") return `${key}=${JSON.stringify(value)}`;
+				return `${key}=${String(value)}`;
+			}).join(" ");
+		} catch {
+			return JSON.stringify(payload);
+		}
+	}
+	/**
+	* Create a formatter with preset configurations
+	*/
+	static createSimple() {
+		return new TextFormatter({
+			colorize: true,
+			includeTimestamp: true,
+			includeAppName: false,
+			includeTraceId: false,
+			includeContext: true,
+			timestampFormat: "short"
+		});
+	}
+	static createDetailed() {
+		return new TextFormatter({
+			colorize: true,
+			includeTimestamp: true,
+			includeAppName: true,
+			includeTraceId: true,
+			includeContext: true,
+			timestampFormat: "locale"
+		});
+	}
+	static createMinimal() {
+		return new TextFormatter({
+			colorize: false,
+			includeTimestamp: false,
+			includeAppName: false,
+			includeTraceId: false,
+			includeContext: false
+		});
+	}
+};
+
+//#endregion
+//#region src/index.ts
+/**
+* Default configuration for Logitron logger
+*/
+const DEFAULT_CONFIG = {
+	appName: "App",
+	environment: "development",
+	traceId: true,
+	format: {
+		timestamp: true,
+		colorize: true,
+		json: false
+	},
+	silent: false,
+	levelOptions: {
+		level: LogLevel.INFO,
+		levels: {
+			[LogLevel.ERROR]: 0,
+			[LogLevel.WARN]: 1,
+			[LogLevel.INFO]: 2,
+			[LogLevel.DEBUG]: 3,
+			[LogLevel.TRACE]: 4,
+			[LogLevel.VERBOSE]: 5
+		},
+		colors: {
+			[LogLevel.ERROR]: "red",
+			[LogLevel.WARN]: "yellow",
+			[LogLevel.INFO]: "blue",
+			[LogLevel.DEBUG]: "green",
+			[LogLevel.TRACE]: "gray",
+			[LogLevel.VERBOSE]: "cyan"
+		}
+	},
+	fields: {
+		timestamp: true,
+		level: true,
+		appName: true,
+		traceId: true,
+		message: true,
+		payload: true,
+		timeTaken: true
+	},
+	outputs: ["console"]
+};
+/**
+* Create a new Logitron logger instance with TypeScript support for custom levels
+* @param config - Logger configuration
+* @returns Typed logger instance
+*/
+const createLogger = createLogger$1;
+/**
+* Create a new Logitron logger service for NestJS
+* @param config - Logger configuration
+* @returns LogixiaLoggerService instance
+*/
+function createLoggerService(config) {
+	return new LogixiaLoggerService({
+		...DEFAULT_CONFIG,
+		...config
+	});
+}
+/**
+* Default logger instance
+*/
+const logger = new LogixiaLogger(DEFAULT_CONFIG);
+/**
+* Export default configuration for reference
+*/
+//#endregion
+export { DEFAULT_CONFIG, DEFAULT_LOG_COLORS, DEFAULT_LOG_LEVELS, JsonFormatter, LOGIXIA_LOGGER_CONFIG, LOGIXIA_LOGGER_PREFIX, LogLevel, LogixiaLogger, LogixiaLoggerModule, LogixiaLoggerService, TextFormatter, createLogger, createLoggerService, createTraceMiddleware, extractTraceId, generateTraceId, getCurrentTraceId, isError, logger, normalizeError, runWithTraceId, serializeError, setTraceId, traceStorage };
+//# sourceMappingURL=index.mjs.map