@upstash/ratelimit 1.0.3 → 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
@@ -121,7 +127,7 @@ function ms(d) {
 }
 
 // src/lua-scripts/multi.ts
-var fixedWindowScript = `
+var fixedWindowLimitScript = `
 	local key           = KEYS[1]
 	local id            = ARGV[1]
 	local window        = ARGV[2]
@@ -137,7 +143,15 @@ var fixedWindowScript = `
 
 	return fields
 `;
-var slidingWindowScript = `
+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
@@ -172,6 +186,54 @@ var slidingWindowScript = `
 	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 {
@@ -235,7 +297,7 @@ var Ratelimit = class {
     const key = [this.prefix, identifier].join(":");
     let timeoutId = null;
     try {
-      const arr = [this.limiter(this.ctx, key, req?.rate)];
+      const arr = [this.limiter().limit(this.ctx, key, req?.rate)];
       if (this.timeout > 0) {
         arr.push(
           new Promise((resolve) => {
@@ -319,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
@@ -367,91 +437,122 @@ var MultiRegionRatelimit = class extends Ratelimit {
    */
   static fixedWindow(tokens, window) {
     const windowDuration = ms(window);
-    return async (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 incrementBy = rate ? Math.max(1, rate) : 1;
-      const dbs = ctx.redis.map((redis) => ({
-        redis,
-        request: redis.eval(
-          fixedWindowScript,
-          [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);
+    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()
+            };
+          }
         }
-        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) => {
+        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);
+          }
+          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) {
-                acc.push(curr);
+                ids.push(currentId);
               }
-              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 ids;
+            }, []);
+            if (usedDbTokens >= tokens) {
+              continue;
             }
-            return accTokens + parsedToken;
-          }, 0);
-          const dbIds = (await db.request).reduce((ids, currentId, index) => {
-            if (index % 2 === 0) {
-              ids.push(currentId);
+            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 });
             }
-            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 });
+        }
+        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
@@ -472,100 +573,129 @@ var MultiRegionRatelimit = class extends Ratelimit {
   static slidingWindow(tokens, window) {
     const windowSize = ms(window);
     const windowDuration = ms(window);
-    return async (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(
-          slidingWindowScript,
-          [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);
-        }
-        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 () => ({
+      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);
           }
-          return accCurrentIds;
-        }, []);
-        for (const db of dbs) {
-          const [_current, previous2, _success] = await db.request;
-          const dbIds = previous2.reduce((ids, currentId, index) => {
+          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) {
-              ids.push(currentId);
+              accCurrentIds.push(curr);
             }
-            return ids;
+            return accCurrentIds;
           }, []);
-          const usedDbTokens = previous2.reduce((accTokens, usedToken, index) => {
-            let parsedToken = 0;
-            if (index % 2) {
-              parsedToken = Number.parseInt(usedToken);
+          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 });
             }
-            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 });
           }
         }
+        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: Math.max(0, remaining),
-        reset,
-        pending: sync()
-      };
-    };
+    });
   }
 };
 
 // src/lua-scripts/single.ts
-var fixedWindowScript2 = `
+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 == incrementBy then
+  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)
@@ -573,7 +703,17 @@ var fixedWindowScript2 = `
 
   return r
 `;
-var slidingWindowScript2 = `
+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
@@ -598,14 +738,36 @@ var slidingWindowScript2 = `
   end
 
   local newValue = redis.call("INCRBY", currentKey, incrementBy)
-  if newValue == incrementBy then
+  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 tokenBucketScript = `
+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
@@ -644,7 +806,19 @@ var tokenBucketScript = `
   redis.call("PEXPIRE", key, expireAt)
   return {remaining, refilledAt + interval}
 `;
-var cachedFixedWindowScript = `
+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
@@ -658,6 +832,16 @@ var cachedFixedWindowScript = `
       
   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 {
@@ -696,41 +880,60 @@ var RegionRatelimit = class extends Ratelimit {
    */
   static fixedWindow(tokens, window) {
     const windowDuration = ms(window);
-    return async (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()
-          };
+    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 incrementBy = rate ? Math.max(1, rate) : 1;
-      const usedTokensAfterUpdate = await ctx.redis.eval(
-        fixedWindowScript2,
-        [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()
-      };
-    };
+    });
   }
   /**
    * Combined approach of `slidingLogs` and `fixedWindow` with lower storage
@@ -750,43 +953,65 @@ var RegionRatelimit = class extends Ratelimit {
    */
   static slidingWindow(tokens, window) {
     const windowSize = ms(window);
-    return async (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()
-          };
+    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 incrementBy = rate ? Math.max(1, rate) : 1;
-      const remainingTokens = await ctx.redis.eval(
-        slidingWindowScript2,
-        [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()
-      };
-    };
+    });
   }
   /**
    * You have a bucket filled with `{maxTokens}` tokens that refills constantly
@@ -803,38 +1028,55 @@ var RegionRatelimit = class extends Ratelimit {
    */
   static tokenBucket(refillRate, interval, maxTokens) {
     const intervalDuration = ms(interval);
-    return async (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()
-          };
+    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 incrementBy = rate ? Math.max(1, rate) : 1;
-      const [remaining, reset] = await ctx.redis.eval(
-        tokenBucketScript,
-        [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()
-      };
-    };
+    });
   }
   /**
    * cachedFixedWindow first uses the local cache to decide if a request may pass and then updates
@@ -862,44 +1104,72 @@ var RegionRatelimit = class extends Ratelimit {
    */
   static cachedFixedWindow(tokens, window) {
     const windowDuration = ms(window);
-    return async (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(cachedFixedWindowScript, [key], [windowDuration, incrementBy]).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(
-        cachedFixedWindowScript,
-        [key],
-        [windowDuration, incrementBy]
-      );
-      ctx.cache.set(key, usedTokensAfterUpdate);
-      const remaining = tokens - usedTokensAfterUpdate;
-      return {
-        success: remaining >= 0,
-        limit: tokens,
-        remaining,
-        reset,
-        pending: Promise.resolve()
-      };
-    };
+    });
   }
 };
 export {