@upstash/redis 0.1.2 → 0.1.6

package/dist/module/client.js

@@ -0,0 +1,608 @@
+import fetch from 'isomorphic-unfetch';
+/**
+ * Parse Options
+ */
+function parseOptions(url, token, edgeUrl, readFromEdge, requestOptions = {}) {
+    if (typeof url === 'object' && url !== null) {
+        return parseOptions(url.url, url.token, url.edgeUrl, url.readFromEdge, url.requestOptions);
+    }
+    // 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;
+        edgeUrl = process.env.UPSTASH_REDIS_EDGE_URL;
+    }
+    readFromEdge = edgeUrl ? readFromEdge ?? true : false;
+    return edgeUrl
+        ? { url: url, token, edgeUrl, readFromEdge, requestOptions }
+        : { url: url, token, requestOptions };
+}
+/**
+ * Fetch
+ */
+async function fetchData(url, options, init) {
+    try {
+        const res = await fetch(url, {
+            ...init,
+            headers: {
+                Authorization: `Bearer ${options.token}`,
+                ...init.headers,
+                ...options.requestOptions?.headers,
+            },
+            ...options.requestOptions,
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            if (data.error)
+                throw data.error;
+            throw `Upstash failed with (${res.status}): ${JSON.stringify(data, null, 2)}`;
+        }
+        let edge = false;
+        let cache = null;
+        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 {
+            data: data.result,
+            error: null,
+            metadata: { edge, cache },
+        };
+    }
+    catch (err) {
+        return {
+            data: null,
+            // @ts-ignore
+            error: err,
+            metadata: { edge: false, cache: null },
+        };
+    }
+}
+/**
+ * Request
+ */
+function request(options, config, ...parts) {
+    if (!options.url) {
+        throw 'Database url not found?';
+    }
+    if (!options.edgeUrl) {
+        if (options.readFromEdge || config?.edge) {
+            throw 'You need to set Edge Url to read from edge.';
+        }
+    }
+    let fromEdge = !!options.edgeUrl && options.readFromEdge !== false;
+    if (config === undefined) {
+        fromEdge = false;
+    }
+    else if (options.edgeUrl) {
+        fromEdge = config?.edge ?? true;
+    }
+    if (fromEdge) {
+        const command = encodeURI(parts.join('/'));
+        const edgeUrlWithPath = `${options.edgeUrl}/${command}`;
+        return fetchData(edgeUrlWithPath, options, { method: 'GET' });
+    }
+    else {
+        return fetchData(options.url, options, {
+            method: 'POST',
+            body: JSON.stringify(parts),
+        });
+    }
+}
+function hasConfig(options, command, a) {
+    let lastArg;
+    let args = [...a];
+    if (a.length > 0) {
+        lastArg = args.pop();
+    }
+    if (typeof lastArg === 'object' && lastArg !== null) {
+        return request(options, lastArg, command, ...args);
+    }
+    else {
+        return request(options, {}, command, ...a);
+    }
+}
+function upstash(url, token) {
+    const options = parseOptions(url, token);
+    /**
+     * Auth
+     */
+    function auth() {
+        Object.assign(options, {
+            url: undefined,
+            token: undefined,
+            edgeUrl: undefined,
+            readFromEdge: undefined,
+        }, parseOptions(arguments[0], arguments[1]));
+    }
+    /**
+     * STRING
+     */
+    function append() {
+        return request(options, undefined, 'append', ...arguments);
+    }
+    function decr() {
+        return request(options, undefined, 'decr', ...arguments);
+    }
+    function decrby() {
+        return request(options, undefined, 'decrby', ...arguments);
+    }
+    function get() {
+        return hasConfig(options, 'get', arguments);
+    }
+    function getrange() {
+        return hasConfig(options, 'getrange', arguments);
+    }
+    function getset() {
+        return request(options, undefined, 'getset', ...arguments);
+    }
+    function incr() {
+        return request(options, undefined, 'incr', ...arguments);
+    }
+    function incrby() {
+        return request(options, undefined, 'incrby', ...arguments);
+    }
+    function incrbyfloat() {
+        return request(options, undefined, 'incrbyfloat', ...arguments);
+    }
+    function mget() {
+        return hasConfig(options, 'mget', arguments);
+    }
+    function mset() {
+        return request(options, undefined, 'mset', ...arguments);
+    }
+    function msetnx() {
+        return request(options, undefined, 'msetnx', ...arguments);
+    }
+    function psetex() {
+        return request(options, undefined, 'psetex', ...arguments);
+    }
+    function set() {
+        return request(options, undefined, 'set', ...arguments);
+    }
+    function setex() {
+        return request(options, undefined, 'setex', ...arguments);
+    }
+    function setnx() {
+        return request(options, undefined, 'setnx', ...arguments);
+    }
+    function setrange() {
+        return request(options, undefined, 'setrange', ...arguments);
+    }
+    function strlen() {
+        return hasConfig(options, 'strlen', arguments);
+    }
+    /**
+     * BITMAPS
+     */
+    function bitcount() {
+        return hasConfig(options, 'bitcount', arguments);
+    }
+    function bitop() {
+        return request(options, undefined, 'bitop', ...arguments);
+    }
+    function bitpos() {
+        return hasConfig(options, 'bitpos', arguments);
+    }
+    function getbit() {
+        return hasConfig(options, 'getbit', arguments);
+    }
+    function setbit() {
+        return request(options, undefined, 'setbit', ...arguments);
+    }
+    /**
+     * CONNECTION
+     */
+    function echo() {
+        return hasConfig(options, 'echo', arguments);
+    }
+    function ping() {
+        return hasConfig(options, 'ping', arguments);
+    }
+    /**
+     * HASHES
+     */
+    function hdel() {
+        return request(options, undefined, 'hdel', ...arguments);
+    }
+    function hexists() {
+        return hasConfig(options, 'hexists', arguments);
+    }
+    function hget() {
+        return hasConfig(options, 'hget', arguments);
+    }
+    function hgetall() {
+        return hasConfig(options, 'hgetall', arguments);
+    }
+    function hincrby() {
+        return request(options, undefined, 'hincrby', ...arguments);
+    }
+    function hincrbyfloat() {
+        return request(options, undefined, 'hincrbyfloat', ...arguments);
+    }
+    function hkeys() {
+        return hasConfig(options, 'hkeys', arguments);
+    }
+    function hlen() {
+        return hasConfig(options, 'hlen', arguments);
+    }
+    function hmget() {
+        return hasConfig(options, 'hmget', arguments);
+    }
+    function hmset() {
+        return request(options, undefined, 'hmset', ...arguments);
+    }
+    function hscan() {
+        return request(options, undefined, 'hscan', ...arguments);
+    }
+    function hset() {
+        return request(options, undefined, 'hset', ...arguments);
+    }
+    function hsetnx() {
+        return request(options, undefined, 'hsetnx', ...arguments);
+    }
+    function hvals() {
+        return hasConfig(options, 'hvals', arguments);
+    }
+    /**
+     * KEYS
+     */
+    function del() {
+        return request(options, undefined, 'del', ...arguments);
+    }
+    function exists() {
+        return hasConfig(options, 'exists', arguments);
+    }
+    function expire() {
+        return request(options, undefined, 'expire', ...arguments);
+    }
+    function expireat() {
+        return request(options, undefined, 'expireat', ...arguments);
+    }
+    function keys() {
+        return hasConfig(options, 'keys', arguments);
+    }
+    function persist() {
+        return request(options, undefined, 'persist', ...arguments);
+    }
+    function pexpire() {
+        return request(options, undefined, 'pexpire', ...arguments);
+    }
+    function pexpireat() {
+        return request(options, undefined, 'pexpireat', ...arguments);
+    }
+    function pttl() {
+        return hasConfig(options, 'pttl', arguments);
+    }
+    function randomkey() {
+        return request(options, undefined, 'randomkey', ...arguments);
+    }
+    function rename() {
+        return request(options, undefined, 'rename', ...arguments);
+    }
+    function renamenx() {
+        return request(options, undefined, 'renamenx', ...arguments);
+    }
+    function scan() {
+        return request(options, undefined, 'scan', ...arguments);
+    }
+    function touch() {
+        return request(options, undefined, 'touch', ...arguments);
+    }
+    function ttl() {
+        return hasConfig(options, 'ttl', arguments);
+    }
+    function type() {
+        return hasConfig(options, 'type', arguments);
+    }
+    function unlink() {
+        return request(options, undefined, 'unlink', ...arguments);
+    }
+    /**
+     * LISTS
+     */
+    function lindex() {
+        return hasConfig(options, 'lindex', arguments);
+    }
+    function linsert() {
+        return request(options, undefined, 'linsert', ...arguments);
+    }
+    function llen() {
+        return hasConfig(options, 'llen', arguments);
+    }
+    function lpop() {
+        return request(options, undefined, 'lpop', ...arguments);
+    }
+    function lpush() {
+        return request(options, undefined, 'lpush', ...arguments);
+    }
+    function lpushx() {
+        return request(options, undefined, 'lpushx', ...arguments);
+    }
+    function lrange() {
+        return hasConfig(options, 'lrange', arguments);
+    }
+    function lrem() {
+        return request(options, undefined, 'lrem', ...arguments);
+    }
+    function lset() {
+        return request(options, undefined, 'lset', ...arguments);
+    }
+    function ltrim() {
+        return request(options, undefined, 'ltrim', ...arguments);
+    }
+    function rpop() {
+        return request(options, undefined, 'rpop', ...arguments);
+    }
+    function rpoplpush() {
+        return request(options, undefined, 'rpoplpush', ...arguments);
+    }
+    function rpush() {
+        return request(options, undefined, 'rpush', ...arguments);
+    }
+    function rpushx() {
+        return request(options, undefined, 'rpushx', ...arguments);
+    }
+    /**
+     * SERVER
+     */
+    function dbsize() {
+        return hasConfig(options, 'dbsize', arguments);
+    }
+    function flushall() {
+        return request(options, undefined, 'flushall', ...arguments);
+    }
+    function flushdb() {
+        return request(options, undefined, 'flushdb', ...arguments);
+    }
+    function info() {
+        return hasConfig(options, 'info', arguments);
+    }
+    function time() {
+        return request(options, undefined, 'time', ...arguments);
+    }
+    /**
+     * SET
+     */
+    function sadd() {
+        return request(options, undefined, 'sadd', ...arguments);
+    }
+    function scard() {
+        return request(options, undefined, 'scard', ...arguments);
+    }
+    function sdiff() {
+        return hasConfig(options, 'sdiff', arguments);
+    }
+    function sdiffstore() {
+        return request(options, undefined, 'sdiffstore', ...arguments);
+    }
+    function sinter() {
+        return hasConfig(options, 'sinter', arguments);
+    }
+    function sinterstore() {
+        return request(options, undefined, 'sinterstore', ...arguments);
+    }
+    function sismember() {
+        return hasConfig(options, 'sismember', arguments);
+    }
+    function smembers() {
+        return hasConfig(options, 'smembers', arguments);
+    }
+    function smove() {
+        return request(options, undefined, 'smove', ...arguments);
+    }
+    function spop() {
+        return request(options, undefined, 'spop', ...arguments);
+    }
+    function srandmember() {
+        return hasConfig(options, 'srandmember', arguments);
+    }
+    function srem() {
+        return request(options, undefined, 'srem', ...arguments);
+    }
+    function sunion() {
+        return hasConfig(options, 'sunion', arguments);
+    }
+    function sunionstore() {
+        return request(options, undefined, 'sunionstore', ...arguments);
+    }
+    /**
+     * SORTED SETS
+     */
+    function zadd() {
+        return request(options, undefined, 'zadd', ...arguments);
+    }
+    function zcard() {
+        return hasConfig(options, 'zcard', arguments);
+    }
+    function zcount() {
+        return hasConfig(options, 'zcount', arguments);
+    }
+    function zincrby() {
+        return request(options, undefined, 'zincrby', ...arguments);
+    }
+    function zinterstore() {
+        return request(options, undefined, 'zinterstore', ...arguments);
+    }
+    function zlexcount() {
+        return hasConfig(options, 'zlexcount', arguments);
+    }
+    function zpopmax() {
+        return request(options, undefined, 'zpopmax', ...arguments);
+    }
+    function zpopmin() {
+        return request(options, undefined, 'zpopmin', ...arguments);
+    }
+    function zrange() {
+        return hasConfig(options, 'zrange', arguments);
+    }
+    function zrangebylex() {
+        return hasConfig(options, 'zrangebylex', arguments);
+    }
+    function zrangebyscore() {
+        return hasConfig(options, 'zrangebyscore', arguments);
+    }
+    function zrank() {
+        return hasConfig(options, 'zrank', arguments);
+    }
+    function zrem() {
+        return request(options, undefined, 'zrem', ...arguments);
+    }
+    function zremrangebylex() {
+        return request(options, undefined, 'zremrangebylex', ...arguments);
+    }
+    function zremrangebyrank() {
+        return request(options, undefined, 'zremrangebyrank', ...arguments);
+    }
+    function zremrangebyscore() {
+        return request(options, undefined, 'zremrangebyscore', ...arguments);
+    }
+    function zrevrange() {
+        return hasConfig(options, 'zrevrange', arguments);
+    }
+    function zrevrangebylex() {
+        return hasConfig(options, 'zrevrangebylex', arguments);
+    }
+    function zrevrangebyscore() {
+        return hasConfig(options, 'zrevrangebyscore', arguments);
+    }
+    function zrevrank() {
+        return hasConfig(options, 'zrevrank', arguments);
+    }
+    function zscore() {
+        return hasConfig(options, 'zscore', arguments);
+    }
+    function zunionstore() {
+        return request(options, undefined, 'zunionstore', ...arguments);
+    }
+    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,
+    };
+}
+export default upstash;

