@lssm/example.lifecycle-cli 0.0.0-canary-20251217083314 → 1.41.0

package/dist/libs/logger/dist/formatters.js

@@ -1,163 +0,0 @@
-import { LogLevel } from "./types.js";
-
-//#region ../../libs/logger/dist/formatters.mjs
-const colors = {
-	reset: "\x1B[0m",
-	bright: "\x1B[1m",
-	dim: "\x1B[2m",
-	red: "\x1B[31m",
-	green: "\x1B[32m",
-	yellow: "\x1B[33m",
-	blue: "\x1B[34m",
-	magenta: "\x1B[35m",
-	cyan: "\x1B[36m",
-	white: "\x1B[37m",
-	gray: "\x1B[90m",
-	bgRed: "\x1B[41m",
-	bgYellow: "\x1B[43m"
-};
-const levelConfig = {
-	[LogLevel.TRACE]: {
-		color: colors.gray,
-		symbol: "○",
-		name: "TRACE"
-	},
-	[LogLevel.DEBUG]: {
-		color: colors.blue,
-		symbol: "●",
-		name: "DEBUG"
-	},
-	[LogLevel.INFO]: {
-		color: colors.green,
-		symbol: "●",
-		name: "INFO "
-	},
-	[LogLevel.WARN]: {
-		color: colors.yellow,
-		symbol: "▲",
-		name: "WARN "
-	},
-	[LogLevel.ERROR]: {
-		color: colors.red,
-		symbol: "✖",
-		name: "ERROR"
-	},
-	[LogLevel.FATAL]: {
-		color: colors.bgRed + colors.white,
-		symbol: "💀",
-		name: "FATAL"
-	}
-};
-var DevFormatter = class {
-	enableColors;
-	constructor(enableColors = true) {
-		this.enableColors = enableColors;
-	}
-	format(entry) {
-		const parts = [];
-		const config = levelConfig[entry.level];
-		const timestamp = this.formatTimestamp(entry.timestamp);
-		parts.push(this.colorize(timestamp, colors.gray));
-		const levelText = `${config.symbol} ${config.name}`;
-		parts.push(this.colorize(levelText, config.color));
-		if (entry.traceId) {
-			const traceInfo = this.formatTraceInfo(entry);
-			parts.push(this.colorize(traceInfo, colors.cyan));
-		}
-		parts.push(this.colorize(entry.message, colors.white));
-		if (entry.duration !== void 0) {
-			const durationText = `(${this.formatDuration(entry.duration)})`;
-			parts.push(this.colorize(durationText, colors.magenta));
-		}
-		let output = parts.join(" ");
-		if (entry.context && Object.keys(entry.context).length > 0) output += "\n" + this.formatContext(entry.context);
-		if (entry.metadata && Object.keys(entry.metadata).length > 0) output += "\n" + this.formatMetadata(entry.metadata);
-		if (entry.error) output += "\n" + this.formatError(entry.error);
-		if (entry.tags && entry.tags.length > 0) {
-			const tagsText = entry.tags.map((tag) => `#${tag}`).join(" ");
-			output += "\n" + this.colorize(`Tags: ${tagsText}`, colors.blue);
-		}
-		return output;
-	}
-	formatTimestamp(timestamp) {
-		return timestamp.toISOString().substring(11, 23);
-	}
-	formatTraceInfo(entry) {
-		const parts = [`trace:${entry.traceId?.substring(0, 8) || "unknown"}`];
-		if (entry.spanId && entry.spanId.length >= 8) parts.push(`span:${entry.spanId.substring(0, 8)}`);
-		if (entry.parentId && entry.parentId.length >= 8) parts.push(`parent:${entry.parentId.substring(0, 8)}`);
-		return `[${parts.join("|")}]`;
-	}
-	formatDuration(duration) {
-		if (duration < 1) return `${(duration * 1e3).toFixed(0)}μs`;
-		else if (duration < 1e3) return `${duration.toFixed(2)}ms`;
-		else return `${(duration / 1e3).toFixed(2)}s`;
-	}
-	formatContext(context) {
-		const formatted = this.formatObject(context, 2);
-		return this.colorize(`Context: ${formatted}`, colors.cyan);
-	}
-	formatMetadata(metadata) {
-		const formatted = this.formatObject(metadata, 2);
-		return this.colorize(`Metadata: ${formatted}`, colors.blue);
-	}
-	formatError(error) {
-		let output = this.colorize(`Error: ${error.name}: ${error.message}`, colors.red);
-		if (error.stack) {
-			const indentedStack = error.stack.split("\n").slice(1, 6).map((line) => `  ${line}`).join("\n");
-			output += "\n" + this.colorize(indentedStack, colors.gray);
-		}
-		return output;
-	}
-	formatObject(obj, indent = 0) {
-		const spaces = " ".repeat(indent);
-		const entries = Object.entries(obj);
-		if (entries.length === 0) return "{}";
-		if (entries[0] && typeof entries[0][1] !== "object") return `{ ${entries[0][0]}: ${this.formatValue(entries[0][1])} }`;
-		return `{\n${entries.map(([key, value]) => {
-			return `${spaces}  ${key}: ${this.formatValue(value, indent + 2)}`;
-		}).join("\n")}\n${spaces}}`;
-	}
-	formatValue(value, indent = 0) {
-		if (value === null) return "null";
-		if (value === void 0) return "undefined";
-		if (typeof value === "string") return `"${value}"`;
-		if (typeof value === "boolean" || typeof value === "number") return String(value);
-		if (value instanceof Date) return value.toISOString();
-		if (Array.isArray(value)) {
-			if (value.length === 0) return "[]";
-			return `[${value.map((v) => this.formatValue(v)).join(", ")}]`;
-		}
-		if (typeof value === "object") return this.formatObject(value, indent);
-		return String(value);
-	}
-	colorize(text, color) {
-		if (!this.enableColors) return text;
-		return `${color}${text}${colors.reset}`;
-	}
-};
-var ProductionFormatter = class {
-	format(entry) {
-		const logObject = {
-			timestamp: entry.timestamp,
-			level: entry.level,
-			message: entry.message
-		};
-		if (entry.traceId) logObject.traceId = entry.traceId;
-		if (entry.spanId) logObject.spanId = entry.spanId;
-		if (entry.parentId) logObject.parentId = entry.parentId;
-		if (entry.duration !== void 0) logObject.duration = entry.duration;
-		if (entry.context && Object.keys(entry.context).length > 0) logObject.context = entry.context;
-		if (entry.metadata && Object.keys(entry.metadata).length > 0) logObject.metadata = entry.metadata;
-		if (entry.error) logObject.error = {
-			name: entry.error.name,
-			message: entry.error.message,
-			stack: entry.error.stack
-		};
-		if (entry.tags && entry.tags.length > 0) logObject.tags = entry.tags;
-		return JSON.stringify(logObject);
-	}
-};
-
-//#endregion
-export { DevFormatter, ProductionFormatter };

