ioredis 4.19.4 → 4.23.0

package/Changelog.md

@@ -1,3 +1,38 @@
+# [4.23.0](https://github.com/luin/ioredis/compare/v4.22.0...v4.23.0) (2021-02-25)
+
+
+### Features
+
+* add support for DNS SRV records ([#1283](https://github.com/luin/ioredis/issues/1283)) ([13a8614](https://github.com/luin/ioredis/commit/13a861432c2331ca25038f6b4eb060ba7b865b47))
+
+# [4.22.0](https://github.com/luin/ioredis/compare/v4.21.0...v4.22.0) (2021-02-06)
+
+
+### Features
+
+* add type support for scanStream ([#1287](https://github.com/luin/ioredis/issues/1287)) ([ad8ffa0](https://github.com/luin/ioredis/commit/ad8ffa06d68788de3c0703a70fe4c5b64ab4ac5b)), closes [#1279](https://github.com/luin/ioredis/issues/1279)
+
+# [4.21.0](https://github.com/luin/ioredis/compare/v4.20.0...v4.21.0) (2021-02-06)
+
+
+### Features
+
+* upgrade command list to Redis 6.2 ([#1286](https://github.com/luin/ioredis/issues/1286)) ([6ef9c6e](https://github.com/luin/ioredis/commit/6ef9c6e839dee8be021bcd43a57eaee56ec2f573))
+
+# [4.20.0](https://github.com/luin/ioredis/compare/v4.19.5...v4.20.0) (2021-02-05)
+
+
+### Features
+
+* support username in URI ([#1284](https://github.com/luin/ioredis/issues/1284)) ([cbc5421](https://github.com/luin/ioredis/commit/cbc54218e26bd20ac3725df2e70b810599112ef8))
+
+## [4.19.5](https://github.com/luin/ioredis/compare/v4.19.4...v4.19.5) (2021-01-14)
+
+
+### Bug Fixes
+
+* password contains colons ([#1274](https://github.com/luin/ioredis/issues/1274)) ([37c6daf](https://github.com/luin/ioredis/commit/37c6dafafd51d817a3dfe4b4ca722fb709a209e7))
+
 ## [4.19.4](https://github.com/luin/ioredis/compare/v4.19.3...v4.19.4) (2020-12-13)
 
 

package/README.md

@@ -25,13 +25,14 @@ used in the world's biggest online commerce company [Alibaba](http://www.alibaba
 4. Transparent key prefixing.
 5. Abstraction for Lua scripting, allowing you to define custom commands.
 6. Support for binary data.
-7. Support for TLS.
+7. Support for TLS 🔒.
 8. Support for offline queue and ready checking.
 9. Support for ES6 types, such as `Map` and `Set`.
-10. Support for GEO commands (Redis 3.2 Unstable).
-11. Sophisticated error handling strategy.
-12. Support for NAT mapping.
-13. Support for autopipelining
+10. Support for GEO commands 📍.
+11. Support for Redis ACL.
+12. Sophisticated error handling strategy.
+13. Support for NAT mapping.
+14. Support for autopipelining
 
 # Links
 
@@ -134,6 +135,13 @@ You can also specify connection options as a [`redis://` URL](http://www.iana.or
 ```javascript
 // Connect to 127.0.0.1:6380, db 4, using password "authpassword":
 new Redis("redis://:authpassword@127.0.0.1:6380/4");
+
+// Username can also be passed via URI.
+// It's worth to noticing that for compatibility reasons `allowUsernameInURI`
+// need to be provided, otherwise the username part will be ignored.
+new Redis(
+  "redis://username:authpassword@127.0.0.1:6380/4?allowUsernameInURI=true"
+);
 ```
 
 See [API Documentation](API.md#new_Redis) for all available options.
@@ -204,7 +212,7 @@ redis.getBuffer("foo", (err, result) => {
 ## Pipelining
 
 If you want to send a batch of commands (e.g. > 5), you can use pipelining to queue
-the commands in memory and then send them to Redis all at once. This way the performance improves by 50%~300% (See [benchmark section](#benchmark)).
+the commands in memory and then send them to Redis all at once. This way the performance improves by 50%~300% (See [benchmark section](#benchmarks)).
 
 `redis.pipeline()` creates a `Pipeline` instance. You can call any Redis
 commands on it just like the `Redis` instance. The commands are queued in memory
@@ -575,12 +583,15 @@ stream.on("end", () => {
 });
 ```
 
-`scanStream` accepts an option, with which you can specify the `MATCH` pattern and the `COUNT` argument:
+`scanStream` accepts an option, with which you can specify the `MATCH` pattern, the `TYPE` filter, and the `COUNT` argument:
 
 ```javascript
 const stream = redis.scanStream({
   // only returns keys following the pattern of `user:*`
   match: "user:*",
+  // only return objects that match a given type,
+  // (requires Redis >= 6.0)
+  type: "zset",
   // returns approximately 100 elements per call
   count: 100,
 });
@@ -662,7 +673,7 @@ Set maxRetriesPerRequest to `null` to disable this behavior, and every command w
 
 ### Reconnect on error
 
-Besides auto-reconnect when the connection is closed, ioredis supports reconnecting on the specified errors by the `reconnectOnError` option. Here's an example that will reconnect when receiving `READONLY` error:
+Besides auto-reconnect when the connection is closed, ioredis supports reconnecting on certain Redis errors using the `reconnectOnError` option. Here's an example that will reconnect when receiving `READONLY` error:
 
 ```javascript
 const redis = new Redis({
@@ -676,9 +687,9 @@ const redis = new Redis({
 });
 ```
 
-This feature is useful when using Amazon ElastiCache. Once failover happens, Amazon ElastiCache will switch the master we currently connected with to a slave, leading to the following writes fails with the error `READONLY`. Using `reconnectOnError`, we can force the connection to reconnect on this error in order to connect to the new master.
+This feature is useful when using Amazon ElastiCache instances with Auto-failover disabled. On these instances, test your `reconnectOnError` handler by manually promoting the replica node to the primary role using the AWS console. The following writes fail with the error `READONLY`. Using `reconnectOnError`, we can force the connection to reconnect on this error in order to connect to the new master. Furthermore, if the `reconnectOnError` returns `2`, ioredis will resend the failed command after reconnecting.
 
-Furthermore, if the `reconnectOnError` returns `2`, ioredis will resend the failed command after reconnecting.
+On ElastiCache insances with Auto-failover enabled, `reconnectOnError` does not execute. Instead of returning a Redis error, AWS closes all connections to the master endpoint until the new primary node is ready. ioredis reconnects via `retryStrategy` instead of `reconnectOnError` after about a minute. On ElastiCache insances with Auto-failover enabled, test failover events with the `Failover primary` option in the AWS console.
 
 ## Connection Events
 
@@ -922,13 +933,17 @@ Sometimes you may want to send a command to multiple nodes (masters or slaves) o
 ```javascript
 // Send `FLUSHDB` command to all slaves:
 const slaves = cluster.nodes("slave");
-Promise.all(slaves.map(node => node.flushdb()))
+Promise.all(slaves.map((node) => node.flushdb()));
 
 // Get keys of all the masters:
 const masters = cluster.nodes("master");
-Promise.all(masters.map(node => node.keys()).then(keys => {
-  // keys: [['key1', 'key2'], ['key3', 'key4']]
-}));
+Promise.all(
+  masters
+    .map((node) => node.keys())
+    .then((keys) => {
+      // keys: [['key1', 'key2'], ['key3', 'key4']]
+    })
+);
 ```
 
 ### NAT Mapping
@@ -1063,7 +1078,7 @@ const cluster = new Redis.Cluster(
 
 ## Autopipelining
 
-In 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. 
+In 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.
 
 The 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).
 
@@ -1075,38 +1090,39 @@ This feature can dramatically improve throughput and avoids HOL blocking. In our
 
 While 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.
 
-When using Redis Cluster, one pipeline per node is created. Commands are assigned to pipelines according to which node serves the slot. 
+When using Redis Cluster, one pipeline per node is created. Commands are assigned to pipelines according to which node serves the slot.
 
-A pipeline will thus contain commands using different slots but that ultimately are assigned to the same node. 
+A pipeline will thus contain commands using different slots but that ultimately are assigned to the same node.
 
 Note that the same slot limitation within a single command still holds, as it is a Redis limitation.
 
-
 ### Example of automatic pipeline enqueuing
 
 This sample code uses ioredis with automatic pipeline enabled.
 
 ```javascript
-const Redis = require('./built');
-const http = require('http');
+const Redis = require("./built");
+const http = require("http");
 
 const db = new Redis({ enableAutoPipelining: true });
 
 const server = http.createServer((request, response) => {
-  const key = new URL(request.url, 'https://localhost:3000/').searchParams.get('key');
+  const key = new URL(request.url, "https://localhost:3000/").searchParams.get(
+    "key"
+  );
 
   db.get(key, (err, value) => {
-    response.writeHead(200, { 'Content-Type': 'text/plain' });
+    response.writeHead(200, { "Content-Type": "text/plain" });
     response.end(value);
   });
-})
+});
 
 server.listen(3000);
 ```
 
 When Node receives requests, it schedules them to be processed in one or more iterations of the events loop.
 
-All commands issued by requests processing during one iteration of the loop will be wrapped in a pipeline automatically created by ioredis. 
+All commands issued by requests processing during one iteration of the loop will be wrapped in a pipeline automatically created by ioredis.
 
 In the example above, the pipeline will have the following contents:
 
@@ -1128,24 +1144,22 @@ This approach increases the utilization of the network link, reduces the TCP ove
 
 ### Benchmarks
 
-Here's some of the results of our tests for a single node. 
+Here's some of the results of our tests for a single node.
 
 Each iteration of the test runs 1000 random commands on the server.
 
 |                           | Samples | Result        | Tolerance |
-|---------------------------|---------|---------------|-----------|
+| ------------------------- | ------- | ------------- | --------- |
 | default                   | 1000    | 174.62 op/sec | ± 0.45 %  |
 | enableAutoPipelining=true | 1500    | 233.33 op/sec | ± 0.88 %  |
 
-
 And here's the same test for a cluster of 3 masters and 3 replicas:
 
 |                           | Samples | Result        | Tolerance |
-|---------------------------|---------|---------------|-----------|
+| ------------------------- | ------- | ------------- | --------- |
 | default                   | 1000    | 164.05 op/sec | ± 0.42 %  |
 | enableAutoPipelining=true | 3000    | 235.31 op/sec | ± 0.94 %  |
 
-
 # Error Handling
 
 All the errors returned by the Redis server are instances of `ReplyError`, which can be accessed via `Redis`:

package/built/ScanStream.js

@@ -27,6 +27,9 @@ class ScanStream extends stream_1.Readable {
         if (this.opt.match) {
             args.push("MATCH", this.opt.match);
         }
+        if (this.opt.type) {
+            args.push("TYPE", this.opt.type);
+        }
         if (this.opt.count) {
             args.push("COUNT", String(this.opt.count));
         }

package/built/cluster/ClusterOptions.js

@@ -12,6 +12,8 @@ exports.DEFAULT_CLUSTER_OPTIONS = {
     retryDelayOnTryAgain: 100,
     slotsRefreshTimeout: 1000,
     slotsRefreshInterval: 5000,
+    useSRVRecords: false,
+    resolveSrv: dns_1.resolveSrv,
     dnsLookup: dns_1.lookup,
     enableAutoPipelining: false,
     autoPipeliningIgnoredCommands: [],

package/built/cluster/index.js

@@ -726,6 +726,30 @@ class Cluster extends events_1.EventEmitter {
             }
         });
     }
+    resolveSrv(hostname) {
+        return new Promise((resolve, reject) => {
+            this.options.resolveSrv(hostname, (err, records) => {
+                if (err) {
+                    return reject(err);
+                }
+                const self = this, groupedRecords = util_1.groupSrvRecords(records), sortedKeys = Object.keys(groupedRecords).sort((a, b) => parseInt(a) - parseInt(b));
+                function tryFirstOne(err) {
+                    if (!sortedKeys.length) {
+                        return reject(err);
+                    }
+                    const key = sortedKeys[0], group = groupedRecords[key], record = util_1.weightSrvRecords(group);
+                    if (!group.records.length) {
+                        sortedKeys.shift();
+                    }
+                    self.dnsLookup(record.name).then((host) => resolve({
+                        host,
+                        port: record.port,
+                    }), tryFirstOne);
+                }
+                tryFirstOne();
+            });
+        });
+    }
     dnsLookup(hostname) {
         return new Promise((resolve, reject) => {
             this.options.dnsLookup(hostname, (err, address) => {
@@ -758,11 +782,20 @@ class Cluster extends events_1.EventEmitter {
         if (hostnames.length === 0) {
             return Promise.resolve(startupNodes);
         }
-        return Promise.all(hostnames.map((hostname) => this.dnsLookup(hostname))).then((ips) => {
-            const hostnameToIP = utils_2.zipMap(hostnames, ips);
-            return startupNodes.map((node) => hostnameToIP.has(node.host)
-                ? Object.assign({}, node, { host: hostnameToIP.get(node.host) })
-                : node);
+        return Promise.all(hostnames.map((this.options.useSRVRecords ? this.resolveSrv : this.dnsLookup).bind(this))).then((configs) => {
+            const hostnameToConfig = utils_2.zipMap(hostnames, configs);
+            return startupNodes.map((node) => {
+                const config = hostnameToConfig.get(node.host);
+                if (!config) {
+                    return node;
+                }
+                else if (this.options.useSRVRecords) {
+                    return Object.assign({}, node, config);
+                }
+                else {
+                    return Object.assign({}, node, { host: config });
+                }
+            });
         });
     }
 }

package/built/cluster/util.js

@@ -57,3 +57,38 @@ function getUniqueHostnamesFromOptions(nodes) {
     return Object.keys(uniqueHostsMap).filter((host) => !net_1.isIP(host));
 }
 exports.getUniqueHostnamesFromOptions = getUniqueHostnamesFromOptions;
+function groupSrvRecords(records) {
+    const recordsByPriority = {};
+    for (const record of records) {
+        if (!recordsByPriority.hasOwnProperty(record.priority)) {
+            recordsByPriority[record.priority] = {
+                totalWeight: record.weight,
+                records: [record],
+            };
+        }
+        else {
+            recordsByPriority[record.priority].totalWeight += record.weight;
+            recordsByPriority[record.priority].records.push(record);
+        }
+    }
+    return recordsByPriority;
+}
+exports.groupSrvRecords = groupSrvRecords;
+function weightSrvRecords(recordsGroup) {
+    if (recordsGroup.records.length === 1) {
+        recordsGroup.totalWeight = 0;
+        return recordsGroup.records.shift();
+    }
+    // + `recordsGroup.records.length` to support `weight` 0
+    const random = Math.floor(Math.random() * (recordsGroup.totalWeight + recordsGroup.records.length));
+    let total = 0;
+    for (const [i, record] of recordsGroup.records.entries()) {
+        total += 1 + record.weight;
+        if (total > random) {
+            recordsGroup.totalWeight -= record.weight;
+            recordsGroup.records.splice(i, 1);
+            return record;
+        }
+    }
+}
+exports.weightSrvRecords = weightSrvRecords;

package/built/redis/index.js

@@ -38,9 +38,9 @@ const debug = utils_1.Debug("redis");
  * it to reduce the latency.
  * @param {string} [options.connectionName=null] - Connection name.
  * @param {number} [options.db=0] - Database index to use.
- * @param {string} [options.username=null] - If set, client will send AUTH command with this user and password when connected.
  * @param {string} [options.password=null] - If set, client will send AUTH command
  * with the value of this option when connected.
+ * @param {string} [options.username=null] - Similar to `password`, Provide this for Redis ACL support.
  * @param {boolean} [options.dropBufferSupport=false] - Drop the buffer support for better performance.
  * This option is recommended to be enabled when
  * handling large array response and you don't need the buffer support.

package/built/utils/index.js

@@ -254,10 +254,17 @@ function parseURL(url) {
         url = "//" + url;
         parsed = url_1.parse(url, true, true);
     }
+    const options = parsed.query || {};
+    const allowUsernameInURI = options.allowUsernameInURI && options.allowUsernameInURI !== "false";
+    delete options.allowUsernameInURI;
     const result = {};
     if (parsed.auth) {
-        const parsedAuth = parsed.auth.split(":");
-        result.password = parsedAuth[1];
+        const index = parsed.auth.indexOf(":");
+        if (allowUsernameInURI) {
+            result.username =
+                index === -1 ? parsed.auth : parsed.auth.slice(0, index);
+        }
+        result.password = index === -1 ? "" : parsed.auth.slice(index + 1);
     }
     if (parsed.pathname) {
         if (parsed.protocol === "redis:" || parsed.protocol === "rediss:") {
@@ -275,7 +282,7 @@ function parseURL(url) {
     if (parsed.port) {
         result.port = parsed.port;
     }
-    lodash_1.defaults(result, parsed.query);
+    lodash_1.defaults(result, options);
     return result;
 }
 exports.parseURL = parseURL;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ioredis",
-  "version": "4.19.4",
+  "version": "4.23.0",
   "description": "A robust, performance-focused and full-featured Redis client for Node.js.",
   "main": "built/index.js",
   "files": [
@@ -39,7 +39,7 @@
     "lodash.defaults": "^4.2.0",
     "lodash.flatten": "^4.4.0",
     "p-map": "^2.1.0",
-    "redis-commands": "1.6.0",
+    "redis-commands": "1.7.0",
     "redis-errors": "^1.2.0",
     "redis-parser": "^3.0.0",
     "standard-as-callback": "^2.0.1"