@devvit/cache 0.12.1-next-2025-10-09-21-45-29-add2ad79f.0 → 0.12.1-next-2025-10-09-23-10-17-c0793c292.0

package/PromiseCache.d.ts

@@ -24,7 +24,7 @@ export type Clock = {
 export declare const SystemClock: Clock;
 export type CacheOptions = {
     /**
-     * Time to live in milliseconds.
+     * Time to live in seconds.
      */
     ttl: number;
     /**

package/PromiseCache.js

@@ -9,7 +9,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _PromiseCache_instances, _PromiseCache_redis, _PromiseCache_localCache, _PromiseCache_clock, _PromiseCache_randomizer, _PromiseCache_localCachedAnswer, _PromiseCache_maybeRefreshCache, _PromiseCache_refreshCache, _PromiseCache_pollForCache, _PromiseCache_updateCache, _PromiseCache_calculateRamp, _PromiseCache_redisEntry, _PromiseCache_enforceTTL;
+var _PromiseCache_instances, _PromiseCache_redis, _PromiseCache_localCache, _PromiseCache_clock, _PromiseCache_randomizer, _PromiseCache_localCachedAnswer, _PromiseCache_maybeRefreshCache, _PromiseCache_refreshCache, _PromiseCache_pollForCache, _PromiseCache_updateCache, _PromiseCache_calculateRamp, _PromiseCache_redisEntry;
 // Isolate the random() method to avoid passing the Math package around
 export const MathRandomizer = {
     random() {
@@ -27,9 +27,9 @@ export function _namespaced(key) {
 export function _lock(key) {
     return `__devvit_cache_lock__${key}`;
 }
+const minTtlMsValue = 5000; // milliseconds
 const pollEvery = 300; // milliseconds
 const maxPollingTimeout = 1000; // milliseconds
-const minTtlValue = 5000; // milliseconds
 export const retryLimit = 3;
 const errorRetryProbability = 0.1;
 export const clientRetryDelay = 1000; // milliseconds
@@ -101,13 +101,18 @@ export class PromiseCache {
      * - SET __lock__${key} '1' and DEL __lock__${key} to acquire and release a lock for a given key
      */
     async cache(closure, options) {
-        __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_enforceTTL).call(this, options);
-        const localCachedAnswer = __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_localCachedAnswer).call(this, options.key);
+        const { key } = options;
+        let ttlMs = options.ttl * 1000; // convert to milliseconds without mutating the original options object
+        if (ttlMs < minTtlMsValue) {
+            console.warn(`Cache TTL cannot be less than ${minTtlMsValue / 1000} seconds! Updating ttl value to ${minTtlMsValue / 1000} seconds.`);
+            ttlMs = minTtlMsValue;
+        }
+        const localCachedAnswer = __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_localCachedAnswer).call(this, key);
         if (localCachedAnswer !== undefined) {
             return localCachedAnswer;
         }
-        const existing = await __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_redisEntry).call(this, options.key);
-        const entry = await __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_maybeRefreshCache).call(this, options, existing, closure);
+        const existing = await __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_redisEntry).call(this, key);
+        const entry = await __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_maybeRefreshCache).call(this, key, ttlMs, existing, closure);
         return _unwrap(entry);
     }
 }
@@ -137,7 +142,7 @@ _PromiseCache_redis = new WeakMap(), _PromiseCache_localCache = new WeakMap(), _
  *
  * We'll always refresh if missing or expired, but its probabilistic if we'll refresh if about to expire or if we have an error.
  */
