cacheable 0.8.0 → 1.2.0

package/README.md

@@ -15,10 +15,12 @@
 * Not bloated with additional modules
 * Extendable to your own caching engine
 * Scalable and trusted storage engine by Keyv
+* Memory Caching with LRU and Expiration `CacheableMemory`
 * Resilient to failures with try/catch and offline
 * Hooks and Events to extend functionality
 * Comprehensive testing and code coverage
 * Distributed Caching Sync via Pub/Sub (coming soon)
+* ESM and CommonJS support with TypeScript
 * Maintained and supported regularly
 
 ## Getting Started
@@ -129,11 +131,11 @@ The following options are available for you to configure `cacheable`:
 * `primary`: The primary store for the cache (layer 1) defaults to in-memory by Keyv.
 * `secondary`: The secondary store for the cache (layer 2) usually a persistent cache by Keyv.
 * `nonBlocking`: If the secondary store is non-blocking. Default is `false`.
-* `enableStats`: If you want to enable statistics for this instance. Default is `false`.
+* `stats`: To enable statistics for this instance. Default is `false`.
 
 ## Cacheable Statistics (Instance Only)
 
-If you want to enable statistics for your instance you can set the `enableStats` property to `true` in the options. This will enable statistics for your instance and you can get the statistics by calling the `stats` property. Here are the following property statistics:
+If you want to enable statistics for your instance you can set the `.stats.enabled` property to `true` in the options. This will enable statistics for your instance and you can get the statistics by calling the `stats` property. Here are the following property statistics:
 
 * `hits`: The number of hits in the cache.
 * `misses`: The number of misses in the cache.
@@ -145,7 +147,7 @@ If you want to enable statistics for your instance you can set the `enableStats`
 * `vsize`: The estimated byte size of the values in the cache.
 * `ksize`: The estimated byte size of the keys in the cache.
 
-You can clear the stats by calling the `clearStats()` method.
+You can clear / reset the stats by calling the `.stats.reset()` method.
 
 _This does not enable statistics for your layer 2 cache as that is a distributed cache_.
 
@@ -157,13 +159,11 @@ _This does not enable statistics for your layer 2 cache as that is a distributed
 * `getMany([keys])`: Gets multiple values from the cache.
 * `has(key | [key])`: Checks if a value exists in the cache.
 * `hasMany([keys])`: Checks if multiple values exist in the cache.
-* `take(key)`: Takes a value from the cache and deletes it. (coming soon)
-* `takeMany([keys])`: Takes multiple values from the cache and deletes them. (coming soon)
+* `take(key)`: Takes a value from the cache and deletes it.
+* `takeMany([keys])`: Takes multiple values from the cache and deletes them.
 * `delete(key | [key])`: Deletes a value from the cache.
 * `deleteMany([keys])`: Deletes multiple values from the cache.
 * `clear()`: Clears the cache stores. Be careful with this as it will clear both layer 1 and layer 2.
-* `clearPrimary()`: Clears the primary store. (coming soon)
-* `clearSecondary()`: Clears the secondary store. (coming soon)
 * `wrap(function, options)`: Wraps a function in a cache. (coming soon)
 * `disconnect()`: Disconnects from the cache stores.
 * `onHook(hook, callback)`: Sets a hook.
@@ -174,7 +174,37 @@ _This does not enable statistics for your layer 2 cache as that is a distributed
 * `secondary`: The secondary store for the cache (layer 2) usually a persistent cache by Keyv.
 * `nonBlocking`: If the secondary store is non-blocking. Default is `false`.
 * `stats`: The statistics for this instance which includes `hits`, `misses`, `sets`, `deletes`, `clears`, `errors`, `count`, `vsize`, `ksize`.
-* `clearStats()`: Clears the statistics for this instance.
+
+## CacheableMemory - In-Memory Cache
+
+`cacheable` comes with a built-in in-memory cache called `CacheableMemory`. This is a simple in-memory cache that is used as the primary store for `cacheable`. You can use this as a standalone cache or as a primary store for `cacheable`. Here is an example of how to use `CacheableMemory`:
+
+```javascript
+import { CacheableMemory } from 'cacheable';
+const options = {
+  ttl: 60 * 60 * 1000, // 1 hour
+  useClones: true, // use clones for the values (default is true)
+  lruSize: 1000, // the size of the LRU cache (default is 0 which is unlimited)
+}
+const cache = new CacheableMemory(options);
+await cache.set('key', 'value');
+const value = await cache.get('key'); // value
+```
+
+You can use `CacheableMemory` as a standalone cache or as a primary store for `cacheable`. You can also set the `useClones` property to `false` if you want to use the same reference for the values. This is useful if you are using large objects and want to save memory. The `lruSize` property is the size of the LRU cache and is set to `0` by default which is unlimited. When setting the `lruSize` property it will limit the number of keys in the cache.
+
+This simple in-memory cache uses multiple Map objects and a with `expiration` and `lru` policies if set to manage the in memory cache at scale.
+
+### CacheableMemory API
+
+* `set(key, value, ttl?)`: Sets a value in the cache.
+* `get(key)`: Gets a value from the cache.
+* `has(key)`: Checks if a value exists in the cache.
+* `delete(key)`: Deletes a value from the cache.
+* `clear()`: Clears the cache.
+* `size()`: The number of keys in the cache.
+* `keys()`: The keys in the cache.
+
 
 ## How to Contribute
 

package/dist/index.cjs

