@upstash/redis 1.0.0-alpha.4 → 1.0.1

package/README.md

@@ -0,0 +1,256 @@
+# Upstash Redis
+
+An HTTP/REST based Redis client built on top of
+[Upstash REST API](https://docs.upstash.com/features/restapi).
+
+[![Tests](https://github.com/upstash/upstash-redis/actions/workflows/tests.yaml/badge.svg)](https://github.com/upstash/upstash-redis/actions/workflows/tests.yaml)
+![npm (scoped)](https://img.shields.io/npm/v/@upstash/redis)
+![npm bundle size](https://img.shields.io/bundlephobia/minzip/@upstash/redis)
+
+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/cloudflare-workers))
+- Fastly Compute@Edge (see
+  [the example](https://github.com/upstash/upstash-redis/tree/master/examples/fastly))
+- Next.js, Jamstack ...
+- Client side web/mobile applications
+- WebAssembly
+- and other environments where HTTP is preferred over TCP.
+
+See [the list of APIs](https://docs.upstash.com/features/restapi#rest---redis-api-compatibility) supported.
+
+## Upgrading from v0.2.0?
+
+Please read the [migration guide](https://github.com/upstash/upstash-redis#migrating-to-v1).
+For further explanation we wrote a [blog post](https://blog.upstash.com/upstash-redis-sdk-v1).
+
+## Quick Start
+
+### Install
+
+```bash
+npm install @upstash/redis
+```
+
+### Create database
+
+Create a new redis database on [upstash](https://console.upstash.com/)
+
+### Environments
+
+We support various platforms, such as nodejs, cloudflare and fastly.
+Platforms differ slightly when it comes to environment variables and their `fetch` api. Please use the correct import when deploying to special platforms.
+
+#### Node.js
+
+Examples: Vercel, Netlify, AWS Lambda
+
+If you are running on nodejs you can set `UPSTASH_REDIS_REST_URL` and `UPSTASH_REDIS_REST_TOKEN` as environment variable and create a redis instance like this:
+
+```ts
+import { Redis } from "@upstash/redis"
+
+const redis = new Redis({
+  url: <UPSTASH_REDIS_REST_URL>,
+  token: <UPSTASH_REDIS_REST_TOKEN>,
+})
+
+// or load directly from env
+const redis = Redis.fromEnv()
+```
+
+- [Code example](https://github.com/upstash/upstash-redis/tree/main/examples/node)
+
+#### Cloudflare Workers
+
+Cloudflare handles environment variables differently than nodejs.
+Please add `UPSTASH_REDIS_REST_URL` and `UPSTASH_REDIS_REST_TOKEN` using `wrangler secret put ...` or in the cloudflare dashboard.
+
+Afterwards you can create a redis instance:
+
+```ts
+import { Redis } from "@upstash/redis/cloudflare"
+
+const redis = new Redis({
+  url: <UPSTASH_REDIS_REST_URL>,
+  token: <UPSTASH_REDIS_REST_TOKEN>,
+})
+// or load directly from env
+const redis = Redis.fromEnv()
+```
+
+- [Code example](https://github.com/upstash/upstash-redis/tree/main/examples/cloudflare-workers)
+- [Documentation](https://docs.upstash.com/redis/tutorials/cloudflare_workers_with_redis)
+
+#### Fastly
+
+Fastly introduces a concept called [backend](https://developer.fastly.com/reference/api/services/backend/). You need to configure a backend in your `fastly.toml`. An example can be found [here](https://github.com/upstash/upstash-redis/blob/main/examples/fastly/fastly.toml).
+Until the fastly api stabilizes we recommend creating an instance manually:
+
+```ts
+import { Redis } from "@upstash/redis/fastly"
+
+const redis = new Redis({
+  url: <UPSTASH_REDIS_REST_URL>,
+  token: <UPSTASH_REDIS_REST_TOKEN>,
+  backend: <BACKEND_NAME>,
+})
+```
+
+- [Code example](https://github.com/upstash/upstash-redis/tree/main/examples/fastly)
+- [Documentation](https://blog.upstash.com/fastly-compute-edge-with-redi)
+
+### Working with types
+
+Most commands allow you to provide a type to make working with typescript easier.
+
+```ts
+const data = await redis.get<MyCustomType>("key")
+// data is typed as `MyCustomType`
+```
+
+## Migrating to v1
+
+### Explicit authentication
+
+The library is no longer automatically trying to load connection secrets from environment variables.
+You must either supply them yourself:
+
+```ts
+import { Redis } from "@upstash/redis"
+
+const redis = new Redis({
+  url: <UPSTASH_REDIS_REST_URL>,
+  token: <UPSTASH_REDIS_REST_TOKEN>,
+})
+```
+
+Or use one of the static constructors to load from environment variables:
+
+```ts
+// Nodejs
+import { Redis } from "@upstash/redis"
+const redis = Redis.fromEnv()
+```
+
+```ts
+// or when deploying to cloudflare workers
+import { Redis } from "@upstash/redis/cloudflare"
+const redis = Redis.fromEnv()
+```
+
+### Error handling
+
+Errors are now thrown automatically instead of being returned to you.
+
+```ts
+// old
+const { data, error } = await set("key", "value")
+if (error) {
+  throw new Error(error)
+}
+
+// new
+const data = await redis.set("key", "value") // error is thrown automatically
+```
+
+## Pipeline
+
+`v1.0.0` introduces redis pipelines.
+Pipelining commands allows you to send a single http request with multiple commands.
+
+```ts
+import { Redis } from "@upstash/redis"
+
+const redis = new Redis({
+  /* auth */
+})
+
+const p = redis.pipeline()
+
+// Now you can chain multiple commands to create your pipeline:
+
+p.set("key", 2)
+p.incr("key")
+
+// or inline:
+p.hset("key2", "field", { hello: "world" }).hvals("key2")
+
+// Execute the pipeline once you are done building it:
+// `exec` returns an array where each element represents the response of a command in the pipeline.
+// You can optionally provide a type like this to get a typed response.
+const res = await p.exec<[Type1, Type2, Type3]>()
+```
+
+For more information about pipelines using REST see [here](https://blog.upstash.com/pipeline).
+
+### Advanced
+
+A low level `Command` class can be imported from `@upstash/redis` in case you need more control about types and or (de)serialization.
+
+By default all objects you are storing in redis are serialized using `JSON.stringify` and recursively deserialized as well. Here's an example how you could customize that behaviour. Keep in mind that you need to provide a `fetch` polyfill if you are running on nodejs. We recommend [isomorphic-fetch](https://www.npmjs.com/package/isomorphic-fetch).
+
+```ts
+import { Command } from "@upstash/redis/commands"
+import { HttpClient } from "@upstash/redis/http"
+
+/**
+ * TData represents what the user will enter or receive,
+ * TResult is the raw data returned from upstash, which may need to be
+ * transformed or parsed.
+ */
+const deserialize: (raw: TResult) => TData = ...
+
+class CustomGetCommand<TData, TResult> extends Command<TData | null, TResult | null> {
+  constructor(key: string, ) {
+    super(["get", key], { deserialize })
+  }
+}
+
+const client = new HttpClient({
+  baseUrl: <UPSTASH_REDIS_REST_URL>,
+  headers: {
+    authorization: `Bearer ${<UPSTASH_REDIS_REST_TOKEN>}`,
+  },
+})
+
+const res = new CustomGetCommand("key").exec(client)
+
+```
+
+#### Javascript MAX_SAFE_INTEGER
+
+Javascript can not handle numbers larger than `2^53 -1` safely and would return wrong results when trying to deserialize them.
+In these cases the default deserializer will return them as string instead. This might cause a mismatch with your custom types.
+
+```ts
+await redis.set("key", "101600000000150081467")
+const res = await redis<number>("get")
+```
+
+In this example `res` will still be a string despite the type annotation.
+Please keep that in mind and adjust accordingly.
+
+## Docs
+
+See [the documentation](https://docs.upstash.com/features/javascriptsdk) for details.
+
+## Contributing
+
+### Installing dependencies
+
+```bash
+pnpm install
+```
+
+### Database
+
+Create a new redis database on [upstash](https://console.upstash.com/) and copy the url and token to `.env` (See `.env.example` for reference)
+
+### Running tests
+
+```sh
+pnpm test
+```

package/chunk-2EIGUPGW.mjs

@@ -0,0 +1,375 @@
+import {
+  AppendCommand,
+  BitCountCommand,
+  BitOpCommand,
+  BitPosCommand,
+  DBSizeCommand,
+  DecrByCommand,
+  DecrCommand,
+  DelCommand,
+  EchoCommand,
+  ExistsCommand,
+  ExpireAtCommand,
+  ExpireCommand,
+  FlushAllCommand,
+  FlushDBCommand,
+  GetBitCommand,
+  GetCommand,
+  GetRangeCommand,
+  GetSetCommand,
+  HDelCommand,
+  HExistsCommand,
+  HGetAllCommand,
+  HGetCommand,
+  HIncrByCommand,
+  HIncrByFloatCommand,
+  HKeysCommand,
+  HLenCommand,
+  HMGetCommand,
+  HMSetCommand,
+  HScanCommand,
+  HSetCommand,
+  HSetNXCommand,
+  HStrLenCommand,
+  HValsCommand,
+  IncrByCommand,
+  IncrByFloatCommand,
+  IncrCommand,
+  KeysCommand,
+  LIndexCommand,
+  LInsertCommand,
+  LLenCommand,
+  LPopCommand,
+  LPushCommand,
+  LPushXCommand,
+  LRangeCommand,
+  LRemCommand,
+  LSetCommand,
+  LTrimCommand,
+  MGetCommand,
+  MSetCommand,
+  MSetNXCommand,
+  PExpireAtCommand,
+  PExpireCommand,
+  PSetEXCommand,
+  PTtlCommand,
+  PersistCommand,
+  PingCommand,
+  RPopCommand,
+  RPushCommand,
+  RPushXCommand,
+  RandomKeyCommand,
+  RenameCommand,
+  RenameNXCommand,
+  SAddCommand,
+  SCardCommand,
+  SDiffCommand,
+  SDiffStoreCommand,
+  SInterCommand,
+  SInterStoreCommand,
+  SIsMemberCommand,
+  SMembersCommand,
+  SMoveCommand,
+  SPopCommand,
+  SRandMemberCommand,
+  SRemCommand,
+  SScanCommand,
+  SUnionCommand,
+  SUnionStoreCommand,
+  ScanCommand,
+  SetBitCommand,
+  SetCommand,
+  SetExCommand,
+  SetNxCommand,
+  SetRangeCommand,
+  StrLenCommand,
+  TimeCommand,
+  TouchCommand,
+  TtlCommand,
+  TypeCommand,
+  UnlinkCommand,
+  ZAddCommand,
+  ZCardCommand,
+  ZCountCommand,
+  ZIncrByComand,
+  ZInterStoreCommand,
+  ZLexCountCommand,
+  ZPopMaxCommand,
+  ZPopMinCommand,
+  ZRangeCommand,
+  ZRankCommand,
+  ZRemCommand,
+  ZRemRangeByLexCommand,
+  ZRemRangeByRankCommand,
+  ZRemRangeByScoreCommand,
+  ZRevRankCommand,
+  ZScanCommand,
+  ZScoreCommand,
+  ZUnionStoreCommand
+} from "./chunk-HGM7M7CJ.mjs";
+import {
+  UpstashError
+} from "./chunk-7YUZYRJS.mjs";
+
+// pkg/pipeline.ts
+var Pipeline = class {
+  constructor(client) {
+    this.exec = async () => {
+      if (this.commands.length === 0) {
+        throw new Error("Pipeline is empty");
+      }
+      const res = await this.client.request({
+        path: ["pipeline"],
+        body: Object.values(this.commands).map((c) => c.command)
+      });
+      return res.map(({ error, result }, i) => {
+        if (error) {
+          throw new UpstashError(`Command ${i + 1} [ ${this.commands[i].command[0]} ] failed: ${error}`);
+        }
+        return this.commands[i].deserialize(result);
+      });
+    };
+    this.append = (...args) => this.chain(new AppendCommand(...args));
+    this.bitcount = (...args) => this.chain(new BitCountCommand(...args));
+    this.bitop = (op, destinationKey, sourceKey, ...sourceKeys) => this.chain(new BitOpCommand(op, destinationKey, sourceKey, ...sourceKeys));
+    this.bitpos = (...args) => this.chain(new BitPosCommand(...args));
+    this.dbsize = () => this.chain(new DBSizeCommand());
+    this.decr = (...args) => this.chain(new DecrCommand(...args));
+    this.decrby = (...args) => this.chain(new DecrByCommand(...args));
+    this.del = (...args) => this.chain(new DelCommand(...args));
+    this.echo = (...args) => this.chain(new EchoCommand(...args));
+    this.exists = (...args) => this.chain(new ExistsCommand(...args));
+    this.expire = (...args) => this.chain(new ExpireCommand(...args));
+    this.expireat = (...args) => this.chain(new ExpireAtCommand(...args));
+    this.flushall = (...args) => this.chain(new FlushAllCommand(...args));
+    this.flushdb = (...args) => this.chain(new FlushDBCommand(...args));
+    this.get = (...args) => this.chain(new GetCommand(...args));
+    this.getbit = (...args) => this.chain(new GetBitCommand(...args));
+    this.getrange = (...args) => this.chain(new GetRangeCommand(...args));
+    this.getset = (key, value) => this.chain(new GetSetCommand(key, value));
+    this.hdel = (...args) => this.chain(new HDelCommand(...args));
+    this.hexists = (...args) => this.chain(new HExistsCommand(...args));
+    this.hget = (...args) => this.chain(new HGetCommand(...args));
+    this.hgetall = (...args) => this.chain(new HGetAllCommand(...args));
+    this.hincrby = (...args) => this.chain(new HIncrByCommand(...args));
+    this.hincrbyfloat = (...args) => this.chain(new HIncrByFloatCommand(...args));
+    this.hkeys = (...args) => this.chain(new HKeysCommand(...args));
+    this.hlen = (...args) => this.chain(new HLenCommand(...args));
+    this.hmget = (...args) => this.chain(new HMGetCommand(...args));
+    this.hmset = (key, kv) => this.chain(new HMSetCommand(key, kv));
+    this.hscan = (...args) => this.chain(new HScanCommand(...args));
+    this.hset = (key, kv) => this.chain(new HSetCommand(key, kv));
+    this.hsetnx = (key, field, value) => this.chain(new HSetNXCommand(key, field, value));
+    this.hstrlen = (...args) => this.chain(new HStrLenCommand(...args));
+    this.hvals = (...args) => this.chain(new HValsCommand(...args));
+    this.incr = (...args) => this.chain(new IncrCommand(...args));
+    this.incrby = (...args) => this.chain(new IncrByCommand(...args));
+    this.incrbyfloat = (...args) => this.chain(new IncrByFloatCommand(...args));
+    this.keys = (...args) => this.chain(new KeysCommand(...args));
+    this.lindex = (...args) => this.chain(new LIndexCommand(...args));
+    this.linsert = (key, direction, pivot, value) => this.chain(new LInsertCommand(key, direction, pivot, value));
+    this.llen = (...args) => this.chain(new LLenCommand(...args));
+    this.lpop = (...args) => this.chain(new LPopCommand(...args));
+    this.lpush = (key, ...elements) => this.chain(new LPushCommand(key, ...elements));
+    this.lpushx = (key, ...elements) => this.chain(new LPushXCommand(key, ...elements));
+    this.lrange = (...args) => this.chain(new LRangeCommand(...args));
+    this.lrem = (key, count, value) => this.chain(new LRemCommand(key, count, value));
+    this.lset = (key, value, index) => this.chain(new LSetCommand(key, value, index));
+    this.ltrim = (...args) => this.chain(new LTrimCommand(...args));
+    this.mget = (...args) => this.chain(new MGetCommand(...args));
+    this.mset = (kv) => this.chain(new MSetCommand(kv));
+    this.msetnx = (kv) => this.chain(new MSetNXCommand(kv));
+    this.persist = (...args) => this.chain(new PersistCommand(...args));
+    this.pexpire = (...args) => this.chain(new PExpireCommand(...args));
+    this.pexpireat = (...args) => this.chain(new PExpireAtCommand(...args));
+    this.ping = (...args) => this.chain(new PingCommand(...args));
+    this.psetex = (key, ttl, value) => this.chain(new PSetEXCommand(key, ttl, value));
+    this.pttl = (...args) => this.chain(new PTtlCommand(...args));
+    this.randomkey = () => this.chain(new RandomKeyCommand());
+    this.rename = (...args) => this.chain(new RenameCommand(...args));
+    this.renamenx = (...args) => this.chain(new RenameNXCommand(...args));
+    this.rpop = (...args) => this.chain(new RPopCommand(...args));
+    this.rpush = (key, ...elements) => this.chain(new RPushCommand(key, ...elements));
+    this.rpushx = (key, ...elements) => this.chain(new RPushXCommand(key, ...elements));
+    this.sadd = (key, ...members) => this.chain(new SAddCommand(key, ...members));
+    this.scan = (...args) => this.chain(new ScanCommand(...args));
+    this.scard = (...args) => this.chain(new SCardCommand(...args));
+    this.sdiff = (...args) => this.chain(new SDiffCommand(...args));
+    this.sdiffstore = (...args) => this.chain(new SDiffStoreCommand(...args));
+    this.set = (key, value, opts) => this.chain(new SetCommand(key, value, opts));
+    this.setbit = (...args) => this.chain(new SetBitCommand(...args));
+    this.setex = (key, ttl, value) => this.chain(new SetExCommand(key, ttl, value));
+    this.setnx = (key, value) => this.chain(new SetNxCommand(key, value));
+    this.setrange = (...args) => this.chain(new SetRangeCommand(...args));
+    this.sinter = (...args) => this.chain(new SInterCommand(...args));
+    this.sinterstore = (...args) => this.chain(new SInterStoreCommand(...args));
+    this.sismember = (key, member) => this.chain(new SIsMemberCommand(key, member));
+    this.smembers = (...args) => this.chain(new SMembersCommand(...args));
+    this.smove = (source, destination, member) => this.chain(new SMoveCommand(source, destination, member));
+    this.spop = (...args) => this.chain(new SPopCommand(...args));
+    this.srandmember = (...args) => this.chain(new SRandMemberCommand(...args));
+    this.srem = (key, ...members) => this.chain(new SRemCommand(key, ...members));
+    this.sscan = (...args) => this.chain(new SScanCommand(...args));
+    this.strlen = (...args) => this.chain(new StrLenCommand(...args));
+    this.sunion = (...args) => this.chain(new SUnionCommand(...args));
+    this.sunionstore = (...args) => this.chain(new SUnionStoreCommand(...args));
+    this.time = () => this.chain(new TimeCommand());
+    this.touch = (...args) => this.chain(new TouchCommand(...args));
+    this.ttl = (...args) => this.chain(new TtlCommand(...args));
+    this.type = (...args) => this.chain(new TypeCommand(...args));
+    this.unlink = (...args) => this.chain(new UnlinkCommand(...args));
+    this.zadd = (...args) => {
+      if ("score" in args[1]) {
+        return this.chain(new ZAddCommand(args[0], args[1], ...args.slice(2)));
+      }
+      return this.chain(new ZAddCommand(args[0], args[1], ...args.slice(2)));
+    };
+    this.zcard = (...args) => this.chain(new ZCardCommand(...args));
+    this.zcount = (...args) => this.chain(new ZCountCommand(...args));
+    this.zincrby = (key, increment, member) => this.chain(new ZIncrByComand(key, increment, member));
+    this.zinterstore = (...args) => this.chain(new ZInterStoreCommand(...args));
+    this.zlexcount = (...args) => this.chain(new ZLexCountCommand(...args));
+    this.zpopmax = (...args) => this.chain(new ZPopMaxCommand(...args));
+    this.zpopmin = (...args) => this.chain(new ZPopMinCommand(...args));
+    this.zrange = (...args) => this.chain(new ZRangeCommand(...args));
+    this.zrank = (key, member) => this.chain(new ZRankCommand(key, member));
+    this.zrem = (key, ...members) => this.chain(new ZRemCommand(key, ...members));
+    this.zremrangebylex = (...args) => this.chain(new ZRemRangeByLexCommand(...args));
+    this.zremrangebyrank = (...args) => this.chain(new ZRemRangeByRankCommand(...args));
+    this.zremrangebyscore = (...args) => this.chain(new ZRemRangeByScoreCommand(...args));
+    this.zrevrank = (key, member) => this.chain(new ZRevRankCommand(key, member));
+    this.zscan = (...args) => this.chain(new ZScanCommand(...args));
+    this.zscore = (key, member) => this.chain(new ZScoreCommand(key, member));
+    this.zunionstore = (...args) => this.chain(new ZUnionStoreCommand(...args));
+    this.client = client;
+    this.commands = [];
+  }
+  chain(command) {
+    this.commands.push(command);
+    return this;
+  }
+};
+
+// pkg/redis.ts
+var Redis = class {
+  constructor(client) {
+    this.pipeline = () => new Pipeline(this.client);
+    this.append = (...args) => new AppendCommand(...args).exec(this.client);
+    this.bitcount = (...args) => new BitCountCommand(...args).exec(this.client);
+    this.bitop = (op, destinationKey, sourceKey, ...sourceKeys) => new BitOpCommand(op, destinationKey, sourceKey, ...sourceKeys).exec(this.client);
+    this.bitpos = (...args) => new BitPosCommand(...args).exec(this.client);
+    this.dbsize = () => new DBSizeCommand().exec(this.client);
+    this.decr = (...args) => new DecrCommand(...args).exec(this.client);
+    this.decrby = (...args) => new DecrByCommand(...args).exec(this.client);
+    this.del = (...args) => new DelCommand(...args).exec(this.client);
+    this.echo = (...args) => new EchoCommand(...args).exec(this.client);
+    this.exists = (...args) => new ExistsCommand(...args).exec(this.client);
+    this.expire = (...args) => new ExpireCommand(...args).exec(this.client);
+    this.expireat = (...args) => new ExpireAtCommand(...args).exec(this.client);
+    this.flushall = (...args) => new FlushAllCommand(...args).exec(this.client);
+    this.flushdb = (...args) => new FlushDBCommand(...args).exec(this.client);
+    this.get = (...args) => new GetCommand(...args).exec(this.client);
+    this.getbit = (...args) => new GetBitCommand(...args).exec(this.client);
+    this.getrange = (...args) => new GetRangeCommand(...args).exec(this.client);
+    this.getset = (key, value) => new GetSetCommand(key, value).exec(this.client);
+    this.hdel = (...args) => new HDelCommand(...args).exec(this.client);
+    this.hexists = (...args) => new HExistsCommand(...args).exec(this.client);
+    this.hget = (...args) => new HGetCommand(...args).exec(this.client);
+    this.hgetall = (...args) => new HGetAllCommand(...args).exec(this.client);
+    this.hincrby = (...args) => new HIncrByCommand(...args).exec(this.client);
+    this.hincrbyfloat = (...args) => new HIncrByFloatCommand(...args).exec(this.client);
+    this.hkeys = (...args) => new HKeysCommand(...args).exec(this.client);
+    this.hlen = (...args) => new HLenCommand(...args).exec(this.client);
+    this.hmget = (...args) => new HMGetCommand(...args).exec(this.client);
+    this.hmset = (key, kv) => new HMSetCommand(key, kv).exec(this.client);
+    this.hscan = (...args) => new HScanCommand(...args).exec(this.client);
+    this.hset = (key, kv) => new HSetCommand(key, kv).exec(this.client);
+    this.hsetnx = (key, field, value) => new HSetNXCommand(key, field, value).exec(this.client);
+    this.hstrlen = (...args) => new HStrLenCommand(...args).exec(this.client);
+    this.hvals = (...args) => new HValsCommand(...args).exec(this.client);
+    this.incr = (...args) => new IncrCommand(...args).exec(this.client);
+    this.incrby = (...args) => new IncrByCommand(...args).exec(this.client);
+    this.incrbyfloat = (...args) => new IncrByFloatCommand(...args).exec(this.client);
+    this.keys = (...args) => new KeysCommand(...args).exec(this.client);
+    this.lindex = (...args) => new LIndexCommand(...args).exec(this.client);
+    this.linsert = (key, direction, pivot, value) => new LInsertCommand(key, direction, pivot, value).exec(this.client);
+    this.llen = (...args) => new LLenCommand(...args).exec(this.client);
+    this.lpop = (...args) => new LPopCommand(...args).exec(this.client);
+    this.lpush = (key, ...elements) => new LPushCommand(key, ...elements).exec(this.client);
+    this.lpushx = (key, ...elements) => new LPushXCommand(key, ...elements).exec(this.client);
+    this.lrange = (...args) => new LRangeCommand(...args).exec(this.client);
+    this.lrem = (key, count, value) => new LRemCommand(key, count, value).exec(this.client);
+    this.lset = (key, value, index) => new LSetCommand(key, value, index).exec(this.client);
+    this.ltrim = (...args) => new LTrimCommand(...args).exec(this.client);
+    this.mget = (...args) => new MGetCommand(...args).exec(this.client);
+    this.mset = (kv) => new MSetCommand(kv).exec(this.client);
+    this.msetnx = (kv) => new MSetNXCommand(kv).exec(this.client);
+    this.persist = (...args) => new PersistCommand(...args).exec(this.client);
+    this.pexpire = (...args) => new PExpireCommand(...args).exec(this.client);
+    this.pexpireat = (...args) => new PExpireAtCommand(...args).exec(this.client);
+    this.ping = (...args) => new PingCommand(...args).exec(this.client);
+    this.psetex = (key, ttl, value) => new PSetEXCommand(key, ttl, value).exec(this.client);
+    this.pttl = (...args) => new PTtlCommand(...args).exec(this.client);
+    this.randomkey = () => new RandomKeyCommand().exec(this.client);
+    this.rename = (...args) => new RenameCommand(...args).exec(this.client);
+    this.renamenx = (...args) => new RenameNXCommand(...args).exec(this.client);
+    this.rpop = (...args) => new RPopCommand(...args).exec(this.client);
+    this.rpush = (key, ...elements) => new RPushCommand(key, ...elements).exec(this.client);
+    this.rpushx = (key, ...elements) => new RPushXCommand(key, ...elements).exec(this.client);
+    this.sadd = (key, ...members) => new SAddCommand(key, ...members).exec(this.client);
+    this.scan = (...args) => new ScanCommand(...args).exec(this.client);
+    this.scard = (...args) => new SCardCommand(...args).exec(this.client);
+    this.sdiff = (...args) => new SDiffCommand(...args).exec(this.client);
+    this.sdiffstore = (...args) => new SDiffStoreCommand(...args).exec(this.client);
+    this.set = (key, value, opts) => new SetCommand(key, value, opts).exec(this.client);
+    this.setbit = (...args) => new SetBitCommand(...args).exec(this.client);
+    this.setex = (key, ttl, value) => new SetExCommand(key, ttl, value).exec(this.client);
+    this.setnx = (key, value) => new SetNxCommand(key, value).exec(this.client);
+    this.setrange = (...args) => new SetRangeCommand(...args).exec(this.client);
+    this.sinter = (...args) => new SInterCommand(...args).exec(this.client);
+    this.sinterstore = (...args) => new SInterStoreCommand(...args).exec(this.client);
+    this.sismember = (key, member) => new SIsMemberCommand(key, member).exec(this.client);
+    this.smembers = (...args) => new SMembersCommand(...args).exec(this.client);
+    this.smove = (source, destination, member) => new SMoveCommand(source, destination, member).exec(this.client);
+    this.spop = (...args) => new SPopCommand(...args).exec(this.client);
+    this.srandmember = (...args) => new SRandMemberCommand(...args).exec(this.client);
+    this.srem = (key, ...members) => new SRemCommand(key, ...members).exec(this.client);
+    this.sscan = (...args) => new SScanCommand(...args).exec(this.client);
+    this.strlen = (...args) => new StrLenCommand(...args).exec(this.client);
+    this.sunion = (...args) => new SUnionCommand(...args).exec(this.client);
+    this.sunionstore = (...args) => new SUnionStoreCommand(...args).exec(this.client);
+    this.time = () => new TimeCommand().exec(this.client);
+    this.touch = (...args) => new TouchCommand(...args).exec(this.client);
+    this.ttl = (...args) => new TtlCommand(...args).exec(this.client);
+    this.type = (...args) => new TypeCommand(...args).exec(this.client);
+    this.unlink = (...args) => new UnlinkCommand(...args).exec(this.client);
+    this.zadd = (...args) => {
+      if ("score" in args[1]) {
+        return new ZAddCommand(args[0], args[1], ...args.slice(2)).exec(this.client);
+      }
+      return new ZAddCommand(args[0], args[1], ...args.slice(2)).exec(this.client);
+    };
+    this.zcard = (...args) => new ZCardCommand(...args).exec(this.client);
+    this.zcount = (...args) => new ZCountCommand(...args).exec(this.client);
+    this.zincrby = (key, increment, member) => new ZIncrByComand(key, increment, member).exec(this.client);
+    this.zinterstore = (...args) => new ZInterStoreCommand(...args).exec(this.client);
+    this.zlexcount = (...args) => new ZLexCountCommand(...args).exec(this.client);
+    this.zpopmax = (...args) => new ZPopMaxCommand(...args).exec(this.client);
+    this.zpopmin = (...args) => new ZPopMinCommand(...args).exec(this.client);
+    this.zrange = (...args) => new ZRangeCommand(...args).exec(this.client);
+    this.zrank = (key, member) => new ZRankCommand(key, member).exec(this.client);
+    this.zrem = (key, ...members) => new ZRemCommand(key, ...members).exec(this.client);
+    this.zremrangebylex = (...args) => new ZRemRangeByLexCommand(...args).exec(this.client);
+    this.zremrangebyrank = (...args) => new ZRemRangeByRankCommand(...args).exec(this.client);
+    this.zremrangebyscore = (...args) => new ZRemRangeByScoreCommand(...args).exec(this.client);
+    this.zrevrank = (key, member) => new ZRevRankCommand(key, member).exec(this.client);
+    this.zscan = (...args) => new ZScanCommand(...args).exec(this.client);
+    this.zscore = (key, member) => new ZScoreCommand(key, member).exec(this.client);
+    this.zunionstore = (...args) => new ZUnionStoreCommand(...args).exec(this.client);
+    this.client = client;
+  }
+};
+
+export {
+  Redis
+};

package/{chunk-ZIB6XPPC.mjs → chunk-HGM7M7CJ.mjs}

@@ -4,13 +4,17 @@ import {
 
 // pkg/util.ts
 function parseRecursive(obj) {
-  return Array.isArray(obj) ? obj.map((o) => {
+  const parsed = Array.isArray(obj) ? obj.map((o) => {
     try {
       return parseRecursive(o);
     } catch {
       return o;
     }
   }) : JSON.parse(obj);
+  if (typeof parsed === "number" && parsed.toString() != obj) {
+    return obj;
+  }
+  return parsed;
 }
 function parseResponse(result) {
   try {
@@ -20,7 +24,7 @@ function parseResponse(result) {
   }
 }
 
-// pkg/command.ts
+// pkg/commands/command.ts
 var Command = class {
   constructor(command, opts) {
     var _a;
@@ -300,8 +304,8 @@ var HScanCommand = class extends Command {
 
 // pkg/commands/hset.ts
 var HSetCommand = class extends Command {
-  constructor(key, field, value) {
-    super(["hset", key, field, value]);
+  constructor(key, kv) {
+    super(["hset", key, ...Object.entries(kv).flatMap(([field, value]) => [field, value])]);
   }
 };
 
@@ -951,6 +955,7 @@ var ZUnionStoreCommand = class extends Command {
 };
 
 export {
+  Command,
   AppendCommand,
   BitCountCommand,
   BitOpCommand,

package/{chunk-6GEVIAL6.mjs → chunk-WPH7MAB2.mjs}

@@ -1,6 +1,6 @@
 import {
   Redis
-} from "./chunk-Y5TC4HX2.mjs";
+} from "./chunk-2EIGUPGW.mjs";
 import {
   HttpClient
 } from "./chunk-HIDCSH5S.mjs";