@upstash/redis 0.1.5 → 0.1.9

package/dist/main/index-cjs.js

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

package/dist/main/types.d.ts

@@ -1,138 +1,161 @@
 export declare type ClientObjectProps = {
     url?: undefined | string;
     token?: undefined | string;
-    edgeUrl?: undefined | string;
-    readFromEdge?: boolean;
+    requestOptions?: undefined | RequestInit;
 };
-export declare type EdgeCacheType = null | 'miss' | 'hit';
 export declare type ReturnType = {
     data: string | number | [] | any;
     error: string | null;
-    metadata?: {
-        edge: boolean;
-        cache: EdgeCacheType;
-    };
 };
 export declare type MethodReturn = Promise<ReturnType>;
-export declare type RequestConfig = undefined | {
-    edge?: boolean;
-};
 export declare type Part = string | boolean | number;
+export declare type Bit = 0 | 1;
+export declare type Infinities = '+inf' | '-inf';
+export declare type ZSetNumber = Infinities | number | string;
 declare type Auth1 = (options?: ClientObjectProps) => void;
 declare type Auth2 = (url?: string, token?: string) => void;
 declare type Auth3 = (url?: string | ClientObjectProps, token?: string) => void;
 export declare type Upstash = {
     auth: Auth1 & Auth2 & Auth3;
-    append: (...args: any) => MethodReturn;
-    decr: (...args: any) => MethodReturn;
-    decrby: (...args: any) => MethodReturn;
-    get: (...args: any) => MethodReturn;
-    getrange: (...args: any) => MethodReturn;
-    getset: (...args: any) => MethodReturn;
-    incr: (...args: any) => MethodReturn;
-    incrby: (...args: any) => MethodReturn;
-    incrbyfloat: (...args: any) => MethodReturn;
-    mget: (...args: any) => MethodReturn;
-    mset: (...args: any) => MethodReturn;
-    msetnx: (...args: any) => MethodReturn;
-    psetex: (...args: any) => MethodReturn;
-    set: (...args: any) => MethodReturn;
-    setex: (...args: any) => MethodReturn;
-    setnx: (...args: any) => MethodReturn;
-    setrange: (...args: any) => MethodReturn;
-    strlen: (...args: any) => MethodReturn;
-    bitcount: (...args: any) => MethodReturn;
-    bitop: (...args: any) => MethodReturn;
-    bitpos: (...args: any) => MethodReturn;
-    getbit: (...args: any) => MethodReturn;
-    setbit: (...args: any) => MethodReturn;
-    echo: (...args: any) => MethodReturn;
-    ping: (...args: any) => MethodReturn;
-    hdel: (...args: any) => MethodReturn;
-    hexists: (...args: any) => MethodReturn;
-    hget: (...args: any) => MethodReturn;
-    hgetall: (...args: any) => MethodReturn;
-    hincrby: (...args: any) => MethodReturn;
-    hincrbyfloat: (...args: any) => MethodReturn;
-    hkeys: (...args: any) => MethodReturn;
-    hlen: (...args: any) => MethodReturn;
-    hmget: (...args: any) => MethodReturn;
-    hmset: (...args: any) => MethodReturn;
-    hscan: (...args: any) => MethodReturn;
-    hset: (...args: any) => MethodReturn;
-    hsetnx: (...args: any) => MethodReturn;
-    hvals: (...args: any) => MethodReturn;
-    del: (...args: any) => MethodReturn;
-    exists: (...args: any) => MethodReturn;
-    expire: (...args: any) => MethodReturn;
-    expireat: (...args: any) => MethodReturn;
-    keys: (...args: any) => MethodReturn;
-    persist: (...args: any) => MethodReturn;
-    pexpire: (...args: any) => MethodReturn;
-    pexpireat: (...args: any) => MethodReturn;
-    pttl: (...args: any) => MethodReturn;
-    randomkey: (...args: any) => MethodReturn;
-    rename: (...args: any) => MethodReturn;
-    renamenx: (...args: any) => MethodReturn;
-    scan: (...args: any) => MethodReturn;
-    touch: (...args: any) => MethodReturn;
-    ttl: (...args: any) => MethodReturn;
-    type: (...args: any) => MethodReturn;
-    unlink: (...args: any) => MethodReturn;
-    lindex: (...args: any) => MethodReturn;
-    linsert: (...args: any) => MethodReturn;
-    llen: (...args: any) => MethodReturn;
-    lpop: (...args: any) => MethodReturn;
-    lpush: (...args: any) => MethodReturn;
-    lpushx: (...args: any) => MethodReturn;
-    lrange: (...args: any) => MethodReturn;
-    lrem: (...args: any) => MethodReturn;
-    lset: (...args: any) => MethodReturn;
-    ltrim: (...args: any) => MethodReturn;
-    rpop: (...args: any) => MethodReturn;
-    rpoplpush: (...args: any) => MethodReturn;
-    rpush: (...args: any) => MethodReturn;
-    rpushx: (...args: any) => MethodReturn;
-    dbsize: (...args: any) => MethodReturn;
-    flushall: (...args: any) => MethodReturn;
-    flushdb: (...args: any) => MethodReturn;
-    info: (...args: any) => MethodReturn;
-    time: (...args: any) => MethodReturn;
-    sadd: (...args: any) => MethodReturn;
-    scard: (...args: any) => MethodReturn;
-    sdiff: (...args: any) => MethodReturn;
-    sdiffstore: (...args: any) => MethodReturn;
-    sinter: (...args: any) => MethodReturn;
-    sinterstore: (...args: any) => MethodReturn;
-    sismember: (...args: any) => MethodReturn;
-    smembers: (...args: any) => MethodReturn;
-    smove: (...args: any) => MethodReturn;
-    spop: (...args: any) => MethodReturn;
-    srandmember: (...args: any) => MethodReturn;
-    srem: (...args: any) => MethodReturn;
-    sunion: (...args: any) => MethodReturn;
-    sunionstore: (...args: any) => MethodReturn;
-    zadd: (...args: any) => MethodReturn;
-    zcard: (...args: any) => MethodReturn;
-    zcount: (...args: any) => MethodReturn;
-    zincrby: (...args: any) => MethodReturn;
-    zinterstore: (...args: any) => MethodReturn;
-    zlexcount: (...args: any) => MethodReturn;
-    zpopmax: (...args: any) => MethodReturn;
-    zpopmin: (...args: any) => MethodReturn;
-    zrange: (...args: any) => MethodReturn;
-    zrangebylex: (...args: any) => MethodReturn;
-    zrangebyscore: (...args: any) => MethodReturn;
-    zrank: (...args: any) => MethodReturn;
-    zrem: (...args: any) => MethodReturn;
-    zremrangebylex: (...args: any) => MethodReturn;
-    zremrangebyrank: (...args: any) => MethodReturn;
-    zremrangebyscore: (...args: any) => MethodReturn;
-    zrevrange: (...args: any) => MethodReturn;
-    zrevrangebylex: (...args: any) => MethodReturn;
-    zrevrangebyscore: (...args: any) => MethodReturn;
-    zrevrank: (...args: any) => MethodReturn;
-    zscore: (...args: any) => MethodReturn;
-    zunionstore: (...args: any) => MethodReturn;
+    append: (key: string, value: string) => MethodReturn;
+    decr: (key: string) => MethodReturn;
+    decrby: (key: string, decrement: number) => MethodReturn;
+    get: (key: string) => MethodReturn;
+    getrange: (key: string, start: number, end: number) => MethodReturn;
+    getset: (key: string, value: string) => MethodReturn;
+    incr: (key: string) => MethodReturn;
+    incrby: (key: string, value: number | string) => MethodReturn;
+    incrbyfloat: (key: string, value: number | string) => MethodReturn;
+    mget: (values: string[]) => MethodReturn;
+    mset: (values: string[]) => MethodReturn;
+    msetnx: (values: string[]) => MethodReturn;
+    psetex: (key: string, miliseconds: number, value: string | number) => MethodReturn;
+    set: (key: string, value: number | string) => MethodReturn;
+    setex: (key: string, seconds: number, value: string | number) => MethodReturn;
+    setnx: (key: string, value: string) => MethodReturn;
+    setrange: (key: string, offset: number | string, value: string) => MethodReturn;
+    strlen: (key: string) => MethodReturn;
+    bitcount: (key: string, start?: number, end?: number) => MethodReturn;
+    bitop: (operation: 'AND' | 'OR' | 'XOR' | 'NOT', destinationKey: string, sourceKeys: string[]) => MethodReturn;
+    bitpos: (key: string, bit: Bit, start?: number, end?: number) => MethodReturn;
+    getbit: (key: string, offset: number) => MethodReturn;
+    setbit: (key: string, offset: number, value: Bit) => MethodReturn;
+    echo: (value: string) => MethodReturn;
+    ping: (value?: string) => MethodReturn;
+    hdel: (key: string, fields: string[]) => MethodReturn;
+    hexists: (key: string, field: string) => MethodReturn;
+    hget: (key: string, field: string) => MethodReturn;
+    hgetall: (key: string) => MethodReturn;
+    hincrby: (key: string, field: string, increment: number | string) => MethodReturn;
+    hincrbyfloat: (key: string, field: string, increment: number | string) => MethodReturn;
+    hkeys: (key: string) => MethodReturn;
+    hlen: (key: string) => MethodReturn;
+    hmget: (key: string, fields: string[]) => MethodReturn;
+    hmset: (key: string, values: string[]) => MethodReturn;
+    hscan: (key: string, cursor: number, options?: {
+        match?: number | string;
+        count?: number | string;
+    }) => MethodReturn;
+    hset: (key: string, values: string[]) => MethodReturn;
+    hsetnx: (key: string, field: string, value: string) => MethodReturn;
+    hvals: (key: string) => MethodReturn;
+    del: (keys: string[]) => MethodReturn;
+    exists: (keys: string[]) => MethodReturn;
+    expire: (key: string, seconds: number) => MethodReturn;
+    expireat: (key: string, timestamp: number | string) => MethodReturn;
+    keys: (pattern: string) => MethodReturn;
+    persist: (key: string) => MethodReturn;
+    pexpire: (key: string, miliseconds: number) => MethodReturn;
+    pexpireat: (key: string, miliseconds: number) => MethodReturn;
+    pttl: (key: string) => MethodReturn;
+    randomkey: () => MethodReturn;
+    rename: (key: string, newKey: string) => MethodReturn;
+    renamenx: (key: string, newKey: string) => MethodReturn;
+    scan: (cursor: number, opitons?: {
+        match?: number | string;
+        count?: number | string;
+    }) => MethodReturn;
+    touch: (keys: string[]) => MethodReturn;
+    ttl: (key: string) => MethodReturn;
+    type: (key: string) => MethodReturn;
+    unlink: (keys: string[]) => MethodReturn;
+    lindex: (key: string, index: number) => MethodReturn;
+    linsert: (key: string, option: 'BEFORE' | 'AFTER', pivot: string, element: string) => MethodReturn;
+    llen: (key: string) => MethodReturn;
+    lpop: (key: string) => MethodReturn;
+    lpush: (key: string, elements: string[]) => MethodReturn;
+    lpushx: (key: string, elements: string[]) => MethodReturn;
+    lrange: (key: string, start: number, stop: number) => MethodReturn;
+    lrem: (key: string, count: number, element: string) => MethodReturn;
+    lset: (key: string, index: number, element: string) => MethodReturn;
+    ltrim: (key: string, start: number, stop: number) => MethodReturn;
+    rpop: (key: string) => MethodReturn;
+    rpoplpush: (source: string, destination: string) => MethodReturn;
+    rpush: (key: string, elements: string[]) => MethodReturn;
+    rpushx: (key: string, elements: string[]) => MethodReturn;
+    dbsize: () => MethodReturn;
+    flushall: (mode?: 'ASYNC') => MethodReturn;
+    flushdb: (mode?: 'ASYNC') => MethodReturn;
+    info: () => MethodReturn;
+    time: () => MethodReturn;
+    sadd: (key: string, members: string[]) => MethodReturn;
+    scard: (key: string) => MethodReturn;
+    sdiff: (keys: string[]) => MethodReturn;
+    sdiffstore: (destination: string, keys: string[]) => MethodReturn;
+    sinter: (keys: string[]) => MethodReturn;
+    sinterstore: (destination: string, keys: string[]) => MethodReturn;
+    sismember: (key: string, member: string) => MethodReturn;
+    smembers: (key: string) => MethodReturn;
+    smove: (source: string, destination: string, member: string) => MethodReturn;
+    spop: (key: string, count?: number) => MethodReturn;
+    srandmember: (key: string, count?: number) => MethodReturn;
+    srem: (key: string, members: string[]) => MethodReturn;
+    sunion: (keys: string[]) => MethodReturn;
+    sunionstore: (destination: string, keys: string[]) => MethodReturn;
+    zadd: (key: string, values: ZSetNumber[], options?: ({
+        xx?: boolean;
+    } | {
+        nx?: boolean;
+    }) & {
+        ch?: boolean;
+        incr: boolean;
+    }) => MethodReturn;
+    zcard: (key: string) => MethodReturn;
+    zcount: (key: string, min: ZSetNumber, max: ZSetNumber) => MethodReturn;
+    zincrby: (key: string, increment: number | string, member: string) => MethodReturn;
+    zinterstore: (destination: string, keys: string[], options?: {
+        weights?: number[];
+        aggregate?: 'MIN' | 'MAX' | 'SUM';
+    }) => MethodReturn;
+    zlexcount: (key: string, min: ZSetNumber, max: ZSetNumber) => MethodReturn;
+    zpopmax: (key: string, count?: number) => MethodReturn;
+    zpopmin: (key: string, count?: number) => MethodReturn;
+    zrange: (key: string, min: ZSetNumber, max: ZSetNumber, options?: {
+        withScores: boolean;
+    }) => MethodReturn;
+    zrangebylex: (key: string, min: ZSetNumber, max: ZSetNumber, offset?: number, count?: number) => MethodReturn;
+    zrangebyscore: (key: string, min: ZSetNumber, max: ZSetNumber, options?: {
+        withScores?: boolean;
+        limit?: {
+            offset: number;
+            count: number;
+        };
+    }) => MethodReturn;
+    zrank: (key: string, member: string) => MethodReturn;
+    zrem: (key: string, members: string[]) => MethodReturn;
+    zremrangebylex: (key: string, min: ZSetNumber, max: ZSetNumber) => MethodReturn;
+    zremrangebyrank: (key: string, start: number, stop: number) => MethodReturn;
+    zremrangebyscore: (key: string, min: ZSetNumber, max: ZSetNumber) => MethodReturn;
+    zrevrange: (key: string, start: number, stop: number, options?: {
+        withScores: boolean;
+    }) => MethodReturn;
+    zrevrangebylex: (key: string, max: ZSetNumber, min: ZSetNumber, offset?: number, count?: number) => MethodReturn;
+    zrevrangebyscore: (key: string, min: ZSetNumber, max: ZSetNumber) => MethodReturn;
+    zrevrank: (key: string, member: string) => MethodReturn;
+    zscore: (key: string, member: string) => MethodReturn;
+    zunionstore: (destination: string, keys: string[], options?: {
+        weights?: number[];
+        aggregate?: 'MIN' | 'MAX' | 'SUM';
+    }) => MethodReturn;
 };
 export {};

package/dist/module/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;