cachette 4.0.12 → 4.0.14

package/src/lib/LocalCache.ts

@@ -3,11 +3,10 @@ import { LRUCache } from 'lru-cache';
 import { CachableValue, CacheInstance } from './CacheInstance';
 
 async function sleep(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 export class LocalCache extends CacheInstance {
-
   public static DEFAULT_MAX_ITEMS = 5000;
   // Default maximum age for the items, in MS.
   public static DEFAULT_MAX_AGE: number = 30 * 60 * 1000;
@@ -126,12 +125,12 @@ export class LocalCache extends CacheInstance {
    */
   public async lock(resource: string, ttlMs: number): Promise<any> {
     let isLocked = true;
-    const startTimestamp = Date.now()
-    while(isLocked) {
+    const startTimestamp = Date.now();
+    while (isLocked) {
       if (Date.now() - startTimestamp > LocalCache.LOCK_ACQUIRE_TIMEOUT) {
-        throw new Error(`Abandoning locking ${resource} , as timed out while waiting for other lock to be released.`)
+        throw new Error(`Abandoning locking ${resource} , as timed out while waiting for other lock to be released.`);
       }
-      this.cache.purgeStale()
+      this.cache.purgeStale();
       if (!this.cache.has(resource)) {
         isLocked = false;
       } else {
@@ -141,7 +140,9 @@ export class LocalCache extends CacheInstance {
       }
     }
     this.cache.set(resource, 1, { ttl: ttlMs });
-    return new Promise(resolve => { resolve(resource) });
+    return new Promise((resolve) => {
+      resolve(resource);
+    });
   }
 
   /**
@@ -149,7 +150,9 @@ export class LocalCache extends CacheInstance {
    */
   public async unlock(lock: any): Promise<void> {
     this.cache.delete(lock);
-    return new Promise(resolve => { resolve() });
+    return new Promise((resolve) => {
+      resolve();
+    });
   }
 
   /**
@@ -172,7 +175,8 @@ export class LocalCache extends CacheInstance {
         found = true;
       }
     });
-    return new Promise((resolve) => { resolve(found) });
+    return new Promise((resolve) => {
+      resolve(found);
+    });
   }
-
 }

package/src/lib/RedisCache.ts

@@ -18,7 +18,6 @@ export interface Lock {
  * or the process might crash unexpectedly.
  */
 export class RedisCache extends CacheInstance {
-
   /**
    * We cannot store null and booleans in Redis, so we store
    * random values representing these values instead.
@@ -66,13 +65,15 @@ export class RedisCache extends CacheInstance {
       // This prevents get/setValue calls from hanging if there is no active connection
       enableOfflineQueue: false,
     });
-    this.redlock = new Redlock([this.redisClient as unknown as Redlock.CompatibleRedisClient], { // Hack until Redlock 5.x is out of beta
+    this.redlock = new Redlock([this.redisClient as unknown as Redlock.CompatibleRedisClient], {
+      // Hack until Redlock 5.x is out of beta
       driftFactor: RedisCache.REDLOCK_CLOCK_DRIFT_FACTOR,
       retryCount: RedisCache.REDLOCK_RETRY_COUNT,
       retryDelay: RedisCache.REDLOCK_RETRY_DELAY_MS,
       retryJitter: RedisCache.REDLOCK_JITTER_MS,
     });
-    this.redlockWithoutRetry = new Redlock([this.redisClient as unknown as Redlock.CompatibleRedisClient], { // Hack until Redlock 5.x is out of beta
+    this.redlockWithoutRetry = new Redlock([this.redisClient as unknown as Redlock.CompatibleRedisClient], {
+      // Hack until Redlock 5.x is out of beta
       driftFactor: RedisCache.REDLOCK_CLOCK_DRIFT_FACTOR,
       retryCount: 0,
       retryDelay: 0,
@@ -95,7 +96,7 @@ export class RedisCache extends CacheInstance {
     if (this.ready) {
       return;
     }
-    return new Promise<void>(resolve => this.redisClient.on('ready', resolve));
+    return new Promise<void>((resolve) => this.redisClient.on('ready', resolve));
   }
 
   /**
@@ -147,7 +148,6 @@ export class RedisCache extends CacheInstance {
    *
    */
   public static serializeValue(value: CachableValue): string {
-
     if (value === null) {
       return RedisCache.NULL_VALUE;
     }
@@ -161,10 +161,13 @@ export class RedisCache extends CacheInstance {
     }
 
     if (value instanceof Error) {
-      return RedisCache.ERROR_PREFIX + JSON.stringify({
-        ...value, // serialize potential Error metadata set as object properties
-        message: value.message,
-      });
+      return (
+        RedisCache.ERROR_PREFIX +
+        JSON.stringify({
+          ...value, // serialize potential Error metadata set as object properties
+          message: value.message,
+        })
+      );
     }
 
     if (typeof value === 'number') {
@@ -172,15 +175,18 @@ export class RedisCache extends CacheInstance {
     }
 
     if (value instanceof Object) {
-      return RedisCache.JSON_PREFIX + JSON.stringify(value,  (key, value) => {
-        if (value instanceof Set) {
-          return { __dataType: 'Set', value: Array.from(value) };
-        } else if (value instanceof Map) {
-          return { __dataType: 'Map', value: Array.from(value) };
-        } else {
-          return value;
-        }
-      });
+      return (
+        RedisCache.JSON_PREFIX +
+        JSON.stringify(value, (key, value) => {
+          if (value instanceof Set) {
+            return { __dataType: 'Set', value: Array.from(value) };
+          } else if (value instanceof Map) {
+            return { __dataType: 'Map', value: Array.from(value) };
+          } else {
+            return value;
+          }
+        })
+      );
     }
 
     return value;
@@ -199,7 +205,6 @@ export class RedisCache extends CacheInstance {
    *
    */
   public static deserializeValue(value: string | null): CachableValue {
-
     if (value === null) {
       // null means that the key was not present, which we interpret as undefined.
       return undefined;
@@ -245,34 +250,28 @@ export class RedisCache extends CacheInstance {
     }
 
     return value;
-
   }
 
   /**
    * @inheritdoc
    */
-  public async setValue(
-    key: string,
-    value: CachableValue,
-    ttl = 0,
-  ): Promise<boolean> {
+  public async setValue(key: string, value: CachableValue, ttl = 0): Promise<boolean> {
     try {
       return await this.setValueInternal(key, value, ttl);
     } catch (err) {
-       // Examples of things that may occur here:
-       // - A timeout, if the connection was broken during a value fetch.
-       // - A general error, e.g. if Redis is Out Of Memory.
+      // Examples of things that may occur here:
+      // - A timeout, if the connection was broken during a value fetch.
+      // - A general error, e.g. if Redis is Out Of Memory.
       const error = err as Error;
-      this.emit('warn', `Error while setting Redis key ${key} with ttl ${ttl}: ${error.name} - ${error.message}\n${error.stack}`);
+      this.emit(
+        'warn',
+        `Error while setting Redis key ${key} with ttl ${ttl}: ${error.name} - ${error.message}\n${error.stack}`,
+      );
       return false;
     }
   }
 
-  public async setValueInternal(
-    key: string,
-    value: CachableValue,
-    ttl: number,
-  ): Promise<boolean> {
+  public async setValueInternal(key: string, value: CachableValue, ttl: number): Promise<boolean> {
     this.emit('set', key, value);
 
     if (value === undefined) {
@@ -387,7 +386,7 @@ export class RedisCache extends CacheInstance {
 
     return {
       value: internalLock.value,
-      unlock: async () => internalLock.unlock()
+      unlock: async () => internalLock.unlock(),
     };
   }
 
@@ -420,11 +419,18 @@ export class RedisCache extends CacheInstance {
   public async hasLock(prefix: string): Promise<boolean> {
     const redisPrefix = prefix.endsWith('*') ? prefix : `${prefix}*`;
     let cursor = '';
-    while (cursor !== '0') { // indicates Redis completed the scan
+    while (cursor !== '0') {
+      // indicates Redis completed the scan
       // Redis detail: we set the `count` option to a number (1000) greater than
       // the default (10), to minimize the amount of network round-trips caused
       // by incomplete scans needing more scanning from the returned cursor.
-      const [nextCursor, matchingKeys] = await this.redisClient.scan(cursor || '0', 'MATCH', redisPrefix, 'COUNT', 1000);
+      const [nextCursor, matchingKeys] = await this.redisClient.scan(
+        cursor || '0',
+        'MATCH',
+        redisPrefix,
+        'COUNT',
+        1000,
+      );
       if (matchingKeys.length > 0) {
         return true;
       }
@@ -437,5 +443,4 @@ export class RedisCache extends CacheInstance {
   public async quit(): Promise<void> {
     await this.redisClient.quit();
   }
-
 }

package/src/lib/WriteThroughCache.ts

@@ -2,7 +2,6 @@ import { CachableValue, CacheInstance } from './CacheInstance';
 import { RedisCache } from './RedisCache';
 import { LocalCache } from './LocalCache';
 
-
 /**
  * Write-through cache, using Redis and a local LRU cache with aligned TTLs.
  *
@@ -31,7 +30,6 @@ import { LocalCache } from './LocalCache';
  *    "pub/sub traffic explosion" is a non-concern? To be evaluated :)
  */
 export class WriteThroughCache extends CacheInstance {
-
   private redisCacheForWriting: CacheInstance;
   private redisCacheForReading: CacheInstance;
   private localCache: CacheInstance;
@@ -59,26 +57,33 @@ export class WriteThroughCache extends CacheInstance {
       const metricsPeriod = parseInt(process.env.CACHETTE_METRICS_PERIOD_MINUTES, 10);
       if (Number.isInteger(metricsPeriod) && metricsPeriod > 0) {
         this.metrics.enabled = true;
-        this.redisCacheForWriting.emit('info', `WriteThroughCache metrics enabled, will report every ${metricsPeriod} min`);
-        setInterval(() => {
-          const total = this.metrics.localHits + this.metrics.redisHits + this.metrics.doubleMisses;
-          this.redisCacheForWriting.emit(
-            'info',
-            `WriteThroughCache metrics during last ${metricsPeriod} min - Total: ${total}, ` +
-            `Local hits: ${this.metrics.localHits} (${total && Math.floor(100 * this.metrics.localHits / total)}%), ` +
-            `Redis hits: ${this.metrics.redisHits} (${total && Math.floor(100 * this.metrics.redisHits / total)}%), ` +
-            `Double misses: ${this.metrics.doubleMisses} (${total && Math.floor(100 * this.metrics.doubleMisses / total)}%).`,
-          );
-
-          this.metrics.localHits = 0;
-          this.metrics.redisHits = 0;
-          this.metrics.doubleMisses = 0;
-        }, metricsPeriod * 60 * 1000);
+        this.redisCacheForWriting.emit(
+          'info',
+          `WriteThroughCache metrics enabled, will report every ${metricsPeriod} min`,
+        );
+        setInterval(
+          () => {
+            const total = this.metrics.localHits + this.metrics.redisHits + this.metrics.doubleMisses;
+            this.redisCacheForWriting.emit(
+              'info',
+              `WriteThroughCache metrics during last ${metricsPeriod} min - Total: ${total}, ` +
+                `Local hits: ${this.metrics.localHits} (${total && Math.floor((100 * this.metrics.localHits) / total)}%), ` +
+                `Redis hits: ${this.metrics.redisHits} (${total && Math.floor((100 * this.metrics.redisHits) / total)}%), ` +
+                `Double misses: ${this.metrics.doubleMisses} (${total && Math.floor((100 * this.metrics.doubleMisses) / total)}%).`,
+            );
+
+            this.metrics.localHits = 0;
+            this.metrics.redisHits = 0;
+            this.metrics.doubleMisses = 0;
+          },
+          metricsPeriod * 60 * 1000,
+        );
       } else {
         this.redisCacheForWriting.emit(
           'warn',
           'WriteThroughCache metrics activation impossible, CACHETTE_METRICS_PERIOD_MINUTES is invalid. ' +
-          `Must be a positive integer, but was ${process.env.CACHETTE_METRICS_PERIOD_MINUTES}`);
+            `Must be a positive integer, but was ${process.env.CACHETTE_METRICS_PERIOD_MINUTES}`,
+        );
       }
     }
   }
@@ -101,19 +106,15 @@ export class WriteThroughCache extends CacheInstance {
    * @inheritdoc
    */
   public async itemCount(): Promise<number> {
-    return await this.redisCacheForReading.itemCount() + await this.localCache.itemCount();
+    return (await this.redisCacheForReading.itemCount()) + (await this.localCache.itemCount());
   }
 
   /**
    * @inheritdoc
    */
-  public async setValue(
-    key: string,
-    value: CachableValue,
-    ttl = 0,
-  ): Promise<boolean> {
+  public async setValue(key: string, value: CachableValue, ttl = 0): Promise<boolean> {
     const response = await this.localCache.setValue(key, value, ttl);
-    return await this.redisCacheForWriting.setValue(key, value, ttl) && response;
+    return (await this.redisCacheForWriting.setValue(key, value, ttl)) && response;
   }
 
   /**
@@ -166,7 +167,7 @@ export class WriteThroughCache extends CacheInstance {
    * @inheritdoc
    */
   public async waitForReplication(replicas: number, timeout: number): Promise<number> {
-    this.emit('wait')
+    this.emit('wait');
     await this.localCache.waitForReplication(replicas, timeout);
     return this.redisCacheForWriting.waitForReplication(replicas, timeout);
   }
@@ -196,5 +197,4 @@ export class WriteThroughCache extends CacheInstance {
   public isLockingSupported(): boolean {
     return false;
   }
-
 }

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);
     });
-
   });
-
 }