fix: update lru-cache

package.json

@@ -42,7 +42,7 @@
   "license": "MIT",
   "dependencies": {
     "lodash.clonedeep": "^4.5.0",
-    "lru-cache": "~9.1.0"
+    "lru-cache": "~9.1.1"
   },
   "devDependencies": {
     "@commitlint/cli": "17.6.1",

src/stores/memory.ts

@@ -1,28 +1,31 @@
-import LRUCache, { Options } from 'lru-cache';
+import { LRUCache } from 'lru-cache';
 import cloneDeep from 'lodash.clonedeep';
 
 import { Config, Cache, Store } from '../caching';
 
-type Lru = LRUCache<string, unknown>;
-
 function clone<T>(object: T): T {
   if (typeof object === 'object' && object !== null) {
     return cloneDeep(object);
   }
   return object;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type LRU = LRUCache<string, any, unknown>;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Pre = LRUCache.OptionsTTLLimit<string, any, unknown>;
+type Options = Omit<Pre, 'ttlAutopurge'> & Partial<Pick<Pre, 'ttlAutopurge'>>;
 export type MemoryConfig = {
   max?: number;
   sizeCalculation?: (key: string, value: unknown) => number;
   shouldCloneBeforeSet?: boolean;
-} & Options<string, unknown> &
+} & Options &
   Config;
 
 export type MemoryStore = Store & {
-  keyCount: () => number;
-  dump: Lru['dump'];
-  load: Lru['load'];
+  get size(): number;
+  dump: LRU['dump'];
+  load: LRU['load'];
 };
 export type MemoryCache = Cache<MemoryStore>;
 
@@ -34,12 +37,13 @@ export function memoryStore(args?: MemoryConfig): MemoryStore {
   const isCacheable = args?.isCacheable ?? ((val) => val !== undefined);
 
   const lruOpts = {
+    ttlAutopurge: true,
     ...args,
     max: args?.max || 500,
     ttl: args?.ttl !== undefined ? args.ttl : 0,
   };
 
-  const lruCache = new LRUCache<string, unknown>(lruOpts);
+  const lruCache = new LRUCache(lruOpts);
 
   return {
     async del(key) {
@@ -76,14 +80,16 @@ export function memoryStore(args?: MemoryConfig): MemoryStore {
     /**
      * This method is not available in the caching modules.
      */
-    keyCount: () => lruCache.size,
+    get size() {
+      return lruCache.size;
+    },
     /**
      * This method is not available in the caching modules.
      */
     dump: () => lruCache.dump(),
     /**
      * This method is not available in the caching modules.
      */
-    load: (...args: Parameters<Lru['load']>) => lruCache.load(...args),
+    load: (...args: Parameters<LRU['load']>) => lruCache.load(...args),
   };
 }

test/stores/memory.test.ts

@@ -47,11 +47,11 @@ describe('memory store', () => {
     it('return total length of keys in cache', async () => {
       memoryCache = memoryStore({ ttl: 10 });
       await memoryCache.set('foo', 'bar');
-      await memoryCache.set('bar', 'foo');
-      expect(memoryCache.keyCount()).toEqual(2);
+      await memoryCache.set('bar', 'foo', 100);
+      expect(memoryCache.size).toEqual(2);
       await sleep(20);
       await expect(memoryCache.get('foo')).resolves.toBeUndefined();
-      expect(memoryCache.keyCount()).toEqual(1);
+      expect(memoryCache.size).toEqual(1);
     });
   });
 
@@ -89,10 +89,11 @@ describe('memory store', () => {
         return cache.wrap(key, async () => () => 'foo');
       }
 
-      // eslint-disable-next-line @typescript-eslint/no-empty-function
-      function Thing() {}
-
-      Thing.prototype.f = () => 'foo';
+      class Thing {
+        f() {
+          return 'foo';
+        }
+      }
 
       function getCachedObjectWithPrototype() {
         return cache.wrap(key, async () => new Thing());

tsconfig.json

@@ -2,6 +2,7 @@
   "compilerOptions": {
     "lib": ["esnext"],
     "module": "commonjs",
+    "target": "ES2015",
     "strict": true,
     "esModuleInterop": true,
     "sourceMap": true,