@upstash/redis 0.1.11 → 0.2.1

package/dist/module/client.js

@@ -1,536 +1,434 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import fetch from 'isomorphic-unfetch';
 /**
- * Upstash client
- * @param {string} url - database rest url
- * @param {string} token - database rest token
+ * Parse Options
  */
-export default function client(url, token) {
-    var _a, _b, _c;
-    let baseURL = (_b = (_a = url !== null && url !== void 0 ? url : process.env.UPSTASH_REDIS_EDGE_URL) !== null && _a !== void 0 ? _a : process.env.UPSTASH_REDIS_REST_URL) !== null && _b !== void 0 ? _b : '';
-    let authToken = (_c = token !== null && token !== void 0 ? token : process.env.UPSTASH_REDIS_REST_TOKEN) !== null && _c !== void 0 ? _c : '';
-    function auth(url, token) {
-        baseURL = url;
-        authToken = token;
+function parseOptions(url, token, requestOptions = {}) {
+    if (typeof url === 'object' && url !== null) {
+        return parseOptions(url.url, url.token, url.requestOptions);
     }
-    /**
-     * Request
-     * @param {function} callback - callback
-     * @param {Object} parts - command, key, values, ...
-     */
-    function request(callback, ...parts) {
-        const promise = new Promise((resolve, reject) => {
-            return fetch(baseURL, {
-                method: 'POST',
-                body: JSON.stringify(parts),
-                headers: {
-                    Authorization: `Bearer ${authToken}`,
-                },
-            })
-                .then((res) => res.json().then())
-                .then((data) => {
+    // try auto fill from env variables
+    if (!url && typeof window === 'undefined') {
+        url = process.env.UPSTASH_REDIS_REST_URL;
+        token = process.env.UPSTASH_REDIS_REST_TOKEN;
+    }
+    return { url: url, token, requestOptions };
+}
+/**
+ * Fetch
+ */
+function fetchData(options, ...parts) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!options.url) {
+            throw 'Database url not found?';
+        }
+        try {
+            const res = yield fetch(options.url, Object.assign({ method: 'POST', body: JSON.stringify(parts), headers: Object.assign({ Authorization: `Bearer ${options.token}` }, (_a = options.requestOptions) === null || _a === void 0 ? void 0 : _a.headers) }, options.requestOptions));
+            const data = yield res.json();
+            if (!res.ok) {
                 if (data.error)
                     throw data.error;
-                resolve({
-                    data: data.result,
-                    error: null,
-                });
-            })
-                .catch((error) => {
-                resolve({
-                    data: null,
-                    error: typeof error === 'object' ? error.message : error,
-                });
-            });
-        });
-        if (callback) {
-            return promise.then(callback);
+                throw `Upstash failed with (${res.status}): ${JSON.stringify(data, null, 2)}`;
+            }
+            return {
+                data: data.result,
+                error: null,
+            };
         }
-        return promise;
+        catch (err) {
+            return {
+                data: null,
+                // @ts-ignore
+                error: err,
+            };
+        }
+    });
+}
+function upstash(url, token) {
+    const options = parseOptions(url, token);
+    /**
+     * Auth
+     */
+    function auth() {
+        Object.assign(options, {
+            url: undefined,
+            token: undefined,
+        }, parseOptions(arguments[0], arguments[1]));
     }
-    /*
-    ------------------------------------------------
-    STRING
-    ------------------------------------------------
+    /**
+     * STRING
      */
-    function append(key, value, callback) {
-        return request(callback, 'append', key, value);
+    function append() {
+        return fetchData(options, 'append', ...arguments);
     }
-    function decr(key, callback) {
-        return request(callback, 'decr', key);
+    function decr() {
+        return fetchData(options, 'decr', ...arguments);
     }
-    function decrby(key, decrement, callback) {
-        return request(callback, 'decrby', key, decrement);
+    function decrby() {
+        return fetchData(options, 'decrby', ...arguments);
     }
-    function get(key, callback) {
-        return request(callback, 'get', key);
+    function get() {
+        return fetchData(options, 'get', ...arguments);
     }
-    function getrange(key, start, end, callback) {
-        return request(callback, 'getrange', key, start, end);
+    function getrange() {
+        return fetchData(options, 'getrange', ...arguments);
     }
-    function getset(key, value, callback) {
-        return request(callback, 'getset', key, value);
+    function getset() {
+        return fetchData(options, 'getset', ...arguments);
     }
-    function incr(key, callback) {
-        return request(callback, 'incr', key);
+    function incr() {
+        return fetchData(options, 'incr', ...arguments);
     }
-    function incrby(key, value, callback) {
-        return request(callback, 'incrby', key, value);
+    function incrby() {
+        return fetchData(options, 'incrby', ...arguments);
     }
-    function incrbyfloat(key, value, callback) {
-        return request(callback, 'incrbyfloat', key, value);
+    function incrbyfloat() {
+        return fetchData(options, 'incrbyfloat', ...arguments);
     }
-    function mget(values, callback) {
-        return request(callback, 'mget', ...values);
+    function mget() {
+        return fetchData(options, 'mget', ...arguments);
     }
-    function mset(values, callback) {
-        return request(callback, 'mset', ...values);
+    function mset() {
+        return fetchData(options, 'mset', ...arguments);
     }
-    function msetnx(values, callback) {
-        return request(callback, 'msetnx', ...values);
+    function msetnx() {
+        return fetchData(options, 'msetnx', ...arguments);
     }
-    function psetex(key, miliseconds, value, callback) {
-        return request(callback, 'psetex', key, miliseconds, value);
+    function psetex() {
+        return fetchData(options, 'psetex', ...arguments);
     }
-    function set(key, value, callback) {
-        return request(callback, 'set', key, value);
+    function set() {
+        return fetchData(options, 'set', ...arguments);
     }
-    function setex(key, seconds, value, callback) {
-        return request(callback, 'setex', key, seconds, value);
+    function setex() {
+        return fetchData(options, 'setex', ...arguments);
     }
-    function setnx(key, value, callback) {
-        return request(callback, 'setnx', key, value);
+    function setnx() {
+        return fetchData(options, 'setnx', ...arguments);
     }
-    function setrange(key, offset, value, callback) {
-        return request(callback, 'setrange', key, offset, value);
+    function setrange() {
+        return fetchData(options, 'setrange', ...arguments);
     }
-    function strlen(key, callback) {
-        return request(callback, 'strlen', key);
+    function strlen() {
+        return fetchData(options, 'strlen', ...arguments);
     }
-    /*
-    ------------------------------------------------
-    BITMAPS
-    ------------------------------------------------
+    /**
+     * BITMAPS
      */
-    function bitcount(key, start, end, callback) {
-        if (start !== undefined && end !== undefined) {
-            return request(callback, 'bitcount', key, start, end);
-        }
-        return request(callback, 'bitcount', key);
+    function bitcount() {
+        return fetchData(options, 'bitcount', ...arguments);
     }
-    function bitop(operation, destinationKey, sourceKeys, callback) {
-        return request(callback, 'bitop', operation, destinationKey, ...sourceKeys);
+    function bitop() {
+        return fetchData(options, 'bitop', ...arguments);
     }
-    function bitpos(key, bit, start, end, callback) {
-        if (start !== undefined && end !== undefined) {
-            return request(callback, 'bitpos', key, bit, start, end);
-        }
-        else if (start !== undefined) {
-            return request(callback, 'bitpos', key, bit, start);
-        }
-        return request(callback, 'bitpos', key, bit);
+    function bitpos() {
+        return fetchData(options, 'bitpos', ...arguments);
     }
-    function getbit(key, offset, callback) {
-        return request(callback, 'getbit', key, offset);
+    function getbit() {
+        return fetchData(options, 'getbit', ...arguments);
     }
-    function setbit(key, offset, value, callback) {
-        return request(callback, 'setbit', key, offset, value);
+    function setbit() {
+        return fetchData(options, 'setbit', ...arguments);
     }
-    /*
-    ------------------------------------------------
-    CONNECTION
-    ------------------------------------------------
+    /**
+     * CONNECTION
      */
-    function echo(value, callback) {
-        return request(callback, 'echo', value);
+    function echo() {
+        return fetchData(options, 'echo', ...arguments);
     }
-    function ping(value, callback) {
-        if (value) {
-            return request(callback, 'ping', value);
-        }
-        return request(callback, 'ping');
+    function ping() {
+        return fetchData(options, 'ping', ...arguments);
     }
-    /*
-    ------------------------------------------------
-    HASHES
-    ------------------------------------------------
+    /**
+     * HASHES
      */
-    function hdel(key, fields, callback) {
-        return request(callback, 'hdel', key, ...fields);
+    function hdel() {
+        return fetchData(options, 'hdel', ...arguments);
     }
-    function hexists(key, field, callback) {
-        return request(callback, 'hexists', key, field);
+    function hexists() {
+        return fetchData(options, 'hexists', ...arguments);
     }
-    function hget(key, field, callback) {
-        return request(callback, 'hget', key, field);
+    function hget() {
+        return fetchData(options, 'hget', ...arguments);
     }
-    function hgetall(key, callback) {
-        return request(callback, 'hgetall', key);
+    function hgetall() {
+        return fetchData(options, 'hgetall', ...arguments);
     }
-    function hincrby(key, field, increment, callback) {
-        return request(callback, 'hincrby', key, field, increment);
+    function hincrby() {
+        return fetchData(options, 'hincrby', ...arguments);
     }
-    function hincrbyfloat(key, field, increment, callback) {
-        return request(callback, 'hincrbyfloat', key, field, increment);
+    function hincrbyfloat() {
+        return fetchData(options, 'hincrbyfloat', ...arguments);
     }
-    function hkeys(key, callback) {
-        return request(callback, 'hkeys', key);
+    function hkeys() {
+        return fetchData(options, 'hkeys', ...arguments);
     }
-    function hlen(key, callback) {
-        return request(callback, 'hlen', key);
+    function hlen() {
+        return fetchData(options, 'hlen', ...arguments);
     }
-    function hmget(key, fields, callback) {
-        return request(callback, 'hmget', key, ...fields);
+    function hmget() {
+        return fetchData(options, 'hmget', ...arguments);
     }
-    function hmset(key, values, callback) {
-        return request(callback, 'hmset', key, ...values);
+    function hmset() {
+        return fetchData(options, 'hmset', ...arguments);
     }
-    function hscan(key, cursor, options, callback) {
-        if ((options === null || options === void 0 ? void 0 : options.match) && (options === null || options === void 0 ? void 0 : options.count)) {
-            return request(callback, 'hscan', key, cursor, 'match', options.match, 'count', options.count);
-        }
-        else if (options === null || options === void 0 ? void 0 : options.match) {
-            return request(callback, 'hscan', key, cursor, 'match', options.match);
-        }
-        else if (options === null || options === void 0 ? void 0 : options.count) {
-            return request(callback, 'hscan', key, cursor, 'count', options.count);
-        }
-        return request(callback, 'hscan', key, cursor);
+    function hscan() {
+        return fetchData(options, 'hscan', ...arguments);
     }
-    function hset(key, values, callback) {
-        return request(callback, 'hset', key, ...values);
+    function hset() {
+        return fetchData(options, 'hset', ...arguments);
     }
-    function hsetnx(key, field, value, callback) {
-        return request(callback, 'hsetnx', key, field, value);
+    function hsetnx() {
+        return fetchData(options, 'hsetnx', ...arguments);
     }
-    function hvals(key, callback) {
-        return request(callback, 'hvals', key);
+    function hvals() {
+        return fetchData(options, 'hvals', ...arguments);
     }
-    /*
-    ------------------------------------------------
-    KEYS
-    ------------------------------------------------
+    /**
+     * KEYS
      */
-    function del(keys, callback) {
-        return request(callback, 'del', ...keys);
+    function del() {
+        return fetchData(options, 'del', ...arguments);
     }
-    function exists(keys, callback) {
-        return request(callback, 'exists', ...keys);
+    function exists() {
+        return fetchData(options, 'exists', ...arguments);
     }
-    function expire(key, seconds, callback) {
-        return request(callback, 'expire', key, seconds);
+    function expire() {
+        return fetchData(options, 'expire', ...arguments);
     }
-    function expireat(key, timestamp, callback) {
-        return request(callback, 'expireat', key, timestamp);
+    function expireat() {
+        return fetchData(options, 'expireat', ...arguments);
     }
-    function keys(pattern, callback) {
-        return request(callback, 'keys', pattern);
+    function keys() {
+        return fetchData(options, 'keys', ...arguments);
     }
-    function persist(key, callback) {
-        return request(callback, 'persist', key);
+    function persist() {
+        return fetchData(options, 'persist', ...arguments);
     }
-    function pexpire(key, miliseconds, callback) {
-        return request(callback, 'pexpire', key, miliseconds);
+    function pexpire() {
+        return fetchData(options, 'pexpire', ...arguments);
     }
-    function pexpireat(key, miliseconds, callback) {
-        return request(callback, 'pexpireat', key, miliseconds);
+    function pexpireat() {
+        return fetchData(options, 'pexpireat', ...arguments);
     }
-    function pttl(key, callback) {
-        return request(callback, 'pttl', key);
+    function pttl() {
+        return fetchData(options, 'pttl', ...arguments);
     }
-    function randomkey(callback) {
-        return request(callback, 'randomkey');
+    function randomkey() {
+        return fetchData(options, 'randomkey', ...arguments);
     }
-    function rename(key, newkey, callback) {
-        return request(callback, 'rename', key, newkey);
+    function rename() {
+        return fetchData(options, 'rename', ...arguments);
     }
-    function renamenx(key, newkey, callback) {
-        return request(callback, 'renamenx', key, newkey);
+    function renamenx() {
+        return fetchData(options, 'renamenx', ...arguments);
     }
-    function scan(cursor, opitons, callback) {
-        if ((opitons === null || opitons === void 0 ? void 0 : opitons.match) && (opitons === null || opitons === void 0 ? void 0 : opitons.count)) {
-            return request(callback, 'scan', cursor, 'match', opitons.match, 'count', opitons.count);
-        }
-        else if (opitons === null || opitons === void 0 ? void 0 : opitons.match) {
-            return request(callback, 'scan', cursor, 'match', opitons.match);
-        }
-        else if (opitons === null || opitons === void 0 ? void 0 : opitons.count) {
-            return request(callback, 'scan', cursor, 'count', opitons.count);
-        }
-        return request(callback, 'scan', cursor);
+    function scan() {
+        return fetchData(options, 'scan', ...arguments);
     }
-    function touch(keys, callback) {
-        return request(callback, 'touch', ...keys);
+    function touch() {
+        return fetchData(options, 'touch', ...arguments);
     }
-    function ttl(key, callback) {
-        return request(callback, 'ttl', key);
+    function ttl() {
+        return fetchData(options, 'ttl', ...arguments);
     }
-    function type(key, callback) {
-        return request(callback, 'type', key);
+    function type() {
+        return fetchData(options, 'type', ...arguments);
     }
-    function unlink(keys, callback) {
-        return request(callback, 'unlink', ...keys);
+    function unlink() {
+        return fetchData(options, 'unlink', ...arguments);
     }
-    /*
-    ------------------------------------------------
-    LISTS
-    ------------------------------------------------
+    /**
+     * LISTS
      */
-    function lindex(key, index, callback) {
-        return request(callback, 'lindex', key, index);
+    function lindex() {
+        return fetchData(options, 'lindex', ...arguments);
     }
-    function linsert(key, option, pivot, element, callback) {
-        return request(callback, 'linsert', key, option, pivot, element);
+    function linsert() {
+        return fetchData(options, 'linsert', ...arguments);
     }
-    function llen(key, callback) {
-        return request(callback, 'llen', key);
+    function llen() {
+        return fetchData(options, 'llen', ...arguments);
     }
-    function lpop(key, callback) {
-        return request(callback, 'lpop', key);
+    function lpop() {
+        return fetchData(options, 'lpop', ...arguments);
     }
-    function lpush(key, elements, callback) {
-        return request(callback, 'lpush', key, ...elements);
+    function lpush() {
+        return fetchData(options, 'lpush', ...arguments);
     }
-    function lpushx(key, elements, callback) {
-        return request(callback, 'lpushx', key, ...elements);
+    function lpushx() {
+        return fetchData(options, 'lpushx', ...arguments);
     }
-    function lrange(key, start, stop, callback) {
-        return request(callback, 'lrange', key, start, stop);
+    function lrange() {
+        return fetchData(options, 'lrange', ...arguments);
     }
-    function lrem(key, count, element, callback) {
-        return request(callback, 'lrem', key, count, element);
+    function lrem() {
+        return fetchData(options, 'lrem', ...arguments);
     }
-    function lset(key, index, element, callback) {
-        return request(callback, 'lset', key, index, element);
+    function lset() {
+        return fetchData(options, 'lset', ...arguments);
     }
-    function ltrim(key, start, stop, callback) {
-        return request(callback, 'ltrim', key, start, stop);
+    function ltrim() {
+        return fetchData(options, 'ltrim', ...arguments);
     }
-    function rpop(key, callback) {
-        return request(callback, 'rpop', key);
+    function rpop() {
+        return fetchData(options, 'rpop', ...arguments);
     }
-    function rpoplpush(source, destination, callback) {
-        return request(callback, 'rpoplpush', source, destination);
+    function rpoplpush() {
+        return fetchData(options, 'rpoplpush', ...arguments);
     }
-    function rpush(key, elements, callback) {
-        return request(callback, 'rpush', key, ...elements);
+    function rpush() {
+        return fetchData(options, 'rpush', ...arguments);
     }
-    function rpushx(key, elements, callback) {
-        return request(callback, 'rpushx', key, ...elements);
+    function rpushx() {
+        return fetchData(options, 'rpushx', ...arguments);
     }
-    /*
-    ------------------------------------------------
-    SERVER
-    ------------------------------------------------
+    /**
+     * SERVER
      */
-    function dbsize(callback) {
-        return request(callback, 'dbsize');
+    function dbsize() {
+        return fetchData(options, 'dbsize', ...arguments);
     }
-    function flushall(mode, callback) {
-        if (mode) {
-            return request(callback, 'flushall', mode);
-        }
-        return request(callback, 'flushall');
+    function flushall() {
+        return fetchData(options, 'flushall', ...arguments);
     }
-    function flushdb(mode, callback) {
-        if (mode) {
-            return request(callback, 'flushdb', mode);
-        }
-        return request(callback, 'flushdb');
+    function flushdb() {
+        return fetchData(options, 'flushdb', ...arguments);
     }
-    function info(callback) {
-        return request(callback, 'info');
+    function info() {
+        return fetchData(options, 'info', ...arguments);
     }
-    function time(callback) {
-        return request(callback, 'time');
+    function time() {
+        return fetchData(options, 'time', ...arguments);
     }
-    /*
-    ------------------------------------------------
-    SET
-    ------------------------------------------------
+    /**
+     * SET
      */
-    function sadd(key, members, callback) {
-        return request(callback, 'sadd', key, ...members);
+    function sadd() {
+        return fetchData(options, 'sadd', ...arguments);
     }
-    function scard(key, callback) {
-        return request(callback, 'scard', key);
+    function scard() {
+        return fetchData(options, 'scard', ...arguments);
     }
-    function sdiff(keys, callback) {
-        return request(callback, 'sdiff', ...keys);
+    function sdiff() {
+        return fetchData(options, 'sdiff', ...arguments);
     }
-    function sdiffstore(destination, keys, callback) {
-        return request(callback, 'sdiffstore', destination, ...keys);
+    function sdiffstore() {
+        return fetchData(options, 'sdiffstore', ...arguments);
     }
-    function sinter(keys, callback) {
-        return request(callback, 'sinter', ...keys);
+    function sinter() {
+        return fetchData(options, 'sinter', ...arguments);
     }
-    function sinterstore(destination, keys, callback) {
-        return request(callback, 'sinterstore', destination, ...keys);
+    function sinterstore() {
+        return fetchData(options, 'sinterstore', ...arguments);
     }
-    function sismember(key, member, callback) {
-        return request(callback, 'sismember', key, member);
+    function sismember() {
+        return fetchData(options, 'sismember', ...arguments);
     }
-    function smembers(key, callback) {
-        return request(callback, 'smembers', key);
+    function smembers() {
+        return fetchData(options, 'smembers', ...arguments);
     }
-    function smove(source, destination, member, callback) {
-        return request(callback, 'smove', source, destination, member);
+    function smove() {
+        return fetchData(options, 'smove', ...arguments);
     }
-    function spop(key, count, callback) {
-        if (count) {
-            return request(callback, 'spop', key, count);
-        }
-        return request(callback, 'spop', key);
+    function spop() {
+        return fetchData(options, 'spop', ...arguments);
     }
-    function srandmember(key, count, callback) {
-        if (count) {
-            return request(callback, 'srandmember', key, count);
-        }
-        return request(callback, 'srandmember', key);
+    function srandmember() {
+        return fetchData(options, 'srandmember', ...arguments);
+    }
+    function srem() {
+        return fetchData(options, 'srem', ...arguments);
     }
-    function srem(key, members, callback) {
-        return request(callback, 'srem', key, ...members);
+    function sscan() {
+        return fetchData(options, 'sscan', ...arguments);
     }
-    function sunion(keys, callback) {
-        return request(callback, 'sunion', ...keys);
+    function sunion() {
+        return fetchData(options, 'sunion', ...arguments);
     }
-    function sunionstore(destination, keys, callback) {
-        return request(callback, 'sunionstore', destination, ...keys);
+    function sunionstore() {
+        return fetchData(options, 'sunionstore', ...arguments);
     }
-    /*
-    ------------------------------------------------
-    SORTED SETS
-    ------------------------------------------------
+    /**
+     * SORTED SETS
      */
-    function zadd(key, values, options, callback) {
-        if (options) {
-            const allOptions = Object.entries(options)
-                .filter((e) => ['string', 'number', 'boolean'].includes(typeof e[1]))
-                .map((e) => e[0].toUpperCase());
-            return request(callback, 'zadd', key, ...allOptions, ...values);
-        }
-        return request(callback, 'zadd', key, ...values);
+    function zadd() {
+        return fetchData(options, 'zadd', ...arguments);
     }
-    function zcard(key, callback) {
-        return request(callback, 'zcard', key);
+    function zcard() {
+        return fetchData(options, 'zcard', ...arguments);
     }
-    function zcount(key, min, max, callback) {
-        return request(callback, 'zcount', key, min, max);
+    function zcount() {
+        return fetchData(options, 'zcount', ...arguments);
     }
-    function zincrby(key, increment, member, callback) {
-        return request(callback, 'zincrby', key, increment, member);
+    function zincrby() {
+        return fetchData(options, 'zincrby', ...arguments);
     }
-    function zinterstore(destination, keys, options, callback) {
-        if (options) {
-            if (options.weights && options.aggregate) {
-                return request(callback, 'zinterstore', destination, keys.length, ...keys, 'weights', ...options.weights, 'aggregate', options.aggregate);
-            }
-            else if (options.weights) {
-                return request(callback, 'zinterstore', destination, keys.length, ...keys, 'weights', ...options.weights);
-            }
-            else if (options.aggregate) {
-                return request(callback, 'zinterstore', destination, keys.length, ...keys, 'aggregate', options.aggregate);
-            }
-        }
-        return request(callback, 'zinterstore', destination, keys.length, ...keys);
+    function zinterstore() {
+        return fetchData(options, 'zinterstore', ...arguments);
     }
-    function zlexcount(key, min, max, callback) {
-        return request(callback, 'zlexcount', key, min, max);
+    function zlexcount() {
+        return fetchData(options, 'zlexcount', ...arguments);
     }
-    function zpopmax(key, count, callback) {
-        if (count) {
-            return request(callback, 'zpopmax', key, count);
-        }
-        return request(callback, 'zpopmax', key);
+    function zpopmax() {
+        return fetchData(options, 'zpopmax', ...arguments);
     }
-    function zpopmin(key, count, callback) {
-        if (count) {
-            return request(callback, 'zpopmin', key, count);
-        }
-        return request(callback, 'zpopmin', key);
+    function zpopmin() {
+        return fetchData(options, 'zpopmin', ...arguments);
     }
-    function zrange(key, min, max, options, callback) {
-        if (options === null || options === void 0 ? void 0 : options.withScores) {
-            return request(callback, 'zrange', key, min, max, 'WITHSCORES');
-        }
-        return request(callback, 'zrange', key, min, max);
+    function zrange() {
+        return fetchData(options, 'zrange', ...arguments);
     }
-    function zrangebylex(key, min, max, offset, count, callback) {
-        if (offset && count) {
-            return request(callback, 'zrangebylex', key, min, max, 'LIMIT', offset, count);
-        }
-        return request(callback, 'zrangebylex', key, min, max);
+    function zrangebylex() {
+        return fetchData(options, 'zrangebylex', ...arguments);
     }
-    function zrangebyscore(key, min, max, options, callback) {
-        if ((options === null || options === void 0 ? void 0 : options.withScores) && (options === null || options === void 0 ? void 0 : options.limit)) {
-            return request(callback, 'zrangebyscore', key, min, max, 'WITHSCORES', 'LIMIT', options.limit.offset, options.limit.count);
-        }
-        else if (options === null || options === void 0 ? void 0 : options.withScores) {
-            return request(callback, 'zrangebyscore', key, min, max, 'WITHSCORES');
-        }
-        else if (options === null || options === void 0 ? void 0 : options.limit) {
-            return request(callback, 'zrangebyscore', key, min, max, 'LIMIT', options.limit.offset, options.limit.count);
-        }
-        return request(callback, 'zrangebyscore', key, min, max);
+    function zrangebyscore() {
+        return fetchData(options, 'zrangebyscore', ...arguments);
     }
-    function zrank(key, member, callback) {
-        return request(callback, 'zrank', key, member);
+    function zrank() {
+        return fetchData(options, 'zrank', ...arguments);
     }
-    function zrem(key, members, callback) {
-        return request(callback, 'zrem', key, ...members);
+    function zrem() {
+        return fetchData(options, 'zrem', ...arguments);
     }
-    function zremrangebylex(key, min, max, callback) {
-        return request(callback, 'zremrangebylex', key, min, max);
+    function zremrangebylex() {
+        return fetchData(options, 'zremrangebylex', ...arguments);
     }
-    function zremrangebyrank(key, start, stop, callback) {
-        return request(callback, 'zremrangebyrank', key, start, stop);
+    function zremrangebyrank() {
+        return fetchData(options, 'zremrangebyrank', ...arguments);
     }
-    function zremrangebyscore(key, min, max, callback) {
-        return request(callback, 'zremrangebyscore', key, min, max);
+    function zremrangebyscore() {
+        return fetchData(options, 'zremrangebyscore', ...arguments);
     }
-    function zrevrange(key, start, stop, options, callback) {
-        if (options === null || options === void 0 ? void 0 : options.withScores) {
-            return request(callback, 'zrevrange', key, start, stop, 'WITHSCORES');
-        }
-        return request(callback, 'zrevrange', key, start, stop);
+    function zrevrange() {
+        return fetchData(options, 'zrevrange', ...arguments);
     }
-    function zrevrangebylex(key, max, min, offset, count, callback) {
-        if (offset && count) {
-            return request(callback, 'zrevrangebylex', key, max, min, 'LIMIT', offset, count);
-        }
-        return request(callback, 'zrevrangebylex', key, max, min);
-    }
-    function zrevrangebyscore(key, min, max, callback) {
-        return request(callback, 'zrevrangebyscore', key, min, max);
-    }
-    // TODO
-    // function zrevrank(
-    //   key: string,
-    //   start: number,
-    //   stop: number,
-    //   options?: { withScores: boolean },
-    //   callback?: Callback
-    // ): MethodReturn {
-    //   if (options?.withScores) {
-    //     return request(callback, 'zrevrank', key, start, stop, 'WITHSCORES');
-    //   }
-    //   return request(callback, 'zrevrank', key, start, stop);
-    // }
-    function zscore(key, member, callback) {
-        return request(callback, 'zscore', key, member);
-    }
-    function zunionstore(destination, keys, options, callback) {
-        if (options) {
-            if (options.weights && options.aggregate) {
-                return request(callback, 'zunionstore', destination, keys.length, ...keys, 'weights', ...options.weights, 'aggregate', options.aggregate);
-            }
-            else if (options.weights) {
-                return request(callback, 'zunionstore', destination, keys.length, ...keys, 'weights', ...options.weights);
-            }
-            else if (options.aggregate) {
-                return request(callback, 'zunionstore', destination, keys.length, ...keys, 'aggregate', options.aggregate);
-            }
-        }
-        return request(callback, 'zunionstore', destination, keys.length, ...keys);
+    function zrevrangebylex() {
+        return fetchData(options, 'zrevrangebylex', ...arguments);
+    }
+    function zrevrangebyscore() {
+        return fetchData(options, 'zrevrangebyscore', ...arguments);
+    }
+    function zrevrank() {
+        return fetchData(options, 'zrevrank', ...arguments);
+    }
+    function zscan() {
+        return fetchData(options, 'zscan', ...arguments);
+    }
+    function zscore() {
+        return fetchData(options, 'zscore', ...arguments);
+    }
+    function zunionstore() {
+        return fetchData(options, 'zunionstore', ...arguments);
     }
     return {
         auth,
@@ -562,7 +460,7 @@ export default function client(url, token) {
         // CONNECTION
         echo,
         ping,
-        //HASHES
+        // HASHES
         hdel,
         hexists,
         hget,
@@ -573,10 +471,10 @@ export default function client(url, token) {
         hlen,
         hmget,
         hmset,
+        hscan,
         hset,
         hsetnx,
         hvals,
-        hscan,
         // KEYS
         del,
         exists,
@@ -595,7 +493,7 @@ export default function client(url, token) {
         ttl,
         type,
         unlink,
-        // LIST
+        // LISTS
         lindex,
         linsert,
         llen,
@@ -616,7 +514,7 @@ export default function client(url, token) {
         flushdb,
         info,
         time,
-        //SET
+        // SET
         sadd,
         scard,
         sdiff,
@@ -629,9 +527,10 @@ export default function client(url, token) {
         spop,
         srandmember,
         srem,
+        sscan,
         sunion,
         sunionstore,
-        //sorted
+        // SORTED SETS
         zadd,
         zcard,
         zcount,
@@ -651,9 +550,10 @@ export default function client(url, token) {
         zrevrange,
         zrevrangebylex,
         zrevrangebyscore,
-        // zrevrank,
+        zrevrank,
+        zscan,
         zscore,
         zunionstore,
     };
 }
-//# sourceMappingURL=client.js.map
+export default upstash;