alepha 0.12.1 → 0.13.1

package/dist/lock-redis/index.cjs

@@ -1,113 +0,0 @@
-let alepha = require("alepha");
-let alepha_lock = require("alepha/lock");
-let alepha_topic = require("alepha/topic");
-let alepha_logger = require("alepha/logger");
-let alepha_redis = require("alepha/redis");
-
-//#region src/topic-redis/providers/RedisTopicProvider.ts
-const envSchema = alepha.t.object({ REDIS_TOPIC_PREFIX: alepha.t.text({ default: "topic" }) });
-var RedisTopicProvider = class extends alepha_topic.TopicProvider {
-	env = (0, alepha.$env)(envSchema);
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	redisProvider = (0, alepha.$inject)(alepha_redis.RedisProvider);
-	redisSubscriberProvider = (0, alepha.$inject)(alepha_redis.RedisSubscriberProvider);
-	log = (0, alepha_logger.$logger)();
-	start = (0, alepha.$hook)({
-		on: "start",
-		handler: async () => {
-			const subscribers = this.subscribers();
-			if (subscribers.length) {
-				await Promise.all(subscribers.map((fn) => fn()));
-				for (const subscriber of subscribers) this.log.debug(`Subscribed to topic '${subscriber.name}'`);
-			}
-		}
-	});
-	prefix(queue) {
-		return `${this.env.REDIS_TOPIC_PREFIX}:${queue}`;
-	}
-	/**
-	* Publish a message to a topic.
-	*/
-	async publish(topic, message) {
-		await this.redisProvider.publisher.publish(this.prefix(topic), message);
-	}
-	/**
-	* Subscribe to a topic.
-	*/
-	async subscribe(name, callback) {
-		const topic = this.prefix(name);
-		await this.redisSubscriberProvider.subscriber.subscribe(topic, callback);
-		return () => this.unsubscribe(name, callback);
-	}
-	/**
-	* Unsubscribe from a topic.
-	*/
-	async unsubscribe(name, callback) {
-		const topic = this.prefix(name);
-		await this.redisSubscriberProvider.subscriber.unsubscribe(topic, callback);
-	}
-};
-
-//#endregion
-//#region src/topic-redis/index.ts
-/**
-* Plugin for Alepha Topic that provides Redis pub/sub capabilities.
-*
-* @see {@link RedisTopicProvider}
-* @module alepha.topic.redis
-*/
-const AlephaTopicRedis = (0, alepha.$module)({
-	name: "alepha.topic.redis",
-	services: [RedisTopicProvider],
-	register: (alepha$1) => alepha$1.with({
-		optional: true,
-		provide: alepha_topic.TopicProvider,
-		use: RedisTopicProvider
-	}).with(alepha_topic.AlephaTopic)
-});
-
-//#endregion
-//#region src/lock-redis/providers/RedisLockProvider.ts
-var RedisLockProvider = class {
-	log = (0, alepha_logger.$logger)();
-	redisProvider = (0, alepha.$inject)(alepha_redis.RedisProvider);
-	async set(key, value, nx, px) {
-		const options = { GET: true };
-		if (px) options.expiration = {
-			type: "PX",
-			value: px
-		};
-		if (nx) options.condition = "NX";
-		return (await this.redisProvider.set(key, value, options)).toString("utf-8");
-	}
-	async del(...keys) {
-		await this.redisProvider.del(keys);
-	}
-};
-
-//#endregion
-//#region src/lock-redis/index.ts
-/**
-* Plugin for Alepha that provides a locking mechanism.
-*
-* @see {@link RedisLockProvider}
-* @module alepha.lock.redis
-*/
-const AlephaLockRedis = (0, alepha.$module)({
-	name: "alepha.lock.redis",
-	services: [RedisLockProvider, RedisTopicProvider],
-	register: (alepha$1) => alepha$1.with({
-		optional: true,
-		provide: alepha_lock.LockTopicProvider,
-		use: RedisTopicProvider
-	}).with({
-		optional: true,
-		provide: alepha_lock.LockProvider,
-		use: RedisLockProvider
-	}).with(alepha_lock.AlephaLock)
-});
-
-//#endregion
-exports.AlephaLockRedis = AlephaLockRedis;
-exports.RedisLockProvider = RedisLockProvider;
-//# sourceMappingURL=index.cjs.map

