@upstash/ratelimit 0.3.0-rc.1 → 0.3.2

package/script/ratelimit.js

@@ -1,202 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Ratelimit = exports.TimeoutError = void 0;
-const analytics_js_1 = require("./analytics.js");
-const cache_js_1 = require("./cache.js");
-class TimeoutError extends Error {
-    constructor() {
-        super("Timeout");
-        this.name = "TimeoutError";
-    }
-}
-exports.TimeoutError = TimeoutError;
-/**
- * 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
-        });
-        Object.defineProperty(this, "timeout", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "analytics", {
-            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, req) => {
-                const key = [this.prefix, identifier].join(":");
-                let timeoutId = null;
-                try {
-                    const arr = [this.limiter(this.ctx, key)];
-                    if (this.timeout) {
-                        arr.push(new Promise((resolve) => {
-                            timeoutId = setTimeout(() => {
-                                resolve({
-                                    success: true,
-                                    limit: 0,
-                                    remaining: 0,
-                                    reset: 0,
-                                    pending: Promise.resolve(),
-                                });
-                            }, this.timeout);
-                        }));
-                    }
-                    const res = await Promise.race(arr);
-                    if (this.analytics) {
-                        const geo = req ? this.analytics.extractGeo(req) : undefined;
-                        const analyticsP = this.analytics.record({
-                            identifier,
-                            time: Date.now(),
-                            success: res.success,
-                            ...geo,
-                        });
-                        res.pending = Promise.all([res.pending, analyticsP]);
-                    }
-                    return res;
-                }
-                finally {
-                    if (timeoutId) {
-                        clearTimeout(timeoutId);
-                    }
-                }
-            }
-        });
-        /**
-         * 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 limit your api across all users, 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.timeout = config.timeout;
-        this.prefix = config.prefix ?? "@upstash/ratelimit";
-        this.analytics = config.analytics !== false
-            ? new analytics_js_1.Analytics({
-                redis: Array.isArray(this.ctx.redis)
-                    ? this.ctx.redis[0]
-                    : this.ctx.redis,
-                prefix: this.prefix,
-            })
-            : undefined;
-        if (config.ephemeralCache instanceof Map) {
-            this.ctx.cache = new cache_js_1.Cache(config.ephemeralCache);
-        }
-        else if (typeof config.ephemeralCache === "undefined") {
-            this.ctx.cache = new cache_js_1.Cache(new Map());
-        }
-    }
-}
-exports.Ratelimit = Ratelimit;

package/script/single.js

@@ -1,380 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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/
- *
- * @example
- * ```ts
- * const { limit } = new Ratelimit({
- *    redis: Redis.fromEnv(),
- *    limiter: Ratelimit.slidingWindow(
- *      "30 m", // interval of 30 minutes
- *      10,     // Allow 10 requests per window of 30 minutes
- *    )
- * })
- *
- * ```
- */
-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) {
-        super({
-            prefix: config.prefix,
-            limiter: config.limiter,
-            timeout: config.timeout,
-            analytics: config.analytics,
-            ctx: {
-                redis: config.redis,
-            },
-            ephemeralCache: config.ephemeralCache,
-        });
-    }
-    /**
-     * 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(
-    /**
-     * How many requests are allowed per window.
-     */
-    tokens, 
-    /**
-     * The duration in which `tokens` requests are allowed.
-     */
-    window) {
-        const windowDuration = (0, duration_js_1.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) {
-            const bucket = Math.floor(Date.now() / windowDuration);
-            const key = [identifier, bucket].join(":");
-            if (ctx.cache) {
-                const { blocked, reset } = ctx.cache.isBlocked(identifier);
-                if (blocked) {
-                    return {
-                        success: false,
-                        limit: tokens,
-                        remaining: 0,
-                        reset: reset,
-                        pending: Promise.resolve(),
-                    };
-                }
-            }
-            const usedTokensAfterUpdate = (await ctx.redis.eval(script, [key], [windowDuration]));
-            const success = usedTokensAfterUpdate <= tokens;
-            const reset = (bucket + 1) * windowDuration;
-            if (ctx.cache && !success) {
-                ctx.cache.blockUntil(identifier, reset);
-            }
-            return {
-                success,
-                limit: tokens,
-                remaining: tokens - usedTokensAfterUpdate,
-                reset,
-                pending: Promise.resolve(),
-            };
-        };
-    }
-    /**
-     * 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(
-    /**
-     * How many requests are allowed per window.
-     */
-    tokens, 
-    /**
-     * The duration in which `tokens` requests are allowed.
-     */
-    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
-      if requestsInPreviousWindow * ( 1 - percentageInCurrent ) + requestsInCurrentWindow >= tokens then
-        return 0
-      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
-      `;
-        const windowSize = (0, duration_js_1.ms)(window);
-        return async function (ctx, identifier) {
-            const now = Date.now();
-            const currentWindow = Math.floor(now / windowSize);
-            const currentKey = [identifier, currentWindow].join(":");
-            const previousWindow = currentWindow - windowSize;
-            const previousKey = [identifier, previousWindow].join(":");
-            if (ctx.cache) {
-                const { blocked, reset } = ctx.cache.isBlocked(identifier);
-                if (blocked) {
-                    return {
-                        success: false,
-                        limit: tokens,
-                        remaining: 0,
-                        reset: reset,
-                        pending: Promise.resolve(),
-                    };
-                }
-            }
-            const remaining = (await ctx.redis.eval(script, [currentKey, previousKey], [tokens, now, windowSize]));
-            const success = remaining > 0;
-            const reset = (currentWindow + 1) * windowSize;
-            if (ctx.cache && !success) {
-                ctx.cache.blockUntil(identifier, reset);
-            }
-            return {
-                success,
-                limit: tokens,
-                remaining,
-                reset,
-                pending: Promise.resolve(),
-            };
-        };
-    }
-    /**
-     * You have a bucket filled with `{maxTokens}` tokens that refills constantly
-     * at `{refillRate}` per `{interval}`.
-     * Every request will remove one token from the bucket and if there is no
-     * token to take, the request is rejected.
-     *
-     * **Pro:**
-     *
-     * - Bursts of requests are smoothed out and you can process them at a constant
-     * rate.
-     * - Allows to set a higher initial burst limit by setting `maxTokens` higher
-     * than `refillRate`
-     */
-    static tokenBucket(
-    /**
-     * How many tokens are refilled per `interval`
-     *
-     * An interval of `10s` and refillRate of 5 will cause a new token to be added every 2 seconds.
-     */
-    refillRate, 
-    /**
-     * The interval for the `refillRate`
-     */
-    interval, 
-    /**
-     * Maximum number of tokens.
-     * A newly created bucket starts with this many tokens.
-     * Useful to allow higher burst limits.
-     */
-    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 remaining   = 0
-        
-        local bucket = redis.call("HMGET", key, "updatedAt", "tokens")
-        
-        if bucket[1] == false then
-          -- The bucket does not exist yet, so we create it and add a ttl.
-          remaining = maxTokens - 1
-          
-          redis.call("HMSET", key, "updatedAt", now, "tokens", remaining)
-          redis.call("PEXPIRE", key, interval)
-  
-          return {remaining, now + interval}
-        end
-
-        -- The bucket does exist
-  
-        local updatedAt = tonumber(bucket[1])
-        local tokens = tonumber(bucket[2])
-  
-        if now >= updatedAt + interval then
-          remaining = math.min(maxTokens, tokens + refillRate) - 1
-          
-          redis.call("HMSET", key, "updatedAt", now, "tokens", remaining)
-          return {remaining, now + interval}
-        end
-  
-        if tokens > 0 then
-          remaining = tokens - 1
-          redis.call("HMSET", key, "updatedAt", now, "tokens", remaining)
-        end
-  
-        return {remaining, updatedAt + interval}
-       `;
-        const intervalDuration = (0, duration_js_1.ms)(interval);
-        return async function (ctx, identifier) {
-            if (ctx.cache) {
-                const { blocked, reset } = ctx.cache.isBlocked(identifier);
-                if (blocked) {
-                    return {
-                        success: false,
-                        limit: maxTokens,
-                        remaining: 0,
-                        reset: reset,
-                        pending: Promise.resolve(),
-                    };
-                }
-            }
-            const now = Date.now();
-            const key = [identifier, Math.floor(now / intervalDuration)].join(":");
-            const [remaining, reset] = (await ctx.redis.eval(script, [key], [maxTokens, intervalDuration, refillRate, now]));
-            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
-     * it asynchronously.
-     * This is experimental and not yet recommended for production use.
-     *
-     * @experimental
-     *
-     * 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 cachedFixedWindow(
-    /**
-     * How many requests are allowed per window.
-     */
-    tokens, 
-    /**
-     * The duration in which `tokens` requests are allowed.
-     */
-    window) {
-        const windowDuration = (0, duration_js_1.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) {
-            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 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) => {
-                        ctx.cache.set(key, t);
-                    })
-                    : Promise.resolve();
-                return {
-                    success,
-                    limit: tokens,
-                    remaining: tokens - cachedTokensAfterUpdate,
-                    reset: reset,
-                    pending,
-                };
-            }
-            const usedTokensAfterUpdate = (await ctx.redis.eval(script, [key], [windowDuration]));
-            ctx.cache.set(key, usedTokensAfterUpdate);
-            const remaining = tokens - usedTokensAfterUpdate;
-            return {
-                success: remaining >= 0,
-                limit: tokens,
-                remaining,
-                reset: reset,
-                pending: Promise.resolve(),
-            };
-        };
-    }
-}
-exports.RegionRatelimit = RegionRatelimit;

