Allow ignored-abort fetches to update cache

Very niche edge case, but happens when a fetch implementation is
aborted, but the underlying fetch implementation was not aborted, and no
value existed in the cache already.

In this case, it *should* update the stored cached value, but was not,
because the pending fetch was not stored.

Fix: isaacs#388

Author: isaacs

src/index.ts

@@ -2387,7 +2387,11 @@ export class LRUCache<K extends {}, V extends {}, FC = unknown> {
       }
       // either we didn't abort, and are still here, or we did, and ignored
       const bf = p as BackgroundFetch<V>
-      if (this.#valList[index as Index] === p) {
+      // if nothing else has been written there but we're set to update the
+      // 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 (v === undefined) {
           if (bf.__staleWhileFetching !== undefined) {
             this.#valList[index as Index] = bf.__staleWhileFetching

test/fetch.ts

@@ -870,3 +870,28 @@ t.test('properly dispose when using fetch', async t => {
   t.strictSame(disposes, [[0, 1, 'set']])
   t.strictSame(disposeAfters, [[0, 1, 'set']])
 })
+
+t.test('allowStaleOnFetchAbort and ignoreFetchAbort', async t => {
+  const c = new LRUCache<number, number, void>({
+    ttl: 10,
+    max: 10,
+    ignoreFetchAbort: true,
+    allowStaleOnFetchAbort: true,
+    fetchMethod: async k => {
+      return new Promise(res => {
+        setTimeout(() => {
+          res(k)
+        }, 100)
+      })
+    },
+  })
+  const ac = new AbortController()
+  const p = c.fetch(1, { signal: ac.signal })
+  await new Promise<void>(res => queueMicrotask(res))
+  ac.abort(new Error('gimme the stale value'))
+  t.equal(await p, undefined)
+  t.equal(c.get(1, { allowStale: true }), undefined)
+  clock.advance(200)
+  await new Promise<void>(res => queueMicrotask(res)).then(() => {})
+  t.equal(c.get(1), 1)
+})