ioredis 4.14.4 → 4.16.1

package/Changelog.md

@@ -1,3 +1,32 @@
+## [4.16.1](https://github.com/luin/ioredis/compare/v4.16.0...v4.16.1) (2020-03-28)
+
+
+### Bug Fixes
+
+* abort incomplete pipelines upon reconnect ([#1084](https://github.com/luin/ioredis/issues/1084)) ([0013991](https://github.com/luin/ioredis/commit/0013991b7fbf239ffd74311266bb9e63e22b46cb)), closes [#965](https://github.com/luin/ioredis/issues/965)
+
+# [4.16.0](https://github.com/luin/ioredis/compare/v4.15.1...v4.16.0) (2020-02-19)
+
+
+### Features
+
+* ability force custom scripts to be readOnly and execute on slaves ([#1057](https://github.com/luin/ioredis/issues/1057)) ([a24c3ab](https://github.com/luin/ioredis/commit/a24c3abcf4013e74e25424d2f6b91a2ae0de12b5))
+
+## [4.15.1](https://github.com/luin/ioredis/compare/v4.15.0...v4.15.1) (2019-12-25)
+
+
+### Bug Fixes
+
+* ignore empty hosts returned by CLUSTER SLOTS ([#1025](https://github.com/luin/ioredis/issues/1025)) ([d79a8ef](https://github.com/luin/ioredis/commit/d79a8ef40f5670af6962b598752dc5a7aa96722c))
+* prevent exception when send custom command ([04cad7f](https://github.com/luin/ioredis/commit/04cad7fbf2db5e14a478e2eb1dc825346abe41dd))
+
+# [4.15.0](https://github.com/luin/ioredis/compare/v4.14.4...v4.15.0) (2019-11-29)
+
+
+### Features
+
+* support multiple fields for hset ([51b1478](https://github.com/luin/ioredis/commit/51b14786eef4c627c178de4967434e8d4a51ebe0))
+
 ## [4.14.4](https://github.com/luin/ioredis/compare/v4.14.3...v4.14.4) (2019-11-22)
 
 

package/README.md

@@ -76,23 +76,32 @@ $ npm install ioredis
 ## Basic Usage
 
 ```javascript
-var Redis = require("ioredis");
-var redis = new Redis();
+const Redis = require("ioredis");
+const redis = new Redis(); // uses defaults unless given configuration object
 
-redis.set("foo", "bar");
+// ioredis supports all Redis commands:
+redis.set("foo", "bar"); // returns promise which resolves to string, "OK"
+
+// the format is: redis[SOME_REDIS_COMMAND_IN_LOWERCASE](ARGUMENTS_ARE_JOINED_INTO_COMMAND_STRING)
+// the js: ` redis.set("mykey", "Hello") ` is equivalent to the cli: ` redis> SET mykey "Hello" `
+
+// ioredis supports the node.js callback style
 redis.get("foo", function(err, result) {
-  console.log(result);
+  if (err) {
+    console.error(err);
+  } else {
+    console.log(result); // Promise resolves to "bar"
+  }
 });
-redis.del("foo");
 
-// Or using a promise if the last argument isn't a function
+// Or ioredis returns a promise if the last argument isn't a function
 redis.get("foo").then(function(result) {
-  console.log(result);
+  console.log(result); // Prints "bar"
 });
 
-// Arguments to commands are flattened, so the following are the same:
-redis.sadd("set", 1, 3, 5, 7);
-redis.sadd("set", [1, 3, 5, 7]);
+// Most responses are strings, or arrays of strings
+redis.zadd("sortedSet", 1, "one", 2, "dos", 4, "quatro", 3, "three")
+redis.zrange("sortedSet", 0, 2, "WITHSCORES").then(res => console.log(res)); // Promise resolves to ["one", "1", "dos", "2", "three", "3"] as if the command was ` redis> ZRANGE sortedSet 0 2 WITHSCORES `
 
 // All arguments are passed directly to the redis server:
 redis.set("key", 100, "EX", 10);
@@ -750,7 +759,7 @@ ioredis **guarantees** that the node you connected to is always a master even af
 
 It'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.
 
-If 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 avaiable 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`.
+If 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`.
 
 ```javascript
 // available slaves format
@@ -832,21 +841,21 @@ cluster.get("foo", function(err, res) {
       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.
       The default value of this option is:
 
-          ```javascript
-          function (times) {
-            var delay = Math.min(100 + times * 2, 2000);
-            return delay;
-          }
-          ```
+      ```javascript
+      function (times) {
+        var delay = Math.min(100 + times * 2, 2000);
+        return delay;
+      }
+      ```
 
-          It's possible to modify the `startupNodes` property in order to switch to another set of nodes here:
+      It's possible to modify the `startupNodes` property in order to switch to another set of nodes here:
 
-          ```javascript
-          function (times) {
-            this.startupNodes = [{ port: 6790, host: '127.0.0.1' }];
-            return Math.min(100 + times * 2, 2000);
-          }
-          ```
+      ```javascript
+      function (times) {
+        this.startupNodes = [{ port: 6790, host: '127.0.0.1' }];
+        return Math.min(100 + times * 2, 2000);
+      }
+      ```
 
     - `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.
     - `enableOfflineQueue`: Similar to the `enableOfflineQueue` option of `Redis` class.
@@ -1047,7 +1056,7 @@ var cluster = new Redis.Cluster(
       tls: {}
     },
   }
-};
+);
 ```
 
 <hr>

package/built/cluster/index.js

@@ -432,8 +432,9 @@ class Cluster extends events_1.EventEmitter {
         }
         let to = this.options.scaleReads;
         if (to !== "master") {
-            const isCommandReadOnly = commands.exists(command.name) &&
-                commands.hasFlag(command.name, "readonly");
+            const isCommandReadOnly = command.isReadOnly ||
+                (commands.exists(command.name) &&
+                    commands.hasFlag(command.name, "readonly"));
             if (!isCommandReadOnly) {
                 to = "master";
             }
@@ -637,6 +638,9 @@ class Cluster extends events_1.EventEmitter {
                 const slotRangeEnd = items[1];
                 const keys = [];
                 for (let j = 2; j < items.length; j++) {
+                    if (!items[j][0]) {
+                        continue;
+                    }
                     items[j] = this.natMapper({ host: items[j][0], port: items[j][1] });
                     items[j].readOnly = j !== 2;
                     nodes.push(items[j]);

package/built/command.js

@@ -45,6 +45,7 @@ class Command {
         this.name = name;
         this.transformed = false;
         this.isCustomCommand = false;
+        this.inTransaction = false;
         this.replyEncoding = options.replyEncoding;
         this.errorStack = options.errorStack;
         this.args = lodash_1.flatten(args);
@@ -53,6 +54,9 @@ class Command {
         if (options.keyPrefix) {
             this._iterateKeys(key => options.keyPrefix + key);
         }
+        if (options.readOnly) {
+            this.isReadOnly = true;
+        }
     }
     static getFlagMap() {
         if (!this.flagMap) {
@@ -293,6 +297,17 @@ Command.setReplyTransformer("hgetall", function (result) {
     }
     return result;
 });
+Command.setArgumentTransformer("hset", function (args) {
+    if (args.length === 2) {
+        if (typeof Map !== "undefined" && args[1] instanceof Map) {
+            return [args[0]].concat(utils_1.convertMapToArray(args[1]));
+        }
+        if (typeof args[1] === "object" && args[1] !== null) {
+            return [args[0]].concat(utils_1.convertObjectToArray(args[1]));
+        }
+    }
+    return args;
+});
 class MixedBuffers {
     constructor() {
         this.length = 0;

package/built/commander.js

@@ -65,10 +65,11 @@ Commander.prototype.send_command = Commander.prototype.call;
  * @param {object} definition
  * @param {string} definition.lua - the lua code
  * @param {number} [definition.numberOfKeys=null] - the number of keys.
+ * @param {boolean} [definition.readOnly=false] - force this script to be readonly so it executes on slaves as well.
  * If omit, you have to pass the number of keys as the first argument every time you invoke the command
  */
 Commander.prototype.defineCommand = function (name, definition) {
-    var script = new script_1.default(definition.lua, definition.numberOfKeys, this.options.keyPrefix);
+    var script = new script_1.default(definition.lua, definition.numberOfKeys, this.options.keyPrefix, definition.readOnly);
     this.scriptsSet[name] = script;
     this[name] = generateScriptingFunction(script, "utf8");
     this[name + "Buffer"] = generateScriptingFunction(script, null);

package/built/pipeline.js

@@ -59,16 +59,9 @@ Pipeline.prototype.fillResult = function (value, position) {
     if (this.isCluster) {
         let retriable = true;
         let commonError;
-        let inTransaction;
         for (let i = 0; i < this._result.length; ++i) {
             var error = this._result[i][0];
             var command = this._queue[i];
-            if (command.name === "multi") {
-                inTransaction = true;
-            }
-            else if (command.name === "exec") {
-                inTransaction = false;
-            }
             if (error) {
                 if (command.name === "exec" &&
                     error.message ===
@@ -87,7 +80,7 @@ Pipeline.prototype.fillResult = function (value, position) {
                     break;
                 }
             }
-            else if (!inTransaction) {
+            else if (!command.inTransaction) {
                 var isReadOnly = redis_commands_1.exists(command.name) && redis_commands_1.hasFlag(command.name, "readonly");
                 if (!isReadOnly) {
                     retriable = false;
@@ -99,7 +92,7 @@ Pipeline.prototype.fillResult = function (value, position) {
             var _this = this;
             var errv = commonError.message.split(" ");
             var queue = this._queue;
-            inTransaction = false;
+            let inTransaction = false;
             this._queue = [];
             for (let i = 0; i < queue.length; ++i) {
                 if (errv[0] === "ASK" &&
@@ -112,12 +105,7 @@ Pipeline.prototype.fillResult = function (value, position) {
                 }
                 queue[i].initPromise();
                 this.sendCommand(queue[i]);
-                if (queue[i].name === "multi") {
-                    inTransaction = true;
-                }
-                else if (queue[i].name === "exec") {
-                    inTransaction = false;
-                }
+                inTransaction = queue[i].inTransaction;
             }
             let matched = true;
             if (typeof this.leftRedirections === "undefined") {
@@ -162,7 +150,11 @@ Pipeline.prototype.fillResult = function (value, position) {
     this.resolve(this._result.slice(0, this._result.length - ignoredCount));
 };
 Pipeline.prototype.sendCommand = function (command) {
+    if (this._transactions > 0) {
+        command.inTransaction = true;
+    }
     const position = this._queue.length;
+    command.pipelineIndex = position;
     command.promise
         .then(result => {
         this.fillResult([null, result], position);

package/built/redis/event_handler.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const redis_errors_1 = require("redis-errors");
 const command_1 = require("../command");
 const errors_1 = require("../errors");
 const utils_1 = require("../utils");
@@ -67,6 +68,59 @@ function connectHandler(self) {
     };
 }
 exports.connectHandler = connectHandler;
+function abortError(command) {
+    const err = new redis_errors_1.AbortError("Command aborted due to connection close");
+    err.command = {
+        name: command.name,
+        args: command.args
+    };
+    return err;
+}
+// If a contiguous set of pipeline commands starts from index zero then they
+// can be safely reattempted. If however we have a chain of pipelined commands
+// starting at index 1 or more it means we received a partial response before
+// the connection close and those pipelined commands must be aborted. For
+// example, if the queue looks like this: [2, 3, 4, 0, 1, 2] then after
+// aborting and purging we'll have a queue that looks like this: [0, 1, 2]
+function abortIncompletePipelines(commandQueue) {
+    let expectedIndex = 0;
+    for (let i = 0; i < commandQueue.length;) {
+        const command = commandQueue.peekAt(i).command;
+        const pipelineIndex = command.pipelineIndex;
+        if (pipelineIndex === undefined || pipelineIndex === 0) {
+            expectedIndex = 0;
+        }
+        if (pipelineIndex !== undefined && pipelineIndex !== expectedIndex++) {
+            commandQueue.remove(i, 1);
+            command.reject(abortError(command));
+            continue;
+        }
+        i++;
+    }
+}
+// If only a partial transaction result was received before connection close,
+// we have to abort any transaction fragments that may have ended up in the
+// offline queue
+function abortTransactionFragments(commandQueue) {
+    for (let i = 0; i < commandQueue.length;) {
+        const command = commandQueue.peekAt(i).command;
+        if (command.name === "multi") {
+            break;
+        }
+        if (command.name === "exec") {
+            commandQueue.remove(i, 1);
+            command.reject(abortError(command));
+            break;
+        }
+        if (command.inTransaction) {
+            commandQueue.remove(i, 1);
+            command.reject(abortError(command));
+        }
+        else {
+            i++;
+        }
+    }
+}
 function closeHandler(self) {
     return function () {
         self.setStatus("close");
@@ -74,8 +128,12 @@ function closeHandler(self) {
             self.prevCondition = self.condition;
         }
         if (self.commandQueue.length) {
+            abortIncompletePipelines(self.commandQueue);
             self.prevCommandQueue = self.commandQueue;
         }
+        if (self.offlineQueue.length) {
+            abortTransactionFragments(self.offlineQueue);
+        }
         if (self.manuallyClosing) {
             self.manuallyClosing = false;
             debug("skip reconnecting since the connection is manually closed.");

package/built/redis/index.js

@@ -581,6 +581,7 @@ Redis.prototype.sendCommand = function (command, stream) {
     var writable = this.status === "ready" ||
         (!stream &&
             this.status === "connect" &&
+            commands.exists(command.name) &&
             commands.hasFlag(command.name, "loading"));
     if (!this.stream) {
         writable = false;

package/built/script.js

@@ -5,10 +5,11 @@ const promiseContainer_1 = require("./promiseContainer");
 const command_1 = require("./command");
 const standard_as_callback_1 = require("standard-as-callback");
 class Script {
-    constructor(lua, numberOfKeys = null, keyPrefix = "") {
+    constructor(lua, numberOfKeys = null, keyPrefix = "", readOnly = false) {
         this.lua = lua;
         this.numberOfKeys = numberOfKeys;
         this.keyPrefix = keyPrefix;
+        this.readOnly = readOnly;
         this.sha = crypto_1.createHash("sha1")
             .update(lua)
             .digest("hex");
@@ -20,6 +21,9 @@ class Script {
         if (this.keyPrefix) {
             options.keyPrefix = this.keyPrefix;
         }
+        if (this.readOnly) {
+            options.readOnly = true;
+        }
         const evalsha = new command_1.default("evalsha", [this.sha].concat(args), options);
         evalsha.isCustomCommand = true;
         const result = container.sendCommand(evalsha);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ioredis",
-  "version": "4.14.4",
+  "version": "4.16.1",
   "description": "A robust, performance-focused and full-featured Redis client for Node.js.",
   "main": "built/index.js",
   "files": [