@lara-node/cache 0.1.0

package/dist/index.cjs

@@ -0,0 +1,796 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+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 __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
+let fs = require("fs");
+fs = __toESM(fs, 1);
+let path = require("path");
+path = __toESM(path, 1);
+let url = require("url");
+let crypto = require("crypto");
+crypto = __toESM(crypto, 1);
+let _lara_node_db = require("@lara-node/db");
+let _lara_node_core = require("@lara-node/core");
+//#region src/Models/Cache.ts
+var Cache$1 = class extends _lara_node_db.Model {
+	static {
+		this.table = "cache_store";
+	}
+	static {
+		this.primaryKey = "k";
+	}
+	static {
+		this.autoIncrement = false;
+	}
+	static {
+		this.fillable = [
+			"k",
+			"v",
+			"expires_at"
+		];
+	}
+	static {
+		this.hidden = [];
+	}
+	constructor(attributes = {}) {
+		super(attributes);
+	}
+};
+//#endregion
+//#region src/RateLimiter.ts
+/**
+* Rate Limiter - Laravel-style rate limiting using cache drivers
+*
+* Supports multiple algorithms:
+* - Fixed Window: Simple counter reset after window expires
+* - Sliding Window: More accurate rate limiting using timestamps
+* - Token Bucket: Gradual replenishment of tokens
+*
+* Usage:
+*   import { RateLimiter } from '@/cache/RateLimiter';
+*
+*   // Check if too many attempts
+*   const limiter = new RateLimiter();
+*   if (await limiter.tooManyAttempts('login:user@example.com', 5, 60)) {
+*     const retryAfter = await limiter.availableIn('login:user@example.com', 60);
+*     throw new Error(`Too many attempts. Retry after ${retryAfter} seconds.`);
+*   }
+*   await limiter.hit('login:user@example.com', 60);
+*/
+/**
+* Rate Limiter class using cache backend
+*/
+var RateLimiter = class {
+	constructor(config = {}) {
+		this.prefix = config.prefix ?? "rate_limiter:";
+		this.defaultMaxAttempts = config.maxAttempts ?? 60;
+		this.defaultDecaySeconds = config.decaySeconds ?? 60;
+	}
+	/**
+	* Get the cache key for a given key
+	*/
+	cacheKey(key) {
+		return `${this.prefix}${key}`;
+	}
+	/**
+	* Get the timer cache key for a given key (stores the reset timestamp)
+	*/
+	timerKey(key) {
+		return `${this.prefix}${key}:timer`;
+	}
+	/**
+	* Determine if the given key has been "accessed" too many times
+	*/
+	async tooManyAttempts(key, maxAttempts, _decaySeconds) {
+		const max = maxAttempts ?? this.defaultMaxAttempts;
+		if (await this.attempts(key) >= max) {
+			if (await Cache.has(this.timerKey(key))) return true;
+			await this.resetAttempts(key);
+		}
+		return false;
+	}
+	/**
+	* Increment the counter for a given key
+	* Returns the new number of attempts
+	*/
+	async hit(key, decaySeconds) {
+		const decay = decaySeconds ?? this.defaultDecaySeconds;
+		const cKey = this.cacheKey(key);
+		const tKey = this.timerKey(key);
+		const newAttempts = await this.attempts(key) + 1;
+		if (!await Cache.has(tKey)) {
+			const expiresAt = Math.floor(Date.now() / 1e3) + decay;
+			await Cache.set(tKey, expiresAt, decay);
+			await Cache.set(cKey, newAttempts, decay);
+		} else {
+			const expiresAt = await Cache.get(tKey);
+			const remainingTtl = expiresAt ? Math.max(1, expiresAt - Math.floor(Date.now() / 1e3)) : decay;
+			await Cache.set(cKey, newAttempts, remainingTtl);
+		}
+		return newAttempts;
+	}
+	/**
+	* Get the number of attempts for the given key
+	*/
+	async attempts(key) {
+		const val = await Cache.get(this.cacheKey(key));
+		return typeof val === "number" ? val : parseInt(val, 10) || 0;
+	}
+	/**
+	* Reset the number of attempts for the given key
+	*/
+	async resetAttempts(key) {
+		await Cache.del(this.cacheKey(key));
+		await Cache.del(this.timerKey(key));
+		return true;
+	}
+	/**
+	* Get the number of retries remaining
+	*/
+	async retriesLeft(key, maxAttempts) {
+		const max = maxAttempts ?? this.defaultMaxAttempts;
+		const attempts = await this.attempts(key);
+		return Math.max(0, max - attempts);
+	}
+	/**
+	* Clear the hits and lockout timer for the given key
+	*/
+	async clear(key) {
+		await this.resetAttempts(key);
+	}
+	/**
+	* Get the number of seconds until the key is accessible again
+	*/
+	async availableIn(key, _decaySeconds) {
+		const expiresAt = await Cache.get(this.timerKey(key));
+		if (!expiresAt) return 0;
+		const now = Math.floor(Date.now() / 1e3);
+		return Math.max(0, expiresAt - now);
+	}
+	/**
+	* Get the timestamp when the key becomes available again
+	*/
+	async availableAt(key) {
+		return await Cache.get(this.timerKey(key)) || Math.floor(Date.now() / 1e3);
+	}
+	/**
+	* Attempt to execute a callback if the rate limit allows
+	* Returns the callback result or throws if rate limited
+	*/
+	async attempt(key, maxAttempts, callback, decaySeconds) {
+		const decay = decaySeconds ?? this.defaultDecaySeconds;
+		if (await this.tooManyAttempts(key, maxAttempts, decay)) {
+			const retryAfter = await this.availableIn(key, decay);
+			throw new RateLimitExceededException(`Too many attempts. Please retry after ${retryAfter} seconds.`, retryAfter, maxAttempts);
+		}
+		await this.hit(key, decay);
+		return callback();
+	}
+	/**
+	* Get complete rate limit info for a key
+	*/
+	async getInfo(key, maxAttempts, decaySeconds) {
+		const max = maxAttempts ?? this.defaultMaxAttempts;
+		const decay = decaySeconds ?? this.defaultDecaySeconds;
+		const attempts = await this.attempts(key);
+		const remaining = Math.max(0, max - attempts);
+		const retryAfter = await this.availableIn(key, decay);
+		const resetsAt = await this.availableAt(key);
+		return {
+			limited: attempts >= max && retryAfter > 0,
+			attempts,
+			maxAttempts: max,
+			remaining,
+			retryAfter,
+			resetsAt
+		};
+	}
+	/**
+	* Execute a callback with rate limiting, using a limiter definition
+	*/
+	async limiter(name, key, maxAttempts, decaySeconds, callback) {
+		const fullKey = `${name}:${key}`;
+		return this.attempt(fullKey, maxAttempts, callback, decaySeconds);
+	}
+};
+/**
+* Exception thrown when rate limit is exceeded
+*/
+var RateLimitExceededException = class extends Error {
+	constructor(message, retryAfter, maxAttempts) {
+		super(message);
+		this.statusCode = 429;
+		this.name = "RateLimitExceededException";
+		this.retryAfter = retryAfter;
+		this.maxAttempts = maxAttempts;
+	}
+};
+const namedLimiters = /* @__PURE__ */ new Map();
+/**
+* Register a named rate limiter
+*/
+function defineRateLimiter(name, config) {
+	namedLimiters.set(name, config);
+}
+/**
+* Get a named rate limiter configuration
+*/
+function getNamedLimiter(name) {
+	const limiter = namedLimiters.get(name);
+	return limiter ? limiter() : null;
+}
+const rateLimiter = new RateLimiter();
+const RateLimiterFacade = {
+	/** Check if too many attempts have been made */
+	tooManyAttempts: (key, maxAttempts, decaySeconds) => rateLimiter.tooManyAttempts(key, maxAttempts, decaySeconds),
+	/** Increment the attempt counter */
+	hit: (key, decaySeconds) => rateLimiter.hit(key, decaySeconds),
+	/** Get current number of attempts */
+	attempts: (key) => rateLimiter.attempts(key),
+	/** Reset attempt counter */
+	resetAttempts: (key) => rateLimiter.resetAttempts(key),
+	/** Get remaining retries */
+	retriesLeft: (key, maxAttempts) => rateLimiter.retriesLeft(key, maxAttempts),
+	/** Clear rate limiter for key */
+	clear: (key) => rateLimiter.clear(key),
+	/** Get seconds until rate limit resets */
+	availableIn: (key, decaySeconds) => rateLimiter.availableIn(key, decaySeconds),
+	/** Get timestamp when rate limit resets */
+	availableAt: (key) => rateLimiter.availableAt(key),
+	/** Attempt to execute callback with rate limiting */
+	attempt: (key, maxAttempts, callback, decaySeconds) => rateLimiter.attempt(key, maxAttempts, callback, decaySeconds),
+	/** Get rate limit info for a key */
+	getInfo: (key, maxAttempts, decaySeconds) => rateLimiter.getInfo(key, maxAttempts, decaySeconds),
+	/** Define a named rate limiter */
+	define: defineRateLimiter,
+	/** Get named limiter config */
+	limiter: getNamedLimiter,
+	/** Execute with named limiter */
+	for: async (name, key, callback) => {
+		const config = getNamedLimiter(name);
+		if (!config) throw new Error(`Rate limiter [${name}] is not defined.`);
+		return rateLimiter.attempt(`${name}:${key}`, config.maxAttempts, callback, config.decaySeconds);
+	}
+};
+//#endregion
+//#region src/CacheManager.ts
+const __dirname$1 = path.default.dirname((0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+let _cacheWatchHook = null;
+function setCacheWatchHook(hook) {
+	_cacheWatchHook = hook;
+}
+const CacheWatcher = { record: (e) => {
+	if (_cacheWatchHook) try {
+		_cacheWatchHook(e);
+	} catch {}
+} };
+const APP_KEY = process.env.APP_KEY || "";
+const CIPHER = "aes-256-cbc";
+let ENCRYPTION_ENABLED = false;
+let ENCRYPTION_KEY = null;
+function deriveKeyFromAppKey(appKey) {
+	if (!appKey) return Buffer.alloc(0);
+	if (appKey.startsWith("base64:")) {
+		const b = appKey.slice(7);
+		return Buffer.from(b, "base64");
+	}
+	const buf = Buffer.from(appKey, "utf8");
+	if (buf.length === 32) return buf;
+	return crypto.default.createHash("sha256").update(buf).digest();
+}
+if (APP_KEY) try {
+	ENCRYPTION_KEY = deriveKeyFromAppKey(APP_KEY);
+	if (ENCRYPTION_KEY.length !== 32) {
+		console.warn("APP_KEY provided but did not yield 32 bytes; derived key length:", ENCRYPTION_KEY.length, "— disabling encryption");
+		ENCRYPTION_ENABLED = false;
+	} else ENCRYPTION_ENABLED = true;
+} catch (e) {
+	console.warn("Failed to initialize cache encryption, proceeding without encryption:", e);
+	ENCRYPTION_ENABLED = false;
+}
+else console.warn("No APP_KEY set; cache encryption is disabled. Set APP_KEY in your .env to enable encryption of cached values.");
+function hmacFor(ivB64, valueB64) {
+	if (!ENCRYPTION_KEY) return "";
+	return crypto.default.createHmac("sha256", ENCRYPTION_KEY).update(ivB64 + "|" + valueB64).digest("hex");
+}
+function encryptRaw(plain) {
+	if (!ENCRYPTION_ENABLED || !ENCRYPTION_KEY || ENCRYPTION_KEY.length !== 32) return plain;
+	const iv = crypto.default.randomBytes(16);
+	const cipher = crypto.default.createCipheriv(CIPHER, ENCRYPTION_KEY, iv);
+	const encrypted = Buffer.concat([cipher.update(Buffer.from(plain, "utf8")), cipher.final()]);
+	const ivB = iv.toString("base64");
+	const valB = encrypted.toString("base64");
+	const payload = {
+		iv: ivB,
+		value: valB,
+		mac: hmacFor(ivB, valB)
+	};
+	return JSON.stringify(payload);
+}
+function decryptRaw(payloadStr) {
+	if (!ENCRYPTION_ENABLED || !ENCRYPTION_KEY || ENCRYPTION_KEY.length !== 32) return payloadStr;
+	let payload;
+	try {
+		payload = JSON.parse(payloadStr);
+	} catch (e) {
+		return null;
+	}
+	if (!payload || !payload.iv || !payload.value || !payload.mac) return null;
+	const expected = hmacFor(payload.iv, payload.value);
+	if (!crypto.default.timingSafeEqual(Buffer.from(expected, "hex"), Buffer.from(payload.mac, "hex"))) throw new Error("Cache decryption failed: invalid MAC");
+	const iv = Buffer.from(payload.iv, "base64");
+	const enc = Buffer.from(payload.value, "base64");
+	const decipher = crypto.default.createDecipheriv(CIPHER, ENCRYPTION_KEY, iv);
+	return Buffer.concat([decipher.update(enc), decipher.final()]).toString("utf8");
+}
+const CACHE_PREFIX = process.env.CACHE_PREFIX ? String(process.env.CACHE_PREFIX) : process.env.APP_NAME || "app";
+function prefixed(key) {
+	if (!CACHE_PREFIX) return key;
+	return `${CACHE_PREFIX}:${key}`;
+}
+function stripPrefix(fullKey) {
+	if (!CACHE_PREFIX) return fullKey;
+	return fullKey.startsWith(CACHE_PREFIX + ":") ? fullKey.slice(CACHE_PREFIX.length + 1) : fullKey;
+}
+function generateCacheKey(...parts) {
+	return parts.filter((p) => p !== void 0 && p !== null).map((p) => p instanceof Date ? p.toISOString() : String(p).trim().replace(/\s+/g, "_")).join(":");
+}
+var FileCache = class {
+	constructor(baseDir) {
+		this.initialized = false;
+		this.dir = baseDir || path.default.resolve(__dirname$1, "../../tmp/cache");
+	}
+	async init() {
+		if (this.initialized) return;
+		await fs.default.promises.mkdir(this.dir, { recursive: true });
+		this.initialized = true;
+	}
+	filePath(key) {
+		const safe = encodeURIComponent(prefixed(key));
+		return path.default.join(this.dir, `${safe}.json`);
+	}
+	async get(key) {
+		await this.init();
+		const p = this.filePath(key);
+		try {
+			const raw = await fs.default.promises.readFile(p, "utf8");
+			const parsed = JSON.parse(raw);
+			if (parsed.expiresAt && Date.now() > parsed.expiresAt) {
+				try {
+					await fs.default.promises.unlink(p);
+				} catch (e) {}
+				return null;
+			}
+			const stored = parsed.value;
+			if (typeof stored === "string") {
+				const dec = decryptRaw(stored);
+				if (dec !== null) try {
+					return JSON.parse(dec);
+				} catch (e) {
+					return dec;
+				}
+				return stored;
+			}
+			return parsed.value;
+		} catch (e) {
+			return null;
+		}
+	}
+	async set(key, value, ttlSeconds) {
+		await this.init();
+		const p = this.filePath(key);
+		const expiresAt = ttlSeconds ? Date.now() + ttlSeconds * 1e3 : null;
+		const payload = {
+			value: encryptRaw(typeof value === "string" ? value : JSON.stringify(value)),
+			expiresAt
+		};
+		await fs.default.promises.writeFile(p, JSON.stringify(payload), "utf8");
+	}
+	async del(key) {
+		await this.init();
+		const p = this.filePath(key);
+		try {
+			await fs.default.promises.unlink(p);
+			return true;
+		} catch (e) {
+			return false;
+		}
+	}
+	async has(key) {
+		const v = await this.get(key);
+		return v !== null && v !== void 0;
+	}
+	async clear() {
+		await this.init();
+		const files = await fs.default.promises.readdir(this.dir);
+		await Promise.all(files.map((f) => fs.default.promises.unlink(path.default.join(this.dir, f)).catch(() => {})));
+	}
+	async keys() {
+		await this.init();
+		return (await fs.default.promises.readdir(this.dir)).filter((f) => f.endsWith(".json")).map((f) => decodeURIComponent(f.replace(/\.json$/, ""))).map(stripPrefix);
+	}
+};
+var DBCache = class {
+	constructor() {
+		this.initialized = false;
+	}
+	async init() {
+		if (this.initialized) return;
+		this.initialized = true;
+	}
+	now() {
+		return Date.now();
+	}
+	async get(key) {
+		await this.init();
+		const record = await Cache$1.where("k", prefixed(key)).first();
+		if (!record) return null;
+		const expiresAt = record.getAttribute ? record.getAttribute("expires_at") : record.expires_at;
+		if (expiresAt && this.now() > Number(expiresAt)) {
+			await this.del(key);
+			return null;
+		}
+		let rawVal = record.getAttribute ? record.getAttribute("v") : record.v;
+		if (typeof rawVal === "string") {
+			const dec = decryptRaw(rawVal);
+			if (dec !== null) try {
+				return JSON.parse(dec);
+			} catch {
+				return dec;
+			}
+			try {
+				return JSON.parse(rawVal);
+			} catch {
+				return rawVal;
+			}
+		}
+		return rawVal;
+	}
+	async set(key, value, ttlSeconds) {
+		await this.init();
+		const expiresAt = ttlSeconds ? Date.now() + ttlSeconds * 1e3 : null;
+		const stored = encryptRaw(typeof value === "string" ? value : JSON.stringify(value));
+		let record = await Cache$1.where("k", prefixed(key)).first();
+		if (record) if (record.setAttribute) {
+			record.setAttribute("v", stored);
+			record.setAttribute("expires_at", expiresAt);
+			await record.save();
+		} else {
+			record.v = stored;
+			record.expires_at = expiresAt;
+			await record.save();
+		}
+		else await Cache$1.create({
+			k: prefixed(key),
+			v: stored,
+			expires_at: expiresAt
+		});
+	}
+	async del(key) {
+		await this.init();
+		const record = await Cache$1.where("k", prefixed(key)).first();
+		if (!record) return false;
+		await record.delete(true);
+		return true;
+	}
+	async has(key) {
+		const v = await this.get(key);
+		return v !== null && v !== void 0;
+	}
+	async clear() {
+		await this.init();
+		const all = await Cache$1.query().get();
+		for (const rec of all) try {
+			await rec.delete(true);
+		} catch {}
+	}
+	async keys() {
+		await this.init();
+		return (await Cache$1.query().get()).map((r) => r.getAttribute ? r.getAttribute("k") : r.k).map(stripPrefix);
+	}
+};
+var RedisCache = class {
+	constructor() {
+		this.client = null;
+		this.initialized = false;
+	}
+	async init() {
+		if (this.initialized) return;
+		let createClient;
+		try {
+			createClient = (await import("redis")).createClient;
+		} catch (e) {
+			throw new Error("Redis driver selected (CACHE_DRIVER=redis) but \"redis\" package is not installed. Install it with `npm install redis`.");
+		}
+		const redisUrl = process.env.REDIS_URL || void 0;
+		const host = process.env.REDIS_HOST || void 0;
+		const port = process.env.REDIS_PORT ? parseInt(process.env.REDIS_PORT, 10) : void 0;
+		const password = process.env.REDIS_PASSWORD || void 0;
+		const opts = {};
+		if (redisUrl) opts.url = redisUrl;
+		if (host) {
+			opts.socket = { host };
+			if (port) opts.socket.port = port;
+		}
+		if (password) opts.password = password;
+		this.client = createClient(opts);
+		if (typeof this.client.connect === "function") await this.client.connect();
+		this.initialized = true;
+	}
+	async get(key) {
+		await this.init();
+		const res = await this.client.get(prefixed(key));
+		if (res === null) return null;
+		const dec = decryptRaw(res);
+		if (dec !== null) try {
+			return JSON.parse(dec);
+		} catch (e) {
+			return dec;
+		}
+		try {
+			return JSON.parse(res);
+		} catch (e) {
+			return res;
+		}
+	}
+	async set(key, value, ttlSeconds) {
+		await this.init();
+		const stored = encryptRaw(typeof value === "string" ? value : JSON.stringify(value));
+		if (ttlSeconds && ttlSeconds > 0) await this.client.set(prefixed(key), stored, { EX: ttlSeconds });
+		else await this.client.set(prefixed(key), stored);
+	}
+	async del(key) {
+		await this.init();
+		return await this.client.del(prefixed(key)) > 0;
+	}
+	async has(key) {
+		await this.init();
+		const exists = await this.client.exists(prefixed(key));
+		return exists === 1 || exists === true || exists > 0;
+	}
+	async clear() {
+		await this.init();
+		const pattern = CACHE_PREFIX ? `${CACHE_PREFIX}:*` : "*";
+		let cursor = "0";
+		do {
+			const res = await this.client.scan(cursor, {
+				MATCH: pattern,
+				COUNT: 200
+			});
+			cursor = res.cursor || res[0];
+			const keys = res.keys || res[1];
+			if (keys.length > 0) await this.client.del(keys);
+		} while (cursor !== "0" && String(cursor) !== "0");
+	}
+	async keys() {
+		await this.init();
+		const pattern = CACHE_PREFIX ? `${CACHE_PREFIX}:*` : "*";
+		const out = [];
+		let cursor = "0";
+		do {
+			const res = await this.client.scan(cursor, {
+				MATCH: pattern,
+				COUNT: 100
+			});
+			cursor = res.cursor || res[0];
+			const keys = res.keys || res[1];
+			for (const k of keys) out.push(stripPrefix(k));
+		} while (cursor !== "0");
+		return out;
+	}
+};
+var CacheManager = class {
+	constructor() {
+		this.driver = null;
+		this.initializing = null;
+	}
+	createDriver() {
+		const driver = (process.env.CACHE_DRIVER || "file").toLowerCase();
+		if (driver === "redis") return new RedisCache();
+		if (driver === "database" || driver === "db") return new DBCache();
+		return new FileCache();
+	}
+	async ensureInit() {
+		if (this.driver) return;
+		if (!this.initializing) {
+			this.driver = this.createDriver();
+			this.initializing = (async () => {
+				await this.driver.init();
+				this.initializing = null;
+			})();
+		}
+		await this.initializing;
+	}
+	async init() {
+		await this.ensureInit();
+	}
+	async get(key) {
+		await this.ensureInit();
+		return this.driver.get(key);
+	}
+	async set(key, value, ttlSeconds) {
+		await this.ensureInit();
+		return this.driver.set(key, value, ttlSeconds);
+	}
+	async del(key) {
+		await this.ensureInit();
+		return this.driver.del(key);
+	}
+	async has(key) {
+		await this.ensureInit();
+		return this.driver.has(key);
+	}
+	async clear() {
+		await this.ensureInit();
+		return this.driver.clear();
+	}
+	async keys() {
+		await this.ensureInit();
+		return this.driver.keys();
+	}
+};
+const manager = new CacheManager();
+const Cache = {
+	get: async (k) => {
+		const value = await manager.get(k);
+		CacheWatcher.record({
+			type: "get",
+			key: k,
+			hit: value !== null,
+			value
+		});
+		return value;
+	},
+	set: async (k, v, ttlSeconds) => {
+		await manager.set(k, v, ttlSeconds);
+		CacheWatcher.record({
+			type: "set",
+			key: k,
+			value: v,
+			ttlSeconds
+		});
+	},
+	del: async (k) => {
+		const result = await manager.del(k);
+		CacheWatcher.record({
+			type: "del",
+			key: k
+		});
+		return result;
+	},
+	has: async (k) => {
+		const result = await manager.has(k);
+		CacheWatcher.record({
+			type: "has",
+			key: k,
+			hit: result
+		});
+		return result;
+	},
+	clear: async () => {
+		await manager.clear();
+		CacheWatcher.record({
+			type: "clear",
+			key: ""
+		});
+	},
+	keys: () => manager.keys(),
+	forget: async (k) => {
+		const result = await manager.del(k);
+		CacheWatcher.record({
+			type: "del",
+			key: k
+		});
+		return result;
+	},
+	flush: async () => {
+		await manager.clear();
+		CacheWatcher.record({
+			type: "clear",
+			key: ""
+		});
+	},
+	remember: async (key, ttlSeconds, callback) => {
+		const cached = await manager.get(key);
+		if (cached !== null) {
+			CacheWatcher.record({
+				type: "get",
+				key,
+				hit: true,
+				value: cached,
+				ttlSeconds
+			});
+			return cached;
+		}
+		CacheWatcher.record({
+			type: "get",
+			key,
+			hit: false,
+			ttlSeconds
+		});
+		const value = await callback();
+		await manager.set(key, value, ttlSeconds);
+		CacheWatcher.record({
+			type: "set",
+			key,
+			value,
+			ttlSeconds
+		});
+		return value;
+	}
+};
+const getCacheDriverName = () => {
+	return (process.env.CACHE_DRIVER || "file").toLowerCase();
+};
+const getCacheDriver = () => manager;
+const initCache = async () => manager.init();
+const cacheGet = async (k) => manager.get(k);
+const cacheSet = async (k, v, ttlSeconds) => manager.set(k, v, ttlSeconds);
+const cacheDel = async (k) => manager.del(k);
+const cacheHas = async (k) => manager.has(k);
+const cacheClear = async () => manager.clear();
+const cacheKeys = async () => manager.keys();
+const cacheDelPrefix = async (prefix) => {
+	const matches = (await manager.keys()).filter((k) => k.startsWith(prefix));
+	await Promise.all(matches.map((k) => manager.del(k).catch(() => {})));
+	return matches.length;
+};
+//#endregion
+//#region src/CacheServiceProvider.ts
+var CacheServiceProvider = class extends _lara_node_core.ServiceProvider {
+	register() {
+		this.container.singleton("cache", () => getCacheDriver());
+	}
+	async boot() {
+		const skip = (process.env.SKIP_CACHE ?? "").toLowerCase();
+		if (skip === "1" || skip === "true") {
+			console.warn("[Cache] SKIP_CACHE set — skipping cache initialization");
+			return;
+		}
+		try {
+			await initCache();
+			console.log(`[Cache] Initialized (driver=${getCacheDriverName()})`);
+		} catch (err) {
+			console.error("[Cache] Initialization failed:", err.message);
+		}
+	}
+};
+//#endregion
+exports.Cache = Cache;
+exports.CacheServiceProvider = CacheServiceProvider;
+exports.RateLimitExceededException = RateLimitExceededException;
+exports.RateLimiter = RateLimiter;
+exports.RateLimiterFacade = RateLimiterFacade;
+exports.cacheClear = cacheClear;
+exports.cacheDel = cacheDel;
+exports.cacheDelPrefix = cacheDelPrefix;
+exports.cacheGet = cacheGet;
+exports.cacheHas = cacheHas;
+exports.cacheKeys = cacheKeys;
+exports.cacheSet = cacheSet;
+exports.defineRateLimiter = defineRateLimiter;
+exports.generateCacheKey = generateCacheKey;
+exports.getCacheDriver = getCacheDriver;
+exports.getCacheDriverName = getCacheDriverName;
+exports.getNamedLimiter = getNamedLimiter;
+exports.initCache = initCache;
+exports.setCacheWatchHook = setCacheWatchHook;