keyv 5.2.2 → 5.3.0

package/README.md

@@ -144,7 +144,15 @@ await cache.get('foo'); // 'cache'
 
 # Events
 
-Keyv is a custom `EventEmitter` and will emit an `'error'` event if there is an error. In addition it will emit a `clear` and `disconnect` event when the corresponding methods are called.
+Keyv is a custom `EventEmitter` and will emit an `'error'` event if there is an error.
+If there is no listener for the `'error'` event, an uncaught exception will be thrown.
+To disable the `'error'` event, pass `emitErrors: false` in the constructor options.
+
+```js
+const keyv = new Keyv({ emitErrors: false });
+```
+
+In addition it will emit `clear` and `disconnect` events when the corresponding methods are called.
 
 ```js
 const keyv = new Keyv();
@@ -281,14 +289,30 @@ The following are third-party storage adapters compatible with Keyv:
 
 # Compression
 
-Keyv supports `gzip` and `brotli` compression. To enable compression, pass the `compress` option to the constructor.
+Keyv supports `gzip`, `brotli` and `lz4` compression. To enable compression, pass the `compress` option to the constructor.
 
 ```js
 import Keyv from 'keyv';
 import KeyvGzip from '@keyv/compress-gzip';
 
 const keyvGzip = new KeyvGzip();
