![\"TypeScript](\"resources/ts-screenshot.png\")
\n\n# Versions\n\n| Version | Branch | Node.js Version | Redis Version |\n| -------------- | ------ | --------------- | --------------- |\n| 5.x.x (latest) | main | >= 12 | 2.6.12 ~ latest |\n| 4.x.x | v4 | >= 8 | 2.6.12 ~ 7 |\n\nRefer to [CHANGELOG.md](CHANGELOG.md) for features and bug fixes introduced in v5.\n\n???? [Upgrading from v4 to v5](https://github.com/redis/ioredis/wiki/Upgrading-from-v4-to-v5)\n\n# Links\n\n- [API Documentation](https://redis.github.io/ioredis/) ([Redis](https://redis.github.io/ioredis/classes/Redis.html), [Cluster](https://redis.github.io/ioredis/classes/Cluster.html))\n- [Changelog](CHANGELOG.md)\n\nOtherwise, `ready` will be emitted immediately right after the `connect` event. |\n| error | emits when an error occurs while connecting.
However, ioredis emits all `error` events silently (only emits when there's at least one listener) so that your application won't crash if you're not listening to the `error` event.
When `redis.connect()` is explicitly called the error will also be rejected from the returned promise, in addition to emitting it. If `redis.connect()` is not called explicitly and `lazyConnect` is true, ioredis will try to connect automatically on the first command and emit the `error` event silently. |\n| close | emits when an established Redis server connection has closed. |\n| reconnecting | emits after `close` when a reconnection will be made. The argument of the event is the time (in ms) before reconnecting. |\n| end | emits after `close` when no more reconnections will be made, or the connection is failed to establish. |\n| wait | emits when `lazyConnect` is set and will wait for the first command to be called before connecting. |\n\nYou can also check out the `Redis#status` property to get the current connection status.\n\nBesides the above connection events, there are several other custom events:\n\n| Event | Description |\n| :----- | :------------------------------------------------------------------ |\n| select | emits when the database changed. The argument is the new db number. |\n\n## Offline Queue\n\nWhen a command can't be processed by Redis (being sent before the `ready` event), by default, it's added to the offline queue and will be\nexecuted when it can be processed. You can disable this feature by setting the `enableOfflineQueue`\noption to `false`:\n\n```javascript\nconst redis = new Redis({ enableOfflineQueue: false });\n```\n\n## TLS Options\n\nRedis doesn't support TLS natively, however if the redis server you want to connect to is hosted behind a TLS proxy (e.g. [stunnel](https://www.stunnel.org/)) or is offered by a PaaS service that supports TLS connection (e.g. [Redis.com](https://redis.com/)), you can set the `tls` option:\n\n```javascript\nconst redis = new Redis({\n host: \"localhost\",\n tls: {\n // Refer to `tls.connect()` section in\n // https://nodejs.org/api/tls.html\n // for all supported options\n ca: fs.readFileSync(\"cert.pem\"),\n },\n});\n```\n\nAlternatively, specify the connection through a [`rediss://` URL](https://www.iana.org/assignments/uri-schemes/prov/rediss).\n\n```javascript\nconst redis = new Redis(\"rediss://redis.my-service.com\");\n```\n\nIf you do not want to use a connection string, you can also specify an empty `tls: {}` object:\n\n```javascript\nconst redis = new Redis({\n host: \"redis.my-service.com\",\n tls: {},\n});\n```\n\n### TLS Profiles\n\n> **Warning**\n> TLS profiles described in this section are going to be deprecated in the next major version. Please provide TLS options explicitly.\n\nTo make it easier to configure we provide a few pre-configured TLS profiles that can be specified by setting the `tls` option to the profile's name or specifying a `tls.profile` option in case you need to customize some values of the profile.\n\nProfiles:\n\n- `RedisCloudFixed`: Contains the CA for [Redis.com](https://redis.com/) Cloud fixed subscriptions\n- `RedisCloudFlexible`: Contains the CA for [Redis.com](https://redis.com/) Cloud flexible subscriptions\n\n```javascript\nconst redis = new Redis({\n host: \"localhost\",\n tls: \"RedisCloudFixed\",\n});\n\nconst redisWithClientCertificate = new Redis({\n host: \"localhost\",\n tls: {\n profile: \"RedisCloudFixed\",\n key: \"123\",\n },\n});\n```\n\n
\n\n## Sentinel\n\nioredis supports Sentinel out of the box. It works transparently as all features that work when\nyou connect to a single node also work when you connect to a sentinel group. Make sure to run Redis >= 2.8.12 if you want to use this feature. Sentinels have a default port of 26379.\n\nTo connect using Sentinel, use:\n\n```javascript\nconst redis = new Redis({\n sentinels: [\n { host: \"localhost\", port: 26379 },\n { host: \"localhost\", port: 26380 },\n ],\n name: \"mymaster\",\n});\n\nredis.set(\"foo\", \"bar\");\n```\n\nThe arguments passed to the constructor are different from the ones you use to connect to a single node, where:\n\n- `name` identifies a group of Redis instances composed of a master and one or more slaves (`mymaster` in the example);\n- `sentinelPassword` (optional) password for Sentinel instances.\n- `sentinels` are a list of sentinels to connect to. The list does not need to enumerate all your sentinel instances, but a few so that if one is down the client will try the next one.\n- `role` (optional) with a value of `slave` will return a random slave from the Sentinel group.\n- `preferredSlaves` (optional) can be used to prefer a particular slave or set of slaves based on priority. It accepts a function or array.\n- `enableTLSForSentinelMode` (optional) set to true if connecting to sentinel instances that are encrypted\n\nioredis **guarantees** that the node you connected to is always a master even after a failover. When a failover happens, instead of trying to reconnect to the failed node (which will be demoted to slave when it's available again), ioredis will ask sentinels for the new master node and connect to it. All commands sent during the failover are queued and will be executed when the new connection is established so that none of the commands will be lost.\n\nIt's possible to connect to a slave instead of a master by specifying the option `role` with the value of `slave` and ioredis will try to connect to a random slave of the specified master, with the guarantee that the connected node is always a slave. If the current node is promoted to master due to a failover, ioredis will disconnect from it and ask the sentinels for another slave node to connect to.\n\nIf you specify the option `preferredSlaves` along with `role: 'slave'` ioredis will attempt to use this value when selecting the slave from the pool of available slaves. The value of `preferredSlaves` should either be a function that accepts an array of available slaves and returns a single result, or an array of slave values priorities by the lowest `prio` value first with a default value of `1`.\n\n```javascript\n// available slaves format\nconst availableSlaves = [{ ip: \"127.0.0.1\", port: \"31231\", flags: \"slave\" }];\n\n// preferredSlaves array format\nlet preferredSlaves = [\n { ip: \"127.0.0.1\", port: \"31231\", prio: 1 },\n { ip: \"127.0.0.1\", port: \"31232\", prio: 2 },\n];\n\n// preferredSlaves function format\npreferredSlaves = function (availableSlaves) {\n for (let i = 0; i < availableSlaves.length; i++) {\n const slave = availableSlaves[i];\n if (slave.ip === \"127.0.0.1\") {\n if (slave.port === \"31234\") {\n return slave;\n }\n }\n }\n // if no preferred slaves are available a random one is used\n return false;\n};\n\nconst redis = new Redis({\n sentinels: [\n { host: \"127.0.0.1\", port: 26379 },\n { host: \"127.0.0.1\", port: 26380 },\n ],\n name: \"mymaster\",\n role: \"slave\",\n preferredSlaves: preferredSlaves,\n});\n```\n\nBesides the `retryStrategy` option, there's also a `sentinelRetryStrategy` in Sentinel mode which will be invoked when all the sentinel nodes are unreachable during connecting. If `sentinelRetryStrategy` returns a valid delay time, ioredis will try to reconnect from scratch. The default value of `sentinelRetryStrategy` is:\n\n```javascript\nfunction (times) {\n const delay = Math.min(times * 10, 1000);\n return delay;\n}\n```\n\n## Cluster\n\nRedis Cluster provides a way to run a Redis installation where data is automatically sharded across multiple Redis nodes.\nYou can connect to a Redis Cluster like this:\n\n```javascript\nconst Redis = require(\"ioredis\");\n\nconst cluster = new Redis.Cluster([\n {\n port: 6380,\n host: \"127.0.0.1\",\n },\n {\n port: 6381,\n host: \"127.0.0.1\",\n },\n]);\n\ncluster.set(\"foo\", \"bar\");\ncluster.get(\"foo\", (err, res) => {\n // res === 'bar'\n});\n```\n\n`Cluster` constructor accepts two arguments, where:\n\n0. The first argument is a list of nodes of the cluster you want to connect to.\n Just like Sentinel, the list does not need to enumerate all your cluster nodes,\n but a few so that if one is unreachable the client will try the next one, and the client will discover other nodes automatically when at least one node is connected.\n1. The second argument is the options, where:\n\n - `clusterRetryStrategy`: When none of the startup nodes are reachable, `clusterRetryStrategy` will be invoked. When a number is returned,\n ioredis will try to reconnect to the startup nodes from scratch after the specified delay (in ms). Otherwise, an error of \"None of startup nodes is available\" will be returned.\n The default value of this option is:\n\n ```javascript\n function (times) {\n const delay = Math.min(100 + times * 2, 2000);\n return delay;\n }\n ```\n\n It's possible to modify the `startupNodes` property in order to switch to another set of nodes here:\n\n ```javascript\n function (times) {\n this.startupNodes = [{ port: 6790, host: '127.0.0.1' }];\n return Math.min(100 + times * 2, 2000);\n }\n ```\n\n - `dnsLookup`: Alternative DNS lookup function (`dns.lookup()` is used by default). It may be useful to override this in special cases, such as when AWS ElastiCache used with TLS enabled.\n - `enableOfflineQueue`: Similar to the `enableOfflineQueue` option of `Redis` class.\n - `enableReadyCheck`: When enabled, \"ready\" event will only be emitted when `CLUSTER INFO` command\n reporting the cluster is ready for handling commands. Otherwise, it will be emitted immediately after \"connect\" is emitted.\n - `scaleReads`: Config where to send the read queries. See below for more details.\n - `maxRedirections`: When a cluster related error (e.g. `MOVED`, `ASK` and `CLUSTERDOWN` etc.) is received, the client will redirect the\n command to another node. This option limits the max redirections allowed when sending a command. The default value is `16`.\n - `retryDelayOnFailover`: If the target node is disconnected when sending a command,\n ioredis will retry after the specified delay. The default value is `100`. You should make sure `retryDelayOnFailover * maxRedirections > cluster-node-timeout`\n to insure that no command will fail during a failover.\n - `retryDelayOnClusterDown`: When a cluster is down, all commands will be rejected with the error of `CLUSTERDOWN`. If this option is a number (by default, it is `100`), the client\n will resend the commands after the specified time (in ms).\n - `retryDelayOnTryAgain`: If this option is a number (by default, it is `100`), the client\n will resend the commands rejected with `TRYAGAIN` error after the specified time (in ms).\n - `retryDelayOnMoved`: By default, this value is `0` (in ms), which means when a `MOVED` error is received, the client will resend\n the command instantly to the node returned together with the `MOVED` error. However, sometimes it takes time for a cluster to become\n state stabilized after a failover, so adding a delay before resending can prevent a ping pong effect.\n - `redisOptions`: Default options passed to the constructor of `Redis` when connecting to a node.\n - `slotsRefreshTimeout`: Milliseconds before a timeout occurs while refreshing slots from the cluster (default `1000`).\n - `slotsRefreshInterval`: Milliseconds between every automatic slots refresh (by default, it is disabled).\n\n### Read-Write Splitting\n\nA typical redis cluster contains three or more masters and several slaves for each master. It's possible to scale out redis cluster by sending read queries to slaves and write queries to masters by setting the `scaleReads` option.\n\n`scaleReads` is \"master\" by default, which means ioredis will never send any queries to slaves. There are other three available options:\n\n1. \"all\": Send write queries to masters and read queries to masters or slaves randomly.\n2. \"slave\": Send write queries to masters and read queries to slaves.\n3. a custom `function(nodes, command): node`: Will choose the custom function to select to which node to send read queries (write queries keep being sent to master). The first node in `nodes` is always the master serving the relevant slots. If the function returns an array of nodes, a random node of that list will be selected.\n\nFor example:\n\n```javascript\nconst cluster = new Redis.Cluster(\n [\n /* nodes */\n ],\n {\n scaleReads: \"slave\",\n }\n);\ncluster.set(\"foo\", \"bar\"); // This query will be sent to one of the masters.\ncluster.get(\"foo\", (err, res) => {\n // This query will be sent to one of the slaves.\n});\n```\n\n**NB** In the code snippet above, the `res` may not be equal to \"bar\" because of the lag of replication between the master and slaves.\n\n### Running Commands to Multiple Nodes\n\nEvery command will be sent to exactly one node. For commands containing keys, (e.g. `GET`, `SET` and `HGETALL`), ioredis sends them to the node that serving the keys, and for other commands not containing keys, (e.g. `INFO`, `KEYS` and `FLUSHDB`), ioredis sends them to a random node.\n\nSometimes you may want to send a command to multiple nodes (masters or slaves) of the cluster, you can get the nodes via `Cluster#nodes()` method.\n\n`Cluster#nodes()` accepts a parameter role, which can be \"master\", \"slave\" and \"all\" (default), and returns an array of `Redis` instance. For example:\n\n```javascript\n// Send `FLUSHDB` command to all slaves:\nconst slaves = cluster.nodes(\"slave\");\nPromise.all(slaves.map((node) => node.flushdb()));\n\n// Get keys of all the masters:\nconst masters = cluster.nodes(\"master\");\nPromise.all(\n masters\n .map((node) => node.keys())\n .then((keys) => {\n // keys: [['key1', 'key2'], ['key3', 'key4']]\n })\n);\n```\n\n### NAT Mapping\n\nSometimes the cluster is hosted within a internal network that can only be accessed via a NAT (Network Address Translation) instance. See [Accessing ElastiCache from outside AWS](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/accessing-elasticache.html) as an example.\n\nYou can specify nat mapping rules via `natMap` option:\n\n```javascript\nconst cluster = new Redis.Cluster(\n [\n {\n host: \"203.0.113.73\",\n port: 30001,\n },\n ],\n {\n natMap: {\n \"10.0.1.230:30001\": { host: \"203.0.113.73\", port: 30001 },\n \"10.0.1.231:30001\": { host: \"203.0.113.73\", port: 30002 },\n \"10.0.1.232:30001\": { host: \"203.0.113.73\", port: 30003 },\n },\n }\n);\n```\n\nOr you can specify this parameter through function:\n```javascript\nconst cluster = new Redis.Cluster(\n [\n {\n host: \"203.0.113.73\",\n port: 30001,\n },\n ],\n {\n natMap: (key) => {\n if(key.includes('30001')) {\n return { host: \"203.0.113.73\", port: 30001 };\n }\n\n return null;\n },\n }\n);\n```\n\nThis option is also useful when the cluster is running inside a Docker container.\nAlso it works for Clusters in cloud infrastructure where cluster nodes connected through dedicated subnet.\n\nSpecifying through may be useful if you don't know concrete internal host and know only node port.\n\n### Transaction and Pipeline in Cluster Mode\n\nAlmost all features that are supported by `Redis` are also supported by `Redis.Cluster`, e.g. custom commands, transaction and pipeline.\nHowever there are some differences when using transaction and pipeline in Cluster mode:\n\n0. All keys in a pipeline should belong to slots served by the same node, since ioredis sends all commands in a pipeline to the same node.\n1. You can't use `multi` without pipeline (aka `cluster.multi({ pipeline: false })`). This is because when you call `cluster.multi({ pipeline: false })`, ioredis doesn't know which node the `multi` command should be sent to.\n\nWhen any commands in a pipeline receives a `MOVED` or `ASK` error, ioredis will resend the whole pipeline to the specified node automatically if all of the following conditions are satisfied:\n\n0. All errors received in the pipeline are the same. For example, we won't resend the pipeline if we got two `MOVED` errors pointing to different nodes.\n1. All commands executed successfully are readonly commands. This makes sure that resending the pipeline won't have side effects.\n\n### Pub/Sub\n\nPub/Sub in cluster mode works exactly as the same as in standalone mode. Internally, when a node of the cluster receives a message, it will broadcast the message to the other nodes. ioredis makes sure that each message will only be received once by strictly subscribing one node at the same time.\n\n```javascript\nconst nodes = [\n /* nodes */\n];\nconst pub = new Redis.Cluster(nodes);\nconst sub = new Redis.Cluster(nodes);\nsub.on(\"message\", (channel, message) => {\n console.log(channel, message);\n});\n\nsub.subscribe(\"news\", () => {\n pub.publish(\"news\", \"highlights\");\n});\n```\n\n### Sharded Pub/Sub\n\nFor sharded Pub/Sub, use the `spublish` and `ssubscribe` commands instead of the traditional `publish` and `subscribe`. With the old commands, the Redis cluster handles message propagation behind the scenes, allowing you to publish or subscribe to any node without considering sharding. However, this approach has scalability limitations that are addressed with sharded Pub/Sub. Here’s what you need to know:\n\n1. Instead of a single subscriber connection, there is now one subscriber connection per shard. Because of the potential overhead, you can enable or disable the use of the cluster subscriber group with the `shardedSubscribers` option. By default, this option is set to `false`, meaning sharded subscriptions are disabled. You should enable this option when establishing your cluster connection before using `ssubscribe`.\n2. All channel names that you pass to a single `ssubscribe` need to map to the same hash slot. You can call `ssubscribe` multiple times on the same cluster client instance to subscribe to channels across slots. The cluster's subscriber group takes care of forwarding the `ssubscribe` command to the shard that is responsible for the channels.\n\nThe following basic example shows you how to use sharded Pub/Sub:\n\n```javascript\nconst cluster: Cluster = new Cluster([{host: host, port: port}], {shardedSubscribers: true});\n\n//Register the callback\ncluster.on(\"smessage\", (channel, message) => {\n console.log(message);\n});\n\n\n//Subscribe to the channels on the same slot\ncluster.ssubscribe(\"channel{my}:1\", \"channel{my}:2\").then( ( count: number ) => {\n console.log(count);\n}).catch( (err) => {\n console.log(err);\n});\n\n//Publish a message\ncluster.spublish(\"channel{my}:1\", \"This is a test message to my first channel.\").then((value: number) => {\n console.log(\"Published a message to channel{my}:1\");\n});\n```\n\n\n### Events\n\n| Event | Description |\n| :----------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| connect | emits when a connection is established to the Redis server. |\n| ready | emits when `CLUSTER INFO` reporting the cluster is able to receive commands (if `enableReadyCheck` is `true`) or immediately after `connect` event (if `enableReadyCheck` is false). |\n| error | emits when an error occurs while connecting with a property of `lastNodeError` representing the last node error received. This event is emitted silently (only emitting if there's at least one listener). |\n| close | emits when an established Redis server connection has closed. |\n| reconnecting | emits after `close` when a reconnection will be made. The argument of the event is the time (in ms) before reconnecting. |\n| end | emits after `close` when no more reconnections will be made. |\n| +node | emits when a new node is connected. |\n| -node | emits when a node is disconnected. |\n| node error | emits when an error occurs when connecting to a node. The second argument indicates the address of the node. |\n\n### Password\n\nSetting the `password` option to access password-protected clusters:\n\n```javascript\nconst Redis = require(\"ioredis\");\nconst cluster = new Redis.Cluster(nodes, {\n redisOptions: {\n password: \"your-cluster-password\",\n },\n});\n```\n\nIf some of nodes in the cluster using a different password, you should specify them in the first parameter:\n\n```javascript\nconst Redis = require(\"ioredis\");\nconst cluster = new Redis.Cluster(\n [\n // Use password \"password-for-30001\" for 30001\n { port: 30001, password: \"password-for-30001\" },\n // Don't use password when accessing 30002\n { port: 30002, password: null },\n // Other nodes will use \"fallback-password\"\n ],\n {\n redisOptions: {\n password: \"fallback-password\",\n },\n }\n);\n```\n\n### Special Note: Aws Elasticache Clusters with TLS\n\nAWS ElastiCache for Redis (Clustered Mode) supports TLS encryption. If you use\nthis, you may encounter errors with invalid certificates. To resolve this\nissue, construct the `Cluster` with the `dnsLookup` option as follows:\n\n```javascript\nconst cluster = new Redis.Cluster(\n [\n {\n host: \"clustercfg.myCluster.abcdefg.xyz.cache.amazonaws.com\",\n port: 6379,\n },\n ],\n {\n dnsLookup: (address, callback) => callback(null, address),\n redisOptions: {\n tls: {},\n },\n }\n);\n```\n\n
\n\n## Autopipelining\n\nIn standard mode, when you issue multiple commands, ioredis sends them to the server one by one. As described in Redis pipeline documentation, this is a suboptimal use of the network link, especially when such link is not very performant.\n\nThe TCP and network overhead negatively affects performance. Commands are stuck in the send queue until the previous ones are correctly delivered to the server. This is a problem known as Head-Of-Line blocking (HOL).\n\nioredis supports a feature called “auto pipelining”. It can be enabled by setting the option `enableAutoPipelining` to `true`. No other code change is necessary.\n\nIn auto pipelining mode, all commands issued during an event loop are enqueued in a pipeline automatically managed by ioredis. At the end of the iteration, the pipeline is executed and thus all commands are sent to the server at the same time.\n\nThis feature can dramatically improve throughput and avoids HOL blocking. In our benchmarks, the improvement was between 35% and 50%.\n\nWhile an automatic pipeline is executing, all new commands will be enqueued in a new pipeline which will be executed as soon as the previous finishes.\n\nWhen using Redis Cluster, one pipeline per node is created. Commands are assigned to pipelines according to which node serves the slot.\n\nA pipeline will thus contain commands using different slots but that ultimately are assigned to the same node.\n\nNote that the same slot limitation within a single command still holds, as it is a Redis limitation.\n\n### Example of Automatic Pipeline Enqueuing\n\nThis sample code uses ioredis with automatic pipeline enabled.\n\n```javascript\nconst Redis = require(\"./built\");\nconst http = require(\"http\");\n\nconst db = new Redis({ enableAutoPipelining: true });\n\nconst server = http.createServer((request, response) => {\n const key = new URL(request.url, \"https://localhost:3000/\").searchParams.get(\n \"key\"\n );\n\n db.get(key, (err, value) => {\n response.writeHead(200, { \"Content-Type\": \"text/plain\" });\n response.end(value);\n });\n});\n\nserver.listen(3000);\n```\n\nWhen Node receives requests, it schedules them to be processed in one or more iterations of the events loop.\n\nAll commands issued by requests processing during one iteration of the loop will be wrapped in a pipeline automatically created by ioredis.\n\nIn the example above, the pipeline will have the following contents:\n\n```\nGET key1\nGET key2\nGET key3\n...\nGET keyN\n```\n\nWhen all events in the current loop have been processed, the pipeline is executed and thus all commands are sent to the server at the same time.\n\nWhile waiting for pipeline response from Redis, Node will still be able to process requests. All commands issued by request handler will be enqueued in a new automatically created pipeline. This pipeline will not be sent to the server yet.\n\nAs soon as a previous automatic pipeline has received all responses from the server, the new pipeline is immediately sent without waiting for the events loop iteration to finish.\n\nThis approach increases the utilization of the network link, reduces the TCP overhead and idle times and therefore improves throughput.\n\n### Benchmarks\n\nHere's some of the results of our tests for a single node.\n\nEach iteration of the test runs 1000 random commands on the server.\n\n| | Samples | Result | Tolerance |\n| ------------------------- | ------- | ------------- | --------- |\n| default | 1000 | 174.62 op/sec | ± 0.45 % |\n| enableAutoPipelining=true | 1500 | 233.33 op/sec | ± 0.88 % |\n\nAnd here's the same test for a cluster of 3 masters and 3 replicas:\n\n| | Samples | Result | Tolerance |\n| ------------------------- | ------- | ------------- | --------- |\n| default | 1000 | 164.05 op/sec | ± 0.42 % |\n| enableAutoPipelining=true | 3000 | 235.31 op/sec | ± 0.94 % |\n\n# Error Handling\n\nAll the errors returned by the Redis server are instances of `ReplyError`, which can be accessed via `Redis`:\n\n```javascript\nconst Redis = require(\"ioredis\");\nconst redis = new Redis();\n// This command causes a reply error since the SET command requires two arguments.\nredis.set(\"foo\", (err) => {\n err instanceof Redis.ReplyError;\n});\n```\n\nThis is the error stack of the `ReplyError`:\n\n```\nReplyError: ERR wrong number of arguments for 'set' command\n at ReplyParser._parseResult (/app/node_modules/ioredis/lib/parsers/javascript.js:60:14)\n at ReplyParser.execute (/app/node_modules/ioredis/lib/parsers/javascript.js:178:20)\n at Socket.
![](\"https://opencollective.com/ioredis/contributors.svg?width=890&showBtn=false\")
\n\n# License\n\nMIT\n\n[](https://app.fossa.io/projects/git%2Bgithub.com%2Fluin%2Fioredis?ref=badge_large)\n","_attachments":{},"homepage":"https://github.com/luin/ioredis#readme","bugs":{"url":"https://github.com/luin/ioredis/issues"},"license":"MIT"}