@upstash/ratelimit 0.2.0 → 0.3.0-rc.0

package/README.md

@@ -150,6 +150,20 @@ export type RatelimitResponse = {
 };
 ````
 
+### Timeout
+
+You can define an optional timeout in milliseconds, after which the request will
+be allowed to pass regardless of what the current limit is. This can be useful
+if you don't want network issues to cause your application to reject requests.
+
+```ts
+const ratelimit = new Ratelimit({
+  redis: Redis.fromEnv(),
+  limiter: Ratelimit.slidingWindow(10, "10 s"),
+  timeout: 1000, // 1 second
+});
+```
+
 ### Block until ready
 
 In case you don't want to reject a request immediately but wait until it can be

package/esm/analytics.js

@@ -0,0 +1,84 @@
+export 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;
+    }
+}

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

@@ -0,0 +1,100 @@
+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];
+}
+export 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("");
+        },
+    };
+}

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

@@ -0,0 +1,9 @@
+import { init } from "./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;
+}
+export const { byteLength, toUint8Array, fromUint8Array } = init(lookup, revLookup, true);

package/esm/deps/deno.land/x/sha1@v1.0.3/deps.js

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

package/esm/deps/deno.land/x/sha1@v1.0.3/mod.js

@@ -0,0 +1,191 @@
+import { encode, decode } from "./deps.js";
+function rotl(x, n) {
+    return (x << n) | (x >>> (32 - n));
+}
+/** Byte length of a SHA1 digest. */
+export const BYTES = 20;
+/**  A class representation of the SHA1 algorithm. */
+export class SHA1 {
+    /** Creates a SHA1 instance. */
+    constructor() {
+        Object.defineProperty(this, "hashSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: BYTES
+        });
+        Object.defineProperty(this, "_buf", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Uint8Array(64)
+        });
+        Object.defineProperty(this, "_bufIdx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_count", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_K", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Uint32Array([0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6])
+        });
+        Object.defineProperty(this, "_H", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_finalized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.init();
+    }
+    /** Reduces the four input numbers to a single one. */
+    static F(t, b, c, d) {
+        if (t <= 19) {
+            return (b & c) | (~b & d);
+        }
+        else if (t <= 39) {
+            return b ^ c ^ d;
+        }
+        else if (t <= 59) {
+            return (b & c) | (b & d) | (c & d);
+        }
+        else {
+            return b ^ c ^ d;
+        }
+    }
+    /** Initializes a hash instance. */
+    init() {
+        // prettier-ignore
+        this._H = new Uint32Array([
+            0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0
+        ]);
+        this._bufIdx = 0;
+        this._count = new Uint32Array(2);
+        this._buf.fill(0);
+        this._finalized = false;
+        return this;
+    }
+    /** Updates a hash with additional message data. */
+    update(msg, inputEncoding) {
+        if (msg === null) {
+            throw new TypeError("msg must be a string or Uint8Array.");
+        }
+        else if (typeof msg === "string") {
+            msg = encode(msg, inputEncoding);
+        }
+        // process the msg as many times as possible, the rest is stored in the buffer
+        // message is processed in 512 bit (64 byte chunks)
+        for (let i = 0; i < msg.length; i++) {
+            this._buf[this._bufIdx++] = msg[i];
+            if (this._bufIdx === 64) {
+                this.transform();
+                this._bufIdx = 0;
+            }
+        }
+        // counter update (number of message bits)
+        const c = this._count;
+        if ((c[0] += msg.length << 3) < msg.length << 3) {
+            c[1]++;
+        }
+        c[1] += msg.length >>> 29;
+        return this;
+    }
+    /** Finalizes a hash with additional message data. */
+    digest(outputEncoding) {
+        if (this._finalized) {
+            throw new Error("digest has already been called.");
+        }
+        this._finalized = true;
+        // append '1'
+        const b = this._buf;
+        let idx = this._bufIdx;
+        b[idx++] = 0x80;
+        // zeropad up to byte pos 56
+        while (idx !== 56) {
+            if (idx === 64) {
+                this.transform();
+                idx = 0;
+            }
+            b[idx++] = 0;
+        }
+        // append length in bits
+        const c = this._count;
+        b[56] = (c[1] >>> 24) & 0xff;
+        b[57] = (c[1] >>> 16) & 0xff;
+        b[58] = (c[1] >>> 8) & 0xff;
+        b[59] = (c[1] >>> 0) & 0xff;
+        b[60] = (c[0] >>> 24) & 0xff;
+        b[61] = (c[0] >>> 16) & 0xff;
+        b[62] = (c[0] >>> 8) & 0xff;
+        b[63] = (c[0] >>> 0) & 0xff;
+        this.transform();
+        // return the hash as byte array (20 bytes)
+        const hash = new Uint8Array(BYTES);
+        for (let i = 0; i < 5; i++) {
+            hash[(i << 2) + 0] = (this._H[i] >>> 24) & 0xff;
+            hash[(i << 2) + 1] = (this._H[i] >>> 16) & 0xff;
+            hash[(i << 2) + 2] = (this._H[i] >>> 8) & 0xff;
+            hash[(i << 2) + 3] = (this._H[i] >>> 0) & 0xff;
+        }
+        // clear internal states and prepare for new hash
+        this.init();
+        return outputEncoding ? decode(hash, outputEncoding) : hash;
+    }
+    /** Performs one transformation cycle. */
+    transform() {
+        const h = this._H;
+        let a = h[0];
+        let b = h[1];
+        let c = h[2];
+        let d = h[3];
+        let e = h[4];
+        // convert byte buffer to words
+        const w = new Uint32Array(80);
+        for (let i = 0; i < 16; i++) {
+            w[i] =
+                this._buf[(i << 2) + 3] |
+                    (this._buf[(i << 2) + 2] << 8) |
+                    (this._buf[(i << 2) + 1] << 16) |
+                    (this._buf[i << 2] << 24);
+        }
+        for (let t = 0; t < 80; t++) {
+            if (t >= 16) {
+                w[t] = rotl(w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16], 1);
+            }
+            const tmp = (rotl(a, 5) +
+                SHA1.F(t, b, c, d) +
+                e +
+                w[t] +
+                this._K[Math.floor(t / 20)]) |
+                0;
+            e = d;
+            d = c;
+            c = rotl(b, 30);
+            b = a;
+            a = tmp;
+        }
+        h[0] = (h[0] + a) | 0;
+        h[1] = (h[1] + b) | 0;
+        h[2] = (h[2] + c) | 0;
+        h[3] = (h[3] + d) | 0;
+        h[4] = (h[4] + e) | 0;
+    }
+}
+/** Generates a SHA1 hash of the input data. */
+export function sha1(msg, inputEncoding, outputEncoding) {
+    return new SHA1().update(msg, inputEncoding).digest(outputEncoding);
+}

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