package/script/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/types/_dnt.shims.d.ts

@@ -1,5 +0,0 @@
-export { crypto, type Crypto, type SubtleCrypto, type AlgorithmIdentifier, type Algorithm, type RsaOaepParams, type BufferSource, type AesCtrParams, type AesCbcParams, type AesGcmParams, type CryptoKey, type KeyAlgorithm, type KeyType, type KeyUsage, type EcdhKeyDeriveParams, type HkdfParams, type HashAlgorithmIdentifier, type Pbkdf2Params, type AesDerivedKeyParams, type HmacImportParams, type JsonWebKey, type RsaOtherPrimesInfo, type KeyFormat, type RsaHashedKeyGenParams, type RsaKeyGenParams, type BigInteger, type EcKeyGenParams, type NamedCurve, type CryptoKeyPair, type AesKeyGenParams, type HmacKeyGenParams, type RsaHashedImportParams, type EcKeyImportParams, type AesKeyAlgorithm, type RsaPssParams, type EcdsaParams } from "@deno/shim-crypto";
-export {} from "@types/node";
-export declare const dntGlobalThis: Omit<typeof globalThis, "crypto"> & {
-    crypto: import("@deno/shim-crypto").Crypto;
-};

package/types/analytics.d.ts

@@ -1,36 +0,0 @@
-import { Redis } from "./deps/deno.land/x/upstash_redis@v1.19.3/mod.js";
-export type Geo = {
-    country?: string;
-    city?: string;
-    region?: string;
-    ip?: string;
-};
-export type Event = Geo & {
-    identifier: string;
-    time: number;
-    success: boolean;
-};
-export type AnalyticsConfig = {
-    redis: Redis;
-    prefix?: string;
-};
-export declare class Analytics {
-    private readonly redis;
-    private readonly prefix;
-    constructor(config: AnalyticsConfig);
-    extractGeo(req: {
-        geo?: Geo;
-    }): Geo;
-    record(event: Event): Promise<void>;
-    /**
-     * Aggregates the events by the given field and returns the number of successes and failures per value
-     *
-     * @param aggregateBy - The field to aggregate by
-     * @param cutoff - Timestamp in milliseconds to limit the aggregation to `cutoff` until now
-     * @returns
-     */
-    aggregate<TAggregateBy extends keyof Omit<Event, "time">>(aggregateBy: TAggregateBy, cutoff?: number): Promise<Record<string, {
-        success: number;
-        blocked: number;
-    }>[]>;
-}