package/dist/libs/logger/dist/index.js

@@ -1,7 +0,0 @@
-import { LogContext } from "./context.node.js";
-import { LogLevel } from "./types.js";
-import { Timer } from "./timer.js";
-import { Tracer } from "./tracer.node.js";
-import { DevFormatter, ProductionFormatter } from "./formatters.js";
-import { Logger } from "./logger.node.js";
-import "./elysia-plugin.js";

package/dist/libs/logger/dist/logger.node.js

@@ -1,189 +0,0 @@
-import { LogContext } from "./context.node.js";
-import { LogLevel } from "./types.js";
-import { TimerManager } from "./timer.js";
-import { Tracer } from "./tracer.node.js";
-import { DevFormatter, ProductionFormatter } from "./formatters.js";
-
-//#region ../../libs/logger/dist/logger.node.mjs
-var Logger = class Logger$1 {
-	config;
-	formatter;
-	context;
-	tracer;
-	timerManager;
-	constructor(config) {
-		this.config = {
-			level: LogLevel.INFO,
-			environment: process.env.NODE_ENV || "development",
-			enableTracing: true,
-			enableTiming: true,
-			enableContext: true,
-			enableColors: true,
-			maxContextDepth: 10,
-			timestampFormat: "iso",
-			...config
-		};
-		this.context = LogContext.getInstance();
-		this.tracer = new Tracer();
-		this.timerManager = new TimerManager();
-		this.formatter = this.config.environment === "production" ? new ProductionFormatter() : new DevFormatter(this.config.enableColors);
-	}
-	traceLog(message, metadata) {
-		this.log(LogLevel.TRACE, message, metadata);
-	}
-	debug(message, metadata) {
-		this.log(LogLevel.DEBUG, message, metadata);
-	}
-	info(message, metadata) {
-		this.log(LogLevel.INFO, message, metadata);
-	}
-	warn(message, metadata) {
-		this.log(LogLevel.WARN, message, metadata);
-	}
-	error(message, metadata, error) {
-		this.log(LogLevel.ERROR, message, metadata, error);
-	}
-	fatal(message, metadata, error) {
-		this.log(LogLevel.FATAL, message, metadata, error);
-	}
-	withContext(context, fn) {
-		return this.context.run(context, fn);
-	}
-	extendContext(additionalContext, fn) {
-		return this.context.extend(additionalContext, fn);
-	}
-	setContext(key, value) {
-		this.context.set(key, value);
-	}
-	getContext() {
-		return this.context.getContext();
-	}
-	trace = async (options, fn) => {
-		if (!this.config.enableTracing) return await fn();
-		return this.tracer.trace(options, fn);
-	};
-	getTraceId() {
-		return this.tracer.getCurrentTrace()?.traceId;
-	}
-	startSpan(options) {
-		if (!this.config.enableTracing) return null;
-		return this.tracer.startSpan(options);
-	}
-	finishSpan(spanId) {
-		if (!this.config.enableTracing) return;
-		return this.tracer.finishSpan(spanId);
-	}
-	addTraceMetadata(key, value) {
-		if (this.config.enableTracing) this.tracer.addMetadata(key, value);
-	}
-	addTraceTags(...tags) {
-		if (this.config.enableTracing) this.tracer.addTags(...tags);
-	}
-	startTimer(id) {
-		if (!this.config.enableTiming) return null;
-		return this.timerManager.start(id);
-	}
-	stopTimer(id) {
-		if (!this.config.enableTiming) return;
-		return this.timerManager.stop(id);
-	}
-	getTimer(id) {
-		return this.timerManager.get(id);
-	}
-	child(context) {
-		const childLogger = new Logger$1(this.config);
-		Object.entries(context).forEach(([key, value]) => {
-			childLogger.setContext(key, value);
-		});
-		return childLogger;
-	}
-	setLevel(level) {
-		this.config.level = level;
-	}
-	setFormatter(formatter) {
-		this.formatter = formatter;
-	}
-	async profile(operationName, fn, options) {
-		const timer = this.startTimer(`profile-${operationName}`);
-		const startTime = performance.now();
-		try {
-			const result = await this.tracer.trace({
-				operationType: "custom",
-				operationName: `profile:${operationName}`,
-				autoTiming: true
-			}, fn);
-			const duration = performance.now() - startTime;
-			timer?.stop();
-			const logLevel = options?.logLevel || LogLevel.DEBUG;
-			this.log(logLevel, `Profile: ${operationName} completed`, {
-				operation: operationName,
-				duration: `${duration.toFixed(2)}ms`,
-				result: options?.logResult ? result : "[result hidden]"
-			});
-			return result;
-		} catch (error) {
-			const duration = performance.now() - startTime;
-			timer?.stop();
-			this.error(`Profile: ${operationName} failed`, {
-				operation: operationName,
-				duration: `${duration.toFixed(2)}ms`,
-				error: error.message
-			}, error);
-			throw error;
-		}
-	}
-	logRequest(method, url, statusCode, duration) {
-		const level = this.getHttpLogLevel(statusCode);
-		const message = `${method.toUpperCase()} ${url}${statusCode ? ` ${statusCode}` : ""}`;
-		this.log(level, message, {
-			method,
-			url,
-			statusCode,
-			duration: duration ? `${duration.toFixed(2)}ms` : void 0,
-			type: "http_request"
-		});
-	}
-	async flush() {
-		this.timerManager.clear();
-	}
-	getStats() {
-		return {
-			activeTimers: this.timerManager.getActive().length,
-			activeSpans: this.tracer.getActiveSpans().length,
-			config: { ...this.config }
-		};
-	}
-	output(message, level) {
-		if (level >= LogLevel.ERROR) console.error(message);
-		else console.log(message);
-	}
-	log(level, message, metadata, error) {
-		if (level < this.config.level) return;
-		const currentTrace = this.config.enableTracing ? this.tracer.getCurrentTrace() : void 0;
-		const contextData = this.config.enableContext ? this.context.getContext() : void 0;
-		const entry = {
-			level,
-			message,
-			timestamp: /* @__PURE__ */ new Date(),
-			traceId: currentTrace?.traceId,
-			parentId: currentTrace?.parentId,
-			spanId: currentTrace?.spanId,
-			context: contextData,
-			metadata,
-			error,
-			tags: currentTrace?.tags
-		};
-		if (currentTrace?.metadata?.duration) entry.duration = currentTrace.metadata.duration;
-		const formatted = this.formatter.format(entry);
-		this.output(formatted, level);
-	}
-	getHttpLogLevel(statusCode) {
-		if (!statusCode) return LogLevel.INFO;
-		if (statusCode >= 500) return LogLevel.ERROR;
-		if (statusCode >= 400) return LogLevel.WARN;
-		return LogLevel.INFO;
-	}
-};
-
-//#endregion
-export { Logger };

