ioredis 5.0.2 → 5.0.3

package/built/Redis.d.ts

@@ -125,30 +125,20 @@ declare class Redis extends Commander {
      * });
      * ```
      */
-    monitor(callback: Callback<Redis>): Promise<Redis>;
+    monitor(callback?: Callback<Redis>): Promise<Redis>;
     /**
      * Send a command to Redis
      *
-     * This method is used internally by the `Redis#set`, `Redis#lpush` etc.
-     * Most of the time you won't invoke this method directly.
-     * However when you want to send a command that is not supported by ioredis yet,
-     * this command will be useful.
+     * This method is used internally and in most cases you should not
+     * use it directly. If you need to send a command that is not supported
+     * by the library, you can use the `call` method:
      *
      * ```js
      * const redis = new Redis();
      *
-     * // Use callback
-     * const get = new Command('get', ['foo'], 'utf8', function (err, result) {
-     *   console.log(result);
-     * });
-     * redis.sendCommand(get);
-     *
-     * // Use promise
-     * const set = new Command('set', ['foo', 'bar'], 'utf8');
-     * set.promise.then(function (result) {
-     *   console.log(result);
-     * });
-     * redis.sendCommand(set);
+     * redis.call('set', 'foo', 'bar');
+     * // or
+     * redis.call(['set', 'foo', 'bar']);
      * ```
      *
      * @ignore

package/built/Redis.js

@@ -135,8 +135,18 @@ class Redis extends Commander_1.default {
                     CONNECT_EVENT = "connect";
                 }
                 _this.stream = stream;
-                if (typeof options.keepAlive === "number") {
-                    stream.setKeepAlive(true, options.keepAlive);
+                if (options.noDelay) {
+                    stream.setNoDelay(true);
+                }
+                // Node ignores setKeepAlive before connect, therefore we wait for the event:
+                // https://github.com/nodejs/node/issues/31663
+                if (typeof options.keepAlive === 'number') {
+                    if (stream.connecting) {
+                        stream.once(CONNECT_EVENT, () => stream.setKeepAlive(true, options.keepAlive));
+                    }
+                    else {
+                        stream.setKeepAlive(true, options.keepAlive);
+                    }
                 }
                 if (stream.connecting) {
                     stream.once(CONNECT_EVENT, eventHandler.connectHandler(_this));
@@ -186,9 +196,6 @@ class Redis extends Commander_1.default {
                     stream.once("error", eventHandler.errorHandler(_this));
                     stream.once("close", eventHandler.closeHandler(_this));
                 }
-                if (options.noDelay) {
-                    stream.setNoDelay(true);
-                }
                 const connectionReadyHandler = function () {
                     _this.removeListener("close", connectionCloseHandler);
                     resolve();
@@ -276,7 +283,8 @@ class Redis extends Commander_1.default {
             monitor: true,
             lazyConnect: false,
         });
-        return (0, standard_as_callback_1.default)(new Promise(function (resolve) {
+        return (0, standard_as_callback_1.default)(new Promise(function (resolve, reject) {
+            monitorInstance.once("error", reject);
             monitorInstance.once("monitoring", function () {
                 resolve(monitorInstance);
             });
@@ -285,26 +293,16 @@ class Redis extends Commander_1.default {
     /**
      * Send a command to Redis
      *
-     * This method is used internally by the `Redis#set`, `Redis#lpush` etc.
-     * Most of the time you won't invoke this method directly.
-     * However when you want to send a command that is not supported by ioredis yet,
-     * this command will be useful.
+     * This method is used internally and in most cases you should not
+     * use it directly. If you need to send a command that is not supported
+     * by the library, you can use the `call` method:
      *
      * ```js
      * const redis = new Redis();
      *
-     * // Use callback
-     * const get = new Command('get', ['foo'], 'utf8', function (err, result) {
-     *   console.log(result);
-     * });
-     * redis.sendCommand(get);
-     *
-     * // Use promise
-     * const set = new Command('set', ['foo', 'bar'], 'utf8');
-     * set.promise.then(function (result) {
-     *   console.log(result);
-     * });
-     * redis.sendCommand(set);
+     * redis.call('set', 'foo', 'bar');
+     * // or
+     * redis.call(['set', 'foo', 'bar']);
      * ```
      *
      * @ignore
@@ -347,8 +345,7 @@ class Redis extends Commander_1.default {
                 command.reject(new Error("Stream isn't writeable and enableOfflineQueue options is false"));
                 return command.promise;
             }
-            if (command.name === "quit" &&
-                this.offlineQueue.length === 0) {
+            if (command.name === "quit" && this.offlineQueue.length === 0) {
                 this.disconnect();
                 command.resolve(Buffer.from("OK"));
                 return command.promise;

package/built/connectors/SentinelConnector/index.js

@@ -88,11 +88,12 @@ class SentinelConnector extends AbstractConnector_1.default {
                 if (this.options.enableTLSForSentinelMode && this.options.tls) {
                     Object.assign(resolved, this.options.tls);
                     this.stream = (0, tls_1.connect)(resolved);
+                    this.stream.once("secureConnect", this.initFailoverDetector.bind(this));
                 }
                 else {
                     this.stream = (0, net_1.createConnection)(resolved);
+                    this.stream.once("connect", this.initFailoverDetector.bind(this));
                 }
-                this.stream.once("connect", () => this.initFailoverDetector());
                 this.stream.once("error", (err) => {
                     this.firstError = err;
                 });

package/built/index.d.ts

@@ -1,4 +1,5 @@
 export { default } from "./Redis";
+export type { default as Redis } from "./Redis";
 export { default as Cluster } from "./cluster";
 /**
  * @ignore

package/built/redis/event_handler.js

@@ -195,7 +195,7 @@ function readyHandler(self) {
         self.setStatus("ready");
         self.retryAttempts = 0;
         if (self.options.monitor) {
-            self.call("monitor");
+            self.call("monitor").then(() => self.setStatus("monitoring"), (error) => self.emit("error", error));
             const { sendCommand } = self;
             self.sendCommand = function (command) {
                 if (Command_1.default.checkFlag("VALID_IN_MONITOR_MODE", command.name)) {
@@ -207,7 +207,6 @@ function readyHandler(self) {
             self.once("close", function () {
                 delete self.sendCommand;
             });
-            self.setStatus("monitoring");
             return;
         }
         const finalSelect = self.prevCondition

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ioredis",
-  "version": "5.0.2",
+  "version": "5.0.3",
   "description": "A robust, performance-focused and full-featured Redis client for Node.js.",
   "main": "./built/index.js",
   "types": "./built/index.d.ts",
@@ -57,6 +57,7 @@
     "@semantic-release/commit-analyzer": "^9.0.2",
     "@semantic-release/git": "^10.0.1",
     "@types/chai": "^4.3.0",
+    "@types/chai-as-promised": "^7.1.5",
     "@types/debug": "^4.1.5",
     "@types/lodash.defaults": "^4.2.6",
     "@types/lodash.isarguments": "^3.1.6",