@upstash/ratelimit 0.3.0-rc.1 → 0.3.2

package/esm/single.js

@@ -1,376 +0,0 @@
-import { ms } from "./duration.js";
-import { Ratelimit } from "./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
- *    )
- * })
- *
- * ```
- */
-export class RegionRatelimit 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,
-            },
-            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 = 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 = 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 = 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 = 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(),
-            };
-        };
-    }
-}

package/esm/types.js

@@ -1 +0,0 @@
-export {};

package/script/_dnt.shims.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dntGlobalThis = exports.crypto = void 0;
-const shim_crypto_1 = require("@deno/shim-crypto");
-var shim_crypto_2 = require("@deno/shim-crypto");
-Object.defineProperty(exports, "crypto", { enumerable: true, get: function () { return shim_crypto_2.crypto; } });
-const dntGlobals = {
-    crypto: shim_crypto_1.crypto,
-};
-exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
-// deno-lint-ignore ban-types
-function createMergeProxy(baseObj, extObj) {
-    return new Proxy(baseObj, {
-        get(_target, prop, _receiver) {
-            if (prop in extObj) {
-                return extObj[prop];
-            }
-            else {
-                return baseObj[prop];
-            }
-        },
-        set(_target, prop, value) {
-            if (prop in extObj) {
-                delete extObj[prop];
-            }
-            baseObj[prop] = value;
-            return true;
-        },
-        deleteProperty(_target, prop) {
-            let success = false;
-            if (prop in extObj) {
-                delete extObj[prop];
-                success = true;
-            }
-            if (prop in baseObj) {
-                delete baseObj[prop];
-                success = true;
-            }
-            return success;
-        },
-        ownKeys(_target) {
-            const baseKeys = Reflect.ownKeys(baseObj);
-            const extKeys = Reflect.ownKeys(extObj);
-            const extKeysSet = new Set(extKeys);
-            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
-        },
-        defineProperty(_target, prop, desc) {
-            if (prop in extObj) {
-                delete extObj[prop];
-            }
-            Reflect.defineProperty(baseObj, prop, desc);
-            return true;
-        },
-        getOwnPropertyDescriptor(_target, prop) {
-            if (prop in extObj) {
-                return Reflect.getOwnPropertyDescriptor(extObj, prop);
-            }
-            else {
-                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
-            }
-        },
-        has(_target, prop) {
-            return prop in extObj || prop in baseObj;
-        },
-    });
-}

package/script/analytics.js

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Analytics = void 0;
-class Analytics {
-    constructor(config) {
-        Object.defineProperty(this, "redis", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "prefix", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.redis = config.redis;
-        this.prefix = config.prefix ?? "@upstash/ratelimit";
-    }
-    extractGeo(req) {
-        if (typeof req.geo !== "undefined") {
-            return req.geo;
-        }
-        return {};
-    }
-    async record(event) {
-        // Bucket is a unix timestamp in milliseconds marking the beginning of a day
-        const bucket = (new Date().setUTCHours(0, 0, 0, 0)).toFixed(0);
-        const key = [this.prefix, "events", bucket].join(":");
-        await this.redis.hincrby(key, JSON.stringify({
-            ...event,
-            time: undefined,
-        }), 1);
-    }
-    /**
-     * 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
-     */
-    async aggregate(aggregateBy, cutoff = 0) {
-        const keys = [];
-        let cursor = 0;
-        do {
-            const [nextCursor, found] = await this.redis.scan(cursor, { match: [this.prefix, "events", "*"].join(":"), count: 1000 });
-            cursor = nextCursor;
-            for (const key of found) {
-                const timestamp = parseInt(key.split(":").pop());
-                // Take all the keys that at least overlap with the given timestamp
-                if (timestamp >= cutoff) {
-                    keys.push(key);
-                }
-            }
-        } while (cursor !== 0);
-        const days = await Promise.all(keys.sort().map(async (key) => {
-            const fields = await this.redis.hgetall(key);
-            if (!fields) {
-                return {};
-            }
-            const day = {};
-            for (const [field, count] of Object.entries(fields)) {
-                const r = JSON.parse(field);
-                for (const [k, v] of Object.entries(r)) {
-                    if (k !== aggregateBy) {
-                        continue;
-                    }
-                    if (!day[v]) {
-                        day[v] = {
-                            success: 0,
-                            blocked: 0,
-                        };
-                    }
-                    if (r.success) {
-                        day[v].success += count;
-                    }
-                    else {
-                        day[v].blocked += count;
-                    }
-                }
-            }
-            return day;
-        }));
-        return days;
-    }
-}
-exports.Analytics = Analytics;

package/script/cache.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cache = void 0;
-class Cache {
-    constructor(cache) {
-        /**
-         * Stores identifier -> reset (in milliseconds)
-         */
-        Object.defineProperty(this, "cache", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.cache = cache;
-    }
-    isBlocked(identifier) {
-        if (!this.cache.has(identifier)) {
-            return { blocked: false, reset: 0 };
-        }
-        const reset = this.cache.get(identifier);
-        if (reset < Date.now()) {
-            this.cache.delete(identifier);
-            return { blocked: false, reset: 0 };
-        }
-        return { blocked: true, reset: reset };
-    }
-    blockUntil(identifier, reset) {
-        this.cache.set(identifier, reset);
-    }
-    set(key, value) {
-        this.cache.set(key, value);
-    }
-    get(key) {
-        return this.cache.get(key) || null;
-    }
-    incr(key) {
-        let value = this.cache.get(key) ?? 0;
-        value += 1;
-        this.cache.set(key, value);
-        return value;
-    }
-}
-exports.Cache = Cache;

package/script/deps/deno.land/x/base64@v0.2.1/base.js

@@ -1,104 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.init = void 0;
-function getLengths(b64) {
-    const len = b64.length;
-    // if (len % 4 > 0) {
-    //   throw new TypeError("Invalid string. Length must be a multiple of 4");
-    // }
-    // Trim off extra bytes after placeholder bytes are found
-    // See: https://github.com/beatgammit/base64-js/issues/42
-    let validLen = b64.indexOf("=");
-    if (validLen === -1) {
-        validLen = len;
-    }
-    const placeHoldersLen = validLen === len ? 0 : 4 - (validLen % 4);
-    return [validLen, placeHoldersLen];
-}
-function init(lookup, revLookup, urlsafe = false) {
-    function _byteLength(validLen, placeHoldersLen) {
-        return Math.floor(((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen);
-    }
-    function tripletToBase64(num) {
-        return (lookup[(num >> 18) & 0x3f] +
-            lookup[(num >> 12) & 0x3f] +
-            lookup[(num >> 6) & 0x3f] +
-            lookup[num & 0x3f]);
-    }
-    function encodeChunk(buf, start, end) {
-        const out = new Array((end - start) / 3);
-        for (let i = start, curTriplet = 0; i < end; i += 3) {
-            out[curTriplet++] = tripletToBase64((buf[i] << 16) + (buf[i + 1] << 8) + buf[i + 2]);
-        }
-        return out.join("");
-    }
-    return {
-        // base64 is 4/3 + up to two characters of the original data
-        byteLength(b64) {
-            return _byteLength.apply(null, getLengths(b64));
-        },
-        toUint8Array(b64) {
-            const [validLen, placeHoldersLen] = getLengths(b64);
-            const buf = new Uint8Array(_byteLength(validLen, placeHoldersLen));
-            // If there are placeholders, only get up to the last complete 4 chars
-            const len = placeHoldersLen ? validLen - 4 : validLen;
-            let tmp;
-            let curByte = 0;
-            let i;
-            for (i = 0; i < len; i += 4) {
-                tmp = (revLookup[b64.charCodeAt(i)] << 18) |
-                    (revLookup[b64.charCodeAt(i + 1)] << 12) |
-                    (revLookup[b64.charCodeAt(i + 2)] << 6) |
-                    revLookup[b64.charCodeAt(i + 3)];
-                buf[curByte++] = (tmp >> 16) & 0xff;
-                buf[curByte++] = (tmp >> 8) & 0xff;
-                buf[curByte++] = tmp & 0xff;
-            }
-            if (placeHoldersLen === 2) {
-                tmp = (revLookup[b64.charCodeAt(i)] << 2) |
-                    (revLookup[b64.charCodeAt(i + 1)] >> 4);
-                buf[curByte++] = tmp & 0xff;
-            }
-            else if (placeHoldersLen === 1) {
-                tmp = (revLookup[b64.charCodeAt(i)] << 10) |
-                    (revLookup[b64.charCodeAt(i + 1)] << 4) |
-                    (revLookup[b64.charCodeAt(i + 2)] >> 2);
-                buf[curByte++] = (tmp >> 8) & 0xff;
-                buf[curByte++] = tmp & 0xff;
-            }
-            return buf;
-        },
-        fromUint8Array(buf) {
-            const maxChunkLength = 16383; // Must be multiple of 3
-            const len = buf.length;
-            const extraBytes = len % 3; // If we have 1 byte left, pad 2 bytes
-            const len2 = len - extraBytes;
-            const parts = new Array(Math.ceil(len2 / maxChunkLength) + (extraBytes ? 1 : 0));
-            let curChunk = 0;
-            let chunkEnd;
-            // Go through the array every three bytes, we'll deal with trailing stuff later
-            for (let i = 0; i < len2; i += maxChunkLength) {
-                chunkEnd = i + maxChunkLength;
-                parts[curChunk++] = encodeChunk(buf, i, chunkEnd > len2 ? len2 : chunkEnd);
-            }
-            let tmp;
-            // Pad the end with zeros, but make sure to not forget the extra bytes
-            if (extraBytes === 1) {
-                tmp = buf[len2];
-                parts[curChunk] = lookup[tmp >> 2] + lookup[(tmp << 4) & 0x3f];
-                if (!urlsafe)
-                    parts[curChunk] += "==";
-            }
-            else if (extraBytes === 2) {
-                tmp = (buf[len2] << 8) | (buf[len2 + 1] & 0xff);
-                parts[curChunk] = lookup[tmp >> 10] +
-                    lookup[(tmp >> 4) & 0x3f] +
-                    lookup[(tmp << 2) & 0x3f];
-                if (!urlsafe)
-                    parts[curChunk] += "=";
-            }
-            return parts.join("");
-        },
-    };
-}
-exports.init = init;

package/script/deps/deno.land/x/base64@v0.2.1/base64url.js

@@ -1,13 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromUint8Array = exports.toUint8Array = exports.byteLength = void 0;
-const base_js_1 = require("./base.js");
-const lookup = [];
-const revLookup = [];
-const code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-for (let i = 0, l = code.length; i < l; ++i) {
-    lookup[i] = code[i];
-    revLookup[code.charCodeAt(i)] = i;
-}
-_a = (0, base_js_1.init)(lookup, revLookup, true), exports.byteLength = _a.byteLength, exports.toUint8Array = _a.toUint8Array, exports.fromUint8Array = _a.fromUint8Array;