clean up Timer objects when using ttlAutopurge

This prevents a possible runaway resource utilization issue when using
ttlAutopurge.

If a single key is written to repetedly, then many NodeJS.Timer objects
will be created (or equivalent in the browser), and they are not
unscheduled when no longer needed. This results in many checks for
staleness happening unnecessarily, and so on.

Now, when a key is overwritten, set with no TTL, or any other behavior
that will mean that autopurge is no longer necessary, the timer is
cleared and deleted.

Author: isaacs

src/index.ts

@@ -1253,6 +1253,7 @@ export class LRUCache<K extends {}, V extends {}, FC = unknown> {
   #sizes?: ZeroArray
   #starts?: ZeroArray
   #ttls?: ZeroArray
+  #autopurgeTimers?: (undefined | ReturnType<typeof setTimeout>)[]
 
   #hasDispose: boolean
   #hasFetchMethod: boolean
@@ -1277,6 +1278,7 @@ export class LRUCache<K extends {}, V extends {}, FC = unknown> {
       // properties
       starts: c.#starts,
       ttls: c.#ttls,
+      autopurgeTimers: c.#autopurgeTimers,
       sizes: c.#sizes,
       keyMap: c.#keyMap as Map<K, number>,
       keyList: c.#keyList,
@@ -1553,11 +1555,20 @@ 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
+    this.#autopurgeTimers = purgeTimers
 
     this.#setItemTTL = (index, ttl, start = this.#perf.now()) => {
       starts[index] = ttl !== 0 ? start : 0
       ttls[index] = ttl
-      if (ttl !== 0 && this.ttlAutopurge) {
+      // clear out the purge timer if we're setting TTL to 0, and
+      // previously had a ttl purge timer running, so it doesn't
+      // fire unnecessarily.
+      if (purgeTimers?.[index]) {
+        clearTimeout(purgeTimers[index])
+        purgeTimers[index] = undefined
+      }
+      if (ttl !== 0 && purgeTimers) {
         const t = setTimeout(() => {
           if (this.#isStale(index)) {
             this.#delete(this.#keyList[index] as K, 'expire')
@@ -1569,6 +1580,7 @@ export class LRUCache<K extends {}, V extends {}, FC = unknown> {
           t.unref()
         }
         /* c8 ignore stop */
+        purgeTimers[index] = t
       }
     }
 
@@ -2897,6 +2909,10 @@ export class LRUCache<K extends {}, V extends {}, FC = unknown> {
     if (this.#size !== 0) {
       const index = this.#keyMap.get(k)
       if (index !== undefined) {
+        if (this.#autopurgeTimers?.[index]) {
+          clearTimeout(this.#autopurgeTimers?.[index])
+          this.#autopurgeTimers[index] = undefined
+        }
         deleted = true
         if (this.#size === 1) {
           this.#clear(reason)

test/purge-stale-resource-management.ts

@@ -0,0 +1,70 @@
+if (typeof performance === 'undefined') {
+  Object.assign(global, {
+    performance: (await import('perf_hooks')).performance,
+  })
+}
+
+import t from 'tap'
+
+// verify that a large number of ttlAutopurge timeouts won't
+// result in a resource exhaustion problem due to timers being
+// created.
+
+const clock = t.clock
+clock.advance(1)
+
+let timeouts = 0
+const origST = global.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>) {
+  ++clears
+  return origCT.apply(this, args)
+}
+
+//@ts-ignore
+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 })
+
+
+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)