feat(cache): Fallback to older decorator results on error

lib/util/cache/package/decorator.spec.ts

@@ -10,7 +10,7 @@ jest.mock('./file');
 describe('util/cache/package/decorator', () => {
   const spy = jest.fn(() => Promise.resolve());
 
-  beforeAll(async () => {
+  beforeEach(async () => {
     memCache.init();
     await packageCache.init({ cacheDir: os.tmpdir() });
   });
@@ -120,4 +120,65 @@ describe('util/cache/package/decorator', () => {
 
     expect(await getNumber.value?.()).toBeNumber();
   });
+
+  describe('Fallback', () => {
+    const inc = jest.fn();
+
+    class MyClass {
+      @cache({
+        namespace: (x: number) => x.toString(),
+        key: () => 'key',
+        ttlMinutes: 1,
+      })
+      public incNumber(x: number): Promise<number> {
+        return inc(x);
+      }
+    }
+
+    beforeEach(() => {
+      jest.useFakeTimers({ advanceTimers: false });
+      inc.mockImplementation((x: number) => Promise.resolve(x + 1));
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+      inc.mockClear();
+    });
+
+    it('updates cached result', async () => {
+      const myInst = new MyClass();
+
+      expect(await myInst.incNumber(99)).toBe(100);
+
+      jest.advanceTimersByTime(60 * 1000 - 1);
+      expect(await myInst.incNumber(99)).toBe(100);
+      expect(inc).toHaveBeenCalledTimes(1);
+
+      jest.advanceTimersByTime(1);
+      expect(await myInst.incNumber(99)).toBe(100);
+      expect(inc).toHaveBeenCalledTimes(2);
+    });
+
+    it('returns obsolete result on error', async () => {
+      const myInst = new MyClass();
+
+      expect(await myInst.incNumber(99)).toBe(100);
+
+      jest.advanceTimersByTime(60 * 1000);
+      inc.mockRejectedValueOnce(new Error('test'));
+      expect(await myInst.incNumber(99)).toBe(100);
+      expect(inc).toHaveBeenCalledTimes(2);
+    });
+
+    it('re-throws if older result is too old', async () => {
+      const myInst = new MyClass();
+
+      expect(await myInst.incNumber(99)).toBe(100);
+
+      jest.advanceTimersByTime(10 * 60 * 1000);
+      inc.mockRejectedValueOnce(new Error('test'));
+      await expect(myInst.incNumber(99)).rejects.toThrow('test');
+      expect(inc).toHaveBeenCalledTimes(2);
+    });
+  });
 });

lib/util/cache/package/decorator.ts

@@ -1,5 +1,7 @@
 import is from '@sindresorhus/is';
+import { DateTime } from 'luxon';
 import { Decorator, decorate } from '../../decorator';
+import type { DecoratorCachedRecord } from './types';
 import * as packageCache from '.';
 
 type HashFunction<T extends any[] = any[]> = (...args: T) => string;
@@ -66,21 +68,59 @@ export function cache<T>({
       return callback();
     }
 
-    const cachedResult = await packageCache.get<unknown>(
+    finalKey = `cache-decorator:${finalKey}`;
+    const cacheRecord = await packageCache.get<DecoratorCachedRecord<T>>(
       finalNamespace,
       finalKey
     );
 
-    if (cachedResult !== undefined) {
-      return cachedResult;
+    const now = DateTime.local();
+    const ttlHardMinutes = ttlMinutes * 10;
+
+    let oldData: T | undefined;
+    if (cacheRecord) {
+      const softDeadline = DateTime.fromISO(cacheRecord.cachedAt).plus({
+        minutes: ttlMinutes,
+      });
+      const hardDeadline = DateTime.fromISO(cacheRecord.cachedAt).plus({
+        minutes: ttlHardMinutes,
+      });
+
+      if (now < softDeadline) {
+        return cacheRecord.data;
+      }
+
+      if (now < hardDeadline) {
+        oldData = cacheRecord.data;
+      }
     }
 
-    const result = await callback();
+    let newData: T | undefined;
+    if (oldData) {
+      try {
+        newData = (await callback()) as T | undefined;
+      } catch (err) {
+        return oldData;
+      }
+    } else {
+      newData = (await callback()) as T | undefined;
+    }
+
+    if (!is.undefined(newData)) {
+      const cachedAt = now.toISO();
+      const newCacheRecord: DecoratorCachedRecord<T> = {
+        cachedAt,
+        data: newData,
+      };
 
-    // only cache if we got a valid result
-    if (result !== undefined) {
-      await packageCache.set(finalNamespace, finalKey, result, ttlMinutes);
+      await packageCache.set(
+        finalNamespace,
+        finalKey,
+        newCacheRecord,
+        ttlHardMinutes
+      );
     }
-    return result;
+
+    return newData;
   });
 }

lib/util/cache/package/types.ts

@@ -8,3 +8,8 @@ export interface PackageCache {
     ttlMinutes?: number
   ): Promise<void>;
 }
+
+export interface DecoratorCachedRecord<T> {
+  data: T;
+  cachedAt: string;
+}