@upstash/redis 0.0.0-ci.c37cc01e → 0.0.0-ci.c6073771-20221014

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/denopkg.com/chiefbiiko/std-encoding@v1.0.0/mod.js

@@ -0,0 +1,50 @@
+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/pkg/commands/scan.js

@@ -11,6 +11,9 @@ export class ScanCommand extends Command {
         if (typeof opts?.count === "number") {
             command.push("count", opts.count);
         }
+        if (opts?.type && opts.type.length > 0) {
+            command.push("type", opts.type);
+        }
         super(command, cmdOpts);
     }
 }

package/esm/pkg/commands/set.js

@@ -6,17 +6,29 @@ export class SetCommand extends Command {
     constructor([key, value, opts], cmdOpts) {
         const command = ["set", key, value];
         if (opts) {
+            if ("nx" in opts && opts.nx) {
+                command.push("nx");
+            }
+            else if ("xx" in opts && opts.xx) {
+                command.push("xx");
+            }
+            if ("get" in opts && opts.get) {
+                command.push("get");
+            }
             if ("ex" in opts && typeof opts.ex === "number") {
                 command.push("ex", opts.ex);
             }
             else if ("px" in opts && typeof opts.px === "number") {
                 command.push("px", opts.px);
             }
-            if ("nx" in opts && opts.nx) {
-                command.push("nx");
+            else if ("exat" in opts && typeof opts.exat === "number") {
+                command.push("exat", opts.exat);
             }
-            else if ("xx" in opts && opts.xx) {
-                command.push("xx");
+            else if ("pxat" in opts && typeof opts.pxat === "number") {
+                command.push("pxat", opts.pxat);
+            }
+            else if ("keepTtl" in opts && opts.keepTtl) {
+                command.push("keepTtl", opts.keepTtl);
             }
         }
         super(command, cmdOpts);

package/esm/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/pkg/http.js

@@ -26,7 +26,11 @@ export class HttpClient {
             value: void 0
         });
         this.baseUrl = config.baseUrl.replace(/\/$/, "");
-        this.headers = { "Content-Type": "application/json", ...config.headers };
+        this.headers = {
+            "Content-Type": "application/json",
+            "Upstash-Encoding": "base64",
+            ...config.headers,
+        };
         this.options = { backend: config.options?.backend };
         if (typeof config?.retry === "boolean" && config?.retry === false) {
             this.retry = {
@@ -72,6 +76,53 @@ export class HttpClient {
         if (!res.ok) {
             throw new UpstashError(body.error);
         }
-        return body;
+        return Array.isArray(body) ? body.map(decode) : decode(body);
+    }
+}
+function base64decode(b64) {
+    let dec = "";
+    try {
+        dec = atob(b64).split("").map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join("");
+    }
+    catch (e) {
+        console.warn(`Unable to decode base64 [${dec}]: ${e.message}`);
+        return dec;
+    }
+    try {
+        return decodeURIComponent(dec);
+    }
+    catch (e) {
+        console.warn(`Unable to decode URI [${dec}]: ${e.message}`);
+        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 };
 }

package/esm/pkg/pipeline.js

@@ -1,5 +1,6 @@
 import { AppendCommand, BitCountCommand, BitOpCommand, BitPosCommand, DBSizeCommand, DecrByCommand, DecrCommand, DelCommand, EchoCommand, EvalCommand, EvalshaCommand, ExistsCommand, ExpireAtCommand, ExpireCommand, FlushAllCommand, FlushDBCommand, GetBitCommand, GetCommand, GetRangeCommand, GetSetCommand, HDelCommand, HExistsCommand, HGetAllCommand, HGetCommand, HIncrByCommand, HIncrByFloatCommand, HKeysCommand, HLenCommand, HMGetCommand, HMSetCommand, HScanCommand, HSetCommand, HSetNXCommand, HStrLenCommand, HValsCommand, IncrByCommand, IncrByFloatCommand, IncrCommand, KeysCommand, LIndexCommand, LInsertCommand, LLenCommand, LPopCommand, LPosCommand, LPushCommand, LPushXCommand, LRangeCommand, LRemCommand, LSetCommand, LTrimCommand, MGetCommand, MSetCommand, MSetNXCommand, PersistCommand, PExpireAtCommand, PExpireCommand, PingCommand, PSetEXCommand, PTtlCommand, PublishCommand, RandomKeyCommand, RenameCommand, RenameNXCommand, RPopCommand, RPushCommand, RPushXCommand, SAddCommand, ScanCommand, SCardCommand, ScriptExistsCommand, ScriptFlushCommand, ScriptLoadCommand, SDiffCommand, SDiffStoreCommand, SetBitCommand, SetCommand, SetExCommand, SetNxCommand, SetRangeCommand, SInterCommand, SInterStoreCommand, SIsMemberCommand, SMembersCommand, SMoveCommand, SPopCommand, SRandMemberCommand, SRemCommand, SScanCommand, StrLenCommand, SUnionCommand, SUnionStoreCommand, TimeCommand, TouchCommand, TtlCommand, TypeCommand, UnlinkCommand, ZAddCommand, ZCardCommand, ZCountCommand, ZIncrByCommand, ZInterStoreCommand, ZLexCountCommand, ZPopMaxCommand, ZPopMinCommand, ZRangeCommand, ZRankCommand, ZRemCommand, ZRemRangeByLexCommand, ZRemRangeByRankCommand, ZRemRangeByScoreCommand, ZRevRankCommand, ZScanCommand, ZScoreCommand, ZUnionStoreCommand, } from "./commands/mod.js";
 import { UpstashError } from "./error.js";
+import { ZMScoreCommand } from "./commands/zmscore.js";
 /**
  * Upstash REST API supports command pipelining to send multiple commands in
  * batch, instead of sending each command one by one and waiting for a response.
@@ -16,7 +17,7 @@ import { UpstashError } from "./error.js";
  * **Examples:**
  *
  * ```ts
- *  const p = redis.pipeline()
+ *  const p = redis.pipeline() // or redis.multi()
  * p.set("key","value")
  * p.get("key")
  * const res = await p.exec()
@@ -39,7 +40,7 @@ import { UpstashError } from "./error.js";
  * ```
  */
 export class Pipeline {
-    constructor(client, commandOptions) {
+    constructor(opts) {
         Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
@@ -58,6 +59,12 @@ export class Pipeline {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "multiExec", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         /**
          * Send the pipeline request to upstash.
          *
@@ -76,8 +83,9 @@ export class Pipeline {
                 if (this.commands.length === 0) {
                     throw new Error("Pipeline is empty");
                 }
+                const path = this.multiExec ? ["multi-exec"] : ["pipeline"];
                 const res = (await this.client.request({
-                    path: ["pipeline"],
+                    path,
                     body: Object.values(this.commands).map((c) => c.command),
                 }));
                 return res.map(({ error, result }, i) => {
@@ -1011,6 +1019,15 @@ export class Pipeline {
             writable: true,
             value: (...args) => this.chain(new ZLexCountCommand(args, this.commandOptions))
         });
+        /**
+         * @see https://redis.io/commands/zmscore
+         */
+        Object.defineProperty(this, "zmscore", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (...args) => this.chain(new ZMScoreCommand(args, this.commandOptions))
+        });
         /**
          * @see https://redis.io/commands/zpopmax
          */
@@ -1119,9 +1136,10 @@ export class Pipeline {
             writable: true,
             value: (...args) => this.chain(new ZUnionStoreCommand(args, this.commandOptions))
         });
-        this.client = client;
+        this.client = opts.client;
         this.commands = [];
-        this.commandOptions = commandOptions;
+        this.commandOptions = opts.commandOptions;
+        this.multiExec = opts.multiExec ?? false;
     }
     /**
      * Pushes a command into the pipelien and returns a chainable instance of the

package/esm/pkg/redis.js

@@ -1,5 +1,7 @@
 import { AppendCommand, BitCountCommand, BitOpCommand, BitPosCommand, DBSizeCommand, DecrByCommand, DecrCommand, DelCommand, EchoCommand, EvalCommand, EvalshaCommand, ExistsCommand, ExpireAtCommand, ExpireCommand, FlushAllCommand, FlushDBCommand, GetBitCommand, GetCommand, GetRangeCommand, GetSetCommand, HDelCommand, HExistsCommand, HGetAllCommand, HGetCommand, HIncrByCommand, HIncrByFloatCommand, HKeysCommand, HLenCommand, HMGetCommand, HMSetCommand, HScanCommand, HSetCommand, HSetNXCommand, HStrLenCommand, HValsCommand, IncrByCommand, IncrByFloatCommand, IncrCommand, KeysCommand, LIndexCommand, LInsertCommand, LLenCommand, LPopCommand, LPosCommand, LPushCommand, LPushXCommand, LRangeCommand, LRemCommand, LSetCommand, LTrimCommand, MGetCommand, MSetCommand, MSetNXCommand, PersistCommand, PExpireAtCommand, PExpireCommand, PingCommand, PSetEXCommand, PTtlCommand, PublishCommand, RandomKeyCommand, RenameCommand, RenameNXCommand, RPopCommand, RPushCommand, RPushXCommand, SAddCommand, ScanCommand, SCardCommand, ScriptExistsCommand, ScriptFlushCommand, ScriptLoadCommand, SDiffCommand, SDiffStoreCommand, SetBitCommand, SetCommand, SetExCommand, SetNxCommand, SetRangeCommand, SInterCommand, SInterStoreCommand, SIsMemberCommand, SMembersCommand, SMoveCommand, SPopCommand, SRandMemberCommand, SRemCommand, SScanCommand, StrLenCommand, SUnionCommand, SUnionStoreCommand, TimeCommand, TouchCommand, TtlCommand, TypeCommand, UnlinkCommand, ZAddCommand, ZCardCommand, ZCountCommand, ZIncrByCommand, ZInterStoreCommand, ZLexCountCommand, ZPopMaxCommand, ZPopMinCommand, ZRangeCommand, ZRankCommand, ZRemCommand, ZRemRangeByLexCommand, ZRemRangeByRankCommand, ZRemRangeByScoreCommand, ZRevRankCommand, ZScanCommand, ZScoreCommand, ZUnionStoreCommand, } from "./commands/mod.js";
 import { Pipeline } from "./pipeline.js";
+import { Script } from "./script.js";
+import { ZMScoreCommand } from "./commands/zmscore.js";
 /**
  * Serverless redis client for upstash.
  */
@@ -49,7 +51,30 @@ export class Redis {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: () => new Pipeline(this.client, this.opts)
+            value: () => new Pipeline({
+                client: this.client,
+                commandOptions: this.opts,
+                multiExec: false,
+            })
+        });
+        /**
+         * Create a new transaction to allow executing multiple steps atomically.
+         *
+         * All the commands in a transaction are serialized and executed sequentially. A request sent by
+         * another client will never be served in the middle of the execution of a Redis Transaction. This
+         * guarantees that the commands are executed as a single isolated operation.
+         *
+         * @see {@link Pipeline}
+         */
+        Object.defineProperty(this, "multi", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => new Pipeline({
+                client: this.client,
+                commandOptions: this.opts,
+                multiExec: true,
+            })
         });
         /**
          * @see https://redis.io/commands/append
@@ -974,6 +999,15 @@ export class Redis {
             writable: true,
             value: (...args) => new ZLexCountCommand(args, this.opts).exec(this.client)
         });
+        /**
+         * @see https://redis.io/commands/zmscore
+         */
+        Object.defineProperty(this, "zmscore", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (...args) => new ZMScoreCommand(args, this.opts).exec(this.client)
+        });
         /**
          * @see https://redis.io/commands/zpopmax
          */
@@ -1085,4 +1119,7 @@ export class Redis {
         this.client = client;
         this.opts = opts;
     }
+    createScript(script) {
+        return new Script(this, script);
+    }
 }