@upstash/ratelimit 0.1.0 → 0.1.1

package/README.md

@@ -161,7 +161,7 @@ const ratelimit = new Ratelimit({
 
 Builds on top of fixed window but instead of a fixed window, we use a rolling
 window. Take this example: We have a rate limit of 10 requests per 1 minute. We
-dividie time into 1 minute slices, just like in the fixed window algorithm.
+divide time into 1 minute slices, just like in the fixed window algorithm.
 Window 1 will be from 00:00:00 to 00:01:00 (HH:MM:SS). Let's assume it is
 currently 00:01:15 and we have received 4 requests in the first window and 5
 requests so far in the current window. The approximation to determine if the

package/esm/mod.js

@@ -1,2 +1 @@
-export * from "./ratelimiter.js";
-export * from "./types.js";
+export { RegionRatelimit as Ratelimit } from "./region.js";

package/esm/ratelimit.js

@@ -0,0 +1,129 @@
+/**
+ * Ratelimiter using serverless redis from https://upstash.com/
+ *
+ * @example
+ * ```ts
+ * const { limit } = new Ratelimit({
+ *    redis: Redis.fromEnv(),
+ *    limiter: Ratelimit.slidingWindow(
+ *      10,     // Allow 10 requests per window of 30 minutes
+ *      "30 m", // interval of 30 minutes
+ *    )
+ * })
+ *
+ * ```
+ */
+export class Ratelimit {
+    constructor(config) {
+        Object.defineProperty(this, "limiter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "prefix", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Determine if a request should pass or be rejected based on the identifier and previously chosen ratelimit.
+         *
+         * Use this if you want to reject all requests that you can not handle right now.
+         *
+         * @example
+         * ```ts
+         *  const ratelimit = new Ratelimit({
+         *    redis: Redis.fromEnv(),
+         *    limiter: Ratelimit.slidingWindow(10, "10 s")
+         *  })
+         *
+         *  const { success } = await ratelimit.limit(id)
+         *  if (!success){
+         *    return "Nope"
+         *  }
+         *  return "Yes"
+         * ```
+         */
+        Object.defineProperty(this, "limit", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (identifier) => {
+                const key = [this.prefix, identifier].join(":");
+                return await this.limiter(this.ctx, key);
+            }
+        });
+        /**
+         * 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
+         * or after the timeoue has been reached.
+         *
+         * Use this if you want to delay the request until it is ready to get processed.
+         *
+         * @example
+         * ```ts
+         *  const ratelimit = new Ratelimit({
+         *    redis: Redis.fromEnv(),
+         *    limiter: Ratelimit.slidingWindow(10, "10 s")
+         *  })
+         *
+         *  const { success } = await ratelimit.blockUntilReady(id, 60_000)
+         *  if (!success){
+         *    return "Nope"
+         *  }
+         *  return "Yes"
+         * ```
+         */
+        Object.defineProperty(this, "blockUntilReady", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (
+            /**
+             * An identifier per user or api.
+             * Choose a userID, or api token, or ip address.
+             *
+             * If you want to globally limit your api, you can set a constant string.
+             */
+            identifier, 
+            /**
+             * Maximum duration to wait in milliseconds.
+             * After this time the request will be denied.
+             */
+            timeout) => {
+                if (timeout <= 0) {
+                    throw new Error("timeout must be positive");
+                }
+                let res;
+                const deadline = Date.now() + timeout;
+                while (true) {
+                    res = await this.limit(identifier);
+                    if (res.success) {
+                        break;
+                    }
+                    if (res.reset === 0) {
+                        throw new Error("This should not happen");
+                    }
+                    const wait = Math.min(res.reset, deadline) - Date.now();
+                    await new Promise((r) => setTimeout(r, wait));
+                    if (Date.now() > deadline) {
+                        break;
+                    }
+                }
+                return res;
+            }
+        });
+        this.ctx = config.ctx;
+        this.limiter = config.limiter;
+        this.prefix = config.prefix ?? "@upstash/ratelimit";
+    }
+}

package/esm/{ratelimiter.js → region.js}

@@ -1,4 +1,5 @@
 import { ms } from "./duration.js";
+import { Ratelimit } from "./ratelimit.js";
 /**
  * Ratelimiter using serverless redis from https://upstash.com/
  *
@@ -14,142 +15,17 @@ import { ms } from "./duration.js";
  *
  * ```
  */
-export class Ratelimit {
+export class RegionRatelimit extends Ratelimit {
     /**
      * Create a new Ratelimit instance by providing a `@upstash/redis` instance and the algorithn of your choice.
      */
     constructor(config) {
-        Object.defineProperty(this, "redis", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
+        super({
+            prefix: config.prefix,
+            limiter: config.limiter,
+            ctx: { redis: config.redis },
         });
-        Object.defineProperty(this, "limiter", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "prefix", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /**
-         * Determine if a request should pass or be rejected based on the identifier and previously chosen ratelimit.
-         *
-         * Use this if you want to reject all requests that you can not handle right now.
-         *
-         * @example
-         * ```ts
-         *  const ratelimit = new Ratelimit({
-         *    redis: Redis.fromEnv(),
-         *    limiter: Ratelimit.slidingWindow(10, "10 s")
-         *  })
-         *
-         *  const { success } = await ratelimit.limit(id)
-         *  if (!success){
-         *    return "Nope"
-         *  }
-         *  return "Yes"
-         * ```
-         */
-        Object.defineProperty(this, "limit", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: async (identifier) => {
-                const key = [this.prefix, identifier].join(":");
-                return await this.limiter({ redis: this.redis }, key);
-            }
-        });
-        /**
-         * 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
-         * or after the timeoue has been reached.
-         *
-         * Use this if you want to delay the request until it is ready to get processed.
-         *
-         * @example
-         * ```ts
-         *  const ratelimit = new Ratelimit({
-         *    redis: Redis.fromEnv(),
-         *    limiter: Ratelimit.slidingWindow(10, "10 s")
-         *  })
-         *
-         *  const { success } = await ratelimit.blockUntilReady(id, 60_000)
-         *  if (!success){
-         *    return "Nope"
-         *  }
-         *  return "Yes"
-         * ```
-         */
-        Object.defineProperty(this, "blockUntilReady", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: async (
-            /**
-             * An identifier per user or api.
-             * Choose a userID, or api token, or ip address.
-             *
-             * If you want to globally limit your api, you can set a constant string.
-             */
-            identifier, 
-            /**
-             * Maximum duration to wait in milliseconds.
-             * After this time the request will be denied.
-             */
-            timeout) => {
-                if (timeout <= 0) {
-                    throw new Error("timeout must be positive");
-                }
-                let res;
-                const deadline = Date.now() + timeout;
-                while (true) {
-                    res = await this.limit(identifier);
-                    if (res.success) {
-                        break;
-                    }
-                    if (res.reset === 0) {
-                        throw new Error("This should not happen");
-                    }
-                    const wait = Math.min(res.reset, deadline) - Date.now();
-                    await new Promise((r) => setTimeout(r, wait));
-                    if (Date.now() > deadline) {
-                        break;
-                    }
-                }
-                return res;
-            }
-        });
-        this.redis = config.redis;
-        this.limiter = config.limiter;
-        this.prefix = config.prefix ?? "@upstash/ratelimit";
     }
-    // EXPERIMENTAL
-    // static eventualWrite(tokens: number, window: Duration): Ratelimiter {
-    //   const windowDuration = ms(window);
-    //   return async function (ctx: Context, identifier: string) {
-    //     const bucket = Math.floor(Date.now() / windowDuration);
-    //     const key = [identifier, bucket].join(":");
-    //     const usedTokensAfterUpdate = (await ctx.redis.get<number>(key)) ?? 1;
-    //     ctx.redis.incr(key).then((res) => {
-    //       if (res === 1) {
-    //         ctx.redis.expire(key, windowDuration);
-    //       }
-    //     });
-    //     return {
-    //       success: usedTokensAfterUpdate <= tokens,
-    //       limit: tokens,
-    //       remaining: tokens - usedTokensAfterUpdate,
-    //       reset: (bucket + 1) * windowDuration,
-    //     };
-    //   };
-    // }
     /**
      * Each requests inside a fixed time increases a counter.
      * Once the counter reaches a maxmimum allowed number, all further requests are

package/esm/types.js

@@ -1,2 +1 @@
-import { Redis } from "./deps/deno.land/x/upstash_redis@v1.3.3-alpha.1/mod.js";
-export { Redis };
+export {};

package/package.json

@@ -3,7 +3,7 @@
   "main": "./script/mod.js",
   "types": "./types/mod.d.ts",
   "name": "@upstash/ratelimit",
-  "version": "v0.1.0",
+  "version": "v0.1.1",
   "description": "A serverless ratelimiter built on top of Upstash REST API.",
   "repository": {
     "type": "git",
@@ -29,7 +29,7 @@
     "size-limit": "latest"
   },
   "peerDependencies": {
-    "@upstash/redis": "1.3.3-alpha.1"
+    "@upstash/redis": "^1.3.4"
   },
   "size-limit": [
     {

package/script/mod.js

@@ -1,18 +1,5 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./ratelimiter.js"), exports);
-__exportStar(require("./types.js"), exports);
+exports.Ratelimit = void 0;
+var region_js_1 = require("./region.js");
+Object.defineProperty(exports, "Ratelimit", { enumerable: true, get: function () { return region_js_1.RegionRatelimit; } });

package/script/ratelimit.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ratelimit = void 0;
+/**
+ * Ratelimiter using serverless redis from https://upstash.com/
+ *
+ * @example
+ * ```ts
+ * const { limit } = new Ratelimit({
+ *    redis: Redis.fromEnv(),
+ *    limiter: Ratelimit.slidingWindow(
+ *      10,     // Allow 10 requests per window of 30 minutes
+ *      "30 m", // interval of 30 minutes
+ *    )
+ * })
+ *
+ * ```
+ */
+class Ratelimit {
+    constructor(config) {
+        Object.defineProperty(this, "limiter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "prefix", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Determine if a request should pass or be rejected based on the identifier and previously chosen ratelimit.
+         *
+         * Use this if you want to reject all requests that you can not handle right now.
+         *
+         * @example
+         * ```ts
+         *  const ratelimit = new Ratelimit({
+         *    redis: Redis.fromEnv(),
+         *    limiter: Ratelimit.slidingWindow(10, "10 s")
+         *  })
+         *
+         *  const { success } = await ratelimit.limit(id)
+         *  if (!success){
+         *    return "Nope"
+         *  }
+         *  return "Yes"
+         * ```
+         */
+        Object.defineProperty(this, "limit", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (identifier) => {
+                const key = [this.prefix, identifier].join(":");
+                return await this.limiter(this.ctx, key);
+            }
+        });
+        /**
+         * 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
+         * or after the timeoue has been reached.
+         *
+         * Use this if you want to delay the request until it is ready to get processed.
+         *
+         * @example
+         * ```ts
+         *  const ratelimit = new Ratelimit({
+         *    redis: Redis.fromEnv(),
+         *    limiter: Ratelimit.slidingWindow(10, "10 s")
+         *  })
+         *
+         *  const { success } = await ratelimit.blockUntilReady(id, 60_000)
+         *  if (!success){
+         *    return "Nope"
+         *  }
+         *  return "Yes"
+         * ```
+         */
+        Object.defineProperty(this, "blockUntilReady", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (
+            /**
+             * An identifier per user or api.
+             * Choose a userID, or api token, or ip address.
+             *
+             * If you want to globally limit your api, you can set a constant string.
+             */
+            identifier, 
+            /**
+             * Maximum duration to wait in milliseconds.
+             * After this time the request will be denied.
+             */
+            timeout) => {
+                if (timeout <= 0) {
+                    throw new Error("timeout must be positive");
+                }
+                let res;
+                const deadline = Date.now() + timeout;
+                while (true) {
+                    res = await this.limit(identifier);
+                    if (res.success) {
+                        break;
+                    }
+                    if (res.reset === 0) {
+                        throw new Error("This should not happen");
+                    }
+                    const wait = Math.min(res.reset, deadline) - Date.now();
+                    await new Promise((r) => setTimeout(r, wait));
+                    if (Date.now() > deadline) {
+                        break;
+                    }
+                }
+                return res;
+            }
+        });
+        this.ctx = config.ctx;
+        this.limiter = config.limiter;
+        this.prefix = config.prefix ?? "@upstash/ratelimit";
+    }
+}
+exports.Ratelimit = Ratelimit;

package/script/{ratelimiter.js → region.js}

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Ratelimit = void 0;
+exports.RegionRatelimit = void 0;
 const duration_js_1 = require("./duration.js");
+const ratelimit_js_1 = require("./ratelimit.js");
 /**
  * Ratelimiter using serverless redis from https://upstash.com/
  *
@@ -17,142 +18,17 @@ const duration_js_1 = require("./duration.js");
  *
  * ```
  */
-class Ratelimit {
+class RegionRatelimit extends ratelimit_js_1.Ratelimit {
     /**
      * Create a new Ratelimit instance by providing a `@upstash/redis` instance and the algorithn of your choice.
      */
     constructor(config) {
-        Object.defineProperty(this, "redis", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
+        super({
+            prefix: config.prefix,
+            limiter: config.limiter,
+            ctx: { redis: config.redis },
         });
-        Object.defineProperty(this, "limiter", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "prefix", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /**
-         * Determine if a request should pass or be rejected based on the identifier and previously chosen ratelimit.
-         *
-         * Use this if you want to reject all requests that you can not handle right now.
-         *
-         * @example
-         * ```ts
-         *  const ratelimit = new Ratelimit({
-         *    redis: Redis.fromEnv(),
-         *    limiter: Ratelimit.slidingWindow(10, "10 s")
-         *  })
-         *
-         *  const { success } = await ratelimit.limit(id)
-         *  if (!success){
-         *    return "Nope"
-         *  }
-         *  return "Yes"
-         * ```
-         */
-        Object.defineProperty(this, "limit", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: async (identifier) => {
-                const key = [this.prefix, identifier].join(":");
-                return await this.limiter({ redis: this.redis }, key);
-            }
-        });
-        /**
-         * 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
-         * or after the timeoue has been reached.
-         *
-         * Use this if you want to delay the request until it is ready to get processed.
-         *
-         * @example
-         * ```ts
-         *  const ratelimit = new Ratelimit({
-         *    redis: Redis.fromEnv(),
-         *    limiter: Ratelimit.slidingWindow(10, "10 s")
-         *  })
-         *
-         *  const { success } = await ratelimit.blockUntilReady(id, 60_000)
-         *  if (!success){
-         *    return "Nope"
-         *  }
-         *  return "Yes"
-         * ```
-         */
-        Object.defineProperty(this, "blockUntilReady", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: async (
-            /**
-             * An identifier per user or api.
-             * Choose a userID, or api token, or ip address.
-             *
-             * If you want to globally limit your api, you can set a constant string.
-             */
-            identifier, 
-            /**
-             * Maximum duration to wait in milliseconds.
-             * After this time the request will be denied.
-             */
-            timeout) => {
-                if (timeout <= 0) {
-                    throw new Error("timeout must be positive");
-                }
-                let res;
-                const deadline = Date.now() + timeout;
-                while (true) {
-                    res = await this.limit(identifier);
-                    if (res.success) {
-                        break;
-                    }
-                    if (res.reset === 0) {
-                        throw new Error("This should not happen");
-                    }
-                    const wait = Math.min(res.reset, deadline) - Date.now();
-                    await new Promise((r) => setTimeout(r, wait));
-                    if (Date.now() > deadline) {
-                        break;
-                    }
-                }
-                return res;
-            }
-        });
-        this.redis = config.redis;
-        this.limiter = config.limiter;
-        this.prefix = config.prefix ?? "@upstash/ratelimit";
     }
-    // EXPERIMENTAL
-    // static eventualWrite(tokens: number, window: Duration): Ratelimiter {
-    //   const windowDuration = ms(window);
-    //   return async function (ctx: Context, identifier: string) {
-    //     const bucket = Math.floor(Date.now() / windowDuration);
-    //     const key = [identifier, bucket].join(":");
-    //     const usedTokensAfterUpdate = (await ctx.redis.get<number>(key)) ?? 1;
-    //     ctx.redis.incr(key).then((res) => {
-    //       if (res === 1) {
-    //         ctx.redis.expire(key, windowDuration);
-    //       }
-    //     });
-    //     return {
-    //       success: usedTokensAfterUpdate <= tokens,
-    //       limit: tokens,
-    //       remaining: tokens - usedTokensAfterUpdate,
-    //       reset: (bucket + 1) * windowDuration,
-    //     };
-    //   };
-    // }
     /**
      * Each requests inside a fixed time increases a counter.
      * Once the counter reaches a maxmimum allowed number, all further requests are
@@ -357,4 +233,4 @@ class Ratelimit {
         };
     }
 }
-exports.Ratelimit = Ratelimit;
+exports.RegionRatelimit = RegionRatelimit;

package/script/types.js

@@ -1,5 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Redis = void 0;
-const mod_js_1 = require("./deps/deno.land/x/upstash_redis@v1.3.3-alpha.1/mod.js");
-Object.defineProperty(exports, "Redis", { enumerable: true, get: function () { return mod_js_1.Redis; } });

package/types/mod.d.ts

@@ -1,2 +1,3 @@
-export * from "./ratelimiter.js";
-export * from "./types.js";
+export { RegionRatelimit as Ratelimit } from "./region.js";
+export type { RegionRatelimitConfig as RatelimitConfig } from "./region.js";
+export type { Algorithm } from "./types.js";