web-gatekeeper-js 1.0.10 → 1.2.0

package/package.json

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

package/src/scripts/slidingWindow.lua.js

@@ -1,30 +1,31 @@
 export const slidingWindowScript = `
-  local key         = KEYS[1]
-  local windowSize  = tonumber(ARGV[1])
-  local limit       = tonumber(ARGV[2])
-  local now         = tonumber(ARGV[3])
-  local ttl         = tonumber(ARGV[4])
+  local key        = KEYS[1]
+  local windowSize = math.floor(tonumber(ARGV[1]))
+  local limit      = math.floor(tonumber(ARGV[2]))
+  local now        = math.floor(tonumber(ARGV[3]))
+  local ttl        = math.floor(tonumber(ARGV[4]))
 
   local windowStart = math.floor(now / windowSize) * windowSize
+  local resetAfter  = math.ceil((windowSize - (now - windowStart)) / 1000)
 
-  local storedWindowStart = tonumber(redis.call('HGET', key, 'windowStart')   or 0)
-  local currentCount      = tonumber(redis.call('HGET', key, 'currentCount')  or 0)
-  local previousCount     = tonumber(redis.call('HGET', key, 'previousCount') or 0)
-
-  -- resetAfter calculated once, used in all returns
-  local resetAfter = math.ceil((windowSize - (now - windowStart)) / 1000)
+  -- check BEFORE reading
+  local rawWindowStart = redis.call('HGET', key, 'windowStart')
 
   -- first time user
-  if storedWindowStart == 0 then
+  if not rawWindowStart then
     redis.call('HSET', key,
       'windowStart',   windowStart,
       'currentCount',  1,
       'previousCount', 0
     )
-    redis.call('PEXPIRE', key, math.floor(ttl))
-    return { 1, 1, limit - 1, resetAfter }   -- ← 4 values
+    redis.call('EXPIRE', key, ttl)
+    return { 1, 1, limit - 1, resetAfter }
   end
 
+  local storedWindowStart = tonumber(rawWindowStart)
+  local currentCount      = tonumber(redis.call('HGET', key, 'currentCount'))
+  local previousCount     = tonumber(redis.call('HGET', key, 'previousCount'))
+
   local windowsPassed = math.floor((windowStart - storedWindowStart) / windowSize)
 
   local newPreviousCount = previousCount
@@ -42,12 +43,10 @@ export const slidingWindowScript = `
   local overlap        = 1 - (elapsedTime / (windowSize / 1000))
   local effectiveCount = (overlap * newPreviousCount) + newCurrentCount
 
-  -- blocked
   if effectiveCount >= limit then
-    return { 0, newCurrentCount, 0, resetAfter }   -- ← 4 values
+    return { 0, newCurrentCount, 0, resetAfter }
   end
 
