@cacheable/node-cache 0.5.0 → 1.0.0

package/dist/index.js

@@ -1,344 +1,362 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeCacheErrors = void 0;
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-const eventemitter3_1 = __importDefault(require("eventemitter3"));
-var NodeCacheErrors;
-(function (NodeCacheErrors) {
-    NodeCacheErrors["ECACHEFULL"] = "Cache max keys amount exceeded";
-    NodeCacheErrors["EKEYTYPE"] = "The key argument has to be of type `string` or `number`. Found: `__key`";
-    NodeCacheErrors["EKEYSTYPE"] = "The keys argument has to be an array.";
-    NodeCacheErrors["ETTLTYPE"] = "The ttl argument has to be a number.";
-})(NodeCacheErrors || (exports.NodeCacheErrors = NodeCacheErrors = {}));
-class NodeCache extends eventemitter3_1.default {
-    constructor(options) {
-        super();
-        this.options = {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            stdTTL: 0,
-            checkperiod: 600,
-            useClones: true,
-            deleteOnExpire: true,
-            maxKeys: -1,
-        };
-        this.store = new Map();
-        this._stats = {
-            keys: 0,
-            hits: 0,
-            misses: 0,
-            ksize: 0,
-            vsize: 0,
-        };
-        this.intervalId = 0;
-        if (options) {
-            this.options = Object.assign(Object.assign({}, this.options), options);
-        }
-        this.startInterval();
-    }
-    // Sets a key value pair. It is possible to define a ttl (in seconds). Returns true on success.
-    set(key, value, ttl) {
-        // Check on key type
-        /* c8 ignore next 3 */
-        if (typeof key !== 'string' && typeof key !== 'number') {
-            throw this.createError(NodeCacheErrors.EKEYTYPE, key);
-        }
-        // Check on ttl type
-        /* c8 ignore next 3 */
-        if (ttl && typeof ttl !== 'number') {
-            throw this.createError(NodeCacheErrors.ETTLTYPE, this.formatKey(key));
-        }
-        const keyValue = this.formatKey(key);
-        const ttlValue = ttl !== null && ttl !== void 0 ? ttl : this.options.stdTTL;
-        let expirationTimestamp = 0; // Never delete
-        if (ttlValue && ttlValue > 0) {
-            expirationTimestamp = this.getExpirationTimestamp(ttlValue);
-        }
-        // Check on max key size
-        if (this.options.maxKeys) {
-            const maxKeys = this.options.maxKeys;
-            if (maxKeys > -1 && this.store.size >= maxKeys) {
-                throw this.createError(NodeCacheErrors.ECACHEFULL, this.formatKey(key));
-            }
-        }
-        this.store.set(keyValue, { key: keyValue, value, ttl: expirationTimestamp });
-        // Event
-        this.emit('set', keyValue, value, ttlValue);
-        // Add the bytes to the stats
-        this._stats.ksize += this.roughSizeOfKey(keyValue);
-        this._stats.vsize += this.roughSizeOfObject(value);
-        this._stats.keys = this.store.size;
-        return true;
-    }
-    // Sets multiple key val pairs. It is possible to define a ttl (seconds). Returns true on success.
-    mset(data) {
-        // Check on keys type
-        /* c8 ignore next 3 */
-        if (!Array.isArray(data)) {
-            throw this.createError(NodeCacheErrors.EKEYSTYPE);
-        }
-        for (const item of data) {
-            this.set(item.key, item.value, item.ttl);
-        }
-        return true;
-    }
-    // Gets a saved value from the cache. Returns a undefined if not found or expired. If the value was found it returns the value.
-    get(key) {
-        const result = this.store.get(this.formatKey(key));
-        if (result) {
-            if (result.ttl > 0) {
-                if (result.ttl < Date.now()) {
-                    if (this.options.deleteOnExpire) {
-                        this.del(key);
-                    }
-                    this.addMiss();
-                    // Event
-                    this.emit('expired', this.formatKey(key), result.value);
-                    return undefined;
-                }
-                this.addHit();
-                if (this.options.useClones) {
-                    return this.clone(result.value);
-                }
-                return result.value;
-            }
-            this.addHit();
-            if (this.options.useClones) {
-                return this.clone(result.value);
-            }
-            return result.value;
-        }
-        this.addMiss();
-        return undefined;
-    }
-    /*
-        Gets multiple saved values from the cache. Returns an empty object {} if not found or expired.
-        If the value was found it returns an object with the key value pair.
-    */
-    mget(keys) {
-        const result = {};
-        for (const key of keys) {
-            const value = this.get(key);
-            if (value) {
-                result[this.formatKey(key)] = value;
-            }
+// 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;
         }
-        return result;
+      }
     }
