@warlock.js/cache 5.29.0 → 5.31.0

package/cjs/index.cjs

@@ -37,7 +37,7 @@ let _warlock_js_fs = require("@warlock.js/fs");
 let path = require("path");
 path = __toESM(path, 1);
 
-//#region ../cache/src/metrics.ts
+//#region ../../packages/cache/src/metrics.ts
 /**
 * Default size of the circular latency-sample buffer. 1000 samples covers
 * "tell me the current p95" for every realistic workload while keeping the
@@ -232,7 +232,7 @@ var CacheMetricsCollector = class {
 };
 
 //#endregion
-//#region ../cache/src/types.ts
+//#region ../../packages/cache/src/types.ts
 /**
 * Base error class for cache-related errors
 */
@@ -292,7 +292,7 @@ var CacheConcurrencyError = class extends CacheError {
 };
 
 //#endregion
-//#region ../cache/src/utils.ts
+//#region ../../packages/cache/src/utils.ts
 /**
 * Make a proper key for the cache
 */
@@ -549,7 +549,7 @@ let CACHE_FOR = /* @__PURE__ */ function(CACHE_FOR) {
 }({});
 
 //#endregion
-//#region ../cache/src/tagged-scoped-cache.ts
+//#region ../../packages/cache/src/tagged-scoped-cache.ts
 /**
 * One-shot tagged write handle on top of a {@link ScopedCache}.
 *
@@ -666,8 +666,8 @@ var TaggedScopedCache = class {
 	* Atomic counter increment on the scoped key. Tags aren't applied to
 	* subsequent increments — they're attached at first-write time.
 	*/
