WIP

Author: renan628

src/defaultWhileMiss.ts

@@ -6,15 +6,15 @@ export type Configuration<K, V> = {
     /**
      * Handler for background revalidation errors
      */
-    errorHandler?: (error: Error) => void,
+    errorHandler?: (key: K, error: Error) => void,
 };
 
 export class DefaultWhileMissCache<K, V> implements CacheProvider<K, V> {
     private readonly provider: Configuration<K, V>['provider'];
 
     private readonly defaultValue: V;
 
-    private readonly errorHandler: (error: Error) => void;
+    private readonly errorHandler: (key: K, error: Error) => void;
 
     public constructor(config: Configuration<K, V>) {
         this.provider = config.provider;
@@ -24,7 +24,7 @@ export class DefaultWhileMissCache<K, V> implements CacheProvider<K, V> {
 
     public get(key: K, loader: CacheLoader<K, V>): Promise<V> {
         return this.provider.get(key, innerKey => {
-            loader(innerKey).catch(this.errorHandler);
+            loader(innerKey).catch(error => this.errorHandler(key, error));
 
             return Promise.resolve(this.defaultValue);
         });

src/staleWhileRevalidate.ts

@@ -23,7 +23,7 @@ type Configuration<K, V> = {
      * evaluated in the background on subsequent gets, but the stale value
      * will still be served until the revalidation is complete.
      */
-    freshPeriod: number,
+    freshPeriod: number | ((key: K, value: V) => number),
 
     /**
      * The clock to use for time-related operations.
@@ -44,17 +44,17 @@ type Configuration<K, V> = {
      *
      * The most common use case for this handler is logging.
      */
-    errorHandler?: (error: Error) => void,
+    errorHandler?: (key: K, error: Error) => void,
 };
 
 export class StaleWhileRevalidateCache<K, V> implements CacheProvider<K, V> {
     private readonly cacheProvider: Configuration<K, V>['cacheProvider'];
 
-    private readonly freshPeriod: number;
+    private readonly freshPeriod: number | ((key: K, value: V) => number);
 
     private readonly clock: Clock;
 
-    private readonly errorHandler: (error: Error) => void;
+    private readonly errorHandler: (key: K, error: Error) => void;
 
     public constructor(config: Configuration<K, V>) {
         this.cacheProvider = config.cacheProvider;
@@ -79,9 +79,13 @@ export class StaleWhileRevalidateCache<K, V> implements CacheProvider<K, V> {
 
         const possiblyStaleEntry = await this.cacheProvider.get(key, retrieveAndSave);
 
-        if (now.isAfter(possiblyStaleEntry.timestamp.plusSeconds(this.freshPeriod))) {
+        const freshPeriod = typeof this.freshPeriod === 'function'
+            ? this.freshPeriod(key, possiblyStaleEntry.value)
+            : this.freshPeriod;
+
+        if (now.isAfter(possiblyStaleEntry.timestamp.plusSeconds(freshPeriod))) {
             // If expired revalidate on the background and return cached value
-            retrieveAndSave().catch(this.errorHandler);
+            retrieveAndSave().catch(error => this.errorHandler(key, error));
         }
 
         return possiblyStaleEntry.value;

test/defaultWhileMiss.test.ts

@@ -44,7 +44,7 @@ describe('A cache provider that returns a default value while loading in the bac
         expect(loader).toHaveBeenCalledWith('key');
 
         expect(errorHandler).toHaveBeenCalledTimes(1);
-        expect(errorHandler).toHaveBeenCalledWith(error);
+        expect(errorHandler).toHaveBeenCalledWith('key', error);
     });
 
     it('should delegate setting a value to the underlying provider', async () => {

test/staleWhileRevalidate.test.ts

@@ -90,6 +90,93 @@ describe('A cache provider that uses stale values while revalidating the cache',
         expect(mockCache.set).toHaveBeenCalledWith('key', expectedEntry);
     });
 
+    it('should expire entries according to the specified logic', async () => {
+        const now = Instant.ofEpochMilli(12345);
+        const clock = FixedClock.of(now, TimeZone.UTC);
+
+        const cachedEntry: TimestampedCacheEntry<string> = {
+            value: 'cachedValue',
+            timestamp: now.plusSeconds(-11),
+        };
+
+        mockCache.get.mockResolvedValue(cachedEntry);
+
+        let resolveSet: () => void = jest.fn();
+        const setPromise = new Promise<void>(resolve => { resolveSet = resolve; });
+
+        mockCache.set.mockImplementation(() => {
+            resolveSet();
+
+            return setPromise;
+        });
+
+        let resolveloader: (value: string) => any = jest.fn();
+
+        const loader = jest.fn().mockReturnValueOnce(
+            new Promise(resolve => { resolveloader = resolve; }),
+        );
+
+        const cache = new StaleWhileRevalidateCache({
+            cacheProvider: mockCache,
+            freshPeriod: (): number => 10,
+            clock: clock,
+        });
+
+        await expect(cache.get('key', loader)).resolves.toBe('cachedValue');
+
+        expect(mockCache.get).toHaveBeenCalledWith('key', expect.any(Function));
+
+        expect(loader).toHaveBeenCalledWith('key');
+
+        expect(mockCache.set).not.toHaveBeenCalled();
+
+        const expectedEntry: TimestampedCacheEntry<string> = {
+            value: 'loaderValue',
+            timestamp: now,
+        };
+
+        resolveloader('loaderValue');
+
+        await setPromise;
+
+        expect(mockCache.set).toHaveBeenCalledWith('key', expectedEntry);
+    });
+
+    it('should handle errors while revalidating expired entries', async () => {
+        const now = Instant.ofEpochMilli(12345);
+        const clock = FixedClock.of(now, TimeZone.UTC);
+
+        const cachedEntry: TimestampedCacheEntry<string> = {
+            value: 'cachedValue',
+            timestamp: now.plusSeconds(-11),
+        };
+
+        mockCache.get.mockResolvedValue(cachedEntry);
+
+        const error = new Error('error');
+
+        const loader = jest.fn().mockRejectedValueOnce(error);
+
+        const errorHandler = jest.fn();
+
+        const cache = new StaleWhileRevalidateCache({
+            cacheProvider: mockCache,
+            freshPeriod: 10,
+            clock: clock,
+            errorHandler: errorHandler,
+        });
+
+        await expect(cache.get('key', loader)).resolves.toBe('cachedValue');
+
+        expect(mockCache.get).toHaveBeenCalledWith('key', expect.any(Function));
+
+        expect(loader).toHaveBeenCalledWith('key');
+
+        expect(mockCache.set).not.toHaveBeenCalled();
+
+        expect(errorHandler).toHaveBeenCalledWith('key', error);
+    });
+
     it('should returned non-expired entries', async () => {
         const now = Instant.ofEpochMilli(12345);
         const clock = FixedClock.of(now, TimeZone.UTC);