-const keyv = new Keyv({ compression: KeyvGzip });
+const keyv = new Keyv({ compression: keyvGzip });
+```
+
+```js
+import Keyv from 'keyv';
+import KeyvBrotli from '@keyv/compress-brotli';
+
+const keyvBrotli = new KeyvBrotli();
+const keyv = new Keyv({ compression: keyvBrotli });
+```
+
+```js
+import Keyv from 'keyv';
+import KeyvLz4 from '@keyv/compress-lz4';
+
+const keyvLz4 = new KeyvLz4();
+const keyv = new Keyv({ compression: keyvLz4 });
 ```
 
 You can also pass a custom compression function to the `compression` option. Following the pattern of the official compression adapters.
@@ -399,10 +423,18 @@ By default keys are persistent. You can set an expiry TTL in milliseconds.
 
 Returns a promise which resolves to `true`.
 
+## .setMany(entries)
+
+Set multiple values using KeyvEntrys `{ key: string, value: any, ttl?: number }`.
+
 ## .get(key, [options])
 
 Returns a promise which resolves to the retrieved value.
 
+## .getMany(keys, [options])
+
+Returns a promise which resolves to an array of retrieved values.
+
 ### options.raw
 
 Type: `Boolean`<br />
@@ -418,6 +450,10 @@ Deletes an entry.
 
 Returns a promise which resolves to `true` if the key existed, `false` if not.
 
+## .deleteMany(keys)
+Deletes multiple entries.
+Returns a promise which resolves to an array of booleans indicating if the key existed or not.
+
 ## .clear()
 
 Delete all entries in the current namespace.

package/dist/index.cjs

@@ -18,13 +18,13 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   Keyv: () => Keyv,
   KeyvHooks: () => KeyvHooks,
-  default: () => src_default
+  default: () => index_default
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 var import_serialize = require("@keyv/serialize");
 
 // src/event-manager.ts
@@ -293,7 +293,7 @@ var Keyv = class extends event_manager_default {
       if (!this._isValidStorageAdapter(this._store)) {
         throw new Error("Invalid storage adapter");
       }
-      if (typeof this._store.on === "function" && this.opts.emitErrors) {
+      if (typeof this._store.on === "function") {
         this._store.on("error", (error) => this.emit("error", error));
       }
       this._store.namespace = this._namespace;
@@ -327,7 +327,7 @@ var Keyv = class extends event_manager_default {
     if (this._isValidStorageAdapter(store)) {
       this._store = store;
       this.opts.store = store;
-      if (typeof store.on === "function" && this.opts.emitErrors) {
+      if (typeof store.on === "function") {
         store.on("error", (error) => this.emit("error", error));
       }
       if (this._namespace) {
@@ -488,52 +488,10 @@ var Keyv = class extends event_manager_default {
     const keyPrefixed = isArray ? this._getKeyPrefixArray(key) : this._getKeyPrefix(key);
     const isDataExpired = (data) => typeof data.expires === "number" && Date.now() > data.expires;
     if (isArray) {
-      this.hooks.trigger("preGetMany" /* PRE_GET_MANY */, { keys: keyPrefixed });
-      if (store.getMany === void 0) {
-        const promises = keyPrefixed.map(async (key2) => {
-          const rawData3 = await store.get(key2);
-          const deserializedRow = typeof rawData3 === "string" || this.opts.compression ? await this.deserializeData(rawData3) : rawData3;
-          if (deserializedRow === void 0 || deserializedRow === null) {
-            return void 0;
-          }
-          if (isDataExpired(deserializedRow)) {
-            await this.delete(key2);
-            return void 0;
-          }
-          return options?.raw ? deserializedRow : deserializedRow.value;
-        });
-        const deserializedRows = await Promise.allSettled(promises);
-        const result2 = deserializedRows.map((row) => row.value);
-        this.hooks.trigger("postGetMany" /* POST_GET_MANY */, result2);
-        if (result2.length > 0) {
-          this.stats.hit();
-        }
-        return result2;
+      if (options?.raw === true) {
+        return this.getMany(key, { raw: true });
       }
-      const rawData2 = await store.getMany(keyPrefixed);
-      const result = [];
-      for (const index in rawData2) {
-        let row = rawData2[index];
-        if (typeof row === "string") {
-          row = await this.deserializeData(row);
-        }
-        if (row === void 0 || row === null) {
-          result.push(void 0);
-          continue;
-        }
-        if (isDataExpired(row)) {
-          await this.delete(key[index]);
-          result.push(void 0);
-          continue;
-        }
-        const value = options?.raw ? row : row.value;
-        result.push(value);
-      }
-      this.hooks.trigger("postGetMany" /* POST_GET_MANY */, result);
-      if (result.length > 0) {
-        this.stats.hit();
-      }
-      return result;
+      return this.getMany(key, { raw: false });
     }
     this.hooks.trigger("preGet" /* PRE_GET */, { key: keyPrefixed });
     const rawData = await store.get(keyPrefixed);
@@ -551,17 +509,64 @@ var Keyv = class extends event_manager_default {
     this.stats.hit();
     return options?.raw ? deserializedData : deserializedData.value;
   }
-  /**
-   * Set an item to the store
-   * @param {string} key the key to use
-   * @param {Value} value the value of the key
-   * @param {number} [ttl] time to live in milliseconds
-   * @returns {boolean} if it sets then it will return a true. On failure will return false.
-   */
+  async getMany(keys, options) {
+    const { store } = this.opts;
+    const keyPrefixed = this._getKeyPrefixArray(keys);
+    const isDataExpired = (data) => typeof data.expires === "number" && Date.now() > data.expires;
+    this.hooks.trigger("preGetMany" /* PRE_GET_MANY */, { keys: keyPrefixed });
+    if (store.getMany === void 0) {
+      const promises = keyPrefixed.map(async (key) => {
+        const rawData2 = await store.get(key);
+        const deserializedRow = typeof rawData2 === "string" || this.opts.compression ? await this.deserializeData(rawData2) : rawData2;
+        if (deserializedRow === void 0 || deserializedRow === null) {
+          return void 0;
+        }
+        if (isDataExpired(deserializedRow)) {
+          await this.delete(key);
+          return void 0;
+        }
+        return options?.raw ? deserializedRow : deserializedRow.value;
+      });
+      const deserializedRows = await Promise.allSettled(promises);
+      const result2 = deserializedRows.map((row) => row.value);
+      this.hooks.trigger("postGetMany" /* POST_GET_MANY */, result2);
+      if (result2.length > 0) {
+        this.stats.hit();
+      }
+      return result2;
+    }
+    const rawData = await store.getMany(keyPrefixed);
+    const result = [];
+    for (const index in rawData) {
+      let row = rawData[index];
+      if (typeof row === "string") {
+        row = await this.deserializeData(row);
+      }
+      if (row === void 0 || row === null) {
+        result.push(void 0);
+        continue;
+      }
+      if (isDataExpired(row)) {
+        await this.delete(keys[index]);
+        result.push(void 0);
+        continue;
+      }
+      const value = options?.raw ? row : row.value;
+      result.push(value);
+    }
+    this.hooks.trigger("postGetMany" /* POST_GET_MANY */, result);
+    if (result.length > 0) {
+      this.stats.hit();
+    }
+    return result;
+  }
   async set(key, value, ttl) {
+    if (Array.isArray(key)) {
+      return this.setMany(key);
+    }
     this.hooks.trigger("preSet" /* PRE_SET */, { key, value, ttl });
     const keyPrefixed = this._getKeyPrefix(key);
-    if (typeof ttl === "undefined") {
+    if (ttl === void 0) {
       ttl = this._ttl;
     }
     if (ttl === 0) {
@@ -576,7 +581,10 @@ var Keyv = class extends event_manager_default {
     const serializedValue = await this.serializeData(formattedValue);
     let result = true;
     try {
-      await store.set(keyPrefixed, serializedValue, ttl);
+      const value2 = await store.set(keyPrefixed, serializedValue, ttl);
+      if (typeof value2 === "boolean") {
+        result = value2;
+      }
     } catch (error) {
       result = false;
       this.emit("error", error);
@@ -585,6 +593,30 @@ var Keyv = class extends event_manager_default {
     this.stats.set();
     return result;
   }
+  /**
+   * Set many items to the store
+   * @param {Array<KeyvEntry>} entries the entries to set
+   * @returns {boolean[]} will return an array of booleans if it sets then it will return a true. On failure will return false.
+   */
+  async setMany(entries) {
+    let results = [];
+    try {
+      if (this._store.setMany !== void 0) {
+        results = await this._store.setMany(entries);
+        return results;
+      }
+      const promises = [];
+      for (const entry of entries) {
+        promises.push(this.set(entry.key, entry.value, entry.ttl));
+      }
+      const promiseResults = await Promise.allSettled(promises);
+      results = promiseResults.map((result) => result.value);
+    } catch (error) {
+      this.emit("error", error);
+      results = entries.map(() => false);
+    }
+    return results;
+  }
   /**
    * Delete an Entry
    * @param {string | string[]} key the key to be deleted. if an array it will delete many items
@@ -593,24 +625,47 @@ var Keyv = class extends event_manager_default {
   async delete(key) {
     const { store } = this.opts;
     if (Array.isArray(key)) {
-      const keyPrefixed2 = this._getKeyPrefixArray(key);
-      this.hooks.trigger("preDelete" /* PRE_DELETE */, { key: keyPrefixed2 });
-      if (store.deleteMany !== void 0) {
-        return store.deleteMany(keyPrefixed2);
-      }
-      const promises = keyPrefixed2.map(async (key2) => store.delete(key2));
-      const results = await Promise.allSettled(promises);
-      const returnResult = results.every((x) => x.value === true);
-      this.hooks.trigger("postDelete" /* POST_DELETE */, { key: keyPrefixed2, value: returnResult });
-      return returnResult;
+      return this.deleteMany(key);
     }
     const keyPrefixed = this._getKeyPrefix(key);
     this.hooks.trigger("preDelete" /* PRE_DELETE */, { key: keyPrefixed });
-    const result = await store.delete(keyPrefixed);
+    let result = true;
+    try {
+      const value = await store.delete(keyPrefixed);
+      if (typeof value === "boolean") {
+        result = value;
+      }
+    } catch (error) {
+      result = false;
+      this.emit("error", error);
+    }
     this.hooks.trigger("postDelete" /* POST_DELETE */, { key: keyPrefixed, value: result });
     this.stats.delete();
     return result;
   }
+  /**
+   * Delete many items from the store
+   * @param {string[]} keys the keys to be deleted
+   * @returns {boolean} will return true if item or items are deleted. false if there is an error
+   */
+  async deleteMany(keys) {
+    try {
+      const { store } = this.opts;
+      const keyPrefixed = this._getKeyPrefixArray(keys);
+      this.hooks.trigger("preDelete" /* PRE_DELETE */, { key: keyPrefixed });
+      if (store.deleteMany !== void 0) {
+        return await store.deleteMany(keyPrefixed);
+      }
+      const promises = keyPrefixed.map(async (key) => store.delete(key));
+      const results = await Promise.allSettled(promises);
+      const returnResult = results.every((x) => x.value === true);
+      this.hooks.trigger("postDelete" /* POST_DELETE */, { key: keyPrefixed, value: returnResult });
+      return returnResult;
+    } catch (error) {
+      this.emit("error", error);
+      return false;
+    }
+  }
   /**
    * Clear the store
    * @returns {void}
@@ -618,20 +673,27 @@ var Keyv = class extends event_manager_default {
   async clear() {
     this.emit("clear");
     const { store } = this.opts;
-    await store.clear();
+    try {
+      await store.clear();
+    } catch (error) {
+      this.emit("error", error);
+    }
   }
-  /**
-   * Has a key
-   * @param {string} key the key to check
-   * @returns {boolean} will return true if the key exists
-   */
   async has(key) {
+    if (Array.isArray(key)) {
+      return this.hasMany(key);
+    }
     const keyPrefixed = this._getKeyPrefix(key);
     const { store } = this.opts;
     if (store.has !== void 0 && !(store instanceof Map)) {
       return store.has(keyPrefixed);
     }
-    const rawData = await store.get(keyPrefixed);
+    let rawData;
+    try {
+      rawData = await store.get(keyPrefixed);
+    } catch (error) {
+      this.emit("error", error);
+    }
     if (rawData) {
       const data = await this.deserializeData(rawData);
       if (data) {
@@ -643,6 +705,23 @@ var Keyv = class extends event_manager_default {
     }
     return false;
   }
+  /**
+   * Check if many keys exist
+   * @param {string[]} keys the keys to check
+   * @returns {boolean[]} will return an array of booleans if the keys exist
+   */
+  async hasMany(keys) {
+    const keyPrefixed = this._getKeyPrefixArray(keys);
+    const { store } = this.opts;
+    if (store.hasMany !== void 0) {
+      return store.hasMany(keyPrefixed);
+    }
+    const results = [];
+    for (const key of keyPrefixed) {
+      results.push(await this.has(key));
+    }
+    return results;
+  }
   /**
    * Will disconnect the store. This is only available if the store has a disconnect method
    * @returns {Promise<void>}
@@ -654,6 +733,12 @@ var Keyv = class extends event_manager_default {
       return store.disconnect();
     }
   }
+  emit(event, ...arguments_) {
+    if (event === "error" && !this.opts.emitErrors) {
+      return;
+    }
+    super.emit(event, ...arguments_);
+  }
   async serializeData(data) {
     if (!this._serialize) {
       return data;
@@ -677,7 +762,7 @@ var Keyv = class extends event_manager_default {
     return void 0;
   }
 };
-var src_default = Keyv;
+var index_default = Keyv;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Keyv,

package/dist/index.d.cts

@@ -44,12 +44,12 @@ type DeserializedData<Value> = {
     value?: Value;
     expires?: number | null;
 };
-interface CompressionAdapter {
+type CompressionAdapter = {
     compress(value: any, options?: any): Promise<any>;
     decompress(value: any, options?: any): Promise<any>;
     serialize<Value>(data: DeserializedData<Value>): Promise<string> | string;
     deserialize<Value>(data: string): Promise<DeserializedData<Value> | undefined> | DeserializedData<Value> | undefined;
-}
+};
 type Serialize = <Value>(data: DeserializedData<Value>) => Promise<string> | string;
 type Deserialize = <Value>(data: string) => Promise<DeserializedData<Value> | undefined> | DeserializedData<Value> | undefined;
 declare enum KeyvHooks {
@@ -62,13 +62,27 @@ declare enum KeyvHooks {
     PRE_DELETE = "preDelete",
     POST_DELETE = "postDelete"
 }
+type KeyvEntry = {
+    /**
+     * Key to set.
+     */
+    key: string;
+    /**
+     * Value to set.
+     */
+    value: any;
+    /**
+     * Time to live in milliseconds.
+     */
+    ttl?: number;
+};
 type StoredDataNoRaw<Value> = Value | undefined;
 type StoredDataRaw<Value> = DeserializedData<Value> | undefined;
 type StoredData<Value> = StoredDataNoRaw<Value> | StoredDataRaw<Value>;
-interface IEventEmitter {
-    on(event: string, listener: (...arguments_: any[]) => void): this;
-}
-interface KeyvStoreAdapter extends IEventEmitter {
+type IEventEmitter = {
+    on(event: string, listener: (...arguments_: any[]) => void): IEventEmitter;
+};
+type KeyvStoreAdapter = {
     opts: any;
     namespace?: string;
     get<Value>(key: string): Promise<StoredData<Value> | undefined>;
@@ -76,11 +90,13 @@ interface KeyvStoreAdapter extends IEventEmitter {
     delete(key: string): Promise<boolean>;
     clear(): Promise<void>;
     has?(key: string): Promise<boolean>;
+    hasMany?(keys: string[]): Promise<boolean[]>;
     getMany?<Value>(keys: string[]): Promise<Array<StoredData<Value | undefined>>>;
     disconnect?(): Promise<void>;
     deleteMany?(key: string[]): Promise<boolean>;
+    setMany?(data: KeyvEntry[]): Promise<boolean[]>;
     iterator?<Value>(namespace?: string): AsyncGenerator<Array<string | Awaited<Value> | undefined>, void>;
-}
+} & IEventEmitter;
 type KeyvOptions = {
     /** Emit errors */
     emitErrors?: boolean;
@@ -216,7 +232,7 @@ declare class Keyv<GenericValue = any> extends EventManager {
     /**
      * Get the Value of a Key
      * @param {string | string[]} key passing in a single key or multiple as an array
-     * @param [options] can pass in to return the raw value by setting { raw: true }
+     * @param {{raw: boolean} | undefined} options can pass in to return the raw value by setting { raw: true }
      */
     get<Value = GenericValue>(key: string, options?: {
         raw: false;
@@ -230,20 +246,44 @@ declare class Keyv<GenericValue = any> extends EventManager {
     get<Value = GenericValue>(key: string[], options?: {
         raw: true;
     }): Promise<Array<StoredDataRaw<Value>>>;
+    /**
+     * Get many values of keys
+     * @param {string[]} keys passing in a single key or multiple as an array
+     * @param {{raw: boolean} | undefined} options can pass in to return the raw value by setting { raw: true }
+     */
+    getMany<Value = GenericValue>(keys: string[], options?: {
+        raw: false;
+    }): Promise<Array<StoredDataNoRaw<Value>>>;
+    getMany<Value = GenericValue>(keys: string[], options?: {
+        raw: true;
+    }): Promise<Array<StoredDataRaw<Value>>>;
     /**
      * Set an item to the store
-     * @param {string} key the key to use
+     * @param {string | Array<KeyvEntry>} key the key to use. If you pass in an array of KeyvEntry it will set many items
      * @param {Value} value the value of the key
      * @param {number} [ttl] time to live in milliseconds
      * @returns {boolean} if it sets then it will return a true. On failure will return false.
      */
+    set<Value = GenericValue>(key: KeyvEntry[]): Promise<boolean[]>;
     set<Value = GenericValue>(key: string, value: Value, ttl?: number): Promise<boolean>;
+    /**
+     * Set many items to the store
+     * @param {Array<KeyvEntry>} entries the entries to set
+     * @returns {boolean[]} will return an array of booleans if it sets then it will return a true. On failure will return false.
+     */
+    setMany<Value = GenericValue>(entries: KeyvEntry[]): Promise<boolean[]>;
     /**
      * Delete an Entry
      * @param {string | string[]} key the key to be deleted. if an array it will delete many items
      * @returns {boolean} will return true if item or items are deleted. false if there is an error
      */
     delete(key: string | string[]): Promise<boolean>;
+    /**
+     * Delete many items from the store
+     * @param {string[]} keys the keys to be deleted
+     * @returns {boolean} will return true if item or items are deleted. false if there is an error
+     */
+    deleteMany(keys: string[]): Promise<boolean>;
     /**
      * Clear the store
      * @returns {void}
@@ -254,14 +294,22 @@ declare class Keyv<GenericValue = any> extends EventManager {
      * @param {string} key the key to check
      * @returns {boolean} will return true if the key exists
      */
+    has(key: string[]): Promise<boolean[]>;
     has(key: string): Promise<boolean>;
+    /**
+     * Check if many keys exist
+     * @param {string[]} keys the keys to check
+     * @returns {boolean[]} will return an array of booleans if the keys exist
+     */
+    hasMany(keys: string[]): Promise<boolean[]>;
     /**
      * Will disconnect the store. This is only available if the store has a disconnect method
      * @returns {Promise<void>}
      */
     disconnect(): Promise<void>;
+    emit(event: string, ...arguments_: any[]): void;
     serializeData<T>(data: DeserializedData<T>): Promise<string | DeserializedData<T>>;
     deserializeData<T>(data: string | DeserializedData<T>): Promise<DeserializedData<T> | undefined>;
 }
 
-export { type CompressionAdapter, type Deserialize, type DeserializedData, type IEventEmitter, Keyv, KeyvHooks, type KeyvOptions, type KeyvStoreAdapter, type Serialize, type StoredData, type StoredDataNoRaw, type StoredDataRaw, Keyv as default };
+export { type CompressionAdapter, type Deserialize, type DeserializedData, type IEventEmitter, Keyv, type KeyvEntry, KeyvHooks, type KeyvOptions, type KeyvStoreAdapter, type Serialize, type StoredData, type StoredDataNoRaw, type StoredDataRaw, Keyv as default };

package/dist/index.d.ts

@@ -44,12 +44,12 @@ type DeserializedData<Value> = {
     value?: Value;
     expires?: number | null;
 };
-interface CompressionAdapter {
+type CompressionAdapter = {
     compress(value: any, options?: any): Promise<any>;
     decompress(value: any, options?: any): Promise<any>;
     serialize<Value>(data: DeserializedData<Value>): Promise<string> | string;
     deserialize<Value>(data: string): Promise<DeserializedData<Value> | undefined> | DeserializedData<Value> | undefined;
-}
+};
 type Serialize = <Value>(data: DeserializedData<Value>) => Promise<string> | string;
 type Deserialize = <Value>(data: string) => Promise<DeserializedData<Value> | undefined> | DeserializedData<Value> | undefined;
 declare enum KeyvHooks {
@@ -62,13 +62,27 @@ declare enum KeyvHooks {
     PRE_DELETE = "preDelete",
     POST_DELETE = "postDelete"
 }
+type KeyvEntry = {
+    /**
+     * Key to set.
+     */
+    key: string;
+    /**
+     * Value to set.
+     */
+    value: any;
+    /**
+     * Time to live in milliseconds.
+     */
+    ttl?: number;
+};
 type StoredDataNoRaw<Value> = Value | undefined;
 type StoredDataRaw<Value> = DeserializedData<Value> | undefined;
 type StoredData<Value> = StoredDataNoRaw<Value> | StoredDataRaw<Value>;
-interface IEventEmitter {
-    on(event: string, listener: (...arguments_: any[]) => void): this;
-}
-interface KeyvStoreAdapter extends IEventEmitter {
+type IEventEmitter = {
+    on(event: string, listener: (...arguments_: any[]) => void): IEventEmitter;
+};
+type KeyvStoreAdapter = {
     opts: any;
     namespace?: string;
     get<Value>(key: string): Promise<StoredData<Value> | undefined>;
@@ -76,11 +90,13 @@ interface KeyvStoreAdapter extends IEventEmitter {
     delete(key: string): Promise<boolean>;
     clear(): Promise<void>;
     has?(key: string): Promise<boolean>;
+    hasMany?(keys: string[]): Promise<boolean[]>;
     getMany?<Value>(keys: string[]): Promise<Array<StoredData<Value | undefined>>>;
     disconnect?(): Promise<void>;
     deleteMany?(key: string[]): Promise<boolean>;
+    setMany?(data: KeyvEntry[]): Promise<boolean[]>;
     iterator?<Value>(namespace?: string): AsyncGenerator<Array<string | Awaited<Value> | undefined>, void>;
-}
+} & IEventEmitter;
 type KeyvOptions = {
     /** Emit errors */
     emitErrors?: boolean;
@@ -216,7 +232,7 @@ declare class Keyv<GenericValue = any> extends EventManager {
     /**
      * Get the Value of a Key
      * @param {string | string[]} key passing in a single key or multiple as an array
-     * @param [options] can pass in to return the raw value by setting { raw: true }
+     * @param {{raw: boolean} | undefined} options can pass in to return the raw value by setting { raw: true }
      */
     get<Value = GenericValue>(key: string, options?: {
         raw: false;
@@ -230,20 +246,44 @@ declare class Keyv<GenericValue = any> extends EventManager {
     get<Value = GenericValue>(key: string[], options?: {
         raw: true;
     }): Promise<Array<StoredDataRaw<Value>>>;
+    /**
+     * Get many values of keys
+     * @param {string[]} keys passing in a single key or multiple as an array
+     * @param {{raw: boolean} | undefined} options can pass in to return the raw value by setting { raw: true }
+     */
+    getMany<Value = GenericValue>(keys: string[], options?: {
+        raw: false;
+    }): Promise<Array<StoredDataNoRaw<Value>>>;
+    getMany<Value = GenericValue>(keys: string[], options?: {
+        raw: true;
+    }): Promise<Array<StoredDataRaw<Value>>>;
     /**
      * Set an item to the store
-     * @param {string} key the key to use
+     * @param {string | Array<KeyvEntry>} key the key to use. If you pass in an array of KeyvEntry it will set many items
      * @param {Value} value the value of the key
      * @param {number} [ttl] time to live in milliseconds
      * @returns {boolean} if it sets then it will return a true. On failure will return false.
      */
+    set<Value = GenericValue>(key: KeyvEntry[]): Promise<boolean[]>;
     set<Value = GenericValue>(key: string, value: Value, ttl?: number): Promise<boolean>;
+    /**
+     * Set many items to the store
+     * @param {Array<KeyvEntry>} entries the entries to set
+     * @returns {boolean[]} will return an array of booleans if it sets then it will return a true. On failure will return false.
+     */
+    setMany<Value = GenericValue>(entries: KeyvEntry[]): Promise<boolean[]>;
     /**
      * Delete an Entry
      * @param {string | string[]} key the key to be deleted. if an array it will delete many items
      * @returns {boolean} will return true if item or items are deleted. false if there is an error
      */
     delete(key: string | string[]): Promise<boolean>;
+    /**
+     * Delete many items from the store
+     * @param {string[]} keys the keys to be deleted
+     * @returns {boolean} will return true if item or items are deleted. false if there is an error
+     */
+    deleteMany(keys: string[]): Promise<boolean>;
     /**
      * Clear the store
      * @returns {void}
@@ -254,14 +294,22 @@ declare class Keyv<GenericValue = any> extends EventManager {
      * @param {string} key the key to check
      * @returns {boolean} will return true if the key exists
      */
+    has(key: string[]): Promise<boolean[]>;
     has(key: string): Promise<boolean>;
+    /**
+     * Check if many keys exist
+     * @param {string[]} keys the keys to check
+     * @returns {boolean[]} will return an array of booleans if the keys exist
+     */
+    hasMany(keys: string[]): Promise<boolean[]>;
     /**
      * Will disconnect the store. This is only available if the store has a disconnect method
      * @returns {Promise<void>}
      */
     disconnect(): Promise<void>;
+    emit(event: string, ...arguments_: any[]): void;
     serializeData<T>(data: DeserializedData<T>): Promise<string | DeserializedData<T>>;
     deserializeData<T>(data: string | DeserializedData<T>): Promise<DeserializedData<T> | undefined>;
 }
 
-export { type CompressionAdapter, type Deserialize, type DeserializedData, type IEventEmitter, Keyv, KeyvHooks, type KeyvOptions, type KeyvStoreAdapter, type Serialize, type StoredData, type StoredDataNoRaw, type StoredDataRaw, Keyv as default };
+export { type CompressionAdapter, type Deserialize, type DeserializedData, type IEventEmitter, Keyv, type KeyvEntry, KeyvHooks, type KeyvOptions, type KeyvStoreAdapter, type Serialize, type StoredData, type StoredDataNoRaw, type StoredDataRaw, Keyv as default };

package/dist/index.js

@@ -267,7 +267,7 @@ var Keyv = class extends event_manager_default {
       if (!this._isValidStorageAdapter(this._store)) {
         throw new Error("Invalid storage adapter");
       }
-      if (typeof this._store.on === "function" && this.opts.emitErrors) {
+      if (typeof this._store.on === "function") {
         this._store.on("error", (error) => this.emit("error", error));
       }
       this._store.namespace = this._namespace;
@@ -301,7 +301,7 @@ var Keyv = class extends event_manager_default {
     if (this._isValidStorageAdapter(store)) {
       this._store = store;
       this.opts.store = store;
-      if (typeof store.on === "function" && this.opts.emitErrors) {
+      if (typeof store.on === "function") {
         store.on("error", (error) => this.emit("error", error));
       }
       if (this._namespace) {
@@ -462,52 +462,10 @@ var Keyv = class extends event_manager_default {
     const keyPrefixed = isArray ? this._getKeyPrefixArray(key) : this._getKeyPrefix(key);
     const isDataExpired = (data) => typeof data.expires === "number" && Date.now() > data.expires;
     if (isArray) {
-      this.hooks.trigger("preGetMany" /* PRE_GET_MANY */, { keys: keyPrefixed });
-      if (store.getMany === void 0) {
-        const promises = keyPrefixed.map(async (key2) => {
-          const rawData3 = await store.get(key2);
-          const deserializedRow = typeof rawData3 === "string" || this.opts.compression ? await this.deserializeData(rawData3) : rawData3;
-          if (deserializedRow === void 0 || deserializedRow === null) {
-            return void 0;
-          }
-          if (isDataExpired(deserializedRow)) {
-            await this.delete(key2);
-            return void 0;
-          }
-          return options?.raw ? deserializedRow : deserializedRow.value;
-        });
-        const deserializedRows = await Promise.allSettled(promises);
-        const result2 = deserializedRows.map((row) => row.value);
-        this.hooks.trigger("postGetMany" /* POST_GET_MANY */, result2);
-        if (result2.length > 0) {
-          this.stats.hit();
-        }
-        return result2;
+      if (options?.raw === true) {
+        return this.getMany(key, { raw: true });
       }
-      const rawData2 = await store.getMany(keyPrefixed);
-      const result = [];
-      for (const index in rawData2) {
-        let row = rawData2[index];
-        if (typeof row === "string") {
-          row = await this.deserializeData(row);
-        }
-        if (row === void 0 || row === null) {
-          result.push(void 0);
-          continue;
-        }
-        if (isDataExpired(row)) {
-          await this.delete(key[index]);
-          result.push(void 0);
-          continue;
-        }
-        const value = options?.raw ? row : row.value;
-        result.push(value);
-      }
-      this.hooks.trigger("postGetMany" /* POST_GET_MANY */, result);
-      if (result.length > 0) {
-        this.stats.hit();
-      }
-      return result;
+      return this.getMany(key, { raw: false });
     }
     this.hooks.trigger("preGet" /* PRE_GET */, { key: keyPrefixed });
     const rawData = await store.get(keyPrefixed);
@@ -525,17 +483,64 @@ var Keyv = class extends event_manager_default {
     this.stats.hit();
     return options?.raw ? deserializedData : deserializedData.value;
   }
-  /**
-   * Set an item to the store
-   * @param {string} key the key to use
-   * @param {Value} value the value of the key
-   * @param {number} [ttl] time to live in milliseconds
-   * @returns {boolean} if it sets then it will return a true. On failure will return false.
-   */
+  async getMany(keys, options) {
+    const { store } = this.opts;
+    const keyPrefixed = this._getKeyPrefixArray(keys);
+    const isDataExpired = (data) => typeof data.expires === "number" && Date.now() > data.expires;
+    this.hooks.trigger("preGetMany" /* PRE_GET_MANY */, { keys: keyPrefixed });
+    if (store.getMany === void 0) {
+      const promises = keyPrefixed.map(async (key) => {
+        const rawData2 = await store.get(key);
+        const deserializedRow = typeof rawData2 === "string" || this.opts.compression ? await this.deserializeData(rawData2) : rawData2;
+        if (deserializedRow === void 0 || deserializedRow === null) {
+          return void 0;
+        }
+        if (isDataExpired(deserializedRow)) {
+          await this.delete(key);
+          return void 0;
+        }
+        return options?.raw ? deserializedRow : deserializedRow.value;
+      });
+      const deserializedRows = await Promise.allSettled(promises);
+      const result2 = deserializedRows.map((row) => row.value);
+      this.hooks.trigger("postGetMany" /* POST_GET_MANY */, result2);
+      if (result2.length > 0) {
+        this.stats.hit();
+      }
+      return result2;
+    }
+    const rawData = await store.getMany(keyPrefixed);
+    const result = [];
+    for (const index in rawData) {
+      let row = rawData[index];
+      if (typeof row === "string") {
+        row = await this.deserializeData(row);
+      }
+      if (row === void 0 || row === null) {
+        result.push(void 0);
+        continue;
+      }
+      if (isDataExpired(row)) {
+        await this.delete(keys[index]);
+        result.push(void 0);
+        continue;
+      }
+      const value = options?.raw ? row : row.value;
+      result.push(value);
+    }
+    this.hooks.trigger("postGetMany" /* POST_GET_MANY */, result);
+    if (result.length > 0) {
+      this.stats.hit();
+    }
+    return result;
+  }
   async set(key, value, ttl) {
+    if (Array.isArray(key)) {
+      return this.setMany(key);
+    }
     this.hooks.trigger("preSet" /* PRE_SET */, { key, value, ttl });
     const keyPrefixed = this._getKeyPrefix(key);
-    if (typeof ttl === "undefined") {
+    if (ttl === void 0) {
       ttl = this._ttl;
     }
     if (ttl === 0) {
@@ -550,7 +555,10 @@ var Keyv = class extends event_manager_default {
     const serializedValue = await this.serializeData(formattedValue);
     let result = true;
     try {
-      await store.set(keyPrefixed, serializedValue, ttl);
+      const value2 = await store.set(keyPrefixed, serializedValue, ttl);
+      if (typeof value2 === "boolean") {
+        result = value2;
+      }
     } catch (error) {
       result = false;
       this.emit("error", error);
@@ -559,6 +567,30 @@ var Keyv = class extends event_manager_default {
     this.stats.set();
     return result;
   }
+  /**
+   * Set many items to the store
+   * @param {Array<KeyvEntry>} entries the entries to set
+   * @returns {boolean[]} will return an array of booleans if it sets then it will return a true. On failure will return false.
+   */
+  async setMany(entries) {
+    let results = [];
+    try {
+      if (this._store.setMany !== void 0) {
+        results = await this._store.setMany(entries);
+        return results;
+      }
+      const promises = [];
+      for (const entry of entries) {
+        promises.push(this.set(entry.key, entry.value, entry.ttl));
+      }
+      const promiseResults = await Promise.allSettled(promises);
+      results = promiseResults.map((result) => result.value);
+    } catch (error) {
+      this.emit("error", error);
+      results = entries.map(() => false);
+    }
+    return results;
+  }
   /**
    * Delete an Entry
    * @param {string | string[]} key the key to be deleted. if an array it will delete many items
@@ -567,24 +599,47 @@ var Keyv = class extends event_manager_default {
   async delete(key) {
     const { store } = this.opts;
     if (Array.isArray(key)) {
-      const keyPrefixed2 = this._getKeyPrefixArray(key);
-      this.hooks.trigger("preDelete" /* PRE_DELETE */, { key: keyPrefixed2 });
-      if (store.deleteMany !== void 0) {
-        return store.deleteMany(keyPrefixed2);
-      }
-      const promises = keyPrefixed2.map(async (key2) => store.delete(key2));
-      const results = await Promise.allSettled(promises);
-      const returnResult = results.every((x) => x.value === true);
-      this.hooks.trigger("postDelete" /* POST_DELETE */, { key: keyPrefixed2, value: returnResult });
-      return returnResult;
+      return this.deleteMany(key);
     }
     const keyPrefixed = this._getKeyPrefix(key);
     this.hooks.trigger("preDelete" /* PRE_DELETE */, { key: keyPrefixed });
-    const result = await store.delete(keyPrefixed);
+    let result = true;
+    try {
+      const value = await store.delete(keyPrefixed);
+      if (typeof value === "boolean") {
+        result = value;
+      }
+    } catch (error) {
+      result = false;
+      this.emit("error", error);
+    }
     this.hooks.trigger("postDelete" /* POST_DELETE */, { key: keyPrefixed, value: result });
     this.stats.delete();
     return result;
   }
+  /**
+   * Delete many items from the store
+   * @param {string[]} keys the keys to be deleted
+   * @returns {boolean} will return true if item or items are deleted. false if there is an error
+   */
+  async deleteMany(keys) {
+    try {
+      const { store } = this.opts;
+      const keyPrefixed = this._getKeyPrefixArray(keys);
+      this.hooks.trigger("preDelete" /* PRE_DELETE */, { key: keyPrefixed });
+      if (store.deleteMany !== void 0) {
+        return await store.deleteMany(keyPrefixed);
+      }
+      const promises = keyPrefixed.map(async (key) => store.delete(key));
+      const results = await Promise.allSettled(promises);
+      const returnResult = results.every((x) => x.value === true);
+      this.hooks.trigger("postDelete" /* POST_DELETE */, { key: keyPrefixed, value: returnResult });
+      return returnResult;
+    } catch (error) {
+      this.emit("error", error);
+      return false;
+    }
+  }
   /**
    * Clear the store
    * @returns {void}
@@ -592,20 +647,27 @@ var Keyv = class extends event_manager_default {
   async clear() {
     this.emit("clear");
     const { store } = this.opts;
-    await store.clear();
+    try {
+      await store.clear();
+    } catch (error) {
+      this.emit("error", error);
+    }
   }
-  /**
-   * Has a key
-   * @param {string} key the key to check
-   * @returns {boolean} will return true if the key exists
-   */
   async has(key) {
+    if (Array.isArray(key)) {
+      return this.hasMany(key);
+    }
     const keyPrefixed = this._getKeyPrefix(key);
     const { store } = this.opts;
     if (store.has !== void 0 && !(store instanceof Map)) {
       return store.has(keyPrefixed);
     }
-    const rawData = await store.get(keyPrefixed);
+    let rawData;
+    try {
+      rawData = await store.get(keyPrefixed);
+    } catch (error) {
+      this.emit("error", error);
+    }
     if (rawData) {
       const data = await this.deserializeData(rawData);
       if (data) {
@@ -617,6 +679,23 @@ var Keyv = class extends event_manager_default {
     }
     return false;
   }
+  /**
+   * Check if many keys exist
+   * @param {string[]} keys the keys to check
+   * @returns {boolean[]} will return an array of booleans if the keys exist
+   */
+  async hasMany(keys) {
+    const keyPrefixed = this._getKeyPrefixArray(keys);
+    const { store } = this.opts;
+    if (store.hasMany !== void 0) {
+      return store.hasMany(keyPrefixed);
+    }
+    const results = [];
+    for (const key of keyPrefixed) {
+      results.push(await this.has(key));
+    }
+    return results;
+  }
   /**
    * Will disconnect the store. This is only available if the store has a disconnect method
    * @returns {Promise<void>}
@@ -628,6 +707,12 @@ var Keyv = class extends event_manager_default {
       return store.disconnect();
     }
   }
+  emit(event, ...arguments_) {
+    if (event === "error" && !this.opts.emitErrors) {
+      return;
+    }
+    super.emit(event, ...arguments_);
+  }
   async serializeData(data) {
     if (!this._serialize) {
       return data;
@@ -651,9 +736,9 @@ var Keyv = class extends event_manager_default {
     return void 0;
   }
 };
-var src_default = Keyv;
+var index_default = Keyv;
 export {
   Keyv,
   KeyvHooks,
-  src_default as default
+  index_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "keyv",
-  "version": "5.2.2",
+  "version": "5.3.0",
   "description": "Simple key-value storage with support for multiple backends",
   "type": "module",
   "main": "dist/index.cjs",
@@ -14,27 +14,12 @@
   },
   "xo": {
     "rules": {
-      "import/no-named-as-default": "off",
-      "unicorn/prefer-module": "off",
-      "unicorn/prefer-node-protocol": "off",
-      "@typescript-eslint/consistent-type-definitions": "off",
-      "unicorn/no-typeof-undefined": "off",
-      "unicorn/prefer-event-target": "off",
-      "import/no-extraneous-dependencies": "off",
-      "import/extensions": "off",
       "@typescript-eslint/ban-ts-comment": "off",
       "@typescript-eslint/no-unsafe-call": "off",
-      "@typescript-eslint/no-for-in-array": "off",
-      "guard-for-in": "off",
-      "no-await-in-loop": "off",
       "@typescript-eslint/no-unsafe-return": "off",
       "@typescript-eslint/no-unsafe-assignment": "off",
       "@typescript-eslint/no-unsafe-argument": "off",
-      "@typescript-eslint/naming-convention": "off",
-      "@typescript-eslint/consistent-type-assertions": "off",
-      "@typescript-eslint/no-confusing-void-expression": "off",
-      "@typescript-eslint/no-var-requires": "off",
-      "@typescript-eslint/prefer-ts-expect-error": "off"
+      "@typescript-eslint/no-confusing-void-expression": "off"
     }
   },
   "repository": {
@@ -69,19 +54,23 @@
   },
   "homepage": "https://github.com/jaredwray/keyv",
   "dependencies": {
-    "@keyv/serialize": "^1.0.1"
+    "@keyv/serialize": "^1.0.3"
   },
   "devDependencies": {
+    "@faker-js/faker": "^9.5.1",
+    "@vitest/coverage-v8": "^3.0.7",
     "rimraf": "^6.0.1",
     "timekeeper": "^2.3.1",
     "tsd": "^0.31.2",
+    "vitest": "^3.0.7",
     "xo": "^0.60.0",
-    "@keyv/mongo": "^3.0.1",
+    "@keyv/compress-brotli": "^2.0.3",
     "@keyv/compress-gzip": "^2.0.2",
-    "@keyv/test-suite": "^2.0.3",
-    "@keyv/sqlite": "^4.0.1",
     "@keyv/memcache": "^2.0.1",
-    "@keyv/compress-brotli": "^2.0.2"
+    "@keyv/compress-lz4": "^1.0.0",
+    "@keyv/mongo": "^3.0.1",
+    "@keyv/sqlite": "^4.0.1",
+    "@keyv/test-suite": "^2.0.5"
   },
   "tsd": {
     "directory": "test"