@cacheable/node-cache 0.8.0 → 1.1.0

package/README.md

@@ -22,6 +22,7 @@ Note: `NodeCache` is ready and available for use. `NodeCacheStore` is in progres
 * [Getting Started](#getting-started)
 * [Basic Usage](#basic-usage)
 * [Advanced Usage](#advanced-usage)
+* [NodeCacheStore](#nodecachestore)
 * [API](#api)
 * [How to Contribute](#how-to-contribute)
 * [License and Copyright](#license-and-copyright)
@@ -60,6 +61,49 @@ await cache.get('foo'); // 'bar'
 cache.getStats(); // {hits: 1, misses: 1, keys: 1, ksize: 2, vsize: 3}
 ```
 
+## NodeCacheStore
+
+The `NodeCacheStore` is a class that extends the `NodeCache` and adds the ability to use storage adapters. This is based on the `cacheable` engine and allows you to do layer 1 and layer 2 caching. The storage adapters are based on the [Keyv](https://keyv.org) package. This allows you to use any of the storage adapters that are available.
+
+```javascript
+import {NodeCacheStore} from '@cacheable/node-cache';
+
+const cache = new NodeCacheStore();
+cache.set('foo', 'bar');
+cache.get('foo'); // 'bar'
+```
+
+### NodeCacheStoreOptions
+
+When initializing the cache you can pass in the options below:
+
+```javascript
+export type NodeCacheStoreOptions = {
+	ttl?: number; // The standard ttl as number in seconds for every generated cache element. 0 = unlimited
+	primary?: Keyv; // The primary storage adapter
+	secondary?: Keyv; // The secondary storage adapter
+	maxKeys?: number; // Default is 0 (unlimited). If this is set it will throw and error if you try to set more keys than the max.
+};
+```
+
+### Node Cache Store API
+
+* `set(key: string | number, value: any, ttl?: number): Promise<boolean>` - Set a key value pair with an optional ttl (in milliseconds). Will return true on success. If the ttl is not set it will default to 0 (no ttl)
+* `mset(data: Array<NodeCacheItem>): Promise<boolean>` - Set multiple key value pairs at once
+* `get<T>(key: string | number): Promise<T>` - Get a value from the cache by key
+* `mget(keys: Array<string | number>): Promise<Record<string, unknown>>` - Get multiple values from the cache by keys
+* `take<T>(key: string | number): Promise<T>` - Get a value from the cache by key and delete it
+* `del(key: string | number): Promise<boolean>` - Delete a key
+* `mdel(keys: Array<string | number>): Promise<boolean>` - Delete multiple keys
+* `clear(): Promise<void>` - Clear the cache
+* `setTtl(key: string | number, ttl: number): Promise<boolean>` - Set the ttl of a key
+* `disconnect(): Promise<void>` - Disconnect the storage adapters
+* `stats`: `NodeCacheStats` - Get the stats of the cache
+* `ttl`: `number` - The standard ttl as number in seconds for every generated cache element. 0 = unlimited
+* `primary`: `Keyv` - The primary storage adapter
+* `secondary`: `Keyv` - The secondary storage adapter
+* `maxKeys`: `number` - If this is set it will throw and error if you try to set more keys than the max
+
 ## API
 
 ### `constructor(options?: NodeCacheOptions)`

package/dist/index.cjs

@@ -31,10 +31,120 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   NodeCacheErrors: () => NodeCacheErrors,
+  NodeCacheStore: () => NodeCacheStore,
   default: () => NodeCache
 });
 module.exports = __toCommonJS(src_exports);
 var import_eventemitter3 = __toESM(require("eventemitter3"), 1);
+var import_cacheable2 = require("cacheable");
+
+// src/store.ts
+var import_cacheable = require("cacheable");
+var import_keyv = require("keyv");
+var NodeCacheStore = class {
+  _maxKeys = 0;
+  _cache = new import_cacheable.Cacheable({ primary: new import_keyv.Keyv({ store: new import_cacheable.CacheableMemory() }) });
+  constructor(options) {
+    if (options) {
+      const cacheOptions = {
+        ttl: options.ttl,
+        primary: options.primary,
+        secondary: options.secondary
+      };
+      this._cache = new import_cacheable.Cacheable(cacheOptions);
+      if (options.maxKeys) {
+        this._maxKeys = options.maxKeys;
+        if (this._maxKeys > 0) {
+          this._cache.stats.enabled = true;
+        }
+      }
+    }
+  }
+  get cache() {
+    return this._cache;
+  }
+  get ttl() {
+    return this._cache.ttl;
+  }
+  set ttl(ttl) {
+    this._cache.ttl = ttl;
+  }
+  get primary() {
+    return this._cache.primary;
+  }
+  set primary(primary) {
+    this._cache.primary = primary;
+  }
+  get secondary() {
+    return this._cache.secondary;
+  }
+  set secondary(secondary) {
+    this._cache.secondary = secondary;
+  }
+  get maxKeys() {
+    return this._maxKeys;
+  }
+  set maxKeys(maxKeys) {
+    this._maxKeys = maxKeys;
+    if (this._maxKeys > 0) {
+      this._cache.stats.enabled = true;
+    }
+  }
+  async set(key, value, ttl) {
+    if (this._maxKeys > 0) {
+      console.log(this._cache.stats.count, this._maxKeys);
+      if (this._cache.stats.count >= this._maxKeys) {
+        return false;
+      }
+    }
+    const finalTtl = ttl ?? this._cache.ttl;
+    await this._cache.set(key.toString(), value, finalTtl);
+    return true;
+  }
+  async mset(list) {
+    const items = new Array();
+    for (const item of list) {
+      items.push({ key: item.key.toString(), value: item.value, ttl: item.ttl });
+    }
+    await this._cache.setMany(items);
+  }
+  async get(key) {
+    return this._cache.get(key.toString());
+  }
+  async mget(keys) {
+    const result = {};
+    for (const key of keys) {
+      result[key.toString()] = await this._cache.get(key.toString());
+    }
+    return result;
+  }
+  async del(key) {
+    return this._cache.delete(key.toString());
+  }
+  async mdel(keys) {
+    return this._cache.deleteMany(keys.map((key) => key.toString()));
+  }
+  async clear() {
+    return this._cache.clear();
+  }
+  async setTtl(key, ttl) {
+    const finalTtl = ttl ?? this._cache.ttl;
+    const item = await this._cache.get(key.toString());
+    if (item) {
+      await this._cache.set(key.toString(), item, finalTtl);
+      return true;
+    }
+    return false;
+  }
+  async take(key) {
+    return this._cache.take(key.toString());
+  }
+  async disconnect() {
+    await this._cache.disconnect();
+  }
+};
+
+// src/index.ts
 var NodeCacheErrors = /* @__PURE__ */ ((NodeCacheErrors2) => {
   NodeCacheErrors2["ECACHEFULL"] = "Cache max keys amount exceeded";
   NodeCacheErrors2["EKEYTYPE"] = "The key argument has to be of type `string` or `number`. Found: `__key`";
@@ -52,13 +162,8 @@ var NodeCache = class extends import_eventemitter3.default {
     maxKeys: -1
   };
   store = /* @__PURE__ */ new Map();
-  _stats = {
-    keys: 0,
-    hits: 0,
-    misses: 0,
-    ksize: 0,
-    vsize: 0
-  };
+  _stats = new import_cacheable2.CacheableStats({ enabled: true });
+  _cacheable = new import_cacheable2.CacheableMemory();
   intervalId = 0;
   constructor(options) {
     super();
@@ -89,9 +194,9 @@ var NodeCache = class extends import_eventemitter3.default {
     }
     this.store.set(keyValue, { key: keyValue, value, ttl: expirationTimestamp });
     this.emit("set", keyValue, value, ttlValue);
-    this._stats.ksize += this.roughSizeOfKey(keyValue);
-    this._stats.vsize += this.roughSizeOfObject(value);
-    this._stats.keys = this.store.size;
+    this._stats.incrementKSize(keyValue);
+    this._stats.incrementVSize(value);
+    this._stats.setCount(this.store.size);
     return true;
   }
   // Sets multiple key val pairs. It is possible to define a ttl (seconds). Returns true on success.
@@ -113,23 +218,23 @@ var NodeCache = class extends import_eventemitter3.default {
           if (this.options.deleteOnExpire) {
             this.del(key);
           }
-          this.addMiss();
+          this._stats.incrementMisses();
           this.emit("expired", this.formatKey(key), result.value);
           return void 0;
         }
-        this.addHit();
+        this._stats.incrementHits();
         if (this.options.useClones) {
-          return this.clone(result.value);
+          return this._cacheable.clone(result.value);
         }
         return result.value;
       }
-      this.addHit();
+      this._stats.incrementHits();
       if (this.options.useClones) {
-        return this.clone(result.value);
+        return this._cacheable.clone(result.value);
       }
       return result.value;
     }
-    this.addMiss();
+    this._stats.incrementMisses();
     return void 0;
   }
   /*
@@ -156,7 +261,7 @@ var NodeCache = class extends import_eventemitter3.default {
     if (result) {
       this.del(key);
       if (this.options.useClones) {
-        return this.clone(result);
+        return this._cacheable.clone(result);
       }
       return result;
     }
@@ -172,9 +277,9 @@ var NodeCache = class extends import_eventemitter3.default {
       const keyValue = this.formatKey(key);
       this.store.delete(keyValue);
       this.emit("del", keyValue, result.value);
-      this._stats.ksize -= this.roughSizeOfKey(keyValue);
-      this._stats.vsize -= this.roughSizeOfObject(result.value);
-      this._stats.keys = this.store.size;
+      this._stats.decreaseKSize(keyValue);
+      this._stats.decreaseVSize(result.value);
+      this._stats.setCount(this.store.size);
       return 1;
     }
     return 0;
@@ -233,7 +338,14 @@ var NodeCache = class extends import_eventemitter3.default {
   }
   // Gets the stats of the cache.
   getStats() {
-    return this._stats;
+    const stats = {
+      keys: this._stats.count,
+      hits: this._stats.hits,
+      misses: this._stats.misses,
+      ksize: this._stats.ksize,
+      vsize: this._stats.vsize
+    };
+    return stats;
   }
   // Flush the whole data.
   flushAll() {
@@ -243,13 +355,7 @@ var NodeCache = class extends import_eventemitter3.default {
   }
   // Flush the stats
   flushStats() {
-    this._stats = {
-      keys: 0,
-      hits: 0,
-      misses: 0,
-      ksize: 0,
-      vsize: 0
-    };
+    this._stats = new import_cacheable2.CacheableStats({ enabled: true });
     this.emit("flush_stats");
   }
   // Close the cache. This will clear the interval timeout which is set on check period option.
@@ -269,37 +375,6 @@ var NodeCache = class extends import_eventemitter3.default {
     const expirationTimestamp = currentTimestamp + ttlInMilliseconds;
     return expirationTimestamp;
   }
-  addHit() {
-    this._stats.hits++;
-  }
-  addMiss() {
-    this._stats.misses++;
-  }
-  roughSizeOfKey(key) {
-    return this.formatKey(key).toString().length * 2;
-  }
-  roughSizeOfObject(object) {
-    const objectList = [];
-    const stack = [object];
-    let bytes = 0;
-    while (stack.length > 0) {
-      const value = stack.pop();
-      if (typeof value === "boolean") {
-        bytes += 4;
-      } else if (typeof value === "string") {
-        bytes += value.length * 2;
-      } else if (typeof value === "number") {
-        bytes += 8;
-      } else if (typeof value === "object" && value !== null && !objectList.includes(value)) {
-        objectList.push(value);
-        for (const key in value) {
-          bytes += key.length * 2;
-          stack.push(value[key]);
-        }
-      }
-    }
-    return bytes;
-  }
   startInterval() {
     if (this.options.checkperiod && this.options.checkperiod > 0) {
       const checkPeriodinSeconds = this.options.checkperiod * 1e3;
@@ -330,24 +405,9 @@ var NodeCache = class extends import_eventemitter3.default {
     }
     return new Error(error);
   }
-  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;
-  }
-  clone(value) {
-    if (this.isPrimitive(value)) {
-      return value;
-    }
-    return structuredClone(value);
-  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  NodeCacheErrors
+  NodeCacheErrors,
+  NodeCacheStore
 });

package/dist/index.d.cts

@@ -1,4 +1,37 @@
 import eventemitter from 'eventemitter3';
+import { Cacheable } from 'cacheable';
+import { Keyv } from 'keyv';
+
+type NodeCacheStoreOptions = {
+    ttl?: number;
+    maxKeys?: number;
+    primary?: Keyv;
+    secondary?: Keyv;
+};
+declare class NodeCacheStore {
+    private _maxKeys;
+    private readonly _cache;
+    constructor(options?: NodeCacheStoreOptions);
+    get cache(): Cacheable;
+    get ttl(): number | undefined;
+    set ttl(ttl: number | undefined);
+    get primary(): Keyv;
+    set primary(primary: Keyv);
+    get secondary(): Keyv | undefined;
+    set secondary(secondary: Keyv | undefined);
+    get maxKeys(): number;
+    set maxKeys(maxKeys: number);
+    set(key: string | number, value: any, ttl?: number): Promise<boolean>;
+    mset(list: NodeCacheItem[]): Promise<void>;
+    get<T>(key: string | number): Promise<T | undefined>;
+    mget<T>(keys: Array<string | number>): Promise<Record<string, T | undefined>>;
+    del(key: string | number): Promise<boolean>;
+    mdel(keys: Array<string | number>): Promise<boolean>;
+    clear(): Promise<void>;
+    setTtl(key: string | number, ttl?: number): Promise<boolean>;
+    take<T>(key: string | number): Promise<T | undefined>;
+    disconnect(): Promise<void>;
+}
 
 type NodeCacheOptions = {
     stdTTL?: number;
@@ -29,6 +62,7 @@ declare class NodeCache extends eventemitter {
     readonly options: NodeCacheOptions;
     readonly store: Map<string, any>;
     private _stats;
+    private readonly _cacheable;
     private intervalId;
     constructor(options?: NodeCacheOptions);
     set(key: string | number, value: any, ttl?: number): boolean;
@@ -49,16 +83,10 @@ declare class NodeCache extends eventemitter {
     getIntervalId(): number | NodeJS.Timeout;
     private formatKey;
     private getExpirationTimestamp;
-    private addHit;
-    private addMiss;
-    private roughSizeOfKey;
-    private roughSizeOfObject;
     private startInterval;
     private checkData;
     private stopInterval;
     private createError;
-    private isPrimitive;
-    private clone;
 }
 
-export { NodeCacheErrors, type NodeCacheItem, type NodeCacheOptions, type NodeCacheStats, NodeCache as default };
+export { NodeCacheErrors, type NodeCacheItem, type NodeCacheOptions, type NodeCacheStats, NodeCacheStore, type NodeCacheStoreOptions, NodeCache as default };

package/dist/index.d.ts

@@ -1,4 +1,37 @@
 import eventemitter from 'eventemitter3';
+import { Cacheable } from 'cacheable';
+import { Keyv } from 'keyv';
+
+type NodeCacheStoreOptions = {
+    ttl?: number;
+    maxKeys?: number;
+    primary?: Keyv;
+    secondary?: Keyv;
+};
+declare class NodeCacheStore {
+    private _maxKeys;
+    private readonly _cache;
+    constructor(options?: NodeCacheStoreOptions);
+    get cache(): Cacheable;
+    get ttl(): number | undefined;
+    set ttl(ttl: number | undefined);
+    get primary(): Keyv;
+    set primary(primary: Keyv);
+    get secondary(): Keyv | undefined;
+    set secondary(secondary: Keyv | undefined);
+    get maxKeys(): number;
+    set maxKeys(maxKeys: number);
+    set(key: string | number, value: any, ttl?: number): Promise<boolean>;
+    mset(list: NodeCacheItem[]): Promise<void>;
+    get<T>(key: string | number): Promise<T | undefined>;
+    mget<T>(keys: Array<string | number>): Promise<Record<string, T | undefined>>;
+    del(key: string | number): Promise<boolean>;
+    mdel(keys: Array<string | number>): Promise<boolean>;
+    clear(): Promise<void>;
+    setTtl(key: string | number, ttl?: number): Promise<boolean>;
+    take<T>(key: string | number): Promise<T | undefined>;
+    disconnect(): Promise<void>;
+}
 
 type NodeCacheOptions = {
     stdTTL?: number;
@@ -29,6 +62,7 @@ declare class NodeCache extends eventemitter {
     readonly options: NodeCacheOptions;
     readonly store: Map<string, any>;
     private _stats;
+    private readonly _cacheable;
     private intervalId;
     constructor(options?: NodeCacheOptions);
     set(key: string | number, value: any, ttl?: number): boolean;
@@ -49,16 +83,10 @@ declare class NodeCache extends eventemitter {
     getIntervalId(): number | NodeJS.Timeout;
     private formatKey;
     private getExpirationTimestamp;
-    private addHit;
-    private addMiss;
-    private roughSizeOfKey;
-    private roughSizeOfObject;
     private startInterval;
     private checkData;
     private stopInterval;
     private createError;
-    private isPrimitive;
-    private clone;
 }
 
-export { NodeCacheErrors, type NodeCacheItem, type NodeCacheOptions, type NodeCacheStats, NodeCache as default };
+export { NodeCacheErrors, type NodeCacheItem, type NodeCacheOptions, type NodeCacheStats, NodeCacheStore, type NodeCacheStoreOptions, NodeCache as default };

package/dist/index.js

@@ -1,5 +1,114 @@
 // src/index.ts
 import eventemitter from "eventemitter3";
+import { CacheableMemory as CacheableMemory2, CacheableStats } from "cacheable";
+
+// src/store.ts
+import { Cacheable, CacheableMemory } from "cacheable";
+import { Keyv } from "keyv";
+var NodeCacheStore = class {
+  _maxKeys = 0;
+  _cache = new Cacheable({ primary: new Keyv({ store: new CacheableMemory() }) });
+  constructor(options) {
+    if (options) {
+      const cacheOptions = {
+        ttl: options.ttl,
+        primary: options.primary,
+        secondary: options.secondary
+      };
+      this._cache = new Cacheable(cacheOptions);
+      if (options.maxKeys) {
+        this._maxKeys = options.maxKeys;
+        if (this._maxKeys > 0) {
+          this._cache.stats.enabled = true;
+        }
+      }
+    }
+  }
+  get cache() {
+    return this._cache;
+  }
+  get ttl() {
+    return this._cache.ttl;
+  }
+  set ttl(ttl) {
+    this._cache.ttl = ttl;
+  }
+  get primary() {
+    return this._cache.primary;
+  }
+  set primary(primary) {
+    this._cache.primary = primary;
+  }
+  get secondary() {
+    return this._cache.secondary;
+  }
+  set secondary(secondary) {
+    this._cache.secondary = secondary;
+  }
+  get maxKeys() {
+    return this._maxKeys;
+  }
+  set maxKeys(maxKeys) {
+    this._maxKeys = maxKeys;
+    if (this._maxKeys > 0) {
+      this._cache.stats.enabled = true;
+    }
+  }
+  async set(key, value, ttl) {
+    if (this._maxKeys > 0) {
+      console.log(this._cache.stats.count, this._maxKeys);
+      if (this._cache.stats.count >= this._maxKeys) {
+        return false;
+      }
+    }
+    const finalTtl = ttl ?? this._cache.ttl;
+    await this._cache.set(key.toString(), value, finalTtl);
+    return true;
+  }
+  async mset(list) {
+    const items = new Array();
+    for (const item of list) {
+      items.push({ key: item.key.toString(), value: item.value, ttl: item.ttl });
+    }
+    await this._cache.setMany(items);
+  }
+  async get(key) {
+    return this._cache.get(key.toString());
+  }
+  async mget(keys) {
+    const result = {};
+    for (const key of keys) {
+      result[key.toString()] = await this._cache.get(key.toString());
+    }
+    return result;
+  }
+  async del(key) {
+    return this._cache.delete(key.toString());
+  }
+  async mdel(keys) {
+    return this._cache.deleteMany(keys.map((key) => key.toString()));
+  }
+  async clear() {
+    return this._cache.clear();
+  }
+  async setTtl(key, ttl) {
+    const finalTtl = ttl ?? this._cache.ttl;
+    const item = await this._cache.get(key.toString());
+    if (item) {
+      await this._cache.set(key.toString(), item, finalTtl);
+      return true;
+    }
+    return false;
+  }
+  async take(key) {
+    return this._cache.take(key.toString());
+  }
+  async disconnect() {
+    await this._cache.disconnect();
+  }
+};
+
+// src/index.ts
 var NodeCacheErrors = /* @__PURE__ */ ((NodeCacheErrors2) => {
   NodeCacheErrors2["ECACHEFULL"] = "Cache max keys amount exceeded";
   NodeCacheErrors2["EKEYTYPE"] = "The key argument has to be of type `string` or `number`. Found: `__key`";
@@ -17,13 +126,8 @@ var NodeCache = class extends eventemitter {
     maxKeys: -1
   };
   store = /* @__PURE__ */ new Map();
-  _stats = {
-    keys: 0,
-    hits: 0,
-    misses: 0,
-    ksize: 0,
-    vsize: 0
-  };
+  _stats = new CacheableStats({ enabled: true });
+  _cacheable = new CacheableMemory2();
   intervalId = 0;
   constructor(options) {
     super();
@@ -54,9 +158,9 @@ var NodeCache = class extends eventemitter {
     }
     this.store.set(keyValue, { key: keyValue, value, ttl: expirationTimestamp });
     this.emit("set", keyValue, value, ttlValue);
-    this._stats.ksize += this.roughSizeOfKey(keyValue);
-    this._stats.vsize += this.roughSizeOfObject(value);
-    this._stats.keys = this.store.size;
+    this._stats.incrementKSize(keyValue);
+    this._stats.incrementVSize(value);
+    this._stats.setCount(this.store.size);
     return true;
   }
   // Sets multiple key val pairs. It is possible to define a ttl (seconds). Returns true on success.
@@ -78,23 +182,23 @@ var NodeCache = class extends eventemitter {
           if (this.options.deleteOnExpire) {
             this.del(key);
           }
-          this.addMiss();
+          this._stats.incrementMisses();
           this.emit("expired", this.formatKey(key), result.value);
           return void 0;
         }
-        this.addHit();
+        this._stats.incrementHits();
         if (this.options.useClones) {
-          return this.clone(result.value);
+          return this._cacheable.clone(result.value);
         }
         return result.value;
       }
-      this.addHit();
+      this._stats.incrementHits();
       if (this.options.useClones) {
-        return this.clone(result.value);
+        return this._cacheable.clone(result.value);
       }
       return result.value;
     }
-    this.addMiss();
+    this._stats.incrementMisses();
     return void 0;
   }
   /*
@@ -121,7 +225,7 @@ var NodeCache = class extends eventemitter {
     if (result) {
       this.del(key);
       if (this.options.useClones) {
-        return this.clone(result);
+        return this._cacheable.clone(result);
       }
       return result;
     }
@@ -137,9 +241,9 @@ var NodeCache = class extends eventemitter {
       const keyValue = this.formatKey(key);
       this.store.delete(keyValue);
       this.emit("del", keyValue, result.value);
-      this._stats.ksize -= this.roughSizeOfKey(keyValue);
-      this._stats.vsize -= this.roughSizeOfObject(result.value);
-      this._stats.keys = this.store.size;
+      this._stats.decreaseKSize(keyValue);
+      this._stats.decreaseVSize(result.value);
+      this._stats.setCount(this.store.size);
       return 1;
     }
     return 0;
@@ -198,7 +302,14 @@ var NodeCache = class extends eventemitter {
   }
   // Gets the stats of the cache.
   getStats() {
-    return this._stats;
+    const stats = {
+      keys: this._stats.count,
+      hits: this._stats.hits,
+      misses: this._stats.misses,
+      ksize: this._stats.ksize,
+      vsize: this._stats.vsize
+    };
+    return stats;
   }
   // Flush the whole data.
   flushAll() {
@@ -208,13 +319,7 @@ var NodeCache = class extends eventemitter {
   }
   // Flush the stats
   flushStats() {
-    this._stats = {
-      keys: 0,
-      hits: 0,
-      misses: 0,
-      ksize: 0,
-      vsize: 0
-    };
+    this._stats = new CacheableStats({ enabled: true });
     this.emit("flush_stats");
   }
   // Close the cache. This will clear the interval timeout which is set on check period option.
@@ -234,37 +339,6 @@ var NodeCache = class extends eventemitter {
     const expirationTimestamp = currentTimestamp + ttlInMilliseconds;
     return expirationTimestamp;
   }
-  addHit() {
-    this._stats.hits++;
-  }
-  addMiss() {
-    this._stats.misses++;
-  }
-  roughSizeOfKey(key) {
-    return this.formatKey(key).toString().length * 2;
-  }
-  roughSizeOfObject(object) {
-    const objectList = [];
-    const stack = [object];
-    let bytes = 0;
-    while (stack.length > 0) {
-      const value = stack.pop();
-      if (typeof value === "boolean") {
-        bytes += 4;
-      } else if (typeof value === "string") {
-        bytes += value.length * 2;
-      } else if (typeof value === "number") {
-        bytes += 8;
-      } else if (typeof value === "object" && value !== null && !objectList.includes(value)) {
-        objectList.push(value);
-        for (const key in value) {
-          bytes += key.length * 2;
-          stack.push(value[key]);
-        }
-      }
-    }
-    return bytes;
-  }
   startInterval() {
     if (this.options.checkperiod && this.options.checkperiod > 0) {
       const checkPeriodinSeconds = this.options.checkperiod * 1e3;
@@ -295,24 +369,9 @@ var NodeCache = class extends eventemitter {
     }
     return new Error(error);
   }
-  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;
-  }
-  clone(value) {
-    if (this.isPrimitive(value)) {
-      return value;
-    }
-    return structuredClone(value);
-  }
 };
 export {
   NodeCacheErrors,
+  NodeCacheStore,
   NodeCache as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cacheable/node-cache",
-  "version": "0.8.0",
+  "version": "1.1.0",
   "description": "Simple and Maintained fast NodeJS internal caching",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -30,14 +30,15 @@
     "@types/node": "^22.5.5",
     "@vitest/coverage-v8": "^2.1.1",
     "rimraf": "^6.0.1",
-    "tsup": "^8.2.4",
+    "tsup": "^8.3.0",
     "typescript": "^5.6.2",
     "vitest": "^2.1.1",
     "xo": "^0.59.3"
   },
   "dependencies": {
-    "cacheable": "^0.8.0",
-    "eventemitter3": "^5.0.1"
+    "cacheable": "^1.2.0",
+    "eventemitter3": "^5.0.1",
+    "keyv": "^5.0.1"
   },
   "files": [
     "dist",