fix: reschedule autopurge timer when updateAgeOnGet resets TTL start

When updateAgeOnGet (or updateAgeOnHas) resets the start time via
#updateItemAge, the one-shot autopurge timer scheduled by #setItemTTL
is not rescheduled. The timer fires at the original deadline, finds
the entry non-stale (start was reset), does nothing, and no new timer
is ever created -- making the entry immortal.

Fix: reschedule the autopurge timer in #updateItemAge when one exists,
following the same pattern as #setItemTTL.

PR-URL: #392
Credit: @thekauer
Close: #392
Reviewed-by: @isaacs

Author: thekauer

src/index.ts

@@ -1569,6 +1569,22 @@ export class LRUCache<K extends {}, V extends {}, FC = unknown> {
 
     this.#updateItemAge = index => {
       starts[index] = ttls[index] !== 0 ? this.#perf.now() : 0
+      // reschedule autopurge timer so it doesn't find the entry non-stale and go silent
+      if (purgeTimers?.[index]) {
+        clearTimeout(purgeTimers[index])
+        const ttl = ttls[index] as number
+        const t = setTimeout(() => {
+          if (this.#isStale(index)) {
+            this.#delete(this.#keyList[index] as K, 'expire')
+          }
+        }, ttl + 1)
+        /* c8 ignore start */
+        if (t.unref) {
+          t.unref()
+        }
+        /* c8 ignore stop */
+        purgeTimers[index] = t
+      }
     }
 
     this.#statusTTL = (status, index) => {

test/ttl.ts

@@ -480,6 +480,60 @@ const runTests = (LRU: typeof LRUCache, t: Test) => {
     t.end()
   })
 
+  t.test('updateAgeOnGet reschedules ttlAutopurge timer', t => {
+    const c = new LRU({
+      ttl: 100,
+      ttlAutopurge: true,
+      updateAgeOnGet: true,
+      ttlResolution: 0,
+    })
+    // set an entry
+    c.set('a', 1)
+    t.equal(c.size, 1)
+
+    // get it before original TTL expires — this should refresh the TTL
+    clock.advance(80)
+    t.equal(c.get('a'), 1, 'still alive before original TTL')
+    t.equal(c.size, 1, 'size is 1 after get')
+
+    // advance past the original TTL (80 + 30 = 110 from set, but only 30 from get)
+    clock.advance(30)
+    t.equal(c.size, 1, 'entry survives past original TTL because get refreshed it')
+    t.equal(c.get('a'), 1, 'entry is still retrievable')
+
+    // now let the refreshed TTL expire without any more gets
+    // after the second get above, the TTL was refreshed again
+    // advance past that refreshed TTL (100 + 1 for the timer margin)
+    clock.advance(102)
+    t.equal(c.size, 0, 'entry is autopurged after refreshed TTL expires')
+    t.equal(c.get('a'), undefined, 'entry is gone')
+
+    t.end()
+  })
+
+  t.test('updateAgeOnGet + ttlAutopurge: entry eventually purged if not re-accessed', t => {
+    const c = new LRU({
+      ttl: 50,
+      ttlAutopurge: true,
+      updateAgeOnGet: true,
+      ttlResolution: 0,
+    })
+    c.set('b', 2)
+    t.equal(c.size, 1)
+
+    // access once before TTL expires, refreshing the timer
+    clock.advance(30)
+    t.equal(c.get('b'), 2, 'alive before TTL')
+
+    // do NOT access again — let the refreshed TTL expire
+    // the refreshed TTL starts at t=30, expires at t=30+50+1=81
+    clock.advance(52)
+    t.equal(c.size, 0, 'entry autopurged after refreshed TTL with no further access')
+    t.equal(c.get('b'), undefined, 'entry is gone')
+
+    t.end()
+  })
+
   t.end()
 }