@seedcord/services 0.7.1 → 0.8.0

package/dist/index.mjs

@@ -1,15 +1,94 @@
-import { a as SeedcordErrorCode, i as isSeedcordError, t as SeedcordError } from "./SeedcordError-E2D_RTuy.mjs";
-import { Envapter } from "envapt";
+import { createServer } from "http";
+import chalk from "chalk";
+import { EventEmitter } from "node:events";
+import { SeedcordErrorCode } from "@seedcord/errors";
+import { SeedcordError } from "@seedcord/errors/internal";
 import path from "node:path";
+import { Envapter } from "envapt";
 import winston, { createLogger, format, transports } from "winston";
 import fs from "node:fs";
 import stripAnsi from "strip-ansi";
 import TransportStream from "winston-transport";
 import { formatFilePath } from "@seedcord/utils";
-import chalk from "chalk";
-import { createServer } from "http";
-import { EventEmitter } from "node:events";
 
+//#region src/RateLimiter.ts
+const SWEEP_INTERVAL_MS = 6e4;
+/**
+* Tracks per-key usage windows and reports when a key is limited and when it frees up.
+*
+* Each key holds a sliding window of hit expiry times, and is limited once its live-hit count
+* reaches the window's `limit`. Expired hits are dropped on the next read, and a background sweep
+* drops fully-expired keys so the map does not grow without bound.
+*/
+var RateLimiter = class {
+	map = /* @__PURE__ */ new Map();
+	constructor() {
+		setInterval(() => {
+			this.sweep();
+		}, SWEEP_INTERVAL_MS).unref();
+	}
+	/** Number of keys currently tracked. */
+	get size() {
+		return this.map.size;
+	}
+	/**
+	* Records a hit for `key` and reports whether the key is now limited.
+	*
+	* @param key - The bucket to record against. The caller builds it from its own scope.
+	* @param window - The usage window to apply for this hit.
+	*/
+	hit(key, window) {
+		const now = Date.now();
+		const limit = Math.max(1, window.limit ?? 1);
+		const live = this.live(key, now);
+		if (live.length >= limit) {
+			this.map.set(key, live);
+			return {
+				limited: true,
+				expires: Math.min(...live)
+			};
+		}
+		const expires = now + window.delay;
+		live.push(expires);
+		this.map.set(key, live);
+		return {
+			limited: false,
+			expires
+		};
+	}
+	/**
+	* Reports whether `key` is limited right now without recording a hit.
+	*
+	* The read half of a peek-then-commit. A gate calls `peek` to decide whether to refuse, and
+	* `hit` to charge the slot only once it is the gate that let the request through.
+	*/
+	peek(key, window) {
+		const now = Date.now();
+		const limit = Math.max(1, window.limit ?? 1);
+		const live = this.live(key, now);
+		if (live.length >= limit) return {
+			limited: true,
+			expires: Math.min(...live)
+		};
+		return {
+			limited: false,
+			expires: now + window.delay
+		};
+	}
+	live(key, now) {
+		return (this.map.get(key) ?? []).filter((exp) => exp > now);
+	}
+	sweep() {
+		const now = Date.now();
+		for (const [key, live] of this.map) {
+			const kept = live.filter((exp) => exp > now);
+			if (kept.length === 0) this.map.delete(key);
+			else this.map.set(key, kept);
+		}
+	}
+};
+
+//#endregion
 //#region src/Logger/LogFormatter.ts
 /**
 * Formats log records for console and file outputs.
@@ -665,26 +744,13 @@ var Logger = class Logger {
 	channel;
 	registry = LoggerChannelRegistry.instance;
 	utils;
-	static instances = /* @__PURE__ */ new Map();
-	static instance(prefix, channel) {
-		const key = channel ? `${channel}::${prefix}` : prefix;
-		let instance = this.instances.get(key);
-		if (!instance) {
-			instance = new Logger(prefix, channel ? { channel } : void 0);
-			this.instances.set(key, instance);
-		}
-		return instance;
-	}
 	/**
-	* Configures global logger settings.
-	*
-	* Applies configuration to all channels and clears instance cache.
+	* Configures global logger settings, applied to all channels.
 	*
 	* @param config - Partial configuration to merge with defaults
 	*/
 	static configure(config) {
 		LoggerChannelRegistry.instance.configure(config);
-		this.instances.clear();
 	}
 	/**
 	* Creates a new Logger instance.
@@ -714,12 +780,12 @@ var Logger = class Logger {
 		});
 	}
 	/**
-	* Returns a new Logger instance configured for the specified channel. Loggers are cached per (label, channel) pair.
+	* Returns a new Logger for this label on the specified channel.
 	*
 	* @param channel - Channel name to use
 	*/
 	inChannel(channel) {
-		return Logger.instance(this.label, channel);
+		return new Logger(this.label, { channel });
 	}
 	/**
 	* Logs an error message with optional additional data.
@@ -786,75 +852,6 @@ var Logger = class Logger {
 	}
 };
 
-//#endregion
-//#region src/CooldownManager.ts
-const logger = new Logger("CooldownManager");
-/**
-* Lightweight utility for per-key cooldowns.
-*
-* Manages time-based restrictions on operations by key,
-* useful for rate limiting, command cooldowns, and spam prevention.
-*/
-var CooldownManager = class {
-	window;
-	Err;
-	msg;
-	map = /* @__PURE__ */ new Map();
-	/**
-	* Creates a new CooldownManager instance.
-	*
-	* @param opts - Configuration options for the cooldown behavior
-	*/
-	constructor(opts = {}) {
-		this.window = opts.cooldown ?? 1e3;
-		this.Err = opts.err ?? Error;
-		this.msg = opts.message ?? "Cooldown active";
-	}
-	/**
-	* Records usage timestamp for a key without any cooldown checks.
-	*
-	* @param key - The unique identifier for the cooldown entry
-	*/
-	set(key) {
-		this.map.set(key, Date.now());
-	}
-	/**
-	* Verifies cooldown status for a key and updates timestamp if not active.
-	*
-	* If the cooldown is still active, throws the configured error.
-	* If not active, updates the timestamp and returns successfully.
-	*
-	* @param key - The unique identifier to check cooldown for
-	* @throws An {@link Err} When the cooldown is still active for the given key
-	*/
-	check(key) {
-		const now = Date.now();
-		const last = this.map.get(key);
-		const remaining = this.window - (now - (last ?? 0));
-		if (Envapter.isDevelopment && remaining > 0) logger.debug(`${key} - ${remaining}ms remaining`);
-		if (last !== void 0 && remaining > 0) throw new this.Err(this.msg, remaining);
-		this.map.set(key, now);
-	}
-	/**
-	* Checks if a key is currently cooling down without updating timestamp.
-	*
-	* @param key - The unique identifier to check
-	* @returns True if the key is still cooling down, false otherwise
-	*/
-	isActive(key) {
-		const last = this.map.get(key);
-		return last !== void 0 && Date.now() - last < this.window;
-	}
-	/**
-	* Removes a key from the cooldown map.
-	*
-	* @param key - The unique identifier to remove (useful for manual resets)
-	*/
-	clear(key) {
-		this.map.delete(key);
-	}
-};
-
 //#endregion
 //#region src/StrictEventEmitter.ts
 /**
@@ -965,7 +962,7 @@ var StrictEventEmitter = class extends EventEmitter {
 			};
 			const onAbort = () => {
 				cleanup();
-				reject(new SeedcordError(1501));
+				reject(new SeedcordError(SeedcordErrorCode.EventEmitterWaitForAborted));
 			};
 			let timeoutId = null;
 			const cleanup = () => {
@@ -982,7 +979,7 @@ var StrictEventEmitter = class extends EventEmitter {
 				const timeoutMs = opts.timeoutMs;
 				timeoutId = setTimeout(() => {
 					cleanup();
-					reject(new SeedcordError(1502, [timeoutMs]));
+					reject(new SeedcordError(SeedcordErrorCode.EventEmitterWaitForTimeout, [timeoutMs]));
 				}, timeoutMs);
 			}
 		});
@@ -1026,7 +1023,7 @@ var CoordinatedLifecycle = class extends StrictEventEmitter {
 	addTask(phase, taskName, task, timeoutMs) {
 		if (!this.canAddTask()) return;
 		const tasks = this.tasksMap.get(phase);
-		if (!tasks) throw new SeedcordError(1104, [phase]);
+		if (!tasks) throw new SeedcordError(SeedcordErrorCode.LifecycleUnknownPhase, [phase]);
 		tasks.push({
 			name: taskName,
 			task,
@@ -1064,7 +1061,7 @@ var CoordinatedLifecycle = class extends StrictEventEmitter {
 		this.logger.info(`${chalk.bold.yellow("Running")} ${this.getTaskType()} phase ${chalk.bold.magenta(this.phaseEnum[phase])} with ${chalk.bold.cyan(tasks.length)} tasks`);
 		this.emitPhase(phase, "start");
 		const failures = (await this.executeTasksInPhase(phase, tasks)).filter((r) => r.status === "rejected").length;
-		if (failures > 0) throw new SeedcordError(1105, [this.phaseEnum[phase], failures]);
+		if (failures > 0) throw new SeedcordError(SeedcordErrorCode.LifecyclePhaseFailures, [this.phaseEnum[phase], failures]);
 		else this.logger.info(`Phase ${chalk.bold.magenta(this.phaseEnum[phase])} ${chalk.bold.green("completed successfully")}`);
 		this.emitPhase(phase, "complete");
 	}
@@ -1077,7 +1074,7 @@ var CoordinatedLifecycle = class extends StrictEventEmitter {
 		try {
 			await Promise.race([task.task(), new Promise((_, reject) => {
 				timeoutId = setTimeout(() => {
-					reject(new SeedcordError(1106, [task.name, task.timeout]));
+					reject(new SeedcordError(SeedcordErrorCode.LifecycleTaskTimeout, [task.name, task.timeout]));
 				}, task.timeout);
 			})]);
 			this.logger.info(`${chalk.italic("Completed")} task ${chalk.bold.cyan(task.name)} in phase ${chalk.bold.magenta(this.phaseEnum[phase])}`);
@@ -1179,7 +1176,7 @@ var CoordinatedShutdown = class extends CoordinatedLifecycle {
 	* @param phase - The shutdown phase from {@link ShutdownPhase}
 	* @param taskName - Unique identifier for the task
 	* @param task - Async function to execute
-	* @param timeoutMs - Task timeout in milliseconds {@default 5000}
+	* @param timeoutMs - Task timeout in milliseconds. {@default `5000`}
 	*/
 	addTask(phase, taskName, task, timeoutMs = 5e3) {
 		super.addTask(phase, taskName, task, timeoutMs);
@@ -1201,8 +1198,8 @@ var CoordinatedShutdown = class extends CoordinatedLifecycle {
 	* Tasks within each phase are executed in parallel for faster shutdown.
 	* Process exits with the specified code when complete.
 	*
-	* @param exitCode - Process exit code {@default 0}
-	* @param exitProcess - Whether to exit the process after shutdown {@default true}
+	* @param exitCode - Process exit code. {@default `0`}
+	* @param exitProcess - Whether to exit the process after shutdown. {@default `true`}
 	* @returns Promise that resolves when shutdown is complete
 	* @example
 	* ```typescript
@@ -1375,18 +1372,18 @@ var CoordinatedStartup = class extends CoordinatedLifecycle {
 	* @param phase - The startup phase from {@link StartupPhase}
 	* @param taskName - Unique identifier for the task
 	* @param task - Async function to execute
-	* @param timeoutMs - Task timeout in milliseconds {@default 10000}
+	* @param timeoutMs - Task timeout in milliseconds. {@default `10000`}
 	*/
 	addTask(phase, taskName, task, timeoutMs = 1e4) {
 		super.addTask(phase, taskName, task, timeoutMs);
 	}
 	canAddTask() {
-		if (this.hasStarted) throw new SeedcordError(1101);
-		if (this.isStartingUp) throw new SeedcordError(1102);
+		if (this.hasStarted) throw new SeedcordError(SeedcordErrorCode.LifecycleAddAfterCompletion);
+		if (this.isStartingUp) throw new SeedcordError(SeedcordErrorCode.LifecycleAddDuringRun);
 		return true;
 	}
 	canRemoveTask() {
-		if (this.isStartingUp) throw new SeedcordError(1103);
+		if (this.isStartingUp) throw new SeedcordError(SeedcordErrorCode.LifecycleRemoveDuringRun);
 		return true;
 	}
 	getTaskType() {
@@ -1453,7 +1450,7 @@ var CoordinatedStartup = class extends CoordinatedLifecycle {
 		try {
 			await Promise.race([task.task(), new Promise((_, reject) => {
 				timeoutId = setTimeout(() => {
-					reject(new SeedcordError(1106, [task.name, task.timeout]));
+					reject(new SeedcordError(SeedcordErrorCode.LifecycleTaskTimeout, [task.name, task.timeout]));
 				}, task.timeout);
 			})]);
 			this.logger.info(`${chalk.italic("Completed")} task ${chalk.bold.cyan(task.name)} in phase ${chalk.bold.magenta(StartupPhase[phase])}`);
@@ -1491,8 +1488,8 @@ var CoordinatedStartup = class extends CoordinatedLifecycle {
 //#endregion
 //#region src/index.ts
 /** Package version */
-const version = "0.7.1";
+const version = "0.8.0";
 
 //#endregion
-export { CooldownManager, CoordinatedLifecycle, CoordinatedShutdown, CoordinatedStartup, HealthCheck, Logger, LoggerChannelRegistry, LoggerUtilities, SeedcordErrorCode, ShutdownPhase, StartupPhase, StrictEventEmitter, isSeedcordError, version };
+export { CoordinatedLifecycle, CoordinatedShutdown, CoordinatedStartup, HealthCheck, Logger, LoggerChannelRegistry, LoggerUtilities, RateLimiter, ShutdownPhase, StartupPhase, StrictEventEmitter, version };
 //# sourceMappingURL=index.mjs.map