ioredis 4.27.1 → 4.27.5

package/Changelog.md

@@ -1,3 +1,31 @@
+## [4.27.5](https://github.com/luin/ioredis/compare/v4.27.4...v4.27.5) (2021-06-05)
+
+
+### Bug Fixes
+
+* **SENTINEL:** actively failover detection under an option ([#1363](https://github.com/luin/ioredis/issues/1363)) ([f02e383](https://github.com/luin/ioredis/commit/f02e383996310adaefc2b4c40d946b76e450e5c7))
+
+## [4.27.4](https://github.com/luin/ioredis/compare/v4.27.3...v4.27.4) (2021-06-04)
+
+
+### Performance Improvements
+
+* Serialize error stack only when needed ([#1359](https://github.com/luin/ioredis/issues/1359)) ([62b6a64](https://github.com/luin/ioredis/commit/62b6a648910eccc3d83a3acd2db873704fd2080a))
+
+## [4.27.3](https://github.com/luin/ioredis/compare/v4.27.2...v4.27.3) (2021-05-22)
+
+
+### Bug Fixes
+
+* autopipeling for buffer function ([#1231](https://github.com/luin/ioredis/issues/1231)) ([abd9a82](https://github.com/luin/ioredis/commit/abd9a82433ad67b91a4bddb45aff8da2e20d45e8))
+
+## [4.27.2](https://github.com/luin/ioredis/compare/v4.27.1...v4.27.2) (2021-05-04)
+
+
+### Bug Fixes
+
+* **cluster:** avoid ClusterAllFailedError in certain cases ([aa9c5b1](https://github.com/luin/ioredis/commit/aa9c5b1fee5daa24f35b3ff0d3556ecfb86db251)), closes [#1330](https://github.com/luin/ioredis/issues/1330)
+
 ## [4.27.1](https://github.com/luin/ioredis/compare/v4.27.0...v4.27.1) (2021-04-24)
 
 

package/built/autoPipelining.js

@@ -61,14 +61,15 @@ function executeAutoPipeline(client, slotKey) {
         }
     });
 }
-function shouldUseAutoPipelining(client, commandName) {
-    return (client.options.enableAutoPipelining &&
+function shouldUseAutoPipelining(client, functionName, commandName) {
+    return (functionName &&
+        client.options.enableAutoPipelining &&
         !client.isPipeline &&
         !exports.notAllowedAutoPipelineCommands.includes(commandName) &&
         !client.options.autoPipeliningIgnoredCommands.includes(commandName));
 }
 exports.shouldUseAutoPipelining = shouldUseAutoPipelining;
-function executeWithAutoPipelining(client, commandName, args, callback) {
+function executeWithAutoPipelining(client, functionName, commandName, args, callback) {
     const CustomPromise = PromiseContainer.get();
     // On cluster mode let's wait for slots to be available
     if (client.isCluster && !client.slots.length) {
@@ -78,7 +79,7 @@ function executeWithAutoPipelining(client, commandName, args, callback) {
                     reject(err);
                     return;
                 }
-                executeWithAutoPipelining(client, commandName, args, callback).then(resolve, reject);
+                executeWithAutoPipelining(client, functionName, commandName, args, callback).then(resolve, reject);
             });
         });
     }
@@ -112,7 +113,7 @@ function executeWithAutoPipelining(client, commandName, args, callback) {
             }
             resolve(value);
         });
-        pipeline[commandName](...args);
+        pipeline[functionName](...args);
     });
     return standard_as_callback_1.default(autoPipelinePromise, callback);
 }

package/built/cluster/index.js

