@upstash/ratelimit 2.0.6 → 2.0.7

package/dist/index.mjs

@@ -92,9 +92,9 @@ var Cache = class {
   get(key) {
     return this.cache.get(key) || null;
   }
-  incr(key) {
+  incr(key, incrementAmount = 1) {
     let value = this.cache.get(key) ?? 0;
-    value += 1;
+    value += incrementAmount;
     this.cache.set(key, value);
     return value;
   }
@@ -182,7 +182,7 @@ var slidingWindowLimitScript = `
   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 incrementBy = tonumber(ARGV[4]) -- increment rate per request at a given value, default is 1
 
   local requestsInCurrentWindow = redis.call("GET", currentKey)
   if requestsInCurrentWindow == false then
@@ -196,12 +196,14 @@ var slidingWindowLimitScript = `
   local percentageInCurrent = ( now % window ) / window
   -- weighted requests to consider from the previous window
   requestsInPreviousWindow = math.floor(( 1 - percentageInCurrent ) * requestsInPreviousWindow)
-  if requestsInPreviousWindow + requestsInCurrentWindow >= tokens then
+
+  -- Only check limit if not refunding (negative rate)
+  if incrementBy > 0 and requestsInPreviousWindow + requestsInCurrentWindow >= tokens then
     return -1
   end
 
   local newValue = redis.call("INCRBY", currentKey, incrementBy)
-  if newValue == tonumber(incrementBy) then
+  if newValue == 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
@@ -258,7 +260,8 @@ var tokenBucketLimitScript = `
     refilledAt = refilledAt + numRefills * interval
   end
 
-  if tokens == 0 then
+  -- Only reject if tokens are 0 and we're consuming (not refunding)
+  if tokens == 0 and incrementBy > 0 then
     return {-1, refilledAt + interval}
   end
 
@@ -266,7 +269,10 @@ var tokenBucketLimitScript = `
   local expireAt = math.ceil(((maxTokens - remaining) / refillRate)) * interval
         
   redis.call("HSET", key, "refilledAt", refilledAt, "tokens", remaining)
-  redis.call("PEXPIRE", key, expireAt)
+
+  if (expireAt > 0) then
+    redis.call("PEXPIRE", key, expireAt)
+  end
   return {remaining, refilledAt + interval}
 `;
 var tokenBucketIdentifierNotFound = -1;
@@ -354,7 +360,9 @@ var slidingWindowLimitScript2 = `
 	end
 
 	local percentageInCurrent = ( now % window) / window
-	if requestsInPreviousWindow * (1 - percentageInCurrent ) + requestsInCurrentWindow >= tokens then
+
+	-- Only check limit if not refunding (negative rate)
+	if incrementBy > 0 and requestsInPreviousWindow * (1 - percentageInCurrent ) + requestsInCurrentWindow + incrementBy > tokens then
 	  return {currentFields, previousFields, false}
 	end
 
@@ -432,7 +440,7 @@ var SCRIPTS = {
     slidingWindow: {
       limit: {
         script: slidingWindowLimitScript,
-        hash: "e1391e429b699c780eb0480350cd5b7280fd9213"
+        hash: "9b7842963bd73721f1a3011650c23c0010848ee3"
       },
       getRemaining: {
         script: slidingWindowRemainingTokensScript,
@@ -442,7 +450,7 @@ var SCRIPTS = {
     tokenBucket: {
       limit: {
         script: tokenBucketLimitScript,
-        hash: "5bece90aeef8189a8cfd28995b479529e270b3c6"
+        hash: "d1f857ebbdaeca90ccd2cd4eada61d7c8e5db1ca"
       },
       getRemaining: {
         script: tokenBucketRemainingTokensScript,
@@ -474,7 +482,7 @@ var SCRIPTS = {
     slidingWindow: {
       limit: {
         script: slidingWindowLimitScript2,
-        hash: "cb4fdc2575056df7c6d422764df0de3a08d6753b"
+        hash: "1e7ca8dcd2d600a6d0124a67a57ea225ed62921b"
       },
       getRemaining: {
         script: slidingWindowRemainingTokensScript2,
@@ -950,7 +958,11 @@ var MultiRegionRatelimit = class extends Ratelimit {
     const windowDuration = ms(window);
     return () => ({
       async limit(ctx, identifier, rate) {
-        if (ctx.cache) {
+        const requestId = randomId();
+        const bucket = Math.floor(Date.now() / windowDuration);
+        const key = [identifier, bucket].join(":");
+        const incrementBy = rate ?? 1;
+        if (ctx.cache && incrementBy > 0) {
           const { blocked, reset: reset2 } = ctx.cache.isBlocked(identifier);
           if (blocked) {
             return {
@@ -963,10 +975,6 @@ var MultiRegionRatelimit = class extends Ratelimit {
             };
           }
         }
-        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.regionContexts.map((regionContext) => ({
           redis: regionContext.redis,
           request: safeEval(
@@ -977,24 +985,29 @@ var MultiRegionRatelimit = class extends Ratelimit {
           )
         }));
         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 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 = [...new Set(
-            individualIDs.flat().reduce((acc, curr, index) => {
-              if (index % 2 === 0) {
-                acc.push(curr);
-              }
-              return acc;
-            }, [])
-          ).values()];
+          const allIDs = [
+            ...new Set(
+              individualIDs.flat().reduce((acc, curr, index) => {
+                if (index % 2 === 0) {
+                  acc.push(curr);
+                }
+                return acc;
+              }, [])
+            ).values()
+          ];
           for (const db of dbs) {
             const usedDbTokensRequest = await db.request;
             const usedDbTokens = usedDbTokensRequest.reduce(
@@ -1008,12 +1021,15 @@ var MultiRegionRatelimit = class extends Ratelimit {
               0
             );
             const dbIdsRequest = await db.request;
-            const dbIds = dbIdsRequest.reduce((ids, currentId, index) => {
-              if (index % 2 === 0) {
-                ids.push(currentId);
-              }
-              return ids;
-            }, []);
+            const dbIds = dbIdsRequest.reduce(
+              (ids, currentId, index) => {
+                if (index % 2 === 0) {
+                  ids.push(currentId);
+                }
+                return ids;
+              },
+              []
+            );
             if (usedDbTokens >= tokens) {
               continue;
             }
@@ -1026,10 +1042,14 @@ var MultiRegionRatelimit = class extends Ratelimit {
             }
           }
         }
-        const success = remaining > 0;
+        const success = remaining >= 0;
         const reset = (bucket + 1) * windowDuration;
-        if (ctx.cache && !success) {
-          ctx.cache.blockUntil(identifier, reset);
+        if (ctx.cache) {
+          if (!success) {
+            ctx.cache.blockUntil(identifier, reset);
+          } else if (incrementBy < 0) {
+            ctx.cache.pop(identifier);
+          }
         }
         return {
           success,
@@ -1052,13 +1072,16 @@ var MultiRegionRatelimit = class extends Ratelimit {
           )
         }));
         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 usedTokens = firstResponse.reduce(
+          (accTokens, usedToken, index) => {
+            let parsedToken = 0;
+            if (index % 2) {
+              parsedToken = Number.parseInt(usedToken);
+            }
+            return accTokens + parsedToken;
+          },
+          0
+        );
         return {
           remaining: Math.max(0, tokens - usedTokens),
           reset: (bucket + 1) * windowDuration
@@ -1069,14 +1092,11 @@ var MultiRegionRatelimit = class extends Ratelimit {
         if (ctx.cache) {
           ctx.cache.pop(identifier);
         }
-        await Promise.all(ctx.regionContexts.map((regionContext) => {
-          safeEval(
-            regionContext,
-            RESET_SCRIPT,
-            [pattern],
-            [null]
-          );
-        }));
+        await Promise.all(
+          ctx.regionContexts.map((regionContext) => {
+            safeEval(regionContext, RESET_SCRIPT, [pattern], [null]);
+          })
+        );
       }
     });
   }
@@ -1101,7 +1121,14 @@ var MultiRegionRatelimit = class extends Ratelimit {
     const windowDuration = ms(window);
     return () => ({
       async limit(ctx, identifier, rate) {
-        if (ctx.cache) {
+        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 ?? 1;
+        if (ctx.cache && incrementBy > 0) {
           const { blocked, reset: reset2 } = ctx.cache.isBlocked(identifier);
           if (blocked) {
             return {
@@ -1114,13 +1141,6 @@ var MultiRegionRatelimit = class extends Ratelimit {
             };
           }
         }
-        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.regionContexts.map((regionContext) => ({
           redis: regionContext.redis,
           request: safeEval(
@@ -1132,37 +1152,49 @@ var MultiRegionRatelimit = class extends Ratelimit {
           )
         }));
         const percentageInCurrent = now % windowDuration / windowDuration;
-        const [current, previous, success] = await Promise.any(dbs.map((s) => s.request));
+        const [current, previous, success] = await Promise.any(
+          dbs.map((s) => s.request)
+        );
         if (success) {
           current.push(requestId, incrementBy.toString());
         }
-        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 = Math.ceil(previousUsedTokens * (1 - percentageInCurrent));
+        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 = Math.ceil(
+          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 = [...new Set(
-            res.flatMap(([current2]) => current2).reduce((acc, curr, index) => {
-              if (index % 2 === 0) {
-                acc.push(curr);
-              }
-              return acc;
-            }, [])
-          ).values()];
+          const allCurrentIds = [
+            ...new Set(
+              res.flatMap(([current2]) => current2).reduce((acc, curr, index) => {
+                if (index % 2 === 0) {
+                  acc.push(curr);
+                }
+                return acc;
+              }, [])
+            ).values()
+          ];
           for (const db of dbs) {
             const [current2, _previous, _success] = await db.request;
             const dbIds = current2.reduce((ids, currentId, index) => {
@@ -1171,13 +1203,16 @@ var MultiRegionRatelimit = class extends Ratelimit {
               }
               return ids;
             }, []);
-            const usedDbTokens = current2.reduce((accTokens, usedToken, index) => {
-              let parsedToken = 0;
-              if (index % 2) {
-                parsedToken = Number.parseInt(usedToken);
-              }
-              return accTokens + parsedToken;
-            }, 0);
+            const usedDbTokens = current2.reduce(
+              (accTokens, usedToken, index) => {
+                let parsedToken = 0;
+                if (index % 2) {
+                  parsedToken = Number.parseInt(usedToken);
+                }
+                return accTokens + parsedToken;
+              },
+              0
+            );
             if (usedDbTokens >= tokens) {
               continue;
             }
@@ -1191,8 +1226,12 @@ var MultiRegionRatelimit = class extends Ratelimit {
           }
         }
         const reset = (currentWindow + 1) * windowDuration;
-        if (ctx.cache && !success) {
-          ctx.cache.blockUntil(identifier, reset);
+        if (ctx.cache) {
+          if (!success) {
+            ctx.cache.blockUntil(identifier, reset);
+          } else if (incrementBy < 0) {
+            ctx.cache.pop(identifier);
+          }
         }
         return {
           success: Boolean(success),
@@ -1229,14 +1268,11 @@ var MultiRegionRatelimit = class extends Ratelimit {
         if (ctx.cache) {
           ctx.cache.pop(identifier);
         }
-        await Promise.all(ctx.regionContexts.map((regionContext) => {
-          safeEval(
-            regionContext,
-            RESET_SCRIPT,
-            [pattern],
-            [null]
-          );
-        }));
+        await Promise.all(
+          ctx.regionContexts.map((regionContext) => {
+            safeEval(regionContext, RESET_SCRIPT, [pattern], [null]);
+          })
+        );
       }
     });
   }
@@ -1285,7 +1321,8 @@ var RegionRatelimit = class extends Ratelimit {
       async limit(ctx, identifier, rate) {
         const bucket = Math.floor(Date.now() / windowDuration);
         const key = [identifier, bucket].join(":");
-        if (ctx.cache) {
+        const incrementBy = rate ?? 1;
+        if (ctx.cache && incrementBy > 0) {
           const { blocked, reset: reset2 } = ctx.cache.isBlocked(identifier);
           if (blocked) {
             return {
@@ -1298,7 +1335,6 @@ var RegionRatelimit = class extends Ratelimit {
             };
           }
         }
-        const incrementBy = rate ? Math.max(1, rate) : 1;
         const usedTokensAfterUpdate = await safeEval(
           ctx,
           SCRIPTS.singleRegion.fixedWindow.limit,
@@ -1308,8 +1344,12 @@ var RegionRatelimit = class extends Ratelimit {
         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);
+        if (ctx.cache) {
+          if (!success) {
+            ctx.cache.blockUntil(identifier, reset);
+          } else if (incrementBy < 0) {
+            ctx.cache.pop(identifier);
+          }
         }
         return {
           success,
@@ -1372,7 +1412,8 @@ var RegionRatelimit = class extends Ratelimit {
         const currentKey = [identifier, currentWindow].join(":");
         const previousWindow = currentWindow - 1;
         const previousKey = [identifier, previousWindow].join(":");
-        if (ctx.cache) {
+        const incrementBy = rate ?? 1;
+        if (ctx.cache && incrementBy > 0) {
           const { blocked, reset: reset2 } = ctx.cache.isBlocked(identifier);
           if (blocked) {
             return {
@@ -1385,7 +1426,6 @@ var RegionRatelimit = class extends Ratelimit {
             };
           }
         }
-        const incrementBy = rate ? Math.max(1, rate) : 1;
         const remainingTokens = await safeEval(
           ctx,
           SCRIPTS.singleRegion.slidingWindow.limit,
@@ -1394,8 +1434,12 @@ var RegionRatelimit = class extends Ratelimit {
         );
         const success = remainingTokens >= 0;
         const reset = (currentWindow + 1) * windowSize;
-        if (ctx.cache && !success) {
-          ctx.cache.blockUntil(identifier, reset);
+        if (ctx.cache) {
+          if (!success) {
+            ctx.cache.blockUntil(identifier, reset);
+          } else if (incrementBy < 0) {
+            ctx.cache.pop(identifier);
+          }
         }
         return {
           success,
@@ -1453,7 +1497,9 @@ var RegionRatelimit = class extends Ratelimit {
     const intervalDuration = ms(interval);
     return () => ({
       async limit(ctx, identifier, rate) {
-        if (ctx.cache) {
+        const now = Date.now();
+        const incrementBy = rate ?? 1;
+        if (ctx.cache && incrementBy > 0) {
           const { blocked, reset: reset2 } = ctx.cache.isBlocked(identifier);
           if (blocked) {
             return {
@@ -1466,8 +1512,6 @@ var RegionRatelimit = class extends Ratelimit {
             };
           }
         }
-        const now = Date.now();
-        const incrementBy = rate ? Math.max(1, rate) : 1;
         const [remaining, reset] = await safeEval(
           ctx,
           SCRIPTS.singleRegion.tokenBucket.limit,
@@ -1475,8 +1519,12 @@ var RegionRatelimit = class extends Ratelimit {
           [maxTokens, intervalDuration, refillRate, now, incrementBy]
         );
         const success = remaining >= 0;
-        if (ctx.cache && !success) {
-          ctx.cache.blockUntil(identifier, reset);
+        if (ctx.cache) {
+          if (!success) {
+            ctx.cache.blockUntil(identifier, reset);
+          } else if (incrementBy < 0) {
+            ctx.cache.pop(identifier);
+          }
         }
         return {
           success,
@@ -1548,10 +1596,10 @@ var RegionRatelimit = class extends Ratelimit {
         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 incrementBy = rate ?? 1;
         const hit = typeof ctx.cache.get(key) === "number";
         if (hit) {
-          const cachedTokensAfterUpdate = ctx.cache.incr(key);
+          const cachedTokensAfterUpdate = ctx.cache.incr(key, incrementBy);
           const success = cachedTokensAfterUpdate < tokens;
           const pending = success ? safeEval(
             ctx,