-    /*
-        Get the cached value and remove the key from the cache.
-        Equivalent to calling get(key) + del(key).
-        Useful for implementing single use mechanism such as OTP, where once a value is read it will become obsolete.
-    */
-    take(key) {
-        const result = this.get(key);
-        if (result) {
-            this.del(key);
-            if (this.options.useClones) {
-                return this.clone(result);
-            }
-            return result;
-        }
-        return undefined;
+  }
+  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;
     }
-    // Delete a key. Returns the number of deleted entries. A delete will never fail.
-    del(key) {
-        if (Array.isArray(key)) {
-            return this.mdel(key);
-        }
-        const result = this.store.get(this.formatKey(key));
-        if (result) {
-            const keyValue = this.formatKey(key);
-            this.store.delete(keyValue);
-            // Event
-            this.emit('del', keyValue, result.value);
-            // Remove the bytes from the stats
-            this._stats.ksize -= this.roughSizeOfKey(keyValue);
-            this._stats.vsize -= this.roughSizeOfObject(result.value);
-            this._stats.keys = this.store.size;
-            return 1;
-        }
-        return 0;
+  }
+  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;
+      }
     }
-    // Delete all keys in Array that exist. Returns the number of deleted entries.
-    mdel(keys) {
-        let result = 0;
-        for (const key of keys) {
-            result += this.del(key);
-        }
-        return result;
+    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 });
     }
-    // Redefine the ttl of a key. Returns true if the key has been found and changed.
-    // Otherwise returns false. If the ttl-argument isn't passed the default-TTL will be used.
-    ttl(key, ttl) {
-        const result = this.store.get(this.formatKey(key));
-        if (result) {
-            const ttlValue = ttl !== null && ttl !== void 0 ? ttl : this.options.stdTTL;
-            result.ttl = this.getExpirationTimestamp(ttlValue);
-            this.store.set(this.formatKey(key), result);
-            return true;
-        }
-        return false;
+    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());
     }