package/dist/lock-redis/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","names":["t","TopicProvider","Alepha","RedisProvider","RedisSubscriberProvider","alepha","TopicProvider","AlephaTopic","RedisProvider","options: RedisSetOptions","alepha","LockTopicProvider","LockProvider","AlephaLock"],"sources":["../../src/topic-redis/providers/RedisTopicProvider.ts","../../src/topic-redis/index.ts","../../src/lock-redis/providers/RedisLockProvider.ts","../../src/lock-redis/index.ts"],"sourcesContent":["import { $env, $hook, $inject, Alepha, t } from \"alepha\";\nimport { $logger } from \"alepha/logger\";\nimport { RedisProvider, RedisSubscriberProvider } from \"alepha/redis\";\nimport {\n  type SubscribeCallback,\n  TopicProvider,\n  type UnSubscribeFn,\n} from \"alepha/topic\";\n\nconst envSchema = t.object({\n  REDIS_TOPIC_PREFIX: t.text({\n    default: \"topic\",\n  }),\n});\n\nexport class RedisTopicProvider extends TopicProvider {\n  protected readonly env = $env(envSchema);\n  protected readonly alepha = $inject(Alepha);\n  protected readonly redisProvider = $inject(RedisProvider);\n  protected readonly redisSubscriberProvider = $inject(RedisSubscriberProvider);\n\n  protected readonly log = $logger();\n\n  protected readonly start = $hook({\n    on: \"start\",\n    handler: async () => {\n      const subscribers = this.subscribers();\n      if (subscribers.length) {\n        await Promise.all(subscribers.map((fn) => fn()));\n        for (const subscriber of subscribers) {\n          this.log.debug(`Subscribed to topic '${subscriber.name}'`);\n        }\n      }\n    },\n  });\n\n  public prefix(queue: string): string {\n    return `${this.env.REDIS_TOPIC_PREFIX}:${queue}`;\n  }\n\n  /**\n   * Publish a message to a topic.\n   */\n  public async publish(topic: string, message: string): Promise<void> {\n    await this.redisProvider.publisher.publish(this.prefix(topic), message);\n  }\n\n  /**\n   * Subscribe to a topic.\n   */\n  public async subscribe(\n    name: string,\n    callback: SubscribeCallback,\n  ): Promise<UnSubscribeFn> {\n    const topic = this.prefix(name);\n    await this.redisSubscriberProvider.subscriber.subscribe(topic, callback);\n\n    return () => this.unsubscribe(name, callback);\n  }\n\n  /**\n   * Unsubscribe from a topic.\n   */\n  public async unsubscribe(\n    name: string,\n    callback?: SubscribeCallback,\n  ): Promise<void> {\n    const topic = this.prefix(name);\n\n    await this.redisSubscriberProvider.subscriber.unsubscribe(topic, callback);\n  }\n}\n","import { $module, type Alepha } from \"alepha\";\nimport { AlephaTopic, TopicProvider } from \"alepha/topic\";\nimport { RedisTopicProvider } from \"./providers/RedisTopicProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./providers/RedisTopicProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Plugin for Alepha Topic that provides Redis pub/sub capabilities.\n *\n * @see {@link RedisTopicProvider}\n * @module alepha.topic.redis\n */\nexport const AlephaTopicRedis = $module({\n  name: \"alepha.topic.redis\",\n  services: [RedisTopicProvider],\n  register: (alepha: Alepha): Alepha =>\n    alepha\n      .with({\n        optional: true,\n        provide: TopicProvider,\n        use: RedisTopicProvider,\n      })\n      .with(AlephaTopic),\n});\n","import { $inject } from \"alepha\";\nimport type { LockProvider } from \"alepha/lock\";\nimport { $logger } from \"alepha/logger\";\nimport { RedisProvider, type RedisSetOptions } from \"alepha/redis\";\n\nexport class RedisLockProvider implements LockProvider {\n  protected readonly log = $logger();\n  protected readonly redisProvider = $inject(RedisProvider);\n\n  public async set(\n    key: string,\n    value: string,\n    nx?: boolean,\n    px?: number,\n  ): Promise<string> {\n    const options: RedisSetOptions = {\n      GET: true, // all the secrets of $lock is based on this\n    };\n\n    if (px) {\n      options.expiration = {\n        type: \"PX\",\n        value: px,\n      };\n    }\n\n    if (nx) {\n      options.condition = \"NX\";\n    }\n\n    const resp = await this.redisProvider.set(key, value, options);\n\n    return resp.toString(\"utf-8\");\n  }\n\n  public async del(...keys: string[]): Promise<void> {\n    await this.redisProvider.del(keys);\n  }\n}\n","import { $module, type Alepha } from \"alepha\";\nimport { AlephaLock, LockProvider, LockTopicProvider } from \"alepha/lock\";\nimport { RedisTopicProvider } from \"alepha/topic/redis\";\nimport { RedisLockProvider } from \"./providers/RedisLockProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./providers/RedisLockProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Plugin for Alepha that provides a locking mechanism.\n *\n * @see {@link RedisLockProvider}\n * @module alepha.lock.redis\n */\nexport const AlephaLockRedis = $module({\n  name: \"alepha.lock.redis\",\n  services: [RedisLockProvider, RedisTopicProvider],\n  register: (alepha: Alepha) =>\n    alepha\n      .with({\n        optional: true,\n        provide: LockTopicProvider,\n        use: RedisTopicProvider,\n      })\n      .with({\n        optional: true,\n        provide: LockProvider,\n        use: RedisLockProvider,\n      })\n      .with(AlephaLock),\n});\n"],"mappings":";;;;;;;AASA,MAAM,YAAYA,SAAE,OAAO,EACzB,oBAAoBA,SAAE,KAAK,EACzB,SAAS,SACV,CAAC,EACH,CAAC;AAEF,IAAa,qBAAb,cAAwCC,2BAAc;CACpD,AAAmB,uBAAW,UAAU;CACxC,AAAmB,6BAAiBC,cAAO;CAC3C,AAAmB,oCAAwBC,2BAAc;CACzD,AAAmB,8CAAkCC,qCAAwB;CAE7E,AAAmB,kCAAe;CAElC,AAAmB,0BAAc;EAC/B,IAAI;EACJ,SAAS,YAAY;GACnB,MAAM,cAAc,KAAK,aAAa;AACtC,OAAI,YAAY,QAAQ;AACtB,UAAM,QAAQ,IAAI,YAAY,KAAK,OAAO,IAAI,CAAC,CAAC;AAChD,SAAK,MAAM,cAAc,YACvB,MAAK,IAAI,MAAM,wBAAwB,WAAW,KAAK,GAAG;;;EAIjE,CAAC;CAEF,AAAO,OAAO,OAAuB;AACnC,SAAO,GAAG,KAAK,IAAI,mBAAmB,GAAG;;;;;CAM3C,MAAa,QAAQ,OAAe,SAAgC;AAClE,QAAM,KAAK,cAAc,UAAU,QAAQ,KAAK,OAAO,MAAM,EAAE,QAAQ;;;;;CAMzE,MAAa,UACX,MACA,UACwB;EACxB,MAAM,QAAQ,KAAK,OAAO,KAAK;AAC/B,QAAM,KAAK,wBAAwB,WAAW,UAAU,OAAO,SAAS;AAExE,eAAa,KAAK,YAAY,MAAM,SAAS;;;;;CAM/C,MAAa,YACX,MACA,UACe;EACf,MAAM,QAAQ,KAAK,OAAO,KAAK;AAE/B,QAAM,KAAK,wBAAwB,WAAW,YAAY,OAAO,SAAS;;;;;;;;;;;;ACrD9E,MAAa,uCAA2B;CACtC,MAAM;CACN,UAAU,CAAC,mBAAmB;CAC9B,WAAW,aACTC,SACG,KAAK;EACJ,UAAU;EACV,SAASC;EACT,KAAK;EACN,CAAC,CACD,KAAKC,yBAAY;CACvB,CAAC;;;;ACtBF,IAAa,oBAAb,MAAuD;CACrD,AAAmB,kCAAe;CAClC,AAAmB,oCAAwBC,2BAAc;CAEzD,MAAa,IACX,KACA,OACA,IACA,IACiB;EACjB,MAAMC,UAA2B,EAC/B,KAAK,MACN;AAED,MAAI,GACF,SAAQ,aAAa;GACnB,MAAM;GACN,OAAO;GACR;AAGH,MAAI,GACF,SAAQ,YAAY;AAKtB,UAFa,MAAM,KAAK,cAAc,IAAI,KAAK,OAAO,QAAQ,EAElD,SAAS,QAAQ;;CAG/B,MAAa,IAAI,GAAG,MAA+B;AACjD,QAAM,KAAK,cAAc,IAAI,KAAK;;;;;;;;;;;;ACnBtC,MAAa,sCAA0B;CACrC,MAAM;CACN,UAAU,CAAC,mBAAmB,mBAAmB;CACjD,WAAW,aACTC,SACG,KAAK;EACJ,UAAU;EACV,SAASC;EACT,KAAK;EACN,CAAC,CACD,KAAK;EACJ,UAAU;EACV,SAASC;EACT,KAAK;EACN,CAAC,CACD,KAAKC,uBAAW;CACtB,CAAC"}

