@upstash/ratelimit 0.4.0 → 0.4.2

package/dist/index.mjs

@@ -1,27 +1,3 @@
-// src/duration.ts
-function ms(d) {
-  const match = d.match(/^(\d+)\s?(ms|s|m|h|d)$/);
-  if (!match) {
-    throw new Error(`Unable to parse window size: ${d}`);
-  }
-  const time = parseInt(match[1]);
-  const unit = match[2];
-  switch (unit) {
-    case "ms":
-      return time;
-    case "s":
-      return time * 1e3;
-    case "m":
-      return time * 1e3 * 60;
-    case "h":
-      return time * 1e3 * 60 * 60;
-    case "d":
-      return time * 1e3 * 60 * 60 * 24;
-    default:
-      throw new Error(`Unable to parse window size: ${d}`);
-  }
-}
-
 // src/analytics.ts
 import { Analytics as CoreAnalytics } from "@upstash/core-analytics";
 var Analytics = class {
@@ -119,6 +95,30 @@ var Cache = class {
   }
 };
 
+// src/duration.ts
+function ms(d) {
+  const match = d.match(/^(\d+)\s?(ms|s|m|h|d)$/);
+  if (!match) {
+    throw new Error(`Unable to parse window size: ${d}`);
+  }
+  const time = parseInt(match[1]);
+  const unit = match[2];
+  switch (unit) {
+    case "ms":
+      return time;
+    case "s":
+      return time * 1e3;
+    case "m":
+      return time * 1e3 * 60;
+    case "h":
+      return time * 1e3 * 60 * 60;
+    case "d":
+      return time * 1e3 * 60 * 60 * 24;
+    default:
+      throw new Error(`Unable to parse window size: ${d}`);
+  }
+}
+
 // src/ratelimit.ts
 var Ratelimit = class {
   limiter;
@@ -131,7 +131,7 @@ var Ratelimit = class {
     this.limiter = config.limiter;
     this.timeout = config.timeout ?? 5e3;
     this.prefix = config.prefix ?? "@upstash/ratelimit";
-    this.analytics = config.analytics !== false ? new Analytics({
+    this.analytics = config.analytics ? new Analytics({
       redis: Array.isArray(this.ctx.redis) ? this.ctx.redis[0] : this.ctx.redis,
       prefix: this.prefix
     }) : void 0;
@@ -207,7 +207,7 @@ var Ratelimit = class {
   /**
    * Block until the request may pass or timeout is reached.
    *
-   * This method returns a promsie that resolves as soon as the request may be processed
+   * This method returns a promise that resolves as soon as the request may be processed
    * or after the timeoue has been reached.
    *
    * Use this if you want to delay the request until it is ready to get processed.
@@ -250,6 +250,224 @@ var Ratelimit = class {
   };
 };
 
+// src/multi.ts
+function randomId() {
+  let result = "";
+  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const charactersLength = characters.length;
+  for (let i = 0; i < 16; i++) {
+    result += characters.charAt(Math.floor(Math.random() * charactersLength));
+  }
+  return result;
+}
+var MultiRegionRatelimit = class extends Ratelimit {
+  /**
+   * Create a new Ratelimit instance by providing a `@upstash/redis` instance and the algorithn of your choice.
+   */
+  constructor(config) {
+    super({
+      prefix: config.prefix,
+      limiter: config.limiter,
+      timeout: config.timeout,
+      analytics: config.analytics,
+      ctx: {
+        redis: config.redis,
+        cache: config.ephemeralCache ? new Cache(config.ephemeralCache) : void 0
+      }
+    });
+  }
+  /**
+   * Each requests inside a fixed time increases a counter.
+   * Once the counter reaches a maxmimum allowed number, all further requests are
+   * rejected.
+   *
+   * **Pro:**
+   *
+   * - Newer requests are not starved by old ones.
+   * - Low storage cost.
+   *
+   * **Con:**
+   *
+   * A burst of requests near the boundary of a window can result in a very
+   * high request rate because two windows will be filled with requests quickly.
+   *
+   * @param tokens - How many requests a user can make in each time window.
+   * @param window - A fixed timeframe
+   */
+  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()
+          };
+        }
+      }
+      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 diff = allIDs.filter((id) => !ids.includes(id));
+          if (diff.length === 0) {
+            continue;
+          }
+          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()
+      };
+    };
+  }
+  /**
+   * Combined approach of `slidingLogs` and `fixedWindow` with lower storage
+   * costs than `slidingLogs` and improved boundary behavior by calcualting a
+   * weighted score between two windows.
+   *
+   * **Pro:**
+   *
+   * Good performance allows this to scale to very high loads.
+   *
+   * **Con:**
+   *
+   * Nothing major.
+   *
+   * @param tokens - How many requests a user can make in each time window.
+   * @param window - The duration in which the user can max X requests.
+   */
+  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}
+      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}
+      `;
+    const windowDuration = ms(window);
+    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()
+          };
+        }
+      }
+      const requestID = randomId();
+      const now = Date.now();
+      const currentWindow = Math.floor(now / windowSize);
+      const currentKey = [identifier, currentWindow].join(":");
+      const previousWindow = currentWindow - windowSize;
+      const previousKey = [identifier, previousWindow].join(":");
+      const dbs = ctx.redis.map((redis) => ({
+        redis,
+        request: redis.eval(script, [currentKey, previousKey], [tokens, now, windowDuration, requestID])
+      }));
+      const percentageInCurrent = now % windowDuration / windowDuration;
+      const [current, previous] = await Promise.any(dbs.map((s) => s.request));
+      const usedTokens = previous.length * (1 - percentageInCurrent) + current.length;
+      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());
+        for (const db of dbs) {
+          const [ids] = await db.request;
+          if (ids.length >= tokens) {
+            continue;
+          }
+          const diff = allIDs.filter((id) => !ids.includes(id));
+          if (diff.length === 0) {
+            continue;
+          }
+          await db.redis.sadd(currentKey, ...allIDs);
+        }
+      }
+      const success = remaining > 0;
+      const reset = (currentWindow + 1) * windowDuration;
+      if (ctx.cache && !success) {
+        ctx.cache.blockUntil(identifier, reset);
+      }
+      return {
+        success,
+        limit: tokens,
+        remaining,
+        reset,
+        pending: sync()
+      };
+    };
+  }
+};
+
 // src/single.ts
 var RegionRatelimit = class extends Ratelimit {
   /**
@@ -356,7 +574,7 @@ var RegionRatelimit = class extends Ratelimit {
 
       local requestsInCurrentWindow = redis.call("GET", currentKey)
       if requestsInCurrentWindow == false then
-        requestsInCurrentWindow = 0
+        requestsInCurrentWindow = -1
       end
 
 
@@ -366,7 +584,7 @@ var RegionRatelimit = class extends Ratelimit {
       end
       local percentageInCurrent = ( now % window) / window
       if requestsInPreviousWindow * ( 1 - percentageInCurrent ) + requestsInCurrentWindow >= tokens then
-        return 0
+        return -1
       end
 
       local newValue = redis.call("INCR", currentKey)
@@ -397,7 +615,7 @@ var RegionRatelimit = class extends Ratelimit {
         }
       }
       const remaining = await ctx.redis.eval(script, [currentKey, previousKey], [tokens, now, windowSize]);
-      const success = remaining > 0;
+      const success = remaining >= 0;
       const reset = (currentWindow + 1) * windowSize;
       if (ctx.cache && !success) {
         ctx.cache.blockUntil(identifier, reset);
@@ -405,7 +623,7 @@ var RegionRatelimit = class extends Ratelimit {
       return {
         success,
         limit: tokens,
-        remaining,
+        remaining: Math.max(0, remaining),
         reset,
         pending: Promise.resolve()
       };
@@ -572,224 +790,6 @@ var RegionRatelimit = class extends Ratelimit {
     };
   }
 };
-
-// src/multi.ts
-function randomId() {
-  let result = "";
-  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  const charactersLength = characters.length;
-  for (let i = 0; i < 16; i++) {
-    result += characters.charAt(Math.floor(Math.random() * charactersLength));
-  }
-  return result;
-}
-var MultiRegionRatelimit = class extends Ratelimit {
-  /**
-   * Create a new Ratelimit instance by providing a `@upstash/redis` instance and the algorithn of your choice.
-   */
-  constructor(config) {
-    super({
-      prefix: config.prefix,
-      limiter: config.limiter,
-      timeout: config.timeout,
-      analytics: config.analytics,
-      ctx: {
-        redis: config.redis,
-        cache: config.ephemeralCache ? new Cache(config.ephemeralCache) : void 0
-      }
-    });
-  }
-  /**
-   * Each requests inside a fixed time increases a counter.
-   * Once the counter reaches a maxmimum allowed number, all further requests are
-   * rejected.
-   *
-   * **Pro:**
-   *
-   * - Newer requests are not starved by old ones.
-   * - Low storage cost.
-   *
-   * **Con:**
-   *
-   * A burst of requests near the boundary of a window can result in a very
-   * high request rate because two windows will be filled with requests quickly.
-   *
-   * @param tokens - How many requests a user can make in each time window.
-   * @param window - A fixed timeframe
-   */
-  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()
-          };
-        }
-      }
-      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 diff = allIDs.filter((id) => !ids.includes(id));
-          if (diff.length === 0) {
-            continue;
-          }
-          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()
-      };
-    };
-  }
-  /**
-   * Combined approach of `slidingLogs` and `fixedWindow` with lower storage
-   * costs than `slidingLogs` and improved boundary behavior by calcualting a
-   * weighted score between two windows.
-   *
-   * **Pro:**
-   *
-   * Good performance allows this to scale to very high loads.
-   *
-   * **Con:**
-   *
-   * Nothing major.
-   *
-   * @param tokens - How many requests a user can make in each time window.
-   * @param window - The duration in which the user can max X requests.
-   */
-  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}
-      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}
-      `;
-    const windowDuration = ms(window);
-    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()
-          };
-        }
-      }
-      const requestID = randomId();
-      const now = Date.now();
-      const currentWindow = Math.floor(now / windowSize);
-      const currentKey = [identifier, currentWindow].join(":");
-      const previousWindow = currentWindow - windowSize;
-      const previousKey = [identifier, previousWindow].join(":");
-      const dbs = ctx.redis.map((redis) => ({
-        redis,
-        request: redis.eval(script, [currentKey, previousKey], [tokens, now, windowDuration, requestID])
-      }));
-      const percentageInCurrent = now % windowDuration / windowDuration;
-      const [current, previous] = await Promise.any(dbs.map((s) => s.request));
-      const usedTokens = previous.length * (1 - percentageInCurrent) + current.length;
-      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());
-        for (const db of dbs) {
-          const [ids] = await db.request;
-          if (ids.length >= tokens) {
-            continue;
-          }
-          const diff = allIDs.filter((id) => !ids.includes(id));
-          if (diff.length === 0) {
-            continue;
-          }
-          await db.redis.sadd(currentKey, ...allIDs);
-        }
-      }
-      const success = remaining > 0;
-      const reset = (currentWindow + 1) * windowDuration;
-      if (ctx.cache && !success) {
-        ctx.cache.blockUntil(identifier, reset);
-      }
-      return {
-        success,
-        limit: tokens,
-        remaining,
-        reset,
-        pending: sync()
-      };
-    };
-  }
-};
 export {
   Analytics,
   MultiRegionRatelimit,