-	increment(key, value) {
-		return this.scope.increment(key, value);
+	increment(key, value, options) {
+		return this.scope.increment(key, value, options);
 	}
 	/**
 	* Atomic counter decrement on the scoped key. See {@link increment}.
@@ -698,7 +698,7 @@ var TaggedScopedCache = class {
 };
 
 //#endregion
-//#region ../cache/src/scoped-cache.ts
+//#region ../../packages/cache/src/scoped-cache.ts
 /**
 * Scoped view over a cache source. Returned by `cache.namespace(prefix, options?)`.
 *
@@ -860,8 +860,8 @@ var ScopedCache = class ScopedCache {
 	* Atomic counter increment on the scoped key. TTL is preserved by the
 	* underlying driver — scope ttl is only applied on first write via `set`.
 	*/
-	increment(key, value) {
-		return this.source.increment(this.scopedKey(key), value);
+	increment(key, value, options) {
+		return this.source.increment(this.scopedKey(key), value, { ttl: options?.ttl ?? this.defaults.ttl });
 	}
 	/**
 	* Atomic counter decrement on the scoped key. See {@link increment} for
@@ -979,7 +979,7 @@ var ScopedCache = class ScopedCache {
 };
 
 //#endregion
-//#region ../cache/src/cache-manager.ts
+//#region ../../packages/cache/src/cache-manager.ts
 var CacheManager = class {
 	constructor() {
 		this.loadedDrivers = {};
@@ -1321,9 +1321,9 @@ var CacheManager = class {
 	/**
 	* {@inheritdoc}
 	*/
-	async increment(key, value) {
+	async increment(key, value, options) {
 		this.ensureDriverInitialized();
-		return this.currentDriver.increment(key, value);
+		return this.currentDriver.increment(key, value, options);
 	}
 	/**
 	* {@inheritdoc}
@@ -1477,7 +1477,7 @@ var CacheManager = class {
 const cache = new CacheManager();
 
 //#endregion
-//#region ../cache/src/cached/auto-key.ts
+//#region ../../packages/cache/src/cached/auto-key.ts
 /**
 * Derive a cache key from a prefix and a set of function arguments.
 *
@@ -1543,7 +1543,7 @@ function normalize(value, prefix, seen) {
 }
 
 //#endregion
-//#region ../cache/src/cached/normalize-args.ts
+//#region ../../packages/cache/src/cached/normalize-args.ts
 /**
 * Resolve the positional-or-options arguments of `cached()` into a single
 * normalized config. Keeps the wrapper body free of shape-checks.
@@ -1565,7 +1565,7 @@ function normalizeCachedArgs(prefixOrOptions, maybeTtl) {
 }
 
 //#endregion
-//#region ../cache/src/cached/cached.ts
+//#region ../../packages/cache/src/cached/cached.ts
 function cached(fn, prefixOrOptions, maybeTtl) {
 	const config = normalizeCachedArgs(prefixOrOptions, maybeTtl);
 	const buildRememberOptions = () => ({
@@ -1589,7 +1589,7 @@ function cached(fn, prefixOrOptions, maybeTtl) {
 }
 
 //#endregion
-//#region ../cache/src/list/memory-cache-list.ts
+//#region ../../packages/cache/src/list/memory-cache-list.ts
 /**
 * Generic array-backed {@link CacheListAccessor}.
 *
@@ -1708,7 +1708,7 @@ var MemoryCacheList = class {
 };
 
 //#endregion
-//#region ../cache/src/tagged-cache.ts
+//#region ../../packages/cache/src/tagged-cache.ts
 /**
 * Tagged Cache Wrapper
 * Wraps a cache driver to automatically manage tag relationships
@@ -1902,8 +1902,8 @@ var TaggedCache = class TaggedCache {
 	/**
 	* {@inheritdoc}
 	*/
-	async increment(key, value = 1) {
-		const newValue = await this.driver.increment(key, value);
+	async increment(key, value = 1, options) {
+		const newValue = await this.driver.increment(key, value, options);
 		await this.storeTaggedKey(key);
 		return newValue;
 	}
@@ -1916,7 +1916,7 @@ var TaggedCache = class TaggedCache {
 };
 
 //#endregion
-//#region ../cache/src/drivers/base-cache-driver.ts
+//#region ../../packages/cache/src/drivers/base-cache-driver.ts
 const messages = {
 	clearing: "Clearing namespace",
 	cleared: "Namespace cleared",
@@ -2309,20 +2309,31 @@ var BaseCacheDriver = class {
 	* {@inheritdoc}
 	*
 	* Default implementation: read-add-write serialized per key in THIS process,
-	* keeping the entry's remaining TTL (a missing key starts from 0 with the
-	* driver default TTL). Not atomic across servers: drivers with a native
-	* primitive override it (redis `INCRBY`, pg single-statement upsert).
-	*/
-	async increment(key, value = 1) {
+	* keeping the entry's deadline (a missing key starts from 0 with the driver
+	* default TTL). Not atomic across servers: drivers with a native primitive
+	* override it (redis `INCRBY`, pg single-statement upsert).
+	*
+	* The value and its deadline come from ONE read. Reading them separately
+	* let a counter that expired in between be rewritten from its stale value
+	* with no expiry at all (a login-throttle counter that then never resets).
+	* The remaining TTL is rounded down, so repeated increments can never push
+	* a window's deadline later.
+	*/
+	async increment(key, value = 1, options = {}) {
+		const ttl = options.ttl === void 0 ? this.ttl : parseTtl(options.ttl);
 		const parsedKey = this.parseKey(key);
 		return this.runSerialized(parsedKey, async () => {
-			const current = await this.get(key);
+			const entry = await this.getEntry(key);
+			const now = Date.now();
+			const expiresAt = entry?.expiresAt;
+			const live = entry ? expiresAt == null || expiresAt > now : false;
+			const current = entry && live ? entry.data : null;
 			const base = current === null || current === void 0 ? 0 : current;
-			if (typeof base !== "number") throw new Error(`Cannot increment non-numeric value for key: ${parsedKey}`);
+			if (typeof base !== "number") throw new Error(`Cannot increment non-numeric value for key: ${(0, _warlock_js_logger.maskEmailsInText)(parsedKey)}`);
 			const newValue = base + value;
-			const remainingTtl = current === null ? void 0 : await this.getRemainingTtl(key);
-			if (remainingTtl !== void 0) await this.set(key, newValue, { ttl: remainingTtl });
-			else await this.set(key, newValue);
+			if (!live) await this.set(key, newValue, { ttl });
+			else if (expiresAt == null || expiresAt === Infinity) await this.set(key, newValue, { ttl: options.ttl === void 0 ? Infinity : ttl });
+			else await this.set(key, newValue, { ttl: Math.max(1, Math.floor((expiresAt - now) / 1e3)) });
 			return newValue;
 		});
 	}
@@ -2349,7 +2360,7 @@ var BaseCacheDriver = class {
 	*/
 	log(operation, key) {
 		if (!this.shouldLog) return;
-		if (typeof key === "string") key = key.replace(/\//g, ".");
+		if (typeof key === "string") key = (0, _warlock_js_logger.maskEmailsInText)(key.replace(/\//g, "."));
 		if (operation === "connectionFailed") _warlock_js_logger.log.fatal(`cache.${this.name}`, operation, key);
 		if (operation == "notFound" || operation == "expired") return _warlock_js_logger.log.info("cache." + this.name, operation, (key ? key + " " : "") + messages[operation]);
 		if (operation.endsWith("ed")) return _warlock_js_logger.log.success("cache." + this.name, operation, (key ? key + " " : "") + messages[operation]);
@@ -2364,8 +2375,14 @@ var BaseCacheDriver = class {
 	* passed to the structured logger.
 	*/
 	logError(message, error) {
-		if (error) _warlock_js_logger.log.error("cache." + this.name, "error", message, safeErrorInfo(error));
-		else _warlock_js_logger.log.error("cache." + this.name, "error", message);
+		const maskedMessage = (0, _warlock_js_logger.maskEmailsInText)(message);
+		if (error) {
+			const info = safeErrorInfo(error);
+			_warlock_js_logger.log.error("cache." + this.name, "error", maskedMessage, {
+				...info,
+				message: (0, _warlock_js_logger.maskEmailsInText)(info.message)
+			});
+		} else _warlock_js_logger.log.error("cache." + this.name, "error", maskedMessage);
 	}
 	/**
 	* Get the default TTL in seconds. Parses human-readable strings (`"1h"`, `"30m"`)
@@ -2560,7 +2577,7 @@ var BaseCacheDriver = class {
 };
 
 //#endregion
-//#region ../cache/src/drivers/file-cache-driver.ts
+//#region ../../packages/cache/src/drivers/file-cache-driver.ts
 var FileCacheDriver = class extends BaseCacheDriver {
 	constructor(..._args) {
 		super(..._args);
@@ -2770,7 +2787,7 @@ var FileCacheDriver = class extends BaseCacheDriver {
 		try {
 			const entry = await (0, _warlock_js_fs.getJsonFileAsync)(path.default.resolve(fileDirectory, this.fileName));
 			if (!entry) return null;
-			if (entry.expiresAt !== void 0 && entry.expiresAt <= Date.now()) return null;
+			if (typeof entry.expiresAt === "number" && entry.expiresAt <= Date.now()) return null;
 			return entry;
 		} catch {
 			return null;
@@ -2837,7 +2854,7 @@ var FileCacheDriver = class extends BaseCacheDriver {
 };
 
 //#endregion
-//#region ../cache/src/drivers/in-memory-tag-index.ts
+//#region ../../packages/cache/src/drivers/in-memory-tag-index.ts
 /**
 * Tag index for the in-process drivers (memory, memoryExtended, lru, mock).
 *
@@ -2908,7 +2925,7 @@ var InMemoryTagIndex = class {
 };
 
 //#endregion
-//#region ../cache/src/drivers/lru-memory-cache-driver.ts
+//#region ../../packages/cache/src/drivers/lru-memory-cache-driver.ts
 var CacheNode = class {
 	constructor(key, value, ttl) {
 		this.key = key;
@@ -3116,17 +3133,19 @@ var LRUMemoryCacheDriver = class extends BaseCacheDriver {
 	* concurrent increments in this process never lose an update. An existing
 	* node keeps its expiry; a missing key starts from 0 with the default TTL.
 	*/
-	async increment(key, value = 1) {
+	async increment(key, value = 1, options = {}) {
+		const ttl = options.ttl === void 0 ? this.ttl : parseTtl(options.ttl);
 		const parsedKey = this.parseKey(key);
 		const node = this.liveNode(parsedKey);
 		const current = node ? node.value : 0;
-		if (typeof current !== "number") throw new Error(`Cannot increment non-numeric value for key: ${parsedKey}`);
+		if (typeof current !== "number") throw new Error(`Cannot increment non-numeric value for key: ${(0, _warlock_js_logger.maskEmailsInText)(parsedKey)}`);
 		const newValue = current + value;
 		if (node) {
 			node.value = newValue;
+			if (options.ttl !== void 0 && !Number.isFinite(node.expiresAt) && Number.isFinite(ttl) && ttl > 0) node.expiresAt = Date.now() + ttl * 1e3;
 			this.moveHead(node);
 		} else {
-			const newNode = new CacheNode(parsedKey, newValue, this.ttl);
+			const newNode = new CacheNode(parsedKey, newValue, ttl);
 			this.cache.set(parsedKey, newNode);
 			this.addNode(newNode);
 			if (this.cache.size > this.capacity) this.removeTail();
@@ -3134,7 +3153,7 @@ var LRUMemoryCacheDriver = class extends BaseCacheDriver {
 		await this.emit("set", {
 			key: parsedKey,
 			value: newValue,
-			ttl: this.ttl
+			ttl
 		});
 		return newValue;
 	}
@@ -3315,7 +3334,7 @@ var LRUMemoryCacheDriver = class extends BaseCacheDriver {
 };
 
 //#endregion
-//#region ../cache/src/drivers/memory-cache-driver.ts
+//#region ../../packages/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.
@@ -3487,17 +3506,23 @@ var MemoryCacheDriver = class extends BaseCacheDriver {
 	* 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) {
+	async increment(key, value = 1, options = {}) {
+		const ttl = options.ttl === void 0 ? this.ttl : parseTtl(options.ttl);
 		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}`);
+		if (typeof current !== "number") throw new Error(`Cannot increment non-numeric value for key: ${(0, _warlock_js_logger.maskEmailsInText)(parsedKey)}`);
 		const newValue = current + value;
 		if (entry) {
 			entry.data = newValue;
+			if (options.ttl !== void 0 && !Number.isFinite(entry.expiresAt) && Number.isFinite(ttl) && ttl > 0) {
+				entry.ttl = ttl;
+				entry.expiresAt = Date.now() + ttl * 1e3;
+				this.expiry.set(parsedKey, entry.expiresAt);
+			}
 			this.touch(parsedKey, entry);
 		} else {
-			const data = this.prepareDataForStorage(newValue, this.ttl);
+			const data = this.prepareDataForStorage(newValue, ttl);
 			this.entries.set(parsedKey, data);
 			if (data.expiresAt !== void 0 && Number.isFinite(data.expiresAt)) this.expiry.set(parsedKey, data.expiresAt);
 			this.enforceMaxSize(parsedKey);
@@ -3505,7 +3530,7 @@ var MemoryCacheDriver = class extends BaseCacheDriver {
 		await this.emit("set", {
 			key: parsedKey,
 			value: newValue,
-			ttl: entry?.ttl ?? this.ttl
+			ttl: entry?.ttl ?? ttl
 		});
 		return newValue;
 	}
@@ -3674,7 +3699,7 @@ var MemoryCacheDriver = class extends BaseCacheDriver {
 };
 
 //#endregion
-//#region ../cache/src/drivers/memory-extended-cache-driver.ts
+//#region ../../packages/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
@@ -3691,7 +3716,7 @@ var MemoryExtendedCacheDriver = class extends MemoryCacheDriver {
 };
 
 //#endregion
-//#region ../cache/src/drivers/mock-cache-driver.ts
+//#region ../../packages/cache/src/drivers/mock-cache-driver.ts
 /**
 * In-memory cache driver with introspection helpers, intended for use as a
 * test double in downstream packages.
@@ -3857,19 +3882,25 @@ var MockCacheDriver = class extends BaseCacheDriver {
 	* Synchronous read-add-write (atomic within the process). Keeps an existing
 	* entry's expiry; a missing key starts from 0 with the default TTL.
 	*/
-	async increment(key, value = 1) {
+	async increment(key, value = 1, options = {}) {
+		const ttl = options.ttl === void 0 ? this.ttl : parseTtl(options.ttl);
 		const parsedKey = this.parseKey(key);
 		this.recordCall("increment", parsedKey, [value]);
 		const entry = this.liveEntry(parsedKey);
 		const current = entry ? entry.data : 0;
-		if (typeof current !== "number") throw new Error(`Cannot increment non-numeric value for key: ${parsedKey}`);
+		if (typeof current !== "number") throw new Error(`Cannot increment non-numeric value for key: ${(0, _warlock_js_logger.maskEmailsInText)(parsedKey)}`);
 		const newValue = current + value;
-		if (entry) entry.data = newValue;
-		else this.storage.set(parsedKey, this.prepareDataForStorage(newValue, this.ttl));
+		if (entry) {
+			entry.data = newValue;
+			if (options.ttl !== void 0 && !Number.isFinite(entry.expiresAt) && Number.isFinite(ttl) && ttl > 0) {
+				entry.ttl = ttl;
+				entry.expiresAt = Date.now() + ttl * 1e3;
+			}
+		} else this.storage.set(parsedKey, this.prepareDataForStorage(newValue, ttl));
 		await this.emit("set", {
 			key: parsedKey,
 			value: newValue,
-			ttl: this.ttl
+			ttl
 		});
 		return newValue;
 	}
@@ -4009,7 +4040,7 @@ var MockCacheDriver = class extends BaseCacheDriver {
 };
 
 //#endregion
-//#region ../cache/src/drivers/null-cache-driver.ts
+//#region ../../packages/cache/src/drivers/null-cache-driver.ts
 var NullCacheDriver = class extends BaseCacheDriver {
 	/**
 	* {@inheritdoc}
@@ -4052,32 +4083,39 @@ var NullCacheDriver = class extends BaseCacheDriver {
 	* {@inheritdoc}
 	*/
 	async removeNamespace(namespace) {
-		_warlock_js_logger.log.info("cache", "clearing namespace", namespace);
-		_warlock_js_logger.log.success("cache", "namespace cleared", namespace);
+		const loggableNamespace = (0, _warlock_js_logger.maskEmailsInText)(namespace);
+		_warlock_js_logger.log.info("cache", "clearing namespace", loggableNamespace);
+		_warlock_js_logger.log.success("cache", "namespace cleared", loggableNamespace);
 		return this;
 	}
 	/**
+	* The key as it may appear in a log line: parsed, with email addresses masked
+	*/
+	loggableKey(key) {
+		return (0, _warlock_js_logger.maskEmailsInText)(this.parseKey(key));
+	}
+	/**
 	* {@inheritdoc}
 	*/
 	async set(key, _value, _ttlOrOptions) {
-		_warlock_js_logger.log.info("cache", "setting key", key);
-		_warlock_js_logger.log.success("cache", "key set", key);
+		_warlock_js_logger.log.info("cache", "setting key", this.loggableKey(key));
+		_warlock_js_logger.log.success("cache", "key set", this.loggableKey(key));
 		return this;
 	}
 	/**
 	* {@inheritdoc}
 	*/
 	async get(key) {
-		_warlock_js_logger.log.info("cache", "fetching", key);
-		_warlock_js_logger.log.success("cache", "fetched", key);
+		_warlock_js_logger.log.info("cache", "fetching", this.loggableKey(key));
+		_warlock_js_logger.log.success("cache", "fetched", this.loggableKey(key));
 		return null;
 	}
 	/**
 	* {@inheritdoc}
 	*/
 	async remove(key) {
-		_warlock_js_logger.log.info("cache", "removing", key);
-		_warlock_js_logger.log.success("cache", "removed", key);
+		_warlock_js_logger.log.info("cache", "removing", this.loggableKey(key));
+		_warlock_js_logger.log.success("cache", "removed", this.loggableKey(key));
 	}
 	/**
 	* {@inheritdoc}
@@ -4104,7 +4142,7 @@ var NullCacheDriver = class extends BaseCacheDriver {
 };
 
 //#endregion
-//#region ../cache/src/drivers/pg-cache-driver.ts
+//#region ../../packages/cache/src/drivers/pg-cache-driver.ts
 /** Compare-and-set attempts before `update()` gives up under contention. */
 const PG_UPDATE_MAX_ATTEMPTS = 10;
 /**
@@ -4539,7 +4577,7 @@ var PgCacheDriver = class extends BaseCacheDriver {
 	* keeps its `expires_at`; a missing or expired row restarts from `value`
 	* with the driver default TTL. A non-numeric live value is rejected.
 	*/
-	async increment(key, value = 1) {
+	async increment(key, value = 1, options = {}) {
 		const parsedKey = this.parseKey(key);
 		const t = this.table;
 		const expired = `${t}.expires_at IS NOT NULL AND ${t}.expires_at <= now()`;
@@ -4548,15 +4586,18 @@ var PgCacheDriver = class extends BaseCacheDriver {
        ON CONFLICT (key) DO UPDATE
          SET value = CASE WHEN ${expired} THEN EXCLUDED.value
                           ELSE to_jsonb((${t}.value #>> '{}')::numeric + $2::numeric) END,
-             expires_at = CASE WHEN ${expired} THEN EXCLUDED.expires_at ELSE ${t}.expires_at END,
+             expires_at = CASE WHEN ${expired} THEN EXCLUDED.expires_at
+                               WHEN $4::boolean AND ${t}.expires_at IS NULL THEN EXCLUDED.expires_at
+                               ELSE ${t}.expires_at END,
              stale_at = CASE WHEN ${expired} THEN NULL ELSE ${t}.stale_at END
          WHERE (${expired}) OR jsonb_typeof(${t}.value) = 'number'
        RETURNING value`, [
 			parsedKey,
 			value,
-			this.ttlToSeconds(this.ttl)
+			this.ttlToSeconds(options.ttl === void 0 ? this.ttl : parseTtl(options.ttl)),
+			options.ttl !== void 0
 		]);
-		if (rows.length === 0) throw new Error(`Cannot increment non-numeric value for key: ${parsedKey}`);
+		if (rows.length === 0) throw new Error(`Cannot increment non-numeric value for key: ${(0, _warlock_js_logger.maskEmailsInText)(parsedKey)}`);
 		const newValue = Number(this.decodeJson(rows[0].value));
 		await this.emit("set", {
 			key: parsedKey,
@@ -4757,7 +4798,7 @@ var PgCacheDriver = class extends BaseCacheDriver {
 };
 
 //#endregion
-//#region ../cache/src/drivers/redis-cache-driver.ts
+//#region ../../packages/cache/src/drivers/redis-cache-driver.ts
 /**
 * Cached Redis module (loaded once, reused)
 */
@@ -4821,6 +4862,23 @@ return 1`;
 const REDIS_GET_DEL_SCRIPT = `local v = redis.call('GET', KEYS[1])
 if v then redis.call('DEL', KEYS[1]) end
 return v`;
+/**
+* Increment that gives a counter without an expiry its per-call or default TTL,
+* in one round trip.
+*
+* KEYS[1]=key; ARGV[1]=amount; ARGV[2]=ttl seconds ('0' = none).
+*
+* Replaces `INCRBY` + `EXPIRE … NX`: the `NX` flag needs Redis >= 7.0, and on
+* Redis 6 the second command failed after the count had already gone up.
+* `TTL == -1` means "exists without an expiry", so a TTL set earlier (by
+* `set(..., { ttl })`) is never shortened or reset.
+*/
+const REDIS_INCREMENT_SCRIPT = `local v = redis.call('INCRBY', KEYS[1], ARGV[1])
+local ttl = tonumber(ARGV[2])
+if ttl > 0 and redis.call('TTL', KEYS[1]) == -1 then
+  redis.call('EXPIRE', KEYS[1], ttl)
+end
+return v`;
 /** Compare-and-set attempts before `update()` gives up under contention. */
 const UPDATE_MAX_ATTEMPTS = 10;
 /** Keys deleted per UNLINK/DEL while draining a namespace. */
@@ -5249,11 +5307,15 @@ var RedisCacheDriver = class extends BaseCacheDriver {
 	* Atomic increment using Redis native INCRBY command
 	* {@inheritdoc}
 	*/
-	async increment(key, value = 1) {
+	async increment(key, value = 1, options = {}) {
 		const parsedKey = this.parseKey(key);
 		this.log("caching", parsedKey);
-		const result = await this.client?.incrBy(parsedKey, value);
-		if (this.ttl !== Infinity && this.ttl > 0) await this.client?.expire(parsedKey, this.ttl, "NX");
+		const ttl = options.ttl === void 0 ? this.ttl : parseTtl(options.ttl);
+		const defaultTtl = Number.isFinite(ttl) && ttl > 0 ? Math.ceil(ttl) : 0;
+		const result = defaultTtl > 0 ? Number(await this.client?.eval(REDIS_INCREMENT_SCRIPT, {
+			keys: [parsedKey],
+			arguments: [String(value), String(defaultTtl)]
+		})) : await this.client?.incrBy(parsedKey, value);
 		this.log("cached", parsedKey);
 		await this.emit("set", {
 			key: parsedKey,
@@ -5327,6 +5389,7 @@ exports.PgCacheDriver = PgCacheDriver;
 exports.REDIS_CAS_SET_SCRIPT = REDIS_CAS_SET_SCRIPT;
 exports.REDIS_COMPARE_DELETE_SCRIPT = REDIS_COMPARE_DELETE_SCRIPT;
 exports.REDIS_GET_DEL_SCRIPT = REDIS_GET_DEL_SCRIPT;
+exports.REDIS_INCREMENT_SCRIPT = REDIS_INCREMENT_SCRIPT;
 exports.RedisCacheDriver = RedisCacheDriver;
 exports.ScopedCache = ScopedCache;
 exports.TaggedCache = TaggedCache;