cacheable 1.8.6 → 1.8.8

package/dist/index.cjs

@@ -28,8 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   Cacheable: () => Cacheable,
   CacheableEvents: () => CacheableEvents,
   CacheableHooks: () => CacheableHooks,
@@ -44,7 +44,7 @@ __export(src_exports, {
   wrap: () => wrap,
   wrapSync: () => wrapSync
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 var import_keyv2 = require("keyv");
 var import_hookified2 = require("hookified");
 
@@ -215,7 +215,9 @@ function wrap(function_, options) {
     const cacheKey = createWrapKey(function_, arguments_, keyPrefix);
     value = await cache.get(cacheKey);
     if (value === void 0) {
-      value = await coalesceAsync(cacheKey, async () => {
+      const cacheId = options.cacheId ?? "default";
+      const coalesceKey = `${cacheId}::${cacheKey}`;
+      value = await coalesceAsync(coalesceKey, async () => {
         try {
           const result = await function_(...arguments_);
           await cache.set(cacheKey, result, ttl);
@@ -1169,6 +1171,7 @@ var Cacheable = class extends import_hookified2.Hookified {
   _ttl;
   _stats = new CacheableStats({ enabled: false });
   _namespace;
+  _cacheId = Math.random().toString(36).slice(2);
   /**
    * Creates a new cacheable instance
    * @param {CacheableOptions} [options] The options for the cacheable instance
@@ -1190,6 +1193,9 @@ var Cacheable = class extends import_hookified2.Hookified {
     if (options?.ttl) {
       this.setTtl(options.ttl);
     }
+    if (options?.cacheId) {
+      this._cacheId = options.cacheId;
+    }
     if (options?.namespace) {
       this._namespace = options.namespace;
       this._primary.namespace = this.getNameSpace();
@@ -1316,6 +1322,22 @@ var Cacheable = class extends import_hookified2.Hookified {
   set ttl(ttl) {
     this.setTtl(ttl);
   }
+  /**
+   * The cacheId for the cacheable instance. This is primarily used for the wrap function to not have conflicts.
+   * If it is not set then it will be a random string that is generated
+   * @returns {string} The cacheId for the cacheable instance
+   */
+  get cacheId() {
+    return this._cacheId;
+  }
+  /**
+   * Sets the cacheId for the cacheable instance. This is primarily used for the wrap function to not have conflicts.
+   * If it is not set then it will be a random string that is generated
+   * @param {string} cacheId The cacheId for the cacheable instance
+   */
+  set cacheId(cacheId) {
+    this._cacheId = cacheId;
+  }
   /**
    * Sets the primary store for the cacheable instance
    * @param {Keyv | KeyvStoreAdapter} primary The primary store for the cacheable instance
@@ -1355,9 +1377,10 @@ var Cacheable = class extends import_hookified2.Hookified {
       await this.hook("BEFORE_GET" /* BEFORE_GET */, key);
       result = await this._primary.get(key);
       if (!result && this._secondary) {
-        result = await this._secondary.get(key);
-        if (result) {
-          const finalTtl = shorthandToMilliseconds(this._ttl);
+        const rawResult = await this._secondary.get(key, { raw: true });
+        if (rawResult) {
+          result = rawResult.value;
+          const finalTtl = rawResult.expires ?? void 0;
           await this._primary.set(key, result, finalTtl);
         }
       }
@@ -1640,7 +1663,8 @@ var Cacheable = class extends import_hookified2.Hookified {
     const wrapOptions = {
       ttl: options?.ttl ?? this._ttl,
       keyPrefix: options?.keyPrefix,
-      cache: this
+      cache: this,
+      cacheId: this._cacheId
     };
     return wrap(function_, wrapOptions);
   }

package/dist/index.d.cts

@@ -113,6 +113,7 @@ type WrapFunctionOptions = {
     ttl?: number | string;
     keyPrefix?: string;
     cacheErrors?: boolean;
+    cacheId?: string;
 };
 type WrapOptions = WrapFunctionOptions & {
     cache: Cacheable;
@@ -371,7 +372,7 @@ declare class CacheableMemory extends Hookified {
      * @param {Object} [options] - The options to wrap
      * @returns {Function} - The wrapped function
      */
-    wrap<T>(function_: (...arguments_: any[]) => T, options?: WrapFunctionOptions): (...arguments_: any[]) => T;
+    wrap<T, Arguments extends any[]>(function_: (...arguments_: Arguments) => T, options?: WrapFunctionOptions): (...arguments_: Arguments) => T;
     private isPrimitive;
     private concatStores;
     private setTtl;
@@ -428,12 +429,38 @@ declare enum CacheableEvents {
     ERROR = "error"
 }
 type CacheableOptions = {
+    /**
+     * The primary store for the cacheable instance
+     */
     primary?: Keyv | KeyvStoreAdapter;
+    /**
+     * The secondary store for the cacheable instance
+     */
     secondary?: Keyv | KeyvStoreAdapter;
+    /**
+     * Whether to enable statistics for the cacheable instance
+     */
     stats?: boolean;
+    /**
+     * Whether the secondary store is non-blocking mode. It is set to false by default.
+     * If it is set to true then the secondary store will not block the primary store.
+     */
     nonBlocking?: boolean;
+    /**
+     * The time-to-live for the cacheable instance and will be used as the default value.
+     * can be a number in milliseconds or a human-readable format such as `1s` for 1 second or `1h` for 1 hour
+     * or undefined if there is no time-to-live.
+     */
     ttl?: number | string;
+    /**
+     * The namespace for the cacheable instance. It can be a string or a function that returns a string.
+     */
     namespace?: string | (() => string);
+    /**
+     * The cacheId for the cacheable instance. This is primarily used for the wrap function to not have conflicts.
+     * If it is not set then it will be a random string that is generated
+     */
+    cacheId?: string;
 };
 declare class Cacheable extends Hookified {
     private _primary;
@@ -442,6 +469,7 @@ declare class Cacheable extends Hookified {
     private _ttl?;
     private readonly _stats;
     private _namespace?;
+    private _cacheId;
     /**
      * Creates a new cacheable instance
      * @param {CacheableOptions} [options] The options for the cacheable instance
@@ -539,6 +567,18 @@ declare class Cacheable extends Hookified {
      * ```
      */
     set ttl(ttl: number | string | undefined);
+    /**
+     * The cacheId for the cacheable instance. This is primarily used for the wrap function to not have conflicts.
+     * If it is not set then it will be a random string that is generated
+     * @returns {string} The cacheId for the cacheable instance
+     */
+    get cacheId(): string;
+    /**
+     * Sets the cacheId for the cacheable instance. This is primarily used for the wrap function to not have conflicts.
+     * If it is not set then it will be a random string that is generated
+     * @param {string} cacheId The cacheId for the cacheable instance
+     */
+    set cacheId(cacheId: string);
     /**
      * Sets the primary store for the cacheable instance
      * @param {Keyv | KeyvStoreAdapter} primary The primary store for the cacheable instance
@@ -633,7 +673,7 @@ declare class Cacheable extends Hookified {
      * @param {WrapOptions} [options] The options for the wrap function
      * @returns {Function} The wrapped function
      */
-    wrap<T>(function_: (...arguments_: any[]) => T, options?: WrapFunctionOptions): (...arguments_: any[]) => T;
+    wrap<T, Arguments extends any[]>(function_: (...arguments_: Arguments) => T, options?: WrapFunctionOptions): (...arguments_: Arguments) => T;
     /**
      * Will hash an object using the specified algorithm. The default algorithm is 'sha256'.
      * @param {any} object the object to hash

package/dist/index.d.ts

@@ -113,6 +113,7 @@ type WrapFunctionOptions = {
     ttl?: number | string;
     keyPrefix?: string;
     cacheErrors?: boolean;
+    cacheId?: string;
 };
 type WrapOptions = WrapFunctionOptions & {
     cache: Cacheable;
@@ -371,7 +372,7 @@ declare class CacheableMemory extends Hookified {
      * @param {Object} [options] - The options to wrap
      * @returns {Function} - The wrapped function
      */
-    wrap<T>(function_: (...arguments_: any[]) => T, options?: WrapFunctionOptions): (...arguments_: any[]) => T;
+    wrap<T, Arguments extends any[]>(function_: (...arguments_: Arguments) => T, options?: WrapFunctionOptions): (...arguments_: Arguments) => T;
     private isPrimitive;
     private concatStores;
     private setTtl;
@@ -428,12 +429,38 @@ declare enum CacheableEvents {
     ERROR = "error"
 }
 type CacheableOptions = {
+    /**
+     * The primary store for the cacheable instance
+     */
     primary?: Keyv | KeyvStoreAdapter;
+    /**
+     * The secondary store for the cacheable instance
+     */
     secondary?: Keyv | KeyvStoreAdapter;
+    /**
+     * Whether to enable statistics for the cacheable instance
+     */
     stats?: boolean;
+    /**
+     * Whether the secondary store is non-blocking mode. It is set to false by default.
+     * If it is set to true then the secondary store will not block the primary store.
+     */
     nonBlocking?: boolean;
+    /**
+     * The time-to-live for the cacheable instance and will be used as the default value.
+     * can be a number in milliseconds or a human-readable format such as `1s` for 1 second or `1h` for 1 hour
+     * or undefined if there is no time-to-live.
+     */
     ttl?: number | string;
+    /**
+     * The namespace for the cacheable instance. It can be a string or a function that returns a string.
+     */
     namespace?: string | (() => string);
+    /**
+     * The cacheId for the cacheable instance. This is primarily used for the wrap function to not have conflicts.
+     * If it is not set then it will be a random string that is generated
+     */
+    cacheId?: string;
 };
 declare class Cacheable extends Hookified {
     private _primary;
@@ -442,6 +469,7 @@ declare class Cacheable extends Hookified {
     private _ttl?;
     private readonly _stats;
     private _namespace?;
+    private _cacheId;
     /**
      * Creates a new cacheable instance
      * @param {CacheableOptions} [options] The options for the cacheable instance
@@ -539,6 +567,18 @@ declare class Cacheable extends Hookified {
      * ```
      */
     set ttl(ttl: number | string | undefined);
+    /**
+     * The cacheId for the cacheable instance. This is primarily used for the wrap function to not have conflicts.
+     * If it is not set then it will be a random string that is generated
+     * @returns {string} The cacheId for the cacheable instance
+     */
+    get cacheId(): string;
+    /**
+     * Sets the cacheId for the cacheable instance. This is primarily used for the wrap function to not have conflicts.
+     * If it is not set then it will be a random string that is generated
+     * @param {string} cacheId The cacheId for the cacheable instance
+     */
+    set cacheId(cacheId: string);
     /**
      * Sets the primary store for the cacheable instance
      * @param {Keyv | KeyvStoreAdapter} primary The primary store for the cacheable instance
@@ -633,7 +673,7 @@ declare class Cacheable extends Hookified {
      * @param {WrapOptions} [options] The options for the wrap function
      * @returns {Function} The wrapped function
      */
-    wrap<T>(function_: (...arguments_: any[]) => T, options?: WrapFunctionOptions): (...arguments_: any[]) => T;
+    wrap<T, Arguments extends any[]>(function_: (...arguments_: Arguments) => T, options?: WrapFunctionOptions): (...arguments_: Arguments) => T;
     /**
      * Will hash an object using the specified algorithm. The default algorithm is 'sha256'.
      * @param {any} object the object to hash

package/dist/index.js

@@ -171,7 +171,9 @@ function wrap(function_, options) {
     const cacheKey = createWrapKey(function_, arguments_, keyPrefix);
     value = await cache.get(cacheKey);
     if (value === void 0) {
-      value = await coalesceAsync(cacheKey, async () => {
+      const cacheId = options.cacheId ?? "default";
+      const coalesceKey = `${cacheId}::${cacheKey}`;
+      value = await coalesceAsync(coalesceKey, async () => {
         try {
           const result = await function_(...arguments_);
           await cache.set(cacheKey, result, ttl);
@@ -1128,6 +1130,7 @@ var Cacheable = class extends Hookified2 {
   _ttl;
   _stats = new CacheableStats({ enabled: false });
   _namespace;
+  _cacheId = Math.random().toString(36).slice(2);
   /**
    * Creates a new cacheable instance
    * @param {CacheableOptions} [options] The options for the cacheable instance
@@ -1149,6 +1152,9 @@ var Cacheable = class extends Hookified2 {
     if (options?.ttl) {
       this.setTtl(options.ttl);
     }
+    if (options?.cacheId) {
+      this._cacheId = options.cacheId;
+    }
     if (options?.namespace) {
       this._namespace = options.namespace;
       this._primary.namespace = this.getNameSpace();
@@ -1275,6 +1281,22 @@ var Cacheable = class extends Hookified2 {
   set ttl(ttl) {
     this.setTtl(ttl);
   }
+  /**
+   * The cacheId for the cacheable instance. This is primarily used for the wrap function to not have conflicts.
+   * If it is not set then it will be a random string that is generated
+   * @returns {string} The cacheId for the cacheable instance
+   */
+  get cacheId() {
+    return this._cacheId;
+  }
+  /**
+   * Sets the cacheId for the cacheable instance. This is primarily used for the wrap function to not have conflicts.
+   * If it is not set then it will be a random string that is generated
+   * @param {string} cacheId The cacheId for the cacheable instance
+   */
+  set cacheId(cacheId) {
+    this._cacheId = cacheId;
+  }
   /**
    * Sets the primary store for the cacheable instance
    * @param {Keyv | KeyvStoreAdapter} primary The primary store for the cacheable instance
@@ -1314,9 +1336,10 @@ var Cacheable = class extends Hookified2 {
       await this.hook("BEFORE_GET" /* BEFORE_GET */, key);
       result = await this._primary.get(key);
       if (!result && this._secondary) {
-        result = await this._secondary.get(key);
-        if (result) {
-          const finalTtl = shorthandToMilliseconds(this._ttl);
+        const rawResult = await this._secondary.get(key, { raw: true });
+        if (rawResult) {
+          result = rawResult.value;
+          const finalTtl = rawResult.expires ?? void 0;
           await this._primary.set(key, result, finalTtl);
         }
       }
@@ -1599,7 +1622,8 @@ var Cacheable = class extends Hookified2 {
     const wrapOptions = {
       ttl: options?.ttl ?? this._ttl,
       keyPrefix: options?.keyPrefix,
-      cache: this
+      cache: this,
+      cacheId: this._cacheId
     };
     return wrap(function_, wrapOptions);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cacheable",
-  "version": "1.8.6",
+  "version": "1.8.8",
   "description": "High Performance Layer 1 / Layer 2 Caching with Keyv Storage",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -21,19 +21,19 @@
   "license": "MIT",
   "private": false,
   "devDependencies": {
-    "@keyv/redis": "^4.0.2",
-    "@types/node": "^22.10.2",
-    "@vitest/coverage-v8": "^2.1.8",
+    "@keyv/redis": "^4.2.0",
+    "@types/node": "^22.10.9",
+    "@vitest/coverage-v8": "^3.0.4",
     "lru-cache": "^11.0.2",
     "rimraf": "^6.0.1",
     "tsup": "^8.3.5",
-    "typescript": "^5.7.2",
-    "vitest": "^2.1.8",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.4",
     "xo": "^0.60.0"
   },
   "dependencies": {
-    "hookified": "^1.5.1",
-    "keyv": "^5.2.1"
+    "hookified": "^1.7.0",
+    "keyv": "^5.2.3"
   },
   "keywords": [
     "cacheable",