rate-limiter-flexible 6.2.0 → 7.0.0

package/README.md

@@ -3,7 +3,7 @@
 [![node version][node-image]][node-url]
 [![deno version](https://img.shields.io/badge/deno-^1.5.3-lightgrey?logo=deno)](https://github.com/denoland/deno)
 
-[node-image]: https://img.shields.io/badge/node.js-%3E=_18.0-green.svg?style=flat-square
+[node-image]: https://img.shields.io/badge/node.js-%3E=_20.0-green.svg?style=flat-square
 [node-url]: http://nodejs.org/download/
 
 <img src="img/rlflx-logo-small.png" width="50" alt="Logo"/>
@@ -12,7 +12,7 @@
 
 **rate-limiter-flexible** counts and limits the number of actions by key and protects from DDoS and brute force attacks at any scale.
 
-It works with _Redis_, _Valkey_, _Prisma_, _DynamoDB_, process _Memory_, _Cluster_ or _PM2_, _Memcached_, _MongoDB_, _MySQL_, _SQLite_, and _PostgreSQL_.
+It works with _Valkey_, _Redis_, _Prisma_, _DynamoDB_, process _Memory_, _Cluster_ or _PM2_, _Memcached_, _MongoDB_, _MySQL_, _SQLite_, and _PostgreSQL_.
 
 Memory limiter also works in the browser.
 
@@ -24,7 +24,9 @@ Memory limiter also works in the browser.
 
 **Ready for growth.** It provides a unified API for all limiters. Whenever your application grows, it is ready. Prepare your limiters in minutes.
 
-**Friendly.** No matter which node package you prefer: `redis` or `ioredis`, `iovalkey`, `sequelize`/`typeorm` or `knex`, `memcached`, native driver or `mongoose`. It works with all of them.
+**Friendly.** No matter which node package you prefer: [`valkey-glide`](https://www.npmjs.com/package/@valkey/valkey-glide) or [`iovalkey`](https://www.npmjs.com/package/iovalkey), `redis` or `ioredis`, `sequelize`/`typeorm` or `knex`, `memcached`, native driver or `mongoose`. It works with all of them.
+
+**Safe for using with valkey cluster.** [`valkey-glide`](https://www.npmjs.com/package/@valkey/valkey-glide) implementation, [RateLimiterValkeyGlide](https://github.com/animir/node-rate-limiter-flexible/wiki/RateLimiterValkeyGlide), is being tested against `valkey` cluster to ensure the rate limiter is agnostic to the server type, it able to avoid race conditions in high traffic along with sharded cluster, and to ensure compatibility and high performance.
 
 **In-memory blocks.** Avoid extra requests to store with [inMemoryBlockOnConsumed](https://github.com/animir/node-rate-limiter-flexible/wiki/Options#inmemoryblockonconsumed).
 
@@ -95,7 +97,7 @@ const headers = {
   "Retry-After": rateLimiterRes.msBeforeNext / 1000,
   "X-RateLimit-Limit": opts.points,
   "X-RateLimit-Remaining": rateLimiterRes.remainingPoints,
-  "X-RateLimit-Reset": new Date(Date.now() + rateLimiterRes.msBeforeNext)
+  "X-RateLimit-Reset": Math.ceil((Date.now() + rateLimiterRes.msBeforeNext) / 1000)
 }
 ```
 
@@ -137,18 +139,18 @@ Some copy/paste examples on Wiki:
 
 * [Options](https://github.com/animir/node-rate-limiter-flexible/wiki/Options)
 * [API methods](https://github.com/animir/node-rate-limiter-flexible/wiki/API-methods)
+* [Valkey](https://github.com/animir/node-rate-limiter-flexible/wiki/Valkey)
 * [Redis](https://github.com/animir/node-rate-limiter-flexible/wiki/Redis)
 * [Memory](https://github.com/animir/node-rate-limiter-flexible/wiki/Memory)
 * [DynamoDb](https://github.com/animir/node-rate-limiter-flexible/wiki/DynamoDB)
 * [Prisma](https://github.com/animir/node-rate-limiter-flexible/wiki/Prisma)
-* [Valkey](https://github.com/animir/node-rate-limiter-flexible/wiki/Valkey)
 * [BurstyRateLimiter](https://github.com/animir/node-rate-limiter-flexible/wiki/BurstyRateLimiter) Traffic burst support
 * [Mongo](https://github.com/animir/node-rate-limiter-flexible/wiki/Mongo) (with [sharding support](https://github.com/animir/node-rate-limiter-flexible/wiki/Mongo#mongodb-sharding-options))
 * [MySQL](https://github.com/animir/node-rate-limiter-flexible/wiki/MySQL) (support Sequelize and Knex)
 * [Postgres](https://github.com/animir/node-rate-limiter-flexible/wiki/PostgreSQL) (support Sequelize, TypeORM and Knex)
 * [SQLite](https://github.com/animir/node-rate-limiter-flexible/wiki/SQLite)
 * [RateLimiterCluster](https://github.com/animir/node-rate-limiter-flexible/wiki/Cluster) ([PM2 cluster docs read here](https://github.com/animir/node-rate-limiter-flexible/wiki/PM2-cluster))
-* [Memcache](https://github.com/animir/node-rate-limiter-flexible/wiki/Memcache)
+* [Memcached](https://github.com/animir/node-rate-limiter-flexible/wiki/Memcache)
 * [RateLimiterUnion](https://github.com/animir/node-rate-limiter-flexible/wiki/RateLimiterUnion) Combine 2 or more limiters to act as single
 * [RLWrapperBlackAndWhite](https://github.com/animir/node-rate-limiter-flexible/wiki/Black-and-White-lists) Black and White lists
 * [RateLimiterQueue](https://github.com/animir/node-rate-limiter-flexible/wiki/RateLimiterQueue) Rate limiter with FIFO queue
@@ -177,7 +179,7 @@ See [releases](https://github.com/animir/node-rate-limiter-flexible/releases) fo
 
     `Required for store limiters` 
 
-    Must be `redis`, `ioredis`, `memcached`, `mongodb`, `pg`, `mysql2`, `mysql` or any other related pool or connection.
+    Must be `@valkey/valkey-glide`, `iovalkey`, `redis`, `ioredis`, `memcached`, `mongodb`, `pg`, `mysql2`, `mysql` or any other related pool or connection.
 
 ### Other options on Wiki:
 * [keyPrefix](https://github.com/animir/node-rate-limiter-flexible/wiki/Options#keyprefix) Make keys unique among different limiters.

package/index.js

@@ -2,7 +2,7 @@ const RateLimiterRedis = require('./lib/RateLimiterRedis');
 const RateLimiterMongo = require('./lib/RateLimiterMongo');
 const RateLimiterMySQL = require('./lib/RateLimiterMySQL');
 const RateLimiterPostgres = require('./lib/RateLimiterPostgres');
-const {RateLimiterClusterMaster, RateLimiterClusterMasterPM2, RateLimiterCluster} = require('./lib/RateLimiterCluster');
+const { RateLimiterClusterMaster, RateLimiterClusterMasterPM2, RateLimiterCluster } = require('./lib/RateLimiterCluster');
 const RateLimiterMemory = require('./lib/RateLimiterMemory');
 const RateLimiterMemcache = require('./lib/RateLimiterMemcache');
 const RLWrapperBlackAndWhite = require('./lib/RLWrapperBlackAndWhite');
@@ -13,6 +13,7 @@ const RateLimiterRes = require('./lib/RateLimiterRes');
 const RateLimiterDynamo = require('./lib/RateLimiterDynamo');
 const RateLimiterPrisma = require('./lib/RateLimiterPrisma');
 const RateLimiterValkey = require('./lib/RateLimiterValkey');
+const RateLimiterValkeyGlide = require('./lib/RateLimiterValkeyGlide');
 const RateLimiterSQLite = require('./lib/RateLimiterSQLite');
 
 module.exports = {
@@ -33,5 +34,6 @@ module.exports = {
   RateLimiterDynamo,
   RateLimiterPrisma,
   RateLimiterValkey,
+  RateLimiterValkeyGlide,
   RateLimiterSQLite,
 };

package/lib/ExpressBruteFlexible.js

@@ -11,6 +11,8 @@ const {
   RateLimiterMySQL,
   RateLimiterPostgres,
   RateLimiterRedis,
+  RateLimiterValkey,
+  RateLimiterValkeyGlide,
 } = require('../index');
 
 function getDelayMs(count, delays, maxWait) {
@@ -119,6 +121,16 @@ ExpressBruteFlexible.prototype.getMiddleware = function (options) {
       this.blockLimiter = new RateLimiterPostgres(blockLimiterOptions);
       this.counterLimiter = new RateLimiterPostgres(counterLimiterOptions);
       break;
+    case 'valkey-glide':
+      this.freeLimiter = new RateLimiterValkeyGlide(freeLimiterOptions);
+      this.blockLimiter = new RateLimiterValkeyGlide(blockLimiterOptions);
+      this.counterLimiter = new RateLimiterValkeyGlide(counterLimiterOptions);
+      break;
+    case 'valkey':
+      this.freeLimiter = new RateLimiterValkey(freeLimiterOptions);
+      this.blockLimiter = new RateLimiterValkey(blockLimiterOptions);
+      this.counterLimiter = new RateLimiterValkey(counterLimiterOptions);
+      break;
     case 'redis':
       this.freeLimiter = new RateLimiterRedis(freeLimiterOptions);
       this.blockLimiter = new RateLimiterRedis(blockLimiterOptions);

package/lib/RateLimiterSQLite.js

@@ -217,8 +217,7 @@ class RateLimiterSQLite extends RateLimiterStoreAbstract {
     return res;
   }
 
-  async _upsertTransactionSQLite3(upsertQuery, upsertParams) {
-    const conn = await this._getConnection();
+  async _upsertTransactionSQLite3(conn, upsertQuery, upsertParams) {
     return await new Promise((resolve, reject) => {
       conn.serialize(() => {
         conn.run("SAVEPOINT rate_limiter_trx;", (err) => {
@@ -237,9 +236,7 @@ class RateLimiterSQLite extends RateLimiterStoreAbstract {
     });
   }
 
-  async _upsertTransactionBetterSQLite3(upsertQuery, upsertParams) {
-    const conn = await this._getConnection();
-
+  async _upsertTransactionBetterSQLite3(conn, upsertQuery, upsertParams) {
     return conn.transaction(() =>
       conn.prepare(upsertQuery).get(...upsertParams)
     )();
@@ -263,9 +260,14 @@ class RateLimiterSQLite extends RateLimiterStoreAbstract {
     try {
       switch (this._internalStoreType) {
         case "sqlite3":
-          return this._upsertTransactionSQLite3(upsertQuery, upsertParams);
+          return this._upsertTransactionSQLite3(
+            conn,
+            upsertQuery,
+            upsertParams
+          );
         case "better-sqlite3":
           return this._upsertTransactionBetterSQLite3(
+            conn,
             upsertQuery,
             upsertParams
           );

package/lib/RateLimiterValkeyGlide.js

@@ -0,0 +1,273 @@
+/* eslint-disable no-unused-vars */
+const RateLimiterStoreAbstract = require('./RateLimiterStoreAbstract');
+const RateLimiterRes = require('./RateLimiterRes');
+
+/**
+ * @typedef {import('@valkey/valkey-glide').GlideClient} GlideClient
+ * @typedef {import('@valkey/valkey-glide').GlideClusterClient} GlideClusterClient
+ */
+
+const DEFAULT_LIBRARY_NAME = 'ratelimiterflexible';
+
+const DEFAULT_VALKEY_SCRIPT = `local key = KEYS[1]
+local pointsToConsume = tonumber(ARGV[1])
+if tonumber(ARGV[2]) > 0 then
+  server.call('set', key, "0", 'EX', ARGV[2], 'NX')
+  local consumed = server.call('incrby', key, pointsToConsume)
+  local pttl = server.call('pttl', key)
+  return {consumed, pttl}
+end
+local consumed = server.call('incrby', key, pointsToConsume)
+local pttl = server.call('pttl', key)
+return {consumed, pttl}`;
+
+const GET_VALKEY_SCRIPT = `local key = KEYS[1]
+local value = server.call('get', key)
+if value == nil then
+  return value
+end
+local pttl = server.call('pttl', key)
+return {tonumber(value), pttl}`;
+
+class RateLimiterValkeyGlide extends RateLimiterStoreAbstract {
+  /**
+   * Constructor for RateLimiterValkeyGlide
+   *
+   * @param {Object} opts - Configuration options
+   * @param {GlideClient|GlideClusterClient} opts.storeClient - Valkey Glide client instance (required)
+   * @param {number} [opts.points=4] - Maximum number of points that can be consumed over duration
+   * @param {number} [opts.duration=1] - Duration in seconds before points are reset
+   * @param {number} [opts.blockDuration=0] - Duration in seconds that a key will be blocked for if consumed more than points
+   * @param {boolean} [opts.rejectIfValkeyNotReady=false] - Whether to reject requests if Valkey is not ready
+   * @param {boolean} [opts.execEvenly=false] - Delay actions to distribute them evenly over duration
+   * @param {number} [opts.execEvenlyMinDelayMs] - Minimum delay between actions when execEvenly is true
+   * @param {string} [opts.customFunction] - Custom Lua script for rate limiting logic
+   * @param {number} [opts.inMemoryBlockOnConsumed] - Points threshold for in-memory blocking
+   * @param {number} [opts.inMemoryBlockDuration] - Duration in seconds for in-memory blocking
+   * @param {string} [opts.customFunctionLibName] - Custom name for the function library, defaults to 'ratelimiter'.
+   * The name is used to identify the library of the lua function. An custom name should be used only if you
+   * you want to use different libraries for different rate limiters, otherwise it is not needed.
+   * @param {RateLimiterAbstract} [opts.insuranceLimiter] - Backup limiter to use when the primary client fails
+   *
+   * @example
+   * const rateLimiter = new RateLimiterValkeyGlide({
+   *   storeClient: glideClient,
+   *   points: 5,
+   *   duration: 1
+   * });
+   *
+   * @example <caption>With custom Lua function</caption>
+   * const customScript = `local key = KEYS[1]
+   * local pointsToConsume = tonumber(ARGV[1]) or 0
+   * local secDuration = tonumber(ARGV[2]) or 0
+   *
+   * -- Custom implementation
+   * -- ...
+   *
+   * -- Must return exactly two values: [consumed_points, ttl_in_ms]
+   * return {consumed, ttl}`
+   *
+   * const rateLimiter = new RateLimiterValkeyGlide({
+   *   storeClient: glideClient,
+   *   points: 5,
+   *   customFunction: customScript
+   * });
+   *
+   * @example <caption>With insurance limiter</caption>
+   * const rateLimiter = new RateLimiterValkeyGlide({
+   *   storeClient: primaryGlideClient,
+   *   points: 5,
+   *   duration: 2,
+   *   insuranceLimiter: new RateLimiterMemory({
+   *     points: 5,
+   *     duration: 2
+   *   })
+   * });
+   *
+   * @description
+   * When providing a custom Lua script via `opts.customFunction`, it must:
+   *
+   * 1. Accept parameters:
+   *    - KEYS[1]: The key being rate limited
+   *    - ARGV[1]: Points to consume (as string, use tonumber() to convert)
+   *    - ARGV[2]: Duration in seconds (as string, use tonumber() to convert)
+   *
+   * 2. Return an array with exactly two elements:
+   *    - [0]: Consumed points (number)
+   *    - [1]: TTL in milliseconds (number)
+   *
+   * 3. Handle scenarios:
+   *    - New key creation: Initialize with expiry for fixed windows
+   *    - Key updates: Increment existing counters
+   */
+  constructor(opts) {
+    super(opts);
+    this.client = opts.storeClient;
+    this._scriptLoaded = false;
+    this._getScriptLoaded = false;
+    this._rejectIfValkeyNotReady = !!opts.rejectIfValkeyNotReady;
+    this._luaScript = opts.customFunction || DEFAULT_VALKEY_SCRIPT;
+    this._libraryName = opts.customFunctionLibName || DEFAULT_LIBRARY_NAME;
+  }
+
+  /**
+   * Ensure scripts are loaded in the Valkey server
+   * @returns {Promise<boolean>} True if scripts are loaded
+   * @private
+   */
+  async _loadScripts() {
+    if (this._scriptLoaded && this._getScriptLoaded) {
+      return true;
+    }
+    if (!this.client) {
+      throw new Error('Valkey client is not set');
+    }
+    const promises = [];
+    if (!this._scriptLoaded) {
+      const script = Buffer.from(`#!lua name=${this._libraryName}
+        local function consume(KEYS, ARGV)
+          ${this._luaScript.trim()}
+        end
+        server.register_function('consume', consume)`);
+      promises.push(this.client.functionLoad(script, { replace: true }));
+    } else promises.push(Promise.resolve(this._libraryName));
+
+    if (!this._getScriptLoaded) {
+      const script = Buffer.from(`#!lua name=ratelimiter_get
+        local function getValue(KEYS, ARGV)
+          ${GET_VALKEY_SCRIPT.trim()}
+        end
+        server.register_function('getValue', getValue)`);
+      promises.push(this.client.functionLoad(script, { replace: true }));
+    } else promises.push(Promise.resolve('ratelimiter_get'));
+
+    const results = await Promise.all(promises);
+    this._scriptLoaded = results[0] === this._libraryName;
+    this._getScriptLoaded = results[1] === 'ratelimiter_get';
+
+    if ((!this._scriptLoaded || !this._getScriptLoaded)) {
+      throw new Error('Valkey connection is not ready, scripts not loaded');
+    }
+    return true;
+  }
+
+  /**
+   * Update or insert the rate limiter record
+   *
+   * @param {string} rlKey - The rate limiter key
+   * @param {number} pointsToConsume - Points to be consumed
+   * @param {number} msDuration - Duration in milliseconds
+   * @param {boolean} [forceExpire=false] - Whether to force expiration
+   * @param {Object} [options={}] - Additional options
+   * @returns {Promise<Array>} Array containing consumed points and TTL
+   * @private
+   */
+  async _upsert(rlKey, pointsToConsume, msDuration, forceExpire = false, options = {}) {
+    await this._loadScripts();
+    const secDuration = Math.floor(msDuration / 1000);
+    if (forceExpire) {
+      if (secDuration > 0) {
+        await this.client.set(
+          rlKey,
+          String(pointsToConsume),
+          { expiry: { type: 'EX', count: secDuration } },
+        );
+        return [pointsToConsume, secDuration * 1000];
+      }
+      await this.client.set(rlKey, String(pointsToConsume));
+      return [pointsToConsume, -1];
+    }
+    const result = await this.client.fcall(
+      'consume',
+      [rlKey],
+      [String(pointsToConsume), String(secDuration)],
+    );
+    return result;
+  }
+
+  /**
+   * Get the rate limiter record
+   *
+   * @param {string} rlKey - The rate limiter key
+   * @param {Object} [options={}] - Additional options
+   * @returns {Promise<Array|null>} Array containing consumed points and TTL, or null if not found
+   * @private
+   */
+  async _get(rlKey, options = {}) {
+    await this._loadScripts();
+    const res = await this.client.fcall('getValue', [rlKey], []);
+    return res.length > 0 ? res : null;
+  }
+
+  /**
+   * Delete the rate limiter record
+   *
+   * @param {string} rlKey - The rate limiter key
+   * @param {Object} [options={}] - Additional options
+   * @returns {Promise<boolean>} True if successful, false otherwise
+   * @private
+   */
+  async _delete(rlKey, options = {}) {
+    const result = await this.client.del([rlKey]);
+    return result > 0;
+  }
+
+  /**
+   * Convert raw result to RateLimiterRes object
+   *
+   * @param {string} rlKey - The rate limiter key
+   * @param {number} changedPoints - Points changed in this operation
+   * @param {Array|null} result - Result from Valkey operation
+   * @returns {RateLimiterRes|null} RateLimiterRes object or null if result is null
+   * @private
+   */
+  _getRateLimiterRes(rlKey, changedPoints, result) {
+    if (result === null) {
+      return null;
+    }
+    const res = new RateLimiterRes();
+    const [consumedPointsStr, pttl] = result;
+    const consumedPoints = Number(consumedPointsStr);
+
+    // Handle consumed points
+    res.isFirstInDuration = consumedPoints === changedPoints;
+    res.consumedPoints = consumedPoints;
+    res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+    res.msBeforeNext = pttl;
+    return res;
+  }
+
+  /**
+   * Close the rate limiter and release resources
+   * Note: The method won't going to close the Valkey client, as it may be shared with other instances.
+   * @returns {Promise<void>} Promise that resolves when the rate limiter is closed
+   */
+  async close() {
+    if (this._scriptLoaded) {
+      await this.client.functionDelete(this._libraryName);
+      this._scriptLoaded = false;
+    }
+    if (this._getScriptLoaded) {
+      await this.client.functionDelete('ratelimiter_get');
+      this._getScriptLoaded = false;
+    }
+    if (this.insuranceLimiter) {
+      try {
+        await this.insuranceLimiter.close();
+      } catch (e) {
+        // We can't assume that insuranceLimiter is a Valkey client or any
+        // other insuranceLimiter type which implement close method.
+      }
+    }
+    // Clear instance properties to let garbage collector free memory
+    this.client = null;
+    this._scriptLoaded = false;
+    this._getScriptLoaded = false;
+    this._rejectIfValkeyNotReady = false;
+    this._luaScript = null;
+    this._libraryName = null;
+    this.insuranceLimiter = null;
+  }
+}
+
+module.exports = RateLimiterValkeyGlide;

package/lib/constants.js

@@ -9,6 +9,8 @@ const LIMITER_TYPES = {
   DYNAMO: 'dynamo',
   PRISMA: 'prisma',
   SQLITE: 'sqlite',
+  VALKEY: 'valkey',
+  VALKEY_GLIDE: 'valkey-glide',
 };
 
 const ERR_UNKNOWN_LIMITER_TYPE_MESSAGE = 'Unknown limiter type. Use one of LIMITER_TYPES constants.';

package/lib/index.d.ts

@@ -417,3 +417,99 @@ interface IRateLimiterDynamoOptions extends IRateLimiterStoreOptions {
 export class RateLimiterDynamo extends RateLimiterStoreAbstract {
     constructor(opts: IRateLimiterDynamoOptions, cb?: ICallbackReady);
 }
+
+/**
+ * Options for RateLimiterValkeyGlide
+ */
+interface IRateLimiterValkeyGlideOptions extends IRateLimiterStoreOptions {
+    /**
+     * Valkey Glide client instance (GlideClient or GlideClusterClient)
+     */
+    storeClient: any; // GlideClient | GlideClusterClient;
+
+    /**
+     * Whether to reject requests if Valkey is not ready
+     * @default false
+     */
+    rejectIfValkeyNotReady?: boolean;
+
+    /**
+     * Custom Lua script for rate limiting logic.
+     * Must accept parameters:
+     * - KEYS[1]: The key being rate limited
+     * - ARGV[1]: Points to consume (as string, use tonumber() to convert)
+     * - ARGV[2]: Duration in seconds (as string, use tonumber() to convert)
+     * 
+     * Must return an array with exactly two elements:
+     * - [0]: Consumed points (number)
+     * - [1]: TTL in milliseconds (number)
+     */
+    customFunction?: string;
+
+    /**
+     * Custom name for the function library, defaults to 'ratelimiter'.
+     * The name is used to identify the library of the Lua function.
+     * A custom name should be used only if you want to use different 
+     * libraries for different rate limiters.
+     * @default 'ratelimiter'
+     */
+    customFunctionLibName?: string;
+}
+
+/**
+ * Rate limiter that uses Valkey Glide client for storage
+ */
+export class RateLimiterValkeyGlide extends RateLimiterStoreAbstract {
+    /**
+     * Creates a new instance of RateLimiterValkeyGlide
+     * 
+     * @param opts Configuration options
+     * 
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const rateLimiter = new RateLimiterValkeyGlide({
+     *   storeClient: glideClient,
+     *   points: 5,
+     *   duration: 1
+     * });
+     * 
+     * // With custom Lua function
+     * const customScript = `local key = KEYS[1]
+     * local pointsToConsume = tonumber(ARGV[1]) or 0
+     * local secDuration = tonumber(ARGV[2]) or 0
+     * 
+     * -- Custom implementation
+     * -- ...
+     * 
+     * -- Must return exactly two values: [consumed_points, ttl_in_ms]
+     * return {consumed, ttl}`;
+     * 
+     * const rateLimiter = new RateLimiterValkeyGlide({
+     *   storeClient: glideClient,
+     *   points: 5,
+     *   customFunction: customScript
+     * });
+     * 
+     * // With insurance limiter
+     * const rateLimiter = new RateLimiterValkeyGlide({
+     *   storeClient: primaryGlideClient,
+     *   points: 5,
+     *   duration: 2,
+     *   insuranceLimiter: new RateLimiterMemory({
+     *     points: 5,
+     *     duration: 2
+     *   })
+     * });
+     * ```
+     */
+    constructor(opts: IRateLimiterValkeyGlideOptions);
+
+    /**
+     * Close the rate limiter and release resources
+     * Note: The method won't close the Valkey client, as it may be shared with other instances.
+     * 
+     * @returns Promise that resolves when the rate limiter is closed
+     */
+    close(): Promise<void>;
+}

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "rate-limiter-flexible",
-  "version": "6.2.0",
+  "version": "7.0.0",
   "description": "Node.js rate limiter by key and protection from DDoS and Brute-Force attacks in process Memory, Redis, MongoDb, Memcached, MySQL, PostgreSQL, Cluster or PM",
   "main": "index.js",
   "scripts": {
     "dc:up": "docker-compose -f docker-compose.yml up -d",
     "dc:down": "docker-compose -f docker-compose.yml down",
+    "valkey-cluster:up": "docker-compose -f docker-compose.valkey-cluster.yml up -d",
+    "valkey-cluster:down": "docker-compose -f docker-compose.valkey-cluster.yml down -v",
+    "test:valkey-cluster": "VALKEY_CLUSTER_PORT=7001 mocha test/RateLimiterValkeyGlide.test.js --  -g 'RateLimiterValkeyGlide with cluster client'",
     "prisma:postgres": "prisma generate --schema=./test/RateLimiterPrisma/Postgres/schema.prisma && prisma db push --schema=./test/RateLimiterPrisma/Postgres/schema.prisma",
     "test": "npm run prisma:postgres && nyc  --reporter=html --reporter=text mocha",
     "debug-test": "mocha --inspect-brk lib/**/**.test.js",
@@ -33,7 +36,12 @@
     "prisma",
     "koa",
     "express",
-    "hapi"
+    "hapi",
+    "valkey",
+    "valkey-glide",
+    "GLIDE",
+    "cluster",
+    "memcached"
   ],
   "author": "animir <animirr@gmail.com>",
   "license": "ISC",
@@ -56,6 +64,7 @@
     "ioredis": "^5.3.2",
     "iovalkey": "^0.3.1",
     "istanbul": "^1.1.0-alpha.1",
+    "knex": "^3.1.0",
     "memcached-mock": "^0.1.0",
     "mocha": "^10.2.0",
     "nyc": "^15.1.0",
@@ -63,7 +72,8 @@
     "redis": "^4.6.8",
     "redis-mock": "^0.48.0",
     "sinon": "^17.0.1",
-    "sqlite3": "^5.1.7"
+    "sqlite3": "^5.1.7",
+    "@valkey/valkey-glide": "^1.3.1"
   },
   "browser": {
     "cluster": false,

package/.editorconfig

@@ -1,13 +0,0 @@
-root = true
-
-[*]
-indent_size = 2
-indent_style = space
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.md]
-insert_final_newline = false
-trim_trailing_whitespace = false