-  -- allowed
   newCurrentCount = newCurrentCount + 1
 
   redis.call('HSET', key,
@@ -55,8 +54,8 @@ export const slidingWindowScript = `
     'currentCount',  newCurrentCount,
     'previousCount', newPreviousCount
   )
-  redis.call('PEXPIRE', key, math.floor(ttl))
+  redis.call('EXPIRE', key, ttl)
 
   local remaining = math.floor(limit - effectiveCount - 1)
-  return { 1, newCurrentCount, remaining, resetAfter }   -- ← 4 values
+  return { 1, newCurrentCount, remaining, resetAfter }
 `

package/src/scripts/throttler.lua.js

@@ -1,9 +1,9 @@
 export const throttlerScript = `
   local key        = KEYS[1]
-  local now        = tonumber(ARGV[1])
+  local now        = math.floor(tonumber(ARGV[1]))
   local refillRate = tonumber(ARGV[2])
-  local maxWait    = tonumber(ARGV[3])
-  local ttl        = tonumber(ARGV[4])
+  local maxWait    = math.floor(tonumber(ARGV[3]))
+  local ttl        = math.floor(tonumber(ARGV[4]))
 
   -- safely read nextAllowedTime
   local raw             = redis.call('HGET', key, 'nextAllowedTime')
@@ -14,21 +14,21 @@ export const throttlerScript = `
 
   -- reject if queue too full
   if waitTime > maxWait then
-    return { 0, waitTime }
+    return { 0, math.floor(waitTime) }
   end
 
   -- calculate new nextAllowedTime
   local newNextAllowedTime
   if waitTime <= 0 then
-    newNextAllowedTime = now + (1000 / refillRate)
+    newNextAllowedTime = math.floor(now + (1000 / refillRate))
   else
-    newNextAllowedTime = nextAllowedTime + (1000 / refillRate)
+    newNextAllowedTime = math.floor(nextAllowedTime + (1000 / refillRate))
   end
 
   -- save and set TTL
   redis.call('HSET', key, 'nextAllowedTime', newNextAllowedTime)
-  redis.call('PEXPIRE', key, math.floor(ttl))
+  redis.call('EXPIRE', key, math.floor(ttl))
 
   -- return allowed + waitTime so Node.js knows how long to delay
-  return { 1, math.max(waitTime, 0) }
+  return { 1, math.floor(math.max(waitTime, 0)) }
 `

package/src/scripts/tokenBucket.lua.js

@@ -1,46 +1,41 @@
 export const tokenBucketScript = `
   local key        = KEYS[1]
-  local now        = tonumber(ARGV[1])
+  local now        = math.floor(tonumber(ARGV[1]))
   local maxToken   = tonumber(ARGV[2])
   local refillRate = tonumber(ARGV[3])
-  local ttl        = tonumber(ARGV[4])
+  local ttl        = math.floor(tonumber(ARGV[4]))
 
-  -- read stored state (same as your hGetAll)
-  local lastReqTime = tonumber(redis.call('HGET', key, 'time')      or now)
-  local tokenLeft   = tonumber(redis.call('HGET', key, 'tokenLeft') or maxToken)
+  local rawTime   = redis.call('HGET', key, 'time')
+  local rawTokens = redis.call('HGET', key, 'tokenLeft')
 
-  -- first time user (same as your empty check)
-  if lastReqTime == nil or tokenLeft == nil then
+  -- first time user
+  if not rawTime then
     redis.call('HSET', key,
       'time',      now,
       'tokenLeft', maxToken - 1
     )
-    redis.call('PEXPIRE', key, math.floor(ttl))
-    return { 1, maxToken - 1 }
+    redis.call('EXPIRE', key, ttl)
+    return { 1, maxToken - 1, 0 }
   end
 
-  -- calculate refill (same as your timeElapsed and updatedToken)
-  local timeElapsed   = (now - lastReqTime) / 1000
-  local updatedToken  = math.min(tokenLeft + (timeElapsed * refillRate), maxToken)
+  local lastReqTime = tonumber(rawTime)
+  local tokenLeft   = tonumber(rawTokens)
 
-  -- block if not enough tokens (same as your updatedToken < 1)
-  if updatedToken < 1 then
-    redis.call('HSET', key,
-      'time',      now,
-      'tokenLeft', updatedToken
-    )
-    redis.call('PEXPIRE', key, math.floor(ttl))
+  local timeElapsed  = (now - lastReqTime) / 1000
+  local updatedToken = math.min(tokenLeft + (timeElapsed * refillRate), maxToken)
 
+  if updatedToken < 1 then
+    redis.call('HSET', key, 'time', now, 'tokenLeft', updatedToken)
+    redis.call('EXPIRE', key, ttl)
     local retryAfter = math.ceil((1 - updatedToken) / refillRate)
     return { 0, 0, retryAfter }
   end
 
-  -- allow — consume 1 token and save (same as your hSet)
   redis.call('HSET', key,
     'time',      now,
     'tokenLeft', updatedToken - 1
   )
-  redis.call('PEXPIRE', key, math.floor(ttl))
+  redis.call('EXPIRE', key, ttl)
 
-  return { 1, updatedToken - 1, 0 }
+  return { 1, math.floor(updatedToken - 1), 0 }
 `