@@ -0,0 +1,66 @@
+import { HttpClient, } from "./pkg/http.js";
+import * as core from "./pkg/redis.js";
+import { VERSION } from "./version.js";
+/**
+ * Serverless redis client for upstash.
+ */
+export class Redis extends core.Redis {
+    /**
+     * Create a new redis client
+     *
+     * @example
+     * ```typescript
+     * const redis = new Redis({
+     *  url: "<UPSTASH_REDIS_REST_URL>",
+     *  token: "<UPSTASH_REDIS_REST_TOKEN>",
+     * });
+     * ```
+     */
+    constructor(config) {
+        if (config.url.startsWith(" ") ||
+            config.url.endsWith(" ") ||
+            /\r|\n/.test(config.url)) {
+            console.warn("The redis url contains whitespace or newline, which can cause errors!");
+        }
+        if (config.token.startsWith(" ") ||
+            config.token.endsWith(" ") ||
+            /\r|\n/.test(config.token)) {
+            console.warn("The redis token contains whitespace or newline, which can cause errors!");
+        }
+        const telemetry = {};
+        if (!Deno.env.get("UPSTASH_DISABLE_TELEMETRY")) {
+            // Deno Deploy does not include the version data, so we need to treat it as optional
+            telemetry.runtime = `deno@${Deno.version?.deno}`;
+            telemetry.sdk = `@upstash/redis@${VERSION}`;
+        }
+        const client = new HttpClient({
+            retry: config.retry,
+            baseUrl: config.url,
+            headers: { authorization: `Bearer ${config.token}` },
+            responseEncoding: config.responseEncoding,
+            telemetry,
+        });
+        super(client, {
+            automaticDeserialization: config.automaticDeserialization,
+        });
+    }
+    /*
+     * Create a new Upstash Redis instance from environment variables on Deno.
+  
+     *
+     */
+    static fromEnv(opts) {
+        /**
+         * These should be injected by Deno.
+         */
+        const url = Deno.env.get("UPSTASH_REDIS_REST_URL");
+        if (!url) {
+            throw new Error("Unable to find environment variable: `UPSTASH_REDIS_REST_URL`.");
+        }
+        const token = Deno.env.get("UPSTASH_REDIS_REST_TOKEN");
+        if (!token) {
+            throw new Error("Unable to find environment variable: `UPSTASH_REDIS_REST_TOKEN`.");
+        }
+        return new Redis({ ...opts, url, token });
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/append
+ */
+export class AppendCommand extends Command {
+    constructor(cmd, opts) {
+        super(["append", ...cmd], opts);
+    }
+}

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

@@ -0,0 +1,16 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/bitcount
+ */
+export class BitCountCommand extends Command {
+    constructor([key, start, end], opts) {
+        const command = ["bitcount", key];
+        if (typeof start === "number") {
+            command.push(start);
+        }
+        if (typeof end === "number") {
+            command.push(end);
+        }
+        super(command, opts);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/bitop
+ */
+export class BitOpCommand extends Command {
+    constructor(cmd, opts) {
+        super(["bitop", ...cmd], opts);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/bitpos
+ */
+export class BitPosCommand extends Command {
+    constructor(cmd, opts) {
+        super(["bitpos", ...cmd], opts);
+    }
+}

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

@@ -0,0 +1,57 @@
+import { UpstashError } from "../error.js";
+import { parseResponse } from "../util.js";
+const defaultSerializer = (c) => typeof c === "string" ? c : JSON.stringify(c);
+/**
+ * Command offers default (de)serialization and the exec method to all commands.
+ *
+ * TData represents what the user will enter or receive,
+ * TResult is the raw data returned from upstash, which may need to be transformed or parsed.
+ */
+export class Command {
+    /**
+     * Create a new command instance.
+     *
+     * You can define a custom `deserialize` function. By default we try to deserialize as json.
+     */
+    constructor(command, opts) {
+        Object.defineProperty(this, "command", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "serialize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "deserialize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.serialize = defaultSerializer;
+        this.deserialize = typeof opts?.automaticDeserialization === "undefined" ||
+            opts.automaticDeserialization
+            ? opts?.deserialize ?? parseResponse
+            : (x) => x;
+        this.command = command.map(this.serialize);
+    }
+    /**
+     * Execute the command using a client.
+     */
+    async exec(client) {
+        const { result, error } = await client.request({
+            body: this.command,
+        });
+        if (error) {
+            throw new UpstashError(error);
+        }
+        if (typeof result === "undefined") {
+            throw new Error(`Request did not return a result`);
+        }
+        return this.deserialize(result);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/dbsize
+ */
+export class DBSizeCommand extends Command {
+    constructor(opts) {
+        super(["dbsize"], opts);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/decr
+ */
+export class DecrCommand extends Command {
+    constructor(cmd, opts) {
+        super(["decr", ...cmd], opts);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/decrby
+ */
+export class DecrByCommand extends Command {
+    constructor(cmd, opts) {
+        super(["decrby", ...cmd], opts);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/del
+ */
+export class DelCommand extends Command {
+    constructor(cmd, opts) {
+        super(["del", ...cmd], opts);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/echo
+ */
+export class EchoCommand extends Command {
+    constructor(cmd, opts) {
+        super(["echo", ...cmd], opts);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/eval
+ */
+export class EvalCommand extends Command {
+    constructor([script, keys, args], opts) {
+        super(["eval", script, keys.length, ...keys, ...(args ?? [])], opts);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/evalsha
+ */
+export class EvalshaCommand extends Command {
+    constructor([sha, keys, args], opts) {
+        super(["evalsha", sha, keys.length, ...keys, ...(args ?? [])], opts);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/exists
+ */
+export class ExistsCommand extends Command {
+    constructor(cmd, opts) {
+        super(["exists", ...cmd], opts);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/expire
+ */
+export class ExpireCommand extends Command {
+    constructor(cmd, opts) {
+        super(["expire", ...cmd], opts);
+    }
+}