package/dist/libs/logger/dist/timer.js

@@ -1,126 +0,0 @@
-//#region ../../libs/logger/dist/timer.mjs
-var Timer = class {
-	id;
-	startTime;
-	laps = [];
-	stopped = false;
-	stopTime;
-	constructor(id) {
-		this.id = id || crypto.randomUUID();
-		this.startTime = performance.now();
-	}
-	/**
-	* Stop the timer and return elapsed time in milliseconds
-	*/
-	stop() {
-		if (this.stopped) return this.getElapsed();
-		this.stopTime = performance.now();
-		this.stopped = true;
-		const elapsed = this.stopTime - this.startTime;
-		this.laps.push({
-			label: "stop",
-			time: this.stopTime,
-			elapsed
-		});
-		return elapsed;
-	}
-	/**
-	* Record a lap time and return elapsed time since start
-	*/
-	lap(label) {
-		if (this.stopped) return this.getElapsed();
-		const now = performance.now();
-		const elapsed = now - this.startTime;
-		this.laps.push({
-			label: label || `lap-${this.laps.length + 1}`,
-			time: now,
-			elapsed
-		});
-		return elapsed;
-	}
-	/**
-	* Get elapsed time without stopping the timer
-	*/
-	getElapsed() {
-		if (this.stopped && this.stopTime) return this.stopTime - this.startTime;
-		return performance.now() - this.startTime;
-	}
-	/**
-	* Get all recorded laps
-	*/
-	getLaps() {
-		return [...this.laps];
-	}
-	/**
-	* Get timer summary with total time and laps
-	*/
-	getSummary() {
-		return {
-			id: this.id,
-			totalTime: this.getElapsed(),
-			isRunning: !this.stopped,
-			laps: this.getLaps()
-		};
-	}
-	/**
-	* Reset the timer (starts a new timing session)
-	*/
-	reset() {
-		this.startTime = performance.now();
-		this.laps = [];
-		this.stopped = false;
-		this.stopTime = void 0;
-	}
-};
-/**
-* Utility class for managing multiple timers
-*/
-var TimerManager = class {
-	timers = /* @__PURE__ */ new Map();
-	/**
-	* Start a new timer
-	*/
-	start(id) {
-		const timer = new Timer(id);
-		this.timers.set(timer.id, timer);
-		return timer;
-	}
-	/**
-	* Get an existing timer
-	*/
-	get(id) {
-		return this.timers.get(id);
-	}
-	/**
-	* Stop and remove a timer
-	*/
-	stop(id) {
-		const timer = this.timers.get(id);
-		if (timer) {
-			const elapsed = timer.stop();
-			this.timers.delete(id);
-			return elapsed;
-		}
-	}
-	/**
-	* Get all active timers
-	*/
-	getActive() {
-		return Array.from(this.timers.values()).filter((timer) => !timer.getSummary().isRunning === false);
-	}
-	/**
-	* Clear all timers
-	*/
-	clear() {
-		this.timers.clear();
-	}
-	/**
-	* Get summary of all timers
-	*/
-	getSummary() {
-		return Array.from(this.timers.values()).map((timer) => timer.getSummary());
-	}
-};
-
-//#endregion
-export { Timer, TimerManager };

