cacheable 2.1.1 → 2.3.0

package/README.md

@@ -32,6 +32,7 @@
 * [Storage Tiering and Caching](#storage-tiering-and-caching)
 * [TTL Propagation and Storage Tiering](#ttl-propagation-and-storage-tiering)
 * [Shorthand for Time to Live (ttl)](#shorthand-for-time-to-live-ttl)
+* [Iteration on Primary and Secondary Stores](#iteration-on-primary-and-secondary-stores)
 * [Non-Blocking Operations](#non-blocking-operations)
 * [Non-Blocking with @keyv/redis](#non-blocking-with-keyvredis)
 * [CacheableSync - Distributed Updates](#cacheablesync---distributed-updates)
@@ -279,6 +280,110 @@ raws.forEach((entry, idx) => {
 });
 ```
 
+## Checking multiple keys with hasMany
+
+The `hasMany` method allows you to efficiently check if multiple keys exist in the cache. It leverages Keyv's native `hasMany` support for optimal performance:
+
+```typescript
+import { Cacheable } from 'cacheable';
+
+const cache = new Cacheable();
+
+// set some values
+await cache.set('user:1', { name: 'Alice' });
+await cache.set('user:2', { name: 'Bob' });
+
+// check if multiple keys exist
+const exists = await cache.hasMany(['user:1', 'user:2', 'user:3']);
+console.log(exists); // [true, true, false]
+```
+
+The `hasMany` method returns an array of booleans in the same order as the input keys. This is particularly useful when you need to verify the existence of multiple cache entries before performing batch operations.
+
+# Iteration on Primary and Secondary Stores
+
+The `Cacheable` class exposes both `primary` and `secondary` Keyv instances, which support iteration over their stored entries using the `iterator()` method. This allows you to access and process all keys and values in either storage layer.
+
+**Important Notes:**
+- Not all storage adapters support iteration. Always check if `iterator` exists before using it.
+- The iterator automatically filters by namespace, skips expired entries (and deletes them), and deserializes values.
+- **Performance Warning:** Be careful when using `iterator()` as it can cause performance issues with large datasets.
+
+## Basic Iteration Example
+
+```typescript
+import { Cacheable } from 'cacheable';
+import KeyvRedis from '@keyv/redis';
+
+// Create cache with primary (in-memory) and secondary (Redis) stores
+const secondary = new KeyvRedis('redis://user:pass@localhost:6379');
+const cache = new Cacheable({ secondary });
+
+// Add some data
+await cache.set('user:1', { name: 'Alice', role: 'admin' });
+await cache.set('user:2', { name: 'Bob', role: 'user' });
+await cache.set('session:abc', { userId: '1', active: true });
+
+// Iterate over primary store (in-memory)
+console.log('Primary store contents:');
+if (cache.primary.iterator) {
+    for await (const [key, value] of cache.primary.iterator()) {
+        console.log(`  ${key}:`, JSON.stringify(value));
+    }
+}
+
+// Iterate over secondary store (Redis)
+console.log('\nSecondary store contents:');
+if (cache.secondary?.iterator) {
+    for await (const [key, value] of cache.secondary.iterator()) {
+        console.log(`  ${key}:`, JSON.stringify(value));
+    }
+}
+```
+
+## Safe Iteration Helper
+
+Here's a recommended helper function for safe iteration that checks for store availability and iterator support:
+
+```typescript
+import { Cacheable } from 'cacheable';
+import type { Keyv } from 'keyv';
+
+async function iterateStore(store: Keyv | undefined, storeName: string) {
+    if (!store) {
+        console.log(`${storeName} store not configured`);
+        return;
+    }
+
+    if (!store.iterator) {
+        console.log(`${storeName} store does not support iteration`);
+        return;
+    }
+
+    console.log(`${storeName} store entries:`);
+    for await (const [key, value] of store.iterator()) {
+        console.log(`  ${key}:`, value);
+    }
+}
+
+// Usage
+const cache = new Cacheable({ /* options */ });
+await iterateStore(cache.primary, 'Primary');
+await iterateStore(cache.secondary, 'Secondary');
+```
+
+## Storage Adapter Support
+
+The `iterator()` method is available when:
+- The store is a Map instance (has Symbol.iterator)
+- The store implements an `iterator()` method (e.g., Redis, Valkey, etc.)
+- The store is a supported iterable adapter
+
+Common stores that support iteration:
+- In-memory (Map-based stores)
+- @keyv/redis
+- @keyv/valkey
+- Other Keyv adapters that implement the iterator interface
 
 # Non-Blocking Operations
 
@@ -442,6 +547,45 @@ const cache = new Cacheable({
 });
 ```
 
+## Namespace Isolation with Sync
+
+When multiple services share the same Redis instance (or other message provider), you can use namespaces to isolate cache synchronization events between services. This prevents one service's cache updates from affecting another service's cache.
+
+```javascript
+import { Cacheable } from 'cacheable';
+import { RedisMessageProvider } from '@qified/redis';
+
+const provider = new RedisMessageProvider({
+  connection: { host: 'localhost', port: 6379 }
+});
+
+// Service 1 with namespace
+const serviceA = new Cacheable({
+  namespace: 'service-a',
+  sync: { qified: provider }
+});
+
+// Service 2 with different namespace
+const serviceB = new Cacheable({
+  namespace: 'service-b',
+  sync: { qified: provider }
+});
+
+// Set value in service A
+await serviceA.set('config', { timeout: 5000 });
+
+// Service B won't receive this update because it has a different namespace
+const value = await serviceB.get('config'); // undefined
+```
+
+**How Namespace Isolation Works:**
+- Without namespaces, sync events use channel names like `cache:set` and `cache:delete`
+- With namespaces, events are prefixed: `service-a::cache:set`, `service-b::cache:set`
+- Services only subscribe to events matching their namespace, ensuring complete isolation
+- Namespaces can be static strings or functions that return strings
+
+**Note:** The namespace is automatically passed from Cacheable to CacheableSync, so you only need to set it once in the Cacheable options.
+
 ## How Sync Works
 
 1. **SET Operations**: When you call `cache.set()` or `cache.setMany()`, the cache:
@@ -517,7 +661,8 @@ _This does not enable statistics for your layer 2 cache as that is a distributed
 * `removeHook(hook)`: Removes a hook.
 * `on(event, callback)`: Listens for an event.
 * `removeListener(event, callback)`: Removes a listener.
-* `hash(object: any, algorithm = 'sha256'): string`: Hashes an object with the algorithm. Default is `sha256`.
+* `hash(object: any, algorithm = 'SHA-256'): Promise<string>`: Asynchronously hashes an object with a cryptographic algorithm (SHA-256, SHA-384, SHA-512). Default is `SHA-256`.
+* `hashSync(object: any, algorithm = 'djb2'): string`: Synchronously hashes an object with a non-cryptographic algorithm (djb2, fnv1, murmer, crc32). Default is `djb2`.
 * `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.
@@ -544,7 +689,7 @@ To learn more go to [@cacheable/memory](https://cacheable.org/docs/memory/)
 
 # Wrap / Memoization for Sync and Async Functions
 
-`Cacheable` and `CacheableMemory` has a feature called `wrap` that comes from [@cacheable/memoize](https://cacheable.org/docs/memoize/) and allows you to wrap a function in a cache. This is useful for memoization and caching the results of a function. You can wrap a `sync` or `async` function in a cache. Here is an example of how to use the `wrap` function:
+`Cacheable` and `CacheableMemory` has a feature called `wrap` that comes from [@cacheable/utils](https://cacheable.org/docs/utils/) and allows you to wrap a function in a cache. This is useful for memoization and caching the results of a function. You can wrap a `sync` or `async` function in a cache. Here is an example of how to use the `wrap` function:
 
 ```javascript
 import { Cacheable } from 'cacheable';
@@ -637,11 +782,11 @@ If you would like to generate your own key for the wrapped function you can set
 
 We will pass in the `function` that is being wrapped, the `arguments` passed to the function, and the `options` used to wrap the function. You can then use these to generate a custom key for the cache.
 
-To learn more visit [@cacheable/memoize](https://cacheable.org/docs/memoize/)
+To learn more visit [@cacheable/utils](https://cacheable.org/docs/utils/)
 
 # Get Or Set Memoization Function
 
-The `getOrSet`  method that comes from [@cacheable/memoize](https://cacheable.org/docs/memoize/) provides a convenient way to implement the cache-aside pattern. It attempts to retrieve a value from cache, and if not found, calls the provided function to compute the value and store it in cache before returning it. Here are the options:
+The `getOrSet`  method that comes from [@cacheable/utils](https://cacheable.org/docs/utils/) provides a convenient way to implement the cache-aside pattern. It attempts to retrieve a value from cache, and if not found, calls the provided function to compute the value and store it in cache before returning it. Here are the options:
 
 ```typescript
 export type GetOrSetFunctionOptions = {
@@ -677,17 +822,17 @@ const function_ = async () => Math.random() * 100;
 const value = await cache.getOrSet(generateKey(), function_, { ttl: '1h' });
 ```
 
-To learn more go to [@cacheable/memoize](https://cacheable.org/docs/memoize/)
+To learn more go to [@cacheable/utils](https://cacheable.org/docs/utils/)
 
 # v1 to v2 Changes
 
-`cacheable` is now using `@cacheable/utils`, `@cacheable/memoize`, and `@cacheable/memory` for its core functionality as we are moving to this modular architecture and plan to eventually have these modules across `cache-manager` and `flat-cache`. In addition there are some breaking changes:
+`cacheable` is now using `@cacheable/utils` and `@cacheable/memory` for its core functionality as we are moving to this modular architecture and plan to eventually have these modules across `cache-manager` and `flat-cache`. In addition there are some breaking changes:
 
 * `get()` and `getMany()` no longer have the `raw` option but instead we have built out `getRaw()` and `getManyRaw()` to use.
 * All `get` related functions now support `nonBlocking` which means if `nonBlocking: true` the primary store will return what it has and then in the background will work to sync from secondary storage for any misses. You can disable this by setting at the `get` function level the option `nonBlocking: false` which will look for any missing keys in the secondary.
-* `Keyv` v5.5+ is now the recommended supported version as we are using its native `getMany*` and `getRaw*`
+* `Keyv` v5.5+ is now the recommended supported version as we are using its native `getMany*`, `getRaw*`, and `hasMany` methods for improved performance
 * `Wrap` and `getOrSet` have been updated with more robust options including the ability to use your own `serialize` function for creating the key in `wrap`.
-* `hash` has now been updated with robust options and also an enum for setting the algorithm.
+* `hash` has been split into async (`hash()` and `hashToNumber()`) and sync (`hashSync()` and `hashToNumberSync()`) methods. MD5 support has been removed. Now uses Hashery library with support for additional algorithms (SHA-384, FNV1, MURMER, CRC32).
 
 # How to Contribute
 

package/dist/index.cjs

@@ -34,15 +34,14 @@ __export(index_exports, {
   calculateTtlFromExpiration: () => import_utils2.calculateTtlFromExpiration,
   createKeyv: () => import_memory2.createKeyv,
   getCascadingTtl: () => import_utils2.getCascadingTtl,
-  getOrSet: () => import_memoize2.getOrSet,
+  getOrSet: () => import_utils2.getOrSet,
   hash: () => import_utils2.hash,
   shorthandToMilliseconds: () => import_utils2.shorthandToMilliseconds,
   shorthandToTime: () => import_utils2.shorthandToTime,
-  wrap: () => import_memoize2.wrap,
-  wrapSync: () => import_memoize2.wrapSync
+  wrap: () => import_utils2.wrap,
+  wrapSync: () => import_utils2.wrapSync
 });
 module.exports = __toCommonJS(index_exports);
-var import_memoize = require("@cacheable/memoize");
 var import_memory = require("@cacheable/memory");
 var import_utils = require("@cacheable/utils");
 var import_hookified2 = require("hookified");
@@ -79,12 +78,16 @@ var CacheableSyncEvents = /* @__PURE__ */ ((CacheableSyncEvents2) => {
 })(CacheableSyncEvents || {});
 var CacheableSync = class extends import_hookified.Hookified {
   _qified = new import_qified.Qified();
+  _namespace;
+  _storage;
+  _cacheId;
   /**
    * Creates an instance of CacheableSync
    * @param options - Configuration options for CacheableSync
    */
   constructor(options) {
     super(options);
+    this._namespace = options.namespace;
     this._qified = this.createQified(options.qified);
   }
   /**
@@ -101,12 +104,36 @@ var CacheableSync = class extends import_hookified.Hookified {
   set qified(value) {
     this._qified = this.createQified(value);
   }
+  /**
+   * Gets the namespace for sync events
+   * @returns The namespace or undefined if not set
+   */
+  get namespace() {
+    return this._namespace;
+  }
+  /**
+   * Sets the namespace for sync events and resubscribes if needed
+   * @param namespace - The namespace string or function
+   */
+  set namespace(namespace) {
+    if (this._storage && this._cacheId) {
+      const oldSetEvent = this.getPrefixedEvent("cache:set" /* SET */);
+      const oldDeleteEvent = this.getPrefixedEvent("cache:delete" /* DELETE */);
+      void this._qified.unsubscribe(oldSetEvent);
+      void this._qified.unsubscribe(oldDeleteEvent);
+    }
+    this._namespace = namespace;
+    if (this._storage && this._cacheId) {
+      this.subscribe(this._storage, this._cacheId);
+    }
+  }
   /**
    * Publishes a cache event to all the cache instances
    * @param data - The cache item data containing cacheId, key, value, and optional ttl
    */
   async publish(event, data) {
-    await this._qified.publish(event, {
+    const eventName = this.getPrefixedEvent(event);
+    await this._qified.publish(eventName, {
       id: crypto.randomUUID(),
       data
     });
@@ -117,7 +144,11 @@ var CacheableSync = class extends import_hookified.Hookified {
    * @param cacheId - The cache ID to identify this instance
    */
   subscribe(storage, cacheId) {
-    this._qified.subscribe("cache:set" /* SET */, {
+    this._storage = storage;
+    this._cacheId = cacheId;
+    const setEvent = this.getPrefixedEvent("cache:set" /* SET */);
+    const deleteEvent = this.getPrefixedEvent("cache:delete" /* DELETE */);
+    this._qified.subscribe(setEvent, {
       handler: async (message) => {
         const data = message.data;
         if (data.cacheId !== cacheId) {
@@ -125,7 +156,7 @@ var CacheableSync = class extends import_hookified.Hookified {
         }
       }
     });
-    this._qified.subscribe("cache:delete" /* DELETE */, {
+    this._qified.subscribe(deleteEvent, {
       handler: async (message) => {
         const data = message.data;
         if (data.cacheId !== cacheId) {
@@ -146,10 +177,28 @@ var CacheableSync = class extends import_hookified.Hookified {
     const providers = Array.isArray(value) ? value : [value];
     return new import_qified.Qified({ messageProviders: providers });
   }
+  /**
+   * Gets the namespace prefix to use for event names
+   * @returns The resolved namespace string or undefined
+   */
+  getNamespace() {
+    if (typeof this._namespace === "function") {
+      return this._namespace();
+    }
+    return this._namespace;
+  }
+  /**
+   * Prefixes an event name with the namespace if one is set
+   * @param event - The event to prefix
+   * @returns The prefixed event name or the original event
+   */
+  getPrefixedEvent(event) {
+    const ns = this.getNamespace();
+    return ns ? `${ns}::${event}` : event;
+  }
 };
 
 // src/index.ts
-var import_memoize2 = require("@cacheable/memoize");
 var import_memory2 = require("@cacheable/memory");
 var import_utils2 = require("@cacheable/utils");
 var import_keyv2 = require("keyv");
@@ -194,7 +243,10 @@ var Cacheable = class extends import_hookified2.Hookified {
       }
     }
     if (options?.sync) {
-      this._sync = options.sync instanceof CacheableSync ? options.sync : new CacheableSync(options.sync);
+      this._sync = options.sync instanceof CacheableSync ? options.sync : new CacheableSync({
+        ...options.sync,
+        namespace: options.namespace
+      });
       this._sync.subscribe(this._primary, this._cacheId);
     }
   }
@@ -216,6 +268,9 @@ var Cacheable = class extends import_hookified2.Hookified {
     if (this._secondary) {
       this._secondary.namespace = this.getNameSpace();
     }
+    if (this._sync) {
+      this._sync.namespace = namespace;
+    }
   }
   /**
    * The statistics for the cacheable instance
@@ -677,7 +732,7 @@ var Cacheable = class extends import_hookified2.Hookified {
    * @returns {Promise<boolean[]>} Whether the keys exist
    */
   async hasMany(keys) {
-    const result = await this.hasManyKeyv(this._primary, keys);
+    const result = await this._primary.hasMany(keys);
     const missingKeys = [];
     for (const [i, key] of keys.entries()) {
       if (!result[i] && this._secondary) {
@@ -685,7 +740,7 @@ var Cacheable = class extends import_hookified2.Hookified {
       }
     }
     if (missingKeys.length > 0 && this._secondary) {
-      const secondary = await this.hasManyKeyv(this._secondary, keys);
+      const secondary = await this._secondary.hasMany(keys);
       for (const [i, _key] of keys.entries()) {
         if (!result[i] && secondary[i]) {
           result[i] = secondary[i];
@@ -795,6 +850,7 @@ var Cacheable = class extends import_hookified2.Hookified {
     if (this._secondary) {
       promises.push(this._secondary.disconnect());
     }
+    promises.push(this._sync?.qified.disconnect());
     await (this._nonBlocking ? Promise.race(promises) : Promise.all(promises));
   }
   /**
@@ -809,18 +865,16 @@ var Cacheable = class extends import_hookified2.Hookified {
   wrap(function_, options) {
     const cacheAdapter = {
       get: async (key) => this.get(key),
+      /* v8 ignore next -- @preserve */
       has: async (key) => this.has(key),
-      // biome-ignore lint/suspicious/noExplicitAny: CacheInstance requires any type
       set: async (key, value, ttl) => {
         await this.set(key, value, ttl);
       },
-      /* c8 ignore start */
-      // biome-ignore lint/suspicious/noExplicitAny: CacheInstance interface
+      /* v8 ignore next -- @preserve */
       on: (event, listener) => {
         this.on(event, listener);
       },
-      /* c8 ignore stop */
-      // biome-ignore lint/suspicious/noExplicitAny: CacheInstance requires any type
+      /* v8 ignore next -- @preserve */
       emit: (event, ...args) => this.emit(event, ...args)
     };
     const wrapOptions = {
@@ -832,7 +886,7 @@ var Cacheable = class extends import_hookified2.Hookified {
       cacheId: this._cacheId,
       serialize: options?.serialize
     };
-    return (0, import_memoize.wrap)(function_, wrapOptions);
+    return (0, import_utils.wrap)(function_, wrapOptions);
   }
   /**
    * Retrieves the value associated with the given key from the cache. If the key is not found,
@@ -847,18 +901,15 @@ var Cacheable = class extends import_hookified2.Hookified {
   async getOrSet(key, function_, options) {
     const cacheAdapter = {
       get: async (key2) => this.get(key2),
+      /* v8 ignore next -- @preserve */
       has: async (key2) => this.has(key2),
-      // biome-ignore lint/suspicious/noExplicitAny: CacheInstance requires any type
       set: async (key2, value, ttl) => {
         await this.set(key2, value, ttl);
       },
-      /* c8 ignore start */
-      // biome-ignore lint/suspicious/noExplicitAny: CacheInstance interface
+      /* v8 ignore next -- @preserve */
       on: (event, listener) => {
         this.on(event, listener);
       },
-      /* c8 ignore stop */
-      // biome-ignore lint/suspicious/noExplicitAny: CacheInstance requires any type
       emit: (event, ...args) => this.emit(event, ...args)
     };
     const getOrSetOptions = {
@@ -868,17 +919,29 @@ var Cacheable = class extends import_hookified2.Hookified {
       cacheErrors: options?.cacheErrors,
       throwErrors: options?.throwErrors
     };
-    return (0, import_memoize.getOrSet)(key, function_, getOrSetOptions);
+    return (0, import_utils.getOrSet)(key, function_, getOrSetOptions);
+  }
+  /**
+   * Will hash an object asynchronously using the specified cryptographic algorithm.
+   * Use this for cryptographic algorithms (SHA-256, SHA-384, SHA-512).
+   * For non-cryptographic algorithms, use hashSync() for better performance.
+   * @param {any} object the object to hash
+   * @param {string} algorithm the hash algorithm to use. The default is 'SHA-256'
+   * @returns {Promise<string>} the hash of the object
+   */
+  async hash(object, algorithm = import_utils.HashAlgorithm.SHA256) {
+    return (0, import_utils.hash)(object, { algorithm });
   }
   /**
-   * Will hash an object using the specified algorithm. The default algorithm is 'sha256'.
+   * Will hash an object synchronously using the specified non-cryptographic algorithm.
+   * Use this for non-cryptographic algorithms (DJB2, FNV1, MURMER, CRC32).
+   * For cryptographic algorithms, use hash() instead.
    * @param {any} object the object to hash
-   * @param {string} algorithm the hash algorithm to use. The default is 'sha256'
+   * @param {string} algorithm the hash algorithm to use. The default is 'djb2'
    * @returns {string} the hash of the object
    */
-  hash(object, algorithm = import_utils.HashAlgorithm.SHA256) {
-    const validAlgorithm = Object.values(import_utils.HashAlgorithm).includes(algorithm) ? algorithm : import_utils.HashAlgorithm.SHA256;
-    return (0, import_utils.hash)(object, { algorithm: validAlgorithm });
+  hashSync(object, algorithm = import_utils.HashAlgorithm.DJB2) {
+    return (0, import_utils.hashSync)(object, { algorithm });
   }
   async setManyKeyv(keyv, items) {
     const entries = [];
@@ -889,13 +952,6 @@ var Cacheable = class extends import_hookified2.Hookified {
     await keyv.setMany(entries);
     return true;
   }
-  async hasManyKeyv(keyv, keys) {
-    const promises = [];
-    for (const key of keys) {
-      promises.push(keyv.has(key));
-    }
-    return Promise.all(promises);
-  }
   /**
    * Processes a single key from secondary store for getRaw operation
    * @param primary - the primary store to use
@@ -1085,3 +1141,4 @@ var Cacheable = class extends import_hookified2.Hookified {
   wrap,
   wrapSync
 });
+/* v8 ignore next -- @preserve */

package/dist/index.d.cts

@@ -1,7 +1,5 @@
-import { WrapFunctionOptions, GetOrSetKey, GetOrSetFunctionOptions } from '@cacheable/memoize';
-export { GetOrSetFunctionOptions, GetOrSetKey, GetOrSetOptions, WrapOptions, WrapSyncOptions, getOrSet, wrap, wrapSync } from '@cacheable/memoize';
-import { Stats, CacheableItem, HashAlgorithm } from '@cacheable/utils';
-export { CacheableItem, Stats as CacheableStats, HashAlgorithm, calculateTtlFromExpiration, getCascadingTtl, hash, shorthandToMilliseconds, shorthandToTime } from '@cacheable/utils';
+import { Stats, CacheableItem, WrapFunctionOptions, GetOrSetKey, GetOrSetFunctionOptions, HashAlgorithm } from '@cacheable/utils';
+export { CacheableItem, Stats as CacheableStats, GetOrSetFunctionOptions, GetOrSetKey, GetOrSetOptions, HashAlgorithm, WrapOptions, WrapSyncOptions, calculateTtlFromExpiration, getCascadingTtl, getOrSet, hash, shorthandToMilliseconds, shorthandToTime, wrap, wrapSync } from '@cacheable/utils';
 import { Hookified, HookifiedOptions } from 'hookified';
 import { Keyv, KeyvStoreAdapter, StoredDataRaw } from 'keyv';
 export { Keyv, KeyvHooks, KeyvOptions, KeyvStoreAdapter } from 'keyv';
@@ -24,6 +22,11 @@ type CacheableSyncOptions = {
      * Qified instance or message provider(s) for synchronization
      */
     qified: Qified | MessageProvider | MessageProvider[];
+    /**
+     * The namespace for sync events. It can be a string or a function that returns a string.
+     * When set, event names will be prefixed with the namespace (e.g., "my-namespace::cache:set")
+     */
+    namespace?: string | (() => string);
 } & HookifiedOptions;
 type CacheableSyncItem = {
     cacheId: string;
@@ -37,6 +40,9 @@ type CacheableSyncItem = {
  */
 declare class CacheableSync extends Hookified {
     private _qified;
+    private _namespace?;
+    private _storage?;
+    private _cacheId?;
     /**
      * Creates an instance of CacheableSync
      * @param options - Configuration options for CacheableSync
@@ -52,6 +58,16 @@ declare class CacheableSync extends Hookified {
      * @param value - Either an existing Qified instance or MessageProvider(s)
      */
     set qified(value: Qified | MessageProvider | MessageProvider[]);
+    /**
+     * Gets the namespace for sync events
+     * @returns The namespace or undefined if not set
+     */
+    get namespace(): string | (() => string) | undefined;
+    /**
+     * Sets the namespace for sync events and resubscribes if needed
+     * @param namespace - The namespace string or function
+     */
+    set namespace(namespace: string | (() => string) | undefined);
     /**
      * Publishes a cache event to all the cache instances
      * @param data - The cache item data containing cacheId, key, value, and optional ttl
@@ -69,6 +85,17 @@ declare class CacheableSync extends Hookified {
      * @returns A Qified instance configured with the provided message provider(s)
      */
     createQified(value: Qified | MessageProvider | MessageProvider[]): Qified;
+    /**
+     * Gets the namespace prefix to use for event names
+     * @returns The resolved namespace string or undefined
+     */
+    private getNamespace;
+    /**
+     * Prefixes an event name with the namespace if one is set
+     * @param event - The event to prefix
+     * @returns The prefixed event name or the original event
+     */
+    private getPrefixedEvent;
 }
 
 type CacheableOptions = {
@@ -408,14 +435,24 @@ declare class Cacheable extends Hookified {
      */
     getOrSet<T>(key: GetOrSetKey, function_: () => Promise<T>, options?: GetOrSetFunctionOptions): Promise<T | undefined>;
     /**
-     * Will hash an object using the specified algorithm. The default algorithm is 'sha256'.
+     * Will hash an object asynchronously using the specified cryptographic algorithm.
+     * Use this for cryptographic algorithms (SHA-256, SHA-384, SHA-512).
+     * For non-cryptographic algorithms, use hashSync() for better performance.
+     * @param {any} object the object to hash
+     * @param {string} algorithm the hash algorithm to use. The default is 'SHA-256'
+     * @returns {Promise<string>} the hash of the object
+     */
+    hash(object: any, algorithm?: HashAlgorithm): Promise<string>;
+    /**
+     * Will hash an object synchronously using the specified non-cryptographic algorithm.
+     * Use this for non-cryptographic algorithms (DJB2, FNV1, MURMER, CRC32).
+     * For cryptographic algorithms, use hash() instead.
      * @param {any} object the object to hash
-     * @param {string} algorithm the hash algorithm to use. The default is 'sha256'
+     * @param {string} algorithm the hash algorithm to use. The default is 'djb2'
      * @returns {string} the hash of the object
      */
-    hash(object: any, algorithm?: HashAlgorithm): string;
+    hashSync(object: any, algorithm?: HashAlgorithm): string;
     private setManyKeyv;
-    private hasManyKeyv;
     /**
      * Processes a single key from secondary store for getRaw operation
      * @param primary - the primary store to use

package/dist/index.d.ts

@@ -1,7 +1,5 @@
-import { WrapFunctionOptions, GetOrSetKey, GetOrSetFunctionOptions } from '@cacheable/memoize';
-export { GetOrSetFunctionOptions, GetOrSetKey, GetOrSetOptions, WrapOptions, WrapSyncOptions, getOrSet, wrap, wrapSync } from '@cacheable/memoize';
-import { Stats, CacheableItem, HashAlgorithm } from '@cacheable/utils';
-export { CacheableItem, Stats as CacheableStats, HashAlgorithm, calculateTtlFromExpiration, getCascadingTtl, hash, shorthandToMilliseconds, shorthandToTime } from '@cacheable/utils';
+import { Stats, CacheableItem, WrapFunctionOptions, GetOrSetKey, GetOrSetFunctionOptions, HashAlgorithm } from '@cacheable/utils';
+export { CacheableItem, Stats as CacheableStats, GetOrSetFunctionOptions, GetOrSetKey, GetOrSetOptions, HashAlgorithm, WrapOptions, WrapSyncOptions, calculateTtlFromExpiration, getCascadingTtl, getOrSet, hash, shorthandToMilliseconds, shorthandToTime, wrap, wrapSync } from '@cacheable/utils';
 import { Hookified, HookifiedOptions } from 'hookified';
 import { Keyv, KeyvStoreAdapter, StoredDataRaw } from 'keyv';
 export { Keyv, KeyvHooks, KeyvOptions, KeyvStoreAdapter } from 'keyv';
@@ -24,6 +22,11 @@ type CacheableSyncOptions = {
      * Qified instance or message provider(s) for synchronization
      */
     qified: Qified | MessageProvider | MessageProvider[];
+    /**
+     * The namespace for sync events. It can be a string or a function that returns a string.
+     * When set, event names will be prefixed with the namespace (e.g., "my-namespace::cache:set")
+     */
+    namespace?: string | (() => string);
 } & HookifiedOptions;
 type CacheableSyncItem = {
     cacheId: string;
@@ -37,6 +40,9 @@ type CacheableSyncItem = {
  */
 declare class CacheableSync extends Hookified {
     private _qified;
+    private _namespace?;
+    private _storage?;
+    private _cacheId?;
     /**
      * Creates an instance of CacheableSync
      * @param options - Configuration options for CacheableSync
@@ -52,6 +58,16 @@ declare class CacheableSync extends Hookified {
      * @param value - Either an existing Qified instance or MessageProvider(s)
      */
     set qified(value: Qified | MessageProvider | MessageProvider[]);
+    /**
+     * Gets the namespace for sync events
+     * @returns The namespace or undefined if not set
+     */
+    get namespace(): string | (() => string) | undefined;
+    /**
+     * Sets the namespace for sync events and resubscribes if needed
+     * @param namespace - The namespace string or function
+     */
+    set namespace(namespace: string | (() => string) | undefined);
     /**
      * Publishes a cache event to all the cache instances
      * @param data - The cache item data containing cacheId, key, value, and optional ttl
@@ -69,6 +85,17 @@ declare class CacheableSync extends Hookified {
      * @returns A Qified instance configured with the provided message provider(s)
      */
     createQified(value: Qified | MessageProvider | MessageProvider[]): Qified;
+    /**
+     * Gets the namespace prefix to use for event names
+     * @returns The resolved namespace string or undefined
+     */
+    private getNamespace;
+    /**
+     * Prefixes an event name with the namespace if one is set
+     * @param event - The event to prefix
+     * @returns The prefixed event name or the original event
+     */
+    private getPrefixedEvent;
 }
 
 type CacheableOptions = {
@@ -408,14 +435,24 @@ declare class Cacheable extends Hookified {
      */
     getOrSet<T>(key: GetOrSetKey, function_: () => Promise<T>, options?: GetOrSetFunctionOptions): Promise<T | undefined>;
     /**
-     * Will hash an object using the specified algorithm. The default algorithm is 'sha256'.
+     * Will hash an object asynchronously using the specified cryptographic algorithm.
+     * Use this for cryptographic algorithms (SHA-256, SHA-384, SHA-512).
+     * For non-cryptographic algorithms, use hashSync() for better performance.
+     * @param {any} object the object to hash
+     * @param {string} algorithm the hash algorithm to use. The default is 'SHA-256'
+     * @returns {Promise<string>} the hash of the object
+     */
+    hash(object: any, algorithm?: HashAlgorithm): Promise<string>;
+    /**
+     * Will hash an object synchronously using the specified non-cryptographic algorithm.
+     * Use this for non-cryptographic algorithms (DJB2, FNV1, MURMER, CRC32).
+     * For cryptographic algorithms, use hash() instead.
      * @param {any} object the object to hash
-     * @param {string} algorithm the hash algorithm to use. The default is 'sha256'
+     * @param {string} algorithm the hash algorithm to use. The default is 'djb2'
      * @returns {string} the hash of the object
      */
-    hash(object: any, algorithm?: HashAlgorithm): string;
+    hashSync(object: any, algorithm?: HashAlgorithm): string;
     private setManyKeyv;
-    private hasManyKeyv;
     /**
      * Processes a single key from secondary store for getRaw operation
      * @param primary - the primary store to use

package/dist/index.js

@@ -1,17 +1,16 @@
 // src/index.ts
-import {
-  getOrSet,
-  wrap
-} from "@cacheable/memoize";
 import { createKeyv } from "@cacheable/memory";
 import {
   Stats as CacheableStats,
   calculateTtlFromExpiration,
   getCascadingTtl,
+  getOrSet,
   HashAlgorithm,
   hash,
+  hashSync,
   isKeyvInstance,
-  shorthandToMilliseconds
+  shorthandToMilliseconds,
+  wrap
 } from "@cacheable/utils";
 import { Hookified as Hookified2 } from "hookified";
 import {
@@ -49,12 +48,16 @@ var CacheableSyncEvents = /* @__PURE__ */ ((CacheableSyncEvents2) => {
 })(CacheableSyncEvents || {});
 var CacheableSync = class extends Hookified {
   _qified = new Qified();
+  _namespace;
+  _storage;
+  _cacheId;
   /**
    * Creates an instance of CacheableSync
    * @param options - Configuration options for CacheableSync
    */
   constructor(options) {
     super(options);
+    this._namespace = options.namespace;
     this._qified = this.createQified(options.qified);
   }
   /**
@@ -71,12 +74,36 @@ var CacheableSync = class extends Hookified {
   set qified(value) {
     this._qified = this.createQified(value);
   }
+  /**
+   * Gets the namespace for sync events
+   * @returns The namespace or undefined if not set
+   */
+  get namespace() {
+    return this._namespace;
+  }
+  /**
+   * Sets the namespace for sync events and resubscribes if needed
+   * @param namespace - The namespace string or function
+   */
+  set namespace(namespace) {
+    if (this._storage && this._cacheId) {
+      const oldSetEvent = this.getPrefixedEvent("cache:set" /* SET */);
+      const oldDeleteEvent = this.getPrefixedEvent("cache:delete" /* DELETE */);
+      void this._qified.unsubscribe(oldSetEvent);
+      void this._qified.unsubscribe(oldDeleteEvent);
+    }
+    this._namespace = namespace;
+    if (this._storage && this._cacheId) {
+      this.subscribe(this._storage, this._cacheId);
+    }
+  }
   /**
    * Publishes a cache event to all the cache instances
    * @param data - The cache item data containing cacheId, key, value, and optional ttl
    */
   async publish(event, data) {
-    await this._qified.publish(event, {
+    const eventName = this.getPrefixedEvent(event);
+    await this._qified.publish(eventName, {
       id: crypto.randomUUID(),
       data
     });
@@ -87,7 +114,11 @@ var CacheableSync = class extends Hookified {
    * @param cacheId - The cache ID to identify this instance
    */
   subscribe(storage, cacheId) {
-    this._qified.subscribe("cache:set" /* SET */, {
+    this._storage = storage;
+    this._cacheId = cacheId;
+    const setEvent = this.getPrefixedEvent("cache:set" /* SET */);
+    const deleteEvent = this.getPrefixedEvent("cache:delete" /* DELETE */);
+    this._qified.subscribe(setEvent, {
       handler: async (message) => {
         const data = message.data;
         if (data.cacheId !== cacheId) {
@@ -95,7 +126,7 @@ var CacheableSync = class extends Hookified {
         }
       }
     });
-    this._qified.subscribe("cache:delete" /* DELETE */, {
+    this._qified.subscribe(deleteEvent, {
       handler: async (message) => {
         const data = message.data;
         if (data.cacheId !== cacheId) {
@@ -116,14 +147,28 @@ var CacheableSync = class extends Hookified {
     const providers = Array.isArray(value) ? value : [value];
     return new Qified({ messageProviders: providers });
   }
+  /**
+   * Gets the namespace prefix to use for event names
+   * @returns The resolved namespace string or undefined
+   */
+  getNamespace() {
+    if (typeof this._namespace === "function") {
+      return this._namespace();
+    }
+    return this._namespace;
+  }
+  /**
+   * Prefixes an event name with the namespace if one is set
+   * @param event - The event to prefix
+   * @returns The prefixed event name or the original event
+   */
+  getPrefixedEvent(event) {
+    const ns = this.getNamespace();
+    return ns ? `${ns}::${event}` : event;
+  }
 };
 
 // src/index.ts
-import {
-  getOrSet as getOrSet2,
-  wrap as wrap2,
-  wrapSync
-} from "@cacheable/memoize";
 import {
   CacheableMemory,
   createKeyv as createKeyv2,
@@ -132,11 +177,14 @@ import {
 import {
   calculateTtlFromExpiration as calculateTtlFromExpiration2,
   getCascadingTtl as getCascadingTtl2,
+  getOrSet as getOrSet2,
   HashAlgorithm as HashAlgorithm2,
   hash as hash2,
   Stats,
   shorthandToMilliseconds as shorthandToMilliseconds2,
-  shorthandToTime
+  shorthandToTime,
+  wrap as wrap2,
+  wrapSync
 } from "@cacheable/utils";
 import { Keyv as Keyv2, KeyvHooks } from "keyv";
 var Cacheable = class extends Hookified2 {
@@ -180,7 +228,10 @@ var Cacheable = class extends Hookified2 {
       }
     }
     if (options?.sync) {
-      this._sync = options.sync instanceof CacheableSync ? options.sync : new CacheableSync(options.sync);
+      this._sync = options.sync instanceof CacheableSync ? options.sync : new CacheableSync({
+        ...options.sync,
+        namespace: options.namespace
+      });
       this._sync.subscribe(this._primary, this._cacheId);
     }
   }
@@ -202,6 +253,9 @@ var Cacheable = class extends Hookified2 {
     if (this._secondary) {
       this._secondary.namespace = this.getNameSpace();
     }
+    if (this._sync) {
+      this._sync.namespace = namespace;
+    }
   }
   /**
    * The statistics for the cacheable instance
@@ -663,7 +717,7 @@ var Cacheable = class extends Hookified2 {
    * @returns {Promise<boolean[]>} Whether the keys exist
    */
   async hasMany(keys) {
-    const result = await this.hasManyKeyv(this._primary, keys);
+    const result = await this._primary.hasMany(keys);
     const missingKeys = [];
     for (const [i, key] of keys.entries()) {
       if (!result[i] && this._secondary) {
@@ -671,7 +725,7 @@ var Cacheable = class extends Hookified2 {
       }
     }
     if (missingKeys.length > 0 && this._secondary) {
-      const secondary = await this.hasManyKeyv(this._secondary, keys);
+      const secondary = await this._secondary.hasMany(keys);
       for (const [i, _key] of keys.entries()) {
         if (!result[i] && secondary[i]) {
           result[i] = secondary[i];
@@ -781,6 +835,7 @@ var Cacheable = class extends Hookified2 {
     if (this._secondary) {
       promises.push(this._secondary.disconnect());
     }
+    promises.push(this._sync?.qified.disconnect());
     await (this._nonBlocking ? Promise.race(promises) : Promise.all(promises));
   }
   /**
@@ -795,18 +850,16 @@ var Cacheable = class extends Hookified2 {
   wrap(function_, options) {
     const cacheAdapter = {
       get: async (key) => this.get(key),
+      /* v8 ignore next -- @preserve */
       has: async (key) => this.has(key),
-      // biome-ignore lint/suspicious/noExplicitAny: CacheInstance requires any type
       set: async (key, value, ttl) => {
         await this.set(key, value, ttl);
       },
-      /* c8 ignore start */
-      // biome-ignore lint/suspicious/noExplicitAny: CacheInstance interface
+      /* v8 ignore next -- @preserve */
       on: (event, listener) => {
         this.on(event, listener);
       },
-      /* c8 ignore stop */
-      // biome-ignore lint/suspicious/noExplicitAny: CacheInstance requires any type
+      /* v8 ignore next -- @preserve */
       emit: (event, ...args) => this.emit(event, ...args)
     };
     const wrapOptions = {
@@ -833,18 +886,15 @@ var Cacheable = class extends Hookified2 {
   async getOrSet(key, function_, options) {
     const cacheAdapter = {
       get: async (key2) => this.get(key2),
+      /* v8 ignore next -- @preserve */
       has: async (key2) => this.has(key2),
-      // biome-ignore lint/suspicious/noExplicitAny: CacheInstance requires any type
       set: async (key2, value, ttl) => {
         await this.set(key2, value, ttl);
       },
-      /* c8 ignore start */
-      // biome-ignore lint/suspicious/noExplicitAny: CacheInstance interface
+      /* v8 ignore next -- @preserve */
       on: (event, listener) => {
         this.on(event, listener);
       },
-      /* c8 ignore stop */
-      // biome-ignore lint/suspicious/noExplicitAny: CacheInstance requires any type
       emit: (event, ...args) => this.emit(event, ...args)
     };
     const getOrSetOptions = {
@@ -857,14 +907,26 @@ var Cacheable = class extends Hookified2 {
     return getOrSet(key, function_, getOrSetOptions);
   }
   /**
-   * Will hash an object using the specified algorithm. The default algorithm is 'sha256'.
+   * Will hash an object asynchronously using the specified cryptographic algorithm.
+   * Use this for cryptographic algorithms (SHA-256, SHA-384, SHA-512).
+   * For non-cryptographic algorithms, use hashSync() for better performance.
    * @param {any} object the object to hash
-   * @param {string} algorithm the hash algorithm to use. The default is 'sha256'
+   * @param {string} algorithm the hash algorithm to use. The default is 'SHA-256'
+   * @returns {Promise<string>} the hash of the object
+   */
+  async hash(object, algorithm = HashAlgorithm.SHA256) {
+    return hash(object, { algorithm });
+  }
+  /**
+   * Will hash an object synchronously using the specified non-cryptographic algorithm.
+   * Use this for non-cryptographic algorithms (DJB2, FNV1, MURMER, CRC32).
+   * For cryptographic algorithms, use hash() instead.
+   * @param {any} object the object to hash
+   * @param {string} algorithm the hash algorithm to use. The default is 'djb2'
    * @returns {string} the hash of the object
    */
-  hash(object, algorithm = HashAlgorithm.SHA256) {
-    const validAlgorithm = Object.values(HashAlgorithm).includes(algorithm) ? algorithm : HashAlgorithm.SHA256;
-    return hash(object, { algorithm: validAlgorithm });
+  hashSync(object, algorithm = HashAlgorithm.DJB2) {
+    return hashSync(object, { algorithm });
   }
   async setManyKeyv(keyv, items) {
     const entries = [];
@@ -875,13 +937,6 @@ var Cacheable = class extends Hookified2 {
     await keyv.setMany(entries);
     return true;
   }
-  async hasManyKeyv(keyv, keys) {
-    const promises = [];
-    for (const key of keys) {
-      promises.push(keyv.has(key));
-    }
-    return Promise.all(promises);
-  }
   /**
    * Processes a single key from secondary store for getRaw operation
    * @param primary - the primary store to use
@@ -1070,3 +1125,4 @@ export {
   wrap2 as wrap,
   wrapSync
 };
+/* v8 ignore next -- @preserve */

package/package.json

@@ -1,15 +1,21 @@
 {
   "name": "cacheable",
-  "version": "2.1.1",
+  "version": "2.3.0",
   "description": "High Performance Layer 1 / Layer 2 Caching with Keyv Storage",
   "type": "module",
-  "main": "./dist/index.cjs",
+  "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "require": "./dist/index.cjs",
-      "import": "./dist/index.js"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     }
   },
   "repository": {
@@ -21,26 +27,25 @@
   "license": "MIT",
   "private": false,
   "devDependencies": {
-    "@biomejs/biome": "^2.2.6",
+    "@biomejs/biome": "^2.3.5",
     "@faker-js/faker": "^10.1.0",
-    "@keyv/redis": "^5.1.3",
-    "@keyv/valkey": "^1.0.10",
-    "@qified/redis": "^0.5.0",
-    "@types/node": "^24.8.1",
-    "@vitest/coverage-v8": "^3.2.4",
+    "@keyv/redis": "^5.1.4",
+    "@keyv/valkey": "^1.0.11",
+    "@qified/redis": "^0.5.2",
+    "@types/node": "^24.10.1",
+    "@vitest/coverage-v8": "^4.0.9",
     "lru-cache": "^11.2.2",
-    "rimraf": "^6.0.1",
-    "tsup": "^8.5.0",
+    "rimraf": "^6.1.0",
+    "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "vitest": "^4.0.9"
   },
   "dependencies": {
-    "hookified": "^1.12.2",
-    "keyv": "^5.5.3",
-    "qified": "^0.5.0",
-    "@cacheable/memoize": "^2.0.3",
-    "@cacheable/memory": "^2.0.3",
-    "@cacheable/utils": "^2.1.0"
+    "hookified": "^1.13.0",
+    "keyv": "^5.5.4",
+    "qified": "^0.5.2",
+    "@cacheable/memory": "^2.0.6",
+    "@cacheable/utils": "^2.3.2"
   },
   "keywords": [
     "cacheable",