@upstash/ratelimit 1.0.1 → 1.1.0-canary-1

package/dist/index.mjs

@@ -94,6 +94,12 @@ var Cache = class {
     this.cache.set(key, value);
     return value;
   }
+  pop(key) {
+    this.cache.delete(key);
+  }
+  empty() {
+    this.cache.clear();
+  }
 };
 
 // src/duration.ts
@@ -102,7 +108,7 @@ function ms(d) {
   if (!match) {
     throw new Error(`Unable to parse window size: ${d}`);
   }
-  const time = parseInt(match[1]);
+  const time = Number.parseInt(match[1]);
   const unit = match[2];
   switch (unit) {
     case "ms":
@@ -120,6 +126,115 @@ function ms(d) {
   }
 }
 
+// src/lua-scripts/multi.ts
+var fixedWindowLimitScript = `
+	local key           = KEYS[1]
+	local id            = ARGV[1]
+	local window        = ARGV[2]
+	local incrementBy   = tonumber(ARGV[3])
+
+	redis.call("HSET", key, id, incrementBy)
+	local fields = redis.call("HGETALL", key)
+	if #fields == 1 and tonumber(fields[1])==incrementBy then
+	-- The first time this key is set, and the value will be equal to incrementBy.
+	-- So we only need the expire command once
+	  redis.call("PEXPIRE", key, window)
+	end
+
+	return fields
+`;
+var fixedWindowRemainingTokensScript = `
+      local key = KEYS[1]
+      local tokens = 0
+
+      local fields = redis.call("HGETALL", key)
+
+      return fields
+    `;
+var slidingWindowLimitScript = `
+	local currentKey    = KEYS[1]           -- identifier including prefixes
+	local previousKey   = KEYS[2]           -- key of the previous bucket
+	local tokens        = tonumber(ARGV[1]) -- tokens per window
+	local now           = ARGV[2]           -- current timestamp in milliseconds
+	local window        = ARGV[3]           -- interval in milliseconds
+	local requestId     = ARGV[4]           -- uuid for this request
+	local incrementBy   = tonumber(ARGV[5]) -- custom rate, default is  1
+
+	local currentFields = redis.call("HGETALL", currentKey)
+	local requestsInCurrentWindow = 0
+	for i = 2, #currentFields, 2 do
+	requestsInCurrentWindow = requestsInCurrentWindow + tonumber(currentFields[i])
+	end
+
+	local previousFields = redis.call("HGETALL", previousKey)
+	local requestsInPreviousWindow = 0
+	for i = 2, #previousFields, 2 do
+	requestsInPreviousWindow = requestsInPreviousWindow + tonumber(previousFields[i])
+	end
+
+	local percentageInCurrent = ( now % window) / window
+	if requestsInPreviousWindow * (1 - percentageInCurrent ) + requestsInCurrentWindow >= tokens then
+	  return {currentFields, previousFields, false}
+	end
+
+	redis.call("HSET", currentKey, requestId, incrementBy)
+
+	if requestsInCurrentWindow == 0 then 
+	  -- The first time this key is set, the value will be equal to incrementBy.
+	  -- So we only need the expire command once
+	  redis.call("PEXPIRE", currentKey, window * 2 + 1000) -- Enough time to overlap with a new window + 1 second
+	end
+	return {currentFields, previousFields, true}
+`;
+var slidingWindowRemainingTokensScript = `
+	local currentKey    = KEYS[1]           -- identifier including prefixes
+	local previousKey   = KEYS[2]           -- key of the previous bucket
+	local now         	= ARGV[1]           -- current timestamp in milliseconds
+  	local window      	= ARGV[2]           -- interval in milliseconds
+
+	local currentFields = redis.call("HGETALL", currentKey)
+	local requestsInCurrentWindow = 0
+	for i = 2, #currentFields, 2 do
+	requestsInCurrentWindow = requestsInCurrentWindow + tonumber(currentFields[i])
+	end
+
+	local previousFields = redis.call("HGETALL", previousKey)
+	local requestsInPreviousWindow = 0
+	for i = 2, #previousFields, 2 do
+	requestsInPreviousWindow = requestsInPreviousWindow + tonumber(previousFields[i])
+	end
+
+	local percentageInCurrent = ( now % window) / window
+  	requestsInPreviousWindow = math.floor(( 1 - percentageInCurrent ) * requestsInPreviousWindow)
+	
+	return requestsInCurrentWindow + requestsInPreviousWindow
+`;
+
+// src/lua-scripts/reset.ts
+var resetScript = `
+      local pattern = KEYS[1]
+
+      -- Initialize cursor to start from 0
+      local cursor = "0"
+
+      repeat
+          -- Scan for keys matching the pattern
+          local scan_result = redis.call('SCAN', cursor, 'MATCH', pattern)
+
+          -- Extract cursor for the next iteration
+          cursor = scan_result[1]
+
+          -- Extract keys from the scan result
+          local keys = scan_result[2]
+
+          for i=1, #keys do
+          redis.call('DEL', keys[i])
+          end
+
+      -- Continue scanning until cursor is 0 (end of keyspace)
+      until cursor == "0"
+    `;
+
 // src/ratelimit.ts
 var Ratelimit = class {
   limiter;
@@ -160,12 +275,29 @@ var Ratelimit = class {
    *  }
    *  return "Yes"
    * ```
+   *
+   * @param req.rate - The rate at which tokens will be added or consumed from the token bucket. A higher rate allows for more requests to be processed. Defaults to 1 token per interval if not specified.
+   *
+   * Usage with `req.rate`
+   * @example
+   * ```ts
+   *  const ratelimit = new Ratelimit({
+   *    redis: Redis.fromEnv(),
+   *    limiter: Ratelimit.slidingWindow(100, "10 s")
+   *  })
+   *
+   *  const { success } = await ratelimit.limit(id, {rate: 10})
+   *  if (!success){
+   *    return "Nope"
+   *  }
+   *  return "Yes"
+   * ```
    */
   limit = async (identifier, req) => {
     const key = [this.prefix, identifier].join(":");
     let timeoutId = null;
     try {
-      const arr = [this.limiter(this.ctx, key)];
+      const arr = [this.limiter().limit(this.ctx, key, req?.rate)];
       if (this.timeout > 0) {
         arr.push(
           new Promise((resolve) => {
@@ -249,6 +381,14 @@ var Ratelimit = class {
     }
     return res;
   };
+  resetUsedTokens = async (identifier) => {
+    const pattern = [this.prefix, identifier].join(":");
+    await this.limiter().resetTokens(this.ctx, pattern);
+  };
+  getRemaining = async (identifier) => {
+    const pattern = [this.prefix, identifier].join(":");
+    return await this.limiter().getRemaining(this.ctx, pattern);
+  };
 };
 
 // src/multi.ts
@@ -297,72 +437,122 @@ var MultiRegionRatelimit = class extends Ratelimit {
    */
   static fixedWindow(tokens, window) {
     const windowDuration = ms(window);
-    const script = `
-    local key     = KEYS[1]
-    local id      = ARGV[1]
-    local window  = ARGV[2]
-    
-    redis.call("SADD", key, id)
-    local members = redis.call("SMEMBERS", key)
-    if #members == 1 then
-    -- The first time this key is set, the value will be 1.
-    -- So we only need the expire command once
-      redis.call("PEXPIRE", key, window)
-    end
-    
-    return members
-`;
-    return async function(ctx, identifier) {
-      if (ctx.cache) {
-        const { blocked, reset: reset2 } = ctx.cache.isBlocked(identifier);
-        if (blocked) {
-          return {
-            success: false,
-            limit: tokens,
-            remaining: 0,
-            reset: reset2,
-            pending: Promise.resolve()
-          };
+    return () => ({
+      async limit(ctx, identifier, rate) {
+        if (ctx.cache) {
+          const { blocked, reset: reset2 } = ctx.cache.isBlocked(identifier);
+          if (blocked) {
+            return {
+              success: false,
+              limit: tokens,
+              remaining: 0,
+              reset: reset2,
+              pending: Promise.resolve()
+            };
+          }
         }
-      }
-      const requestId = randomId();
-      const bucket = Math.floor(Date.now() / windowDuration);
-      const key = [identifier, bucket].join(":");
-      const dbs = ctx.redis.map((redis) => ({
-        redis,
-        request: redis.eval(script, [key], [requestId, windowDuration])
-      }));
-      const firstResponse = await Promise.any(dbs.map((s) => s.request));
-      const usedTokens = firstResponse.length;
-      const remaining = tokens - usedTokens - 1;
-      async function sync() {
-        const individualIDs = await Promise.all(dbs.map((s) => s.request));
-        const allIDs = Array.from(new Set(individualIDs.flatMap((_) => _)).values());
-        for (const db of dbs) {
-          const ids = await db.request;
-          if (ids.length >= tokens) {
-            continue;
+        const requestId = randomId();
+        const bucket = Math.floor(Date.now() / windowDuration);
+        const key = [identifier, bucket].join(":");
+        const incrementBy = rate ? Math.max(1, rate) : 1;
+        const dbs = ctx.redis.map((redis) => ({
+          redis,
+          request: redis.eval(
+            fixedWindowLimitScript,
+            [key],
+            [requestId, windowDuration, incrementBy]
+          )
+        }));
+        const firstResponse = await Promise.any(dbs.map((s) => s.request));
+        const usedTokens = firstResponse.reduce((accTokens, usedToken, index) => {
+          let parsedToken = 0;
+          if (index % 2) {
+            parsedToken = Number.parseInt(usedToken);
           }
-          const diff = allIDs.filter((id) => !ids.includes(id));
-          if (diff.length === 0) {
-            continue;
+          return accTokens + parsedToken;
+        }, 0);
+        const remaining = tokens - usedTokens;
+        async function sync() {
+          const individualIDs = await Promise.all(dbs.map((s) => s.request));
+          const allIDs = Array.from(
+            new Set(
+              individualIDs.flatMap((_) => _).reduce((acc, curr, index) => {
+                if (index % 2 === 0) {
+                  acc.push(curr);
+                }
+                return acc;
+              }, [])
+            ).values()
+          );
+          for (const db of dbs) {
+            const usedDbTokens = (await db.request).reduce(
+              (accTokens, usedToken, index) => {
+                let parsedToken = 0;
+                if (index % 2) {
+                  parsedToken = Number.parseInt(usedToken);
+                }
+                return accTokens + parsedToken;
+              },
+              0
+            );
+            const dbIds = (await db.request).reduce((ids, currentId, index) => {
+              if (index % 2 === 0) {
+                ids.push(currentId);
+              }
+              return ids;
+            }, []);
+            if (usedDbTokens >= tokens) {
+              continue;
+            }
+            const diff = allIDs.filter((id) => !dbIds.includes(id));
+            if (diff.length === 0) {
+              continue;
+            }
+            for (const requestId2 of diff) {
+              await db.redis.hset(key, { [requestId2]: incrementBy });
+            }
           }
-          await db.redis.sadd(key, ...allIDs);
+        }
+        const success = remaining > 0;
+        const reset = (bucket + 1) * windowDuration;
+        if (ctx.cache && !success) {
+          ctx.cache.blockUntil(identifier, reset);
+        }
+        return {
+          success,
+          limit: tokens,
+          remaining,
+          reset,
+          pending: sync()
+        };
+      },
+      async getRemaining(ctx, identifier) {
+        const bucket = Math.floor(Date.now() / windowDuration);
+        const key = [identifier, bucket].join(":");
+        const dbs = ctx.redis.map((redis) => ({
+          redis,
+          request: redis.eval(fixedWindowRemainingTokensScript, [key], [null])
+        }));
+        const firstResponse = await Promise.any(dbs.map((s) => s.request));
+        const usedTokens = firstResponse.reduce((accTokens, usedToken, index) => {
+          let parsedToken = 0;
+          if (index % 2) {
+            parsedToken = Number.parseInt(usedToken);
+          }
+          return accTokens + parsedToken;
+        }, 0);
+        return Math.max(0, tokens - usedTokens);
+      },
+      async resetTokens(ctx, identifier) {
+        const pattern = [identifier, "*"].join(":");
+        if (ctx.cache) {
+          ctx.cache.pop(identifier);
+        }
+        for (const db of ctx.redis) {
+          await db.eval(resetScript, [pattern], [null]);
         }
       }
-      const success = remaining > 0;
-      const reset = (bucket + 1) * windowDuration;
-      if (ctx.cache && !success) {
-        ctx.cache.blockUntil(identifier, reset);
-      }
-      return {
-        success,
-        limit: tokens,
-        remaining,
-        reset,
-        pending: sync()
-      };
-    };
+    });
   }
   /**
    * Combined approach of `slidingLogs` and `fixedWindow` with lower storage
@@ -382,86 +572,277 @@ var MultiRegionRatelimit = class extends Ratelimit {
    */
   static slidingWindow(tokens, window) {
     const windowSize = ms(window);
-    const script = `
-      local currentKey  = KEYS[1]           -- identifier including prefixes
-      local previousKey = KEYS[2]           -- key of the previous bucket
-      local tokens      = tonumber(ARGV[1]) -- tokens per window
-      local now         = ARGV[2]           -- current timestamp in milliseconds
-      local window      = ARGV[3]           -- interval in milliseconds
-      local requestId   = ARGV[4]           -- uuid for this request
-
-
-      local currentMembers = redis.call("SMEMBERS", currentKey)
-      local requestsInCurrentWindow = #currentMembers
-      local previousMembers = redis.call("SMEMBERS", previousKey)
-      local requestsInPreviousWindow = #previousMembers
-
-      local percentageInCurrent = ( now % window) / window
-      if requestsInPreviousWindow * ( 1 - percentageInCurrent ) + requestsInCurrentWindow >= tokens then
-        return {currentMembers, previousMembers, false}
-      end
-
-      redis.call("SADD", currentKey, requestId)
-      table.insert(currentMembers, requestId)
-      if requestsInCurrentWindow == 0 then 
-        -- The first time this key is set, the value will be 1.
-        -- So we only need the expire command once
-        redis.call("PEXPIRE", currentKey, window * 2 + 1000) -- Enough time to overlap with a new window + 1 second
-      end
-      return {currentMembers, previousMembers, true}
-      `;
     const windowDuration = ms(window);
-    return async function(ctx, identifier) {
-      const requestId = randomId();
-      const now = Date.now();
-      const currentWindow = Math.floor(now / windowSize);
-      const currentKey = [identifier, currentWindow].join(":");
-      const previousWindow = currentWindow - 1;
-      const previousKey = [identifier, previousWindow].join(":");
-      const dbs = ctx.redis.map((redis) => ({
-        redis,
-        request: redis.eval(
-          script,
-          [currentKey, previousKey],
-          [tokens, now, windowDuration, requestId]
-          // lua seems to return `1` for true and `null` for false
-        )
-      }));
-      const percentageInCurrent = now % windowDuration / windowDuration;
-      const [current, previous, success] = await Promise.any(dbs.map((s) => s.request));
-      const previousPartialUsed = previous.length * (1 - percentageInCurrent);
-      const usedTokens = previousPartialUsed + current.length;
-      const remaining = tokens - usedTokens;
-      async function sync() {
-        const res = await Promise.all(dbs.map((s) => s.request));
-        const allCurrentIds = res.flatMap(([current2]) => current2);
-        for (const db of dbs) {
-          const [ids] = await db.request;
-          if (ids.length >= tokens) {
-            continue;
+    return () => ({
+      async limit(ctx, identifier, rate) {
+        const requestId = randomId();
+        const now = Date.now();
+        const currentWindow = Math.floor(now / windowSize);
+        const currentKey = [identifier, currentWindow].join(":");
+        const previousWindow = currentWindow - 1;
+        const previousKey = [identifier, previousWindow].join(":");
+        const incrementBy = rate ? Math.max(1, rate) : 1;
+        const dbs = ctx.redis.map((redis) => ({
+          redis,
+          request: redis.eval(
+            slidingWindowLimitScript,
+            [currentKey, previousKey],
+            [tokens, now, windowDuration, requestId, incrementBy]
+            // lua seems to return `1` for true and `null` for false
+          )
+        }));
+        const percentageInCurrent = now % windowDuration / windowDuration;
+        const [current, previous, success] = await Promise.any(dbs.map((s) => s.request));
+        const previousUsedTokens = previous.reduce((accTokens, usedToken, index) => {
+          let parsedToken = 0;
+          if (index % 2) {
+            parsedToken = Number.parseInt(usedToken);
           }
-          const diff = allCurrentIds.filter((id) => !ids.includes(id));
-          if (diff.length === 0) {
-            continue;
+          return accTokens + parsedToken;
+        }, 0);
+        const currentUsedTokens = current.reduce((accTokens, usedToken, index) => {
+          let parsedToken = 0;
+          if (index % 2) {
+            parsedToken = Number.parseInt(usedToken);
+          }
+          return accTokens + parsedToken;
+        }, 0);
+        const previousPartialUsed = previousUsedTokens * (1 - percentageInCurrent);
+        const usedTokens = previousPartialUsed + currentUsedTokens;
+        const remaining = tokens - usedTokens;
+        async function sync() {
+          const res = await Promise.all(dbs.map((s) => s.request));
+          const allCurrentIds = res.flatMap(([current2]) => current2).reduce((accCurrentIds, curr, index) => {
+            if (index % 2 === 0) {
+              accCurrentIds.push(curr);
+            }
+            return accCurrentIds;
+          }, []);
+          for (const db of dbs) {
+            const [_current, previous2, _success] = await db.request;
+            const dbIds = previous2.reduce((ids, currentId, index) => {
+              if (index % 2 === 0) {
+                ids.push(currentId);
+              }
+              return ids;
+            }, []);
+            const usedDbTokens = previous2.reduce((accTokens, usedToken, index) => {
+              let parsedToken = 0;
+              if (index % 2) {
+                parsedToken = Number.parseInt(usedToken);
+              }
+              return accTokens + parsedToken;
+            }, 0);
+            if (usedDbTokens >= tokens) {
+              continue;
+            }
+            const diff = allCurrentIds.filter((id) => !dbIds.includes(id));
+            if (diff.length === 0) {
+              continue;
+            }
+            for (const requestId2 of diff) {
+              await db.redis.hset(currentKey, { [requestId2]: incrementBy });
+            }
           }
-          await db.redis.sadd(currentKey, ...diff);
+        }
+        const reset = (currentWindow + 1) * windowDuration;
+        if (ctx.cache && !success) {
+          ctx.cache.blockUntil(identifier, reset);
+        }
+        return {
+          success: Boolean(success),
+          limit: tokens,
+          remaining: Math.max(0, remaining),
+          reset,
+          pending: sync()
+        };
+      },
+      async getRemaining(ctx, identifier) {
+        const now = Date.now();
+        const currentWindow = Math.floor(now / windowSize);
+        const currentKey = [identifier, currentWindow].join(":");
+        const previousWindow = currentWindow - 1;
+        const previousKey = [identifier, previousWindow].join(":");
+        const dbs = ctx.redis.map((redis) => ({
+          redis,
+          request: redis.eval(
+            slidingWindowRemainingTokensScript,
+            [currentKey, previousKey],
+            [now, windowSize]
+            // lua seems to return `1` for true and `null` for false
+          )
+        }));
+        const usedTokens = await Promise.any(dbs.map((s) => s.request));
+        return Math.max(0, tokens - usedTokens);
+      },
+      async resetTokens(ctx, identifier) {
+        const pattern = [identifier, "*"].join(":");
+        if (ctx.cache) {
+          ctx.cache.pop(identifier);
+        }
+        for (const db of ctx.redis) {
+          await db.eval(resetScript, [pattern], [null]);
         }
       }
-      const reset = (currentWindow + 1) * windowDuration;
-      if (ctx.cache && !success) {
-        ctx.cache.blockUntil(identifier, reset);
-      }
-      return {
-        success: Boolean(success),
-        limit: tokens,
-        remaining,
-        reset,
-        pending: sync()
-      };
-    };
+    });
   }
 };
 
+// src/lua-scripts/single.ts
+var fixedWindowLimitScript2 = `
+  local key           = KEYS[1]
+  local window        = ARGV[1]
+  local incrementBy   = ARGV[2] -- increment rate per request at a given value, default is 1
+
+  local r = redis.call("INCRBY", key, incrementBy)
+  if r == tonumber(incrementBy) then
+  -- The first time this key is set, the value will be equal to incrementBy.
+  -- So we only need the expire command once
+  redis.call("PEXPIRE", key, window)
+  end
+
+  return r
+`;
+var fixedWindowRemainingTokensScript2 = `
+      local key = KEYS[1]
+      local tokens = 0
+
+      local value = redis.call('GET', key)
+      if value then
+          tokens = value
+      end
+      return tokens
+    `;
+var slidingWindowLimitScript2 = `
+  local currentKey  = KEYS[1]           -- identifier including prefixes
+  local previousKey = KEYS[2]           -- key of the previous bucket
+  local tokens      = tonumber(ARGV[1]) -- tokens per window
+  local now         = ARGV[2]           -- current timestamp in milliseconds
+  local window      = ARGV[3]           -- interval in milliseconds
+  local incrementBy = ARGV[4]           -- increment rate per request at a given value, default is 1
+
+  local requestsInCurrentWindow = redis.call("GET", currentKey)
+  if requestsInCurrentWindow == false then
+    requestsInCurrentWindow = 0
+  end
+
+  local requestsInPreviousWindow = redis.call("GET", previousKey)
+  if requestsInPreviousWindow == false then
+    requestsInPreviousWindow = 0
+  end
+  local percentageInCurrent = ( now % window ) / window
+  -- weighted requests to consider from the previous window
+  requestsInPreviousWindow = math.floor(( 1 - percentageInCurrent ) * requestsInPreviousWindow)
+  if requestsInPreviousWindow + requestsInCurrentWindow >= tokens then
+    return -1
+  end
+
+  local newValue = redis.call("INCRBY", currentKey, incrementBy)
+  if newValue == tonumber(incrementBy) then
+    -- The first time this key is set, the value will be equal to incrementBy.
+    -- So we only need the expire command once
+    redis.call("PEXPIRE", currentKey, window * 2 + 1000) -- Enough time to overlap with a new window + 1 second
+  end
+  return tokens - ( newValue + requestsInPreviousWindow )
+`;
+var slidingWindowRemainingTokensScript2 = `
+  local currentKey  = KEYS[1]           -- identifier including prefixes
+  local previousKey = KEYS[2]           -- key of the previous bucket
+  local now         = ARGV[1]           -- current timestamp in milliseconds
+  local window      = ARGV[2]           -- interval in milliseconds
+
+  local requestsInCurrentWindow = redis.call("GET", currentKey)
+  if requestsInCurrentWindow == false then
+    requestsInCurrentWindow = 0
+  end
+
+  local requestsInPreviousWindow = redis.call("GET", previousKey)
+  if requestsInPreviousWindow == false then
+    requestsInPreviousWindow = 0
+  end
+
+  local percentageInCurrent = ( now % window ) / window
+  -- weighted requests to consider from the previous window
+  requestsInPreviousWindow = math.floor(( 1 - percentageInCurrent ) * requestsInPreviousWindow)
+
+  return requestsInPreviousWindow + requestsInCurrentWindow
+`;
+var tokenBucketLimitScript = `
+  local key         = KEYS[1]           -- identifier including prefixes
+  local maxTokens   = tonumber(ARGV[1]) -- maximum number of tokens
+  local interval    = tonumber(ARGV[2]) -- size of the window in milliseconds
+  local refillRate  = tonumber(ARGV[3]) -- how many tokens are refilled after each interval
+  local now         = tonumber(ARGV[4]) -- current timestamp in milliseconds
+  local incrementBy = tonumber(ARGV[5]) -- how many tokens to consume, default is 1
+        
+  local bucket = redis.call("HMGET", key, "refilledAt", "tokens")
+        
+  local refilledAt
+  local tokens
+
+  if bucket[1] == false then
+    refilledAt = now
+    tokens = maxTokens
+  else
+    refilledAt = tonumber(bucket[1])
+    tokens = tonumber(bucket[2])
+  end
+        
+  if now >= refilledAt + interval then
+    local numRefills = math.floor((now - refilledAt) / interval)
+    tokens = math.min(maxTokens, tokens + numRefills * refillRate)
+
+    refilledAt = refilledAt + numRefills * interval
+  end
+
+  if tokens == 0 then
+    return {-1, refilledAt + interval}
+  end
+
+  local remaining = tokens - incrementBy
+  local expireAt = math.ceil(((maxTokens - remaining) / refillRate)) * interval
+        
+  redis.call("HSET", key, "refilledAt", refilledAt, "tokens", remaining)
+  redis.call("PEXPIRE", key, expireAt)
+  return {remaining, refilledAt + interval}
+`;
+var tokenBucketRemainingTokensScript = `
+  local key         = KEYS[1]
+  local maxTokens   = tonumber(ARGV[1])
+        
+  local bucket = redis.call("HMGET", key, "tokens")
+
+  if bucket[1] == false then
+    return maxTokens
+  end
+        
+  return tonumber(bucket[1])
+`;
+var cachedFixedWindowLimitScript = `
+  local key     = KEYS[1]
+  local window  = ARGV[1]
+  local incrementBy   = ARGV[2] -- increment rate per request at a given value, default is 1
+
+  local r = redis.call("INCRBY", key, incrementBy)
+  if r == incrementBy then
+  -- The first time this key is set, the value will be equal to incrementBy.
+  -- So we only need the expire command once
+  redis.call("PEXPIRE", key, window)
+  end
+      
+  return r
+`;
+var cachedFixedWindowRemainingTokenScript = `
+  local key = KEYS[1]
+  local tokens = 0
+
+  local value = redis.call('GET', key)
+  if value then
+      tokens = value
+  end
+  return tokens
+`;
+
 // src/single.ts
 var RegionRatelimit = class extends Ratelimit {
   /**
@@ -499,52 +880,60 @@ var RegionRatelimit = class extends Ratelimit {
    */
   static fixedWindow(tokens, window) {
     const windowDuration = ms(window);
-    const script = `
-    local key     = KEYS[1]
-    local window  = ARGV[1]
-    
-    local r = redis.call("INCR", key)
-    if r == 1 then 
-    -- The first time this key is set, the value will be 1.
-    -- So we only need the expire command once
-    redis.call("PEXPIRE", key, window)
-    end
-    
-    return r
-    `;
-    return async function(ctx, identifier) {
-      const bucket = Math.floor(Date.now() / windowDuration);
-      const key = [identifier, bucket].join(":");
-      if (ctx.cache) {
-        const { blocked, reset: reset2 } = ctx.cache.isBlocked(identifier);
-        if (blocked) {
-          return {
-            success: false,
-            limit: tokens,
-            remaining: 0,
-            reset: reset2,
-            pending: Promise.resolve()
-          };
+    return () => ({
+      async limit(ctx, identifier, rate) {
+        const bucket = Math.floor(Date.now() / windowDuration);
+        const key = [identifier, bucket].join(":");
+        if (ctx.cache) {
+          const { blocked, reset: reset2 } = ctx.cache.isBlocked(identifier);
+          if (blocked) {
+            return {
+              success: false,
+              limit: tokens,
+              remaining: 0,
+              reset: reset2,
+              pending: Promise.resolve()
+            };
+          }
         }
+        const incrementBy = rate ? Math.max(1, rate) : 1;
+        const usedTokensAfterUpdate = await ctx.redis.eval(
+          fixedWindowLimitScript2,
+          [key],
+          [windowDuration, incrementBy]
+        );
+        const success = usedTokensAfterUpdate <= tokens;
+        const remainingTokens = Math.max(0, tokens - usedTokensAfterUpdate);
+        const reset = (bucket + 1) * windowDuration;
+        if (ctx.cache && !success) {
+          ctx.cache.blockUntil(identifier, reset);
+        }
+        return {
+          success,
+          limit: tokens,
+          remaining: remainingTokens,
+          reset,
+          pending: Promise.resolve()
+        };
+      },
+      async getRemaining(ctx, identifier) {
+        const bucket = Math.floor(Date.now() / windowDuration);
+        const key = [identifier, bucket].join(":");
+        const usedTokens = await ctx.redis.eval(
+          fixedWindowRemainingTokensScript2,
+          [key],
+          [null]
+        );
+        return Math.max(0, tokens - usedTokens);
+      },
+      async resetTokens(ctx, identifier) {
+        const pattern = [identifier, "*"].join(":");
+        if (ctx.cache) {
+          ctx.cache.pop(identifier);
+        }
+        await ctx.redis.eval(resetScript, [pattern], [null]);
       }
-      const usedTokensAfterUpdate = await ctx.redis.eval(
-        script,
-        [key],
-        [windowDuration]
-      );
-      const success = usedTokensAfterUpdate <= tokens;
-      const reset = (bucket + 1) * windowDuration;
-      if (ctx.cache && !success) {
-        ctx.cache.blockUntil(identifier, reset);
-      }
-      return {
-        success,
-        limit: tokens,
-        remaining: Math.max(0, tokens - usedTokensAfterUpdate),
-        reset,
-        pending: Promise.resolve()
-      };
-    };
+    });
   }
   /**
    * Combined approach of `slidingLogs` and `fixedWindow` with lower storage
@@ -563,74 +952,66 @@ var RegionRatelimit = class extends Ratelimit {
    * @param window - The duration in which the user can max X requests.
    */
   static slidingWindow(tokens, window) {
-    const script = `
-      local currentKey  = KEYS[1]           -- identifier including prefixes
-      local previousKey = KEYS[2]           -- key of the previous bucket
-      local tokens      = tonumber(ARGV[1]) -- tokens per window
-      local now         = ARGV[2]           -- current timestamp in milliseconds
-      local window      = ARGV[3]           -- interval in milliseconds
-
-      local requestsInCurrentWindow = redis.call("GET", currentKey)
-      if requestsInCurrentWindow == false then
-        requestsInCurrentWindow = 0
-      end
-
-      local requestsInPreviousWindow = redis.call("GET", previousKey)
-      if requestsInPreviousWindow == false then
-        requestsInPreviousWindow = 0
-      end
-      local percentageInCurrent = ( now % window ) / window
-      -- weighted requests to consider from the previous window
-      requestsInPreviousWindow = math.floor(( 1 - percentageInCurrent ) * requestsInPreviousWindow)
-      if requestsInPreviousWindow + requestsInCurrentWindow >= tokens then
-        return -1
-      end
-
-      local newValue = redis.call("INCR", currentKey)
-      if newValue == 1 then 
-        -- The first time this key is set, the value will be 1.
-        -- So we only need the expire command once
-        redis.call("PEXPIRE", currentKey, window * 2 + 1000) -- Enough time to overlap with a new window + 1 second
-      end
-      return tokens - ( newValue + requestsInPreviousWindow )
-      `;
     const windowSize = ms(window);
-    return async function(ctx, identifier) {
-      const now = Date.now();
-      const currentWindow = Math.floor(now / windowSize);
-      const currentKey = [identifier, currentWindow].join(":");
-      const previousWindow = currentWindow - 1;
-      const previousKey = [identifier, previousWindow].join(":");
-      if (ctx.cache) {
-        const { blocked, reset: reset2 } = ctx.cache.isBlocked(identifier);
-        if (blocked) {
-          return {
-            success: false,
-            limit: tokens,
-            remaining: 0,
-            reset: reset2,
-            pending: Promise.resolve()
-          };
+    return () => ({
+      async limit(ctx, identifier, rate) {
+        const now = Date.now();
+        const currentWindow = Math.floor(now / windowSize);
+        const currentKey = [identifier, currentWindow].join(":");
+        const previousWindow = currentWindow - 1;
+        const previousKey = [identifier, previousWindow].join(":");
+        if (ctx.cache) {
+          const { blocked, reset: reset2 } = ctx.cache.isBlocked(identifier);
+          if (blocked) {
+            return {
+              success: false,
+              limit: tokens,
+              remaining: 0,
+              reset: reset2,
+              pending: Promise.resolve()
+            };
+          }
         }
+        const incrementBy = rate ? Math.max(1, rate) : 1;
+        const remainingTokens = await ctx.redis.eval(
+          slidingWindowLimitScript2,
+          [currentKey, previousKey],
+          [tokens, now, windowSize, incrementBy]
+        );
+        const success = remainingTokens >= 0;
+        const reset = (currentWindow + 1) * windowSize;
+        if (ctx.cache && !success) {
+          ctx.cache.blockUntil(identifier, reset);
+        }
+        return {
+          success,
+          limit: tokens,
+          remaining: Math.max(0, remainingTokens),
+          reset,
+          pending: Promise.resolve()
+        };
+      },
+      async getRemaining(ctx, identifier) {
+        const now = Date.now();
+        const currentWindow = Math.floor(now / windowSize);
+        const currentKey = [identifier, currentWindow].join(":");
+        const previousWindow = currentWindow - 1;
+        const previousKey = [identifier, previousWindow].join(":");
+        const usedTokens = await ctx.redis.eval(
+          slidingWindowRemainingTokensScript2,
+          [currentKey, previousKey],
+          [now, windowSize]
+        );
+        return Math.max(0, tokens - usedTokens);
+      },
+      async resetTokens(ctx, identifier) {
+        const pattern = [identifier, "*"].join(":");
+        if (ctx.cache) {
+          ctx.cache.pop(identifier);
+        }
+        await ctx.redis.eval(resetScript, [pattern], [null]);
       }
-      const remaining = await ctx.redis.eval(
-        script,
-        [currentKey, previousKey],
-        [tokens, now, windowSize]
-      );
-      const success = remaining >= 0;
-      const reset = (currentWindow + 1) * windowSize;
-      if (ctx.cache && !success) {
-        ctx.cache.blockUntil(identifier, reset);
-      }
-      return {
-        success,
-        limit: tokens,
-        remaining: Math.max(0, remaining),
-        reset,
-        pending: Promise.resolve()
-      };
-    };
+    });
   }
   /**
    * You have a bucket filled with `{maxTokens}` tokens that refills constantly
@@ -646,76 +1027,56 @@ var RegionRatelimit = class extends Ratelimit {
    * than `refillRate`
    */
   static tokenBucket(refillRate, interval, maxTokens) {
-    const script = `
-        local key         = KEYS[1]           -- identifier including prefixes
-        local maxTokens   = tonumber(ARGV[1]) -- maximum number of tokens
-        local interval    = tonumber(ARGV[2]) -- size of the window in milliseconds
-        local refillRate  = tonumber(ARGV[3]) -- how many tokens are refilled after each interval
-        local now         = tonumber(ARGV[4]) -- current timestamp in milliseconds
-        
-        local bucket = redis.call("HMGET", key, "refilledAt", "tokens")
-        
-        local refilledAt
-        local tokens
-
-        if bucket[1] == false then
-          refilledAt = now
-          tokens = maxTokens
-        else
-          refilledAt = tonumber(bucket[1])
-          tokens = tonumber(bucket[2])
-        end
-        
-        if now >= refilledAt + interval then
-          local numRefills = math.floor((now - refilledAt) / interval)
-          tokens = math.min(maxTokens, tokens + numRefills * refillRate)
-
-          refilledAt = refilledAt + numRefills * interval
-        end
-
-        if tokens == 0 then
-          return {-1, refilledAt + interval}
-        end
-
-        local remaining = tokens - 1
-        local expireAt = math.ceil(((maxTokens - remaining) / refillRate)) * interval
-        
-        redis.call("HSET", key, "refilledAt", refilledAt, "tokens", remaining)
-        redis.call("PEXPIRE", key, expireAt)
-        return {remaining, refilledAt + interval}
-       `;
     const intervalDuration = ms(interval);
-    return async function(ctx, identifier) {
-      if (ctx.cache) {
-        const { blocked, reset: reset2 } = ctx.cache.isBlocked(identifier);
-        if (blocked) {
-          return {
-            success: false,
-            limit: maxTokens,
-            remaining: 0,
-            reset: reset2,
-            pending: Promise.resolve()
-          };
+    return () => ({
+      async limit(ctx, identifier, rate) {
+        if (ctx.cache) {
+          const { blocked, reset: reset2 } = ctx.cache.isBlocked(identifier);
+          if (blocked) {
+            return {
+              success: false,
+              limit: maxTokens,
+              remaining: 0,
+              reset: reset2,
+              pending: Promise.resolve()
+            };
+          }
         }
+        const now = Date.now();
+        const incrementBy = rate ? Math.max(1, rate) : 1;
+        const [remaining, reset] = await ctx.redis.eval(
+          tokenBucketLimitScript,
+          [identifier],
+          [maxTokens, intervalDuration, refillRate, now, incrementBy]
+        );
+        const success = remaining >= 0;
+        if (ctx.cache && !success) {
+          ctx.cache.blockUntil(identifier, reset);
+        }
+        return {
+          success,
+          limit: maxTokens,
+          remaining,
+          reset,
+          pending: Promise.resolve()
+        };
+      },
+      async getRemaining(ctx, identifier) {
+        const remainingTokens = await ctx.redis.eval(
+          tokenBucketRemainingTokensScript,
+          [identifier],
+          [maxTokens]
+        );
+        return remainingTokens;
+      },
+      async resetTokens(ctx, identifier) {
+        const pattern = identifier;
+        if (ctx.cache) {
+          ctx.cache.pop(identifier);
+        }
+        await ctx.redis.eval(resetScript, [pattern], [null]);
       }
-      const now = Date.now();
-      const [remaining, reset] = await ctx.redis.eval(
-        script,
-        [identifier],
-        [maxTokens, intervalDuration, refillRate, now]
-      );
-      const success = remaining >= 0;
-      if (ctx.cache && !success) {
-        ctx.cache.blockUntil(identifier, reset);
-      }
-      return {
-        success,
-        limit: maxTokens,
-        remaining,
-        reset,
-        pending: Promise.resolve()
-      };
-    };
+    });
   }
   /**
    * cachedFixedWindow first uses the local cache to decide if a request may pass and then updates
@@ -743,56 +1104,72 @@ var RegionRatelimit = class extends Ratelimit {
    */
   static cachedFixedWindow(tokens, window) {
     const windowDuration = ms(window);
-    const script = `
-      local key     = KEYS[1]
-      local window  = ARGV[1]
-      
-      local r = redis.call("INCR", key)
-      if r == 1 then 
-      -- The first time this key is set, the value will be 1.
-      -- So we only need the expire command once
-      redis.call("PEXPIRE", key, window)
-      end
-      
-      return r
-      `;
-    return async function(ctx, identifier) {
-      if (!ctx.cache) {
-        throw new Error("This algorithm requires a cache");
-      }
-      const bucket = Math.floor(Date.now() / windowDuration);
-      const key = [identifier, bucket].join(":");
-      const reset = (bucket + 1) * windowDuration;
-      const hit = typeof ctx.cache.get(key) === "number";
-      if (hit) {
-        const cachedTokensAfterUpdate = ctx.cache.incr(key);
-        const success = cachedTokensAfterUpdate < tokens;
-        const pending = success ? ctx.redis.eval(script, [key], [windowDuration]).then((t) => {
-          ctx.cache.set(key, t);
-        }) : Promise.resolve();
+    return () => ({
+      async limit(ctx, identifier, rate) {
+        if (!ctx.cache) {
+          throw new Error("This algorithm requires a cache");
+        }
+        const bucket = Math.floor(Date.now() / windowDuration);
+        const key = [identifier, bucket].join(":");
+        const reset = (bucket + 1) * windowDuration;
+        const incrementBy = rate ? Math.max(1, rate) : 1;
+        const hit = typeof ctx.cache.get(key) === "number";
+        if (hit) {
+          const cachedTokensAfterUpdate = ctx.cache.incr(key);
+          const success = cachedTokensAfterUpdate < tokens;
+          const pending = success ? ctx.redis.eval(cachedFixedWindowLimitScript, [key], [windowDuration, incrementBy]).then((t) => {
+            ctx.cache.set(key, t);
+          }) : Promise.resolve();
+          return {
+            success,
+            limit: tokens,
+            remaining: tokens - cachedTokensAfterUpdate,
+            reset,
+            pending
+          };
+        }
+        const usedTokensAfterUpdate = await ctx.redis.eval(
+          cachedFixedWindowLimitScript,
+          [key],
+          [windowDuration, incrementBy]
+        );
+        ctx.cache.set(key, usedTokensAfterUpdate);
+        const remaining = tokens - usedTokensAfterUpdate;
         return {
-          success,
+          success: remaining >= 0,
           limit: tokens,
-          remaining: tokens - cachedTokensAfterUpdate,
+          remaining,
           reset,
-          pending
+          pending: Promise.resolve()
         };
+      },
+      async getRemaining(ctx, identifier) {
+        if (!ctx.cache) {
+          throw new Error("This algorithm requires a cache");
+        }
+        const bucket = Math.floor(Date.now() / windowDuration);
+        const key = [identifier, bucket].join(":");
+        const hit = typeof ctx.cache.get(key) === "number";
+        if (hit) {
+          const cachedUsedTokens = ctx.cache.get(key) ?? 0;
+          return Math.max(0, tokens - cachedUsedTokens);
+        }
+        const usedTokens = await ctx.redis.eval(
+          cachedFixedWindowRemainingTokenScript,
+          [key],
+          [null]
+        );
+        return Math.max(0, tokens - usedTokens);
+      },
+      async resetTokens(ctx, identifier) {
+        const pattern = [identifier, "*"].join(":");
+        if (!ctx.cache) {
+          throw new Error("This algorithm requires a cache");
+        }
+        ctx.cache.pop(identifier);
+        await ctx.redis.eval(resetScript, [pattern], [null]);
       }
-      const usedTokensAfterUpdate = await ctx.redis.eval(
-        script,
-        [key],
-        [windowDuration]
-      );
-      ctx.cache.set(key, usedTokensAfterUpdate);
-      const remaining = tokens - usedTokensAfterUpdate;
-      return {
-        success: remaining >= 0,
-        limit: tokens,
-        remaining,
-        reset,
-        pending: Promise.resolve()
-      };
-    };
+    });
   }
 };
 export {