@upstash/redis 0.1.4 → 0.1.8

package/src/client.ts

@@ -1,17 +1,11 @@
 import fetch from 'isomorphic-unfetch';
 import {
   ClientObjectProps,
-  EdgeCacheType,
   MethodReturn,
   Part,
-  RequestConfig,
   ReturnType,
   Upstash,
-} from './type';
-
-function isObject(objectToCheck: any): boolean {
-  return typeof objectToCheck === 'object' && objectToCheck !== null;
-}
+} from './types';
 
 /**
  * Parse Options
@@ -19,150 +13,82 @@ function isObject(objectToCheck: any): boolean {
 function parseOptions(
   url?: string | ClientObjectProps,
   token?: string,
-  edgeUrl?: string,
-  readFromEdge?: boolean
+  requestOptions: undefined | RequestInit = {}
 ): ClientObjectProps {
-  if (url && typeof url !== 'string') {
-    return parseOptions(url?.url, url?.token, url?.edgeUrl, url?.readFromEdge);
+  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 ?? !!edgeUrl;
-
-  return edgeUrl ? { url, token, edgeUrl, readFromEdge } : { url, token };
+  return { url: url as string, token, requestOptions };
 }
 
 /**
  * Fetch
  */
 async function fetchData(
-  url: string,
   options: ClientObjectProps,
-  init: RequestInit
+  ...parts: Part[]
 ): Promise<ReturnType> {
+  if (!options.url) {
+    throw 'Database url not found?';
+  }
+
   try {
-    const res = await fetch(url, {
-      ...init,
+    const res = await fetch(options.url!, {
+      method: 'POST',
+      body: JSON.stringify(parts),
       headers: {
         Authorization: `Bearer ${options.token}`,
-        ...init.headers,
+        ...options.requestOptions?.headers,
       },
+      ...options.requestOptions,
     });
 
     const data = await res.json();
 
-    if (res.ok) {
-      let edge = false;
-      let cache: EdgeCacheType = 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 },
-      };
-    } else {
-      if (data.error) throw data;
-      throw new Error(
-        `Upstash failed with (${res.status}): ${JSON.stringify(data, null, 2)}`
-      );
+    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,
+    };
   } catch (err) {
     return {
       data: null,
-      error: typeof err.data === 'object' ? err.data.message : err,
-      metadata: { edge: false, cache: null },
+      // @ts-ignore
+      error: err,
     };
   }
 }
 
