@upstash/redis 0.1.22 → 0.2.0

package/README.md

@@ -9,7 +9,7 @@ An HTTP/REST based Redis client built on top of [Upstash REST API](https://docs.
 It is the only connectionless (HTTP based) Redis client and designed for:
 
 - Serverless functions (AWS Lambda ...)
-- Cloudflare Workers (see [the example](https://github.com/upstash/upstash-redis/tree/master/examples/workers-with-upstash))
+- Cloudflare Workers (see [the example](https://github.com/upstash/upstash-redis/tree/master/examples/cloudflare-workers))
 - Fastly Compute@Edge
 - Next.js, Jamstack ...
 - Client side web/mobile applications
@@ -26,78 +26,38 @@ See [the list of APIs](https://docs.upstash.com/features/restapi#rest---redis-ap
 npm install @upstash/redis
 ```
 
-### Usage with Callback Style
+### Usage with Promise
 
 ```typescript
-import upstash from '@upstash/redis';
+import { auth, set } from '@upstash/redis';
 
-const redis = upstash('UPSTASH_REDIS_REST_URL', 'UPSTASH_REDIS_REST_TOKEN');
+auth('UPSTASH_REDIS_REST_URL', 'UPSTASH_REDIS_REST_TOKEN');
 
-redis.get('key', function ({ data, error }) {
-  if (error) {
-    return console.error(error);
-  }
+set('key', 'value').then(({ data }) => {
   console.log(data);
+  // -> "OK"
 });
 ```
 
-### Usage with async/await (Promise)
-
-```typescript
-import upstash from '@upstash/redis';
-
-const redis = upstash('UPSTASH_REDIS_REST_URL', 'UPSTASH_REDIS_REST_TOKEN');
-
-(async () => {
-  try {
-    const { data, error } = await redis.get('key');
-    if (error) throw error;
-    console.log(data);
-  } catch (error) {
-    console.error(error);
-  }
-})();
-```
-
-If you define `UPSTASH_REDIS_REST_URL` and` UPSTASH_REDIS_REST_TOKEN` environment variables, you can run the Redis commands directly.
+### Usage with async/await
 
 ```typescript
-import { get } from '@upstash/redis';
+import { set } from '@upstash/redis';
 
 (async () => {
   try {
-    const { data, error } = await get('key');
+    const { data, error } = await set('key', 'value');
     if (error) throw error;
     console.log(data);
+    // -> "OK"
   } catch (error) {
     console.error(error);
   }
 })();
 ```
 
-### Edge Support
-
-> Only GET requests are supported in Edge Caching. As a result, write/update commands are not supported.
+> If you define `UPSTASH_REDIS_REST_URL` and` UPSTASH_REDIS_REST_TOKEN` environment variables, you can skip the auth().
 
-```typescript
-import upstash from '@upstash/redis';
+## Docs
 
-const redis = upstash({
-  url: 'UPSTASH_REDIS_REST_URL',
-  token: 'UPSTASH_REDIS_REST_TOKEN',
-  edgeUrl: 'UPSTASH_REDIS_EDGE_URL',
-});
-
-(async () => {
-  try {
-    const { data, error, metadata } = await redis.get('key');
-    if (error) throw error;
-    console.log(data);
-    // -> null | string
-    console.log(metadata);
-    // -> { edge: boolean, cache: null | 'miss' | 'hit' }
-  } catch (error) {
-    console.error(error);
-  }
-})();
-```
+See [the documentation](https://docs.upstash.com/features/javascriptsdk) for details.

package/dist/main/client.d.ts

@@ -0,0 +1,21 @@
+import { ClientObjectProps, Upstash } from './types';
+/**
+ * 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: {} });
+ * ```
+ */
+declare function upstash(options?: ClientObjectProps): Upstash;
+declare function upstash(url?: string, token?: string): Upstash;
+export default upstash;

package/dist/main/client.js

@@ -0,0 +1,556 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isomorphic_unfetch_1 = __importDefault(require("isomorphic-unfetch"));
+/**
+ * Parse Options
+ */
+function parseOptions(url, token, requestOptions = {}) {
+    if (typeof url === 'object' && url !== null) {
+        return parseOptions(url.url, url.token, url.requestOptions);
+    }
+    // try auto fill from env variables
+    if (!url && typeof window === 'undefined') {
+        url = process.env.UPSTASH_REDIS_REST_URL;
+        token = process.env.UPSTASH_REDIS_REST_TOKEN;
+    }
+    return { url: url, token, requestOptions };
+}
+/**
+ * Fetch
+ */
+function fetchData(options, ...parts) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!options.url) {
+            throw 'Database url not found?';
+        }
+        try {
+            const res = yield (0, isomorphic_unfetch_1.default)(options.url, Object.assign({ method: 'POST', body: JSON.stringify(parts), headers: Object.assign({ Authorization: `Bearer ${options.token}` }, (_a = options.requestOptions) === null || _a === void 0 ? void 0 : _a.headers) }, options.requestOptions));
+            const data = yield res.json();
+            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,
+                // @ts-ignore
+                error: err,
+            };
+        }
+    });
+}
+function upstash(url, token) {
+    const options = parseOptions(url, token);
+    /**
+     * Auth
+     */
+    function auth() {
+        Object.assign(options, {
+            url: undefined,
+            token: undefined,
+        }, parseOptions(arguments[0], arguments[1]));
+    }
+    /**
+     * STRING
+     */
+    function append() {
+        return fetchData(options, 'append', ...arguments);
+    }
+    function decr() {
+        return fetchData(options, 'decr', ...arguments);
+    }
+    function decrby() {
+        return fetchData(options, 'decrby', ...arguments);
+    }
+    function get() {
+        return fetchData(options, 'get', ...arguments);
+    }
+    function getrange() {
+        return fetchData(options, 'getrange', ...arguments);
+    }
+    function getset() {
+        return fetchData(options, 'getset', ...arguments);
+    }
+    function incr() {
+        return fetchData(options, 'incr', ...arguments);
+    }
+    function incrby() {
+        return fetchData(options, 'incrby', ...arguments);
+    }
+    function incrbyfloat() {
+        return fetchData(options, 'incrbyfloat', ...arguments);
+    }
+    function mget() {
+        return fetchData(options, 'mget', ...arguments);
+    }
+    function mset() {
+        return fetchData(options, 'mset', ...arguments);
+    }
+    function msetnx() {
+        return fetchData(options, 'msetnx', ...arguments);
+    }
+    function psetex() {
+        return fetchData(options, 'psetex', ...arguments);
+    }
+    function set() {
+        return fetchData(options, 'set', ...arguments);
+    }
+    function setex() {
+        return fetchData(options, 'setex', ...arguments);
+    }
+    function setnx() {
+        return fetchData(options, 'setnx', ...arguments);
+    }
+    function setrange() {
+        return fetchData(options, 'setrange', ...arguments);
+    }
+    function strlen() {
+        return fetchData(options, 'strlen', ...arguments);
+    }
+    /**
+     * BITMAPS
+     */
+    function bitcount() {
+        return fetchData(options, 'bitcount', ...arguments);
+    }
+    function bitop() {
+        return fetchData(options, 'bitop', ...arguments);
+    }
+    function bitpos() {
+        return fetchData(options, 'bitpos', ...arguments);
+    }
+    function getbit() {
+        return fetchData(options, 'getbit', ...arguments);
+    }
+    function setbit() {
+        return fetchData(options, 'setbit', ...arguments);
+    }
+    /**
+     * CONNECTION
+     */
+    function echo() {
+        return fetchData(options, 'echo', ...arguments);
+    }
+    function ping() {
+        return fetchData(options, 'ping', ...arguments);
+    }
+    /**
+     * HASHES
+     */
+    function hdel() {
+        return fetchData(options, 'hdel', ...arguments);
+    }
+    function hexists() {
+        return fetchData(options, 'hexists', ...arguments);
+    }
+    function hget() {
+        return fetchData(options, 'hget', ...arguments);
+    }
+    function hgetall() {
+        return fetchData(options, 'hgetall', ...arguments);
+    }
+    function hincrby() {
+        return fetchData(options, 'hincrby', ...arguments);
+    }
+    function hincrbyfloat() {
+        return fetchData(options, 'hincrbyfloat', ...arguments);
+    }
+    function hkeys() {
+        return fetchData(options, 'hkeys', ...arguments);
+    }
+    function hlen() {
+        return fetchData(options, 'hlen', ...arguments);
+    }
+    function hmget() {
+        return fetchData(options, 'hmget', ...arguments);
+    }
+    function hmset() {
+        return fetchData(options, 'hmset', ...arguments);
+    }
+    function hscan() {
+        return fetchData(options, 'hscan', ...arguments);
+    }
+    function hset() {
+        return fetchData(options, 'hset', ...arguments);
+    }
+    function hsetnx() {
+        return fetchData(options, 'hsetnx', ...arguments);
+    }
+    function hvals() {
+        return fetchData(options, 'hvals', ...arguments);
+    }
+    /**
+     * KEYS
+     */
+    function del() {
+        return fetchData(options, 'del', ...arguments);
+    }
+    function exists() {
+        return fetchData(options, 'exists', ...arguments);
+    }
+    function expire() {
+        return fetchData(options, 'expire', ...arguments);
+    }
+    function expireat() {
+        return fetchData(options, 'expireat', ...arguments);
+    }
+    function keys() {
+        return fetchData(options, 'keys', ...arguments);
+    }
+    function persist() {
+        return fetchData(options, 'persist', ...arguments);
+    }
+    function pexpire() {
+        return fetchData(options, 'pexpire', ...arguments);
+    }
+    function pexpireat() {
+        return fetchData(options, 'pexpireat', ...arguments);
+    }
+    function pttl() {
+        return fetchData(options, 'pttl', ...arguments);
+    }
+    function randomkey() {
+        return fetchData(options, 'randomkey', ...arguments);
+    }
+    function rename() {
+        return fetchData(options, 'rename', ...arguments);
+    }
+    function renamenx() {
+        return fetchData(options, 'renamenx', ...arguments);
+    }
+    function scan() {
+        return fetchData(options, 'scan', ...arguments);
+    }
+    function touch() {
+        return fetchData(options, 'touch', ...arguments);
+    }
+    function ttl() {
+        return fetchData(options, 'ttl', ...arguments);
+    }
+    function type() {
+        return fetchData(options, 'type', ...arguments);
+    }
+    function unlink() {
+        return fetchData(options, 'unlink', ...arguments);
+    }
+    /**
+     * LISTS
+     */
+    function lindex() {
+        return fetchData(options, 'lindex', ...arguments);
+    }
+    function linsert() {
+        return fetchData(options, 'linsert', ...arguments);
+    }
+    function llen() {
+        return fetchData(options, 'llen', ...arguments);
+    }
+    function lpop() {
+        return fetchData(options, 'lpop', ...arguments);
+    }
+    function lpush() {
+        return fetchData(options, 'lpush', ...arguments);
+    }
+    function lpushx() {
+        return fetchData(options, 'lpushx', ...arguments);
+    }
+    function lrange() {
+        return fetchData(options, 'lrange', ...arguments);
+    }
+    function lrem() {
+        return fetchData(options, 'lrem', ...arguments);
+    }
+    function lset() {
+        return fetchData(options, 'lset', ...arguments);
+    }
+    function ltrim() {
+        return fetchData(options, 'ltrim', ...arguments);
+    }
+    function rpop() {
+        return fetchData(options, 'rpop', ...arguments);
+    }
+    function rpoplpush() {
+        return fetchData(options, 'rpoplpush', ...arguments);
+    }
+    function rpush() {
+        return fetchData(options, 'rpush', ...arguments);
+    }
+    function rpushx() {
+        return fetchData(options, 'rpushx', ...arguments);
+    }
+    /**
+     * SERVER
+     */
+    function dbsize() {
+        return fetchData(options, 'dbsize', ...arguments);
+    }
+    function flushall() {
+        return fetchData(options, 'flushall', ...arguments);
+    }
+    function flushdb() {
+        return fetchData(options, 'flushdb', ...arguments);
+    }
+    function info() {
+        return fetchData(options, 'info', ...arguments);
+    }
+    function time() {
+        return fetchData(options, 'time', ...arguments);
+    }
+    /**
+     * SET
+     */
+    function sadd() {
+        return fetchData(options, 'sadd', ...arguments);
+    }
+    function scard() {
+        return fetchData(options, 'scard', ...arguments);
+    }
+    function sdiff() {
+        return fetchData(options, 'sdiff', ...arguments);
+    }
+    function sdiffstore() {
+        return fetchData(options, 'sdiffstore', ...arguments);
+    }
+    function sinter() {
+        return fetchData(options, 'sinter', ...arguments);
+    }
+    function sinterstore() {
+        return fetchData(options, 'sinterstore', ...arguments);
+    }
+    function sismember() {
+        return fetchData(options, 'sismember', ...arguments);
+    }
+    function smembers() {
+        return fetchData(options, 'smembers', ...arguments);
+    }
+    function smove() {
+        return fetchData(options, 'smove', ...arguments);
+    }
+    function spop() {
+        return fetchData(options, 'spop', ...arguments);
+    }
+    function srandmember() {
+        return fetchData(options, 'srandmember', ...arguments);
+    }
+    function srem() {
+        return fetchData(options, 'srem', ...arguments);
+    }
+    function sunion() {
+        return fetchData(options, 'sunion', ...arguments);
+    }
+    function sunionstore() {
+        return fetchData(options, 'sunionstore', ...arguments);
+    }
+    /**
+     * SORTED SETS
+     */
+    function zadd() {
+        return fetchData(options, 'zadd', ...arguments);
+    }
+    function zcard() {
+        return fetchData(options, 'zcard', ...arguments);
+    }
+    function zcount() {
+        return fetchData(options, 'zcount', ...arguments);
+    }
+    function zincrby() {
+        return fetchData(options, 'zincrby', ...arguments);
+    }
+    function zinterstore() {
+        return fetchData(options, 'zinterstore', ...arguments);
+    }
+    function zlexcount() {
+        return fetchData(options, 'zlexcount', ...arguments);
+    }
+    function zpopmax() {
+        return fetchData(options, 'zpopmax', ...arguments);
+    }
+    function zpopmin() {
+        return fetchData(options, 'zpopmin', ...arguments);
+    }
+    function zrange() {
+        return fetchData(options, 'zrange', ...arguments);
+    }
+    function zrangebylex() {
+        return fetchData(options, 'zrangebylex', ...arguments);
+    }
+    function zrangebyscore() {
+        return fetchData(options, 'zrangebyscore', ...arguments);
+    }
+    function zrank() {
+        return fetchData(options, 'zrank', ...arguments);
+    }
+    function zrem() {
+        return fetchData(options, 'zrem', ...arguments);
+    }
+    function zremrangebylex() {
+        return fetchData(options, 'zremrangebylex', ...arguments);
+    }
+    function zremrangebyrank() {
+        return fetchData(options, 'zremrangebyrank', ...arguments);
+    }
+    function zremrangebyscore() {
+        return fetchData(options, 'zremrangebyscore', ...arguments);
+    }
+    function zrevrange() {
+        return fetchData(options, 'zrevrange', ...arguments);
+    }
+    function zrevrangebylex() {
+        return fetchData(options, 'zrevrangebylex', ...arguments);
+    }
+    function zrevrangebyscore() {
+        return fetchData(options, 'zrevrangebyscore', ...arguments);
+    }
+    function zrevrank() {
+        return fetchData(options, 'zrevrank', ...arguments);
+    }
+    function zscore() {
+        return fetchData(options, 'zscore', ...arguments);
+    }
+    function zunionstore() {
+        return fetchData(options, 'zunionstore', ...arguments);
+    }
+    return {
+        auth,
+        // STRING
+        append,
+        decr,
+        decrby,
+        get,
+        getrange,
+        getset,
+        incr,
+        incrby,
+        incrbyfloat,
+        mget,
+        mset,
+        msetnx,
+        psetex,
+        set,
+        setex,
+        setnx,
+        setrange,
+        strlen,
+        // BITMAPS
+        bitcount,
+        bitop,
+        bitpos,
+        getbit,
+        setbit,
+        // CONNECTION
+        echo,
+        ping,
+        // HASHES
+        hdel,
+        hexists,
+        hget,
+        hgetall,
+        hincrby,
+        hincrbyfloat,
+        hkeys,
+        hlen,
+        hmget,
+        hmset,
+        hscan,
+        hset,
+        hsetnx,
+        hvals,
+        // KEYS
+        del,
+        exists,
+        expire,
+        expireat,
+        keys,
+        persist,
+        pexpire,
+        pexpireat,
+        pttl,
+        randomkey,
+        rename,
+        renamenx,
+        scan,
+        touch,
+        ttl,
+        type,
+        unlink,
+        // LISTS
+        lindex,
+        linsert,
+        llen,
+        lpop,
+        lpush,
+        lpushx,
+        lrange,
+        lrem,
+        lset,
+        ltrim,
+        rpop,
+        rpoplpush,
+        rpush,
+        rpushx,
+        // SERVER
+        dbsize,
+        flushall,
+        flushdb,
+        info,
+        time,
+        // SET
+        sadd,
+        scard,
+        sdiff,
+        sdiffstore,
+        sinter,
+        sinterstore,
+        sismember,
+        smembers,
+        smove,
+        spop,
+        srandmember,
+        srem,
+        sunion,
+        sunionstore,
+        // SORTED SETS
+        zadd,
+        zcard,
+        zcount,
+        zincrby,
+        zinterstore,
+        zlexcount,
+        zpopmax,
+        zpopmin,
+        zrange,
+        zrangebylex,
+        zrangebyscore,
+        zrank,
+        zrem,
+        zremrangebylex,
+        zremrangebyrank,
+        zremrangebyscore,
+        zrevrange,
+        zrevrangebylex,
+        zrevrangebyscore,
+        zrevrank,
+        zscore,
+        zunionstore,
+    };
+}
+exports.default = upstash;

package/dist/main/index-cjs.d.ts

@@ -0,0 +1 @@
+export {};