package/dist/module/index.d.ts

@@ -0,0 +1,3 @@
+import upstash from './client';
+export default upstash;
+export declare const auth: ((options?: import("./types").ClientObjectProps | undefined) => void) & ((url?: string | undefined, token?: string | undefined) => void) & ((url?: string | import("./types").ClientObjectProps | undefined, token?: string | undefined) => void), append: (...args: any) => import("./types").MethodReturn, decr: (...args: any) => import("./types").MethodReturn, decrby: (...args: any) => import("./types").MethodReturn, get: (...args: any) => import("./types").MethodReturn, getrange: (...args: any) => import("./types").MethodReturn, getset: (...args: any) => import("./types").MethodReturn, incr: (...args: any) => import("./types").MethodReturn, incrby: (...args: any) => import("./types").MethodReturn, incrbyfloat: (...args: any) => import("./types").MethodReturn, mget: (...args: any) => import("./types").MethodReturn, mset: (...args: any) => import("./types").MethodReturn, msetnx: (...args: any) => import("./types").MethodReturn, psetex: (...args: any) => import("./types").MethodReturn, set: (...args: any) => import("./types").MethodReturn, setex: (...args: any) => import("./types").MethodReturn, setnx: (...args: any) => import("./types").MethodReturn, setrange: (...args: any) => import("./types").MethodReturn, strlen: (...args: any) => import("./types").MethodReturn, bitcount: (...args: any) => import("./types").MethodReturn, bitop: (...args: any) => import("./types").MethodReturn, bitpos: (...args: any) => import("./types").MethodReturn, getbit: (...args: any) => import("./types").MethodReturn, setbit: (...args: any) => import("./types").MethodReturn, echo: (...args: any) => import("./types").MethodReturn, ping: (...args: any) => import("./types").MethodReturn, hdel: (...args: any) => import("./types").MethodReturn, hexists: (...args: any) => import("./types").MethodReturn, hget: (...args: any) => import("./types").MethodReturn, hgetall: (...args: any) => import("./types").MethodReturn, hincrby: (...args: any) => import("./types").MethodReturn, hincrbyfloat: (...args: any) => import("./types").MethodReturn, hkeys: (...args: any) => import("./types").MethodReturn, hlen: (...args: any) => import("./types").MethodReturn, hmget: (...args: any) => import("./types").MethodReturn, hmset: (...args: any) => import("./types").MethodReturn, hscan: (...args: any) => import("./types").MethodReturn, hset: (...args: any) => import("./types").MethodReturn, hsetnx: (...args: any) => import("./types").MethodReturn, hvals: (...args: any) => import("./types").MethodReturn, del: (...args: any) => import("./types").MethodReturn, exists: (...args: any) => import("./types").MethodReturn, expire: (...args: any) => import("./types").MethodReturn, expireat: (...args: any) => import("./types").MethodReturn, keys: (...args: any) => import("./types").MethodReturn, persist: (...args: any) => import("./types").MethodReturn, pexpire: (...args: any) => import("./types").MethodReturn, pexpireat: (...args: any) => import("./types").MethodReturn, pttl: (...args: any) => import("./types").MethodReturn, randomkey: (...args: any) => import("./types").MethodReturn, rename: (...args: any) => import("./types").MethodReturn, renamenx: (...args: any) => import("./types").MethodReturn, scan: (...args: any) => import("./types").MethodReturn, touch: (...args: any) => import("./types").MethodReturn, ttl: (...args: any) => import("./types").MethodReturn, type: (...args: any) => import("./types").MethodReturn, unlink: (...args: any) => import("./types").MethodReturn, lindex: (...args: any) => import("./types").MethodReturn, linsert: (...args: any) => import("./types").MethodReturn, llen: (...args: any) => import("./types").MethodReturn, lpop: (...args: any) => import("./types").MethodReturn, lpush: (...args: any) => import("./types").MethodReturn, lpushx: (...args: any) => import("./types").MethodReturn, lrange: (...args: any) => import("./types").MethodReturn, lrem: (...args: any) => import("./types").MethodReturn, lset: (...args: any) => import("./types").MethodReturn, ltrim: (...args: any) => import("./types").MethodReturn, rpop: (...args: any) => import("./types").MethodReturn, rpoplpush: (...args: any) => import("./types").MethodReturn, rpush: (...args: any) => import("./types").MethodReturn, rpushx: (...args: any) => import("./types").MethodReturn, dbsize: (...args: any) => import("./types").MethodReturn, flushall: (...args: any) => import("./types").MethodReturn, flushdb: (...args: any) => import("./types").MethodReturn, info: (...args: any) => import("./types").MethodReturn, time: (...args: any) => import("./types").MethodReturn, sadd: (...args: any) => import("./types").MethodReturn, scard: (...args: any) => import("./types").MethodReturn, sdiff: (...args: any) => import("./types").MethodReturn, sdiffstore: (...args: any) => import("./types").MethodReturn, sinter: (...args: any) => import("./types").MethodReturn, sinterstore: (...args: any) => import("./types").MethodReturn, sismember: (...args: any) => import("./types").MethodReturn, smembers: (...args: any) => import("./types").MethodReturn, smove: (...args: any) => import("./types").MethodReturn, spop: (...args: any) => import("./types").MethodReturn, srandmember: (...args: any) => import("./types").MethodReturn, srem: (...args: any) => import("./types").MethodReturn, sunion: (...args: any) => import("./types").MethodReturn, sunionstore: (...args: any) => import("./types").MethodReturn, zadd: (...args: any) => import("./types").MethodReturn, zcard: (...args: any) => import("./types").MethodReturn, zcount: (...args: any) => import("./types").MethodReturn, zincrby: (...args: any) => import("./types").MethodReturn, zinterstore: (...args: any) => import("./types").MethodReturn, zlexcount: (...args: any) => import("./types").MethodReturn, zpopmax: (...args: any) => import("./types").MethodReturn, zpopmin: (...args: any) => import("./types").MethodReturn, zrange: (...args: any) => import("./types").MethodReturn, zrangebylex: (...args: any) => import("./types").MethodReturn, zrangebyscore: (...args: any) => import("./types").MethodReturn, zrank: (...args: any) => import("./types").MethodReturn, zrem: (...args: any) => import("./types").MethodReturn, zremrangebylex: (...args: any) => import("./types").MethodReturn, zremrangebyrank: (...args: any) => import("./types").MethodReturn, zremrangebyscore: (...args: any) => import("./types").MethodReturn, zrevrange: (...args: any) => import("./types").MethodReturn, zrevrangebylex: (...args: any) => import("./types").MethodReturn, zrevrangebyscore: (...args: any) => import("./types").MethodReturn, zrevrank: (...args: any) => import("./types").MethodReturn, zscore: (...args: any) => import("./types").MethodReturn, zunionstore: (...args: any) => import("./types").MethodReturn;