-/**
- * Request
- */
-function request(
-  options: ClientObjectProps,
-  config: RequestConfig,
-  ...parts: Part[]
-): MethodReturn {
-  if (!options.url) {
-    throw new Error('Database url not found?');
-  }
-
-  if (!options.edgeUrl) {
-    if (options.readFromEdge || config?.edge) {
-      throw new Error('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: ClientObjectProps, command: string, a: any) {
-  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);
-  }
-}
-
 /**
  * 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: {} });
  * ```
  */
 
@@ -181,7 +107,6 @@ function upstash(url?: string | ClientObjectProps, token?: string): Upstash {
       {
         url: undefined,
         token: undefined,
-        edgeUrl: undefined,
       },
       parseOptions(arguments[0], arguments[1])
     );
@@ -192,58 +117,58 @@ function upstash(url?: string | ClientObjectProps, token?: string): Upstash {
    */
 
   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);
   }
 
   /**
@@ -251,19 +176,19 @@ function upstash(url?: string | ClientObjectProps, token?: string): Upstash {
    */
 
   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);
   }
 
   /**
@@ -271,10 +196,10 @@ function upstash(url?: string | ClientObjectProps, token?: string): Upstash {
    */
 
   function echo() {
-    return hasConfig(options, 'echo', arguments);
+    return fetchData(options, 'echo', ...arguments);
   }
   function ping() {
-    return hasConfig(options, 'ping', arguments);
+    return fetchData(options, 'ping', ...arguments);
   }
 
   /**
@@ -282,46 +207,46 @@ function upstash(url?: string | ClientObjectProps, token?: string): Upstash {
    */
 
   function hdel(): MethodReturn {
-    return request(options, undefined, 'hdel', ...arguments);
+    return fetchData(options, 'hdel', ...arguments);
   }
   function hexists(): MethodReturn {
-    return hasConfig(options, 'hexists', arguments);
+    return fetchData(options, 'hexists', ...arguments);
   }
   function hget(): MethodReturn {
-    return hasConfig(options, 'hget', arguments);
+    return fetchData(options, 'hget', ...arguments);
   }
   function hgetall(): MethodReturn {
-    return hasConfig(options, 'hgetall', arguments);
+    return fetchData(options, 'hgetall', ...arguments);
   }
   function hincrby(): MethodReturn {
-    return request(options, undefined, 'hincrby', ...arguments);
+    return fetchData(options, 'hincrby', ...arguments);
   }
   function hincrbyfloat(): MethodReturn {
-    return request(options, undefined, 'hincrbyfloat', ...arguments);
+    return fetchData(options, 'hincrbyfloat', ...arguments);
   }
   function hkeys(): MethodReturn {
-    return hasConfig(options, 'hkeys', arguments);
+    return fetchData(options, 'hkeys', ...arguments);
   }
   function hlen(): MethodReturn {
-    return hasConfig(options, 'hlen', arguments);
+    return fetchData(options, 'hlen', ...arguments);
   }
   function hmget(): MethodReturn {
-    return hasConfig(options, 'hmget', arguments);
+    return fetchData(options, 'hmget', ...arguments);
   }
   function hmset(): MethodReturn {
-    return request(options, undefined, 'hmset', ...arguments);
+    return fetchData(options, 'hmset', ...arguments);
   }
   function hscan(): MethodReturn {
-    return request(options, undefined, 'hscan', ...arguments);
+    return fetchData(options, 'hscan', ...arguments);
   }
   function hset(): MethodReturn {
-    return request(options, undefined, 'hset', ...arguments);
+    return fetchData(options, 'hset', ...arguments);
   }
   function hsetnx(): MethodReturn {
-    return request(options, undefined, 'hsetnx', ...arguments);
+    return fetchData(options, 'hsetnx', ...arguments);
   }
   function hvals(): MethodReturn {
-    return hasConfig(options, 'hvals', arguments);
+    return fetchData(options, 'hvals', ...arguments);
   }
 
   /**
@@ -329,55 +254,55 @@ function upstash(url?: string | ClientObjectProps, token?: string): Upstash {
    */
 
   function del(): MethodReturn {
-    return request(options, undefined, 'del', ...arguments);
+    return fetchData(options, 'del', ...arguments);
   }
   function exists(): MethodReturn {
-    return hasConfig(options, 'exists', arguments);
+    return fetchData(options, 'exists', ...arguments);
   }
   function expire(): MethodReturn {
-    return request(options, undefined, 'expire', ...arguments);
+    return fetchData(options, 'expire', ...arguments);
   }
   function expireat(): MethodReturn {
-    return request(options, undefined, 'expireat', ...arguments);
+    return fetchData(options, 'expireat', ...arguments);
   }
   function keys(): MethodReturn {
-    return hasConfig(options, 'keys', arguments);
+    return fetchData(options, 'keys', ...arguments);
   }
   function persist(): MethodReturn {
-    return request(options, undefined, 'persist', ...arguments);
+    return fetchData(options, 'persist', ...arguments);
   }
   function pexpire(): MethodReturn {
-    return request(options, undefined, 'pexpire', ...arguments);
+    return fetchData(options, 'pexpire', ...arguments);
   }
   function pexpireat(): MethodReturn {
-    return request(options, undefined, 'pexpireat', ...arguments);
+    return fetchData(options, 'pexpireat', ...arguments);
   }
   function pttl(): MethodReturn {
-    return hasConfig(options, 'pttl', arguments);
+    return fetchData(options, 'pttl', ...arguments);
   }
   function randomkey(): MethodReturn {
-    return request(options, undefined, 'randomkey', ...arguments);
+    return fetchData(options, 'randomkey', ...arguments);
   }
   function rename(): MethodReturn {
-    return request(options, undefined, 'rename', ...arguments);
+    return fetchData(options, 'rename', ...arguments);
   }
   function renamenx(): MethodReturn {
-    return request(options, undefined, 'renamenx', ...arguments);
+    return fetchData(options, 'renamenx', ...arguments);
   }
   function scan(): MethodReturn {
-    return request(options, undefined, 'scan', ...arguments);
+    return fetchData(options, 'scan', ...arguments);
   }
   function touch(): MethodReturn {
-    return request(options, undefined, 'touch', ...arguments);
+    return fetchData(options, 'touch', ...arguments);
   }
   function ttl(): MethodReturn {
-    return hasConfig(options, 'ttl', arguments);
+    return fetchData(options, 'ttl', ...arguments);
   }
   function type(): MethodReturn {
-    return hasConfig(options, 'type', arguments);
+    return fetchData(options, 'type', ...arguments);
   }
   function unlink(): MethodReturn {
-    return request(options, undefined, 'unlink', ...arguments);
+    return fetchData(options, 'unlink', ...arguments);
   }
 
   /**
@@ -385,46 +310,46 @@ function upstash(url?: string | ClientObjectProps, token?: string): Upstash {
    */
 
   function lindex(): MethodReturn {
-    return hasConfig(options, 'lindex', arguments);
+    return fetchData(options, 'lindex', ...arguments);
   }
   function linsert(): MethodReturn {
-    return request(options, undefined, 'linsert', ...arguments);
+    return fetchData(options, 'linsert', ...arguments);
   }
   function llen(): MethodReturn {
-    return hasConfig(options, 'llen', arguments);
+    return fetchData(options, 'llen', ...arguments);
   }
   function lpop(): MethodReturn {
-    return request(options, undefined, 'lpop', ...arguments);
+    return fetchData(options, 'lpop', ...arguments);
   }
   function lpush(): MethodReturn {
-    return request(options, undefined, 'lpush', ...arguments);
+    return fetchData(options, 'lpush', ...arguments);
   }
   function lpushx(): MethodReturn {
-    return request(options, undefined, 'lpushx', ...arguments);
+    return fetchData(options, 'lpushx', ...arguments);
   }
   function lrange(): MethodReturn {
-    return hasConfig(options, 'lrange', arguments);
+    return fetchData(options, 'lrange', ...arguments);
   }
   function lrem(): MethodReturn {
-    return request(options, undefined, 'lrem', ...arguments);
+    return fetchData(options, 'lrem', ...arguments);
   }
   function lset(): MethodReturn {
-    return request(options, undefined, 'lset', ...arguments);
+    return fetchData(options, 'lset', ...arguments);
   }
   function ltrim(): MethodReturn {
-    return request(options, undefined, 'ltrim', ...arguments);
+    return fetchData(options, 'ltrim', ...arguments);
   }
   function rpop(): MethodReturn {
-    return request(options, undefined, 'rpop', ...arguments);
+    return fetchData(options, 'rpop', ...arguments);
   }
   function rpoplpush(): MethodReturn {
-    return request(options, undefined, 'rpoplpush', ...arguments);
+    return fetchData(options, 'rpoplpush', ...arguments);
   }
   function rpush(): MethodReturn {
-    return request(options, undefined, 'rpush', ...arguments);
+    return fetchData(options, 'rpush', ...arguments);
   }
   function rpushx(): MethodReturn {
-    return request(options, undefined, 'rpushx', ...arguments);
+    return fetchData(options, 'rpushx', ...arguments);
   }
 
   /**
@@ -432,19 +357,19 @@ function upstash(url?: string | ClientObjectProps, token?: string): Upstash {
    */
 
   function dbsize(): MethodReturn {
-    return hasConfig(options, 'dbsize', arguments);
+    return fetchData(options, 'dbsize', ...arguments);
   }
   function flushall(): MethodReturn {
-    return request(options, undefined, 'flushall', ...arguments);
+    return fetchData(options, 'flushall', ...arguments);
   }
   function flushdb(): MethodReturn {
-    return request(options, undefined, 'flushdb', ...arguments);
+    return fetchData(options, 'flushdb', ...arguments);
   }
   function info(): MethodReturn {
-    return hasConfig(options, 'info', arguments);
+    return fetchData(options, 'info', ...arguments);
   }
   function time(): MethodReturn {
-    return request(options, undefined, 'time', ...arguments);
+    return fetchData(options, 'time', ...arguments);
   }
 
   /**
@@ -452,46 +377,46 @@ function upstash(url?: string | ClientObjectProps, token?: string): Upstash {
    */
 
   function sadd(): MethodReturn {
-    return request(options, undefined, 'sadd', ...arguments);
+    return fetchData(options, 'sadd', ...arguments);
   }
   function scard(): MethodReturn {
-    return request(options, undefined, 'scard', ...arguments);
+    return fetchData(options, 'scard', ...arguments);
   }
   function sdiff(): MethodReturn {
-    return hasConfig(options, 'sdiff', arguments);
+    return fetchData(options, 'sdiff', ...arguments);
   }
   function sdiffstore(): MethodReturn {
-    return request(options, undefined, 'sdiffstore', ...arguments);
+    return fetchData(options, 'sdiffstore', ...arguments);
   }
   function sinter(): MethodReturn {
-    return hasConfig(options, 'sinter', arguments);
+    return fetchData(options, 'sinter', ...arguments);
   }
   function sinterstore(): MethodReturn {
-    return request(options, undefined, 'sinterstore', ...arguments);
+    return fetchData(options, 'sinterstore', ...arguments);
   }
   function sismember(): MethodReturn {
-    return hasConfig(options, 'sismember', arguments);
+    return fetchData(options, 'sismember', ...arguments);
   }
   function smembers(): MethodReturn {
-    return hasConfig(options, 'smembers', arguments);
+    return fetchData(options, 'smembers', ...arguments);
   }
   function smove(): MethodReturn {
-    return request(options, undefined, 'smove', ...arguments);
+    return fetchData(options, 'smove', ...arguments);
   }
   function spop(): MethodReturn {
-    return request(options, undefined, 'spop', ...arguments);
+    return fetchData(options, 'spop', ...arguments);
   }
   function srandmember(): MethodReturn {
-    return hasConfig(options, 'srandmember', arguments);
+    return fetchData(options, 'srandmember', ...arguments);
   }
   function srem(): MethodReturn {
-    return request(options, undefined, 'srem', ...arguments);
+    return fetchData(options, 'srem', ...arguments);
   }
   function sunion(): MethodReturn {
-    return hasConfig(options, 'sunion', arguments);
+    return fetchData(options, 'sunion', ...arguments);
   }
   function sunionstore(): MethodReturn {
-    return request(options, undefined, 'sunionstore', ...arguments);
+    return fetchData(options, 'sunionstore', ...arguments);
   }
 
   /**
@@ -499,70 +424,70 @@ function upstash(url?: string | ClientObjectProps, token?: string): Upstash {
    */
 
   function zadd(): MethodReturn {
-    return request(options, undefined, 'zadd', ...arguments);
+    return fetchData(options, 'zadd', ...arguments);
   }
   function zcard(): MethodReturn {
-    return hasConfig(options, 'zcard', arguments);
+    return fetchData(options, 'zcard', ...arguments);
   }
   function zcount(): MethodReturn {
-    return hasConfig(options, 'zcount', arguments);
+    return fetchData(options, 'zcount', ...arguments);
   }
   function zincrby(): MethodReturn {
-    return request(options, undefined, 'zincrby', ...arguments);
+    return fetchData(options, 'zincrby', ...arguments);
   }
   function zinterstore(): MethodReturn {
-    return request(options, undefined, 'zinterstore', ...arguments);
+    return fetchData(options, 'zinterstore', ...arguments);
   }
   function zlexcount(): MethodReturn {
-    return hasConfig(options, 'zlexcount', arguments);
+    return fetchData(options, 'zlexcount', ...arguments);
   }
   function zpopmax(): MethodReturn {
-    return request(options, undefined, 'zpopmax', ...arguments);
+    return fetchData(options, 'zpopmax', ...arguments);
   }
   function zpopmin(): MethodReturn {
-    return request(options, undefined, 'zpopmin', ...arguments);
+    return fetchData(options, 'zpopmin', ...arguments);
   }
   function zrange(): MethodReturn {
-    return hasConfig(options, 'zrange', arguments);
+    return fetchData(options, 'zrange', ...arguments);
   }
   function zrangebylex(): MethodReturn {
-    return hasConfig(options, 'zrangebylex', arguments);
+    return fetchData(options, 'zrangebylex', ...arguments);
   }
   function zrangebyscore(): MethodReturn {
-    return hasConfig(options, 'zrangebyscore', arguments);
+    return fetchData(options, 'zrangebyscore', ...arguments);
   }
   function zrank(): MethodReturn {
-    return hasConfig(options, 'zrank', arguments);
+    return fetchData(options, 'zrank', ...arguments);
   }
   function zrem(): MethodReturn {
-    return request(options, undefined, 'zrem', ...arguments);
+    return fetchData(options, 'zrem', ...arguments);
   }
   function zremrangebylex(): MethodReturn {
-    return request(options, undefined, 'zremrangebylex', ...arguments);
+    return fetchData(options, 'zremrangebylex', ...arguments);
   }
   function zremrangebyrank(): MethodReturn {
-    return request(options, undefined, 'zremrangebyrank', ...arguments);
+    return fetchData(options, 'zremrangebyrank', ...arguments);
   }
   function zremrangebyscore(): MethodReturn {
-    return request(options, undefined, 'zremrangebyscore', ...arguments);
+    return fetchData(options, 'zremrangebyscore', ...arguments);
   }
   function zrevrange(): MethodReturn {
-    return hasConfig(options, 'zrevrange', arguments);
+    return fetchData(options, 'zrevrange', ...arguments);
   }
   function zrevrangebylex(): MethodReturn {
-    return hasConfig(options, 'zrevrangebylex', arguments);
+    return fetchData(options, 'zrevrangebylex', ...arguments);
   }
   function zrevrangebyscore(): MethodReturn {
-    return hasConfig(options, 'zrevrangebyscore', arguments);
+    return fetchData(options, 'zrevrangebyscore', ...arguments);
   }
   function zrevrank(): MethodReturn {
-    return hasConfig(options, 'zrevrank', arguments);
+    return fetchData(options, 'zrevrank', ...arguments);
   }
   function zscore(): MethodReturn {
-    return hasConfig(options, 'zscore', arguments);
+    return fetchData(options, 'zscore', ...arguments);
   }
   function zunionstore(): MethodReturn {
-    return request(options, undefined, 'zunionstore', ...arguments);
+    return fetchData(options, 'zunionstore', ...arguments);
   }
 
   return {