web-gatekeeper-js 1.0.7 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "web-gatekeeper-js",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Redis based rate limiter and throttler using sliding window and token bucket algorithms",
   "main": "src/index.js",
   "type": "module",

package/src/RateLimiter.js

@@ -1,5 +1,5 @@
 import { slidingWindowScript } from "./scripts/slidingWindow.lua.js";
-import { tokenBucketScript } from "./scripts/tokenBucket.lua.js"
+import { tokenBucketScript } from "./scripts/tokenBucket.lua.js";
 import { RedisStore } from "./store/RedisStore.js";
 
 export class RateLimiter {
@@ -13,8 +13,16 @@ export class RateLimiter {
     if (!redisClient) throw new Error("redisClient is required");
     if (!windowSize) throw new Error("windowSize is required");
     if (!limit) throw new Error("limit is required");
-    if (!maxToken) throw new Error("maxToken is required");
-    if (!refillRate) throw new Error("refillRate is required");
+    if (maxToken == null) throw new Error("maxToken is required");
+    if (refillRate == null) throw new Error("refillRate is required");
+
+    if (refillRate <= 0) {
+  throw new Error("refillRate must be greater than 0");
+}
+
+if (maxToken <= 0) {
+  throw new Error("maxToken must be greater than 0");
+}
 
     this.#store = new RedisStore(redisClient);
     this.#windowSize = windowSize;
@@ -23,72 +31,86 @@ export class RateLimiter {
     this.#refillRate = refillRate;
   }
 
-  async consume(identifier){
-    const now = Date.now()
+  async consume(identifier) {
+    const now = Date.now();
 
-    const slidingResult = await this.#runSlidingWindow(identifier, now)
-    if(!slidingResult.allowed){
-        return {
-            allowed: false,
-            reason: 'rate_limit_exceeded',
-            resetAfter: slidingResult.resetAfter
-        }
+    const slidingResult = await this.#runSlidingWindow(identifier, now);
+    if (!slidingResult.allowed) {
+      return {
+        allowed: false,
+        reason: "rate_limit_exceeded",
+        resetAfter: slidingResult.resetAfter,
+      };
     }
 
-    const bucketResult = await this.#runTokenBucket(identifier, now)
-    if(!bucketResult.allowed){
-        return {
-            allowed: false,
-            reason: 'burst_limit_exceeded',
-            retryAfter: bucketResult.retryAfter
-        }
+    const bucketResult = await this.#runTokenBucket(identifier, now);
+    if (!bucketResult.allowed) {
+      return {
+        allowed: false,
+        reason: "burst_limit_exceeded",
+        retryAfter: bucketResult.retryAfter,
+      };
     }
 
     return {
-      allowed         : true,
-      remaining       : slidingResult.remaining,
-      tokensRemaining : bucketResult.tokensLeft
-    }
+      allowed: true,
+      remaining: slidingResult.remaining,
+      tokensRemaining: bucketResult.tokensLeft,
+    };
   }
 
-  async #runSlidingWindow(identifier,now){
-    const key = `rl:sliding:${identifier}`
-    const ttl = Math.ceil((this.#windowSize / 1000) * 2)
+  async #runSlidingWindow(identifier, now) {
+    const key = `rl:sliding:${identifier}`;
+    const ttl = Math.ceil((this.#windowSize / 1000) * 2);
+    console.log(typeof ttl, ttl);
+    console.log({
+      now,
+      maxToken : this.#maxToken,
+      refillRate : this.refillRate,
+      ttl,
+    });
 
     const result = await this.#store.evalScript(
-        slidingWindowScript,
-        key,
-        this.#windowSize,
-        this.#limit,
-        now,
-        ttl
-    )
+      slidingWindowScript,
+      key,
+      this.#windowSize,
+      this.#limit,
+      now,
+      ttl,
+    );
 
     return {
-        allowed : result[0] === 1,
-        current : result[1],
-        remaining : result[2],
-        resetAfter: result[3]
-    }
+      allowed: result[0] === 1,
+      current: result[1],
+      remaining: result[2],
+      resetAfter: result[3],
+    };
   }
 
   async #runTokenBucket(identifier, now) {
-    const key = `rl:bucket:${identifier}`
-    const ttl = Math.max(Math.ceil(this.#maxToken / this.#refillRate) * 2, 60)
-
+    const key = `rl:bucket:${identifier}`;
+    const ttl = Math.max(Math.ceil(this.#maxToken / this.#refillRate) * 2, 60);
+    
+    console.log({
+      now,
+      maxToken : this.#maxToken,
+      refillRate : this.refillRate,
+      ttl,
+    });
+    
     const result = await this.#store.evalScript(
       tokenBucketScript,
       key,
-      now,                
-      this.#maxToken,     
-      this.#refillRate,   
-      ttl                 
-    )
+      now,
+      this.#maxToken,
+      this.#refillRate,
+      ttl,
+    );
 
     return {
-      allowed    : result[0] === 1,
-      tokensLeft : result[1],
-      retryAfter : result[2]
-    }
-  }  
+      allowed: result[0] === 1,
+      tokensLeft: result[1],
+      retryAfter: result[2],
+    };
+  }
 }

package/src/scripts/slidingWindow.lua.js

@@ -21,7 +21,7 @@ export const slidingWindowScript = `
       'currentCount',  1,
       'previousCount', 0
     )
-    redis.call('EXPIRE', key, math.floor(ttl))
+    redis.call('PEXPIRE', key, math.floor(ttl))
     return { 1, 1, limit - 1, resetAfter }   -- ← 4 values
   end
 
@@ -55,7 +55,7 @@ export const slidingWindowScript = `
     'currentCount',  newCurrentCount,
     'previousCount', newPreviousCount
   )
-  redis.call('EXPIRE', key, math.floor(ttl))
+  redis.call('PEXPIRE', key, math.floor(ttl))
 
   local remaining = math.floor(limit - effectiveCount - 1)
   return { 1, newCurrentCount, remaining, resetAfter }   -- ← 4 values

package/src/scripts/throttler.lua.js

@@ -27,7 +27,7 @@ export const throttlerScript = `
 
   -- save and set TTL
   redis.call('HSET', key, 'nextAllowedTime', newNextAllowedTime)
-  redis.call('EXPIRE', key, math.floor(ttl))
+  redis.call('PEXPIRE', key, math.floor(ttl))
 
   -- return allowed + waitTime so Node.js knows how long to delay
   return { 1, math.max(waitTime, 0) }

package/src/scripts/tokenBucket.lua.js

@@ -15,7 +15,7 @@ export const tokenBucketScript = `
       'time',      now,
       'tokenLeft', maxToken - 1
     )
-    redis.call('EXPIRE', key, math.floor(ttl))
+    redis.call('PEXPIRE', key, math.floor(ttl))
     return { 1, maxToken - 1 }
   end
 
@@ -29,7 +29,7 @@ export const tokenBucketScript = `
       'time',      now,
       'tokenLeft', updatedToken
     )
-    redis.call('EXPIRE', key, math.floor(ttl))
+    redis.call('PEXPIRE', key, math.floor(ttl))
 
     local retryAfter = math.ceil((1 - updatedToken) / refillRate)
     return { 0, 0, retryAfter }
@@ -40,7 +40,7 @@ export const tokenBucketScript = `
     'time',      now,
     'tokenLeft', updatedToken - 1
   )
-  redis.call('EXPIRE', key, math.floor(ttl))
+  redis.call('PEXPIRE', key, math.floor(ttl))
 
   return { 1, updatedToken - 1, 0 }
 `