cachette 4.0.13 → 4.0.15

package/test/CacheClient_test.ts

@@ -2,11 +2,8 @@ import { expect } from 'chai';
 import { CacheClient } from '../src/lib/CacheClient';
 import { LocalCache } from '../src/lib/LocalCache';
 
-
 describe('CacheClient', () => {
-
   describe('decorator cached()', () => {
-
     interface Response {
       variant: string;
       value: number;
@@ -20,7 +17,7 @@ describe('CacheClient', () => {
       @CacheClient.cached()
       async fetchSomething(variant: string): Promise<Response> {
         this.numCalled++;
-        await new Promise(resolve => setTimeout(resolve, 100));
+        await new Promise((resolve) => setTimeout(resolve, 100));
         return {
           variant: variant,
           value: 100 + parseInt(variant, 10),
@@ -33,7 +30,7 @@ describe('CacheClient', () => {
         throw new Error('nope');
       }
 
-      @CacheClient.cached(undefined, err => err['retryable'] === false) // custom error-caching function: caches only 'retryable' errors
+      @CacheClient.cached(undefined, (err) => err['retryable'] === false) // custom error-caching function: caches only 'retryable' errors
       async throwingMachine2(): Promise<string> {
         this.numCalled++;
         // initially throws a retryable (to assert we don't cache),
@@ -45,10 +42,9 @@ describe('CacheClient', () => {
         }
         throw new Error('nope');
       }
-
     }
 
-    it ('1. provides an error-caching function that caches all errors by default, 2. cohabits with the non-caching function', async () => {
+    it('1. provides an error-caching function that caches all errors by default, 2. cohabits with the non-caching function', async () => {
       const myObj = new MyClass();
       const myObjThrowingMachine1WithErrorCaching = myObj.getErrorCachingFunction('throwingMachine1');
 
@@ -147,7 +143,7 @@ describe('CacheClient', () => {
 
       const results = await Promise.all(jobs);
       let numSuccess = 0;
-      results.forEach(x => {
+      results.forEach((x) => {
         if (x.value === 100 + parseInt(x.variant, 10)) {
           numSuccess++;
         }
@@ -182,85 +178,70 @@ describe('CacheClient', () => {
       cachedValue = await myObj.getCachedFunctionCall('fetchSomething', '123');
       expect(cachedValue).not.to.exist;
     });
-
   });
 
   describe('buildCacheKey', () => {
-
     class MyCacheClient extends CacheClient {
       cacheInstance = new LocalCache();
     }
 
     it('will add null or undefined to the key', async () => {
-
       const cacheClient = new MyCacheClient();
       const key = cacheClient['buildCacheKey']('functionName', [null, undefined, 'argument']);
       expect(key).to.equal('functionName-null-undefined-argument');
-
     });
 
     it('will convert boolean values', async () => {
-
       const cacheClient = new MyCacheClient();
       const key = cacheClient['buildCacheKey']('functionName', ['argument', true, 'argument', false]);
       expect(key).to.equal('functionName-argument-true-argument-false');
-
     });
 
     it('will convert number values', async () => {
-
       const cacheClient = new MyCacheClient();
       const key = cacheClient['buildCacheKey']('functionName', ['argument', 14, 'argument', 16]);
       expect(key).to.equal('functionName-argument-14-argument-16');
-
     });
 
     it('will convert plain object values', async () => {
       const cacheClient = new MyCacheClient();
-      const expectedKey = 'functionName-argument-property1-prop1-property2-prop2-property3-nestedProp1-nestedProp1-nestedProp2-nestedProp2';
+      const expectedKey =
+        'functionName-argument-property1-prop1-property2-prop2-property3-nestedProp1-nestedProp1-nestedProp2-nestedProp2';
 
       const keyWithSortedObjectProperties = cacheClient['buildCacheKey']('functionName', [
         'argument',
-        { property1: 'prop1', property2: 'prop2', property3: { nestedProp1: 'nestedProp1', nestedProp2: 'nestedProp2' } },
+        {
+          property1: 'prop1',
+          property2: 'prop2',
+          property3: { nestedProp1: 'nestedProp1', nestedProp2: 'nestedProp2' },
+        },
         new Date(),
       ]);
       expect(keyWithSortedObjectProperties).to.equal(expectedKey);
-    })
+    });
 
     it('will convert array values', async () => {
       const cacheClient = new MyCacheClient();
       const expectedKey = 'functionName-prop1-propValue1-prop2-propValue2-value1-value2';
 
       const keyWithArrayValues = cacheClient['buildCacheKey']('functionName', [
-       [
-         { prop1: 'propValue1', prop2: 'propValue2' },
-         'value1',
-         'value2',
-       ],
+        [{ prop1: 'propValue1', prop2: 'propValue2' }, 'value1', 'value2'],
       ]);
       expect(keyWithArrayValues).to.equal(expectedKey);
-    })
+    });
 
     it('will convert array values and the result should be the same key if two array own the same properties but not in the same order', async () => {
       const cacheClient = new MyCacheClient();
 
-      const keyWithSortedArrayValues= cacheClient['buildCacheKey']('functionName', [
-        [
-          { prop1: 'propValue1', prop2: 'propValue2' },
-          'value1',
-          'value2',
-        ],
+      const keyWithSortedArrayValues = cacheClient['buildCacheKey']('functionName', [
+        [{ prop1: 'propValue1', prop2: 'propValue2' }, 'value1', 'value2'],
       ]);
 
-      const keyWithUnsortedArrayValues= cacheClient['buildCacheKey']('functionName', [
-        [
-          'value1',
-          'value2',
-          { prop1: 'propValue1', prop2: 'propValue2' },
-        ],
+      const keyWithUnsortedArrayValues = cacheClient['buildCacheKey']('functionName', [
+        ['value1', 'value2', { prop1: 'propValue1', prop2: 'propValue2' }],
       ]);
       expect(keyWithSortedArrayValues).to.equal(keyWithUnsortedArrayValues);
-    })
+    });
 
     it('will convert plain object values and the result should be the same key if two objects have the same properties but not in the same order', async () => {
       const cacheClient = new MyCacheClient();
@@ -277,7 +258,7 @@ describe('CacheClient', () => {
         ['value2', 'value1'],
       ]);
       expect(keyWithUnsortedObjectProperties).to.equal(keyWithSortedObjectProperties);
-    })
+    });
 
     it('should throw if key is bigger than 1000', async () => {
       const cacheClient = new MyCacheClient();
@@ -288,7 +269,7 @@ describe('CacheClient', () => {
       }
 
       expect(() => cacheClient['buildCacheKey']('functionName', [bigArray])).to.throw();
-    })
+    });
 
     it('should detect circular reference in an object', async () => {
       const cacheClient = new MyCacheClient();
@@ -301,18 +282,18 @@ describe('CacheClient', () => {
       obj2.property1 = obj;
 
       expect(() => cacheClient['buildCacheKey']('functionName', [obj2])).to.throw();
-    })
+    });
   });
 
   describe('Redlock maintenance reminder', () => {
-
     it('is still on Redlock v4, or was carefully migrated to v5', () => {
       // eslint-disable-next-line @typescript-eslint/no-require-imports
       const redlockVersion = require('../../package.json').dependencies.redlock;
       if (redlockVersion !== '4.x') {
-        throw new Error('Migrating Redlock to v5? This breaking test is a reminder to:\n  1. Migrate v4 handling of `clientError` events into v5 `error` events\n  2. Review error handling: Redlock v5 throws at many places, while Redlock v4 only threw in its constructor\n  3. Review other breaking changes provided by the upgrade guide, if Redlock maintainers provide one when shipping v5');
+        throw new Error(
+          'Migrating Redlock to v5? This breaking test is a reminder to:\n  1. Migrate v4 handling of `clientError` events into v5 `error` events\n  2. Review error handling: Redlock v5 throws at many places, while Redlock v4 only threw in its constructor\n  3. Review other breaking changes provided by the upgrade guide, if Redlock maintainers provide one when shipping v5',
+        );
       }
     });
-
   });
 });

package/test/CacheInstance_test.ts

@@ -7,14 +7,13 @@ import { WriteThroughCache } from '../src/lib/WriteThroughCache';
 import { CacheInstance, FetchingFunction } from '../src/lib/CacheInstance';
 
 async function sleep(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 // set env var TEST_REDIS_URL (e.g. redis://localhost:6379) to enable running
 // the tests with Redis
 
 describe('CacheInstance', () => {
-
   runTests('local', new LocalCache());
 
   if (process.env.TEST_REDIS_URL) {
@@ -24,13 +23,11 @@ describe('CacheInstance', () => {
     const writeThroughCache = new WriteThroughCache(process.env.TEST_REDIS_URL);
     runTests('writeThrough', writeThroughCache);
   }
-
 });
 
 function runTests(name: string, cache: CacheInstance): void {
-
   const lockSupported = cache.isLockingSupported();
-  const ifLockIt = (cache && cache.isLockingSupported()) ? it : it.skip;
+  const ifLockIt = cache && cache.isLockingSupported() ? it : it.skip;
   let lockSpy: sinon.SinonSpy;
   let unlockSpy: sinon.SinonSpy;
 
@@ -57,9 +54,7 @@ function runTests(name: string, cache: CacheInstance): void {
     }
   });
 
-
   describe(`getOrFetchValue - ${name}`, () => {
-
     beforeEach(() => cache.clear());
 
     it('does not fetch if value in cache', async () => {
@@ -94,11 +89,7 @@ function runTests(name: string, cache: CacheInstance): void {
 
       await cache.setValue('key2', 'value');
       const fetchFunction = object.fetch.bind(object, 'newvalue');
-      const value = await cache.getOrFetchValue(
-        'key',
-        10,
-        fetchFunction,
-      );
+      const value = await cache.getOrFetchValue('key', 10, fetchFunction);
       expect(value).to.eql('newvalue');
       expect(numCalled).to.eql(1);
       if (lockSupported) {
@@ -194,13 +185,8 @@ function runTests(name: string, cache: CacheInstance): void {
       const fetchFunction = object.fetchThatThrowsAfterThree.bind(object, 'newvalue');
 
       let didThrow = false;
-      const getFromCache = async () => cache.getOrFetchValue(
-        'key',
-        10,
-        fetchFunction,
-        undefined,
-        (err) => err.name !== 'NonCacheableError',
-      );
+      const getFromCache = async () =>
+        cache.getOrFetchValue('key', 10, fetchFunction, undefined, (err) => err.name !== 'NonCacheableError');
       try {
         await getFromCache();
       } catch (err) {
@@ -258,11 +244,7 @@ function runTests(name: string, cache: CacheInstance): void {
       await cache.setValue('key2', 'value');
 
       const fetchFunction = object.fetch.bind(object, 'newvalue');
-      const callGetOrFetch = () => cache.getOrFetchValue(
-        'key',
-        10,
-        fetchFunction,
-      );
+      const callGetOrFetch = () => cache.getOrFetchValue('key', 10, fetchFunction);
 
       const calls: Promise<any>[] = [];
       for (let i = 0; i < 100; i++) {
@@ -293,18 +275,14 @@ function runTests(name: string, cache: CacheInstance): void {
 
       const callGetOrFetch = (key, fn) => {
         const fetchFunction = fn.bind(object, 'newvalue');
-        return cache.getOrFetchValue(
-          key,
-          10,
-          fetchFunction,
-        );
+        return cache.getOrFetchValue(key, 10, fetchFunction);
       };
 
       const calls: Promise<any>[] = [];
 
       for (let i = 0; i < 100; i++) {
-        const fn = (i % 2) ? object.fetch1 : object.fetch2;
-        const key = (i % 2) ? 'key1' : 'key2';
+        const fn = i % 2 ? object.fetch1 : object.fetch2;
+        const key = i % 2 ? 'key1' : 'key2';
         calls.push(callGetOrFetch(key, fn as FetchingFunction));
       }
 
@@ -334,11 +312,7 @@ function runTests(name: string, cache: CacheInstance): void {
         },
       };
 
-      const callGetOrFetch = () => cache.getOrFetchValue(
-        'key',
-        10,
-        object.fetch,
-      );
+      const callGetOrFetch = () => cache.getOrFetchValue('key', 10, object.fetch);
 
       const calls: Promise<any>[] = [];
       for (let i = 0; i < 10; i++) {
@@ -448,7 +422,7 @@ function runTests(name: string, cache: CacheInstance): void {
       };
 
       const fetchFunction = object.fetch.bind(object, 'newvalue');
-      const value = await cache.getOrFetchValue(key, 10, fetchFunction, 1);  // enable locking
+      const value = await cache.getOrFetchValue(key, 10, fetchFunction, 1); // enable locking
 
       expect(value).to.eql('newvalue');
       expect(numCalled).to.eql(1);
@@ -479,10 +453,8 @@ function runTests(name: string, cache: CacheInstance): void {
 
       expect(value).to.eql('abcd');
       expect(numCalled).to.eql(0);
-      sinon.assert.calledTwice(lockSpy);   // includes our own call above
+      sinon.assert.calledTwice(lockSpy); // includes our own call above
       sinon.assert.calledTwice(unlockSpy);
     });
-
   });
-
 }

package/test/LocalCache_test.ts

@@ -1,10 +1,10 @@
 import { expect } from 'chai';
+import * as sinon from 'sinon';
 
 import { LocalCache } from '../src/lib/LocalCache';
-
+import { CacheInstance } from '../src/lib/CacheInstance';
 
 describe('LocalCache', () => {
-
   it('can set values', async () => {
     const cache = new LocalCache();
     const wasSet = await cache.setValue('key', 'value');
@@ -50,13 +50,12 @@ describe('LocalCache', () => {
 
   it('can set values with expiry', async () => {
     const cache = new LocalCache();
-    await cache.setValue('key', 'value', .2);
+    await cache.setValue('key', 'value', 0.2);
     let value = await cache.getValue('key');
     expect(value).to.equal('value');
     await sleep(250);
     value = await cache.getValue('key');
     expect(value).to.equal(undefined);
-
   });
 
   it('can delete a value', async () => {
@@ -67,7 +66,6 @@ describe('LocalCache', () => {
     await cache.delValue('key');
 
     expect(await cache.getValue('key')).not.to.exist;
-
   });
 
   it('will not grow in size past the maximum size', async () => {
@@ -92,8 +90,7 @@ describe('LocalCache', () => {
 
     // restore
     LocalCache['DEFAULT_MAX_ITEMS'] = origMax;
-
-  })
+  });
 
   it('can get the remaining TTL of an item', async () => {
     const cache = new LocalCache();
@@ -121,6 +118,104 @@ describe('LocalCache', () => {
     expect(cacheTtl).to.equal(0);
   });
 
+  describe('lock', () => {
+    it('returns a Lock object with value property and unlock method', async () => {
+      const cache = new LocalCache();
+      const lock = await cache.lock('test-resource', 10000);
+
+      expect(lock).to.have.property('value');
+      expect(lock.value).to.be.a('string');
+      expect(lock.value).to.match(/^local-\d+-[a-z0-9]+$/);
+
+      expect(lock).to.have.property('unlock');
+      expect(lock.unlock).to.be.a('function');
+
+      await cache.unlock(lock);
+    });
+
+    it('releases lock via the returned Lock object unlock method', async () => {
+      const cache = new LocalCache();
+      const resource = `test-resource-${Math.random()}`;
+
+      const lock = await cache.lock(resource, 10000);
+      expect(await cache.hasLock(resource)).to.be.true;
+
+      await lock.unlock();
+      expect(await cache.hasLock(resource)).to.be.false;
+    });
+
+    it('releases lock via cache.unlock()', async () => {
+      const cache = new LocalCache();
+      const resource = `test-resource-${Math.random()}`;
+
+      const lock = await cache.lock(resource, 10000);
+      expect(await cache.hasLock(resource)).to.be.true;
+
+      await cache.unlock(lock);
+      expect(await cache.hasLock(resource)).to.be.false;
+    });
+
+    it('with retry = true, retries until lock is available', async () => {
+      // Fake only setTimeout to avoid conflicts with LRU cache's TTL (which uses Date)
+      const clock = sinon.useFakeTimers({ toFake: ['setTimeout'] });
+
+      try {
+        const resource = 'test-resource';
+        const cache = new LocalCache();
+        const hasSpy = sinon.spy(cache['cache'], 'has');
+
+        const firstLock = await cache.lock(resource, 10000);
+        const hasCallsAfterFirstLock = hasSpy.callCount;
+
+        let secondLockAcquired = false;
+        const lockPromise = cache.lock(resource, 10000, true).then((lock) => {
+          secondLockAcquired = true;
+          return lock;
+        });
+
+        // Advance time to trigger retry, but lock still held
+        await clock.tickAsync(CacheInstance.LOCK_RETRY_DELAY_MS);
+        expect(secondLockAcquired).to.be.false;
+        expect(hasSpy.callCount).to.be.greaterThan(hasCallsAfterFirstLock);
+
+        // Release first lock
+        await cache.unlock(firstLock);
+
+        // Advance time for next retry - should acquire now
+        await clock.tickAsync(CacheInstance.LOCK_RETRY_DELAY_MS);
+        const secondLock = await lockPromise;
+
+        expect(secondLockAcquired).to.be.true;
+        expect(secondLock).to.have.property('value');
+
+        hasSpy.restore();
+        await cache.unlock(secondLock);
+      } finally {
+        clock.restore();
+      }
+    });
+
+    it('with retry = false, throws immediately if lock is held', async () => {
+      const cache = new LocalCache();
+      const resource = `test-resource-${Math.random()}`;
+
+      const firstLock = await cache.lock(resource, 10000);
+      expect(await cache.hasLock(resource)).to.be.true;
+
+      let error: Error | undefined;
+      try {
+        await cache.lock(resource, 10000, false);
+      } catch (err) {
+        error = err as Error;
+      }
+
+      expect(error).to.exist;
+      expect(error!.message).to.include('Failed to acquire lock');
+      expect(error!.message).to.include('after 1 attempts');
+
+      await cache.unlock(firstLock);
+    });
+  });
 });
 
 function sleep(ms: number): Promise<void> {

package/test/RedisCache_test.ts

@@ -3,9 +3,7 @@ import * as sinon from 'sinon';
 
 import { RedisCache, SIZE_THRESHOLD_WARNING_BYTES } from '../src/lib/RedisCache';
 
-
 describe('RedisCache', () => {
-
   describe('constructor', () => {
     it('will not crash the application given an invalid Redis URL', async () => {
       let cache = new RedisCache('redis://localhost:9999');
@@ -17,20 +15,15 @@ describe('RedisCache', () => {
     });
 
     it('will raise an error if given a Redis URL without protocol', async () => {
-      expect(
-        () => new RedisCache('rer17kq3qdwc5wmy.4gzf3f.ng.0001.use1.cache.amazonaws.com'),
-      ).to.throw();
+      expect(() => new RedisCache('rer17kq3qdwc5wmy.4gzf3f.ng.0001.use1.cache.amazonaws.com')).to.throw();
     });
 
     it('will raise an error if given a Redis URL with an invalid protocol', async () => {
-      expect(
-        () => new RedisCache('potato://rer17kq3qdwc5wmy.4gzf3f.ng.0001.use1.cache.amazonaws.com'),
-      ).to.throw();
+      expect(() => new RedisCache('potato://rer17kq3qdwc5wmy.4gzf3f.ng.0001.use1.cache.amazonaws.com')).to.throw();
     });
   });
 
   describe('value serialization', () => {
-
     it('can serialize the null value', () => {
       let value = RedisCache.serializeValue(null);
       expect(value).to.equal(RedisCache.NULL_VALUE);
@@ -58,12 +51,15 @@ describe('RedisCache', () => {
       value = RedisCache.deserializeValue(value);
       expect(value).to.deep.equal(obj);
     });
-  
+
     it('can serialize an object with a nested map', () => {
-      const mapStructure: Map<string, {
-        checksum: number;
-        originCommentId?: string;
-      }> = new Map();
+      const mapStructure: Map<
+        string,
+        {
+          checksum: number;
+          originCommentId?: string;
+        }
+      > = new Map();
       mapStructure.set('key1', { checksum: 1, originCommentId: 'c1' });
       mapStructure.set('key2', { checksum: 2, originCommentId: 'c2' });
       const obj = {
@@ -83,7 +79,7 @@ describe('RedisCache', () => {
       value = RedisCache.deserializeValue(value);
       expect(value).to.deep.equal(obj);
     });
-  
+
     it('can serialize an object with a nested set', () => {
       const setStructure: Set<string> = new Set();
       setStructure.add('key1');
@@ -124,7 +120,6 @@ describe('RedisCache', () => {
       const value = RedisCache.deserializeValue(null);
       expect(value).to.equal(undefined);
     });
-
   });
 
   describe('setValue', async () => {
@@ -237,7 +232,10 @@ describe('RedisCache', () => {
       const key = `emits-warning-on-large-value-${Math.random()}`;
       await cache.setValue(key, 'a'.repeat(SIZE_THRESHOLD_WARNING_BYTES));
 
-      const warningsAfterSetLargeKey = warnSpy.getCalls().map(c => c.firstArg).filter(msg => msg.includes('Writing large value to Redis!'));
+      const warningsAfterSetLargeKey = warnSpy
+        .getCalls()
+        .map((c) => c.firstArg)
+        .filter((msg) => msg.includes('Writing large value to Redis!'));
       expect(warningsAfterSetLargeKey.length).to.equal(1);
     });
 
@@ -254,13 +252,15 @@ describe('RedisCache', () => {
       const key = `doesnt-emit-warning-on-small-value-${Math.random()}`;
       await cache.setValue(key, 'a'.repeat(SIZE_THRESHOLD_WARNING_BYTES - 1));
 
-      const warningsAfterSetLargeKey = warnSpy.getCalls().map(c => c.firstArg).filter(msg => msg.includes('Writing large value to Redis!'));
+      const warningsAfterSetLargeKey = warnSpy
+        .getCalls()
+        .map((c) => c.firstArg)
+        .filter((msg) => msg.includes('Writing large value to Redis!'));
       expect(warningsAfterSetLargeKey.length).to.equal(0);
     });
   });
 
   describe('itemCount', async () => {
-
     it('can count the items in the redis cache.', async function (): Promise<void> {
       if (!process.env.TEST_REDIS_URL) {
         this.skip();
@@ -293,7 +293,7 @@ describe('RedisCache', () => {
       await cache.clear();
 
       await cache.setValue('test1', 'value1');
-      
+
       const replicationAcknowledged = await cache.waitForReplication(0, 50);
 
       // No replicas so we expect 0. This test basically confirms that waitForReplication doesn't crash. 🤷‍♂️