Preserve fetch promises working in the background

Fix: #389

Author: isaacs

src/index.ts

@@ -2342,6 +2342,8 @@ export class LRUCache<K extends {}, V extends {}, FC = unknown> {
     const cb = (v: V | undefined, updateCache = false): V | undefined => {
       const { aborted } = ac.signal
       const ignoreAbort = options.ignoreFetchAbort && v !== undefined
+      const proceed = options.ignoreFetchAbort ||
+        !!(options.allowStaleOnFetchAbort && v !== undefined)
       if (options.status) {
         if (aborted && !updateCache) {
           options.status.fetchAborted = true
@@ -2352,7 +2354,7 @@ export class LRUCache<K extends {}, V extends {}, FC = unknown> {
         }
       }
       if (aborted && !ignoreAbort && !updateCache) {
-        return fetchFail(ac.signal.reason)
+        return fetchFail(ac.signal.reason, proceed)
       }
       // either we didn't abort, and are still here, or we did, and ignored
       const bf = p as BackgroundFetch<V>
@@ -2380,10 +2382,11 @@ export class LRUCache<K extends {}, V extends {}, FC = unknown> {
         options.status.fetchRejected = true
         options.status.fetchError = er
       }
-      return fetchFail(er)
+      // do not pass go, do not collect $200
+      return fetchFail(er, false)
     }
 
-    const fetchFail = (er: any): V | undefined => {
+    const fetchFail = (er: any, proceed: boolean): V | undefined => {
       const { aborted } = ac.signal
       const allowStaleAborted = aborted && options.allowStaleOnFetchAbort
       const allowStale =
@@ -2393,7 +2396,8 @@ export class LRUCache<K extends {}, V extends {}, FC = unknown> {
       if (this.#valList[index as Index] === p) {
         // if we allow stale on fetch rejections, then we need to ensure that
         // the stale value is not removed from the cache when the fetch fails.
-        const del = !noDelete || bf.__staleWhileFetching === undefined
+        const del = !noDelete ||
+          !proceed && bf.__staleWhileFetching === undefined
         if (del) {
           this.#delete(k, 'fetch')
         } else if (!allowStaleAborted) {

test/lost-background-fetch.ts

@@ -0,0 +1,68 @@
+// https://github.com/isaacs/node-lru-cache/issues/389
+import t from 'tap'
+
+const clock = t.clock
+clock.enter()
+
+const { LRUCache } = await import('../src/index.js')
+
+const c = new LRUCache<number, number, void>({
+  ttl: 1000,
+  max: 10,
+  ignoreFetchAbort: true,
+  allowStaleOnFetchAbort: true,
+  fetchMethod: async k => {
+    return new Promise(res => {
+      setTimeout(() => {
+        res(k)
+      }, 100 * k)
+    })
+  },
+})
+
+// c.set(1, 10)
+// c.set(2, 20)
+
+// make them stale
+// clock.advance(2000)
+
+//t.ok(c.getRemainingTTL(1) < 0, {
+//  found: c.getRemainingTTL(1),
+//  wanted: '< 0',
+//})
+//t.ok(c.getRemainingTTL(2) < 0, {
+//  found: c.getRemainingTTL(2),
+//  wanted: '< 0',
+//})
+
+const ac = new AbortController()
+const ac2 = new AbortController()
+// fails
+const p2 = c.fetch(2, { signal: ac.signal })
+const p1 = c.fetch(1, { signal: ac.signal })
+
+//c.set(3, 3)
+
+// works
+// const p1 = c.fetch(1, { signal: ac.signal })
+// const p2 = c.fetch(2, { signal: ac.signal })
+
+clock.advance(50)
+await new Promise<void>(res => queueMicrotask(res))
+ac.abort(new Error('gimme the stale value'))
+ac2.abort(new Error('gimme the stale value 2'))
+t.equal(await p1, undefined)
+t.equal(await p2, undefined)
+
+t.equal(c.get(1, { allowStale: true }), undefined, 'get expect undef 1')
+t.equal(c.get(2, { allowStale: true }), undefined, 'get expect undef 2')
+
+clock.advance(100)
+await new Promise<void>(res => queueMicrotask(res)).then(() => {})
+t.equal(c.get(1), 1, 'get expect 1')
+t.equal(c.get(2), undefined, 'get 2 expect undef')
+
+clock.advance(100)
+await new Promise<void>(res => queueMicrotask(res)).then(() => {})
+t.equal(c.get(1), 1, 'get expect 1')
+t.equal(c.get(2), 2, 'get expect 2')