package/dist/lock-redis/index.d.cts

@@ -1,24 +0,0 @@
-import * as alepha0 from "alepha";
-import * as alepha_logger0 from "alepha/logger";
-import { LockProvider } from "alepha/lock";
-import { RedisProvider } from "alepha/redis";
-
-//#region src/lock-redis/providers/RedisLockProvider.d.ts
-declare class RedisLockProvider implements LockProvider {
-  protected readonly log: alepha_logger0.Logger;
-  protected readonly redisProvider: RedisProvider;
-  set(key: string, value: string, nx?: boolean, px?: number): Promise<string>;
-  del(...keys: string[]): Promise<void>;
-}
-//#endregion
-//#region src/lock-redis/index.d.ts
-/**
- * Plugin for Alepha that provides a locking mechanism.
- *
- * @see {@link RedisLockProvider}
- * @module alepha.lock.redis
- */
-declare const AlephaLockRedis: alepha0.Service<alepha0.Module>;
-//#endregion
-export { AlephaLockRedis, RedisLockProvider };
-//# sourceMappingURL=index.d.cts.map

package/dist/logger/index.cjs

@@ -1,521 +0,0 @@
-let alepha = require("alepha");
-let alepha_datetime = require("alepha/datetime");
-
-//#region src/logger/providers/LogDestinationProvider.ts
-var LogDestinationProvider = class {};
-
-//#endregion
-//#region src/logger/providers/LogFormatterProvider.ts
-var LogFormatterProvider = class {};
-
-//#endregion
-//#region src/logger/services/Logger.ts
-var Logger = class {
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	formatter = (0, alepha.$inject)(LogFormatterProvider);
-	destination = (0, alepha.$inject)(LogDestinationProvider);
-	dateTimeProvider = (0, alepha.$inject)(alepha_datetime.DateTimeProvider);
-	levels = {
-		SILENT: -1,
-		ERROR: 0,
-		WARN: 1,
-		INFO: 2,
-		DEBUG: 3,
-		TRACE: 4
-	};
-	service;
-	module;
-	app;
-	appLogLevel = "INFO";
-	logLevel = "INFO";
-	constructor(service, module$1) {
-		this.service = service;
-		this.module = module$1;
-		this.app = this.alepha.env.APP_NAME;
-	}
-	get context() {
-		return this.alepha.context.get("context");
-	}
-	get level() {
-		const stateLogLevel = this.alepha.state.get("alepha.logger.level");
-		if (stateLogLevel && stateLogLevel !== this.appLogLevel) {
-			this.appLogLevel = stateLogLevel;
-			this.logLevel = this.parseLevel(this.appLogLevel, this.module);
-		}
-		return this.logLevel;
-	}
-	parseLevel(level, app) {
-		const parts = level.toLowerCase().split(/[,;]/);
-		for (const part of parts) {
-			const trimmedPart = part.trim();
-			if (!trimmedPart) continue;
-			if (trimmedPart.includes(":") || trimmedPart.includes("=")) {
-				const [modulePattern, levelValue] = trimmedPart.split(/[:=]/);
-				const trimmedModule = modulePattern.trim();
-				const trimmedLevel = levelValue?.trim();
-				if (!trimmedLevel) continue;
-				if (this.matchesPattern(app, trimmedModule)) try {
-					return this.asLogLevel(trimmedLevel);
-				} catch (error) {
-					throw new alepha.AlephaError(`Invalid log level '${levelValue?.trim()}' for module pattern '${trimmedModule}'`);
-				}
-			}
-		}
-		for (const part of parts) {
-			const trimmedPart = part.trim();
-			if (!trimmedPart) continue;
-			if (!trimmedPart.includes(":") && !trimmedPart.includes("=")) try {
-				return this.asLogLevel(trimmedPart);
-			} catch (error) {
-				throw new Error(`Invalid global log level "${trimmedPart}"`);
-			}
-		}
-		return "INFO";
-	}
-	matchesPattern(moduleName, pattern) {
-		if (pattern.includes("*")) {
-			const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*");
-			return (/* @__PURE__ */ new RegExp(`^${regexPattern}`)).test(moduleName);
-		}
-		return moduleName.startsWith(pattern);
-	}
-	asLogLevel(something) {
-		const level = something.trim().toUpperCase();
-		if (this.levels[level] !== void 0) return level;
-		throw new alepha.AlephaError(`Invalid log level: ${something}`);
-	}
-	error(message, data) {
-		this.log("ERROR", message, data);
-	}
-	warn(message, data) {
-		this.log("WARN", message, data);
-	}
-	info(message, data) {
-		this.log("INFO", message, data);
-	}
-	debug(message, data) {
-		this.log("DEBUG", message, data);
-	}
-	trace(message, data) {
-		this.log("TRACE", message, data);
-	}
-	log(level, message, data) {
-		let _message = "";
-		if (typeof message === "string") _message = message;
-		else if (typeof data === "string") _message = data;
-		let _data;
-		if (typeof data === "object" && !!data) _data = data;
-		else if (typeof message === "object" && message) _data = message;
-		const logEntry = {
-			level,
-			message: _message,
-			data: _data,
-			context: this.context,
-			service: this.service,
-			module: this.module,
-			app: this.app,
-			timestamp: this.dateTimeProvider.nowMillis()
-		};
-		if (this.levels[level] > this.levels[this.level]) {
-			this.emit(logEntry);
-			return;
-		}
-		const formatted = this.formatter.format(logEntry);
-		this.emit(logEntry, formatted);
-		this.destination.write(formatted, logEntry);
-	}
-	emit(entry, message) {
-		this.alepha.events.emit("log", {
-			message,
-			entry
-		}, { catch: true }).catch(() => null);
-	}
-};
-
-//#endregion
-//#region src/logger/descriptors/$logger.ts
-/**
-* Create a logger.
-*
-* `name` is optional, by default it will use the name of the service.
-*
-* @example
-* ```ts
-* import { $logger } from "alepha";
-*
-* class MyService {
-* 	log = $logger();
-*
-*   constructor() {
-*     this.log.info("Service initialized");
-*     // print something like '[23:45:53.326] INFO <app.MyService>: Service initialized'
-*   }
-* }
-* ```
-*/
-const $logger = (options = {}) => {
-	const { alepha: alepha$1, service, module: module$1 } = (0, alepha.$context)();
-	return (0, alepha.$inject)(Logger, {
-		lifetime: "transient",
-		args: [options.name ?? service?.name, module$1?.name ?? alepha$1.env.MODULE_NAME ?? "app"]
-	});
-};
-$logger[alepha.KIND] = Logger;
-
-//#endregion
-//#region src/logger/providers/ConsoleDestinationProvider.ts
-var ConsoleDestinationProvider = class extends LogDestinationProvider {
-	write(message) {
-		console.log(message);
-	}
-};
-
-//#endregion
-//#region src/logger/providers/JsonFormatterProvider.ts
-var JsonFormatterProvider = class extends LogFormatterProvider {
-	format(entry) {
-		const json = {
-			level: entry.level,
-			message: entry.message,
-			context: entry.context,
-			service: entry.service,
-			module: entry.module,
-			app: entry.app,
-			time: entry.timestamp
-		};
-		if (entry.data instanceof Error) json.error = this.formatJsonError(entry.data);
-		else json.data = entry.data;
-		return JSON.stringify(json);
-	}
-	formatJsonError(error) {
-		return {
-			name: error.name,
-			message: error.message,
-			stack: error.stack,
-			cause: error.cause instanceof Error ? this.formatJsonError(error.cause) : void 0
-		};
-	}
-};
-
-//#endregion
-//#region src/logger/providers/MemoryDestinationProvider.ts
-var MemoryDestinationProvider = class extends LogDestinationProvider {
-	entries = [];
-	options = { maxEntries: 1e3 };
-	write(formatted, entry) {
-		this.entries.push({
-			...entry,
-			formatted
-		});
-		if (this.entries.length > this.options.maxEntries) this.entries = this.entries.slice(-Math.floor(this.options.maxEntries * .8));
-	}
-	get logs() {
-		return [...this.entries];
-	}
-	clear() {
-		this.entries = [];
-	}
-};
-
-//#endregion
-//#region src/logger/providers/RawFormatterProvider.ts
-var RawFormatterProvider = class extends LogFormatterProvider {
-	format(entry) {
-		let output = "";
-		output += `${entry.message}`;
-		if (entry.data instanceof Error) {
-			output += `\n${entry.data.message}`;
-			let cause = entry.data.cause;
-			while (cause instanceof Error) {
-				output += `\nCaused by: ${cause.message}`;
-				cause = cause.cause;
-			}
-		}
-		return output;
-	}
-};
-
-//#endregion
-//#region src/logger/providers/ConsoleColorProvider.ts
-const envSchema$1 = alepha.t.object({
-	NO_COLOR: alepha.t.optional(alepha.t.text()),
-	FORCE_COLOR: alepha.t.optional(alepha.t.text())
-});
-var ConsoleColorProvider = class ConsoleColorProvider {
-	static COLORS = {
-		RESET: "\x1B[0m",
-		BLACK: "\x1B[30m",
-		RED: "\x1B[31m",
-		GREEN: "\x1B[32m",
-		ORANGE: "\x1B[33m",
-		BLUE: "\x1B[34m",
-		PURPLE: "\x1B[35m",
-		CYAN: "\x1B[36m",
-		GREY_LIGHT: "\x1B[37m",
-		GREY_LIGHT_BOLD: "\x1B[1;37m",
-		GREY_DARK: "\x1B[90m",
-		GREY_DARK_BOLD: "\x1B[1;90m",
-		WHITE: "\x1B[97m",
-		WHITE_BOLD: "\x1B[1;97m",
-		SILENT: "",
-		ERROR: "\x1B[31m",
-		WARN: "\x1B[33m",
-		INFO: "\x1B[32m",
-		DEBUG: "\x1B[34m",
-		TRACE: "\x1B[90m"
-	};
-	env = (0, alepha.$env)(envSchema$1);
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	enabled = true;
-	constructor() {
-		this.enabled = this.isEnabled();
-	}
-	isEnabled() {
-		if (this.env.NO_COLOR) return false;
-		if (this.env.FORCE_COLOR) return true;
-		return !this.alepha.isProduction();
-	}
-	set(color, text, reset = ConsoleColorProvider.COLORS.RESET) {
-		if (!this.enabled) return text;
-		return `${ConsoleColorProvider.COLORS[color]}${text}${reset}`;
-	}
-};
-
-//#endregion
-//#region src/logger/providers/SimpleFormatterProvider.ts
-var SimpleFormatterProvider = class extends LogFormatterProvider {
-	color = (0, alepha.$inject)(ConsoleColorProvider);
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	format(entry) {
-		const { data, timestamp } = entry;
-		let output = "";
-		let details = "";
-		const isError = data instanceof Error;
-		if (isError) details = this.formatError(data);
-		else if (data) try {
-			details = JSON.stringify(data);
-		} catch {
-			details = "[Unserializable Object]";
-		}
-		output += this.color.set("GREY_DARK", `[${this.formatTimestamp(timestamp)}]`);
-		output += " ";
-		output += this.color.set(entry.level, entry.level.toUpperCase());
-		output += " ";
-		if (entry.app) {
-			output += this.color.set("GREY_DARK", `${entry.app}`);
-			output += " ";
-		}
-		if (entry.context) {
-			output += this.color.set("GREY_DARK", `(${this.formatContext(entry.context)})`);
-			output += " ";
-		}
-		const module$1 = this.color.set("GREY_LIGHT", `${entry.module}.`);
-		const service = this.color.set(this.alepha.isBrowser() ? "RESET" : "WHITE", entry.service);
-		output += `<${module$1}${service}>`;
-		if (entry.message) output += `: ${this.color.set("CYAN", entry.message)}`;
-		else output += ":";
-		if (details) if (isError) output += ` \n${details}`;
-		else output += ` ${this.color.set("GREY_DARK", details)}`;
-		return output;
-	}
-	formatTimestamp(timestamp) {
-		const d = new Date(timestamp);
-		const h = d.getHours();
-		const m = d.getMinutes();
-		const s = d.getSeconds();
-		const ms = d.getMilliseconds();
-		return `${this.pad2(h)}:${this.pad2(m)}:${this.pad2(s)}.${this.pad3(ms)}`;
-	}
-	pad2 = (n) => (n < 10 ? "0" : "") + n;
-	pad3 = (n) => n < 10 ? `00${n}` : n < 100 ? `0${n}` : `${n}`;
-	/**
-	* Avoid to display the whole UUID in development mode
-	*/
-	formatContext(context) {
-		if (this.alepha.isProduction()) return context;
-		return context.slice(0, 8);
-	}
-	formatError(error) {
-		if (this.alepha.isBrowser()) {
-			setTimeout(() => {
-				console.error(error);
-			});
-			return "";
-		}
-		let str = error.stack ?? error.message;
-		const anyError = error;
-		while (anyError.cause && anyError.cause instanceof Error) {
-			str += `\nCaused by: ${anyError.cause.stack ?? anyError.cause.message}`;
-			anyError.cause = anyError.cause.cause;
-		}
-		return str;
-	}
-};
-
-//#endregion
-//#region src/logger/schemas/logEntrySchema.ts
-const logEntrySchema = alepha.t.object({
-	level: alepha.t.enum([
-		"SILENT",
-		"TRACE",
-		"DEBUG",
-		"INFO",
-		"WARN",
-		"ERROR"
-	]),
-	message: alepha.t.text({ size: "rich" }),
-	service: alepha.t.text(),
-	module: alepha.t.text(),
-	context: alepha.t.optional(alepha.t.text()),
-	app: alepha.t.optional(alepha.t.text()),
-	data: alepha.t.optional(alepha.t.any()),
-	timestamp: alepha.t.number()
-});
-
-//#endregion
-//#region src/logger/index.ts
-/**
-* Minimalist logger module for Alepha.
-*
-* It offers a global logger interface (info, warn, ...) via the `$logger` descriptor.
-*
-* ```ts
-* import { $logger } from "alepha/logger";
-*
-* class App {
-*   log = $logger();
-* }
-* ```
-*
-* ### Formatting and Destinations
-*
-* `AlephaLogger` is **extensible**, destinations and formatters can be added or replaced.
-*
-* Default log destinations are:
-* - ConsoleDestinationProvider: logs to the console.
-* - MemoryDestinationProvider: stores logs in memory for later retrieval.
-*
-* Default log formatters are:
-* - JsonFormatterProvider: formats logs as JSON.
-* - SimpleFormatterProvider: formats logs as simple text (with colors when possible).
-* - RawFormatterProvider: formats logs as raw text without any formatting.
-*
-* ### Event Emission
-*
-* The logger emits 'log' events that can be listened to by external code, allowing for custom log processing and destinations.
-*
-* ```ts
-* class CustomDestination {
-*   onLog = $hook({
-*     on: "log",
-*     handler: (ev) => {
-*       // ev.message (formatted message)
-*       // ev.entry (level, raw message, ...)
-*     }
-*   });
-* }
-* ```
-*
-* ### Log Level
-*
-* You can configure the log level and format via environment variables:
-*
-* - `LOG_LEVEL`: Sets the default log level for the application.
-* - `LOG_FORMAT`: Sets the default log format for the application.
-*
-* ```bash
-* LOG_LEVEL=debug LOG_FORMAT=json node src/index.ts
-* ```
-*
-* Log level is also available in the state as `logLevel`, which can be used to dynamically change the log level at runtime.
-* ```ts
-* alepha.state.set("alepha.logger.level", "debug");
-* ```
-*
-* Log level is $module aware, meaning you can set different log levels for different modules.
-*
-* **Module-specific configuration:**
-* - `LOG_LEVEL=my.module.name:debug,info` - debug for `my.module.name` (and submodules), info for others
-* - `LOG_LEVEL=alepha:trace,my.app:error,info` - trace for alepha modules, error for my.app modules, info for others
-*
-* **Wildcard patterns (NEW):**
-* - `LOG_LEVEL=alepha.*:debug,info` - debug for all alepha submodules
-* - `LOG_LEVEL=*.test:silent,*.core:trace,info` - silent for test modules, trace for core modules
-*/
-const AlephaLogger = (0, alepha.$module)({
-	name: "alepha.logger",
-	descriptors: [$logger],
-	services: [
-		Logger,
-		ConsoleDestinationProvider,
-		MemoryDestinationProvider,
-		JsonFormatterProvider,
-		SimpleFormatterProvider,
-		RawFormatterProvider
-	],
-	register: (alepha$1) => {
-		const env = alepha$1.parseEnv(envSchema);
-		const getLogDestinationProvider = () => {
-			if (alepha$1.isTest() && !env.LOG_LEVEL) {
-				const printOnError = (ev) => {
-					if (ev.task?.result?.state === "fail") {
-						const output = alepha$1.inject(MemoryDestinationProvider);
-						for (const log of output.logs) console.log(log.formatted);
-					}
-				};
-				try {
-					alepha$1.state.get("alepha.test.afterEach")?.(printOnError);
-					alepha$1.state.get("alepha.test.onTestFinished")?.(printOnError);
-				} catch {}
-				return MemoryDestinationProvider;
-			}
-			return ConsoleDestinationProvider;
-		};
-		const getLogFormatterProvider = () => {
-			if (env.LOG_FORMAT) {
-				if (env.LOG_FORMAT === "json") return JsonFormatterProvider;
-				if (env.LOG_FORMAT === "raw") return RawFormatterProvider;
-				return SimpleFormatterProvider;
-			}
-			if (alepha$1.isProduction() && !alepha$1.isBrowser()) return JsonFormatterProvider;
-			return SimpleFormatterProvider;
-		};
-		alepha$1.with({
-			optional: true,
-			provide: LogDestinationProvider,
-			use: getLogDestinationProvider()
-		});
-		alepha$1.with({
-			optional: true,
-			provide: LogFormatterProvider,
-			use: getLogFormatterProvider()
-		});
-		alepha$1.state.set("alepha.logger", alepha$1.inject(Logger, {
-			lifetime: "transient",
-			args: ["Alepha", "alepha.core"]
-		}));
-		alepha$1.state.set("alepha.logger.level", env.LOG_LEVEL ?? (alepha$1.isTest() ? "trace" : "info"));
-	}
-});
-const envSchema = alepha.t.object({
-	LOG_LEVEL: alepha.t.optional(alepha.t.text({ lowercase: true })),
-	LOG_FORMAT: alepha.t.optional(alepha.t.enum([
-		"json",
-		"pretty",
-		"raw"
-	], { lowercase: true }))
-});
-
-//#endregion
-exports.$logger = $logger;
-exports.AlephaLogger = AlephaLogger;
-exports.ConsoleColorProvider = ConsoleColorProvider;
-exports.ConsoleDestinationProvider = ConsoleDestinationProvider;
-exports.JsonFormatterProvider = JsonFormatterProvider;
-exports.LogDestinationProvider = LogDestinationProvider;
-exports.LogFormatterProvider = LogFormatterProvider;
-exports.Logger = Logger;
-exports.MemoryDestinationProvider = MemoryDestinationProvider;
-exports.SimpleFormatterProvider = SimpleFormatterProvider;
-exports.logEntrySchema = logEntrySchema;
-//# sourceMappingURL=index.cjs.map