@upstash/ratelimit 1.0.1-canary → 1.0.3

package/dist/index.js

@@ -130,7 +130,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":
@@ -148,6 +148,59 @@ function ms(d) {
   }
 }
 
+// src/lua-scripts/multi.ts
+var fixedWindowScript = `
+	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 slidingWindowScript = `
+	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}
+`;
+
 // src/ratelimit.ts
 var Ratelimit = class {
   limiter;
@@ -188,12 +241,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(this.ctx, key, req?.rate)];
       if (this.timeout > 0) {
         arr.push(
           new Promise((resolve) => {
@@ -325,22 +395,7 @@ 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) {
+    return async (ctx, identifier, rate) => {
       if (ctx.cache) {
         const { blocked, reset: reset2 } = ctx.cache.isBlocked(identifier);
         if (blocked) {
@@ -356,26 +411,60 @@ 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.redis.map((redis) => ({
         redis,
-        request: redis.eval(script, [key], [requestId, windowDuration])
+        request: redis.eval(
+          fixedWindowScript,
+          [key],
+          [requestId, windowDuration, incrementBy]
+        )
       }));
       const firstResponse = await Promise.any(dbs.map((s) => s.request));
-      const usedTokens = firstResponse.length;
-      const remaining = tokens - usedTokens - 1;
+      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((_) => _)).values());
+        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 ids = await db.request;
-          if (ids.length >= tokens) {
+          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) => !ids.includes(id));
+          const diff = allIDs.filter((id) => !dbIds.includes(id));
           if (diff.length === 0) {
             continue;
           }
-          await db.redis.sadd(key, ...allIDs);
+          for (const requestId2 of diff) {
+            await db.redis.hset(key, { [requestId2]: incrementBy });
+          }
         }
       }
       const success = remaining > 0;
@@ -410,69 +499,76 @@ 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) {
+    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(
-          script,
+          slidingWindowScript,
           [currentKey, previousKey],
-          [tokens, now, windowDuration, requestId]
+          [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 previousPartialUsed = previous.length * (1 - percentageInCurrent);
-      const usedTokens = previousPartialUsed + current.length;
+      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);
+        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 [ids] = await db.request;
-          if (ids.length >= tokens) {
+          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) => !ids.includes(id));
+          const diff = allCurrentIds.filter((id) => !dbIds.includes(id));
           if (diff.length === 0) {
             continue;
           }
-          await db.redis.sadd(currentKey, ...diff);
+          for (const requestId2 of diff) {
+            await db.redis.hset(currentKey, { [requestId2]: incrementBy });
+          }
         }
       }
       const reset = (currentWindow + 1) * windowDuration;
@@ -482,7 +578,7 @@ var MultiRegionRatelimit = class extends Ratelimit {
       return {
         success: Boolean(success),
         limit: tokens,
-        remaining,
+        remaining: Math.max(0, remaining),
         reset,
         pending: sync()
       };
@@ -490,6 +586,107 @@ var MultiRegionRatelimit = class extends Ratelimit {
   }
 };
 
+// src/lua-scripts/single.ts
+var fixedWindowScript2 = `
+  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 slidingWindowScript2 = `
+  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 == 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 = `
+  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 cachedFixedWindowScript = `
+  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
+`;
+
 // src/single.ts
 var RegionRatelimit = class extends Ratelimit {
   /**
@@ -527,20 +724,7 @@ 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) {
+    return async (ctx, identifier, rate) => {
       const bucket = Math.floor(Date.now() / windowDuration);
       const key = [identifier, bucket].join(":");
       if (ctx.cache) {
@@ -555,12 +739,14 @@ var RegionRatelimit = class extends Ratelimit {
           };
         }
       }
+      const incrementBy = rate ? Math.max(1, rate) : 1;
       const usedTokensAfterUpdate = await ctx.redis.eval(
-        script,
+        fixedWindowScript2,
         [key],
-        [windowDuration]
+        [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);
@@ -568,7 +754,7 @@ var RegionRatelimit = class extends Ratelimit {
       return {
         success,
         limit: tokens,
-        remaining: Math.max(0, tokens - usedTokensAfterUpdate),
+        remaining: remainingTokens,
         reset,
         pending: Promise.resolve()
       };
@@ -591,39 +777,8 @@ 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) {
+    return async (ctx, identifier, rate) => {
       const now = Date.now();
       const currentWindow = Math.floor(now / windowSize);
       const currentKey = [identifier, currentWindow].join(":");
@@ -641,12 +796,13 @@ var RegionRatelimit = class extends Ratelimit {
           };
         }
       }
-      const remaining = await ctx.redis.eval(
-        script,
+      const incrementBy = rate ? Math.max(1, rate) : 1;
+      const remainingTokens = await ctx.redis.eval(
+        slidingWindowScript2,
         [currentKey, previousKey],
-        [tokens, now, windowSize]
+        [tokens, now, windowSize, incrementBy]
       );
-      const success = remaining >= 0;
+      const success = remainingTokens >= 0;
       const reset = (currentWindow + 1) * windowSize;
       if (ctx.cache && !success) {
         ctx.cache.blockUntil(identifier, reset);
@@ -654,7 +810,7 @@ var RegionRatelimit = class extends Ratelimit {
       return {
         success,
         limit: tokens,
-        remaining: Math.max(0, remaining),
+        remaining: Math.max(0, remainingTokens),
         reset,
         pending: Promise.resolve()
       };
@@ -674,46 +830,8 @@ 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) {
+    return async (ctx, identifier, rate) => {
       if (ctx.cache) {
         const { blocked, reset: reset2 } = ctx.cache.isBlocked(identifier);
         if (blocked) {
@@ -727,10 +845,11 @@ var RegionRatelimit = class extends Ratelimit {
         }
       }
       const now = Date.now();
+      const incrementBy = rate ? Math.max(1, rate) : 1;
       const [remaining, reset] = await ctx.redis.eval(
-        script,
+        tokenBucketScript,
         [identifier],
-        [maxTokens, intervalDuration, refillRate, now]
+        [maxTokens, intervalDuration, refillRate, now, incrementBy]
       );
       const success = remaining >= 0;
       if (ctx.cache && !success) {
@@ -771,31 +890,19 @@ 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) {
+    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(script, [key], [windowDuration]).then((t) => {
+        const pending = success ? ctx.redis.eval(cachedFixedWindowScript, [key], [windowDuration, incrementBy]).then((t) => {
           ctx.cache.set(key, t);
         }) : Promise.resolve();
         return {
@@ -807,9 +914,9 @@ var RegionRatelimit = class extends Ratelimit {
         };
       }
       const usedTokensAfterUpdate = await ctx.redis.eval(
-        script,
+        cachedFixedWindowScript,
         [key],
-        [windowDuration]
+        [windowDuration, incrementBy]
       );
       ctx.cache.set(key, usedTokensAfterUpdate);
       const remaining = tokens - usedTokensAfterUpdate;