autopurge: also clear timers for eviction, clear()

Author: isaacs

src/index.ts

@@ -1555,7 +1555,12 @@ export class LRUCache<K extends {}, V extends {}, FC = unknown> {
     const starts = new ZeroArray(this.#max)
     this.#ttls = ttls
     this.#starts = starts
-    const purgeTimers = this.ttlAutopurge ? new Array<undefined | ReturnType<typeof setTimeout>>(this.#max) : undefined
+    const purgeTimers =
+      this.ttlAutopurge ?
+        new Array<undefined | ReturnType<typeof setTimeout>>(
+          this.#max,
+        )
+      : undefined
     this.#autopurgeTimers = purgeTimers
 
     this.#setItemTTL = (index, ttl, start = this.#perf.now()) => {
@@ -2270,6 +2275,10 @@ export class LRUCache<K extends {}, V extends {}, FC = unknown> {
       }
     }
     this.#removeItemSize(head)
+    if (this.#autopurgeTimers?.[head]) {
+      clearTimeout(this.#autopurgeTimers[head])
+      this.#autopurgeTimers[head] = undefined
+    }
     // if we aren't about to use the index, then null these out
     if (free) {
       this.#keyList[head] = undefined
@@ -2403,7 +2412,10 @@ export class LRUCache<K extends {}, V extends {}, FC = unknown> {
       // cache and ignore the abort, or if it's still pending on this specific
       // background request, then write it to the cache.
       const vl = this.#valList[index as Index]
-      if (vl === p || ignoreAbort && updateCache && vl === undefined) {
+      if (
+        vl === p ||
+        (ignoreAbort && updateCache && vl === undefined)
+      ) {
         if (v === undefined) {
           if (bf.__staleWhileFetching !== undefined) {
             this.#valList[index as Index] = bf.__staleWhileFetching
@@ -2985,6 +2997,10 @@ export class LRUCache<K extends {}, V extends {}, FC = unknown> {
     if (this.#ttls && this.#starts) {
       this.#ttls.fill(0)
       this.#starts.fill(0)
+      for (const t of this.#autopurgeTimers ?? []) {
+        if (t !== undefined) clearTimeout(t)
+      }
+      this.#autopurgeTimers?.fill(undefined)
     }
     if (this.#sizes) {
       this.#sizes.fill(0)

test/purge-stale-resource-management.ts

@@ -15,13 +15,19 @@ clock.advance(1)
 
 let timeouts = 0
 const origST = global.setTimeout
-const newST = function (this: any, ...args: Parameters<typeof setTimeout>) {
+const newST = function (
+  this: any,
+  ...args: Parameters<typeof setTimeout>
+) {
   ++timeouts
   return origST.apply(this, args)
 }
 let clears = 0
 const origCT = global.clearTimeout
-const newCT = function (this: any, ...args: Parameters<typeof clearTimeout>) {
+const newCT = function (
+  this: any,
+  ...args: Parameters<typeof clearTimeout>
+) {
   ++clears
   return origCT.apply(this, args)
 }
@@ -31,40 +37,100 @@ global.setTimeout = newST
 //@ts-ignore
 global.clearTimeout = newCT
 
-
 const { LRUCache: LRU } = await import('../dist/esm/index.js')
 
-const cache = new LRU<string, number>({ ttl: 10, ttlAutopurge: true })
+t.test('a cache that overwrites a hot key many times', async t => {
+  const cache = new LRU<string, number>({
+    ttl: 10,
+    ttlAutopurge: true,
+  })
+
+  const N = 10 //_000
+  for (let i = 0; i < N; i++) {
+    cache.set('hot-key', i)
+  }
+  t.equal(timeouts, N)
+  t.equal(clears, N - 1)
 
+  timeouts = 0
+  clears = 0
+  cache.set('hot-key', 99, { ttl: 0 })
+  const clearsAfterSetTTL0 = clears
+  const timeoutsAfterSetTTL0 = timeouts
 
-const N = 10//_000
-for (let i = 0; i < N; i++) {
-  cache.set('hot-key', i)
-}
-t.equal(timeouts, N)
-t.equal(clears, N + 1)
-
-timeouts = 0
-clears = 0
-cache.set('hot-key', 99, { ttl: 0 })
-const clearsAfterSetTTL0 = clears
-const timeoutsAfterSetTTL0 = timeouts
-
-t.equal(timeoutsAfterSetTTL0, 0)
-t.equal(clearsAfterSetTTL0, 1)
-
-timeouts = 0
-clears = 0
-cache.set('hot-key', 100)
-const clearsAfterSetTTLDef = clears
-const timeoutsAfterSetTTLDef = timeouts
-t.equal(clearsAfterSetTTLDef, 0)
-t.equal(timeoutsAfterSetTTLDef, 1)
-
-timeouts = 0
-clears = 0
-cache.delete('hot-key')
-const clearsAfterDelete = clears
-const timeoutsAfterDelete = timeouts
-t.equal(clearsAfterDelete, 1)
-t.equal(timeoutsAfterDelete, 0)
+  t.equal(timeoutsAfterSetTTL0, 0)
+  t.equal(clearsAfterSetTTL0, 1)
+
+  timeouts = 0
+  clears = 0
+  cache.set('hot-key', 100)
+  const clearsAfterSetTTLDef = clears
+  const timeoutsAfterSetTTLDef = timeouts
+  t.equal(clearsAfterSetTTLDef, 0)
+  t.equal(timeoutsAfterSetTTLDef, 1)
+
+  timeouts = 0
+  clears = 0
+  cache.delete('hot-key')
+  const clearsAfterDelete = clears
+  const timeoutsAfterDelete = timeouts
+  t.equal(clearsAfterDelete, 1)
+  t.equal(timeoutsAfterDelete, 0)
+})
+
+t.test('evicting an item means no need for autopurge', async t => {
+  const cache = new LRU<string, number>({
+    ttl: 10,
+    max: 5,
+    ttlAutopurge: true,
+  })
+
+  timeouts = 0
+  clears = 0
+  cache.set('a', 1)
+  const clearsAfterSet = clears
+  const timeoutsAfterSet = timeouts
+  t.equal(clearsAfterSet, 0)
+  t.equal(timeoutsAfterSet, 1)
+
+  timeouts = 0
+  clears = 0
+  cache.set('b', 1, { ttl: 0 })
+  cache.set('c', 1, { ttl: 0 })
+  cache.set('d', 1, { ttl: 0 })
+  cache.set('e', 1, { ttl: 0 })
+  cache.set('f', 1, { ttl: 0 })
+
+  const clearsAfterEvict = clears
+  const timeoutsAfterEvict = timeouts
+  t.equal(clearsAfterEvict, 1)
+  t.equal(timeoutsAfterEvict, 0)
+})
+
+t.test('clearing list clears autopurge timers', async t => {
+  const cache = new LRU<string, number>({
+    ttl: 10,
+    max: 5,
+    ttlAutopurge: true,
+  })
+
+  timeouts = 0
+  clears = 0
+  cache.set('a', 1)
+  cache.set('b', 1)
+  cache.set('c', 1)
+  cache.set('d', 1)
+  const clearsAfterSet = clears
+  const timeoutsAfterSet = timeouts
+  t.equal(clearsAfterSet, 0)
+  t.equal(timeoutsAfterSet, 4)
+
+  timeouts = 0
+  clears = 0
+  cache.clear()
+
+  const clearsAfterClear = clears
+  const timeoutsAfterClear = timeouts
+  t.equal(clearsAfterClear, 4)
+  t.equal(timeoutsAfterClear, 0)
+})