@upstash/redis 0.1.22 → 0.2.0

package/dist/module/src/client.js

@@ -1,743 +0,0 @@
-import fetch from 'isomorphic-unfetch';
-import { isFunction, isObject, isString } from '../utils/helper';
-/**
- * Creates a Upstash Redis instance
- *
- * @constructor
- * @param {string} url - database rest url
- * @param {string} token - database rest token
- * @param {Object} options - database config
- * @param {string} [options.url] - database rest url
- * @param {string} [options.token] - database rest token
- * @param {string} [options.edgeUrl] - database rest edge url
- * @param {string} [options.readFromEdge] - database rest read from edge
- *
- * @example
- * ```js
- * import Upstash from '@upstash/redis'
- *
- * const redis1 = new Upstash('url', token);
- * const redis2 = new Upstash({ url: '', token: '', edgeUrl: '', readFromEdge: false });
- * ```
- */
-export default Upstash;
-function Upstash() {
-    let OPTIONS;
-    // @ts-ignore
-    parseOptions(arguments[0], arguments[1]);
-    /**
-     * Parse Options
-     */
-    function parseOptions() {
-        const arg0 = arguments[0];
-        const arg1 = arguments[1];
-        OPTIONS = { url: '', token: '', edgeUrl: '', readFromEdge: false };
-        // Upstash({})
-        if (isObject(arg0)) {
-            const { url, token, edgeUrl, readFromEdge } = arg0;
-            OPTIONS.url = url;
-            OPTIONS.token = token;
-            OPTIONS.edgeUrl = edgeUrl;
-            OPTIONS.readFromEdge = readFromEdge !== null && readFromEdge !== void 0 ? readFromEdge : !!edgeUrl;
-        }
-        // Upstash(url, token)
-        else if (isString(arg0) && isString(arg1)) {
-            OPTIONS.url = arg0;
-            OPTIONS.token = arg1;
-        }
-        // try auto fill from env variable
-        else if (process) {
-            const { UPSTASH_REDIS_REST_URL, UPSTASH_REDIS_REST_TOKEN, UPSTASH_REDIS_EDGE_URL, } = process.env;
-            OPTIONS.url = UPSTASH_REDIS_REST_URL !== null && UPSTASH_REDIS_REST_URL !== void 0 ? UPSTASH_REDIS_REST_URL : '';
-            OPTIONS.token = UPSTASH_REDIS_REST_TOKEN !== null && UPSTASH_REDIS_REST_TOKEN !== void 0 ? UPSTASH_REDIS_REST_TOKEN : '';
-            OPTIONS.edgeUrl = UPSTASH_REDIS_EDGE_URL !== null && UPSTASH_REDIS_EDGE_URL !== void 0 ? UPSTASH_REDIS_EDGE_URL : '';
-            OPTIONS.readFromEdge = !!UPSTASH_REDIS_EDGE_URL;
-        }
-    }
-    /**
-     * Fetch
-     */
-    function fetchData(url, options) {
-        let cache = null;
-        let edge = false;
-        return new Promise((resolve) => {
-            fetch(url, {
-                ...options,
-                headers: {
-                    Authorization: `Bearer ${OPTIONS.token}`,
-                },
-            })
-                .then((res) => {
-                switch (res.headers.get('x-cache')) {
-                    case 'Hit from cloudfront':
-                        edge = true;
-                        cache = 'hit';
-                        break;
-                    case 'Miss from cloudfront':
-                        edge = true;
-                        cache = 'miss';
-                        break;
-                }
-                return res.json().then();
-            })
-                .then((data) => {
-                if (data.error)
-                    throw data.error;
-                resolve({
-                    data: data.result,
-                    error: null,
-                    metadata: { edge, cache },
-                });
-            })
-                .catch((error) => {
-                resolve({
-                    data: null,
-                    error: typeof error === 'object' ? error.message : error,
-                    metadata: { edge, cache },
-                });
-            });
-        });
-    }
-    /**
-     * Request
-     */
-    function request(configOrCallback, callback, ...parts) {
-        if (!OPTIONS.url) {
-            return new Promise((resolve) => resolve({ data: null, error: 'Database url not found?' }));
-        }
-        if (!OPTIONS.edgeUrl && OPTIONS.readFromEdge) {
-            return new Promise((resolve) => resolve({
-                data: null,
-                error: 'You need to set Edge Url to read from edge.',
-            }));
-        }
-        let promise;
-        let isRequestDefaultEdge = !!OPTIONS.edgeUrl && OPTIONS.readFromEdge;
-        let isRequestCustomEdge = isRequestDefaultEdge;
-        // write command?
-        if (configOrCallback === false) {
-            isRequestCustomEdge = false;
-        }
-        // get command
-        // has config & has edgeUrl
-        else if (isObject(configOrCallback)) {
-            // @ts-ignore
-            if (!OPTIONS.edgeUrl && (configOrCallback === null || configOrCallback === void 0 ? void 0 : configOrCallback.edge)) {
-                return new Promise((resolve) => resolve({
-                    data: null,
-                    error: 'You need to set Edge Url to read from edge.',
-                }));
-            }
-            if (OPTIONS.edgeUrl) {
-                // @ts-ignore
-                isRequestCustomEdge = configOrCallback === null || configOrCallback === void 0 ? void 0 : configOrCallback.edge;
-            }
-        }
-        if (isRequestCustomEdge) {
-            const command = encodeURI(parts.join('/'));
-            const edgeUrlWithPath = `${OPTIONS.edgeUrl}/${command}`;
-            promise = fetchData(edgeUrlWithPath, {
-                method: 'GET',
-            });
-        }
-        else {
-            promise = fetchData(OPTIONS.url, {
-                method: 'POST',
-                body: JSON.stringify(parts),
-            });
-        }
-        if (isFunction(configOrCallback)) {
-            // @ts-ignore
-            return promise.then(configOrCallback);
-        }
-        else if (isFunction(callback)) {
-            return promise.then(callback);
-        }
-        return promise;
-    }
-    function auth() {
-        // @ts-ignore
-        parseOptions(arguments[0], arguments[1]);
-    }
-    /**
-     * STRING
-     */
-    function append(key, value) {
-        return request(false, arguments[2], 'append', key, value);
-    }
-    function decr(key) {
-        return request(false, arguments[1], 'decr', key);
-    }
-    function decrby(key, decrement) {
-        return request(false, arguments[2], 'decrby', key, decrement);
-    }
-    function get(key) {
-        return request(arguments[1], arguments[2], 'get', key);
-    }
-    function getrange(key, start, end) {
-        return request(arguments[3], arguments[4], 'getrange', key, start, end);
-    }
-    function getset(key, value) {
-        return request(false, arguments[2], 'getset', key, value);
-    }
-    function incr(key) {
-        return request(false, arguments[1], 'incr', key);
-    }
-    function incrby(key, value) {
-        return request(false, arguments[2], 'incrby', key, value);
-    }
-    function incrbyfloat(key, value) {
-        return request(false, arguments[2], 'incrbyfloat', key, value);
-    }
-    function mget(values) {
-        return request(arguments[1], arguments[2], 'mget', ...values);
-    }
-    function mset(values) {
-        return request(false, arguments[1], 'mset', ...values);
-    }
-    function msetnx(values) {
-        return request(false, arguments[1], 'msetnx', ...values);
-    }
-    function psetex(key, miliseconds, value) {
-        return request(false, arguments[3], 'psetex', key, miliseconds, value);
-    }
-    function set(key, value) {
-        return request(false, arguments[2], 'set', key, value);
-    }
-    function setex(key, seconds, value) {
-        return request(false, arguments[3], 'setex', key, seconds, value);
-    }
-    function setnx(key, value) {
-        return request(false, arguments[2], 'setnx', key, value);
-    }
-    function setrange(key, offset, value) {
-        return request(false, arguments[3], 'setrange', key, offset, value);
-    }
-    function strlen(key) {
-        return request(arguments[1], arguments[2], 'strlen', key);
-    }
-    /**
-     * BITMAPS
-     */
-    function bitcount(key, start, end) {
-        if (start !== undefined && end !== undefined) {
-            return request(arguments[3], arguments[4], 'bitcount', key, start, end);
-        }
-        return request(arguments[3], arguments[4], 'bitcount', key);
-    }
-    function bitop(operation, destinationKey, sourceKeys) {
-        return request(false, arguments[3], 'bitop', operation, destinationKey, ...sourceKeys);
-    }
-    function bitpos(key, bit, start, end) {
-        if (start !== undefined && end !== undefined) {
-            return request(arguments[4], arguments[5], 'bitpos', key, bit, start, end);
-        }
-        else if (start !== undefined) {
-            return request(arguments[4], arguments[5], 'bitpos', key, bit, start);
-        }
-        return request(arguments[4], arguments[5], 'bitpos', key, bit);
-    }
-    function getbit(key, offset) {
-        return request(arguments[2], arguments[3], 'getbit', key, offset);
-    }
-    function setbit(key, offset, value) {
-        return request(false, arguments[3], 'setbit', key, offset, value);
-    }
-    /**
-     * CONNECTION
-     */
-    function echo(value) {
-        return request(arguments[1], arguments[2], 'echo', value);
-    }
-    function ping(value) {
-        if (value) {
-            return request(arguments[1], arguments[2], 'ping', value);
-        }
-        return request(arguments[1], arguments[2], 'ping');
-    }
-    /**
-     * HASHES
-     */
-    function hdel(key, fields) {
-        return request(false, arguments[2], 'hdel', key, ...fields);
-    }
-    function hexists(key, field) {
-        return request(arguments[2], arguments[3], 'hexists', key, field);
-    }
-    function hget(key, field) {
-        return request(arguments[2], arguments[3], 'hget', key, field);
-    }
-    function hgetall(key) {
-        return request(arguments[1], arguments[2], 'hgetall', key);
-    }
-    function hincrby(key, field, increment) {
-        return request(false, arguments[3], 'hincrby', key, field, increment);
-    }
-    function hincrbyfloat(key, field, increment) {
-        return request(false, arguments[3], 'hincrbyfloat', key, field, increment);
-    }
-    function hkeys(key) {
-        return request(arguments[1], arguments[2], 'hkeys', key);
-    }
-    function hlen(key) {
-        return request(arguments[1], arguments[2], 'hlen', key);
-    }
-    function hmget(key, fields) {
-        return request(arguments[2], arguments[3], 'hmget', key, ...fields);
-    }
-    function hmset(key, values) {
-        return request(false, arguments[2], 'hmset', key, ...values);
-    }
-    function hscan(key, cursor, options) {
-        if ((options === null || options === void 0 ? void 0 : options.match) && (options === null || options === void 0 ? void 0 : options.count)) {
-            return request(false, arguments[3], 'hscan', key, cursor, 'match', options.match, 'count', options.count);
-        }
-        else if (options === null || options === void 0 ? void 0 : options.match) {
-            return request(false, arguments[3], 'hscan', key, cursor, 'match', options.match);
-        }
-        else if (options === null || options === void 0 ? void 0 : options.count) {
-            return request(false, arguments[3], 'hscan', key, cursor, 'count', options.count);
-        }
-        return request(false, arguments[3], 'hscan', key, cursor);
-    }
-    function hset(key, values) {
-        return request(false, arguments[2], 'hset', key, ...values);
-    }
-    function hsetnx(key, field, value) {
-        return request(false, arguments[3], 'hsetnx', key, field, value);
-    }
-    function hvals(key) {
-        return request(arguments[1], arguments[2], 'hvals', key);
-    }
-    /**
-     * KEYS
-     */
-    function del(keys) {
-        return request(false, arguments[1], 'del', ...keys);
-    }
-    function exists(keys) {
-        return request(arguments[1], arguments[2], 'exists', ...keys);
-    }
-    function expire(key, seconds) {
-        return request(false, arguments[2], 'expire', key, seconds);
-    }
-    function expireat(key, timestamp) {
-        return request(false, arguments[2], 'expireat', key, timestamp);
-    }
-    function keys(pattern) {
-        return request(arguments[1], arguments[2], 'keys', pattern);
-    }
-    function persist(key) {
-        return request(false, arguments[1], 'persist', key);
-    }
-    function pexpire(key, miliseconds) {
-        return request(false, arguments[2], 'pexpire', key, miliseconds);
-    }
-    function pexpireat(key, miliseconds) {
-        return request(false, arguments[2], 'pexpireat', key, miliseconds);
-    }
-    function pttl(key) {
-        return request(arguments[1], arguments[2], 'pttl', key);
-    }
-    function randomkey() {
-        return request(false, arguments[0], 'randomkey');
-    }
-    function rename(key, newKey) {
-        return request(false, arguments[2], 'rename', key, newKey);
-    }
-    function renamenx(key, newKey) {
-        return request(false, arguments[2], 'renamenx', key, newKey);
-    }
-    function scan(cursor, opitons) {
-        if ((opitons === null || opitons === void 0 ? void 0 : opitons.match) && (opitons === null || opitons === void 0 ? void 0 : opitons.count)) {
-            return request(false, arguments[2], 'scan', cursor, 'match', opitons.match, 'count', opitons.count);
-        }
-        else if (opitons === null || opitons === void 0 ? void 0 : opitons.match) {
-            return request(false, arguments[2], 'scan', cursor, 'match', opitons.match);
-        }
-        else if (opitons === null || opitons === void 0 ? void 0 : opitons.count) {
-            return request(false, arguments[2], 'scan', cursor, 'count', opitons.count);
-        }
-        return request(false, arguments[2], 'scan', cursor);
-    }
-    function touch(keys) {
-        return request(false, arguments[1], 'touch', ...keys);
-    }
-    function ttl(key) {
-        return request(arguments[1], arguments[2], 'ttl', key);
-    }
-    function type(key) {
-        return request(arguments[1], arguments[2], 'type', key);
-    }
-    function unlink(keys) {
-        return request(false, arguments[1], 'unlink', ...keys);
-    }
-    /**
-     * LISTS
-     */
-    function lindex(key, index) {
-        return request(arguments[2], arguments[3], 'lindex', key, index);
-    }
-    function linsert(key, option, pivot, element) {
-        return request(false, arguments[4], 'linsert', key, option, pivot, element);
-    }
-    function llen(key) {
-        return request(arguments[1], arguments[2], 'llen', key);
-    }
-    function lpop(key) {
-        return request(false, arguments[1], 'lpop', key);
-    }
-    function lpush(key, elements) {
-        return request(false, arguments[2], 'lpush', key, ...elements);
-    }
-    function lpushx(key, elements) {
-        return request(false, arguments[2], 'lpushx', key, ...elements);
-    }
-    function lrange(key, start, stop) {
-        return request(arguments[3], arguments[4], 'lrange', key, start, stop);
-    }
-    function lrem(key, count, element) {
-        return request(false, arguments[3], 'lrem', key, count, element);
-    }
-    function lset(key, index, element) {
-        return request(false, arguments[3], 'lset', key, index, element);
-    }
-    function ltrim(key, start, stop) {
-        return request(false, arguments[3], 'ltrim', key, start, stop);
-    }
-    function rpop(key) {
-        return request(false, arguments[1], 'rpop', key);
-    }
-    function rpoplpush(source, destination) {
-        return request(false, arguments[2], 'rpoplpush', source, destination);
-    }
-    function rpush(key, elements) {
-        return request(false, arguments[2], 'rpush', key, ...elements);
-    }
-    function rpushx(key, elements) {
-        return request(false, arguments[2], 'rpushx', key, ...elements);
-    }
-    /**
-     * SERVER
-     */
-    function dbsize() {
-        return request(arguments[0], arguments[1], 'dbsize');
-    }
-    function flushall(mode) {
-        if (mode) {
-            return request(false, arguments[1], 'flushall', mode);
-        }
-        return request(false, arguments[1], 'flushall');
-    }
-    function flushdb(mode) {
-        if (mode) {
-            return request(false, arguments[1], 'flushdb', mode);
-        }
-        return request(false, arguments[1], 'flushdb');
-    }
-    function info() {
-        return request(arguments[0], arguments[1], 'info');
-    }
-    function time() {
-        return request(false, arguments[0], 'time');
-    }
-    /**
-     * SET
-     */
-    function sadd(key, members) {
-        return request(false, arguments[2], 'sadd', key, ...members);
-    }
-    function scard(key) {
-        return request(false, arguments[1], 'scard', key);
-    }
-    function sdiff(keys) {
-        return request(arguments[1], arguments[2], 'sdiff', ...keys);
-    }
-    function sdiffstore(destination, keys) {
-        return request(false, arguments[2], 'sdiffstore', destination, ...keys);
-    }
-    function sinter(keys) {
-        return request(arguments[1], arguments[2], 'sinter', ...keys);
-    }
-    function sinterstore(destination, keys) {
-        return request(false, arguments[2], 'sinterstore', destination, ...keys);
-    }
-    function sismember(key, member) {
-        return request(arguments[2], arguments[3], 'sismember', key, member);
-    }
-    function smembers(key) {
-        return request(arguments[1], arguments[2], 'smembers', key);
-    }
-    function smove(source, destination, member) {
-        return request(false, arguments[3], 'smove', source, destination, member);
-    }
-    function spop(key, count) {
-        if (count) {
-            return request(false, arguments[2], 'spop', key, count);
-        }
-        return request(false, arguments[2], 'spop', key);
-    }
-    function srandmember(key, count) {
-        if (count) {
-            return request(arguments[2], arguments[3], 'srandmember', key, count);
-        }
-        return request(arguments[2], arguments[3], 'srandmember', key);
-    }
-    function srem(key, members) {
-        return request(false, arguments[2], 'srem', key, ...members);
-    }
-    function sunion(keys) {
-        return request(arguments[1], arguments[2], 'sunion', ...keys);
-    }
-    function sunionstore(destination, keys) {
-        return request(false, arguments[2], 'sunionstore', destination, ...keys);
-    }
-    /**
-     * SORTED SETS
-     */
-    function zadd(key, values, options) {
-        if (options) {
-            const allOptions = Object.entries(options)
-                .filter((e) => ['string', 'number', 'boolean'].includes(typeof e[1]))
-                .map((e) => e[0].toUpperCase());
-            return request(false, arguments[3], 'zadd', key, ...allOptions, ...values);
-        }
-        return request(arguments[3], arguments[4], 'zadd', key, ...values);
-    }
-    function zcard(key) {
-        return request(arguments[1], arguments[2], 'zcard', key);
-    }
-    function zcount(key, min, max) {
-        return request(arguments[3], arguments[4], 'zcount', key, min, max);
-    }
-    function zincrby(key, increment, member) {
-        return request(false, arguments[3], 'zincrby', key, increment, member);
-    }
-    function zinterstore(destination, keys, options) {
-        if (options) {
-            if (options.weights && options.aggregate) {
-                return request(false, arguments[3], 'zinterstore', destination, keys.length, ...keys, 'weights', ...options.weights, 'aggregate', options.aggregate);
-            }
-            else if (options.weights) {
-                return request(false, arguments[3], 'zinterstore', destination, keys.length, ...keys, 'weights', ...options.weights);
-            }
-            else if (options.aggregate) {
-                return request(false, arguments[3], 'zinterstore', destination, keys.length, ...keys, 'aggregate', options.aggregate);
-            }
-        }
-        return request(false, arguments[3], 'zinterstore', destination, keys.length, ...keys);
-    }
-    function zlexcount(key, min, max) {
-        return request(arguments[3], arguments[4], 'zlexcount', key, min, max);
-    }
-    function zpopmax(key, count) {
-        if (count) {
-            return request(false, arguments[2], 'zpopmax', key, count);
-        }
-        return request(false, arguments[2], 'zpopmax', key);
-    }
-    function zpopmin(key, count) {
-        if (count) {
-            return request(false, arguments[2], 'zpopmin', key, count);
-        }
-        return request(false, arguments[2], 'zpopmin', key);
-    }
-    function zrange(key, min, max, options) {
-        if (options === null || options === void 0 ? void 0 : options.withScores) {
-            return request(arguments[4], arguments[5], 'zrange', key, min, max, 'WITHSCORES');
-        }
-        return request(arguments[4], arguments[5], 'zrange', key, min, max);
-    }
-    function zrangebylex(key, min, max, offset, count) {
-        if (offset && count) {
-            return request(arguments[5], arguments[6], 'zrangebylex', key, min, max, 'LIMIT', offset, count);
-        }
-        return request(arguments[5], arguments[6], 'zrangebylex', key, min, max);
-    }
-    function zrangebyscore(key, min, max, options) {
-        if ((options === null || options === void 0 ? void 0 : options.withScores) && (options === null || options === void 0 ? void 0 : options.limit)) {
-            return request(arguments[4], arguments[5], '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(arguments[4], arguments[5], 'zrangebyscore', key, min, max, 'WITHSCORES');
-        }
-        else if (options === null || options === void 0 ? void 0 : options.limit) {
-            return request(arguments[4], arguments[5], 'zrangebyscore', key, min, max, 'LIMIT', options.limit.offset, options.limit.count);
-        }
-        return request(arguments[4], arguments[5], 'zrangebyscore', key, min, max);
-    }
-    function zrank(key, member) {
-        return request(arguments[2], arguments[3], 'zrank', key, member);
-    }
-    function zrem(key, members) {
-        return request(false, arguments[2], 'zrem', key, ...members);
-    }
-    function zremrangebylex(key, min, max) {
-        return request(false, arguments[3], 'zremrangebylex', key, min, max);
-    }
-    function zremrangebyrank(key, start, stop) {
-        return request(false, arguments[3], 'zremrangebyrank', key, start, stop);
-    }
-    function zremrangebyscore(key, min, max) {
-        return request(false, arguments[3], 'zremrangebyscore', key, min, max);
-    }
-    function zrevrange(key, start, stop, options) {
-        if (options === null || options === void 0 ? void 0 : options.withScores) {
-            return request(arguments[4], arguments[5], 'zrevrange', key, start, stop, 'WITHSCORES');
-        }
-        return request(arguments[4], arguments[5], 'zrevrange', key, start, stop);
-    }
-    function zrevrangebylex(key, max, min, offset, count) {
-        if (offset && count) {
-            return request(arguments[5], arguments[6], 'zrevrangebylex', key, max, min, 'LIMIT', offset, count);
-        }
-        return request(arguments[5], arguments[6], 'zrevrangebylex', key, max, min);
-    }
-    function zrevrangebyscore(key, min, max) {
-        return request(arguments[3], arguments[4], 'zrevrangebyscore', key, min, max);
-    }
-    function zrevrank(key, member) {
-        return request(arguments[2], arguments[3], 'zrevrank', key, member);
-    }
-    function zscore(key, member) {
-        return request(arguments[2], arguments[3], 'zscore', key, member);
-    }
-    function zunionstore(destination, keys, options) {
-        if (options) {
-            if (options.weights && options.aggregate) {
-                return request(false, arguments[3], 'zunionstore', destination, keys.length, ...keys, 'weights', ...options.weights, 'aggregate', options.aggregate);
-            }
-            else if (options.weights) {
-                return request(false, arguments[3], 'zunionstore', destination, keys.length, ...keys, 'weights', ...options.weights);
-            }
-            else if (options.aggregate) {
-                return request(false, arguments[3], 'zunionstore', destination, keys.length, ...keys, 'aggregate', options.aggregate);
-            }
-        }
-        return request(false, arguments[3], 'zunionstore', destination, keys.length, ...keys);
-    }
-    return {
-        auth,
-        // STRING
-        append,
-        decr,
-        decrby,
-        get,
-        getrange,
-        getset,
-        incr,
-        incrby,
-        incrbyfloat,
-        mget,
-        mset,
-        msetnx,
-        psetex,
-        set,
-        setex,
-        setnx,
-        setrange,
-        strlen,
-        // BITMAPS
-        bitcount,
-        bitop,
-        bitpos,
-        getbit,
-        setbit,
-        // CONNECTION
-        echo,
-        ping,
-        // HASHES
-        hdel,
-        hexists,
-        hget,
-        hgetall,
-        hincrby,
-        hincrbyfloat,
-        hkeys,
-        hlen,
-        hmget,
-        hmset,
-        hscan,
-        hset,
-        hsetnx,
-        hvals,
-        // KEYS
-        del,
-        exists,
-        expire,
-        expireat,
-        keys,
-        persist,
-        pexpire,
-        pexpireat,
-        pttl,
-        randomkey,
-        rename,
-        renamenx,
-        scan,
-        touch,
-        ttl,
-        type,
-        unlink,
-        // LISTS
-        lindex,
-        linsert,
-        llen,
-        lpop,
-        lpush,
-        lpushx,
-        lrange,
-        lrem,
-        lset,
-        ltrim,
-        rpop,
-        rpoplpush,
-        rpush,
-        rpushx,
-        // SERVER
-        dbsize,
-        flushall,
-        flushdb,
-        info,
-        time,
-        // SET
-        sadd,
-        scard,
-        sdiff,
-        sdiffstore,
-        sinter,
-        sinterstore,
-        sismember,
-        smembers,
-        smove,
-        spop,
-        srandmember,
-        srem,
-        sunion,
-        sunionstore,
-        // SORTED SETS
-        zadd,
-        zcard,
-        zcount,
-        zincrby,
-        zinterstore,
-        zlexcount,
-        zpopmax,
-        zpopmin,
-        zrange,
-        zrangebylex,
-        zrangebyscore,
-        zrank,
-        zrem,
-        zremrangebylex,
-        zremrangebyrank,
-        zremrangebyscore,
-        zrevrange,
-        zrevrangebylex,
-        zrevrangebyscore,
-        zrevrank,
-        zscore,
-        zunionstore,
-    };
-}
-//# sourceMappingURL=client.js.map