@upstash/redis 0.1.6 → 0.1.7

package/README.md

@@ -58,38 +58,6 @@ import { set } from '@upstash/redis';
 
 > If you define `UPSTASH_REDIS_REST_URL` and` UPSTASH_REDIS_REST_TOKEN` environment variables, you can skip the auth().
 
-### Edge Support
-
-Once you set `edgeUrl`, all read commands are fetched using edge url. The REST URL is used for write/update commands.
-
-```typescript
-import { auth, get } from '@upstash/redis';
-
-auth({
-  url: 'UPSTASH_REDIS_REST_URL',
-  token: 'UPSTASH_REDIS_REST_TOKEN',
-  edgeUrl: 'UPSTASH_REDIS_EDGE_URL',
-});
-
-(async () => {
-  try {
-    // the below reads using edge url
-    const { data, error, metadata } = await get('key');
-    if (error) throw error;
-    console.log(data);
-    // -> null | string
-    console.log(metadata);
-    // -> { edge: boolean, cache: null | 'miss' | 'hit' }
-
-    // the below reads using REST url (non-edge)
-    const get1 = await get('key', { edge: false });
-    if (get1.error) throw get1.error;
-  } catch (error) {
-    console.error(error);
-  }
-})();
-```
-
 ## Docs
 
 See [the documentation](https://docs.upstash.com/features/javascriptsdk) for details.

package/dist/main/client.d.ts

@@ -3,20 +3,17 @@ import { ClientObjectProps, Upstash } from './types';
  * 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
+ * @param {Object} options
+ * @param {string} [options.url]
+ * @param {string} [options.token]
+ * @param {Object} [options.requestOptions]
  *
  * @example
  * ```js
  * import upstash from '@upstash/redis'
  *
  * const redis1 = upstash('url', token);
- * const redis2 = upstash({ url: '', token: '', edgeUrl: '', readFromEdge: false });
+ * const redis2 = upstash({ url: '', token: '', requestOptions: {} });
  * ```
  */
 declare function upstash(options?: ClientObjectProps): Upstash;

package/dist/main/client.js

@@ -7,31 +7,30 @@ const isomorphic_unfetch_1 = __importDefault(require("isomorphic-unfetch"));
 /**
  * Parse Options
  */
-function parseOptions(url, token, edgeUrl, readFromEdge, requestOptions = {}) {
+function parseOptions(url, token, requestOptions = {}) {
     if (typeof url === 'object' && url !== null) {
-        return parseOptions(url.url, url.token, url.edgeUrl, url.readFromEdge, url.requestOptions);
+        return parseOptions(url.url, url.token, 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 };
+    return { url: url, token, requestOptions };
 }
 /**
  * Fetch
  */
-async function fetchData(url, options, init) {
+async function fetchData(options, ...parts) {
+    if (!options.url) {
+        throw 'Database url not found?';
+    }
     try {
-        const res = await (0, isomorphic_unfetch_1.default)(url, {
-            ...init,
+        const res = await (0, isomorphic_unfetch_1.default)(options.url, {
+            method: 'POST',
+            body: JSON.stringify(parts),
             headers: {
                 Authorization: `Bearer ${options.token}`,
-                ...init.headers,
                 ...options.requestOptions?.headers,
             },
             ...options.requestOptions,
@@ -42,22 +41,9 @@ async function fetchData(url, options, init) {
                 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) {
@@ -65,54 +51,9 @@ async function fetchData(url, options, init) {
             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);
     /**
@@ -122,369 +63,367 @@ function upstash(url, token) {
         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);
+        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,