@@ -22,7 +22,9 @@ var src_exports = {};
 __export(src_exports, {
   Cacheable: () => Cacheable,
   CacheableEvents: () => CacheableEvents,
-  CacheableHooks: () => CacheableHooks
+  CacheableHooks: () => CacheableHooks,
+  CacheableMemory: () => CacheableMemory,
+  CacheableStats: () => CacheableStats
 });
 module.exports = __toCommonJS(src_exports);
 var import_keyv = require("keyv");
@@ -148,7 +150,7 @@ var CacheableStats = class {
     }
     this._count++;
   }
-  descreaseCount() {
+  decreaseCount() {
     if (!this._enabled) {
       return;
     }
@@ -196,6 +198,304 @@ var CacheableStats = class {
     this._ksize = 0;
     this._count = 0;
   }
+  resetStoreValues() {
+    this._vsize = 0;
+    this._ksize = 0;
+    this._count = 0;
+  }
+};
+
+// src/memory-lru.ts
+var ListNode = class {
+  // eslint-disable-next-line @typescript-eslint/parameter-properties
+  value;
+  prev = void 0;
+  next = void 0;
+  constructor(value) {
+    this.value = value;
+  }
+};
+var DoublyLinkedList = class {
+  head = void 0;
+  tail = void 0;
+  nodesMap = /* @__PURE__ */ new Map();
+  // Add a new node to the front (most recently used)
+  addToFront(value) {
+    const newNode = new ListNode(value);
+    if (this.head) {
+      newNode.next = this.head;
+      this.head.prev = newNode;
+      this.head = newNode;
+    } else {
+      this.head = this.tail = newNode;
+    }
+    this.nodesMap.set(value, newNode);
+  }
+  // Move an existing node to the front (most recently used)
+  moveToFront(value) {
+    const node = this.nodesMap.get(value);
+    if (!node || this.head === node) {
+      return;
+    }
+    if (node.prev) {
+      node.prev.next = node.next;
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    }
+    if (node === this.tail) {
+      this.tail = node.prev;
+    }
+    node.prev = void 0;
+    node.next = this.head;
+    if (this.head) {
+      this.head.prev = node;
+    }
+    this.head = node;
+    this.tail ||= node;
+  }
+  // Get the oldest node (tail)
+  getOldest() {
+    return this.tail ? this.tail.value : void 0;
+  }
+  // Remove the oldest node (tail)
+  removeOldest() {
+    if (!this.tail) {
+      return void 0;
+    }
+    const oldValue = this.tail.value;
+    if (this.tail.prev) {
+      this.tail = this.tail.prev;
+      this.tail.next = void 0;
+    } else {
+      this.head = this.tail = void 0;
+    }
+    this.nodesMap.delete(oldValue);
+    return oldValue;
+  }
+  get size() {
+    return this.nodesMap.size;
+  }
+};
+
+// src/memory.ts
+var CacheableMemory = class {
+  _hashCache = /* @__PURE__ */ new Map();
+  _hash0 = /* @__PURE__ */ new Map();
+  _hash1 = /* @__PURE__ */ new Map();
+  _hash2 = /* @__PURE__ */ new Map();
+  _hash3 = /* @__PURE__ */ new Map();
+  _hash4 = /* @__PURE__ */ new Map();
+  _hash5 = /* @__PURE__ */ new Map();
+  _hash6 = /* @__PURE__ */ new Map();
+  _hash7 = /* @__PURE__ */ new Map();
+  _hash8 = /* @__PURE__ */ new Map();
+  _hash9 = /* @__PURE__ */ new Map();
+  _lru = new DoublyLinkedList();
+  _ttl = 0;
+  _useClone = true;
+  _lruSize = 0;
+  constructor(options) {
+    if (options?.ttl) {
+      this._ttl = options.ttl;
+    }
+    if (options?.useClone !== void 0) {
+      this._useClone = options.useClone;
+    }
+    if (options?.lruSize) {
+      this._lruSize = options.lruSize;
+    }
+  }
+  get ttl() {
+    return this._ttl;
+  }
+  set ttl(value) {
+    this._ttl = value;
+  }
+  get useClone() {
+    return this._useClone;
+  }
+  set useClone(value) {
+    this._useClone = value;
+  }
+  get lruSize() {
+    return this._lruSize;
+  }
+  set lruSize(value) {
+    this._lruSize = value;
+    this.lruResize();
+  }
+  get size() {
+    return this._hash0.size + this._hash1.size + this._hash2.size + this._hash3.size + this._hash4.size + this._hash5.size + this._hash6.size + this._hash7.size + this._hash8.size + this._hash9.size;
+  }
+  get keys() {
+    return this.concatStores().keys();
+  }
+  get(key) {
+    const store = this.getStore(key);
+    const item = store.get(key);
+    if (!item) {
+      return void 0;
+    }
+    if (item.expires && item.expires && Date.now() > item.expires) {
+      store.delete(key);
+      return void 0;
+    }
+    this.lruMoveToFront(key);
+    if (!this._useClone) {
+      return item.value;
+    }
+    return this.clone(item.value);
+  }
+  set(key, value, ttl) {
+    const store = this.getStore(key);
+    let expires;
+    if (ttl !== void 0 || this._ttl !== 0) {
+      expires = Date.now() + (ttl ?? this._ttl);
+    }
+    if (this._lruSize > 0) {
+      if (store.has(key)) {
+        this.lruMoveToFront(key);
+      } else {
+        this.lruAddToFront(key);
+        if (this._lru.size > this._lruSize) {
+          const oldestKey = this._lru.getOldest();
+          if (oldestKey) {
+            this._lru.removeOldest();
+            this.delete(oldestKey);
+          }
+        }
+      }
+    }
+    store.set(key, {
+      key,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      value,
+      expires
+    });
+  }
+  has(key) {
+    const item = this.get(key);
+    return Boolean(item);
+  }
+  take(key) {
+    const item = this.get(key);
+    if (!item) {
+      return void 0;
+    }
+    this.delete(key);
+    return item;
+  }
+  delete(key) {
+    const store = this.getStore(key);
+    store.delete(key);
+  }
+  clear() {
+    this._hash0.clear();
+    this._hash1.clear();
+    this._hash2.clear();
+    this._hash3.clear();
+    this._hash4.clear();
+    this._hash5.clear();
+    this._hash6.clear();
+    this._hash7.clear();
+    this._hash8.clear();
+    this._hash9.clear();
+    this._hashCache.clear();
+  }
+  hashKey(key) {
+    const cacheHashNumber = this._hashCache.get(key);
+    if (cacheHashNumber) {
+      return cacheHashNumber;
+    }
+    let hash = 0;
+    const primeMultiplier = 31;
+    for (let i = 0; i < key.length; i++) {
+      hash = hash * primeMultiplier + key.charCodeAt(i);
+    }
+    const result = Math.abs(hash) % 10;
+    this._hashCache.set(key, result);
+    return result;
+  }
+  getStore(key) {
+    const hashKey = this.hashKey(key);
+    switch (hashKey) {
+      case 1: {
+        return this._hash1;
+      }
+      case 2: {
+        return this._hash2;
+      }
+      case 3: {
+        return this._hash3;
+      }
+      case 4: {
+        return this._hash4;
+      }
+      case 5: {
+        return this._hash5;
+      }
+      case 6: {
+        return this._hash6;
+      }
+      case 7: {
+        return this._hash7;
+      }
+      case 8: {
+        return this._hash8;
+      }
+      case 9: {
+        return this._hash9;
+      }
+      default: {
+        return this._hash0;
+      }
+    }
+  }
+  clone(value) {
+    if (this.isPrimitive(value)) {
+      return value;
+    }
+    return structuredClone(value);
+  }
+  lruAddToFront(key) {
+    if (this._lruSize === 0) {
+      return;
+    }
+    this._lru.addToFront(key);
+  }
+  lruMoveToFront(key) {
+    if (this._lruSize === 0) {
+      return;
+    }
+    this._lru.moveToFront(key);
+  }
+  lruResize() {
+    if (this._lruSize === 0) {
+      return;
+    }
+    while (this._lru.size > this._lruSize) {
+      const oldestKey = this._lru.getOldest();
+      if (oldestKey) {
+        this._lru.removeOldest();
+        this.delete(oldestKey);
+      }
+    }
+  }
+  isPrimitive(value) {
+    const result = false;
+    if (value === null || value === void 0) {
+      return true;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      return true;
+    }
+    return result;
+  }
+  concatStores() {
+    const result = new Map([...this._hash0, ...this._hash1, ...this._hash2, ...this._hash3, ...this._hash4, ...this._hash5, ...this._hash6, ...this._hash7, ...this._hash8, ...this._hash9]);
+    return result;
+  }
 };
 
 // src/index.ts
@@ -215,9 +515,10 @@ var CacheableEvents = /* @__PURE__ */ ((CacheableEvents2) => {
   return CacheableEvents2;
 })(CacheableEvents || {});
 var Cacheable = class extends import_hookified.Hookified {
-  _primary = new import_keyv.Keyv();
+  _primary = new import_keyv.Keyv({ store: new CacheableMemory() });
   _secondary;
   _nonBlocking = false;
+  _ttl;
   _stats = new CacheableStats({ enabled: false });
   constructor(options) {
     super();
@@ -233,6 +534,9 @@ var Cacheable = class extends import_hookified.Hookified {
     if (options?.stats) {
       this._stats.enabled = options.stats;
     }
+    if (options?.ttl) {
+      this._ttl = options.ttl;
+    }
   }
   get stats() {
     return this._stats;
@@ -255,6 +559,12 @@ var Cacheable = class extends import_hookified.Hookified {
   set nonBlocking(nonBlocking) {
     this._nonBlocking = nonBlocking;
   }
+  get ttl() {
+    return this._ttl;
+  }
+  set ttl(ttl) {
+    this._ttl = ttl;
+  }
   setPrimary(primary) {
     this._primary = primary instanceof import_keyv.Keyv ? primary : new import_keyv.Keyv(primary);
   }
@@ -269,13 +579,21 @@ var Cacheable = class extends import_hookified.Hookified {
       if (!result && this._secondary) {
         result = await this._secondary.get(key);
         if (result) {
-          await this._primary.set(key, result);
+          await this._primary.set(key, result, this._ttl);
         }
       }
       await this.hook("AFTER_GET" /* AFTER_GET */, { key, result });
     } catch (error) {
       await this.emit("error" /* ERROR */, error);
     }
+    if (this.stats.enabled) {
+      if (result) {
+        this._stats.incrementHits();
+      } else {
+        this._stats.incrementMisses();
+      }
+      this.stats.incrementGets();
+    }
     return result;
   }
   async getMany(keys) {
@@ -294,7 +612,7 @@ var Cacheable = class extends import_hookified.Hookified {
         for (const [i, key] of keys.entries()) {
           if (!result[i] && secondaryResult[i]) {
             result[i] = secondaryResult[i];
-            await this._primary.set(key, secondaryResult[i]);
+            await this._primary.set(key, secondaryResult[i], this._ttl);
           }
         }
       }
@@ -302,16 +620,27 @@ var Cacheable = class extends import_hookified.Hookified {
     } catch (error) {
       await this.emit("error" /* ERROR */, error);
     }
+    if (this.stats.enabled) {
+      for (const item of result) {
+        if (item) {
+          this._stats.incrementHits();
+        } else {
+          this._stats.incrementMisses();
+        }
+      }
+      this.stats.incrementGets();
+    }
     return result;
   }
   async set(key, value, ttl) {
     let result = false;
+    const finalTtl = ttl ?? this._ttl;
     try {
-      await this.hook("BEFORE_SET" /* BEFORE_SET */, { key, value, ttl });
+      await this.hook("BEFORE_SET" /* BEFORE_SET */, { key, value, finalTtl });
       const promises = [];
-      promises.push(this._primary.set(key, value, ttl));
+      promises.push(this._primary.set(key, value, finalTtl));
       if (this._secondary) {
-        promises.push(this._secondary.set(key, value, ttl));
+        promises.push(this._secondary.set(key, value, finalTtl));
       }
       if (this._nonBlocking) {
         result = await Promise.race(promises);
@@ -319,10 +648,16 @@ var Cacheable = class extends import_hookified.Hookified {
         const results = await Promise.all(promises);
         result = results[0];
       }
-      await this.hook("AFTER_SET" /* AFTER_SET */, { key, value, ttl });
+      await this.hook("AFTER_SET" /* AFTER_SET */, { key, value, finalTtl });
     } catch (error) {
       await this.emit("error" /* ERROR */, error);
     }
+    if (this.stats.enabled) {
+      this.stats.incrementKSize(key);
+      this.stats.incrementCount();
+      this.stats.incrementVSize(value);
+      this.stats.incrementSets();
+    }
     return result;
   }
   async setMany(items) {
@@ -341,6 +676,13 @@ var Cacheable = class extends import_hookified.Hookified {
     } catch (error) {
       await this.emit("error" /* ERROR */, error);
     }
+    if (this.stats.enabled) {
+      for (const item of items) {
+        this.stats.incrementKSize(item.key);
+        this.stats.incrementCount();
+        this.stats.incrementVSize(item.value);
+      }
+    }
     return result;
   }
   async take(key) {
@@ -354,11 +696,18 @@ var Cacheable = class extends import_hookified.Hookified {
     return result;
   }
   async has(key) {
-    let result = await this._primary.has(key);
-    if (!result && this._secondary) {
-      result = await this._secondary.has(key);
+    const promises = [];
+    promises.push(this._primary.has(key));
+    if (this._secondary) {
+      promises.push(this._secondary.has(key));
     }
-    return result;
+    const resultAll = await Promise.all(promises);
+    for (const result of resultAll) {
+      if (result) {
+        return true;
+      }
+    }
+    return false;
   }
   async hasMany(keys) {
     const result = await this.hasManyKeyv(this._primary, keys);
@@ -379,17 +728,39 @@ var Cacheable = class extends import_hookified.Hookified {
     return result;
   }
   async delete(key) {
-    const result = await this._primary.delete(key);
-    if (this._secondary) {
-      if (this._nonBlocking) {
-        this._secondary.delete(key);
-      } else {
-        await this._secondary.delete(key);
+    let result = false;
+    const promises = [];
+    if (this.stats.enabled) {
+      const statResult = await this._primary.get(key);
+      if (statResult) {
+        this.stats.decreaseKSize(key);
+        this.stats.decreaseVSize(statResult);
+        this.stats.decreaseCount();
+        this.stats.incrementDeletes();
       }
     }
+    promises.push(this._primary.delete(key));
+    if (this._secondary) {
+      promises.push(this._secondary.delete(key));
+    }
+    if (this.nonBlocking) {
+      result = await Promise.race(promises);
+    } else {
+      const resultAll = await Promise.all(promises);
+      result = resultAll[0];
+    }
     return result;
   }
   async deleteMany(keys) {
+    if (this.stats.enabled) {
+      const statResult = await this._primary.get(keys);
+      for (const key of keys) {
+        this.stats.decreaseKSize(key);
+        this.stats.decreaseVSize(statResult);
+        this.stats.decreaseCount();
+        this.stats.incrementDeletes();
+      }
+    }
     const result = await this.deleteManyKeyv(this._primary, keys);
     if (this._secondary) {
       if (this._nonBlocking) {
@@ -407,6 +778,10 @@ var Cacheable = class extends import_hookified.Hookified {
       promises.push(this._secondary.clear());
     }
     await (this._nonBlocking ? Promise.race(promises) : Promise.all(promises));
+    if (this.stats.enabled) {
+      this._stats.resetStoreValues();
+      this._stats.incrementClears();
+    }
   }
   async disconnect() {
     const promises = [];
@@ -427,7 +802,8 @@ var Cacheable = class extends import_hookified.Hookified {
   async setManyKeyv(keyv, items) {
     const promises = [];
     for (const item of items) {
-      promises.push(keyv.set(item.key, item.value, item.ttl));
+      const finalTtl = item.ttl ?? this._ttl;
+      promises.push(keyv.set(item.key, item.value, finalTtl));
     }
     await Promise.all(promises);
     return true;
@@ -444,5 +820,7 @@ var Cacheable = class extends import_hookified.Hookified {
 0 && (module.exports = {
   Cacheable,
   CacheableEvents,
-  CacheableHooks
+  CacheableHooks,
+  CacheableMemory,
+  CacheableStats
 });

package/dist/index.d.cts

@@ -38,11 +38,58 @@ declare class CacheableStats {
     incrementKSize(key: string): void;
     decreaseKSize(key: string): void;
     incrementCount(): void;
-    descreaseCount(): void;
+    decreaseCount(): void;
     setCount(count: number): void;
     roughSizeOfString(value: string): number;
     roughSizeOfObject(object: any): number;
     reset(): void;
+    resetStoreValues(): void;
+}
+
+type CacheableMemoryOptions = {
+    ttl?: number;
+    useClone?: boolean;
+    lruSize?: number;
+};
+declare class CacheableMemory {
+    private readonly _hashCache;
+    private readonly _hash0;
+    private readonly _hash1;
+    private readonly _hash2;
+    private readonly _hash3;
+    private readonly _hash4;
+    private readonly _hash5;
+    private readonly _hash6;
+    private readonly _hash7;
+    private readonly _hash8;
+    private readonly _hash9;
+    private readonly _lru;
+    private _ttl;
+    private _useClone;
+    private _lruSize;
+    constructor(options?: CacheableMemoryOptions);
+    get ttl(): number;
+    set ttl(value: number);
+    get useClone(): boolean;
+    set useClone(value: boolean);
+    get lruSize(): number;
+    set lruSize(value: number);
+    get size(): number;
+    get keys(): IterableIterator<string>;
+    get<T>(key: string): any;
+    set(key: string, value: any, ttl?: number): void;
+    has(key: string): boolean;
+    take<T>(key: string): any;
+    delete(key: string): void;
+    clear(): void;
+    hashKey(key: string): number;
+    getStore(key: string): Map<string, any>;
+    clone(value: any): any;
+    lruAddToFront(key: string): void;
+    lruMoveToFront(key: string): void;
+    lruResize(): void;
+    private isPrimitive;
+    private concatStores;
 }
 
 declare enum CacheableHooks {
@@ -68,11 +115,13 @@ type CacheableOptions = {
     secondary?: Keyv | KeyvStoreAdapter;
     stats?: boolean;
     nonBlocking?: boolean;
+    ttl?: number;
 };
 declare class Cacheable extends Hookified {
     private _primary;
     private _secondary;
     private _nonBlocking;
+    private _ttl?;
     private readonly _stats;
     constructor(options?: CacheableOptions);
     get stats(): CacheableStats;
@@ -82,6 +131,8 @@ declare class Cacheable extends Hookified {
     set secondary(secondary: Keyv | undefined);
     get nonBlocking(): boolean;
     set nonBlocking(nonBlocking: boolean);
+    get ttl(): number | undefined;
+    set ttl(ttl: number | undefined);
     setPrimary(primary: Keyv | KeyvStoreAdapter): void;
     setSecondary(secondary: Keyv | KeyvStoreAdapter): void;
     get<T>(key: string): Promise<T | undefined>;
@@ -101,4 +152,4 @@ declare class Cacheable extends Hookified {
     private hasManyKeyv;
 }
 
-export { Cacheable, CacheableEvents, CacheableHooks, type CacheableItem, type CacheableOptions };
+export { Cacheable, CacheableEvents, CacheableHooks, type CacheableItem, CacheableMemory, type CacheableOptions, CacheableStats };

package/dist/index.d.ts

@@ -38,11 +38,58 @@ declare class CacheableStats {
     incrementKSize(key: string): void;
     decreaseKSize(key: string): void;
     incrementCount(): void;
-    descreaseCount(): void;
+    decreaseCount(): void;
     setCount(count: number): void;
     roughSizeOfString(value: string): number;
     roughSizeOfObject(object: any): number;
     reset(): void;
+    resetStoreValues(): void;
+}
+
+type CacheableMemoryOptions = {
+    ttl?: number;
+    useClone?: boolean;
+    lruSize?: number;
+};
+declare class CacheableMemory {
+    private readonly _hashCache;
+    private readonly _hash0;
+    private readonly _hash1;
+    private readonly _hash2;
+    private readonly _hash3;
+    private readonly _hash4;
+    private readonly _hash5;
+    private readonly _hash6;
+    private readonly _hash7;
+    private readonly _hash8;
+    private readonly _hash9;
+    private readonly _lru;
+    private _ttl;
+    private _useClone;
+    private _lruSize;
+    constructor(options?: CacheableMemoryOptions);
+    get ttl(): number;
+    set ttl(value: number);
+    get useClone(): boolean;
+    set useClone(value: boolean);
+    get lruSize(): number;
+    set lruSize(value: number);
+    get size(): number;
+    get keys(): IterableIterator<string>;
+    get<T>(key: string): any;
+    set(key: string, value: any, ttl?: number): void;
+    has(key: string): boolean;
+    take<T>(key: string): any;
+    delete(key: string): void;
+    clear(): void;
+    hashKey(key: string): number;
+    getStore(key: string): Map<string, any>;
+    clone(value: any): any;
+    lruAddToFront(key: string): void;
+    lruMoveToFront(key: string): void;
+    lruResize(): void;
+    private isPrimitive;
+    private concatStores;
 }
 
 declare enum CacheableHooks {
@@ -68,11 +115,13 @@ type CacheableOptions = {
     secondary?: Keyv | KeyvStoreAdapter;
     stats?: boolean;
     nonBlocking?: boolean;
+    ttl?: number;
 };
 declare class Cacheable extends Hookified {
     private _primary;
     private _secondary;
     private _nonBlocking;
+    private _ttl?;
     private readonly _stats;
     constructor(options?: CacheableOptions);
     get stats(): CacheableStats;
@@ -82,6 +131,8 @@ declare class Cacheable extends Hookified {
     set secondary(secondary: Keyv | undefined);
     get nonBlocking(): boolean;
     set nonBlocking(nonBlocking: boolean);
+    get ttl(): number | undefined;
+    set ttl(ttl: number | undefined);
     setPrimary(primary: Keyv | KeyvStoreAdapter): void;
     setSecondary(secondary: Keyv | KeyvStoreAdapter): void;
     get<T>(key: string): Promise<T | undefined>;
@@ -101,4 +152,4 @@ declare class Cacheable extends Hookified {
     private hasManyKeyv;
 }
 
-export { Cacheable, CacheableEvents, CacheableHooks, type CacheableItem, type CacheableOptions };
+export { Cacheable, CacheableEvents, CacheableHooks, type CacheableItem, CacheableMemory, type CacheableOptions, CacheableStats };

package/dist/index.js

@@ -122,7 +122,7 @@ var CacheableStats = class {
     }
     this._count++;
   }
-  descreaseCount() {
+  decreaseCount() {
     if (!this._enabled) {
       return;
     }
@@ -170,6 +170,304 @@ var CacheableStats = class {
     this._ksize = 0;
     this._count = 0;
   }
+  resetStoreValues() {
+    this._vsize = 0;
+    this._ksize = 0;
+    this._count = 0;
+  }
+};
+
+// src/memory-lru.ts
+var ListNode = class {
+  // eslint-disable-next-line @typescript-eslint/parameter-properties
+  value;
+  prev = void 0;
+  next = void 0;
+  constructor(value) {
+    this.value = value;
+  }
+};
+var DoublyLinkedList = class {
+  head = void 0;
+  tail = void 0;
+  nodesMap = /* @__PURE__ */ new Map();
+  // Add a new node to the front (most recently used)
+  addToFront(value) {
+    const newNode = new ListNode(value);
+    if (this.head) {
+      newNode.next = this.head;
+      this.head.prev = newNode;
+      this.head = newNode;
+    } else {
+      this.head = this.tail = newNode;
+    }
+    this.nodesMap.set(value, newNode);
+  }
+  // Move an existing node to the front (most recently used)
+  moveToFront(value) {
+    const node = this.nodesMap.get(value);
+    if (!node || this.head === node) {
+      return;
+    }
+    if (node.prev) {
+      node.prev.next = node.next;
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    }
+    if (node === this.tail) {
+      this.tail = node.prev;
+    }
+    node.prev = void 0;
+    node.next = this.head;
+    if (this.head) {
+      this.head.prev = node;
+    }
+    this.head = node;
+    this.tail ||= node;
+  }
+  // Get the oldest node (tail)
+  getOldest() {
+    return this.tail ? this.tail.value : void 0;
+  }
+  // Remove the oldest node (tail)
+  removeOldest() {
+    if (!this.tail) {
+      return void 0;
+    }
+    const oldValue = this.tail.value;
+    if (this.tail.prev) {
+      this.tail = this.tail.prev;
+      this.tail.next = void 0;
+    } else {
+      this.head = this.tail = void 0;
+    }
+    this.nodesMap.delete(oldValue);
+    return oldValue;
+  }
+  get size() {
+    return this.nodesMap.size;
+  }
+};
+
+// src/memory.ts
+var CacheableMemory = class {
+  _hashCache = /* @__PURE__ */ new Map();
+  _hash0 = /* @__PURE__ */ new Map();
+  _hash1 = /* @__PURE__ */ new Map();
+  _hash2 = /* @__PURE__ */ new Map();
+  _hash3 = /* @__PURE__ */ new Map();
+  _hash4 = /* @__PURE__ */ new Map();
+  _hash5 = /* @__PURE__ */ new Map();
+  _hash6 = /* @__PURE__ */ new Map();
+  _hash7 = /* @__PURE__ */ new Map();
+  _hash8 = /* @__PURE__ */ new Map();
+  _hash9 = /* @__PURE__ */ new Map();
+  _lru = new DoublyLinkedList();
+  _ttl = 0;
+  _useClone = true;
+  _lruSize = 0;
+  constructor(options) {
+    if (options?.ttl) {
+      this._ttl = options.ttl;
+    }
+    if (options?.useClone !== void 0) {
+      this._useClone = options.useClone;
+    }
+    if (options?.lruSize) {
+      this._lruSize = options.lruSize;
+    }
+  }
+  get ttl() {
+    return this._ttl;
+  }
+  set ttl(value) {
+    this._ttl = value;
+  }
+  get useClone() {
+    return this._useClone;
+  }
+  set useClone(value) {
+    this._useClone = value;
+  }
+  get lruSize() {
+    return this._lruSize;
+  }
+  set lruSize(value) {
+    this._lruSize = value;
+    this.lruResize();
+  }
+  get size() {
+    return this._hash0.size + this._hash1.size + this._hash2.size + this._hash3.size + this._hash4.size + this._hash5.size + this._hash6.size + this._hash7.size + this._hash8.size + this._hash9.size;
+  }
+  get keys() {
+    return this.concatStores().keys();
+  }
+  get(key) {
+    const store = this.getStore(key);
+    const item = store.get(key);
+    if (!item) {
+      return void 0;
+    }
+    if (item.expires && item.expires && Date.now() > item.expires) {
+      store.delete(key);
+      return void 0;
+    }
+    this.lruMoveToFront(key);
+    if (!this._useClone) {
+      return item.value;
+    }
+    return this.clone(item.value);
+  }
+  set(key, value, ttl) {
+    const store = this.getStore(key);
+    let expires;
+    if (ttl !== void 0 || this._ttl !== 0) {
+      expires = Date.now() + (ttl ?? this._ttl);
+    }
+    if (this._lruSize > 0) {
+      if (store.has(key)) {
+        this.lruMoveToFront(key);
+      } else {
+        this.lruAddToFront(key);
+        if (this._lru.size > this._lruSize) {
+          const oldestKey = this._lru.getOldest();
+          if (oldestKey) {
+            this._lru.removeOldest();
+            this.delete(oldestKey);
+          }
+        }
+      }
+    }
+    store.set(key, {
+      key,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      value,
+      expires
+    });
+  }
+  has(key) {
+    const item = this.get(key);
+    return Boolean(item);
+  }
+  take(key) {
+    const item = this.get(key);
+    if (!item) {
+      return void 0;
+    }
+    this.delete(key);
+    return item;
+  }
+  delete(key) {
+    const store = this.getStore(key);
+    store.delete(key);
+  }
+  clear() {
+    this._hash0.clear();
+    this._hash1.clear();
+    this._hash2.clear();
+    this._hash3.clear();
+    this._hash4.clear();
+    this._hash5.clear();
+    this._hash6.clear();
+    this._hash7.clear();
+    this._hash8.clear();
+    this._hash9.clear();
+    this._hashCache.clear();
+  }
+  hashKey(key) {
+    const cacheHashNumber = this._hashCache.get(key);
+    if (cacheHashNumber) {
+      return cacheHashNumber;
+    }
+    let hash = 0;
+    const primeMultiplier = 31;
+    for (let i = 0; i < key.length; i++) {
+      hash = hash * primeMultiplier + key.charCodeAt(i);
+    }
+    const result = Math.abs(hash) % 10;
+    this._hashCache.set(key, result);
+    return result;
+  }
+  getStore(key) {
+    const hashKey = this.hashKey(key);
+    switch (hashKey) {
+      case 1: {
+        return this._hash1;
+      }
+      case 2: {
+        return this._hash2;
+      }
+      case 3: {
+        return this._hash3;
+      }
+      case 4: {
+        return this._hash4;
+      }
+      case 5: {
+        return this._hash5;
+      }
+      case 6: {
+        return this._hash6;
+      }
+      case 7: {
+        return this._hash7;
+      }
+      case 8: {
+        return this._hash8;
+      }
+      case 9: {
+        return this._hash9;
+      }
+      default: {
+        return this._hash0;
+      }
+    }
+  }
+  clone(value) {
+    if (this.isPrimitive(value)) {
+      return value;
+    }
+    return structuredClone(value);
+  }
+  lruAddToFront(key) {
+    if (this._lruSize === 0) {
+      return;
+    }
+    this._lru.addToFront(key);
+  }
+  lruMoveToFront(key) {
+    if (this._lruSize === 0) {
+      return;
+    }
+    this._lru.moveToFront(key);
+  }
+  lruResize() {
+    if (this._lruSize === 0) {
+      return;
+    }
+    while (this._lru.size > this._lruSize) {
+      const oldestKey = this._lru.getOldest();
+      if (oldestKey) {
+        this._lru.removeOldest();
+        this.delete(oldestKey);
+      }
+    }
+  }
+  isPrimitive(value) {
+    const result = false;
+    if (value === null || value === void 0) {
+      return true;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      return true;
+    }
+    return result;
+  }
+  concatStores() {
+    const result = new Map([...this._hash0, ...this._hash1, ...this._hash2, ...this._hash3, ...this._hash4, ...this._hash5, ...this._hash6, ...this._hash7, ...this._hash8, ...this._hash9]);
+    return result;
+  }
 };
 
 // src/index.ts
@@ -189,9 +487,10 @@ var CacheableEvents = /* @__PURE__ */ ((CacheableEvents2) => {
   return CacheableEvents2;
 })(CacheableEvents || {});
 var Cacheable = class extends Hookified {
-  _primary = new Keyv();
+  _primary = new Keyv({ store: new CacheableMemory() });
   _secondary;
   _nonBlocking = false;
+  _ttl;
   _stats = new CacheableStats({ enabled: false });
   constructor(options) {
     super();
@@ -207,6 +506,9 @@ var Cacheable = class extends Hookified {
     if (options?.stats) {
       this._stats.enabled = options.stats;
     }
+    if (options?.ttl) {
+      this._ttl = options.ttl;
+    }
   }
   get stats() {
     return this._stats;
@@ -229,6 +531,12 @@ var Cacheable = class extends Hookified {
   set nonBlocking(nonBlocking) {
     this._nonBlocking = nonBlocking;
   }
+  get ttl() {
+    return this._ttl;
+  }
+  set ttl(ttl) {
+    this._ttl = ttl;
+  }
   setPrimary(primary) {
     this._primary = primary instanceof Keyv ? primary : new Keyv(primary);
   }
@@ -243,13 +551,21 @@ var Cacheable = class extends Hookified {
       if (!result && this._secondary) {
         result = await this._secondary.get(key);
         if (result) {
-          await this._primary.set(key, result);
+          await this._primary.set(key, result, this._ttl);
         }
       }
       await this.hook("AFTER_GET" /* AFTER_GET */, { key, result });
     } catch (error) {
       await this.emit("error" /* ERROR */, error);
     }
+    if (this.stats.enabled) {
+      if (result) {
+        this._stats.incrementHits();
+      } else {
+        this._stats.incrementMisses();
+      }
+      this.stats.incrementGets();
+    }
     return result;
   }
   async getMany(keys) {
@@ -268,7 +584,7 @@ var Cacheable = class extends Hookified {
         for (const [i, key] of keys.entries()) {
           if (!result[i] && secondaryResult[i]) {
             result[i] = secondaryResult[i];
-            await this._primary.set(key, secondaryResult[i]);
+            await this._primary.set(key, secondaryResult[i], this._ttl);
           }
         }
       }
@@ -276,16 +592,27 @@ var Cacheable = class extends Hookified {
     } catch (error) {
       await this.emit("error" /* ERROR */, error);
     }
+    if (this.stats.enabled) {
+      for (const item of result) {
+        if (item) {
+          this._stats.incrementHits();
+        } else {
+          this._stats.incrementMisses();
+        }
+      }
+      this.stats.incrementGets();
+    }
     return result;
   }
   async set(key, value, ttl) {
     let result = false;
+    const finalTtl = ttl ?? this._ttl;
     try {
-      await this.hook("BEFORE_SET" /* BEFORE_SET */, { key, value, ttl });
+      await this.hook("BEFORE_SET" /* BEFORE_SET */, { key, value, finalTtl });
       const promises = [];
-      promises.push(this._primary.set(key, value, ttl));
+      promises.push(this._primary.set(key, value, finalTtl));
       if (this._secondary) {
-        promises.push(this._secondary.set(key, value, ttl));
+        promises.push(this._secondary.set(key, value, finalTtl));
       }
       if (this._nonBlocking) {
         result = await Promise.race(promises);
@@ -293,10 +620,16 @@ var Cacheable = class extends Hookified {
         const results = await Promise.all(promises);
         result = results[0];
       }
-      await this.hook("AFTER_SET" /* AFTER_SET */, { key, value, ttl });
+      await this.hook("AFTER_SET" /* AFTER_SET */, { key, value, finalTtl });
     } catch (error) {
       await this.emit("error" /* ERROR */, error);
     }
+    if (this.stats.enabled) {
+      this.stats.incrementKSize(key);
+      this.stats.incrementCount();
+      this.stats.incrementVSize(value);
+      this.stats.incrementSets();
+    }
     return result;
   }
   async setMany(items) {
@@ -315,6 +648,13 @@ var Cacheable = class extends Hookified {
     } catch (error) {
       await this.emit("error" /* ERROR */, error);
     }
+    if (this.stats.enabled) {
+      for (const item of items) {
+        this.stats.incrementKSize(item.key);
+        this.stats.incrementCount();
+        this.stats.incrementVSize(item.value);
+      }
+    }
     return result;
   }
   async take(key) {
@@ -328,11 +668,18 @@ var Cacheable = class extends Hookified {
     return result;
   }
   async has(key) {
-    let result = await this._primary.has(key);
-    if (!result && this._secondary) {
-      result = await this._secondary.has(key);
+    const promises = [];
+    promises.push(this._primary.has(key));
+    if (this._secondary) {
+      promises.push(this._secondary.has(key));
     }
-    return result;
+    const resultAll = await Promise.all(promises);
+    for (const result of resultAll) {
+      if (result) {
+        return true;
+      }
+    }
+    return false;
   }
   async hasMany(keys) {
     const result = await this.hasManyKeyv(this._primary, keys);
@@ -353,17 +700,39 @@ var Cacheable = class extends Hookified {
     return result;
   }
   async delete(key) {
-    const result = await this._primary.delete(key);
-    if (this._secondary) {
-      if (this._nonBlocking) {
-        this._secondary.delete(key);
-      } else {
-        await this._secondary.delete(key);
+    let result = false;
+    const promises = [];
+    if (this.stats.enabled) {
+      const statResult = await this._primary.get(key);
+      if (statResult) {
+        this.stats.decreaseKSize(key);
+        this.stats.decreaseVSize(statResult);
+        this.stats.decreaseCount();
+        this.stats.incrementDeletes();
       }
     }
+    promises.push(this._primary.delete(key));
+    if (this._secondary) {
+      promises.push(this._secondary.delete(key));
+    }
+    if (this.nonBlocking) {
+      result = await Promise.race(promises);
+    } else {
+      const resultAll = await Promise.all(promises);
+      result = resultAll[0];
+    }
     return result;
   }
   async deleteMany(keys) {
+    if (this.stats.enabled) {
+      const statResult = await this._primary.get(keys);
+      for (const key of keys) {
+        this.stats.decreaseKSize(key);
+        this.stats.decreaseVSize(statResult);
+        this.stats.decreaseCount();
+        this.stats.incrementDeletes();
+      }
+    }
     const result = await this.deleteManyKeyv(this._primary, keys);
     if (this._secondary) {
       if (this._nonBlocking) {
@@ -381,6 +750,10 @@ var Cacheable = class extends Hookified {
       promises.push(this._secondary.clear());
     }
     await (this._nonBlocking ? Promise.race(promises) : Promise.all(promises));
+    if (this.stats.enabled) {
+      this._stats.resetStoreValues();
+      this._stats.incrementClears();
+    }
   }
   async disconnect() {
     const promises = [];
@@ -401,7 +774,8 @@ var Cacheable = class extends Hookified {
   async setManyKeyv(keyv, items) {
     const promises = [];
     for (const item of items) {
-      promises.push(keyv.set(item.key, item.value, item.ttl));
+      const finalTtl = item.ttl ?? this._ttl;
+      promises.push(keyv.set(item.key, item.value, finalTtl));
     }
     await Promise.all(promises);
     return true;
@@ -417,5 +791,7 @@ var Cacheable = class extends Hookified {
 export {
   Cacheable,
   CacheableEvents,
-  CacheableHooks
+  CacheableHooks,
+  CacheableMemory,
+  CacheableStats
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cacheable",
-  "version": "0.8.0",
+  "version": "1.2.0",
   "description": "Simple Caching Engine using Keyv",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -19,11 +19,11 @@
   "devDependencies": {
     "@keyv/redis": "^3.0.1",
     "@vitest/coverage-v8": "^2.1.1",
-    "lru-cache": "^10.4.3",
+    "lru-cache": "^11.0.1",
     "rimraf": "^6.0.1",
     "ts-node": "^10.9.2",
-    "tsup": "^8.2.4",
-    "typescript": "^5.5.4",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.2",
     "vitest": "^2.1.1",
     "xo": "^0.59.3"
   },