@upstash/ratelimit 0.3.0-rc.0 → 0.3.1

package/esm/deps/deno.land/x/upstash_redis@v1.19.3/pkg/script.js

@@ -1,77 +0,0 @@
-import { sha1 as digest } from "../../sha1@v1.0.3/mod.js";
-/**
- * Creates a new script.
- *
- * Scripts offer the ability to optimistically try to execute a script without having to send the
- * entire script to the server. If the script is loaded on the server, it tries again by sending
- * the entire script. Afterwards, the script is cached on the server.
- *
- * @example
- * ```ts
- * const redis = new Redis({...})
- *
- * const script = redis.createScript<string>("return ARGV[1];")
- * const arg1 = await script.eval([], ["Hello World"])
- * assertEquals(arg1, "Hello World")
- * ```
- */
-export class Script {
-    constructor(redis, script) {
-        Object.defineProperty(this, "script", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "sha1", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "redis", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.redis = redis;
-        this.sha1 = this.digest(script);
-        this.script = script;
-    }
-    /**
-     * Send an `EVAL` command to redis.
-     */
-    async eval(keys, args) {
-        return await this.redis.eval(this.script, keys, args);
-    }
-    /**
-     * Calculates the sha1 hash of the script and then calls `EVALSHA`.
-     */
-    async evalsha(keys, args) {
-        return await this.redis.evalsha(this.sha1, keys, args);
-    }
-    /**
-     * Optimistically try to run `EVALSHA` first.
-     * If the script is not loaded in redis, it will fall back and try again with `EVAL`.
-     *
-     * Following calls will be able to use the cached script
-     */
-    async exec(keys, args) {
-        const res = await this.redis.evalsha(this.sha1, keys, args).catch(async (err) => {
-            if (err instanceof Error &&
-                err.message.toLowerCase().includes("noscript")) {
-                return await this.redis.eval(this.script, keys, args);
-            }
-            throw err;
-        });
-        return res;
-    }
-    /**
-     * Compute the sha1 hash of the script and return its hex representation.
-     */
-    digest(s) {
-        const hash = digest(s, "utf8", "hex");
-        return typeof hash === "string" ? hash : new TextDecoder().decode(hash);
-    }
-}

package/esm/deps/deno.land/x/upstash_redis@v1.19.3/pkg/types.js

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

package/esm/deps/deno.land/x/upstash_redis@v1.19.3/pkg/util.js

@@ -1,31 +0,0 @@
-function parseRecursive(obj) {
-    const parsed = Array.isArray(obj)
-        ? obj.map((o) => {
-            try {
-                return parseRecursive(o);
-            }
-            catch {
-                return o;
-            }
-        })
-        : JSON.parse(obj);
-    /**
-     * Parsing very large numbers can result in MAX_SAFE_INTEGER
-     * overflow. In that case we return the number as string instead.
-     */
-    if (typeof parsed === "number" && parsed.toString() != obj) {
-        return obj;
-    }
-    return parsed;
-}
-export function parseResponse(result) {
-    try {
-        /**
-         * Try to parse the response if possible
-         */
-        return parseRecursive(result);
-    }
-    catch {
-        return result;
-    }
-}

package/esm/deps/deno.land/x/upstash_redis@v1.19.3/version.js

@@ -1 +0,0 @@
-export const VERSION = "development";

package/esm/deps/denopkg.com/chiefbiiko/std-encoding@v1.0.0/mod.js

@@ -1,50 +0,0 @@
-import { toUint8Array, fromUint8Array } from "../../../deno.land/x/base64@v0.2.1/base64url.js";
-const decoder = new TextDecoder();
-const encoder = new TextEncoder();
-/** Serializes a Uint8Array to a hexadecimal string. */
-function toHexString(buf) {
-    return buf.reduce((hex, byte) => `${hex}${byte < 16 ? "0" : ""}${byte.toString(16)}`, "");
-}
-/** Deserializes a Uint8Array from a hexadecimal string. */
-function fromHexString(hex) {
-    const len = hex.length;
-    if (len % 2 || !/^[0-9a-fA-F]+$/.test(hex)) {
-        throw new TypeError("Invalid hex string.");
-    }
-    hex = hex.toLowerCase();
-    const buf = new Uint8Array(Math.floor(len / 2));
-    const end = len / 2;
-    for (let i = 0; i < end; ++i) {
-        buf[i] = parseInt(hex.substr(i * 2, 2), 16);
-    }
-    return buf;
-}
-/** Decodes a Uint8Array to utf8-, base64-, or hex-encoded string. */
-export function decode(buf, encoding = "utf8") {
-    if (/^utf-?8$/i.test(encoding)) {
-        return decoder.decode(buf);
-    }
-    else if (/^base64$/i.test(encoding)) {
-        return fromUint8Array(buf);
-    }
-    else if (/^hex(?:adecimal)?$/i.test(encoding)) {
-        return toHexString(buf);
-    }
-    else {
-        throw new TypeError("Unsupported string encoding.");
-    }
-}
-export function encode(str, encoding = "utf8") {
-    if (/^utf-?8$/i.test(encoding)) {
-        return encoder.encode(str);
-    }
-    else if (/^base64$/i.test(encoding)) {
-        return toUint8Array(str);
-    }
-    else if (/^hex(?:adecimal)?$/i.test(encoding)) {
-        return fromHexString(str);
-    }
-    else {
-        throw new TypeError("Unsupported string encoding.");
-    }
-}

package/esm/duration.js

@@ -1,21 +0,0 @@
-/**
- * Convert a human readable duration to milliseconds
- */
-export function ms(d) {
-    const [timeString, duration] = d.split(" ");
-    const time = parseFloat(timeString);
-    switch (duration) {
-        case "ms":
-            return time;
-        case "s":
-            return time * 1000;
-        case "m":
-            return time * 1000 * 60;
-        case "h":
-            return time * 1000 * 60 * 60;
-        case "d":
-            return time * 1000 * 60 * 60 * 24;
-        default:
-            throw new Error(`Unable to parse window size: ${d}`);
-    }
-}

package/esm/mod.js

@@ -1,2 +0,0 @@
-export { RegionRatelimit as Ratelimit } from "./single.js";
-export { MultiRegionRatelimit } from "./multi.js";

package/esm/multi.js

@@ -1,268 +0,0 @@
-import * as dntShim from "./_dnt.shims.js";
-import { ms } from "./duration.js";
-import { Ratelimit } from "./ratelimit.js";
-import { Cache } from "./cache.js";
-/**
- * Ratelimiter using serverless redis from https://upstash.com/
- *
- * @example
- * ```ts
- * const { limit } = new MultiRegionRatelimit({
- *    redis: Redis.fromEnv(),
- *    limiter: MultiRegionRatelimit.fixedWindow(
- *      10,     // Allow 10 requests per window of 30 minutes
- *      "30 m", // interval of 30 minutes
- *    )
- * })
- *
- * ```
- */
-export class MultiRegionRatelimit 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)
-                    : undefined,
-            },
-        });
-    }
-    /**
-     * 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 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 } = ctx.cache.isBlocked(identifier);
-                if (blocked) {
-                    return {
-                        success: false,
-                        limit: tokens,
-                        remaining: 0,
-                        reset: reset,
-                        pending: Promise.resolve(),
-                    };
-                }
-            }
-            const requestID = dntShim.crypto.randomUUID();
-            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;
-            /**
-             * If the length between two databases does not match, we sync the two databases
-             */
-            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 the bucket in this db is already full, it doesn't matter which ids it contains.
-                     * So we do not have to sync.
-                     */
-                    if (ids.length >= tokens) {
-                        continue;
-                    }
-                    const diff = allIDs.filter((id) => !ids.includes(id));
-                    /**
-                     * Don't waste a request if there is nothing to send
-                     */
-                    if (diff.length === 0) {
-                        continue;
-                    }
-                    await db.redis.sadd(key, ...allIDs);
-                }
-            }
-            /**
-             * Do not await sync. This should not run in the critical path.
-             */
-            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(
-    /**
-     * How many requests are allowed per window.
-     */
-    tokens, 
-    /**
-     * The duration in which `tokens` requests are allowed.
-     */
-    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 } = ctx.cache.isBlocked(identifier);
-                if (blocked) {
-                    return {
-                        success: false,
-                        limit: tokens,
-                        remaining: 0,
-                        reset: reset,
-                        pending: Promise.resolve(),
-                    };
-                }
-            }
-            const requestID = dntShim.crypto.randomUUID();
-            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;
-            /**
-             * If a database differs from the consensus, we sync it
-             */
-            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 the bucket in this db is already full, it doesn't matter which ids it contains.
-                     * So we do not have to sync.
-                     */
-                    if (ids.length >= tokens) {
-                        continue;
-                    }
-                    const diff = allIDs.filter((id) => !ids.includes(id));
-                    /**
-                     * Don't waste a request if there is nothing to send
-                     */
-                    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(),
-            };
-        };
-    }
-}

package/esm/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}

package/esm/ratelimit.js

@@ -1,197 +0,0 @@
-import { Analytics } from "./analytics.js";
-import { Cache } from "./cache.js";
-export class TimeoutError extends Error {
-    constructor() {
-        super("Timeout");
-        this.name = "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
- *    ),
- * })
- *
- * ```
- */
-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
-        });
-        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({
-                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(config.ephemeralCache);
-        }
-        else if (typeof config.ephemeralCache === "undefined") {
-            this.ctx.cache = new Cache(new Map());
-        }
-    }
-}