-    /*
-        Receive the ttl of a key. You will get:
+    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();
+  }
+};
 
-        undefined if the key does not exist
-        0 if this key has no ttl
-        a timestamp in ms representing the time at which the key will expire
-    */
-    getTtl(key) {
-        const result = this.store.get(this.formatKey(key));
-        if (result) {
-            if (result.ttl === 0) {
-                return 0;
-            }
-            return result.ttl;
-        }
-        return undefined;
+// 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`";
+  NodeCacheErrors2["EKEYSTYPE"] = "The keys argument has to be an array.";
+  NodeCacheErrors2["ETTLTYPE"] = "The ttl argument has to be a number.";
+  return NodeCacheErrors2;
+})(NodeCacheErrors || {});
+var NodeCache = class extends eventemitter {
+  options = {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    stdTTL: 0,
+    checkperiod: 600,
+    useClones: true,
+    deleteOnExpire: true,
+    maxKeys: -1
+  };
+  store = /* @__PURE__ */ new Map();
+  _stats = new CacheableStats({ enabled: true });
+  _cacheable = new CacheableMemory2();
+  intervalId = 0;
+  constructor(options) {
+    super();
+    if (options) {
+      this.options = { ...this.options, ...options };
     }
-    /*
-        Returns an array of all existing keys.
-        [ "all", "my", "keys", "foo", "bar" ]
-    */
-    keys() {
-        const result = [];
-        for (const key of this.store.keys()) {
-            result.push(key);
-        }
-        return result;
+    this.startInterval();
+  }
+  // Sets a key value pair. It is possible to define a ttl (in seconds). Returns true on success.
+  set(key, value, ttl) {
+    if (typeof key !== "string" && typeof key !== "number") {
+      throw this.createError("The key argument has to be of type `string` or `number`. Found: `__key`" /* EKEYTYPE */, key);
     }
-    // Returns boolean indicating if the key is cached.
-    has(key) {
-        return this.store.has(this.formatKey(key));
+    if (ttl && typeof ttl !== "number") {
+      throw this.createError("The ttl argument has to be a number." /* ETTLTYPE */, this.formatKey(key));
     }
-    // Gets the stats of the cache.
-    getStats() {
-        return this._stats;
+    const keyValue = this.formatKey(key);
+    const ttlValue = ttl ?? this.options.stdTTL;
+    let expirationTimestamp = 0;
+    if (ttlValue && ttlValue > 0) {
+      expirationTimestamp = this.getExpirationTimestamp(ttlValue);
     }
-    // Flush the whole data.
-    flushAll() {
-        this.store.clear();
-        this.flushStats();
-        // Event
-        this.emit('flush');
+    if (this.options.maxKeys) {
+      const maxKeys = this.options.maxKeys;
+      if (maxKeys > -1 && this.store.size >= maxKeys) {
+        throw this.createError("Cache max keys amount exceeded" /* ECACHEFULL */, this.formatKey(key));
+      }
     }
-    // Flush the stats
-    flushStats() {
-        this._stats = {
-            keys: 0,
-            hits: 0,
-            misses: 0,
-            ksize: 0,
-            vsize: 0,
-        };
-        // Event
-        this.emit('flush_stats');
+    this.store.set(keyValue, { key: keyValue, value, ttl: expirationTimestamp });
+    this.emit("set", keyValue, value, ttlValue);
+    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.
+  mset(data) {
+    if (!Array.isArray(data)) {
+      throw this.createError("The keys argument has to be an array." /* EKEYSTYPE */);
     }
-    // Close the cache. This will clear the interval timeout which is set on check period option.
-    close() {
-        this.stopInterval();
+    for (const item of data) {
+      this.set(item.key, item.value, item.ttl);
     }
-    // Get the interval id
-    getIntervalId() {
-        return this.intervalId;
+    return true;
+  }
+  // Gets a saved value from the cache. Returns a undefined if not found or expired. If the value was found it returns the value.
+  get(key) {
+    const result = this.store.get(this.formatKey(key));
+    if (result) {
+      if (result.ttl > 0) {
+        if (result.ttl < Date.now()) {
+          if (this.options.deleteOnExpire) {
+            this.del(key);
+          }
+          this._stats.incrementMisses();
+          this.emit("expired", this.formatKey(key), result.value);
+          return void 0;
+        }
+        this._stats.incrementHits();
+        if (this.options.useClones) {
+          return this._cacheable.clone(result.value);
+        }
+        return result.value;
+      }
+      this._stats.incrementHits();
+      if (this.options.useClones) {
+        return this._cacheable.clone(result.value);
+      }
+      return result.value;
     }
-    formatKey(key) {
-        return key.toString();
+    this._stats.incrementMisses();
+    return void 0;
+  }
+  /*
+  	Gets multiple saved values from the cache. Returns an empty object {} if not found or expired.
+  	If the value was found it returns an object with the key value pair.
+  */
+  mget(keys) {
+    const result = {};
+    for (const key of keys) {
+      const value = this.get(key);
+      if (value) {
+        result[this.formatKey(key)] = value;
+      }
     }
-    getExpirationTimestamp(ttlInSeconds) {
-        const currentTimestamp = Date.now(); // Current time in milliseconds
-        const ttlInMilliseconds = ttlInSeconds * 1000; // Convert TTL to milliseconds
-        const expirationTimestamp = currentTimestamp + ttlInMilliseconds;
-        return expirationTimestamp;
+    return result;
+  }
+  /*
+  	Get the cached value and remove the key from the cache.
+  	Equivalent to calling get(key) + del(key).
+  	Useful for implementing single use mechanism such as OTP, where once a value is read it will become obsolete.
+  */
+  take(key) {
+    const result = this.get(key);
+    if (result) {
+      this.del(key);
+      if (this.options.useClones) {
+        return this._cacheable.clone(result);
+      }
+      return result;
     }
-    addHit() {
-        this._stats.hits++;
+    return void 0;
+  }
+  // Delete a key. Returns the number of deleted entries. A delete will never fail.
+  del(key) {
+    if (Array.isArray(key)) {
+      return this.mdel(key);
     }
-    addMiss() {
-        this._stats.misses++;
+    const result = this.store.get(this.formatKey(key));
+    if (result) {
+      const keyValue = this.formatKey(key);
+      this.store.delete(keyValue);
+      this.emit("del", keyValue, result.value);
+      this._stats.decreaseKSize(keyValue);
+      this._stats.decreaseVSize(result.value);
+      this._stats.setCount(this.store.size);
+      return 1;
     }
-    roughSizeOfKey(key) {
-        // Keys are strings (UTF-16)
-        return this.formatKey(key).toString().length * 2;
+    return 0;
+  }
+  // Delete all keys in Array that exist. Returns the number of deleted entries.
+  mdel(keys) {
+    let result = 0;
+    for (const key of keys) {
+      result += this.del(key);
     }
-    roughSizeOfObject(object) {
-        const objectList = [];
-        const stack = [object];
-        let bytes = 0;
-        while (stack.length > 0) {
-            const value = stack.pop();
-            if (typeof value === 'boolean') {
-                bytes += 4; // Booleans are 4 bytes
-            }
-            else if (typeof value === 'string') {
-                bytes += value.length * 2; // Each character is 2 bytes (UTF-16 encoding)
-            }
-            else if (typeof value === 'number') {
-                bytes += 8; // Numbers are 8 bytes (IEEE 754 format)
-            }
-            else if (typeof value === 'object' && value !== null && !objectList.includes(value)) {
-                objectList.push(value);
-                // Estimate object overhead, and then recursively estimate the size of properties
-                // eslint-disable-next-line guard-for-in
-                for (const key in value) {
-                    bytes += key.length * 2; // Keys are strings (UTF-16)
-                    stack.push(value[key]); // Add values to the stack to compute their size
-                }
-            }
-        }
-        return bytes;
+    return result;
+  }
+  // Redefine the ttl of a key. Returns true if the key has been found and changed.
+  // Otherwise returns false. If the ttl-argument isn't passed the default-TTL will be used.
+  ttl(key, ttl) {
+    const result = this.store.get(this.formatKey(key));
+    if (result) {
+      const ttlValue = ttl ?? this.options.stdTTL;
+      result.ttl = this.getExpirationTimestamp(ttlValue);
+      this.store.set(this.formatKey(key), result);
+      return true;
     }
-    startInterval() {
-        if (this.options.checkperiod && this.options.checkperiod > 0) {
-            const checkPeriodinSeconds = this.options.checkperiod * 1000;
-            this.intervalId = setInterval(() => {
-                this.checkData();
-            }, checkPeriodinSeconds);
-            return;
-        }
-        this.intervalId = 0;
+    return false;
+  }
+  /*
+  		Receive the ttl of a key. You will get:
+  
+  		undefined if the key does not exist
+  		0 if this key has no ttl
+  		a timestamp in ms representing the time at which the key will expire
+  	*/
+  getTtl(key) {
+    const result = this.store.get(this.formatKey(key));
+    if (result) {
+      if (result.ttl === 0) {
+        return 0;
+      }
+      return result.ttl;
     }
-    checkData() {
-        for (const [key, value] of this.store.entries()) {
-            if (value.ttl > 0 && value.ttl < Date.now()) {
-                this.del(key);
-            }
-        }
+    return void 0;
+  }
+  /*
+  	Returns an array of all existing keys.
+  	[ "all", "my", "keys", "foo", "bar" ]
+  */
+  keys() {
+    const result = [];
+    for (const key of this.store.keys()) {
+      result.push(key);
     }
-    stopInterval() {
-        if (this.intervalId !== 0) {
-            clearInterval(this.intervalId);
-            this.intervalId = 0;
-        }
+    return result;
+  }
+  // Returns boolean indicating if the key is cached.
+  has(key) {
+    return this.store.has(this.formatKey(key));
+  }
+  // Gets the stats of the cache.
+  getStats() {
+    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() {
+    this.store.clear();
+    this.flushStats();
+    this.emit("flush");
+  }
+  // Flush the stats
+  flushStats() {
+    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.
+  close() {
+    this.stopInterval();
+  }
+  // Get the interval id
+  getIntervalId() {
+    return this.intervalId;
+  }
+  formatKey(key) {
+    return key.toString();
+  }
+  getExpirationTimestamp(ttlInSeconds) {
+    const currentTimestamp = Date.now();
+    const ttlInMilliseconds = ttlInSeconds * 1e3;
+    const expirationTimestamp = currentTimestamp + ttlInMilliseconds;
+    return expirationTimestamp;
+  }
+  startInterval() {
+    if (this.options.checkperiod && this.options.checkperiod > 0) {
+      const checkPeriodinSeconds = this.options.checkperiod * 1e3;
+      this.intervalId = setInterval(() => {
+        this.checkData();
+      }, checkPeriodinSeconds);
+      return;
     }
-    createError(errorCode, key) {
-        let error = errorCode;
-        /* c8 ignore next 3 */
-        if (key) {
-            error = error.replace('__key', key);
-        }
-        return new Error(error);
+    this.intervalId = 0;
+  }
+  checkData() {
+    for (const [key, value] of this.store.entries()) {
+      if (value.ttl > 0 && value.ttl < Date.now()) {
+        this.del(key);
+      }
     }
-    isPrimitive(value) {
-        const result = false;
-        /* c8 ignore next 3 */
-        if (value === null || value === undefined) {
-            return true;
-        }
-        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-            return true;
-        }
-        return result;
+  }
+  stopInterval() {
+    if (this.intervalId !== 0) {
+      clearInterval(this.intervalId);
+      this.intervalId = 0;
     }
-    clone(value) {
-        if (this.isPrimitive(value)) {
-            return value;
-        }
-        return structuredClone(value);
+  }
+  createError(errorCode, key) {
+    let error = errorCode;
+    if (key) {
+      error = error.replace("__key", key);
     }
-}
-exports.default = NodeCache;
-//# sourceMappingURL=index.js.map
+    return new Error(error);
+  }
+};
+export {
+  NodeCacheErrors,
+  NodeCacheStore,
+  NodeCache as default
+};