cacheable 2.1.1 → 2.2.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
 
@@ -517,7 +622,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 +650,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 +743,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 +783,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");
@@ -149,7 +148,6 @@ var CacheableSync = class extends import_hookified.Hookified {
 };
 
 // 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");
@@ -677,7 +675,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 +683,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 +793,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 +808,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 +829,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 +844,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 +862,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 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 = import_utils.HashAlgorithm.SHA256) {
+    return (0, import_utils.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 = 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 +895,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 +1084,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';
@@ -408,14 +406,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 'sha256'
+     * @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 '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';
@@ -408,14 +406,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 'sha256'
+     * @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 '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 {
@@ -119,11 +118,6 @@ var CacheableSync = class extends Hookified {
 };
 
 // src/index.ts
-import {
-  getOrSet as getOrSet2,
-  wrap as wrap2,
-  wrapSync
-} from "@cacheable/memoize";
 import {
   CacheableMemory,
   createKeyv as createKeyv2,
@@ -132,11 +126,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 {
@@ -663,7 +660,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 +668,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 +778,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 +793,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 +829,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 +850,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 '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 'sha256'
+   * @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 +880,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 +1068,4 @@ export {
   wrap2 as wrap,
   wrapSync
 };
+/* v8 ignore next -- @preserve */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cacheable",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "High Performance Layer 1 / Layer 2 Caching with Keyv Storage",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -21,26 +21,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.5",
+    "@cacheable/utils": "^2.3.0"
   },
   "keywords": [
     "cacheable",