-async function _PromiseCache_maybeRefreshCache(options, entry, closure) {
+async function _PromiseCache_maybeRefreshCache(key, ttlMs, entry, closure) {
     const expires = entry?.expires;
     const rampProbability = expires ? __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_calculateRamp).call(this, expires) : 1;
     if (!entry ||
@@ -145,7 +150,7 @@ async function _PromiseCache_maybeRefreshCache(options, entry, closure) {
             entry.errorCount < retryLimit &&
             errorRetryProbability > __classPrivateFieldGet(this, _PromiseCache_randomizer, "f").random()) ||
         rampProbability > __classPrivateFieldGet(this, _PromiseCache_randomizer, "f").random()) {
-        return __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_refreshCache).call(this, options, entry, closure);
+        return __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_refreshCache).call(this, key, ttlMs, entry, closure);
     }
     else {
         return entry;
@@ -157,19 +162,19 @@ async function _PromiseCache_maybeRefreshCache(options, entry, closure) {
  *
  * If you don't win the lock, you'll poll for the cache.  If you don't get the cache within maxPollingTimeout, you'll throw an error.
  */
-async function _PromiseCache_refreshCache(options, entry, closure) {
-    const lockKey = _lock(options.key);
+async function _PromiseCache_refreshCache(key, ttlMs, entry, closure) {
+    const lockKey = _lock(key);
     const now = __classPrivateFieldGet(this, _PromiseCache_clock, "f").now().getTime();
     /**
      * The write lock should last for a while, but not the full TTL.  Hopefully write attempts settle down after a while.
      */
-    const lockExpiration = new Date(now + options.ttl / 2);
+    const lockExpiration = new Date(now + ttlMs / 2);
     const lockObtained = await __classPrivateFieldGet(this, _PromiseCache_redis, "f").set(lockKey, '1', {
         expiration: lockExpiration,
         nx: true,
     });
     if (lockObtained) {
-        return __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_updateCache).call(this, options.key, entry, closure, options.ttl);
+        return __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_updateCache).call(this, key, entry, closure, ttlMs);
     }
     else if (entry) {
         // This entry is still valid, return it
@@ -177,10 +182,10 @@ async function _PromiseCache_refreshCache(options, entry, closure) {
     }
     else {
         const start = __classPrivateFieldGet(this, _PromiseCache_clock, "f").now();
-        return __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_pollForCache).call(this, start, options.key, options.ttl);
+        return __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_pollForCache).call(this, start, key, ttlMs);
     }
-}, _PromiseCache_pollForCache = async function _PromiseCache_pollForCache(start, key, ttl) {
-    const pollingTimeout = Math.min(ttl, maxPollingTimeout);
+}, _PromiseCache_pollForCache = async function _PromiseCache_pollForCache(start, key, ttlMs) {
+    const pollingTimeout = Math.min(ttlMs, maxPollingTimeout);
     const existing = await __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_redisEntry).call(this, key);
     if (existing) {
         return existing;
@@ -189,13 +194,13 @@ async function _PromiseCache_refreshCache(options, entry, closure) {
         throw new Error(`Cache request timed out trying to get data at key: ${key}`);
     }
     await new Promise((resolve) => setTimeout(resolve, pollEvery));
-    return __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_pollForCache).call(this, start, key, ttl);
+    return __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_pollForCache).call(this, start, key, ttlMs);
 }, _PromiseCache_updateCache = 
 /**
  * Actually update the cache.  This is the method that will be called if we have the lock.
  */
-async function _PromiseCache_updateCache(key, entry, closure, ttl) {
-    const expires = __classPrivateFieldGet(this, _PromiseCache_clock, "f").now().getTime() + ttl;
+async function _PromiseCache_updateCache(key, entry, closure, ttlMs) {
+    const expires = __classPrivateFieldGet(this, _PromiseCache_clock, "f").now().getTime() + ttlMs;
     entry = entry ?? {
         value: null,
         expires,
@@ -255,9 +260,4 @@ async function _PromiseCache_updateCache(key, entry, closure, ttl) {
         return entry;
     }
     return undefined;
-}, _PromiseCache_enforceTTL = function _PromiseCache_enforceTTL(options) {
-    if (options.ttl < minTtlValue) {
-        console.warn(`Cache TTL cannot be less than ${minTtlValue} milliseconds! Updating ttl value of ${options.ttl} to ${minTtlValue}.`);
-        options.ttl = minTtlValue;
-    }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devvit/cache",
-  "version": "0.12.1-next-2025-10-09-21-45-29-add2ad79f.0",
+  "version": "0.12.1-next-2025-10-09-23-10-17-c0793c292.0",
   "license": "BSD-3-Clause",
   "repository": {
     "type": "git",
@@ -31,15 +31,15 @@
     "test:unit-with-coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "@devvit/redis": "0.12.1-next-2025-10-09-21-45-29-add2ad79f.0",
-    "@devvit/shared-types": "0.12.1-next-2025-10-09-21-45-29-add2ad79f.0"
+    "@devvit/redis": "0.12.1-next-2025-10-09-23-10-17-c0793c292.0",
+    "@devvit/shared-types": "0.12.1-next-2025-10-09-23-10-17-c0793c292.0"
   },
   "devDependencies": {
-    "@devvit/repo-tools": "0.12.1-next-2025-10-09-21-45-29-add2ad79f.0",
-    "@devvit/tsconfig": "0.12.1-next-2025-10-09-21-45-29-add2ad79f.0",
+    "@devvit/repo-tools": "0.12.1-next-2025-10-09-23-10-17-c0793c292.0",
+    "@devvit/tsconfig": "0.12.1-next-2025-10-09-23-10-17-c0793c292.0",
     "eslint": "9.11.1",
     "typescript": "5.8.3",
     "vitest": "1.6.1"
   },
-  "gitHead": "e51c2e6fbb23434d3bc2053c7a835c1ab8f1d225"
+  "gitHead": "704e966f3a13c15799c23625bb48ebeef2f8e2bd"
 }