ioredis 5.9.1 → 5.9.3

package/built/Pipeline.js

@@ -139,7 +139,14 @@ class Pipeline extends Commander_1.default {
                 cluster.handleError(commonError, this.leftRedirections, {
                     moved: function (_slot, key) {
                         _this.preferKey = key;
-                        cluster.slots[errv[1]] = [key];
+                        if (cluster.slots[errv[1]]) {
+                            if (cluster.slots[errv[1]][0] !== key) {
+                                cluster.slots[errv[1]] = [key];
+                            }
+                        }
+                        else {
+                            cluster.slots[errv[1]] = [key];
+                        }
                         cluster._groupsBySlot[errv[1]] =
                             cluster._groupsIds[cluster.slots[errv[1]].join(";")];
                         cluster.refreshSlotsCache();

package/built/autoPipelining.js

@@ -4,6 +4,7 @@ exports.executeWithAutoPipelining = exports.getFirstValueInFlattenedArray = expo
 const lodash_1 = require("./utils/lodash");
 const calculateSlot = require("cluster-key-slot");
 const standard_as_callback_1 = require("standard-as-callback");
+const commands_1 = require("@ioredis/commands");
 exports.kExec = Symbol("exec");
 exports.kCallbacks = Symbol("callbacks");
 exports.notAllowedAutoPipelineCommands = [
@@ -118,9 +119,15 @@ function executeWithAutoPipelining(client, functionName, commandName, args, call
     // Note that the first value in args may be a (possibly empty) array.
     // ioredis will only flatten one level of the array, in the Command constructor.
     const prefix = client.options.keyPrefix || "";
-    const slotKey = client.isCluster
+    let slotKey = client.isCluster
         ? client.slots[calculateSlot(`${prefix}${getFirstValueInFlattenedArray(args)}`)].join(",")
         : "main";
+    // When scaleReads is enabled, separate read and write commands into different pipelines
+    // so they can be routed to replicas and masters respectively
+    if (client.isCluster && client.options.scaleReads !== "master") {
+        const isReadOnly = (0, commands_1.exists)(commandName) && (0, commands_1.hasFlag)(commandName, "readonly");
+        slotKey += isReadOnly ? ":read" : ":write";
+    }
     if (!client._autoPipelines.has(slotKey)) {
         const pipeline = client.pipeline();
         pipeline[exports.kExec] = false;

package/built/cluster/ClusterOptions.d.ts

@@ -24,26 +24,26 @@ export interface ClusterOptions extends CommanderOptions {
      *
      * @default (times) => Math.min(100 + times * 2, 2000)
      */
-    clusterRetryStrategy?: (times: number, reason?: Error) => number | void | null;
+    clusterRetryStrategy?: ((times: number, reason?: Error) => number | void | null) | undefined;
     /**
      * See Redis class.
      *
      * @default true
      */
-    enableOfflineQueue?: boolean;
+    enableOfflineQueue?: boolean | undefined;
     /**
      * When enabled, ioredis only emits "ready" event when `CLUSTER INFO`
      * command reporting the cluster is ready for handling commands.
      *
      * @default true
      */
-    enableReadyCheck?: boolean;
+    enableReadyCheck?: boolean | undefined;
     /**
      * Scale reads to the node with the specified role.
      *
      * @default "master"
      */
-    scaleReads?: NodeRole | Function;
+    scaleReads?: NodeRole | Function | undefined;
     /**
      * When a MOVED or ASK error is received, client will redirect the
      * command to another node.
@@ -51,7 +51,7 @@ export interface ClusterOptions extends CommanderOptions {
      *
      * @default 16
      */
-    maxRedirections?: number;
+    maxRedirections?: number | undefined;
     /**
      * When an error is received when sending a command (e.g.
      * "Connection is closed." when the target Redis node is down), client will retry
@@ -59,21 +59,21 @@ export interface ClusterOptions extends CommanderOptions {
      *
      * @default 100
      */
-    retryDelayOnFailover?: number;
+    retryDelayOnFailover?: number | undefined;
     /**
      * When a CLUSTERDOWN error is received, client will retry
      * if `retryDelayOnClusterDown` is valid delay time (in ms).
      *
      * @default 100
      */
-    retryDelayOnClusterDown?: number;
+    retryDelayOnClusterDown?: number | undefined;
     /**
      * When a TRYAGAIN error is received, client will retry
      * if `retryDelayOnTryAgain` is valid delay time (in ms).
      *
      * @default 100
      */
-    retryDelayOnTryAgain?: number;
+    retryDelayOnTryAgain?: number | undefined;
     /**
      * By default, this value is 0, which means when a `MOVED` error is received,
      * the client will resend the command instantly to the node returned together with
@@ -83,20 +83,20 @@ export interface ClusterOptions extends CommanderOptions {
      *
      * @default 0
      */
-    retryDelayOnMoved?: number;
+    retryDelayOnMoved?: number | undefined;
     /**
      * The milliseconds before a timeout occurs while refreshing
      * slots from the cluster.
      *
      * @default 1000
      */
-    slotsRefreshTimeout?: number;
+    slotsRefreshTimeout?: number | undefined;
     /**
      * The milliseconds between every automatic slots refresh.
      *
      * @default 5000
      */
-    slotsRefreshInterval?: number;
+    slotsRefreshInterval?: number | undefined;
     /**
      * Use sharded subscribers instead of a single subscriber.
      *
@@ -105,13 +105,13 @@ export interface ClusterOptions extends CommanderOptions {
      *
      * @default false
      */
-    shardedSubscribers?: boolean;
+    shardedSubscribers?: boolean | undefined;
     /**
      * Passed to the constructor of `Redis`
      *
      * @default null
      */
-    redisOptions?: Omit<RedisOptions, "port" | "host" | "path" | "sentinels" | "retryStrategy" | "enableOfflineQueue" | "readOnly">;
+    redisOptions?: Omit<RedisOptions, "port" | "host" | "path" | "sentinels" | "retryStrategy" | "enableOfflineQueue" | "readOnly"> | undefined;
     /**
      * By default, When a new Cluster instance is created,
      * it will connect to the Redis cluster automatically.
@@ -120,13 +120,13 @@ export interface ClusterOptions extends CommanderOptions {
      *
      * @default false
      */
-    lazyConnect?: boolean;
+    lazyConnect?: boolean | undefined;
     /**
      * Discover nodes using SRV records
      *
      * @default false
      */
-    useSRVRecords?: boolean;
+    useSRVRecords?: boolean | undefined;
     /**
      * SRV records will be resolved via this function.
      *
@@ -135,7 +135,7 @@ export interface ClusterOptions extends CommanderOptions {
      *
      * @default require('dns').resolveSrv
      */
-    resolveSrv?: DNSResolveSrvFunction;
+    resolveSrv?: DNSResolveSrvFunction | undefined;
     /**
      * Hostnames will be resolved to IP addresses via this function.
      * This is needed when the addresses of startup nodes are hostnames instead
@@ -146,20 +146,20 @@ export interface ClusterOptions extends CommanderOptions {
      *
      * @default require('dns').lookup
      */
-    dnsLookup?: DNSLookupFunction;
-    natMap?: NatMap;
+    dnsLookup?: DNSLookupFunction | undefined;
+    natMap?: NatMap | undefined;
     /**
      * See Redis class.
      *
      * @default false
      */
-    enableAutoPipelining?: boolean;
+    enableAutoPipelining?: boolean | undefined;
     /**
      * See Redis class.
      *
      * @default []
      */
-    autoPipeliningIgnoredCommands?: string[];
+    autoPipeliningIgnoredCommands?: string[] | undefined;
     /**
      * Custom LUA commands
      */
@@ -167,6 +167,6 @@ export interface ClusterOptions extends CommanderOptions {
         lua: string;
         numberOfKeys?: number;
         readOnly?: boolean;
-    }>;
+    }> | undefined;
 }
 export declare const DEFAULT_CLUSTER_OPTIONS: ClusterOptions;

package/built/cluster/ClusterSubscriberGroup.d.ts

@@ -46,7 +46,7 @@ export default class ClusterSubscriberGroup {
      */
     removeChannels(channels: (string | Buffer)[]): number;
     /**
-     * Disconnect all subscribers
+     * Disconnect all subscribers and clear some of the internal state.
      */
     stop(): void;
     /**

package/built/cluster/ClusterSubscriberGroup.js

@@ -112,12 +112,17 @@ class ClusterSubscriberGroup {
         return Array.from(this.channels.values()).reduce((sum, array) => sum + array.length, 0);
     }
     /**
-     * Disconnect all subscribers
+     * Disconnect all subscribers and clear some of the internal state.
      */
     stop() {
         for (const s of this.shardedSubscribers.values()) {
             s.stop();
         }
+        // Clear subscriber instances and pending operations.
+        // Channels are preserved for resubscription on reconnect.
+        this.pendingReset = null;
+        this.shardedSubscribers.clear();
+        this.subscriberToSlotsIndex.clear();
     }
     /**
      * Start all not yet started subscribers

package/built/cluster/index.js

@@ -890,18 +890,28 @@ class Cluster extends Commander_1.default {
     createShardedSubscriberGroup() {
         this.subscriberGroupEmitter = new events_1.EventEmitter();
         this.shardedSubscribers = new ClusterSubscriberGroup_1.default(this.subscriberGroupEmitter);
+        // Error handler used only for sharded-subscriber-triggered slots cache refreshes.
+        // Normal (non-subscriber) connections are created with lazyConnect: true and can
+        // become zombied. For sharded subscribers, a ClusterAllFailedError means
+        // we have lost all nodes from the subscriber perspective and must tear down.
+        const refreshSlotsCacheCallback = (err) => {
+            // Disconnect only when refreshing the slots cache fails with ClusterAllFailedError
+            if (err instanceof ClusterAllFailedError_1.default) {
+                this.disconnect(true);
+            }
+        };
         this.subscriberGroupEmitter.on("-node", (redis, nodeKey) => {
             this.emit("-node", redis, nodeKey);
-            this.refreshSlotsCache();
+            this.refreshSlotsCache(refreshSlotsCacheCallback);
         });
         this.subscriberGroupEmitter.on("subscriberConnectFailed", ({ delay, error }) => {
             this.emit("error", error);
             setTimeout(() => {
-                this.refreshSlotsCache();
+                this.refreshSlotsCache(refreshSlotsCacheCallback);
             }, delay);
         });
         this.subscriberGroupEmitter.on("moved", () => {
-            this.refreshSlotsCache();
+            this.refreshSlotsCache(refreshSlotsCacheCallback);
         });
         this.subscriberGroupEmitter.on("-subscriber", () => {
             this.emit("-subscriber");

package/built/cluster/util.d.ts

@@ -5,8 +5,8 @@ export declare type NodeRole = "master" | "slave" | "all";
 export interface RedisOptions {
     port: number;
     host: string;
-    username?: string;
-    password?: string;
+    username?: string | undefined;
+    password?: string | undefined;
     [key: string]: any;
 }
 export interface SrvRecordsGroup {

package/built/connectors/SentinelConnector/index.d.ts

@@ -9,46 +9,46 @@ import { NetStream } from "../../types";
 interface AddressFromResponse {
     port: string;
     ip: string;
-    flags?: string;
+    flags?: string | undefined;
 }
 declare type PreferredSlaves = ((slaves: AddressFromResponse[]) => AddressFromResponse | null) | Array<{
     port: string;
     ip: string;
-    prio?: number;
+    prio?: number | undefined;
 }> | {
     port: string;
     ip: string;
-    prio?: number;
+    prio?: number | undefined;
 };
 export { SentinelAddress, SentinelIterator };
 export interface SentinelConnectionOptions {
     /**
      * Master group name of the Sentinel
      */
-    name?: string;
+    name?: string | undefined;
     /**
      * @default "master"
      */
-    role?: "master" | "slave";
-    tls?: ConnectionOptions;
-    sentinelUsername?: string;
-    sentinelPassword?: string;
-    sentinels?: Array<Partial<SentinelAddress>>;
-    sentinelRetryStrategy?: (retryAttempts: number) => number | void | null;
-    sentinelReconnectStrategy?: (retryAttempts: number) => number | void | null;
-    preferredSlaves?: PreferredSlaves;
-    connectTimeout?: number;
-    disconnectTimeout?: number;
-    sentinelCommandTimeout?: number;
-    enableTLSForSentinelMode?: boolean;
-    sentinelTLS?: ConnectionOptions;
-    natMap?: NatMap;
-    updateSentinels?: boolean;
+    role?: "master" | "slave" | undefined;
+    tls?: ConnectionOptions | undefined;
+    sentinelUsername?: string | undefined;
+    sentinelPassword?: string | undefined;
+    sentinels?: Array<Partial<SentinelAddress>> | undefined;
+    sentinelRetryStrategy?: ((retryAttempts: number) => number | void | null) | undefined;
+    sentinelReconnectStrategy?: ((retryAttempts: number) => number | void | null) | undefined;
+    preferredSlaves?: PreferredSlaves | undefined;
+    connectTimeout?: number | undefined;
+    disconnectTimeout?: number | undefined;
+    sentinelCommandTimeout?: number | undefined;
+    enableTLSForSentinelMode?: boolean | undefined;
+    sentinelTLS?: ConnectionOptions | undefined;
+    natMap?: NatMap | undefined;
+    updateSentinels?: boolean | undefined;
     /**
      * @default 10
      */
-    sentinelMaxConnections?: number;
-    failoverDetector?: boolean;
+    sentinelMaxConnections?: number | undefined;
+    failoverDetector?: boolean | undefined;
 }
 export default class SentinelConnector extends AbstractConnector {
     protected options: SentinelConnectionOptions;

package/built/connectors/StandaloneConnector.d.ts

@@ -6,8 +6,8 @@ import AbstractConnector, { ErrorEmitter } from "./AbstractConnector";
 declare type TcpOptions = Pick<TcpNetConnectOpts, "port" | "host" | "family">;
 declare type IpcOptions = Pick<IpcNetConnectOpts, "path">;
 export declare type StandaloneConnectionOptions = Partial<TcpOptions & IpcOptions> & {
-    disconnectTimeout?: number;
-    tls?: ConnectionOptions;
+    disconnectTimeout?: number | undefined;
+    tls?: ConnectionOptions | undefined;
 };
 export default class StandaloneConnector extends AbstractConnector {
     protected options: StandaloneConnectionOptions;

package/built/redis/RedisOptions.d.ts

@@ -4,89 +4,89 @@ import { SentinelConnectionOptions } from "../connectors/SentinelConnector";
 import { StandaloneConnectionOptions } from "../connectors/StandaloneConnector";
 export declare type ReconnectOnError = (err: Error) => boolean | 1 | 2;
 export interface CommonRedisOptions extends CommanderOptions {
-    Connector?: ConnectorConstructor;
-    retryStrategy?: (times: number) => number | void | null;
+    Connector?: ConnectorConstructor | undefined;
+    retryStrategy?: ((times: number) => number | void | null) | undefined;
     /**
      * If a command does not return a reply within a set number of milliseconds,
      * a "Command timed out" error will be thrown.
      */
-    commandTimeout?: number;
+    commandTimeout?: number | undefined;
     /**
      * Enables client-side timeout protection for blocking commands when set
      * to a positive number. If `blockingTimeout` is undefined, `0`, or
      * negative (e.g. `-1`), the protection is disabled and no client-side
      * timers are installed for blocking commands.
      */
-    blockingTimeout?: number;
+    blockingTimeout?: number | undefined;
     /**
      * Grace period (ms) added to blocking command timeouts. Only used when
      * `blockingTimeout` is a positive number. Defaults to 100ms.
      */
-    blockingTimeoutGrace?: number;
+    blockingTimeoutGrace?: number | undefined;
     /**
      * If the socket does not receive data within a set number of milliseconds:
      * 1. the socket is considered "dead" and will be destroyed
      * 2. the client will reject any running commands (altought they might have been processed by the server)
      * 3. the reconnect strategy will kick in (depending on the configuration)
      */
-    socketTimeout?: number;
+    socketTimeout?: number | undefined;
     /**
      * Enable/disable keep-alive functionality.
      * @link https://nodejs.org/api/net.html#socketsetkeepaliveenable-initialdelay
      * @default 0
      */
-    keepAlive?: number;
+    keepAlive?: number | undefined;
     /**
      * Enable/disable the use of Nagle's algorithm.
      * @link https://nodejs.org/api/net.html#socketsetnodelaynodelay
      * @default true
      */
-    noDelay?: boolean;
+    noDelay?: boolean | undefined;
     /**
      * Set the name of the connection to make it easier to identity the connection
      * in client list.
      * @link https://redis.io/commands/client-setname
      */
-    connectionName?: string;
+    connectionName?: string | undefined;
     /**
      * If true, skips setting library info via CLIENT SETINFO.
      * @link https://redis.io/docs/latest/commands/client-setinfo/
      * @default false
      */
-    disableClientInfo?: boolean;
+    disableClientInfo?: boolean | undefined;
     /**
      * Tag to append to the library name in CLIENT SETINFO (ioredis(tag)).
      * @link https://redis.io/docs/latest/commands/client-setinfo/
      * @default undefined
      */
-    clientInfoTag?: string;
+    clientInfoTag?: string | undefined;
     /**
      * 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;
+    username?: string | undefined;
     /**
      * If set, client will send AUTH command with the value of this option when connected.
      */
-    password?: string;
+    password?: string | undefined;
     /**
      * Database index to use.
      *
      * @default 0
      */
-    db?: number;
+    db?: number | undefined;
     /**
      * When the client reconnects, channels subscribed in the previous connection will be
      * resubscribed automatically if `autoResubscribe` is `true`.
      * @default true
      */
-    autoResubscribe?: boolean;
+    autoResubscribe?: boolean | undefined;
     /**
      * Whether or not to resend unfulfilled commands on reconnect.
      * Unfulfilled commands are most likely to be blocking commands such as `brpop` or `blpop`.
      * @default true
      */
-    autoResendUnfulfilledCommands?: boolean;
+    autoResendUnfulfilledCommands?: boolean | undefined;
     /**
      * Whether or not to reconnect on certain Redis errors.
      * This options by default is `null`, which means it should never reconnect on Redis errors.
@@ -108,29 +108,29 @@ export interface CommonRedisOptions extends CommanderOptions {
      * ```
      * @default null
      */
-    reconnectOnError?: ReconnectOnError | null;
+    reconnectOnError?: ReconnectOnError | null | undefined;
     /**
      * @default false
      */
-    readOnly?: boolean;
+    readOnly?: boolean | undefined;
     /**
      * When enabled, numbers returned by Redis will be converted to JavaScript strings instead of numbers.
      * This is necessary if you want to handle big numbers (above `Number.MAX_SAFE_INTEGER` === 2^53).
      * @default false
      */
-    stringNumbers?: boolean;
+    stringNumbers?: boolean | undefined;
     /**
      * How long the client will wait before killing a socket due to inactivity during initial connection.
      * @default 10000
      */
-    connectTimeout?: number;
+    connectTimeout?: number | undefined;
     /**
      * 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;
+    monitor?: boolean | undefined;
     /**
      * 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).
@@ -141,21 +141,21 @@ export interface CommonRedisOptions extends CommanderOptions {
      *
      * @default 20
      */
-    maxRetriesPerRequest?: number | null;
+    maxRetriesPerRequest?: number | null | undefined;
     /**
      * @default 10000
      */
-    maxLoadingRetryTime?: number;
+    maxLoadingRetryTime?: number | undefined;
     /**
      * @default false
      */
-    enableAutoPipelining?: boolean;
+    enableAutoPipelining?: boolean | undefined;
     /**
      * @default []
      */
-    autoPipeliningIgnoredCommands?: string[];
-    offlineQueue?: boolean;
-    commandQueue?: boolean;
+    autoPipeliningIgnoredCommands?: string[] | undefined;
+    offlineQueue?: boolean | undefined;
+    commandQueue?: boolean | undefined;
     /**
      *
      * By default, if the connection to Redis server has not been established, commands are added to a queue
@@ -166,7 +166,7 @@ export interface CommonRedisOptions extends CommanderOptions {
      *
      * @default true
      */
-    enableOfflineQueue?: boolean;
+    enableOfflineQueue?: boolean | undefined;
     /**
      * 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
@@ -174,7 +174,7 @@ export interface CommonRedisOptions extends CommanderOptions {
      *
      * @default true
      */
-    enableReadyCheck?: boolean;
+    enableReadyCheck?: boolean | undefined;
     /**
      * 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
@@ -183,15 +183,15 @@ export interface CommonRedisOptions extends CommanderOptions {
      *
      * @default false
      */
-    lazyConnect?: boolean;
+    lazyConnect?: boolean | undefined;
     /**
      * @default undefined
      */
     scripts?: Record<string, {
         lua: string;
-        numberOfKeys?: number;
-        readOnly?: boolean;
-    }>;
+        numberOfKeys?: number | undefined;
+        readOnly?: boolean | undefined;
+    }> | undefined;
 }
 export declare type RedisOptions = CommonRedisOptions & SentinelConnectionOptions & StandaloneConnectionOptions;
 export declare const DEFAULT_REDIS_OPTIONS: RedisOptions;

package/built/utils/Commander.d.ts

@@ -2,8 +2,8 @@ import Command from "../Command";
 import { WriteableStream } from "../types";
 import RedisCommander, { ClientContext } from "./RedisCommander";
 export interface CommanderOptions {
-    keyPrefix?: string;
-    showFriendlyErrorStack?: boolean;
+    keyPrefix?: string | undefined;
+    showFriendlyErrorStack?: boolean | undefined;
 }
 declare class Commander<Context extends ClientContext = {
     type: "default";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ioredis",
-  "version": "5.9.1",
+  "version": "5.9.3",
   "description": "A robust, performance-focused and full-featured Redis client for Node.js.",
   "main": "./built/index.js",
   "types": "./built/index.d.ts",