@upstash/redis 0.1.4 → 0.1.8

package/dist/main/client.js

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

package/dist/main/index-cjs.d.ts

@@ -0,0 +1 @@
+export {};