@upstash/ratelimit 0.2.0 → 0.3.0-rc.0

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

@@ -0,0 +1,27 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/zInterstore
+ */
+export class ZInterStoreCommand extends Command {
+    constructor([destination, numKeys, keyOrKeys, opts], cmdOpts) {
+        const command = ["zinterstore", destination, numKeys];
+        if (Array.isArray(keyOrKeys)) {
+            command.push(...keyOrKeys);
+        }
+        else {
+            command.push(keyOrKeys);
+        }
+        if (opts) {
+            if ("weights" in opts && opts.weights) {
+                command.push("weights", ...opts.weights);
+            }
+            else if ("weight" in opts && typeof opts.weight === "number") {
+                command.push("weights", opts.weight);
+            }
+            if ("aggregate" in opts) {
+                command.push("aggregate", opts.aggregate);
+            }
+        }
+        super(command, cmdOpts);
+    }
+}

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

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

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

@@ -0,0 +1,10 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/zmscore
+ */
+export class ZMScoreCommand extends Command {
+    constructor(cmd, opts) {
+        const [key, members] = cmd;
+        super(["zmscore", key, ...members], opts);
+    }
+}

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

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

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

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

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

@@ -0,0 +1,26 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/zrange
+ */
+export class ZRangeCommand extends Command {
+    constructor([key, min, max, opts], cmdOpts) {
+        const command = ["zrange", key, min, max];
+        // Either byScore or byLex is allowed
+        if (opts?.byScore) {
+            command.push("byscore");
+        }
+        if (opts?.byLex) {
+            command.push("bylex");
+        }
+        if (opts?.rev) {
+            command.push("rev");
+        }
+        if (typeof opts?.count !== "undefined" && typeof opts?.offset !== "undefined") {
+            command.push("limit", opts.offset, opts.count);
+        }
+        if (opts?.withScores) {
+            command.push("withscores");
+        }
+        super(command, cmdOpts);
+    }
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/zscan
+ */
+export class ZScanCommand extends Command {
+    constructor([key, cursor, opts], cmdOpts) {
+        const command = ["zscan", key, cursor];
+        if (opts?.match) {
+            command.push("match", opts.match);
+        }
+        if (typeof opts?.count === "number") {
+            command.push("count", opts.count);
+        }
+        super(command, cmdOpts);
+    }
+}

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

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

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

@@ -0,0 +1,27 @@
+import { Command } from "./command.js";
+/**
+ * @see https://redis.io/commands/zunionstore
+ */
+export class ZUnionStoreCommand extends Command {
+    constructor([destination, numKeys, keyOrKeys, opts], cmdOpts) {
+        const command = ["zunionstore", destination, numKeys];
+        if (Array.isArray(keyOrKeys)) {
+            command.push(...keyOrKeys);
+        }
+        else {
+            command.push(keyOrKeys);
+        }
+        if (opts) {
+            if ("weights" in opts && opts.weights) {
+                command.push("weights", ...opts.weights);
+            }
+            else if ("weight" in opts && typeof opts.weight === "number") {
+                command.push("weights", opts.weight);
+            }
+            if ("aggregate" in opts) {
+                command.push("aggregate", opts.aggregate);
+            }
+        }
+        super(command, cmdOpts);
+    }
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Result of a bad request to upstash
+ */
+export class UpstashError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UpstashError";
+    }
+}

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

@@ -0,0 +1,165 @@
+import { UpstashError } from "./error.js";
+export class HttpClient {
+    constructor(config) {
+        Object.defineProperty(this, "baseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "headers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "retry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.options = {
+            backend: config.options?.backend,
+            agent: config.agent,
+            responseEncoding: config.responseEncoding ?? "base64", // default to base64
+        };
+        this.baseUrl = config.baseUrl.replace(/\/$/, "");
+        this.headers = {
+            "Content-Type": "application/json",
+            ...config.headers,
+        };
+        if (this.options.responseEncoding === "base64") {
+            this.headers["Upstash-Encoding"] = "base64";
+        }
+        if (typeof config?.retry === "boolean" && config?.retry === false) {
+            this.retry = {
+                attempts: 1,
+                backoff: () => 0,
+            };
+        }
+        else {
+            this.retry = {
+                attempts: config?.retry?.retries ?? 5,
+                backoff: config?.retry?.backoff ??
+                    ((retryCount) => Math.exp(retryCount) * 50),
+            };
+        }
+    }
+    mergeTelemetry(telemetry) {
+        function merge(obj, key, value) {
+            if (!value) {
+                return obj;
+            }
+            if (obj[key]) {
+                obj[key] = [obj[key], value].join(",");
+            }
+            else {
+                obj[key] = value;
+            }
+            return obj;
+        }
+        this.headers = merge(this.headers, "Upstash-Telemetry-Runtime", telemetry.runtime);
+        this.headers = merge(this.headers, "Upstash-Telemetry-Platform", telemetry.platform);
+        this.headers = merge(this.headers, "Upstash-Telemetry-Sdk", telemetry.sdk);
+    }
+    async request(req) {
+        const requestOptions = {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(req.body),
+            keepalive: true,
+            agent: this.options?.agent,
+            /**
+             * Fastly specific
+             */
+            backend: this.options?.backend,
+        };
+        let res = null;
+        let error = null;
+        for (let i = 0; i <= this.retry.attempts; i++) {
+            try {
+                res = await fetch([this.baseUrl, ...(req.path ?? [])].join("/"), requestOptions);
+                break;
+            }
+            catch (err) {
+                error = err;
+                await new Promise((r) => setTimeout(r, this.retry.backoff(i)));
+            }
+        }
+        if (!res) {
+            throw error ?? new Error("Exhausted all retries");
+        }
+        const body = (await res.json());
+        if (!res.ok) {
+            throw new UpstashError(body.error);
+        }
+        if (this.options?.responseEncoding === "base64") {
+            return Array.isArray(body) ? body.map(decode) : decode(body);
+        }
+        return body;
+    }
+}
+function base64decode(b64) {
+    let dec = "";
+    try {
+        /**
+         * Using only atob() is not enough because it doesn't work with unicode characters
+         */
+        const binString = atob(b64);
+        const size = binString.length;
+        const bytes = new Uint8Array(size);
+        for (let i = 0; i < size; i++) {
+            bytes[i] = binString.charCodeAt(i);
+        }
+        dec = new TextDecoder().decode(bytes);
+    }
+    catch {
+        dec = b64;
+    }
+    return dec;
+    // try {
+    //   return decodeURIComponent(dec);
+    // } catch {
+    //   return dec;
+    // }
+}
+function decode(raw) {
+    let result = undefined;
+    switch (typeof raw.result) {
+        case "undefined":
+            return raw;
+        case "number": {
+            result = raw.result;
+            break;
+        }
+        case "object": {
+            if (Array.isArray(raw.result)) {
+                result = raw.result.map((v) => typeof v === "string"
+                    ? base64decode(v)
+                    : Array.isArray(v)
+                        ? v.map(base64decode)
+                        : v);
+            }
+            else {
+                // If it's not an array it must be null
+                // Apparently null is an object in javascript
+                result = null;
+            }
+            break;
+        }
+        case "string": {
+            result = raw.result === "OK" ? "OK" : base64decode(raw.result);
+            break;
+        }
+        default:
+            break;
+    }
+    return { result, error: raw.error };
+}