package/dist/module/index.js

@@ -0,0 +1,3 @@
+import upstash from './client';
+export default upstash;
+export const { auth, append, decr, decrby, get, getrange, getset, incr, incrby, incrbyfloat, mget, mset, msetnx, psetex, set, setex, setnx, setrange, strlen, bitcount, bitop, bitpos, getbit, setbit, echo, ping, hdel, hexists, hget, hgetall, hincrby, hincrbyfloat, hkeys, hlen, hmget, hmset, hscan, hset, hsetnx, hvals, del, exists, expire, expireat, keys, persist, pexpire, pexpireat, pttl, randomkey, rename, renamenx, scan, touch, ttl, type, unlink, lindex, linsert, llen, lpop, lpush, lpushx, lrange, lrem, lset, ltrim, rpop, rpoplpush, rpush, rpushx, dbsize, flushall, flushdb, info, time, sadd, scard, sdiff, sdiffstore, sinter, sinterstore, sismember, smembers, smove, spop, srandmember, srem, sunion, sunionstore, zadd, zcard, zcount, zincrby, zinterstore, zlexcount, zpopmax, zpopmin, zrange, zrangebylex, zrangebyscore, zrank, zrem, zremrangebylex, zremrangebyrank, zremrangebyscore, zrevrange, zrevrangebylex, zrevrangebyscore, zrevrank, zscore, zunionstore, } = upstash();