@@ -185,7 +185,12 @@ class Cluster extends events_1.EventEmitter {
                 this.once("refresh", refreshListener);
                 this.once("close", closeListener);
                 this.once("close", this.handleCloseEvent.bind(this));
-                this.refreshSlotsCache();
+                this.refreshSlotsCache(function (err) {
+                    if (err && err.message === "Failed to refresh slots cache.") {
+                        redis_1.default.prototype.silentEmit.call(this, "error", err);
+                        this.connectionPool.reset([]);
+                    }
+                }.bind(this));
                 this.subscriber.start();
             })
                 .catch((err) => {
@@ -385,8 +390,6 @@ class Cluster extends events_1.EventEmitter {
         function tryNode(index) {
             if (index === nodes.length) {
                 const error = new ClusterAllFailedError_1.default("Failed to refresh slots cache.", lastNodeError);
-                redis_1.default.prototype.silentEmit.call(_this, "error", error);
-                _this.connectionPool.reset([]);
                 return wrapper(error);
             }
             const node = nodes[index];

package/built/command.js

@@ -101,7 +101,7 @@ class Command {
             this.resolve = this._convertValue(resolve);
             if (this.errorStack) {
                 this.reject = (err) => {
-                    reject(utils_1.optimizeErrorStack(err, this.errorStack, __dirname));
+                    reject(utils_1.optimizeErrorStack(err, this.errorStack.stack, __dirname));
                 };
             }
             else {

package/built/commander.js

@@ -23,6 +23,7 @@ function Commander() {
         showFriendlyErrorStack: false,
     });
     this.scriptsSet = {};
+    this.addedBuiltinSet = new Set();
 }
 exports.default = Commander;
 const commands = require("redis-commands").list.filter(function (command) {
@@ -47,16 +48,28 @@ Commander.prototype.getBuiltinCommands = function () {
  */
 Commander.prototype.createBuiltinCommand = function (commandName) {
     return {
-        string: generateFunction(commandName, "utf8"),
-        buffer: generateFunction(commandName, null),
+        string: generateFunction(null, commandName, "utf8"),
+        buffer: generateFunction(null, commandName, null),
     };
 };
+/**
+ * Create add builtin command
+ *
+ * @param {string} commandName - command name
+ * @return {object} functions
+ * @public
+ */
+Commander.prototype.addBuiltinCommand = function (commandName) {
+    this.addedBuiltinSet.add(commandName);
+    this[commandName] = generateFunction(commandName, commandName, "utf8");
+    this[commandName + "Buffer"] = generateFunction(commandName + "Buffer", commandName, null);
+};
 commands.forEach(function (commandName) {
-    Commander.prototype[commandName] = generateFunction(commandName, "utf8");
-    Commander.prototype[commandName + "Buffer"] = generateFunction(commandName, null);
+    Commander.prototype[commandName] = generateFunction(commandName, commandName, "utf8");
+    Commander.prototype[commandName + "Buffer"] = generateFunction(commandName + "Buffer", commandName, null);
 });
-Commander.prototype.call = generateFunction("utf8");
-Commander.prototype.callBuffer = generateFunction(null);
+Commander.prototype.call = generateFunction("call", "utf8");
+Commander.prototype.callBuffer = generateFunction("callBuffer", null);
 // eslint-disable-next-line @typescript-eslint/camelcase
 Commander.prototype.send_command = Commander.prototype.call;
 /**
@@ -72,8 +85,8 @@ Commander.prototype.send_command = Commander.prototype.call;
 Commander.prototype.defineCommand = function (name, definition) {
     const script = new script_1.default(definition.lua, definition.numberOfKeys, this.options.keyPrefix, definition.readOnly);
     this.scriptsSet[name] = script;
-    this[name] = generateScriptingFunction(name, script, "utf8");
-    this[name + "Buffer"] = generateScriptingFunction(name, script, null);
+    this[name] = generateScriptingFunction(name, name, script, "utf8");
+    this[name + "Buffer"] = generateScriptingFunction(name + "Buffer", name, script, null);
 };
 /**
  * Send a command
@@ -82,7 +95,7 @@ Commander.prototype.defineCommand = function (name, definition) {
  * @public
  */
 Commander.prototype.sendCommand = function () { };
-function generateFunction(_commandName, _encoding) {
+function generateFunction(functionName, _commandName, _encoding) {
     if (typeof _encoding === "undefined") {
         _encoding = _commandName;
         _commandName = null;
@@ -97,9 +110,7 @@ function generateFunction(_commandName, _encoding) {
             callback = undefined;
         }
         const options = {
-            errorStack: this.options.showFriendlyErrorStack
-                ? new Error().stack
-                : undefined,
+            errorStack: this.options.showFriendlyErrorStack ? new Error() : undefined,
             keyPrefix: this.options.keyPrefix,
             replyEncoding: _encoding,
         };
@@ -107,14 +118,14 @@ function generateFunction(_commandName, _encoding) {
             return standard_as_callback_1.default(PromiseContainer.get().reject(new Error(DROP_BUFFER_SUPPORT_ERROR)), callback);
         }
         // No auto pipeline, use regular command sending
-        if (!autoPipelining_1.shouldUseAutoPipelining(this, commandName)) {
+        if (!autoPipelining_1.shouldUseAutoPipelining(this, functionName, commandName)) {
             return this.sendCommand(new command_1.default(commandName, args, options, callback));
         }
         // Create a new pipeline and make sure it's scheduled
-        return autoPipelining_1.executeWithAutoPipelining(this, commandName, args, callback);
+        return autoPipelining_1.executeWithAutoPipelining(this, functionName, commandName, args, callback);
     };
 }
-function generateScriptingFunction(name, script, encoding) {
+function generateScriptingFunction(functionName, commandName, script, encoding) {
     return function () {
         let length = arguments.length;
         const lastArgIndex = length - 1;
@@ -140,13 +151,13 @@ function generateScriptingFunction(name, script, encoding) {
             options = { replyEncoding: encoding };
         }
         if (this.options.showFriendlyErrorStack) {
-            options.errorStack = new Error().stack;
+            options.errorStack = new Error();
         }
         // No auto pipeline, use regular command sending
-        if (!autoPipelining_1.shouldUseAutoPipelining(this, name)) {
+        if (!autoPipelining_1.shouldUseAutoPipelining(this, functionName, commandName)) {
             return script.execute(this, args, options, callback);
         }
         // Create a new pipeline and make sure it's scheduled
-        return autoPipelining_1.executeWithAutoPipelining(this, name, args, callback);
+        return autoPipelining_1.executeWithAutoPipelining(this, functionName, commandName, args, callback);
     };
 }

package/built/connectors/SentinelConnector/index.js

@@ -205,6 +205,9 @@ class SentinelConnector extends AbstractConnector_1.default {
     initFailoverDetector() {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.options.failoverDetector) {
+                return;
+            }
             // Move the current sentinel to the first position
             this.sentinelIterator.reset(true);
             const sentinels = [];

package/built/pipeline.js

@@ -41,6 +41,10 @@ function Pipeline(redis) {
         this[name] = redis[name];
         this[name + "Buffer"] = redis[name + "Buffer"];
     });
+    redis.addedBuiltinSet.forEach((name) => {
+        this[name] = redis[name];
+        this[name + "Buffer"] = redis[name + "Buffer"];
+    });
     const Promise = PromiseContainer.get();
     this.promise = new Promise((resolve, reject) => {
         this.resolve = resolve;

package/built/redis/RedisOptions.js

@@ -31,6 +31,7 @@ exports.DEFAULT_REDIS_OPTIONS = {
     natMap: null,
     enableTLSForSentinelMode: false,
     updateSentinels: true,
+    failoverDetector: false,
     // Status
     username: null,
     password: null,

package/built/redis/index.js

@@ -93,6 +93,11 @@ const debug = utils_1.Debug("redis");
  * @param {NatMap} [options.natMap=null] NAT map for sentinel connector.
  * @param {boolean} [options.updateSentinels=true] - Update the given `sentinels` list with new IP
  * addresses when communicating with existing sentinels.
+ * @param {boolean} [options.failoverDetector=false] - Detect failover actively by subscribing to the
+ * related channels. With this option disabled, ioredis is still able to detect failovers because Redis
+ * Sentinel will disconnect all clients whenever a failover happens, so ioredis will reconnect to the new
+ * master. This option is useful when you want to detect failover quicker, but it will create more TCP
+ * connections to Redis servers in order to subscribe to related channels.
 * @param {boolean} [options.enableAutoPipelining=false] - When enabled, all commands issued during an event loop
  * iteration are automatically wrapped in a pipeline and sent to the server at the same time.
  * This can dramatically improve performance.

package/package.json

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