Swap quick-lru with lru-cache

The motivation here is that unlike `quick-lru` `lru-cache` comes in 2 formats we're interested in: cjs and esm.

Plus, DHT already uses `lru-cache` so it already fits the stack.

Author: mondoreale

package-lock.json

@@ -100,6 +100,7 @@
     "idb": "^8.0.0",
     "lit-siwe": "^1.1.8",
     "lodash": "^4.17.21",
+    "lru-cache": "^11.0.2",
     "node-fetch": "^2.7.0",
     "p-limit": "^3.1.0",
     "p-memoize": "4.0.4",

packages/sdk/package.json

@@ -1,6 +1,6 @@
 import { MapKey } from '@streamr/utils'
 import pMemoize from 'p-memoize'
-import LRU from '../../vendor/quick-lru'
+import { LRUCache } from 'lru-cache'
 
 interface Options<P, K> {
     maxSize: number
@@ -23,16 +23,16 @@ interface Options<P, K> {
 export class CachingMap<K extends MapKey, V, P extends any[]> {
 
     private readonly cachedFn: (...args: P) => Promise<V>
-    private readonly cache: LRU<K, { data: V, maxAge: number }>
+    private readonly cache: LRUCache<K, { data: V, maxAge: number }>
     private readonly opts: Options<P, K>
 
     constructor(
         asyncFn: (...args: P) => Promise<V>,
         opts: Options<P, K>
     ) {
-        this.cache = new LRU<K, { data: V, maxAge: number }>({
-            maxSize: opts.maxSize,
-            maxAge: opts.maxAge
+        this.cache = new LRUCache<K, { data: V, maxAge: number }>({
+            max: opts.maxSize,
+            ttl: opts.maxAge
         })
         this.cachedFn = pMemoize(asyncFn, {
             cachePromiseRejection: false,

packages/sdk/src/utils/CachingMap.ts

@@ -1,5 +1,5 @@
+import { LRUCache } from 'lru-cache'
 import { formLookupKey } from './utils'
-import LRU from '../../vendor/quick-lru'
 
 type KeyType = (string | number | symbol)[]
 
@@ -19,14 +19,22 @@ interface Item<K, V> {
     value: V
 }
 
+interface LRU<K extends string, V> {
+    get(key: K): V | undefined
+    set(key: K, value: V): void
+    delete(key: K): void
+    values(): Iterable<V>
+    entries(): Iterable<[K, V]>
+}
+
 /*
  * A map that lazily creates values. The factory function is called only when a key
  * is accessed for the first time. Subsequent calls to `get()` return the cached value
  * unless it has been evicted due to `maxSize` or `maxAge` limits.
  */
 export class Mapping<K extends KeyType, V> {
 
-    private readonly delegate: Map<string, Item<K, V>>
+    private readonly delegate: LRU<string, Item<K, V>>
     private readonly pendingPromises: Map<string, Promise<V>> = new Map()
     private readonly opts: CacheMapOptions<K, V> | LazyMapOptions<K, V>
 
@@ -37,9 +45,9 @@ export class Mapping<K extends KeyType, V> {
      **/
     constructor(opts: CacheMapOptions<K, V> | LazyMapOptions<K, V>) {
         if ('maxSize' in opts) {
-            this.delegate = new LRU<string, Item<K, V>>({
-                maxSize: opts.maxSize,
-                maxAge: opts.maxAge
+            this.delegate = new LRUCache<string, Item<K, V>>({
+                max: opts.maxSize,
+                ttl: opts.maxAge
             })
         } else {
             this.delegate = new Map<string, Item<K, V>>()

packages/sdk/src/utils/Mapping.ts

@@ -8,7 +8,7 @@ import { ContractTransactionReceipt } from 'ethers'
 import compact from 'lodash/compact'
 import fetch, { Response } from 'node-fetch'
 import { Readable } from 'stream'
-import LRU from '../../vendor/quick-lru'
+import { LRUCache } from 'lru-cache'
 import { NetworkNodeType, NetworkPeerDescriptor, StrictStreamrClientConfig } from '../Config'
 import { StreamrClientEventEmitter } from '../events'
 import { WebStreamToNodeStream } from './WebStreamToNodeStream'
@@ -92,12 +92,12 @@ export function formStorageNodeAssignmentStreamId(clusterAddress: string): Strea
     return toStreamID('/assignments', toEthereumAddress(clusterAddress))
 }
 
-export class MaxSizedSet<T> {
+export class MaxSizedSet<T extends string> {
 
-    private readonly delegate: LRU<T, true>
+    private readonly delegate: LRUCache<T, true>
 
     constructor(maxSize: number) {
-        this.delegate = new LRU<T, true>({ maxSize })
+        this.delegate = new LRUCache<T, true>({ maxSize })
     }
 
     add(value: T): void {

packages/sdk/src/utils/utils.ts

@@ -80,25 +80,35 @@ describe('Mapping', () => {
     })
 
     it('max size', async () => {
-        const SIZE = 3
+        const maxSize = 3
         const valueFactory = jest.fn().mockImplementation(async (p1: string, p2: number) => {
             return `${p1}${p2}`
         })
-        const mapping = createCacheMap({ valueFactory, maxSize: 3 })
-        const ids = range(SIZE)
+        const mapping = createCacheMap({ valueFactory, maxSize })
+        const ids = range(maxSize)
+        /**
+         * Each call to `get` is considered usage. The following populates the cache with
+         * entries for: foo0, foo1, foo2 (3 in total).
+         */
         for (const id of ids) {
             await mapping.get('foo', id)
         }
-        expect(valueFactory).toHaveBeenCalledTimes(3)
-        // add a value which is not in cache
+        expect(valueFactory).toHaveBeenCalledTimes(maxSize)
+        /**
+         * Calling `get` on a key that's not in the cache causes usage. It will discard
+         * an item associated to `foo0` key (least recently used).
+         */
         await mapping.get('foo', -1)
-        expect(valueFactory).toHaveBeenCalledTimes(4)
-        // one of the items was removed from cache when -1 was added, now we is re-add that
-        // (we don't know which item it was)
+        expect(valueFactory).toHaveBeenCalledTimes(maxSize + 1)
+        /**
+         * The current list of keys (most-to-least recently used) goes as follows: foo-1,
+         * foo2, foo1. Going through all ids now will reconstruct the initial collection
+         * causing 3 hits.
+         */
         for (const id of ids) {
             await mapping.get('foo', id)
         }
-        expect(valueFactory).toHaveBeenCalledTimes(5)
+        expect(valueFactory).toHaveBeenCalledTimes(maxSize + 1 + 3)
     })
 
     it('max age', async () => {