@cacheable/node-cache 1.4.2 → 1.5.1

package/README.md

@@ -36,6 +36,22 @@ npm install @cacheable/node-cache --save
 
 # Basic Usage
 
+```javascript
+import NodeCache from '@cacheable/node-cache';
+
+const cache = new NodeCache();
+cache.set('foo', 'bar');
+cache.get('foo'); // 'bar'
+
+cache.set('foo', 'bar', 10); // 10 seconds
+
+cache.del('foo'); // true
+
+cache.set('bar', 'baz', '35m'); // 35 minutes using shorthand
+```
+
+# NodeCache Not Default Export
+
 ```javascript
 import {NodeCache} from '@cacheable/node-cache';
 
@@ -84,6 +100,7 @@ export type NodeCacheStoreOptions = {
 	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.
+	stats?: boolean; // Default is true, if this is set to false it will not track stats
 };
 ```
 
@@ -121,7 +138,7 @@ Create a new cache instance. You can pass in options to set the configuration:
 
 ```javascript
 export type NodeCacheOptions = {
-	stdTTL?: number; // The standard ttl as number in seconds for every generated cache element. 0 = unlimited
+	stdTTL?: number; // The standard ttl as number in seconds for every generated cache element. 0 = unlimited. If string, it will be parsed as shorthand and default to milliseconds if it is a number as a string.
 	checkperiod?: number; // Default is 600, 0 means no periodic check
 	useClones?: boolean; // Default is true
 	deleteOnExpire?: boolean; // Default is true, if this is set to true it will delete the key when it expires.

package/dist/index.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,48 +15,44 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  NodeCache: () => NodeCache,
   NodeCacheErrors: () => NodeCacheErrors,
   NodeCacheStore: () => NodeCacheStore,
-  default: () => NodeCache
+  default: () => src_default
 });
 module.exports = __toCommonJS(src_exports);
-var import_eventemitter3 = __toESM(require("eventemitter3"), 1);
 var import_cacheable2 = require("cacheable");
+var import_hookified2 = require("hookified");
 
 // src/store.ts
 var import_cacheable = require("cacheable");
 var import_keyv = require("keyv");
-var NodeCacheStore = class {
+var import_hookified = require("hookified");
+var NodeCacheStore = class extends import_hookified.Hookified {
   _maxKeys = 0;
   _cache = new import_cacheable.Cacheable({ primary: new import_keyv.Keyv({ store: new import_cacheable.CacheableMemory() }) });
   constructor(options) {
+    super();
     if (options) {
       const cacheOptions = {
         ttl: options.ttl,
         primary: options.primary,
-        secondary: options.secondary
+        secondary: options.secondary,
+        stats: options.stats ?? true
       };
       this._cache = new import_cacheable.Cacheable(cacheOptions);
       if (options.maxKeys) {
         this._maxKeys = options.maxKeys;
-        if (this._maxKeys > 0) {
-          this._cache.stats.enabled = true;
-        }
       }
     }
+    this._cache.on("error", (error) => {
+      this.emit("error", error);
+    });
   }
   /**
    * Cacheable instance.
@@ -240,10 +234,10 @@ 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.";
+  NodeCacheErrors2["ETTLTYPE"] = "The ttl argument has to be a number or a string for shorthand ttl.";
   return NodeCacheErrors2;
 })(NodeCacheErrors || {});
-var NodeCache = class extends import_eventemitter3.default {
+var NodeCache = class extends import_hookified2.Hookified {
   options = {
     // eslint-disable-next-line @typescript-eslint/naming-convention
     stdTTL: 0,
@@ -267,21 +261,27 @@ var NodeCache = class extends import_eventemitter3.default {
    * Sets a key value pair. It is possible to define a ttl (in seconds). Returns true on success.
    * @param {string | number} key - it will convert the key to a string
    * @param {any} value
-   * @param {number} [ttl] - this is in seconds and undefined will use the default ttl
+   * @param {number | string} [ttl] - this is in seconds and undefined will use the default ttl
    * @returns {boolean}
    */
   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);
     }
-    if (ttl && typeof ttl !== "number") {
-      throw this.createError("The ttl argument has to be a number." /* ETTLTYPE */, this.formatKey(key));
+    if (ttl && typeof ttl !== "number" && typeof ttl !== "string") {
+      throw this.createError("The ttl argument has to be a number or a string for shorthand ttl." /* ETTLTYPE */, this.formatKey(key));
     }
     const keyValue = this.formatKey(key);
-    const ttlValue = ttl ?? this.options.stdTTL;
+    let ttlValue = 0;
+    if (this.options.stdTTL) {
+      ttlValue = this.getExpirationTimestamp(this.options.stdTTL);
+    }
+    if (ttl) {
+      ttlValue = this.getExpirationTimestamp(ttl);
+    }
     let expirationTimestamp = 0;
     if (ttlValue && ttlValue > 0) {
-      expirationTimestamp = this.getExpirationTimestamp(ttlValue);
+      expirationTimestamp = ttlValue;
     }
     if (this.options.maxKeys) {
       const maxKeys = this.options.maxKeys;
@@ -412,7 +412,7 @@ var NodeCache = class extends import_eventemitter3.default {
    * 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.
    * @param {string | number} key if the key is a number it will convert it to a string
-   * @param {number} [ttl] the ttl in seconds
+   * @param {number | string} [ttl] the ttl in seconds if number, or a shorthand string like '1h' for 1 hour
    * @returns {boolean} true if the key has been found and changed. Otherwise returns false.
    */
   ttl(key, ttl) {
@@ -509,6 +509,9 @@ var NodeCache = class extends import_eventemitter3.default {
     return key.toString();
   }
   getExpirationTimestamp(ttlInSeconds) {
+    if (typeof ttlInSeconds === "string") {
+      return (0, import_cacheable2.shorthandToTime)(ttlInSeconds);
+    }
     const currentTimestamp = Date.now();
     const ttlInMilliseconds = ttlInSeconds * 1e3;
     const expirationTimestamp = currentTimestamp + ttlInMilliseconds;
@@ -545,8 +548,10 @@ var NodeCache = class extends import_eventemitter3.default {
     return new Error(error);
   }
 };
+var src_default = NodeCache;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  NodeCache,
   NodeCacheErrors,
   NodeCacheStore
 });

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import eventemitter from 'eventemitter3';
+import { Hookified } from 'hookified';
 import { Cacheable } from 'cacheable';
 import { Keyv } from 'keyv';
 
@@ -20,8 +20,12 @@ type NodeCacheStoreOptions = {
      * [storage-tiering-and-caching](https://github.com/jaredwray/cacheable/tree/main/packages/cacheable#storage-tiering-and-caching)
      */
     secondary?: Keyv;
+    /**
+     * Enable stats tracking. This is a breaking change from the original NodeCache.
+     */
+    stats?: boolean;
 };
-declare class NodeCacheStore {
+declare class NodeCacheStore extends Hookified {
     private _maxKeys;
     private readonly _cache;
     constructor(options?: NodeCacheStoreOptions);
@@ -142,9 +146,9 @@ declare class NodeCacheStore {
 
 type NodeCacheOptions = {
     /**
-     * The standard ttl as number in seconds for every generated cache element. 0 = unlimited
+     * The standard ttl as number in seconds for every generated cache element. 0 = unlimited, If string, it will be in shorthand format like '1h' for 1 hour
      */
-    stdTTL?: number;
+    stdTTL?: number | string;
     /**
      * The interval to check for expired items in seconds. Default is 600 = 5 minutes
      */
@@ -181,7 +185,7 @@ declare enum NodeCacheErrors {
     ECACHEFULL = "Cache max keys amount exceeded",
     EKEYTYPE = "The key argument has to be of type `string` or `number`. Found: `__key`",
     EKEYSTYPE = "The keys argument has to be an array.",
-    ETTLTYPE = "The ttl argument has to be a number."
+    ETTLTYPE = "The ttl argument has to be a number or a string for shorthand ttl."
 }
 type NodeCacheStats = {
     /**
@@ -205,7 +209,7 @@ type NodeCacheStats = {
      */
     vsize: number;
 };
-declare class NodeCache extends eventemitter {
+declare class NodeCache extends Hookified {
     readonly options: NodeCacheOptions;
     readonly store: Map<string, any>;
     private _stats;
@@ -216,10 +220,10 @@ declare class NodeCache extends eventemitter {
      * Sets a key value pair. It is possible to define a ttl (in seconds). Returns true on success.
      * @param {string | number} key - it will convert the key to a string
      * @param {any} value
-     * @param {number} [ttl] - this is in seconds and undefined will use the default ttl
+     * @param {number | string} [ttl] - this is in seconds and undefined will use the default ttl
      * @returns {boolean}
      */
-    set(key: string | number, value: any, ttl?: number): boolean;
+    set(key: string | number, value: any, ttl?: number | string): boolean;
     /**
      * Sets multiple key val pairs. It is possible to define a ttl (seconds). Returns true on success.
      * @param {NodeCacheItem[]} data an array of key value pairs with optional ttl
@@ -262,10 +266,10 @@ declare class NodeCache extends eventemitter {
      * 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.
      * @param {string | number} key if the key is a number it will convert it to a string
-     * @param {number} [ttl] the ttl in seconds
+     * @param {number | string} [ttl] the ttl in seconds if number, or a shorthand string like '1h' for 1 hour
      * @returns {boolean} true if the key has been found and changed. Otherwise returns false.
      */
-    ttl(key: string | number, ttl?: number): boolean;
+    ttl(key: string | number, ttl?: number | string): boolean;
     /**
      * Receive the ttl of a key.
      * @param {string | number} key if the key is a number it will convert it to a string
@@ -317,4 +321,4 @@ declare class NodeCache extends eventemitter {
     private createError;
 }
 
-export { NodeCacheErrors, type NodeCacheItem, type NodeCacheOptions, type NodeCacheStats, NodeCacheStore, type NodeCacheStoreOptions, NodeCache as default };
+export { NodeCache, NodeCacheErrors, type NodeCacheItem, type NodeCacheOptions, type NodeCacheStats, NodeCacheStore, type NodeCacheStoreOptions, NodeCache as default };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import eventemitter from 'eventemitter3';
+import { Hookified } from 'hookified';
 import { Cacheable } from 'cacheable';
 import { Keyv } from 'keyv';
 
@@ -20,8 +20,12 @@ type NodeCacheStoreOptions = {
      * [storage-tiering-and-caching](https://github.com/jaredwray/cacheable/tree/main/packages/cacheable#storage-tiering-and-caching)
      */
     secondary?: Keyv;
+    /**
+     * Enable stats tracking. This is a breaking change from the original NodeCache.
+     */
+    stats?: boolean;
 };
-declare class NodeCacheStore {
+declare class NodeCacheStore extends Hookified {
     private _maxKeys;
     private readonly _cache;
     constructor(options?: NodeCacheStoreOptions);
@@ -142,9 +146,9 @@ declare class NodeCacheStore {
 
 type NodeCacheOptions = {
     /**
-     * The standard ttl as number in seconds for every generated cache element. 0 = unlimited
+     * The standard ttl as number in seconds for every generated cache element. 0 = unlimited, If string, it will be in shorthand format like '1h' for 1 hour
      */
-    stdTTL?: number;
+    stdTTL?: number | string;
     /**
      * The interval to check for expired items in seconds. Default is 600 = 5 minutes
      */
@@ -181,7 +185,7 @@ declare enum NodeCacheErrors {
     ECACHEFULL = "Cache max keys amount exceeded",
     EKEYTYPE = "The key argument has to be of type `string` or `number`. Found: `__key`",
     EKEYSTYPE = "The keys argument has to be an array.",
-    ETTLTYPE = "The ttl argument has to be a number."
+    ETTLTYPE = "The ttl argument has to be a number or a string for shorthand ttl."
 }
 type NodeCacheStats = {
     /**
@@ -205,7 +209,7 @@ type NodeCacheStats = {
      */
     vsize: number;
 };
-declare class NodeCache extends eventemitter {
+declare class NodeCache extends Hookified {
     readonly options: NodeCacheOptions;
     readonly store: Map<string, any>;
     private _stats;
@@ -216,10 +220,10 @@ declare class NodeCache extends eventemitter {
      * Sets a key value pair. It is possible to define a ttl (in seconds). Returns true on success.
      * @param {string | number} key - it will convert the key to a string
      * @param {any} value
-     * @param {number} [ttl] - this is in seconds and undefined will use the default ttl
+     * @param {number | string} [ttl] - this is in seconds and undefined will use the default ttl
      * @returns {boolean}
      */
-    set(key: string | number, value: any, ttl?: number): boolean;
+    set(key: string | number, value: any, ttl?: number | string): boolean;
     /**
      * Sets multiple key val pairs. It is possible to define a ttl (seconds). Returns true on success.
      * @param {NodeCacheItem[]} data an array of key value pairs with optional ttl
@@ -262,10 +266,10 @@ declare class NodeCache extends eventemitter {
      * 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.
      * @param {string | number} key if the key is a number it will convert it to a string
-     * @param {number} [ttl] the ttl in seconds
+     * @param {number | string} [ttl] the ttl in seconds if number, or a shorthand string like '1h' for 1 hour
      * @returns {boolean} true if the key has been found and changed. Otherwise returns false.
      */
-    ttl(key: string | number, ttl?: number): boolean;
+    ttl(key: string | number, ttl?: number | string): boolean;
     /**
      * Receive the ttl of a key.
      * @param {string | number} key if the key is a number it will convert it to a string
@@ -317,4 +321,4 @@ declare class NodeCache extends eventemitter {
     private createError;
 }
 
-export { NodeCacheErrors, type NodeCacheItem, type NodeCacheOptions, type NodeCacheStats, NodeCacheStore, type NodeCacheStoreOptions, NodeCache as default };
+export { NodeCache, NodeCacheErrors, type NodeCacheItem, type NodeCacheOptions, type NodeCacheStats, NodeCacheStore, type NodeCacheStoreOptions, NodeCache as default };

package/dist/index.js

@@ -1,28 +1,31 @@
 // src/index.ts
-import eventemitter from "eventemitter3";
-import { CacheableMemory as CacheableMemory2, CacheableStats } from "cacheable";
+import { CacheableMemory as CacheableMemory2, CacheableStats, shorthandToTime } from "cacheable";
+import { Hookified as Hookified2 } from "hookified";
 
 // src/store.ts
 import { Cacheable, CacheableMemory } from "cacheable";
 import { Keyv } from "keyv";
-var NodeCacheStore = class {
+import { Hookified } from "hookified";
+var NodeCacheStore = class extends Hookified {
   _maxKeys = 0;
   _cache = new Cacheable({ primary: new Keyv({ store: new CacheableMemory() }) });
   constructor(options) {
+    super();
     if (options) {
       const cacheOptions = {
         ttl: options.ttl,
         primary: options.primary,
-        secondary: options.secondary
+        secondary: options.secondary,
+        stats: options.stats ?? true
       };
       this._cache = new Cacheable(cacheOptions);
       if (options.maxKeys) {
         this._maxKeys = options.maxKeys;
-        if (this._maxKeys > 0) {
-          this._cache.stats.enabled = true;
-        }
       }
     }
+    this._cache.on("error", (error) => {
+      this.emit("error", error);
+    });
   }
   /**
    * Cacheable instance.
@@ -204,10 +207,10 @@ 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.";
+  NodeCacheErrors2["ETTLTYPE"] = "The ttl argument has to be a number or a string for shorthand ttl.";
   return NodeCacheErrors2;
 })(NodeCacheErrors || {});
-var NodeCache = class extends eventemitter {
+var NodeCache = class extends Hookified2 {
   options = {
     // eslint-disable-next-line @typescript-eslint/naming-convention
     stdTTL: 0,
@@ -231,21 +234,27 @@ var NodeCache = class extends eventemitter {
    * Sets a key value pair. It is possible to define a ttl (in seconds). Returns true on success.
    * @param {string | number} key - it will convert the key to a string
    * @param {any} value
-   * @param {number} [ttl] - this is in seconds and undefined will use the default ttl
+   * @param {number | string} [ttl] - this is in seconds and undefined will use the default ttl
    * @returns {boolean}
    */
   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);
     }
-    if (ttl && typeof ttl !== "number") {
-      throw this.createError("The ttl argument has to be a number." /* ETTLTYPE */, this.formatKey(key));
+    if (ttl && typeof ttl !== "number" && typeof ttl !== "string") {
+      throw this.createError("The ttl argument has to be a number or a string for shorthand ttl." /* ETTLTYPE */, this.formatKey(key));
     }
     const keyValue = this.formatKey(key);
-    const ttlValue = ttl ?? this.options.stdTTL;
+    let ttlValue = 0;
+    if (this.options.stdTTL) {
+      ttlValue = this.getExpirationTimestamp(this.options.stdTTL);
+    }
+    if (ttl) {
+      ttlValue = this.getExpirationTimestamp(ttl);
+    }
     let expirationTimestamp = 0;
     if (ttlValue && ttlValue > 0) {
-      expirationTimestamp = this.getExpirationTimestamp(ttlValue);
+      expirationTimestamp = ttlValue;
     }
     if (this.options.maxKeys) {
       const maxKeys = this.options.maxKeys;
@@ -376,7 +385,7 @@ var NodeCache = class extends eventemitter {
    * 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.
    * @param {string | number} key if the key is a number it will convert it to a string
-   * @param {number} [ttl] the ttl in seconds
+   * @param {number | string} [ttl] the ttl in seconds if number, or a shorthand string like '1h' for 1 hour
    * @returns {boolean} true if the key has been found and changed. Otherwise returns false.
    */
   ttl(key, ttl) {
@@ -473,6 +482,9 @@ var NodeCache = class extends eventemitter {
     return key.toString();
   }
   getExpirationTimestamp(ttlInSeconds) {
+    if (typeof ttlInSeconds === "string") {
+      return shorthandToTime(ttlInSeconds);
+    }
     const currentTimestamp = Date.now();
     const ttlInMilliseconds = ttlInSeconds * 1e3;
     const expirationTimestamp = currentTimestamp + ttlInMilliseconds;
@@ -509,8 +521,10 @@ var NodeCache = class extends eventemitter {
     return new Error(error);
   }
 };
+var src_default = NodeCache;
 export {
+  NodeCache,
   NodeCacheErrors,
   NodeCacheStore,
-  NodeCache as default
+  src_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cacheable/node-cache",
-  "version": "1.4.2",
+  "version": "1.5.1",
   "description": "Simple and Maintained fast NodeJS internal caching",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -41,7 +41,7 @@
   },
   "dependencies": {
     "cacheable": "^1.8.1",
-    "eventemitter3": "^5.0.1",
+    "hookified": "^1.5.1",
     "keyv": "^5.2.1"
   },
   "files": [