@upstash/redis 0.1.22 → 0.2.0

package/src/client.ts

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