rate-limiter-flexible 7.3.1 → 7.4.0

package/README.md

@@ -42,14 +42,9 @@ It uses a **fixed window**, as it is much faster than a rolling window.
 ## Import
   
   ```javascript
-  // CommonJS
-  const { RateLimiterMemory } = require("rate-limiter-flexible");
-
-  // or
-
-  // ECMAScript 
   import { RateLimiterMemory } from "rate-limiter-flexible";
-  // or
+  
+  // or import directly
   import RateLimiterMemory from "rate-limiter-flexible/lib/RateLimiterMemory.js";
   ```
 
@@ -136,9 +131,9 @@ 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)
 
-* [Drizzle](https://github.com/animir/node-rate-limiter-flexible/wiki/Drizzle)
+* [Drizzle](https://github.com/animir/node-rate-limiter-flexible/wiki/Drizzle) Atomic and non-atomic counters.
 * [DynamoDb](https://github.com/animir/node-rate-limiter-flexible/wiki/DynamoDB)
-* [Etcd](https://github.com/animir/node-rate-limiter-flexible/wiki/Etcd)
+* [Etcd](https://github.com/animir/node-rate-limiter-flexible/wiki/Etcd) Atomic and non-atomic counters.
 * [Memcached](https://github.com/animir/node-rate-limiter-flexible/wiki/Memcache)
 * [Memory](https://github.com/animir/node-rate-limiter-flexible/wiki/Memory)
 * [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))

package/index.js

@@ -13,6 +13,7 @@ const RateLimiterRes = require('./lib/RateLimiterRes');
 const RateLimiterDynamo = require('./lib/RateLimiterDynamo');
 const RateLimiterPrisma = require('./lib/RateLimiterPrisma');
 const RateLimiterDrizzle = require('./lib/RateLimiterDrizzle');
+const RateLimiterDrizzleNonAtomic = require('./lib/RateLimiterDrizzleNonAtomic');
 const RateLimiterValkey = require('./lib/RateLimiterValkey');
 const RateLimiterValkeyGlide = require('./lib/RateLimiterValkeyGlide');
 const RateLimiterSQLite = require('./lib/RateLimiterSQLite');
@@ -41,5 +42,6 @@ module.exports = {
   RateLimiterSQLite,
   RateLimiterEtcd,
   RateLimiterDrizzle,
+  RateLimiterDrizzleNonAtomic,
   RateLimiterEtcdNonAtomic,
 };

package/lib/RateLimiterDrizzle.js

@@ -14,7 +14,10 @@ async function getDrizzleOperators() {
 
   try {
     // Use dynamic import to prevent static analysis tools from detecting the import
-    const drizzleOrm = await import('drizzle-orm');
+    function getPackageName() {
+      return ['drizzle', 'orm'].join('-');
+    }
+    const drizzleOrm = await import(`${getPackageName()}`);
     const { and, or, gt, lt, eq, isNull, sql } = drizzleOrm.default || drizzleOrm;
     drizzleOperators = { and, or, gt, lt, eq, isNull, sql };
     return drizzleOperators;

package/lib/RateLimiterDrizzleNonAtomic.js

@@ -0,0 +1,175 @@
+let drizzleOperators = null;
+const CLEANUP_INTERVAL_MS = 300000; // 5 minutes
+const EXPIRED_THRESHOLD_MS = 3600000; // 1 hour
+
+class RateLimiterDrizzleError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'RateLimiterDrizzleError';
+  }
+}
+
+async function getDrizzleOperators() {
+  if (drizzleOperators) return drizzleOperators;
+
+  try {
+    // Use dynamic import to prevent static analysis tools from detecting the import
+    function getPackageName() {
+      return ['drizzle', 'orm'].join('-');
+    }
+    const drizzleOrm = await import(`${getPackageName()}`);
+    const { and, or, gt, lt, eq, isNull, sql } = drizzleOrm.default || drizzleOrm;
+    drizzleOperators = { and, or, gt, lt, eq, isNull, sql };
+    return drizzleOperators;
+  } catch (error) {
+    throw new RateLimiterDrizzleError(
+      'drizzle-orm is not installed. Please install drizzle-orm to use RateLimiterDrizzleNonAtomic.'
+    );
+  }
+}
+
+const RateLimiterStoreAbstract = require('./RateLimiterStoreAbstract');
+const RateLimiterRes = require('./RateLimiterRes');
+
+class RateLimiterDrizzleNonAtomic extends RateLimiterStoreAbstract {
+  constructor(opts) {
+    super(opts);
+
+    if (!opts?.schema) {
+      throw new RateLimiterDrizzleError('Drizzle schema is required');
+    }
+
+    if (!opts?.storeClient) {
+      throw new RateLimiterDrizzleError('Drizzle client is required');
+    }
+
+    this.schema = opts.schema;
+    this.drizzleClient = opts.storeClient;
+    this.clearExpiredByTimeout = opts.clearExpiredByTimeout ?? true;
+
+    if (this.clearExpiredByTimeout) {
+      this._clearExpiredHourAgo();
+    }
+  }
+
+  _getRateLimiterRes(rlKey, changedPoints, result) {
+    const res = new RateLimiterRes();
+
+    let doc = result;
+    res.isFirstInDuration = doc.points === changedPoints;
+    res.consumedPoints = doc.points;
+    res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+    res.msBeforeNext = doc.expire !== null
+      ? Math.max(new Date(doc.expire).getTime() - Date.now(), 0)
+      : -1;
+
+    return res;
+  }
+
+  async _upsert(key, points, msDuration, forceExpire = false) {
+    if (!this.drizzleClient) {
+      return Promise.reject(new RateLimiterDrizzleError('Drizzle client is not established'));
+    }
+
+    const { eq } = await getDrizzleOperators();
+    const now = new Date();
+    const newExpire = msDuration > 0 ? new Date(now.getTime() + msDuration) : null;
+
+    const [existingRecord] = await this.drizzleClient
+      .select()
+      .from(this.schema)
+      .where(eq(this.schema.key, key))
+      .limit(1);
+
+    const shouldUpdateExpire =
+      forceExpire ||
+      !existingRecord ||
+      !existingRecord.expire ||
+      existingRecord.expire <= now ||
+      newExpire === null;
+
+    let newPoints;
+    if (existingRecord && !shouldUpdateExpire) {
+      newPoints = existingRecord.points + points;
+    } else {
+      newPoints = points;
+    }
+
+    const [data] = await this.drizzleClient
+      .insert(this.schema)
+      .values({
+        key,
+        points: newPoints,
+        expire: newExpire,
+      })
+      .onConflictDoUpdate({
+        target: this.schema.key,
+        set: {
+          points: newPoints,
+          ...(shouldUpdateExpire && { expire: newExpire }),
+        },
+      })
+      .returning();
+
+    return data;
+  }
+
+  async _get(rlKey) {
+    if (!this.drizzleClient) {
+      return Promise.reject(new RateLimiterDrizzleError('Drizzle client is not established'));
+    }
+
+    const { and, or, gt, eq, isNull } = await getDrizzleOperators();
+
+    const [response] = await this.drizzleClient
+      .select()
+      .from(this.schema)
+      .where(
+        and(
+          eq(this.schema.key, rlKey),
+          or(gt(this.schema.expire, new Date()), isNull(this.schema.expire))
+        )
+      )
+      .limit(1);
+
+    return response || null;
+  }
+
+  async _delete(rlKey) {
+    if (!this.drizzleClient) {
+      return Promise.reject(new RateLimiterDrizzleError('Drizzle client is not established'));
+    }
+
+    const { eq } = await getDrizzleOperators();
+
+    const [result] = await this.drizzleClient
+      .delete(this.schema)
+      .where(eq(this.schema.key, rlKey))
+      .returning({ key: this.schema.key });
+
+    return !!(result && result.key);
+  }
+
+  _clearExpiredHourAgo() {
+    if (this._clearExpiredTimeoutId) {
+      clearTimeout(this._clearExpiredTimeoutId);
+    }
+
+    this._clearExpiredTimeoutId = setTimeout(async () => {
+      try {
+        const { lt } = await getDrizzleOperators();
+        await this.drizzleClient
+          .delete(this.schema)
+          .where(lt(this.schema.expire, new Date(Date.now() - EXPIRED_THRESHOLD_MS)));
+      } catch (error) {
+        console.warn('Failed to clear expired records:', error);
+      }
+
+      this._clearExpiredHourAgo();
+    }, CLEANUP_INTERVAL_MS);
+
+    this._clearExpiredTimeoutId.unref();
+  }
+}
+
+module.exports = RateLimiterDrizzleNonAtomic;

package/lib/index.d.ts

@@ -377,6 +377,10 @@ export class RateLimiterDrizzle extends RateLimiterStoreAbstract {
   constructor(opts: IRateLimiterStoreNoAutoExpiryOptionsAndSchema, cb?: ICallbackReady);
 }
 
+export class RateLimiterDrizzleNonAtomic extends RateLimiterStoreAbstract {
+  constructor(opts: IRateLimiterStoreNoAutoExpiryOptionsAndSchema, cb?: ICallbackReady);
+}
+
 export class RateLimiterMemcache extends RateLimiterStoreAbstract { }
 
 export class RateLimiterUnion {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rate-limiter-flexible",
-  "version": "7.3.1",
+  "version": "7.4.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": {