package/dist/libs/logger/dist/tracer.node.js

@@ -1,115 +0,0 @@
-import { LogContext } from "./context.node.js";
-import { Timer } from "./timer.js";
-
-//#region ../../libs/logger/dist/tracer.node.mjs
-var Tracer = class {
-	context;
-	activeSpans = /* @__PURE__ */ new Map();
-	constructor() {
-		this.context = LogContext.getInstance();
-	}
-	/**
-	* Start a new trace span
-	*/
-	startSpan(options) {
-		const parentTrace = this.context.getCurrentTrace();
-		const span = {
-			traceId: parentTrace?.traceId || this.generateTraceId(),
-			parentId: parentTrace?.spanId,
-			spanId: this.generateSpanId(),
-			operationType: options.operationType,
-			operationName: options.operationName,
-			startTime: performance.now(),
-			metadata: { ...options.metadata },
-			tags: [...options.tags || []]
-		};
-		this.activeSpans.set(span.spanId, span);
-		this.context.setTrace(span);
-		return span;
-	}
-	/**
-	* Finish a trace span
-	*/
-	finishSpan(spanId) {
-		const span = this.activeSpans.get(spanId);
-		if (!span) return;
-		const duration = performance.now() - span.startTime;
-		this.activeSpans.delete(spanId);
-		if (this.context.getCurrentTrace()?.spanId === spanId && span.parentId) {
-			const parentSpan = this.findSpanById(span.parentId);
-			if (parentSpan) this.context.setTrace(parentSpan);
-		}
-		return duration;
-	}
-	/**
-	* Execute a function within a trace span
-	*/
-	async trace(options, fn) {
-		const span = this.startSpan(options);
-		const timer = options.autoTiming !== false ? new Timer(`trace-${span.spanId}`) : void 0;
-		try {
-			const result = await fn();
-			const duration = this.finishSpan(span.spanId);
-			if (timer) timer.stop();
-			if (duration !== void 0) span.metadata.duration = duration;
-			return result;
-		} catch (error) {
-			span.metadata.error = {
-				name: error.name || "Unknown",
-				message: error.message || "Unknown error",
-				stack: error.stack
-			};
-			const duration = this.finishSpan(span.spanId);
-			span.metadata.duration = duration;
-			if (timer) timer.stop();
-			throw error;
-		}
-	}
-	/**
-	* Add metadata to current span
-	*/
-	addMetadata(key, value) {
-		const currentTrace = this.context.getCurrentTrace();
-		if (currentTrace) currentTrace.metadata[key] = value;
-	}
-	/**
-	* Add tags to current span
-	*/
-	addTags(...tags) {
-		const currentTrace = this.context.getCurrentTrace();
-		if (currentTrace) currentTrace.tags.push(...tags);
-	}
-	/**
-	* Get current trace context
-	*/
-	getCurrentTrace() {
-		return this.context.getCurrentTrace();
-	}
-	/**
-	* Get all active spans
-	*/
-	getActiveSpans() {
-		return Array.from(this.activeSpans.values());
-	}
-	/**
-	* Find a span by ID
-	*/
-	findSpanById(spanId) {
-		return this.activeSpans.get(spanId);
-	}
-	/**
-	* Generate a unique trace ID
-	*/
-	generateTraceId() {
-		return crypto.randomUUID().replace(/-/g, "");
-	}
-	/**
-	* Generate a unique span ID
-	*/
-	generateSpanId() {
-		return crypto.randomUUID().replace(/-/g, "").substring(0, 16);
-	}
-};
-
-//#endregion
-export { Tracer };

package/dist/libs/logger/dist/types.js

@@ -1,13 +0,0 @@
-//#region ../../libs/logger/dist/types.mjs
-let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
-	LogLevel$1[LogLevel$1["TRACE"] = 0] = "TRACE";
-	LogLevel$1[LogLevel$1["DEBUG"] = 1] = "DEBUG";
-	LogLevel$1[LogLevel$1["INFO"] = 2] = "INFO";
-	LogLevel$1[LogLevel$1["WARN"] = 3] = "WARN";
-	LogLevel$1[LogLevel$1["ERROR"] = 4] = "ERROR";
-	LogLevel$1[LogLevel$1["FATAL"] = 5] = "FATAL";
-	return LogLevel$1;
-}({});
-
-//#endregion
-export { LogLevel };