package/types/cache.d.ts

@@ -1,16 +0,0 @@
-import { EphemeralCache } from "./types.js";
-export declare class Cache implements EphemeralCache {
-    /**
-     * Stores identifier -> reset (in milliseconds)
-     */
-    private readonly cache;
-    constructor(cache: Map<string, number>);
-    isBlocked(identifier: string): {
-        blocked: boolean;
-        reset: number;
-    };
-    blockUntil(identifier: string, reset: number): void;
-    set(key: string, value: number): void;
-    get(key: string): number | null;
-    incr(key: string): number;
-}

package/types/deps/deno.land/x/base64@v0.2.1/base.d.ts

@@ -1,5 +0,0 @@
-export declare function init(lookup: string[], revLookup: number[], urlsafe?: boolean): {
-    byteLength(b64: string): number;
-    toUint8Array(b64: string): Uint8Array;
-    fromUint8Array(buf: Uint8Array): string;
-};

package/types/deps/deno.land/x/base64@v0.2.1/base64url.d.ts

@@ -1 +0,0 @@
-export declare const byteLength: (b64: string) => number, toUint8Array: (b64: string) => Uint8Array, fromUint8Array: (buf: Uint8Array) => string;

package/types/deps/deno.land/x/sha1@v1.0.3/deps.d.ts

@@ -1 +0,0 @@
-export { encode, decode } from "../../../denopkg.com/chiefbiiko/std-encoding@v1.0.0/mod.js";

package/types/deps/deno.land/x/sha1@v1.0.3/mod.d.ts

@@ -1,26 +0,0 @@
-/** Byte length of a SHA1 digest. */
-export declare const BYTES: number;
-/**  A class representation of the SHA1 algorithm. */
-export declare class SHA1 {
-    readonly hashSize: number;
-    private _buf;
-    private _bufIdx;
-    private _count;
-    private _K;
-    private _H;
-    private _finalized;
-    /** Creates a SHA1 instance. */
-    constructor();
-    /** Reduces the four input numbers to a single one. */
-    protected static F(t: number, b: number, c: number, d: number): number;
-    /** Initializes a hash instance. */
-    init(): SHA1;
-    /** Updates a hash with additional message data. */
-    update(msg: string | Uint8Array, inputEncoding?: string): SHA1;
-    /** Finalizes a hash with additional message data. */
-    digest(outputEncoding?: string): string | Uint8Array;
-    /** Performs one transformation cycle. */
-    private transform;
-}
-/** Generates a SHA1 hash of the input data. */
-export declare function sha1(msg: string | Uint8Array, inputEncoding?: string, outputEncoding?: string): string | Uint8Array;