@upstash/redis 0.1.22 → 0.2.0

package/src/index-cjs.ts

@@ -0,0 +1,117 @@
+import upstash from './client';
+
+const redis = upstash();
+
+module.exports = upstash;
+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/src/index.ts

@@ -1,8 +1,8 @@
-import Upstash from './client';
+import upstash from './client';
 
-export default Upstash;
+export default upstash;
 
-const {
+export const {
   auth,
   append,
   decr,
@@ -115,119 +115,4 @@ const {
   zrevrank,
   zscore,
   zunionstore,
-} = Upstash();
-
-export {
-  auth,
-  append,
-  decr,
-  decrby,
-  get,
-  getrange,
-  getset,
-  incr,
-  incrby,
-  incrbyfloat,
-  mget,
-  mset,
-  msetnx,
-  psetex,
-  set,
-  setex,
-  setnx,
-  setrange,
-  strlen,
-  bitcount,
-  bitop,
-  bitpos,
-  getbit,
-  setbit,
-  echo,
-  ping,
-  hdel,
-  hexists,
-  hget,
-  hgetall,
-  hincrby,
-  hincrbyfloat,
-  hkeys,
-  hlen,
-  hmget,
-  hmset,
-  hscan,
-  hset,
-  hsetnx,
-  hvals,
-  del,
-  exists,
-  expire,
-  expireat,
-  keys,
-  persist,
-  pexpire,
-  pexpireat,
-  pttl,
-  randomkey,
-  rename,
-  renamenx,
-  scan,
-  touch,
-  ttl,
-  type,
-  unlink,
-  lindex,
-  linsert,
-  llen,
-  lpop,
-  lpush,
-  lpushx,
-  lrange,
-  lrem,
-  lset,
-  ltrim,
-  rpop,
-  rpoplpush,
-  rpush,
-  rpushx,
-  dbsize,
-  flushall,
-  flushdb,
-  info,
-  time,
-  sadd,
-  scard,
-  sdiff,
-  sdiffstore,
-  sinter,
-  sinterstore,
-  sismember,
-  smembers,
-  smove,
-  spop,
-  srandmember,
-  srem,
-  sunion,
-  sunionstore,
-  zadd,
-  zcard,
-  zcount,
-  zincrby,
-  zinterstore,
-  zlexcount,
-  zpopmax,
-  zpopmin,
-  zrange,
-  zrangebylex,
-  zrangebyscore,
-  zrank,
-  zrem,
-  zremrangebylex,
-  zremrangebyrank,
-  zremrangebyscore,
-  zrevrange,
-  zrevrangebylex,
-  zrevrangebyscore,
-  zrevrank,
-  zscore,
-  zunionstore,
-};
+} = upstash();

package/src/types.ts

@@ -0,0 +1,408 @@
+export type ClientObjectProps = {
+  url?: undefined | string;
+  token?: undefined | string;
+  requestOptions?: undefined | RequestInit;
+};
+
+export type ReturnType = {
+  data: string | number | [] | any;
+  error: string | null;
+};
+
+export type MethodReturn = Promise<ReturnType>;
+
+export type Part = string | boolean | number;
+
+export type Bit = 0 | 1;
+
+export type Infinities = '+inf' | '-inf';
+
+export type ZSetNumber = Infinities | number | string;
+
+type Auth1 = (options?: ClientObjectProps) => void;
+type Auth2 = (url?: string, token?: string) => void;
+type Auth3 = (url?: string | ClientObjectProps, token?: string) => void;
+
+type SET1 = (key: string, value: string | number) => MethodReturn;
+type SET2 = (
+  key: string,
+  value: string | number,
+  timeType: 'EX' | 'PX',
+  time: number | string
+) => MethodReturn;
+
+type BITCOUNT1 = (key: string) => MethodReturn;
+type BITCOUNT2 = (
+  key: string,
+  start: number | string,
+  end: number | string
+) => MethodReturn;
+
+type BITPOS1 = (key: string, bit: Bit) => MethodReturn;
+type BITPOS2 = (key: string, bit: Bit, start: number) => MethodReturn;
+type BITPOS3 = (
+  key: string,
+  bit: Bit,
+  start: number,
+  end: number
+) => MethodReturn;
+
+type PING1 = () => MethodReturn;
+type PING2 = (message: string) => MethodReturn;
+
+type HSCAN1 = (key: string, cursor: number | string) => MethodReturn;
+type HSCAN2 = (
+  key: string,
+  cursor: number | string,
+  match: 'MATCH',
+  pattern: string
+) => MethodReturn;
+type HSCAN3 = (
+  key: string,
+  cursor: number | string,
+  count: 'COUNT',
+  value: number | string
+) => MethodReturn;
+type HSCAN4 = (
+  key: string,
+  cursor: number | string,
+  match: 'MATCH',
+  pattern: string,
+  count: 'COUNT',
+  value: number | string
+) => MethodReturn;
+
+type SCAN1 = (cursor: number | string) => MethodReturn;
+type SCAN2 = (
+  cursor: number | string,
+  match: 'MATCH',
+  pattern: string
+) => MethodReturn;
+type SCAN3 = (
+  cursor: number | string,
+  count: 'COUNT',
+  value: number | string
+) => MethodReturn;
+type SCAN4 = (
+  cursor: number | string,
+  match: 'MATCH',
+  pattern: string,
+  count: 'COUNT',
+  value: number | string
+) => MethodReturn;
+
+type FLUSHALL1 = () => MethodReturn;
+type FLUSHALL2 = (mode: 'ASYNC') => MethodReturn;
+
+type FLUSHDB1 = () => MethodReturn;
+type FLUSHDB2 = (mode: 'ASYNC' | 'SYNC') => MethodReturn;
+
+type INFO1 = () => MethodReturn;
+type INFO2 = (section: string) => MethodReturn;
+
+type SPOP1 = (key: string) => MethodReturn;
+type SPOP2 = (key: string, count: number) => MethodReturn;
+
+type SRANDMEMBER1 = (key: string) => MethodReturn;
+type SRANDMEMBER2 = (key: string, count: number) => MethodReturn;
+
+type ZPOPMAX1 = (key: string) => MethodReturn;
+type ZPOPMAX2 = (key: string, count: number | string) => MethodReturn;
+
+type ZRANGE1 = (key: string, min: ZSetNumber, max: ZSetNumber) => MethodReturn;
+type ZRANGE2 = (
+  key: string,
+  min: ZSetNumber,
+  max: ZSetNumber,
+  withscores: 'WITHSCORES'
+) => MethodReturn;
+
+type ZRANGEBYLEX1 = (
+  key: string,
+  min: ZSetNumber,
+  max: ZSetNumber
+) => MethodReturn;
+type ZRANGEBYLEX2 = (
+  key: string,
+  min: ZSetNumber,
+  max: ZSetNumber,
+  limit: 'LIMIT',
+  offset: number | string,
+  count: number | string
+) => MethodReturn;
+
+type ZRANGEBYSCORE1 = (
+  key: string,
+  min: ZSetNumber,
+  max: ZSetNumber
+) => MethodReturn;
+type ZRANGEBYSCORE2 = (
+  key: string,
+  min: ZSetNumber,
+  max: ZSetNumber,
+  withScores: 'WITHSCORES'
+) => MethodReturn;
+type ZRANGEBYSCORE3 = (
+  key: string,
+  min: ZSetNumber,
+  max: ZSetNumber,
+  limit: 'LIMIT',
+  offset: number | string,
+  count: number | string
+) => MethodReturn;
+type ZRANGEBYSCORE4 = (
+  key: string,
+  min: ZSetNumber,
+  max: ZSetNumber,
+  withScores: 'WITHSCORES',
+  limit: 'LIMIT',
+  offset: number | string,
+  count: number | string
+) => MethodReturn;
+
+type ZREVRANGEBYLEX1 = (
+  key: string,
+  max: ZSetNumber,
+  min: ZSetNumber
+) => MethodReturn;
+type ZREVRANGEBYLEX2 = (
+  key: string,
+  max: ZSetNumber,
+  min: ZSetNumber,
+  limit: 'LIMIT',
+  offset: number | string,
+  count: number | string
+) => MethodReturn;
+
+type ZREVRANGEBYSCORE1 = (
+  key: string,
+  max: ZSetNumber,
+  min: ZSetNumber
+) => MethodReturn;
+type ZREVRANGEBYSCORE2 = (
+  key: string,
+  max: ZSetNumber,
+  min: ZSetNumber,
+  withScores: 'WITHSCORES'
+) => MethodReturn;
+type ZREVRANGEBYSCORE3 = (
+  key: string,
+  max: ZSetNumber,
+  min: ZSetNumber,
+  limit: 'LIMIT',
+  offset: number | string,
+  count: number | string
+) => MethodReturn;
+type ZREVRANGEBYSCORE4 = (
+  key: string,
+  max: ZSetNumber,
+  min: ZSetNumber,
+  withScores: 'WITHSCORES',
+  limit: 'LIMIT',
+  offset: number | string,
+  count: number | string
+) => MethodReturn;
+
+type ZREVRANGE1 = (
+  key: string,
+  start: number | string,
+  stop: number | string
+) => MethodReturn;
+type ZREVRANGE2 = (
+  key: string,
+  start: number | string,
+  stop: number | string,
+  withscores: 'WITHSCORES'
+) => MethodReturn;
+
+export type Upstash = {
+  auth: Auth1 & Auth2 & Auth3;
+  //
+  append: (key: string, value: string) => MethodReturn;
+  decr: (key: string) => MethodReturn;
+  decrby: (key: string, decrement: number | string) => MethodReturn;
+  get: (key: string) => MethodReturn;
+  getrange: (
+    key: string,
+    start: number | string,
+    end: number | string
+  ) => MethodReturn;
+  getset: (key: string, value: string) => MethodReturn;
+  incr: (key: string) => MethodReturn;
+  incrby: (key: string, increment: number | string) => MethodReturn;
+  incrbyfloat: (key: string, increment: number | string) => MethodReturn;
+  mget: (...key: any) => MethodReturn;
+  mset: (...keyValue: any) => MethodReturn;
+  msetnx: (...keyValue: any) => MethodReturn;
+  psetex: (
+    key: string,
+    miliseconds: number | string,
+    value: string
+  ) => MethodReturn;
+  set: SET1 & SET2;
+  setex: (key: string, seconds: number | string, value: string) => MethodReturn;
+  setnx: (key: string, value: string) => MethodReturn;
+  setrange: (
+    key: string,
+    offset: number | string,
+    value: string
+  ) => MethodReturn;
+  strlen: (key: string) => MethodReturn;
+  //
+  bitcount: BITCOUNT1 & BITCOUNT2;
+  bitop: (
+    operation: 'AND' | 'OR' | 'XOR' | 'NOT',
+    destKey: string,
+    ...key: any
+  ) => MethodReturn;
+  bitpos: BITPOS1 & BITPOS2 & BITPOS3;
+  getbit: (key: string, offset: number | string) => MethodReturn;
+  setbit: (key: string, offset: number | string, value: Bit) => MethodReturn;
+  //
+  echo: (message: string) => MethodReturn;
+  ping: PING1 & PING2;
+  //
+  hdel: (key: string, ...field: any) => 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, ...field: any) => MethodReturn;
+  hmset: (key: string, ...fieldValue: any) => MethodReturn;
+  hscan: HSCAN1 & HSCAN2 & HSCAN3 & HSCAN4;
+  hset: (key: string, ...fieldValue: any) => MethodReturn;
+  hsetnx: (key: string, field: string, value: string) => MethodReturn;
+  hvals: (key: string) => MethodReturn;
+  //
+  del: (...key: any) => MethodReturn;
+  exists: (...key: any) => MethodReturn;
+  expire: (key: string, seconds: number | string) => MethodReturn;
+  expireat: (key: string, timestamp: number | string) => MethodReturn;
+  keys: (pattern: string) => MethodReturn;
+  persist: (key: string) => MethodReturn;
+  pexpire: (key: string, miliseconds: number | string) => MethodReturn;
+  pexpireat: (
+    key: string,
+    milisecondsTimestamp: number | string
+  ) => MethodReturn;
+  pttl: (key: string) => MethodReturn;
+  randomkey: () => MethodReturn;
+  rename: (key: string, newKey: string) => MethodReturn;
+  renamenx: (key: string, newKey: string) => MethodReturn;
+  scan: SCAN1 & SCAN2 & SCAN3 & SCAN4;
+  touch: (...key: any) => MethodReturn;
+  ttl: (key: string) => MethodReturn;
+  type: (key: string) => MethodReturn;
+  unlink: (...key: any) => MethodReturn;
+  //
+  lindex: (key: string, index: number | string) => MethodReturn;
+  linsert: (
+    key: string,
+    option: 'BEFORE' | 'AFTER',
+    pivot: string,
+    element: string
+  ) => MethodReturn;
+  llen: (key: string) => MethodReturn;
+  lpop: (key: string) => MethodReturn;
+  lpush: (key: string, ...element: any) => MethodReturn;
+  lpushx: (key: string, ...element: any) => MethodReturn;
+  lrange: (
+    key: string,
+    start: number | string,
+    stop: number | string
+  ) => MethodReturn;
+  lrem: (key: string, count: number | string, element: string) => MethodReturn;
+  lset: (key: string, index: number | string, element: string) => MethodReturn;
+  ltrim: (
+    key: string,
+    start: number | string,
+    stop: number | string
+  ) => MethodReturn;
+  rpop: (key: string) => MethodReturn;
+  rpoplpush: (source: string, destination: string) => MethodReturn;
+  rpush: (key: string, ...element: any) => MethodReturn;
+  rpushx: (key: string, ...element: any) => MethodReturn;
+  //
+  dbsize: () => MethodReturn;
+  flushall: FLUSHALL1 & FLUSHALL2;
+  flushdb: FLUSHDB1 & FLUSHDB2;
+  info: INFO1 & INFO2;
+  time: () => MethodReturn;
+  //
+  sadd: (key: string, ...member: any) => MethodReturn;
+  scard: (key: string) => MethodReturn;
+  sdiff: (...key: any) => MethodReturn;
+  sdiffstore: (destination: string, ...key: any) => MethodReturn;
+  sinter: (...key: any) => MethodReturn;
+  sinterstore: (destination: string, ...key: any) => MethodReturn;
+  sismember: (key: string, member: string) => MethodReturn;
+  smembers: (key: string) => MethodReturn;
+  smove: (source: string, destination: string, member: string) => MethodReturn;
+  spop: SPOP1 & SPOP2;
+  srandmember: SRANDMEMBER1 & SRANDMEMBER2;
+  srem: (key: string, ...member: any) => MethodReturn;
+  sunion: (...key: any) => MethodReturn;
+  sunionstore: (destination: string, ...key: any) => MethodReturn;
+  //
+  zadd: (key: string, ...scoreMember: any) => MethodReturn;
+  zcard: (key: string) => MethodReturn;
+  zcount: (key: string, min: ZSetNumber, max: ZSetNumber) => MethodReturn;
+  zincrby: (
+    key: string,
+    increment: number | string,
+    member: string
+  ) => MethodReturn;
+  // TODO: fix args
+  zinterstore: (
+    destination: string,
+    numkeys: number | string,
+    ...key: any
+  ) => MethodReturn;
+  zlexcount: (key: string, min: ZSetNumber, max: ZSetNumber) => MethodReturn;
+  zpopmax: ZPOPMAX1 & ZPOPMAX2;
+  zpopmin: ZPOPMAX1 & ZPOPMAX2;
+  zrange: ZRANGE1 & ZRANGE2;
+  zrangebylex: ZRANGEBYLEX1 & ZRANGEBYLEX2;
+  zrangebyscore: ZRANGEBYSCORE1 &
+    ZRANGEBYSCORE2 &
+    ZRANGEBYSCORE3 &
+    ZRANGEBYSCORE4;
+  zrank: (key: string, member: string) => MethodReturn;
+  zrem: (key: string, ...member: any) => MethodReturn;
+  zremrangebylex: (
+    key: string,
+    min: ZSetNumber,
+    max: ZSetNumber
+  ) => MethodReturn;
+  zremrangebyrank: (
+    key: string,
+    start: number | string,
+    stop: number | string
+  ) => MethodReturn;
+  zremrangebyscore: (
+    key: string,
+    min: ZSetNumber,
+    max: ZSetNumber
+  ) => MethodReturn;
+  zrevrange: ZREVRANGE1 & ZREVRANGE2;
+  zrevrangebylex: ZREVRANGEBYLEX1 & ZREVRANGEBYLEX2;
+  zrevrangebyscore: ZREVRANGEBYSCORE1 &
+    ZREVRANGEBYSCORE2 &
+    ZREVRANGEBYSCORE3 &
+    ZREVRANGEBYSCORE4;
+  zrevrank: (key: string, member: string) => MethodReturn;
+  zscore: (key: string, member: string) => MethodReturn;
+  // TODO: fix args
+  zunionstore: (destination: string, ...numkeys: any) => MethodReturn;
+};

package/tsconfig.json

@@ -1,18 +1,20 @@
 {
-  "include": ["src", "types"],
-  "exclude": ["node_modules/**/*.ts"],
+  "files": ["src/index-cjs.ts"],
+  "exclude": ["./**/dist", "node_modules"],
   "compilerOptions": {
     "declaration": true,
-    "declarationMap": true,
+    "lib": ["ES2015", "DOM"],
     "module": "CommonJS",
+    "rootDir": "src",
     "outDir": "dist/main",
-    "sourceMap": true,
-    "target": "ES2019",
+    "target": "ES2015",
     "strict": true,
-    "esModuleInterop": true,
     "moduleResolution": "Node",
     "forceConsistentCasingInFileNames": true,
     "stripInternal": true,
-    "allowSyntheticDefaultImports": true
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "baseUrl": ".",
+    "typeRoots": ["./src/types", "node_modules/@types"]
   }
 }

package/tsconfig.module.json

@@ -1,7 +1,8 @@
 {
   "extends": "./tsconfig",
+  "files": ["src/index.ts"],
   "compilerOptions": {
-    "module": "ES2015",
-    "outDir": "dist/module"
+    "outDir": "dist/module",
+    "module": "ES2015"
   }
 }