cacheable 1.8.1 → 1.8.2

package/README.md

@@ -192,6 +192,7 @@ The following options are available for you to configure `cacheable`:
 * `nonBlocking`: If the secondary store is non-blocking. Default is `false`.
 * `stats`: To enable statistics for this instance. Default is `false`.
 * `ttl`: The default time to live for the cache in milliseconds. Default is `undefined` which is disabled.
+* `namespace`: The namespace for the cache. Default is `undefined`.
 
 # Cacheable Statistics (Instance Only)
 
@@ -233,6 +234,7 @@ _This does not enable statistics for your layer 2 cache as that is a distributed
 * `hash(object: any, algorithm = 'sha256'): string`: Hashes an object with the algorithm. Default is `sha256`.
 * `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.
+* `namespace`: The namespace for the cache. Default is `undefined`. This will set the namespace for the primary and secondary stores.
 * `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`.
 
@@ -296,11 +298,15 @@ By default we use lazy expiration deletion which means on `get` and `getMany` ty
 ```javascript
 import { Cacheable } from 'cacheable';
 const asyncFunction = async (value: number) => {
-  return value * 2;
+  return Math.random() * value;
 };
 
 const cache = new Cacheable();
-const wrappedFunction = cache.wrap(asyncFunction, { ttl: '1h' });
+const options = {
+  ttl: '1h', // 1 hour
+  keyPrefix: 'p1', // key prefix. This is used if you have multiple functions and need to set a unique prefix.
+}
+const wrappedFunction = cache.wrap(asyncFunction, options);
 console.log(await wrappedFunction(2)); // 4
 console.log(await wrappedFunction(2)); // 4 from cache
 ```

package/dist/index.cjs

@@ -114,11 +114,23 @@ var shorthandToTime = (shorthand, fromDate) => {
   return fromDate.getTime() + milliseconds;
 };
 
+// src/hash.ts
+var crypto = __toESM(require("crypto"), 1);
+function hash(object, algorithm = "sha256") {
+  const objectString = JSON.stringify(object);
+  if (!crypto.getHashes().includes(algorithm)) {
+    throw new Error(`Unsupported hash algorithm: '${algorithm}'`);
+  }
+  const hasher = crypto.createHash(algorithm);
+  hasher.update(objectString);
+  return hasher.digest("hex");
+}
+
 // src/wrap.ts
 function wrapSync(function_, options) {
-  const { ttl, key, cache } = options;
+  const { ttl, keyPrefix, cache } = options;
   return function(...arguments_) {
-    const cacheKey = key ?? cache.hash(arguments_);
+    const cacheKey = createWrapKey(function_, arguments_, keyPrefix);
     let value = cache.get(cacheKey);
     if (value === void 0) {
       value = function_(...arguments_);
@@ -128,9 +140,9 @@ function wrapSync(function_, options) {
   };
 }
 function wrap(function_, options) {
-  const { ttl, key, cache } = options;
+  const { ttl, keyPrefix, cache } = options;
   return async function(...arguments_) {
-    const cacheKey = key ?? cache.hash(arguments_);
+    const cacheKey = createWrapKey(function_, arguments_, keyPrefix);
     let value = await cache.get(cacheKey);
     if (value === void 0) {
       value = await function_(...arguments_);
@@ -139,6 +151,12 @@ function wrap(function_, options) {
     return value;
   };
 }
+function createWrapKey(function_, arguments_, keyPrefix) {
+  if (!keyPrefix) {
+    return `${function_.name}::${hash(arguments_)}`;
+  }
+  return `${keyPrefix}::${function_.name}::${hash(arguments_)}`;
+}
 
 // src/memory-lru.ts
 var ListNode = class {
@@ -213,20 +231,9 @@ var DoublyLinkedList = class {
   }
 };
 
-// src/hash.ts
-var crypto = __toESM(require("crypto"), 1);
-function hash(object, algorithm = "sha256") {
-  const objectString = JSON.stringify(object);
-  if (!crypto.getHashes().includes(algorithm)) {
-    throw new Error(`Unsupported hash algorithm: '${algorithm}'`);
-  }
-  const hasher = crypto.createHash(algorithm);
-  hasher.update(objectString);
-  return hasher.digest("hex");
-}
-
 // src/memory.ts
 var CacheableMemory = class {
+  _lru = new DoublyLinkedList();
   _hashCache = /* @__PURE__ */ new Map();
   _hash0 = /* @__PURE__ */ new Map();
   _hash1 = /* @__PURE__ */ new Map();
@@ -238,7 +245,6 @@ var CacheableMemory = class {
   _hash7 = /* @__PURE__ */ new Map();
   _hash8 = /* @__PURE__ */ new Map();
   _hash9 = /* @__PURE__ */ new Map();
-  _lru = new DoublyLinkedList();
   _ttl;
   // Turned off by default
   _useClone = true;
@@ -440,12 +446,11 @@ var CacheableMemory = class {
         }
       }
     }
-    store.set(key, {
+    const item = { key, value, expires };
+    store.set(
       key,
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      value,
-      expires
-    });
+      item
+    );
   }
   /**
    * Sets the values of the keys
@@ -539,34 +544,24 @@ var CacheableMemory = class {
     this._hash8.clear();
     this._hash9.clear();
     this._hashCache.clear();
-  }
-  /**
-   * Hash the key. this is used to determine which store to use (internal use)
-   * @param {string} key - The key to hash
-   * @returns {number} - The hash number
-   */
-  hashKey(key) {
-    const cacheHashNumber = this._hashCache.get(key);
-    if (cacheHashNumber) {
-      return cacheHashNumber;
-    }
-    let hash2 = 0;
-    const primeMultiplier = 31;
-    for (let i = 0; i < key.length; i++) {
-      hash2 = hash2 * primeMultiplier + key.charCodeAt(i);
-    }
-    const result = Math.abs(hash2) % 10;
-    this._hashCache.set(key, result);
-    return result;
+    this._lru = new DoublyLinkedList();
   }
   /**
    * Get the store based on the key (internal use)
    * @param {string} key - The key to get the store
-   * @returns {Map<string, any>} - The store
+   * @returns {CacheableHashStore} - The store
    */
   getStore(key) {
-    const hashKey = this.hashKey(key);
-    switch (hashKey) {
+    const hash2 = this.hashKey(key);
+    return this.getStoreFromHash(hash2);
+  }
+  /**
+   * Get the store based on the hash (internal use)
+   * @param {number} hash
+   * @returns {Map<string, CacheableStoreItem>}
+   */
+  getStoreFromHash(hash2) {
+    switch (hash2) {
       case 1: {
         return this._hash1;
       }
@@ -599,6 +594,25 @@ var CacheableMemory = class {
       }
     }
   }
+  /**
+   * Hash the key (internal use)
+   * @param key
+   * @returns {number} from 0 to 9
+   */
+  hashKey(key) {
+    const cacheHashNumber = this._hashCache.get(key);
+    if (cacheHashNumber) {
+      return cacheHashNumber;
+    }
+    let hash2 = 0;
+    const primeMultiplier = 31;
+    for (let i = 0; i < key.length; i++) {
+      hash2 = hash2 * primeMultiplier + key.charCodeAt(i);
+    }
+    const result = Math.abs(hash2) % 10;
+    this._hashCache.set(key, result);
+    return result;
+  }
   /**
    * Clone the value. This is for internal use
    * @param {any} value - The value to clone
@@ -697,10 +711,10 @@ var CacheableMemory = class {
    * @param {Object} [options] - The options to wrap
    * @returns {Function} - The wrapped function
    */
-  wrap(function_, options = {}) {
+  wrap(function_, options) {
     const wrapOptions = {
       ttl: options.ttl,
-      key: options.key,
+      keyPrefix: options.keyPrefix,
       cache: this
     };
     return wrapSync(function_, wrapOptions);
@@ -716,8 +730,7 @@ var CacheableMemory = class {
     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;
+    return new Map([...this._hash0, ...this._hash1, ...this._hash2, ...this._hash3, ...this._hash4, ...this._hash5, ...this._hash6, ...this._hash7, ...this._hash8, ...this._hash9]);
   }
   setTtl(ttl) {
     if (typeof ttl === "string" || ttl === void 0) {
@@ -738,48 +751,71 @@ var KeyvCacheableMemory = class {
     lruSize: 0,
     checkInterval: 0
   };
-  namespace;
-  _cache = new CacheableMemory();
+  _defaultCache = new CacheableMemory();
+  _nCache = /* @__PURE__ */ new Map();
+  _namespace;
   constructor(options) {
     if (options) {
       this.opts = options;
-      this._cache = new CacheableMemory(options);
+      this._defaultCache = new CacheableMemory(options);
+      if (options.namespace) {
+        this._namespace = options.namespace;
+        this._nCache.set(this._namespace, new CacheableMemory(options));
+      }
     }
   }
+  get namespace() {
+    return this._namespace;
+  }
+  set namespace(value) {
+    this._namespace = value;
+  }
+  get store() {
+    return this.getStore(this._namespace);
+  }
   async get(key) {
-    const result = this._cache.get(key);
+    const result = this.getStore(this._namespace).get(key);
     if (result) {
       return result;
     }
     return void 0;
   }
   async getMany(keys) {
-    const result = this._cache.getMany(keys);
+    const result = this.getStore(this._namespace).getMany(keys);
     return result;
   }
   async set(key, value, ttl) {
-    this._cache.set(key, value, ttl);
+    this.getStore(this._namespace).set(key, value, ttl);
   }
   async setMany(values) {
-    this._cache.setMany(values);
+    this.getStore(this._namespace).setMany(values);
   }
   async delete(key) {
-    this._cache.delete(key);
+    this.getStore(this._namespace).delete(key);
     return true;
   }
   async deleteMany(key) {
-    this._cache.deleteMany(key);
+    this.getStore(this._namespace).deleteMany(key);
     return true;
   }
   async clear() {
-    this._cache.clear();
+    this.getStore(this._namespace).clear();
   }
   async has(key) {
-    return this._cache.has(key);
+    return this.getStore(this._namespace).has(key);
   }
   on(event, listener) {
     return this;
   }
+  getStore(namespace) {
+    if (!namespace) {
+      return this._defaultCache;
+    }
+    if (!this._nCache.has(namespace)) {
+      this._nCache.set(namespace, new CacheableMemory(this.opts));
+    }
+    return this._nCache.get(namespace);
+  }
 };
 
 // src/stats.ts
@@ -1022,6 +1058,7 @@ var Cacheable = class extends import_hookified.Hookified {
   _nonBlocking = false;
   _ttl;
   _stats = new CacheableStats({ enabled: false });
+  _namespace;
   /**
    * Creates a new cacheable instance
    * @param {CacheableOptions} [options] The options for the cacheable instance
@@ -1043,6 +1080,32 @@ var Cacheable = class extends import_hookified.Hookified {
     if (options?.ttl) {
       this.setTtl(options.ttl);
     }
+    if (options?.namespace) {
+      this._namespace = options.namespace;
+      this._primary.namespace = this.getNameSpace();
+      if (this._secondary) {
+        this._secondary.namespace = this.getNameSpace();
+      }
+    }
+  }
+  /**
+   * The namespace for the cacheable instance
+   * @returns {string | (() => string) | undefined} The namespace for the cacheable instance
+   */
+  get namespace() {
+    return this._namespace;
+  }
+  /**
+   * Sets the namespace for the cacheable instance
+   * @param {string | (() => string) | undefined} namespace The namespace for the cacheable instance
+   * @returns {void}
+   */
+  set namespace(namespace) {
+    this._namespace = namespace;
+    this._primary.namespace = this.getNameSpace();
+    if (this._secondary) {
+      this._secondary.namespace = this.getNameSpace();
+    }
   }
   /**
    * The statistics for the cacheable instance
@@ -1159,6 +1222,12 @@ var Cacheable = class extends import_hookified.Hookified {
   setSecondary(secondary) {
     this._secondary = secondary instanceof import_keyv.Keyv ? secondary : new import_keyv.Keyv(secondary);
   }
+  getNameSpace() {
+    if (typeof this._namespace === "function") {
+      return this._namespace();
+    }
+    return this._namespace;
+  }
   /**
    * Gets the value of the key. If the key does not exist in the primary store then it will check the secondary store.
    * @param {string} key The key to get the value of
@@ -1236,9 +1305,8 @@ var Cacheable = class extends import_hookified.Hookified {
    * Sets the value of the key. If the secondary store is set then it will also set the value in the secondary store.
    * @param {string} key the key to set the value of
    * @param {T} value The value to set
-   * @param {number | string} [ttl] Time to Live - If you set a number it is miliseconds, if you set a string it is a human-readable
-   * format such as `1s` for 1 second or `1h` for 1 hour. Setting undefined means that it will use the default time-to-live. If both are
-   * undefined then it will not have a time-to-live.
+   * @param {number | string} [ttl] set a number it is miliseconds, set a string it is a human-readable
+   * format such as `1s` for 1 second or `1h` for 1 hour. Setting undefined means that it will use the default time-to-live.
    * @returns {boolean} Whether the value was set
    */
   async set(key, value, ttl) {
@@ -1452,10 +1520,10 @@ var Cacheable = class extends import_hookified.Hookified {
    * @param {WrapOptions} [options] The options for the wrap function
    * @returns {Function} The wrapped function
    */
-  wrap(function_, options = {}) {
+  wrap(function_, options) {
     const wrapOptions = {
       ttl: options.ttl,
-      key: options.key,
+      keyPrefix: options.keyPrefix,
       cache: this
     };
     return wrap(function_, wrapOptions);

package/dist/index.d.cts

@@ -109,6 +109,24 @@ type CacheableStoreItem = {
     expires?: number;
 };
 
+type WrapOptions = {
+    ttl?: number | string;
+    keyPrefix?: string;
+    cache: Cacheable;
+};
+type WrapSyncOptions = {
+    ttl?: number | string;
+    keyPrefix?: string;
+    cache: CacheableMemory;
+};
+type WrapFunctionOptions = {
+    ttl?: number | string;
+    keyPrefix: string;
+};
+type AnyFunction = (...arguments_: any[]) => any;
+declare function wrapSync<T>(function_: AnyFunction, options: WrapSyncOptions): AnyFunction;
+declare function wrap<T>(function_: AnyFunction, options: WrapOptions): AnyFunction;
+
 /**
  * @typedef {Object} CacheableMemoryOptions
  * @property {number|string} [ttl] - Time to Live - If you set a number it is miliseconds, if you set a string it is a human-readable
@@ -125,6 +143,7 @@ type CacheableMemoryOptions = {
     checkInterval?: number;
 };
 declare class CacheableMemory {
+    private _lru;
     private readonly _hashCache;
     private readonly _hash0;
     private readonly _hash1;
@@ -136,7 +155,6 @@ declare class CacheableMemory {
     private readonly _hash7;
     private readonly _hash8;
     private readonly _hash9;
-    private readonly _lru;
     private _ttl;
     private _useClone;
     private _lruSize;
@@ -282,18 +300,24 @@ declare class CacheableMemory {
      * @returns {void}
      */
     clear(): void;
-    /**
-     * Hash the key. this is used to determine which store to use (internal use)
-     * @param {string} key - The key to hash
-     * @returns {number} - The hash number
-     */
-    hashKey(key: string): number;
     /**
      * Get the store based on the key (internal use)
      * @param {string} key - The key to get the store
-     * @returns {Map<string, any>} - The store
+     * @returns {CacheableHashStore} - The store
      */
-    getStore(key: string): Map<string, any>;
+    getStore(key: string): Map<string, CacheableStoreItem>;
+    /**
+     * Get the store based on the hash (internal use)
+     * @param {number} hash
+     * @returns {Map<string, CacheableStoreItem>}
+     */
+    getStoreFromHash(hash: number): Map<string, CacheableStoreItem>;
+    /**
+     * Hash the key (internal use)
+     * @param key
+     * @returns {number} from 0 to 9
+     */
+    hashKey(key: string): number;
     /**
      * Clone the value. This is for internal use
      * @param {any} value - The value to clone
@@ -345,20 +369,24 @@ declare class CacheableMemory {
      * @param {Object} [options] - The options to wrap
      * @returns {Function} - The wrapped function
      */
-    wrap<T>(function_: (...arguments_: any[]) => T, options?: {
-        ttl?: number;
-        key?: string;
-    }): (...arguments_: any[]) => T;
+    wrap<T>(function_: (...arguments_: any[]) => T, options: WrapFunctionOptions): (...arguments_: any[]) => T;
     private isPrimitive;
     private concatStores;
     private setTtl;
 }
 
+type KeyvCacheableMemoryOptions = CacheableMemoryOptions & {
+    namespace?: string;
+};
 declare class KeyvCacheableMemory implements KeyvStoreAdapter {
     opts: CacheableMemoryOptions;
-    namespace?: string | undefined;
-    private readonly _cache;
-    constructor(options?: CacheableMemoryOptions);
+    private readonly _defaultCache;
+    private readonly _nCache;
+    private _namespace?;
+    constructor(options?: KeyvCacheableMemoryOptions);
+    get namespace(): string | undefined;
+    set namespace(value: string | undefined);
+    get store(): CacheableMemory;
     get<Value>(key: string): Promise<StoredData<Value> | undefined>;
     getMany<Value>(keys: string[]): Promise<Array<StoredData<Value | undefined>>>;
     set(key: string, value: any, ttl?: number): Promise<void>;
@@ -372,25 +400,12 @@ declare class KeyvCacheableMemory implements KeyvStoreAdapter {
     clear(): Promise<void>;
     has?(key: string): Promise<boolean>;
     on(event: string, listener: (...arguments_: any[]) => void): this;
+    getStore(namespace?: string): CacheableMemory;
 }
 
 declare const shorthandToMilliseconds: (shorthand?: string | number) => number | undefined;
 declare const shorthandToTime: (shorthand?: string | number, fromDate?: Date) => number;
 
-type WrapOptions = {
-    ttl?: number | string;
-    key?: string;
-    cache: Cacheable;
-};
-type WrapSyncOptions = {
-    ttl?: number | string;
-    key?: string;
-    cache: CacheableMemory;
-};
-type AnyFunction = (...arguments_: any[]) => any;
-declare function wrapSync<T>(function_: AnyFunction, options: WrapSyncOptions): AnyFunction;
-declare function wrap<T>(function_: AnyFunction, options: WrapOptions): AnyFunction;
-
 declare enum CacheableHooks {
     BEFORE_SET = "BEFORE_SET",
     AFTER_SET = "AFTER_SET",
@@ -410,6 +425,7 @@ type CacheableOptions = {
     stats?: boolean;
     nonBlocking?: boolean;
     ttl?: number | string;
+    namespace?: string | (() => string);
 };
 declare class Cacheable extends Hookified {
     private _primary;
@@ -417,11 +433,23 @@ declare class Cacheable extends Hookified {
     private _nonBlocking;
     private _ttl?;
     private readonly _stats;
+    private _namespace?;
     /**
      * Creates a new cacheable instance
      * @param {CacheableOptions} [options] The options for the cacheable instance
      */
     constructor(options?: CacheableOptions);
+    /**
+     * The namespace for the cacheable instance
+     * @returns {string | (() => string) | undefined} The namespace for the cacheable instance
+     */
+    get namespace(): string | (() => string) | undefined;
+    /**
+     * Sets the namespace for the cacheable instance
+     * @param {string | (() => string) | undefined} namespace The namespace for the cacheable instance
+     * @returns {void}
+     */
+    set namespace(namespace: string | (() => string) | undefined);
     /**
      * The statistics for the cacheable instance
      * @returns {CacheableStats} The statistics for the cacheable instance
@@ -515,6 +543,7 @@ declare class Cacheable extends Hookified {
      * @returns {void}
      */
     setSecondary(secondary: Keyv | KeyvStoreAdapter): void;
+    getNameSpace(): string | undefined;
     /**
      * Gets the value of the key. If the key does not exist in the primary store then it will check the secondary store.
      * @param {string} key The key to get the value of
@@ -531,9 +560,8 @@ declare class Cacheable extends Hookified {
      * Sets the value of the key. If the secondary store is set then it will also set the value in the secondary store.
      * @param {string} key the key to set the value of
      * @param {T} value The value to set
-     * @param {number | string} [ttl] Time to Live - If you set a number it is miliseconds, if you set a string it is a human-readable
-     * format such as `1s` for 1 second or `1h` for 1 hour. Setting undefined means that it will use the default time-to-live. If both are
-     * undefined then it will not have a time-to-live.
+     * @param {number | string} [ttl] set a number it is miliseconds, set a string it is a human-readable
+     * format such as `1s` for 1 second or `1h` for 1 hour. Setting undefined means that it will use the default time-to-live.
      * @returns {boolean} Whether the value was set
      */
     set<T>(key: string, value: T, ttl?: number | string): Promise<boolean>;
@@ -597,10 +625,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?: {
-        ttl?: number;
-        key?: string;
-    }): (...arguments_: any[]) => T;
+    wrap<T>(function_: (...arguments_: any[]) => T, options: WrapFunctionOptions): (...arguments_: any[]) => 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

@@ -109,6 +109,24 @@ type CacheableStoreItem = {
     expires?: number;
 };
 
+type WrapOptions = {
+    ttl?: number | string;
+    keyPrefix?: string;
+    cache: Cacheable;
+};
+type WrapSyncOptions = {
+    ttl?: number | string;
+    keyPrefix?: string;
+    cache: CacheableMemory;
+};
+type WrapFunctionOptions = {
+    ttl?: number | string;
+    keyPrefix: string;
+};
+type AnyFunction = (...arguments_: any[]) => any;
+declare function wrapSync<T>(function_: AnyFunction, options: WrapSyncOptions): AnyFunction;
+declare function wrap<T>(function_: AnyFunction, options: WrapOptions): AnyFunction;
+
 /**
  * @typedef {Object} CacheableMemoryOptions
  * @property {number|string} [ttl] - Time to Live - If you set a number it is miliseconds, if you set a string it is a human-readable
@@ -125,6 +143,7 @@ type CacheableMemoryOptions = {
     checkInterval?: number;
 };
 declare class CacheableMemory {
+    private _lru;
     private readonly _hashCache;
     private readonly _hash0;
     private readonly _hash1;
@@ -136,7 +155,6 @@ declare class CacheableMemory {
     private readonly _hash7;
     private readonly _hash8;
     private readonly _hash9;
-    private readonly _lru;
     private _ttl;
     private _useClone;
     private _lruSize;
@@ -282,18 +300,24 @@ declare class CacheableMemory {
      * @returns {void}
      */
     clear(): void;
-    /**
-     * Hash the key. this is used to determine which store to use (internal use)
-     * @param {string} key - The key to hash
-     * @returns {number} - The hash number
-     */
-    hashKey(key: string): number;
     /**
      * Get the store based on the key (internal use)
      * @param {string} key - The key to get the store
-     * @returns {Map<string, any>} - The store
+     * @returns {CacheableHashStore} - The store
      */
-    getStore(key: string): Map<string, any>;
+    getStore(key: string): Map<string, CacheableStoreItem>;
+    /**
+     * Get the store based on the hash (internal use)
+     * @param {number} hash
+     * @returns {Map<string, CacheableStoreItem>}
+     */
+    getStoreFromHash(hash: number): Map<string, CacheableStoreItem>;
+    /**
+     * Hash the key (internal use)
+     * @param key
+     * @returns {number} from 0 to 9
+     */
+    hashKey(key: string): number;
     /**
      * Clone the value. This is for internal use
      * @param {any} value - The value to clone
@@ -345,20 +369,24 @@ declare class CacheableMemory {
      * @param {Object} [options] - The options to wrap
      * @returns {Function} - The wrapped function
      */
-    wrap<T>(function_: (...arguments_: any[]) => T, options?: {
-        ttl?: number;
-        key?: string;
-    }): (...arguments_: any[]) => T;
+    wrap<T>(function_: (...arguments_: any[]) => T, options: WrapFunctionOptions): (...arguments_: any[]) => T;
     private isPrimitive;
     private concatStores;
     private setTtl;
 }
 
+type KeyvCacheableMemoryOptions = CacheableMemoryOptions & {
+    namespace?: string;
+};
 declare class KeyvCacheableMemory implements KeyvStoreAdapter {
     opts: CacheableMemoryOptions;
-    namespace?: string | undefined;
-    private readonly _cache;
-    constructor(options?: CacheableMemoryOptions);
+    private readonly _defaultCache;
+    private readonly _nCache;
+    private _namespace?;
+    constructor(options?: KeyvCacheableMemoryOptions);
+    get namespace(): string | undefined;
+    set namespace(value: string | undefined);
+    get store(): CacheableMemory;
     get<Value>(key: string): Promise<StoredData<Value> | undefined>;
     getMany<Value>(keys: string[]): Promise<Array<StoredData<Value | undefined>>>;
     set(key: string, value: any, ttl?: number): Promise<void>;
@@ -372,25 +400,12 @@ declare class KeyvCacheableMemory implements KeyvStoreAdapter {
     clear(): Promise<void>;
     has?(key: string): Promise<boolean>;
     on(event: string, listener: (...arguments_: any[]) => void): this;
+    getStore(namespace?: string): CacheableMemory;
 }
 
 declare const shorthandToMilliseconds: (shorthand?: string | number) => number | undefined;
 declare const shorthandToTime: (shorthand?: string | number, fromDate?: Date) => number;
 
-type WrapOptions = {
-    ttl?: number | string;
-    key?: string;
-    cache: Cacheable;
-};
-type WrapSyncOptions = {
-    ttl?: number | string;
-    key?: string;
-    cache: CacheableMemory;
-};
-type AnyFunction = (...arguments_: any[]) => any;
-declare function wrapSync<T>(function_: AnyFunction, options: WrapSyncOptions): AnyFunction;
-declare function wrap<T>(function_: AnyFunction, options: WrapOptions): AnyFunction;
-
 declare enum CacheableHooks {
     BEFORE_SET = "BEFORE_SET",
     AFTER_SET = "AFTER_SET",
@@ -410,6 +425,7 @@ type CacheableOptions = {
     stats?: boolean;
     nonBlocking?: boolean;
     ttl?: number | string;
+    namespace?: string | (() => string);
 };
 declare class Cacheable extends Hookified {
     private _primary;
@@ -417,11 +433,23 @@ declare class Cacheable extends Hookified {
     private _nonBlocking;
     private _ttl?;
     private readonly _stats;
+    private _namespace?;
     /**
      * Creates a new cacheable instance
      * @param {CacheableOptions} [options] The options for the cacheable instance
      */
     constructor(options?: CacheableOptions);
+    /**
+     * The namespace for the cacheable instance
+     * @returns {string | (() => string) | undefined} The namespace for the cacheable instance
+     */
+    get namespace(): string | (() => string) | undefined;
+    /**
+     * Sets the namespace for the cacheable instance
+     * @param {string | (() => string) | undefined} namespace The namespace for the cacheable instance
+     * @returns {void}
+     */
+    set namespace(namespace: string | (() => string) | undefined);
     /**
      * The statistics for the cacheable instance
      * @returns {CacheableStats} The statistics for the cacheable instance
@@ -515,6 +543,7 @@ declare class Cacheable extends Hookified {
      * @returns {void}
      */
     setSecondary(secondary: Keyv | KeyvStoreAdapter): void;
+    getNameSpace(): string | undefined;
     /**
      * Gets the value of the key. If the key does not exist in the primary store then it will check the secondary store.
      * @param {string} key The key to get the value of
@@ -531,9 +560,8 @@ declare class Cacheable extends Hookified {
      * Sets the value of the key. If the secondary store is set then it will also set the value in the secondary store.
      * @param {string} key the key to set the value of
      * @param {T} value The value to set
-     * @param {number | string} [ttl] Time to Live - If you set a number it is miliseconds, if you set a string it is a human-readable
-     * format such as `1s` for 1 second or `1h` for 1 hour. Setting undefined means that it will use the default time-to-live. If both are
-     * undefined then it will not have a time-to-live.
+     * @param {number | string} [ttl] set a number it is miliseconds, set a string it is a human-readable
+     * format such as `1s` for 1 second or `1h` for 1 hour. Setting undefined means that it will use the default time-to-live.
      * @returns {boolean} Whether the value was set
      */
     set<T>(key: string, value: T, ttl?: number | string): Promise<boolean>;
@@ -597,10 +625,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?: {
-        ttl?: number;
-        key?: string;
-    }): (...arguments_: any[]) => T;
+    wrap<T>(function_: (...arguments_: any[]) => T, options: WrapFunctionOptions): (...arguments_: any[]) => 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

@@ -69,11 +69,23 @@ var shorthandToTime = (shorthand, fromDate) => {
   return fromDate.getTime() + milliseconds;
 };
 
+// src/hash.ts
+import * as crypto from "node:crypto";
+function hash(object, algorithm = "sha256") {
+  const objectString = JSON.stringify(object);
+  if (!crypto.getHashes().includes(algorithm)) {
+    throw new Error(`Unsupported hash algorithm: '${algorithm}'`);
+  }
+  const hasher = crypto.createHash(algorithm);
+  hasher.update(objectString);
+  return hasher.digest("hex");
+}
+
 // src/wrap.ts
 function wrapSync(function_, options) {
-  const { ttl, key, cache } = options;
+  const { ttl, keyPrefix, cache } = options;
   return function(...arguments_) {
-    const cacheKey = key ?? cache.hash(arguments_);
+    const cacheKey = createWrapKey(function_, arguments_, keyPrefix);
     let value = cache.get(cacheKey);
     if (value === void 0) {
       value = function_(...arguments_);
@@ -83,9 +95,9 @@ function wrapSync(function_, options) {
   };
 }
 function wrap(function_, options) {
-  const { ttl, key, cache } = options;
+  const { ttl, keyPrefix, cache } = options;
   return async function(...arguments_) {
-    const cacheKey = key ?? cache.hash(arguments_);
+    const cacheKey = createWrapKey(function_, arguments_, keyPrefix);
     let value = await cache.get(cacheKey);
     if (value === void 0) {
       value = await function_(...arguments_);
@@ -94,6 +106,12 @@ function wrap(function_, options) {
     return value;
   };
 }
+function createWrapKey(function_, arguments_, keyPrefix) {
+  if (!keyPrefix) {
+    return `${function_.name}::${hash(arguments_)}`;
+  }
+  return `${keyPrefix}::${function_.name}::${hash(arguments_)}`;
+}
 
 // src/memory-lru.ts
 var ListNode = class {
@@ -168,20 +186,9 @@ var DoublyLinkedList = class {
   }
 };
 
-// src/hash.ts
-import * as crypto from "node:crypto";
-function hash(object, algorithm = "sha256") {
-  const objectString = JSON.stringify(object);
-  if (!crypto.getHashes().includes(algorithm)) {
-    throw new Error(`Unsupported hash algorithm: '${algorithm}'`);
-  }
-  const hasher = crypto.createHash(algorithm);
-  hasher.update(objectString);
-  return hasher.digest("hex");
-}
-
 // src/memory.ts
 var CacheableMemory = class {
+  _lru = new DoublyLinkedList();
   _hashCache = /* @__PURE__ */ new Map();
   _hash0 = /* @__PURE__ */ new Map();
   _hash1 = /* @__PURE__ */ new Map();
@@ -193,7 +200,6 @@ var CacheableMemory = class {
   _hash7 = /* @__PURE__ */ new Map();
   _hash8 = /* @__PURE__ */ new Map();
   _hash9 = /* @__PURE__ */ new Map();
-  _lru = new DoublyLinkedList();
   _ttl;
   // Turned off by default
   _useClone = true;
@@ -395,12 +401,11 @@ var CacheableMemory = class {
         }
       }
     }
-    store.set(key, {
+    const item = { key, value, expires };
+    store.set(
       key,
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      value,
-      expires
-    });
+      item
+    );
   }
   /**
    * Sets the values of the keys
@@ -494,34 +499,24 @@ var CacheableMemory = class {
     this._hash8.clear();
     this._hash9.clear();
     this._hashCache.clear();
-  }
-  /**
-   * Hash the key. this is used to determine which store to use (internal use)
-   * @param {string} key - The key to hash
-   * @returns {number} - The hash number
-   */
-  hashKey(key) {
-    const cacheHashNumber = this._hashCache.get(key);
-    if (cacheHashNumber) {
-      return cacheHashNumber;
-    }
-    let hash2 = 0;
-    const primeMultiplier = 31;
-    for (let i = 0; i < key.length; i++) {
-      hash2 = hash2 * primeMultiplier + key.charCodeAt(i);
-    }
-    const result = Math.abs(hash2) % 10;
-    this._hashCache.set(key, result);
-    return result;
+    this._lru = new DoublyLinkedList();
   }
   /**
    * Get the store based on the key (internal use)
    * @param {string} key - The key to get the store
-   * @returns {Map<string, any>} - The store
+   * @returns {CacheableHashStore} - The store
    */
   getStore(key) {
-    const hashKey = this.hashKey(key);
-    switch (hashKey) {
+    const hash2 = this.hashKey(key);
+    return this.getStoreFromHash(hash2);
+  }
+  /**
+   * Get the store based on the hash (internal use)
+   * @param {number} hash
+   * @returns {Map<string, CacheableStoreItem>}
+   */
+  getStoreFromHash(hash2) {
+    switch (hash2) {
       case 1: {
         return this._hash1;
       }
@@ -554,6 +549,25 @@ var CacheableMemory = class {
       }
     }
   }
+  /**
+   * Hash the key (internal use)
+   * @param key
+   * @returns {number} from 0 to 9
+   */
+  hashKey(key) {
+    const cacheHashNumber = this._hashCache.get(key);
+    if (cacheHashNumber) {
+      return cacheHashNumber;
+    }
+    let hash2 = 0;
+    const primeMultiplier = 31;
+    for (let i = 0; i < key.length; i++) {
+      hash2 = hash2 * primeMultiplier + key.charCodeAt(i);
+    }
+    const result = Math.abs(hash2) % 10;
+    this._hashCache.set(key, result);
+    return result;
+  }
   /**
    * Clone the value. This is for internal use
    * @param {any} value - The value to clone
@@ -652,10 +666,10 @@ var CacheableMemory = class {
    * @param {Object} [options] - The options to wrap
    * @returns {Function} - The wrapped function
    */
-  wrap(function_, options = {}) {
+  wrap(function_, options) {
     const wrapOptions = {
       ttl: options.ttl,
-      key: options.key,
+      keyPrefix: options.keyPrefix,
       cache: this
     };
     return wrapSync(function_, wrapOptions);
@@ -671,8 +685,7 @@ var CacheableMemory = class {
     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;
+    return new Map([...this._hash0, ...this._hash1, ...this._hash2, ...this._hash3, ...this._hash4, ...this._hash5, ...this._hash6, ...this._hash7, ...this._hash8, ...this._hash9]);
   }
   setTtl(ttl) {
     if (typeof ttl === "string" || ttl === void 0) {
@@ -693,48 +706,71 @@ var KeyvCacheableMemory = class {
     lruSize: 0,
     checkInterval: 0
   };
-  namespace;
-  _cache = new CacheableMemory();
+  _defaultCache = new CacheableMemory();
+  _nCache = /* @__PURE__ */ new Map();
+  _namespace;
   constructor(options) {
     if (options) {
       this.opts = options;
-      this._cache = new CacheableMemory(options);
+      this._defaultCache = new CacheableMemory(options);
+      if (options.namespace) {
+        this._namespace = options.namespace;
+        this._nCache.set(this._namespace, new CacheableMemory(options));
+      }
     }
   }
+  get namespace() {
+    return this._namespace;
+  }
+  set namespace(value) {
+    this._namespace = value;
+  }
+  get store() {
+    return this.getStore(this._namespace);
+  }
   async get(key) {
-    const result = this._cache.get(key);
+    const result = this.getStore(this._namespace).get(key);
     if (result) {
       return result;
     }
     return void 0;
   }
   async getMany(keys) {
-    const result = this._cache.getMany(keys);
+    const result = this.getStore(this._namespace).getMany(keys);
     return result;
   }
   async set(key, value, ttl) {
-    this._cache.set(key, value, ttl);
+    this.getStore(this._namespace).set(key, value, ttl);
   }
   async setMany(values) {
-    this._cache.setMany(values);
+    this.getStore(this._namespace).setMany(values);
   }
   async delete(key) {
-    this._cache.delete(key);
+    this.getStore(this._namespace).delete(key);
     return true;
   }
   async deleteMany(key) {
-    this._cache.deleteMany(key);
+    this.getStore(this._namespace).deleteMany(key);
     return true;
   }
   async clear() {
-    this._cache.clear();
+    this.getStore(this._namespace).clear();
   }
   async has(key) {
-    return this._cache.has(key);
+    return this.getStore(this._namespace).has(key);
   }
   on(event, listener) {
     return this;
   }
+  getStore(namespace) {
+    if (!namespace) {
+      return this._defaultCache;
+    }
+    if (!this._nCache.has(namespace)) {
+      this._nCache.set(namespace, new CacheableMemory(this.opts));
+    }
+    return this._nCache.get(namespace);
+  }
 };
 
 // src/stats.ts
@@ -980,6 +1016,7 @@ var Cacheable = class extends Hookified {
   _nonBlocking = false;
   _ttl;
   _stats = new CacheableStats({ enabled: false });
+  _namespace;
   /**
    * Creates a new cacheable instance
    * @param {CacheableOptions} [options] The options for the cacheable instance
@@ -1001,6 +1038,32 @@ var Cacheable = class extends Hookified {
     if (options?.ttl) {
       this.setTtl(options.ttl);
     }
+    if (options?.namespace) {
+      this._namespace = options.namespace;
+      this._primary.namespace = this.getNameSpace();
+      if (this._secondary) {
+        this._secondary.namespace = this.getNameSpace();
+      }
+    }
+  }
+  /**
+   * The namespace for the cacheable instance
+   * @returns {string | (() => string) | undefined} The namespace for the cacheable instance
+   */
+  get namespace() {
+    return this._namespace;
+  }
+  /**
+   * Sets the namespace for the cacheable instance
+   * @param {string | (() => string) | undefined} namespace The namespace for the cacheable instance
+   * @returns {void}
+   */
+  set namespace(namespace) {
+    this._namespace = namespace;
+    this._primary.namespace = this.getNameSpace();
+    if (this._secondary) {
+      this._secondary.namespace = this.getNameSpace();
+    }
   }
   /**
    * The statistics for the cacheable instance
@@ -1117,6 +1180,12 @@ var Cacheable = class extends Hookified {
   setSecondary(secondary) {
     this._secondary = secondary instanceof Keyv ? secondary : new Keyv(secondary);
   }
+  getNameSpace() {
+    if (typeof this._namespace === "function") {
+      return this._namespace();
+    }
+    return this._namespace;
+  }
   /**
    * Gets the value of the key. If the key does not exist in the primary store then it will check the secondary store.
    * @param {string} key The key to get the value of
@@ -1194,9 +1263,8 @@ var Cacheable = class extends Hookified {
    * Sets the value of the key. If the secondary store is set then it will also set the value in the secondary store.
    * @param {string} key the key to set the value of
    * @param {T} value The value to set
-   * @param {number | string} [ttl] Time to Live - If you set a number it is miliseconds, if you set a string it is a human-readable
-   * format such as `1s` for 1 second or `1h` for 1 hour. Setting undefined means that it will use the default time-to-live. If both are
-   * undefined then it will not have a time-to-live.
+   * @param {number | string} [ttl] set a number it is miliseconds, set a string it is a human-readable
+   * format such as `1s` for 1 second or `1h` for 1 hour. Setting undefined means that it will use the default time-to-live.
    * @returns {boolean} Whether the value was set
    */
   async set(key, value, ttl) {
@@ -1410,10 +1478,10 @@ var Cacheable = class extends Hookified {
    * @param {WrapOptions} [options] The options for the wrap function
    * @returns {Function} The wrapped function
    */
-  wrap(function_, options = {}) {
+  wrap(function_, options) {
     const wrapOptions = {
       ttl: options.ttl,
-      key: options.key,
+      keyPrefix: options.keyPrefix,
       cache: this
     };
     return wrap(function_, wrapOptions);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cacheable",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "description": "Simple Caching Engine using Keyv",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -22,18 +22,18 @@
   "private": false,
   "devDependencies": {
     "@keyv/redis": "^3.0.1",
-    "@types/node": "^22.7.4",
-    "@vitest/coverage-v8": "^2.1.1",
+    "@types/node": "^22.8.1",
+    "@vitest/coverage-v8": "^2.1.3",
     "lru-cache": "^11.0.1",
     "rimraf": "^6.0.1",
-    "tsup": "^8.3.0",
-    "typescript": "^5.6.2",
-    "vitest": "^2.1.1",
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.3",
     "xo": "^0.59.3"
   },
   "dependencies": {
-    "hookified": "^1.1.0",
-    "keyv": "^5.0.3"
+    "hookified": "^1.4.0",
+    "keyv": "^5.1.2"
   },
   "keywords": [
     "cacheable",