ioredis 5.0.2 → 5.0.5

package/README.md

@@ -37,7 +37,7 @@ used in the world's biggest online commerce company [Alibaba](http://www.alibaba
 
 # Versions
 
-| NPM Version    | Branch | Node.js Version | Redis Version   |
+| Version        | Branch | Node.js Version | Redis Version   |
 | -------------- | ------ | --------------- | --------------- |
 | 5.x.x (latest) | main   | >= 12           | 2.6.12 ~ latest |
 | 4.x.x          | v4     | >= 6            | 2.6.12 ~ 7      |
@@ -48,7 +48,7 @@ Refer to [CHANGELOG.md](CHANGELOG.md) for features and bug fixes introduced in v
 
 # Links
 
-- [API Documentation](http://luin.github.io/ioredis/) ([Redis](http://luin.github.io/ioredis/classes/default.html), [Cluster](http://luin.github.io/ioredis/classes/Cluster.html))
+- [API Documentation](https://luin.github.io/ioredis/) ([Redis](https://luin.github.io/ioredis/classes/Redis.html), [Cluster](https://luin.github.io/ioredis/classes/Cluster.html))
 - [Changelog](CHANGELOG.md)
 - [Migrating from node_redis](https://github.com/luin/ioredis/wiki/Migrating-from-node_redis)
 
@@ -164,7 +164,7 @@ See the `examples/` folder for more examples. For example:
 * [Streams](examples/stream.js)
 * [Redis Modules](examples/module.js) e.g. RedisJSON
 
-All Redis commands are supported. See [the documentation](http://luin.github.io/ioredis/classes/default.html) for details.
+All Redis commands are supported. See [the documentation](https://luin.github.io/ioredis/classes/Redis.html) for details.
 
 ## Connect to Redis
 
@@ -196,7 +196,7 @@ new Redis("redis://:authpassword@127.0.0.1:6380/4");
 new Redis("redis://username:authpassword@127.0.0.1:6380/4");
 ```
 
-See [API Documentation](http://luin.github.io/ioredis/index.html#RedisOptions) for all available options.
+See [API Documentation](https://luin.github.io/ioredis/index.html#RedisOptions) for all available options.
 
 ## Pub/Sub
 

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/autoPipelining.js

@@ -148,6 +148,9 @@ function executeWithAutoPipelining(client, functionName, commandName, args, call
             }
             resolve(value);
         });
+        if (functionName === "call") {
+            args.unshift(commandName);
+        }
         pipeline[functionName](...args);
     });
     return (0, standard_as_callback_1.default)(autoPipelinePromise, callback);

package/built/cluster/ClusterOptions.d.ts

@@ -3,8 +3,8 @@ import { SrvRecord } from "dns";
 import { RedisOptions } from "../redis/RedisOptions";
 import { CommanderOptions } from "../utils/Commander";
 import { NodeRole } from "./util";
-export declare type DNSResolveSrvFunction = (hostname: string, callback: (err: NodeJS.ErrnoException | undefined, records?: SrvRecord[]) => void) => void;
-export declare type DNSLookupFunction = (hostname: string, callback: (err: NodeJS.ErrnoException | undefined, address: string, family?: number) => void) => void;
+export declare type DNSResolveSrvFunction = (hostname: string, callback: (err: NodeJS.ErrnoException | null | undefined, records?: SrvRecord[]) => void) => void;
+export declare type DNSLookupFunction = (hostname: string, callback: (err: NodeJS.ErrnoException | null | undefined, address: string, family?: number) => void) => void;
 export interface NatMap {
     [key: string]: {
         host: string;

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
@@ -32,8 +33,9 @@ export { SentinelAddress, SentinelConnectionOptions, } from "./connectors/Sentin
 export { StandaloneConnectionOptions } from "./connectors/StandaloneConnector";
 export { RedisOptions, CommonRedisOptions } from "./redis/RedisOptions";
 export { ClusterNode } from "./cluster";
-export { ClusterOptions } from "./cluster/ClusterOptions";
+export { ClusterOptions, DNSLookupFunction, DNSResolveSrvFunction, NatMap, } from "./cluster/ClusterOptions";
 export { NodeRole } from "./cluster/util";
+export type { RedisKey, RedisValue, ChainableCommander, } from "./utils/RedisCommander";
 export declare const ReplyError: any;
 /**
  * @ignore

package/built/redis/RedisOptions.d.ts

@@ -6,6 +6,10 @@ export declare type ReconnectOnError = (err: Error) => boolean | 1 | 2;
 export interface CommonRedisOptions extends CommanderOptions {
     Connector?: ConnectorConstructor;
     retryStrategy?: (times: number) => number | void | null;
+    /**
+     * If a command does not return a reply within a set number of milliseconds,
+     * a "Command timed out" error will be thrown.
+     */
     commandTimeout?: number;
     /**
      * Enable/disable keep-alive functionality.
@@ -25,13 +29,24 @@ export interface CommonRedisOptions extends CommanderOptions {
      * @link https://redis.io/commands/client-setname
      */
     connectionName?: string;
+    /**
+     * If set, client will send AUTH command with the value of this option as the first argument when connected.
+     * This is supported since Redis 6.
+     */
     username?: string;
+    /**
+     * If set, client will send AUTH command with the value of this option when connected.
+     */
     password?: string;
     /**
+     * Database index to use.
+     *
      * @default 0
      */
     db?: number;
     /**
+     * When the client reconnects, channels subscribed in the previous connection will be
+     * resubscribed automatically if `autoResubscribe` is `true`.
      * @default true
      */
     autoResubscribe?: boolean;
@@ -74,14 +89,25 @@ export interface CommonRedisOptions extends CommanderOptions {
      */
     stringNumbers?: boolean;
     /**
+     * How long the client will wait before killing a socket due to inactivity during initial connection.
      * @default 10000
      */
     connectTimeout?: number;
     /**
+     * This option is used internally when you call `redis.monitor()` to tell Redis
+     * to enter the monitor mode when the connection is established.
+     *
      * @default false
      */
     monitor?: boolean;
     /**
+     * The commands that don't get a reply due to the connection to the server is lost are
+     * put into a queue and will be resent on reconnect (if allowed by the `retryStrategy` option).
+     * This option is used to configure how many reconnection attempts should be allowed before
+     * the queue is flushed with a `MaxRetriesPerRequestError` error.
+     * Set this options to `null` instead of a number to let commands wait forever
+     * until the connection is alive again.
+     *
      * @default 20
      */
     maxRetriesPerRequest?: number | null;
@@ -100,14 +126,29 @@ export interface CommonRedisOptions extends CommanderOptions {
     offlineQueue?: boolean;
     commandQueue?: boolean;
     /**
+     *
+     * By default, if the connection to Redis server has not been established, commands are added to a queue
+     * and are executed once the connection is "ready" (when `enableReadyCheck` is true, "ready" means
+     * the Redis server has loaded the database from disk, otherwise means the connection to the Redis
+     * server has been established). If this option is false, when execute the command when the connection
+     * isn't ready, an error will be returned.
+     *
      * @default true
      */
     enableOfflineQueue?: boolean;
     /**
+     * The client will sent an INFO command to check whether the server is still loading data from the disk (
+     * which happens when the server is just launched) when the connection is established, and only wait until
+     * the loading process is finished before emitting the `ready` event.
+     *
      * @default true
      */
     enableReadyCheck?: boolean;
     /**
+     * When a Redis instance is initialized, a connection to the server is immediately established. Set this to
+     * true will delay the connection to the server until the first command is sent or `redis.connect()` is called
+     * explicitly.
+     *
      * @default false
      */
     lazyConnect?: boolean;

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/built/transaction.d.ts

@@ -1,6 +1,6 @@
 import { ChainableCommander } from "./utils/RedisCommander";
 export interface Transaction {
-    pipeline(commands?: [name: string, ...args: unknown[]][]): ChainableCommander;
+    pipeline(commands?: unknown[][]): ChainableCommander;
     multi(options: {
         pipeline: false;
     }): Promise<"OK">;
@@ -8,6 +8,6 @@ export interface Transaction {
     multi(options: {
         pipeline: true;
     }): ChainableCommander;
-    multi(commands?: [name: string, ...args: unknown[]][]): ChainableCommander;
+    multi(commands?: unknown[][]): ChainableCommander;
 }
 export declare function addTransactionSupport(redis: any): void;

package/built/utils/RedisCommander.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { Callback } from "../types";
-declare type RedisKey = string | Buffer;
-declare type RedisValue = string | Buffer | number;
+export declare type RedisKey = string | Buffer;
+export declare type RedisValue = string | Buffer | number;
 export interface ResultTypes<Result, Context> {
     default: Promise<Result>;
     pipeline: ChainableCommander;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ioredis",
-  "version": "5.0.2",
+  "version": "5.0.5",
   "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",