@warlock.js/cache 5.19.1 → 5.21.0

package/esm/drivers/memory-cache-driver.mjs

@@ -1,31 +1,52 @@
-import { cosineSimilarity } from "../utils.mjs";
+import { cosineSimilarity, parseTtl } from "../utils.mjs";
 import { BaseCacheDriver } from "./base-cache-driver.mjs";
-import { get, set, unset } from "@mongez/reinforcements";
+import { InMemoryTagIndex } from "./in-memory-tag-index.mjs";
 
 //#region ../cache/src/drivers/memory-cache-driver.ts
+/**
+* Clone non-primitive values so cached state can't be mutated through
+* references held by callers. Primitives are immutable and returned as-is.
+*/
+function cloneValue(value) {
+	if (value === null || value === void 0) return value;
+	const type = typeof value;
+	if (type === "string" || type === "number" || type === "boolean") return value;
+	return structuredClone(value);
+}
 var MemoryCacheDriver = class extends BaseCacheDriver {
+	/**
+	* Read-only object view of the stored entries, keyed by parsed key.
+	* Kept for introspection; the values are the live stored wrappers.
+	*/
+	get data() {
+		return Object.fromEntries(this.entries);
+	}
 	/**
 	* {@inheritdoc}
 	*/
 	constructor() {
 		super();
 		this.name = "memory";
-		this.data = {};
-		this.temporaryData = {};
-		this.accessOrder = [];
+		this.entries = /* @__PURE__ */ new Map();
+		this.expiry = /* @__PURE__ */ new Map();
 		this.vectorIndex = /* @__PURE__ */ new Map();
+		this.tagIndex = new InMemoryTagIndex();
+		this.slidingExpiration = false;
 		this.startCleanup();
 	}
 	/**
-	* Start the cleanup process whenever a data that has a cache key is set
+	* Start the cleanup process for entries that carry a finite ttl
 	*/
 	startCleanup() {
 		if (this.cleanupInterval) clearInterval(this.cleanupInterval);
 		this.cleanupInterval = setInterval(async () => {
 			const now = Date.now();
-			for (const [key, entry] of Object.entries(this.temporaryData)) if (entry.expiresAt <= now) {
-				await this.remove(entry.key);
-				delete this.temporaryData[key];
+			const expiredKeys = [];
+			for (const [key, expiresAt] of this.expiry) if (expiresAt <= now) expiredKeys.push(key);
+			for (const key of expiredKeys) {
+				const expiresAt = this.expiry.get(key);
+				if (expiresAt === void 0 || expiresAt > now) continue;
+				this.dropEntry(key);
 				this.log("expired", key);
 				await this.emit("expired", { key });
 			}
@@ -33,44 +54,94 @@ var MemoryCacheDriver = class extends BaseCacheDriver {
 		this.cleanupInterval.unref();
 	}
 	/**
+	* Delete an entry and every side record (expiry, vector). Synchronous.
+	*/
+	dropEntry(parsedKey) {
+		this.entries.delete(parsedKey);
+		this.expiry.delete(parsedKey);
+		this.vectorIndex.delete(parsedKey);
+	}
+	/**
+	* Raw, synchronous read of a live entry. An expired entry is deleted and
+	* reported as missing. Never slides TTLs, never emits, never touches LRU order.
+	*/
+	readLive(parsedKey) {
+		const entry = this.entries.get(parsedKey);
+		if (!entry) return;
+		if (entry.expiresAt !== void 0 && entry.expiresAt <= Date.now()) {
+			this.dropEntry(parsedKey);
+			return;
+		}
+		return entry;
+	}
+	/**
+	* Mark an entry as most recently used (only tracked when `maxSize` is set).
+	*/
+	touch(parsedKey, entry) {
+		if (!this.options.maxSize) return;
+		this.entries.delete(parsedKey);
+		this.entries.set(parsedKey, entry);
+	}
+	/**
+	* Invoked on a live read hit, before the value is returned. Runs only from
+	* `get()` after the expiry check, so an expired entry is never resurrected,
+	* and never from the internal existence check used by `onConflict`.
+	*/
+	onRead(parsedKey, entry) {
+		if (!this.slidingExpiration) return;
+		const rawTtl = entry.ttl ?? this.options.ttl;
+		const ttl = rawTtl !== void 0 ? parseTtl(rawTtl) : void 0;
+		if (ttl && Number.isFinite(ttl)) {
+			entry.expiresAt = this.getExpiresAt(ttl);
+			this.expiry.set(parsedKey, entry.expiresAt);
+		}
+	}
+	/**
 	* {@inheritdoc}
 	*/
 	async removeNamespace(namespace) {
 		this.log("clearing", namespace);
 		namespace = this.parseKey(namespace);
-		unset(this.data, [namespace]);
-		if (namespace === "") this.vectorIndex.clear();
-		else {
+		this.tagIndex.removeNamespace(namespace);
+		if (namespace === "") {
+			this.entries.clear();
+			this.expiry.clear();
+			this.vectorIndex.clear();
+		} else {
 			const prefix = namespace + ".";
-			for (const k of [...this.vectorIndex.keys()]) if (k === namespace || k.startsWith(prefix)) this.vectorIndex.delete(k);
+			for (const key of [...this.entries.keys()]) if (key === namespace || key.startsWith(prefix)) this.dropEntry(key);
 		}
 		this.log("cleared", namespace);
 		return this;
 	}
 	/**
 	* {@inheritdoc}
+	*
+	* The conditional check and the write run with no `await` in between, so
+	* `onConflict` decisions are atomic within the process.
 	*/
 	async set(key, value, ttlOrOptions) {
 		const parsedKey = this.parseKey(key);
 		const { ttl, tags, onConflict, vector, staleAt } = this.resolveSetOptions(ttlOrOptions);
 		this.log("caching", parsedKey);
-		const existingValue = onConflict === "upsert" ? null : await this.get(key);
-		const exists = existingValue !== null;
-		if (onConflict === "create" && exists) return {
+		const existing = onConflict === "create" || onConflict === "update" ? this.readLive(parsedKey) : void 0;
+		if (onConflict === "create" && existing) return {
 			wasSet: false,
-			existing: existingValue
+			existing: cloneValue(existing.data)
 		};
-		if (onConflict === "update" && !exists) return {
+		if (onConflict === "update" && !existing) return {
 			wasSet: false,
 			existing: null
 		};
-		const data = this.prepareDataForStorage(value, ttl, staleAt);
-		if (ttl) this.setTemporaryData(key, parsedKey, ttl);
-		set(this.data, parsedKey, data);
-		this.trackAccess(parsedKey);
-		if (!exists && this.options.maxSize) await this.enforceMaxSize();
-		if (tags && tags.length > 0) await this.applyTags(key, tags);
+		const data = this.prepareDataForStorage(cloneValue(value), ttl, staleAt);
+		this.entries.delete(parsedKey);
+		this.entries.set(parsedKey, data);
+		if (data.expiresAt !== void 0 && Number.isFinite(data.expiresAt)) this.expiry.set(parsedKey, data.expiresAt);
+		else this.expiry.delete(parsedKey);
 		if (vector) this.vectorIndex.set(parsedKey, vector.slice());
+		else this.vectorIndex.delete(parsedKey);
+		this.enforceMaxSize(parsedKey);
+		if (tags && tags.length > 0) await this.applyTags(key, tags);
 		this.log("cached", parsedKey);
 		await this.emit("set", {
 			key: parsedKey,
@@ -85,38 +156,101 @@ var MemoryCacheDriver = class extends BaseCacheDriver {
 	}
 	/**
 	* {@inheritdoc}
+	*
+	* The check and the delete run synchronously (no `await` between them), so
+	* the compare-and-delete is atomic within the process.
+	*/
+	async deleteIfEquals(key, expected) {
+		const parsedKey = this.parseKey(key);
+		const entry = this.readLive(parsedKey);
+		if (!entry || entry.data !== expected) return false;
+		await this.remove(key);
+		return true;
+	}
+	/**
+	* {@inheritdoc}
+	*
+	* Read, add and write run synchronously (no `await` in between), so
+	* concurrent increments in this process never lose an update. An existing
+	* entry keeps its expiry; a missing key starts from 0 with the default TTL.
+	*/
+	async increment(key, value = 1) {
+		const parsedKey = this.parseKey(key);
+		const entry = this.readLive(parsedKey);
+		const current = entry ? entry.data : 0;
+		if (typeof current !== "number") throw new Error(`Cannot increment non-numeric value for key: ${parsedKey}`);
+		const newValue = current + value;
+		if (entry) {
+			entry.data = newValue;
+			this.touch(parsedKey, entry);
+		} else {
+			const data = this.prepareDataForStorage(newValue, this.ttl);
+			this.entries.set(parsedKey, data);
+			if (data.expiresAt !== void 0 && Number.isFinite(data.expiresAt)) this.expiry.set(parsedKey, data.expiresAt);
+			this.enforceMaxSize(parsedKey);
+		}
+		await this.emit("set", {
+			key: parsedKey,
+			value: newValue,
+			ttl: entry?.ttl ?? this.ttl
+		});
+		return newValue;
+	}
+	/**
+	* {@inheritdoc}
+	*
+	* Read and delete run synchronously, so a value is handed out exactly once
+	* even when concurrent callers pull the same key.
+	*/
+	async pull(key) {
+		const parsedKey = this.parseKey(key);
+		const entry = this.readLive(parsedKey);
+		if (!entry) {
+			await this.emit("miss", { key: parsedKey });
+			return null;
+		}
+		this.dropEntry(parsedKey);
+		const value = cloneValue(entry.data);
+		await this.emit("hit", {
+			key: parsedKey,
+			value
+		});
+		await this.emit("removed", { key: parsedKey });
+		return value;
+	}
+	/**
+	* {@inheritdoc}
 	*/
 	async get(key) {
 		const parsedKey = this.parseKey(key);
 		this.log("fetching", parsedKey);
-		const value = get(this.data, parsedKey);
-		if (!value) {
+		const entry = this.readLive(parsedKey);
+		if (!entry) {
 			this.log("notFound", parsedKey);
 			await this.emit("miss", { key: parsedKey });
 			return null;
 		}
-		const result = await this.parseCachedData(parsedKey, value);
-		if (result === null) await this.emit("miss", { key: parsedKey });
-		else {
-			this.trackAccess(parsedKey);
-			await this.emit("hit", {
-				key: parsedKey,
-				value: result
-			});
-		}
+		this.onRead(parsedKey, entry);
+		this.touch(parsedKey, entry);
+		const result = await this.parseCachedData(parsedKey, entry);
+		await this.emit("hit", {
+			key: parsedKey,
+			value: result
+		});
 		return result;
 	}
 	/**
-	* Read the raw {@link CacheData} wrapper, including `staleAt` metadata.
+	* Read the raw {@link CacheData} wrapper (cloned), including `staleAt` metadata.
 	* Returns `null` for missing or expired entries so the SWR flow can branch
 	* cleanly. Does not emit `hit`/`miss` events — that's `get()`'s job.
 	*/
 	async getEntry(key) {
-		const parsedKey = this.parseKey(key);
-		const entry = get(this.data, parsedKey);
+		const entry = this.readLive(this.parseKey(key));
 		if (!entry) return null;
-		if (entry.expiresAt !== void 0 && entry.expiresAt <= Date.now()) return null;
-		return entry;
+		return {
+			...entry,
+			data: cloneValue(entry.data)
+		};
 	}
 	/**
 	* {@inheritdoc}
@@ -124,76 +258,65 @@ var MemoryCacheDriver = class extends BaseCacheDriver {
 	async remove(key) {
 		const parsedKey = this.parseKey(key);
 		this.log("removing", parsedKey);
-		unset(this.data, [parsedKey]);
-		delete this.temporaryData[parsedKey];
-		this.removeFromAccessOrder(parsedKey);
-		this.vectorIndex.delete(parsedKey);
+		this.dropEntry(parsedKey);
 		this.log("removed", parsedKey);
 		await this.emit("removed", { key: parsedKey });
 	}
 	/**
 	* {@inheritdoc}
+	*
+	* Synchronous in-process set — concurrent tagged writes never drop members.
 	*/
-	async flush() {
-		this.log("flushing");
-		if (this.options.globalPrefix) this.removeNamespace("");
-		else {
-			this.data = {};
-			this.accessOrder = [];
-			this.vectorIndex.clear();
-		}
-		this.log("flushed");
-		await this.emit("flushed");
+	async tagAdd(tagKey, members) {
+		this.tagIndex.add(this.parseKey(tagKey), members);
 	}
 	/**
-	* Set the temporary data
+	* {@inheritdoc}
 	*/
-	setTemporaryData(key, parsedKey, ttl) {
-		this.temporaryData[parsedKey] = {
-			key: JSON.stringify(key),
-			expiresAt: Date.now() + ttl * 1e3
-		};
+	async tagMembers(tagKey) {
+		return this.tagIndex.members(this.parseKey(tagKey));
 	}
 	/**
-	* Track access for LRU eviction
+	* {@inheritdoc}
 	*/
-	trackAccess(key) {
-		if (!this.options.maxSize) return;
-		const index = this.accessOrder.indexOf(key);
-		if (index > -1) this.accessOrder.splice(index, 1);
-		this.accessOrder.push(key);
+	async tagRemove(tagKey, members) {
+		this.tagIndex.remove(this.parseKey(tagKey), members);
 	}
 	/**
-	* Remove key from access order tracking
+	* {@inheritdoc}
 	*/
-	removeFromAccessOrder(key) {
-		const index = this.accessOrder.indexOf(key);
-		if (index > -1) this.accessOrder.splice(index, 1);
+	async tagDelete(tagKey) {
+		this.tagIndex.delete(this.parseKey(tagKey));
 	}
 	/**
-	* Enforce max size by evicting least recently used items.
-	*
-	* Recomputes the live cache size on every iteration — a single snapshot at
-	* the top of the loop would go stale and cause this routine to evict every
-	* entry in `accessOrder` (including the just-inserted key).
+	* {@inheritdoc}
 	*/
-	async enforceMaxSize() {
-		if (!this.options.maxSize) return;
-		while (this.getCacheSize() > this.options.maxSize && this.accessOrder.length > 0) {
-			const lruKey = this.accessOrder.shift();
-			if (!lruKey) break;
-			this.log("removing", lruKey);
-			unset(this.data, [lruKey]);
-			delete this.temporaryData[lruKey];
-			this.vectorIndex.delete(lruKey);
-			this.log("removed", lruKey);
+	async flush() {
+		this.log("flushing");
+		if (this.options.globalPrefix) await this.removeNamespace("");
+		else {
+			this.entries.clear();
+			this.expiry.clear();
+			this.vectorIndex.clear();
+			this.tagIndex.clear();
 		}
+		this.log("flushed");
+		await this.emit("flushed");
 	}
 	/**
-	* Get current cache size (number of cached items)
+	* Evict least recently used entries (Map insertion order) until the size is
+	* within `maxSize`. Never evicts `protectedKey` (the key just written).
 	*/
-	getCacheSize() {
-		return Object.keys(this.data).length;
+	enforceMaxSize(protectedKey) {
+		const maxSize = this.options.maxSize;
+		if (!maxSize) return;
+		for (const lruKey of [...this.entries.keys()]) {
+			if (this.entries.size <= maxSize) break;
+			if (lruKey === protectedKey) continue;
+			this.log("removing", lruKey);
+			this.dropEntry(lruKey);
+			this.log("removed", lruKey);
+		}
 	}
 	/**
 	* {@inheritdoc}
@@ -208,16 +331,11 @@ var MemoryCacheDriver = class extends BaseCacheDriver {
 	async similar(vector, options) {
 		const tagFilter = await this.getKeysForTags(options.tags);
 		const hits = [];
-		for (const [parsedKey, stored] of this.vectorIndex) {
+		for (const [parsedKey, stored] of [...this.vectorIndex]) {
 			if (tagFilter && !tagFilter.has(parsedKey)) continue;
-			const entry = get(this.data, parsedKey);
+			const entry = this.readLive(parsedKey);
 			if (!entry) continue;
-			if (entry.expiresAt !== void 0 && entry.expiresAt <= Date.now()) continue;
-			let value = entry.data;
-			if (value !== null && value !== void 0) {
-				const type = typeof value;
-				if (type !== "string" && type !== "number" && type !== "boolean") value = structuredClone(value);
-			}
+			const value = cloneValue(entry.data);
 			const score = cosineSimilarity(vector, stored);
 			if (options.threshold !== void 0 && score < options.threshold) continue;
 			hits.push({

package/esm/drivers/memory-cache-driver.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"memory-cache-driver.mjs","names":[],"sources":["../../../../../../../cache/src/drivers/memory-cache-driver.ts"],"sourcesContent":["import type { GenericObject } from \"@mongez/reinforcements\";\nimport { get, set, unset } from \"@mongez/reinforcements\";\nimport type {\n  CacheData,\n  CacheDriver,\n  CacheKey,\n  CacheSetOptions,\n  CacheSetResult,\n  CacheSimilarHit,\n  CacheSimilarOptions,\n  CacheTtl,\n  MemoryCacheOptions,\n} from \"../types\";\nimport { cosineSimilarity } from \"../utils\";\nimport { BaseCacheDriver } from \"./base-cache-driver\";\n\nexport class MemoryCacheDriver\n  extends BaseCacheDriver<MemoryCacheDriver, MemoryCacheOptions>\n  implements CacheDriver<MemoryCacheDriver, MemoryCacheOptions>\n{\n  /**\n   * {@inheritdoc}\n   */\n  public name = \"memory\";\n\n  /**\n   * Cached data\n   */\n  public data: GenericObject = {};\n\n  /**\n   * List of data that will be cleared from cache\n   */\n  protected temporaryData: Record<\n    string,\n    {\n      key: string;\n      expiresAt: number;\n    }\n  > = {};\n\n  /**\n   * Cleanup interval reference\n   */\n  protected cleanupInterval?: NodeJS.Timeout;\n\n  /**\n   * Access order tracking for LRU eviction (when maxSize is set)\n   */\n  protected accessOrder: string[] = [];\n\n  /**\n   * Parallel vector index keyed by parsedKey. Populated by `set({ vector })`,\n   * scanned by `similar()`. Lifetime mirrors the main entry — cleared on\n   * `remove`, `flush`, expiry, namespace clear, and LRU eviction.\n   */\n  protected vectorIndex: Map<string, number[]> = new Map();\n\n  /**\n   * {@inheritdoc}\n   */\n  public constructor() {\n    super();\n\n    this.startCleanup();\n  }\n\n  /**\n   * Start the cleanup process whenever a data that has a cache key is set\n   */\n  public startCleanup() {\n    // Clear existing interval if any\n    if (this.cleanupInterval) {\n      clearInterval(this.cleanupInterval);\n    }\n\n    this.cleanupInterval = setInterval(async () => {\n      const now = Date.now();\n\n      // `Object.entries` rather than `for...in` + index. Two reasons, and the\n      // second is not about types at all: under `noUncheckedIndexedAccess` the\n      // index read is `T | undefined`, AND this loop DELETES from the object it\n      // is iterating. `for...in` over a mutating object has\n      // implementation-defined behaviour for keys not yet visited; entries\n      // snapshots first, so the deletion below is unambiguous.\n      for (const [key, entry] of Object.entries(this.temporaryData)) {\n        if (entry.expiresAt <= now) {\n          await this.remove(entry.key);\n          delete this.temporaryData[key];\n\n          this.log(\"expired\", key);\n          // Emit expired event\n          await this.emit(\"expired\", { key });\n        }\n      }\n    }, 1000);\n\n    // do not block the process from exiting\n    this.cleanupInterval.unref();\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async removeNamespace(namespace: string) {\n    this.log(\"clearing\", namespace);\n\n    namespace = this.parseKey(namespace);\n\n    unset(this.data, [namespace]);\n\n    // Drop vector entries that fall under this namespace.\n    if (namespace === \"\") {\n      this.vectorIndex.clear();\n    } else {\n      const prefix = namespace + \".\";\n      for (const k of [...this.vectorIndex.keys()]) {\n        if (k === namespace || k.startsWith(prefix)) {\n          this.vectorIndex.delete(k);\n        }\n      }\n    }\n\n    this.log(\"cleared\", namespace);\n\n    return this;\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async set(\n    key: CacheKey,\n    value: any,\n    ttlOrOptions?: CacheTtl | CacheSetOptions,\n  ): Promise<any> {\n    const parsedKey = this.parseKey(key);\n    const { ttl, tags, onConflict, vector, staleAt } = this.resolveSetOptions(ttlOrOptions);\n\n    this.log(\"caching\", parsedKey);\n\n    // Use get() for the existence check so expired entries are treated as\n    // missing (and cleaned up as a side effect). A raw map lookup would let\n    // stale entries block onConflict: \"create\" even after their TTL elapsed.\n    const existingValue = onConflict === \"upsert\" ? null : await this.get(key);\n    const exists = existingValue !== null;\n\n    if (onConflict === \"create\" && exists) {\n      const result: CacheSetResult = { wasSet: false, existing: existingValue };\n      return result;\n    }\n\n    if (onConflict === \"update\" && !exists) {\n      const result: CacheSetResult = { wasSet: false, existing: null };\n      return result;\n    }\n\n    const data = this.prepareDataForStorage(value, ttl, staleAt);\n\n    if (ttl) {\n      this.setTemporaryData(key, parsedKey, ttl);\n    }\n\n    set(this.data, parsedKey, data);\n\n    this.trackAccess(parsedKey);\n\n    if (!exists && this.options.maxSize) {\n      await this.enforceMaxSize();\n    }\n\n    if (tags && tags.length > 0) {\n      await this.applyTags(key, tags);\n    }\n\n    if (vector) {\n      this.vectorIndex.set(parsedKey, vector.slice());\n    }\n\n    this.log(\"cached\", parsedKey);\n\n    await this.emit(\"set\", { key: parsedKey, value, ttl });\n\n    if (onConflict === \"create\" || onConflict === \"update\") {\n      const result: CacheSetResult = { wasSet: true, existing: null };\n      return result;\n    }\n\n    return this;\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async get(key: CacheKey) {\n    const parsedKey = this.parseKey(key);\n\n    this.log(\"fetching\", parsedKey);\n\n    const value: CacheData = get(this.data, parsedKey);\n\n    if (!value) {\n      this.log(\"notFound\", parsedKey);\n      // Emit miss event\n      await this.emit(\"miss\", { key: parsedKey });\n      return null;\n    }\n\n    const result = await this.parseCachedData(parsedKey, value);\n\n    if (result === null) {\n      // Expired\n      await this.emit(\"miss\", { key: parsedKey });\n    } else {\n      // Track access for LRU\n      this.trackAccess(parsedKey);\n      // Emit hit event\n      await this.emit(\"hit\", { key: parsedKey, value: result });\n    }\n\n    return result;\n  }\n\n  /**\n   * Read the raw {@link CacheData} wrapper, including `staleAt` metadata.\n   * Returns `null` for missing or expired entries so the SWR flow can branch\n   * cleanly. Does not emit `hit`/`miss` events — that's `get()`'s job.\n   */\n  protected async getEntry(key: CacheKey): Promise<CacheData | null> {\n    const parsedKey = this.parseKey(key);\n    const entry: CacheData | undefined = get(this.data, parsedKey);\n\n    if (!entry) {\n      return null;\n    }\n\n    if (entry.expiresAt !== undefined && entry.expiresAt <= Date.now()) {\n      return null;\n    }\n\n    return entry;\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async remove(key: CacheKey) {\n    const parsedKey = this.parseKey(key);\n\n    this.log(\"removing\", parsedKey);\n\n    unset(this.data, [parsedKey]);\n\n    // Clean up from temporaryData as well\n    delete this.temporaryData[parsedKey];\n\n    // Remove from access order\n    this.removeFromAccessOrder(parsedKey);\n\n    // Drop the vector index entry if any\n    this.vectorIndex.delete(parsedKey);\n\n    this.log(\"removed\", parsedKey);\n\n    // Emit removed event\n    await this.emit(\"removed\", { key: parsedKey });\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async flush() {\n    this.log(\"flushing\");\n    if (this.options.globalPrefix) {\n      this.removeNamespace(\"\");\n    } else {\n      this.data = {};\n      this.accessOrder = [];\n      this.vectorIndex.clear();\n    }\n\n    this.log(\"flushed\");\n\n    // Emit flushed event\n    await this.emit(\"flushed\");\n  }\n\n  /**\n   * Set the temporary data\n   */\n  protected setTemporaryData(key: CacheKey, parsedKey: string, ttl: number) {\n    this.temporaryData[parsedKey] = {\n      key: JSON.stringify(key),\n      expiresAt: Date.now() + ttl * 1000,\n    };\n  }\n\n  /**\n   * Track access for LRU eviction\n   */\n  protected trackAccess(key: string) {\n    if (!this.options.maxSize) return;\n\n    // Remove key from current position\n    const index = this.accessOrder.indexOf(key);\n    if (index > -1) {\n      this.accessOrder.splice(index, 1);\n    }\n\n    // Add to end (most recently used)\n    this.accessOrder.push(key);\n  }\n\n  /**\n   * Remove key from access order tracking\n   */\n  protected removeFromAccessOrder(key: string) {\n    const index = this.accessOrder.indexOf(key);\n    if (index > -1) {\n      this.accessOrder.splice(index, 1);\n    }\n  }\n\n  /**\n   * Enforce max size by evicting least recently used items.\n   *\n   * Recomputes the live cache size on every iteration — a single snapshot at\n   * the top of the loop would go stale and cause this routine to evict every\n   * entry in `accessOrder` (including the just-inserted key).\n   */\n  protected async enforceMaxSize() {\n    if (!this.options.maxSize) {\n      return;\n    }\n\n    while (this.getCacheSize() > this.options.maxSize && this.accessOrder.length > 0) {\n      const lruKey = this.accessOrder.shift();\n      if (!lruKey) {\n        break;\n      }\n\n      this.log(\"removing\", lruKey);\n      unset(this.data, [lruKey]);\n      delete this.temporaryData[lruKey];\n      this.vectorIndex.delete(lruKey);\n      this.log(\"removed\", lruKey);\n    }\n  }\n\n  /**\n   * Get current cache size (number of cached items)\n   */\n  protected getCacheSize(): number {\n    // Count top-level keys in data object\n    return Object.keys(this.data).length;\n  }\n\n  /**\n   * {@inheritdoc}\n   *\n   * Brute-force O(N) cosine similarity over every entry that was written with\n   * `set({ vector })`. Suitable for development and small in-memory knowledge\n   * bases — not for production beyond ~10k entries. Use the `pg` driver\n   * (with pgvector) or `redis` (with RediSearch) at scale.\n   *\n   * @warning Dev-only — O(N) per query.\n   */\n  public async similar<T = any>(\n    vector: number[],\n    options: CacheSimilarOptions,\n  ): Promise<CacheSimilarHit<T>[]> {\n    const tagFilter = await this.getKeysForTags(options.tags);\n\n    const hits: CacheSimilarHit<T>[] = [];\n\n    for (const [parsedKey, stored] of this.vectorIndex) {\n      if (tagFilter && !tagFilter.has(parsedKey)) {\n        continue;\n      }\n\n      // Read the entry directly by its already-parsed key — this.get() would\n      // parse it again and apply globalPrefix twice, missing every entry.\n      const entry: CacheData | undefined = get(this.data, parsedKey);\n\n      if (!entry) {\n        continue;\n      }\n\n      if (entry.expiresAt !== undefined && entry.expiresAt <= Date.now()) {\n        continue;\n      }\n\n      let value: any = entry.data;\n      if (value !== null && value !== undefined) {\n        const type = typeof value;\n        if (type !== \"string\" && type !== \"number\" && type !== \"boolean\") {\n          value = structuredClone(value);\n        }\n      }\n\n      const score = cosineSimilarity(vector, stored);\n\n      if (options.threshold !== undefined && score < options.threshold) {\n        continue;\n      }\n\n      hits.push({ key: parsedKey, value, score });\n    }\n\n    hits.sort((a, b) => b.score - a.score);\n\n    if (options.topK >= 0 && hits.length > options.topK) {\n      hits.length = options.topK;\n    }\n\n    return hits;\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async disconnect() {\n    // Clear the cleanup interval to prevent memory leaks\n    if (this.cleanupInterval) {\n      clearInterval(this.cleanupInterval);\n      this.cleanupInterval = undefined;\n    }\n\n    await super.disconnect();\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"memory-cache-driver.mjs","names":[],"sources":["../../../../../../../cache/src/drivers/memory-cache-driver.ts"],"sourcesContent":["import type {\n  CacheData,\n  CacheDriver,\n  CacheKey,\n  CacheSetOptions,\n  CacheSetResult,\n  CacheSimilarHit,\n  CacheSimilarOptions,\n  CacheTtl,\n  MemoryCacheOptions,\n} from \"../types\";\nimport { cosineSimilarity, parseTtl } from \"../utils\";\nimport { BaseCacheDriver } from \"./base-cache-driver\";\nimport { InMemoryTagIndex } from \"./in-memory-tag-index\";\n\n/**\n * Clone non-primitive values so cached state can't be mutated through\n * references held by callers. Primitives are immutable and returned as-is.\n */\nfunction cloneValue<T>(value: T): T {\n  if (value === null || value === undefined) {\n    return value;\n  }\n\n  const type = typeof value;\n\n  if (type === \"string\" || type === \"number\" || type === \"boolean\") {\n    return value;\n  }\n\n  return structuredClone(value);\n}\n\nexport class MemoryCacheDriver\n  extends BaseCacheDriver<MemoryCacheDriver, MemoryCacheOptions>\n  implements CacheDriver<MemoryCacheDriver, MemoryCacheOptions>\n{\n  /**\n   * {@inheritdoc}\n   */\n  public name = \"memory\";\n\n  /**\n   * Flat storage keyed by the parsed key. Insertion order doubles as LRU\n   * order (least recently used first) — accessed entries are deleted and\n   * re-inserted.\n   */\n  protected entries: Map<string, CacheData> = new Map();\n\n  /**\n   * Read-only object view of the stored entries, keyed by parsed key.\n   * Kept for introspection; the values are the live stored wrappers.\n   */\n  public get data(): Record<string, CacheData> {\n    return Object.fromEntries(this.entries);\n  }\n\n  /**\n   * Expiry records for entries with a FINITE ttl only (parsed key => expiresAt ms).\n   * The sweep iterates just these.\n   */\n  protected expiry: Map<string, number> = new Map();\n\n  /**\n   * Cleanup interval reference\n   */\n  protected cleanupInterval?: NodeJS.Timeout;\n\n  /**\n   * Parallel vector index keyed by parsedKey. Populated by `set({ vector })`,\n   * scanned by `similar()`. Lifetime mirrors the main entry — cleared on\n   * `remove`, `flush`, expiry, namespace clear, overwrite without a vector,\n   * and LRU eviction.\n   */\n  protected vectorIndex: Map<string, number[]> = new Map();\n\n  /**\n   * Tag index, kept apart from `entries`: never evicted by `maxSize`, never\n   * swept by TTL, and updated synchronously.\n   */\n  protected tagIndex: InMemoryTagIndex = new InMemoryTagIndex();\n\n  /**\n   * {@inheritdoc}\n   */\n  public constructor() {\n    super();\n\n    this.startCleanup();\n  }\n\n  /**\n   * Start the cleanup process for entries that carry a finite ttl\n   */\n  public startCleanup() {\n    // Clear existing interval if any\n    if (this.cleanupInterval) {\n      clearInterval(this.cleanupInterval);\n    }\n\n    this.cleanupInterval = setInterval(async () => {\n      const now = Date.now();\n      const expiredKeys: string[] = [];\n\n      for (const [key, expiresAt] of this.expiry) {\n        if (expiresAt <= now) {\n          expiredKeys.push(key);\n        }\n      }\n\n      for (const key of expiredKeys) {\n        // the entry may have been rewritten/slid since the snapshot\n        const expiresAt = this.expiry.get(key);\n\n        if (expiresAt === undefined || expiresAt > now) {\n          continue;\n        }\n\n        this.dropEntry(key);\n\n        this.log(\"expired\", key);\n        // Emit expired event\n        await this.emit(\"expired\", { key });\n      }\n    }, 1000);\n\n    // do not block the process from exiting\n    this.cleanupInterval.unref();\n  }\n\n  /**\n   * Delete an entry and every side record (expiry, vector). Synchronous.\n   */\n  protected dropEntry(parsedKey: string) {\n    this.entries.delete(parsedKey);\n    this.expiry.delete(parsedKey);\n    this.vectorIndex.delete(parsedKey);\n  }\n\n  /**\n   * Raw, synchronous read of a live entry. An expired entry is deleted and\n   * reported as missing. Never slides TTLs, never emits, never touches LRU order.\n   */\n  protected readLive(parsedKey: string): CacheData | undefined {\n    const entry = this.entries.get(parsedKey);\n\n    if (!entry) {\n      return undefined;\n    }\n\n    if (entry.expiresAt !== undefined && entry.expiresAt <= Date.now()) {\n      this.dropEntry(parsedKey);\n      return undefined;\n    }\n\n    return entry;\n  }\n\n  /**\n   * Mark an entry as most recently used (only tracked when `maxSize` is set).\n   */\n  protected touch(parsedKey: string, entry: CacheData) {\n    if (!this.options.maxSize) return;\n\n    this.entries.delete(parsedKey);\n    this.entries.set(parsedKey, entry);\n  }\n\n  /**\n   * When true, every live read slides the entry's expiration forward by its\n   * ttl (the `memoryExtended` driver). Set in a subclass constructor rather\n   * than redeclared, so subclasses stay structurally compatible with this\n   * class (the `client` type relies on that).\n   */\n  protected slidingExpiration = false;\n\n  /**\n   * Invoked on a live read hit, before the value is returned. Runs only from\n   * `get()` after the expiry check, so an expired entry is never resurrected,\n   * and never from the internal existence check used by `onConflict`.\n   */\n  protected onRead(parsedKey: string, entry: CacheData) {\n    if (!this.slidingExpiration) {\n      return;\n    }\n\n    const rawTtl = entry.ttl ?? this.options.ttl;\n    const ttl = rawTtl !== undefined ? parseTtl(rawTtl) : undefined;\n\n    if (ttl && Number.isFinite(ttl)) {\n      entry.expiresAt = this.getExpiresAt(ttl);\n      this.expiry.set(parsedKey, entry.expiresAt as number);\n    }\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async removeNamespace(namespace: string) {\n    this.log(\"clearing\", namespace);\n\n    namespace = this.parseKey(namespace);\n\n    this.tagIndex.removeNamespace(namespace);\n\n    if (namespace === \"\") {\n      this.entries.clear();\n      this.expiry.clear();\n      this.vectorIndex.clear();\n    } else {\n      const prefix = namespace + \".\";\n\n      for (const key of [...this.entries.keys()]) {\n        if (key === namespace || key.startsWith(prefix)) {\n          this.dropEntry(key);\n        }\n      }\n    }\n\n    this.log(\"cleared\", namespace);\n\n    return this;\n  }\n\n  /**\n   * {@inheritdoc}\n   *\n   * The conditional check and the write run with no `await` in between, so\n   * `onConflict` decisions are atomic within the process.\n   */\n  public async set(\n    key: CacheKey,\n    value: any,\n    ttlOrOptions?: CacheTtl | CacheSetOptions,\n  ): Promise<any> {\n    const parsedKey = this.parseKey(key);\n    const { ttl, tags, onConflict, vector, staleAt } = this.resolveSetOptions(ttlOrOptions);\n\n    this.log(\"caching\", parsedKey);\n\n    // expired entries count as missing (readLive deletes them)\n    const existing = onConflict === \"create\" || onConflict === \"update\" ? this.readLive(parsedKey) : undefined;\n\n    if (onConflict === \"create\" && existing) {\n      const result: CacheSetResult = { wasSet: false, existing: cloneValue(existing.data) };\n      return result;\n    }\n\n    if (onConflict === \"update\" && !existing) {\n      const result: CacheSetResult = { wasSet: false, existing: null };\n      return result;\n    }\n\n    const data = this.prepareDataForStorage(cloneValue(value), ttl, staleAt);\n\n    // delete + set moves the key to the most-recent position\n    this.entries.delete(parsedKey);\n    this.entries.set(parsedKey, data);\n\n    if (data.expiresAt !== undefined && Number.isFinite(data.expiresAt)) {\n      this.expiry.set(parsedKey, data.expiresAt);\n    } else {\n      this.expiry.delete(parsedKey);\n    }\n\n    if (vector) {\n      this.vectorIndex.set(parsedKey, vector.slice());\n    } else {\n      this.vectorIndex.delete(parsedKey);\n    }\n\n    this.enforceMaxSize(parsedKey);\n\n    if (tags && tags.length > 0) {\n      await this.applyTags(key, tags);\n    }\n\n    this.log(\"cached\", parsedKey);\n\n    await this.emit(\"set\", { key: parsedKey, value, ttl });\n\n    if (onConflict === \"create\" || onConflict === \"update\") {\n      const result: CacheSetResult = { wasSet: true, existing: null };\n      return result;\n    }\n\n    return this;\n  }\n\n  /**\n   * {@inheritdoc}\n   *\n   * The check and the delete run synchronously (no `await` between them), so\n   * the compare-and-delete is atomic within the process.\n   */\n  protected async deleteIfEquals(key: CacheKey, expected: unknown): Promise<boolean> {\n    const parsedKey = this.parseKey(key);\n    const entry = this.readLive(parsedKey);\n\n    if (!entry || entry.data !== expected) {\n      return false;\n    }\n\n    await this.remove(key);\n\n    return true;\n  }\n\n  /**\n   * {@inheritdoc}\n   *\n   * Read, add and write run synchronously (no `await` in between), so\n   * concurrent increments in this process never lose an update. An existing\n   * entry keeps its expiry; a missing key starts from 0 with the default TTL.\n   */\n  public async increment(key: CacheKey, value: number = 1): Promise<number> {\n    const parsedKey = this.parseKey(key);\n    const entry = this.readLive(parsedKey);\n    const current = entry ? entry.data : 0;\n\n    if (typeof current !== \"number\") {\n      throw new Error(`Cannot increment non-numeric value for key: ${parsedKey}`);\n    }\n\n    const newValue = current + value;\n\n    if (entry) {\n      entry.data = newValue;\n      this.touch(parsedKey, entry);\n    } else {\n      const data = this.prepareDataForStorage(newValue, this.ttl);\n\n      this.entries.set(parsedKey, data);\n\n      if (data.expiresAt !== undefined && Number.isFinite(data.expiresAt)) {\n        this.expiry.set(parsedKey, data.expiresAt);\n      }\n\n      this.enforceMaxSize(parsedKey);\n    }\n\n    await this.emit(\"set\", { key: parsedKey, value: newValue, ttl: entry?.ttl ?? this.ttl });\n\n    return newValue;\n  }\n\n  /**\n   * {@inheritdoc}\n   *\n   * Read and delete run synchronously, so a value is handed out exactly once\n   * even when concurrent callers pull the same key.\n   */\n  public async pull(key: CacheKey): Promise<any | null> {\n    const parsedKey = this.parseKey(key);\n    const entry = this.readLive(parsedKey);\n\n    if (!entry) {\n      await this.emit(\"miss\", { key: parsedKey });\n\n      return null;\n    }\n\n    this.dropEntry(parsedKey);\n\n    const value = cloneValue(entry.data);\n\n    await this.emit(\"hit\", { key: parsedKey, value });\n    await this.emit(\"removed\", { key: parsedKey });\n\n    return value;\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async get(key: CacheKey) {\n    const parsedKey = this.parseKey(key);\n\n    this.log(\"fetching\", parsedKey);\n\n    const entry = this.readLive(parsedKey);\n\n    if (!entry) {\n      this.log(\"notFound\", parsedKey);\n      // Emit miss event\n      await this.emit(\"miss\", { key: parsedKey });\n      return null;\n    }\n\n    this.onRead(parsedKey, entry);\n    this.touch(parsedKey, entry);\n\n    const result = await this.parseCachedData(parsedKey, entry);\n\n    // Emit hit event\n    await this.emit(\"hit\", { key: parsedKey, value: result });\n\n    return result;\n  }\n\n  /**\n   * Read the raw {@link CacheData} wrapper (cloned), including `staleAt` metadata.\n   * Returns `null` for missing or expired entries so the SWR flow can branch\n   * cleanly. Does not emit `hit`/`miss` events — that's `get()`'s job.\n   */\n  protected async getEntry(key: CacheKey): Promise<CacheData | null> {\n    const entry = this.readLive(this.parseKey(key));\n\n    if (!entry) {\n      return null;\n    }\n\n    return { ...entry, data: cloneValue(entry.data) };\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async remove(key: CacheKey) {\n    const parsedKey = this.parseKey(key);\n\n    this.log(\"removing\", parsedKey);\n\n    this.dropEntry(parsedKey);\n\n    this.log(\"removed\", parsedKey);\n\n    // Emit removed event\n    await this.emit(\"removed\", { key: parsedKey });\n  }\n\n  /**\n   * {@inheritdoc}\n   *\n   * Synchronous in-process set — concurrent tagged writes never drop members.\n   */\n  public async tagAdd(tagKey: CacheKey, members: string[]): Promise<void> {\n    this.tagIndex.add(this.parseKey(tagKey), members);\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async tagMembers(tagKey: CacheKey): Promise<string[]> {\n    return this.tagIndex.members(this.parseKey(tagKey));\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async tagRemove(tagKey: CacheKey, members: string[]): Promise<void> {\n    this.tagIndex.remove(this.parseKey(tagKey), members);\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async tagDelete(tagKey: CacheKey): Promise<void> {\n    this.tagIndex.delete(this.parseKey(tagKey));\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async flush() {\n    this.log(\"flushing\");\n    if (this.options.globalPrefix) {\n      await this.removeNamespace(\"\");\n    } else {\n      this.entries.clear();\n      this.expiry.clear();\n      this.vectorIndex.clear();\n      this.tagIndex.clear();\n    }\n\n    this.log(\"flushed\");\n\n    // Emit flushed event\n    await this.emit(\"flushed\");\n  }\n\n  /**\n   * Evict least recently used entries (Map insertion order) until the size is\n   * within `maxSize`. Never evicts `protectedKey` (the key just written).\n   */\n  protected enforceMaxSize(protectedKey: string) {\n    const maxSize = this.options.maxSize;\n\n    if (!maxSize) {\n      return;\n    }\n\n    for (const lruKey of [...this.entries.keys()]) {\n      if (this.entries.size <= maxSize) {\n        break;\n      }\n\n      if (lruKey === protectedKey) {\n        continue;\n      }\n\n      this.log(\"removing\", lruKey);\n      this.dropEntry(lruKey);\n      this.log(\"removed\", lruKey);\n    }\n  }\n\n  /**\n   * {@inheritdoc}\n   *\n   * Brute-force O(N) cosine similarity over every entry that was written with\n   * `set({ vector })`. Suitable for development and small in-memory knowledge\n   * bases — not for production beyond ~10k entries. Use the `pg` driver\n   * (with pgvector) or `redis` (with RediSearch) at scale.\n   *\n   * @warning Dev-only — O(N) per query.\n   */\n  public async similar<T = any>(\n    vector: number[],\n    options: CacheSimilarOptions,\n  ): Promise<CacheSimilarHit<T>[]> {\n    const tagFilter = await this.getKeysForTags(options.tags);\n\n    const hits: CacheSimilarHit<T>[] = [];\n\n    for (const [parsedKey, stored] of [...this.vectorIndex]) {\n      if (tagFilter && !tagFilter.has(parsedKey)) {\n        continue;\n      }\n\n      // Read the entry directly by its already-parsed key — this.get() would\n      // parse it again and apply globalPrefix twice, missing every entry.\n      const entry = this.readLive(parsedKey);\n\n      if (!entry) {\n        continue;\n      }\n\n      const value: any = cloneValue(entry.data);\n\n      const score = cosineSimilarity(vector, stored);\n\n      if (options.threshold !== undefined && score < options.threshold) {\n        continue;\n      }\n\n      hits.push({ key: parsedKey, value, score });\n    }\n\n    hits.sort((a, b) => b.score - a.score);\n\n    if (options.topK >= 0 && hits.length > options.topK) {\n      hits.length = options.topK;\n    }\n\n    return hits;\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async disconnect() {\n    // Clear the cleanup interval to prevent memory leaks\n    if (this.cleanupInterval) {\n      clearInterval(this.cleanupInterval);\n      this.cleanupInterval = undefined;\n    }\n\n    await super.disconnect();\n  }\n}\n"],"mappings":"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"}

package/esm/drivers/memory-extended-cache-driver.d.mts

@@ -1,16 +1,20 @@
 import { MemoryCacheDriver } from "./memory-cache-driver.mjs";
-import { CacheDriver, CacheKey, MemoryExtendedCacheOptions } from "../types.mjs";
+import { CacheDriver, MemoryExtendedCacheOptions } from "../types.mjs";
 
 //#region ../cache/src/drivers/memory-extended-cache-driver.d.ts
+/**
+ * Memory driver with a sliding ttl: every live read pushes the entry's
+ * expiration forward by its ttl. The sliding itself lives in
+ * `MemoryCacheDriver.onRead`, which checks expiry first, so an expired entry
+ * is never resurrected and the internal `onConflict` existence check never
+ * slides a held lock.
+ */
 declare class MemoryExtendedCacheDriver extends MemoryCacheDriver implements CacheDriver<MemoryExtendedCacheDriver, MemoryExtendedCacheOptions> {
   /**
    * {@inheritdoc}
    */
   name: string;
-  /**
-   * {@inheritdoc}
-   */
-  get(key: CacheKey): Promise<any>;
+  constructor();
 }
 //#endregion
 export { MemoryExtendedCacheDriver };

package/esm/drivers/memory-extended-cache-driver.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-extended-cache-driver.d.mts","names":[],"sources":["../../../../../../../cache/src/drivers/memory-extended-cache-driver.ts"],"mappings":";;;;cAKa,yBAAA,SACH,iBAAA,YACG,WAAA,CAAY,yBAAA,EAA2B,0BAAA;;AAFpD;;EAOS,IAAA;EALgB;;;EAUV,GAAA,CAAI,GAAA,EAAK,QAAA,GAAQ,OAAA;AAAA"}
+{"version":3,"file":"memory-extended-cache-driver.d.mts","names":[],"sources":["../../../../../../../cache/src/drivers/memory-extended-cache-driver.ts"],"mappings":";;;;;;AAUA;;;;;cAAa,yBAAA,SACH,iBAAA,YACG,WAAA,CAAY,yBAAA,EAA2B,0BAAA;EAAvC;;;EAKJ,IAAA"}

package/esm/drivers/memory-extended-cache-driver.mjs

@@ -1,31 +1,18 @@
-import { parseTtl } from "../utils.mjs";
 import { MemoryCacheDriver } from "./memory-cache-driver.mjs";
-import { get } from "@mongez/reinforcements";
 
 //#region ../cache/src/drivers/memory-extended-cache-driver.ts
+/**
+* Memory driver with a sliding ttl: every live read pushes the entry's
+* expiration forward by its ttl. The sliding itself lives in
+* `MemoryCacheDriver.onRead`, which checks expiry first, so an expired entry
+* is never resurrected and the internal `onConflict` existence check never
+* slides a held lock.
+*/
 var MemoryExtendedCacheDriver = class extends MemoryCacheDriver {
-	constructor(..._args) {
-		super(..._args);
+	constructor() {
+		super();
 		this.name = "memoryExtended";
-	}
-	/**
-	* {@inheritdoc}
-	*/
-	async get(key) {
-		const parsedKey = this.parseKey(key);
-		this.log("fetching", parsedKey);
-		const value = get(this.data, parsedKey);
-		if (!value) {
-			this.log("notFound", parsedKey);
-			return null;
-		}
-		const rawTtl = value.ttl ?? this.options.ttl;
-		const ttl = rawTtl !== void 0 ? parseTtl(rawTtl) : void 0;
-		if (ttl) {
-			this.setTemporaryData(key, parsedKey, ttl);
-			value.expiresAt = this.getExpiresAt(ttl);
-		}
-		return this.parseCachedData(parsedKey, value);
+		this.slidingExpiration = true;
 	}
 };
 

package/esm/drivers/memory-extended-cache-driver.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"memory-extended-cache-driver.mjs","names":[],"sources":["../../../../../../../cache/src/drivers/memory-extended-cache-driver.ts"],"sourcesContent":["import { get } from \"@mongez/reinforcements\";\r\nimport type { CacheData, CacheDriver, CacheKey, MemoryExtendedCacheOptions } from \"../types\";\r\nimport { parseTtl } from \"../utils\";\r\nimport { MemoryCacheDriver } from \"./memory-cache-driver\";\r\n\r\nexport class MemoryExtendedCacheDriver\r\n  extends MemoryCacheDriver\r\n  implements CacheDriver<MemoryExtendedCacheDriver, MemoryExtendedCacheOptions>\r\n{\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public name = \"memoryExtended\";\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async get(key: CacheKey) {\r\n    const parsedKey = this.parseKey(key);\r\n\r\n    this.log(\"fetching\", parsedKey);\r\n\r\n    const value: CacheData = get(this.data, parsedKey);\r\n\r\n    if (!value) {\r\n      this.log(\"notFound\", parsedKey);\r\n      return null;\r\n    }\r\n\r\n    const rawTtl = value.ttl ?? this.options.ttl;\r\n    const ttl = rawTtl !== undefined ? parseTtl(rawTtl) : undefined;\r\n\r\n    if (ttl) {\r\n      // reset the expiration time\r\n      this.setTemporaryData(key, parsedKey, ttl);\r\n      value.expiresAt = this.getExpiresAt(ttl);\r\n    }\r\n\r\n    return this.parseCachedData(parsedKey, value);\r\n  }\r\n}\r\n"],"mappings":";;;;;AAKA,IAAa,4BAAb,cACU,kBAEV;;;cAIgB;;;;;CAKd,MAAa,IAAI,KAAe;EAC9B,MAAM,YAAY,KAAK,SAAS,GAAG;EAEnC,KAAK,IAAI,YAAY,SAAS;EAE9B,MAAM,QAAmB,IAAI,KAAK,MAAM,SAAS;EAEjD,IAAI,CAAC,OAAO;GACV,KAAK,IAAI,YAAY,SAAS;GAC9B,OAAO;EACT;EAEA,MAAM,SAAS,MAAM,OAAO,KAAK,QAAQ;EACzC,MAAM,MAAM,WAAW,SAAY,SAAS,MAAM,IAAI;EAEtD,IAAI,KAAK;GAEP,KAAK,iBAAiB,KAAK,WAAW,GAAG;GACzC,MAAM,YAAY,KAAK,aAAa,GAAG;EACzC;EAEA,OAAO,KAAK,gBAAgB,WAAW,KAAK;CAC9C;AACF"}
+{"version":3,"file":"memory-extended-cache-driver.mjs","names":[],"sources":["../../../../../../../cache/src/drivers/memory-extended-cache-driver.ts"],"sourcesContent":["import type { CacheDriver, MemoryExtendedCacheOptions } from \"../types\";\nimport { MemoryCacheDriver } from \"./memory-cache-driver\";\n\n/**\n * Memory driver with a sliding ttl: every live read pushes the entry's\n * expiration forward by its ttl. The sliding itself lives in\n * `MemoryCacheDriver.onRead`, which checks expiry first, so an expired entry\n * is never resurrected and the internal `onConflict` existence check never\n * slides a held lock.\n */\nexport class MemoryExtendedCacheDriver\n  extends MemoryCacheDriver\n  implements CacheDriver<MemoryExtendedCacheDriver, MemoryExtendedCacheOptions>\n{\n  /**\n   * {@inheritdoc}\n   */\n  public name = \"memoryExtended\";\n\n  public constructor() {\n    super();\n\n    this.slidingExpiration = true;\n  }\n}\n"],"mappings":";;;;;;;;;;AAUA,IAAa,4BAAb,cACU,kBAEV;CAME,AAAO,cAAc;EACnB,MAAM;cAHM;EAKZ,KAAK,oBAAoB;CAC3B;AACF"}