ioredis 5.6.1 → 5.8.0

package/README.md

@@ -262,7 +262,7 @@ async function listenForMessage(lastId = "$") {
   // `results` is an array, each element of which corresponds to a key.
   // Because we only listen to one key (mystream) here, `results` only contains
   // a single element. See more: https://redis.io/commands/xread#return-value
-  const results = await redis.xread("block", 0, "STREAMS", "mystream", lastId);
+  const results = await redis.xread("BLOCK", 0, "STREAMS", "mystream", lastId);
   const [key, messages] = results[0]; // `key` equals to "mystream"
 
   messages.forEach(processMessage);
@@ -826,7 +826,7 @@ The Redis instance will emit some events about the state of the connection to th
 | :----------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | connect      | emits when a connection is established to the Redis server.                                                                                                                                                                                     |
 | ready        | If `enableReadyCheck` is `true`, client will emit `ready` when the server reports that it is ready to receive commands (e.g. finish loading data from disk).<br>Otherwise, `ready` will be emitted immediately right after the `connect` event. |
-| error        | emits when an error occurs while connecting.<br>However, ioredis emits all `error` events silently (only emits when there's at least one listener) so that your application won't crash if you're not listening to the `error` event.           |
+| error        | emits when an error occurs while connecting.<br>However, ioredis emits all `error` events silently (only emits when there's at least one listener) so that your application won't crash if you're not listening to the `error` event.<br>When `redis.connect()` is explicitly called the error will also be rejected from the returned promise, in addition to emitting it. If `redis.connect()` is not called explicitly and `lazyConnect` is true, ioredis will try to connect automatically on the first command and emit the `error` event silently.                                                      |
 | close        | emits when an established Redis server connection has closed.                                                                                                                                                                                   |
 | reconnecting | emits after `close` when a reconnection will be made. The argument of the event is the time (in ms) before reconnecting.                                                                                                                        |
 | end          | emits after `close` when no more reconnections will be made, or the connection is failed to establish.                                                                                                                                          |
@@ -1149,7 +1149,7 @@ const cluster = new Redis.Cluster(
   ],
   {
     natMap: (key) => {
-      if(key.indexOf('30001')) {
+      if(key.includes('30001')) {
         return { host: "203.0.113.73", port: 30001 };
       }
 

package/built/DataHandler.js

@@ -41,6 +41,10 @@ class DataHandler {
             name: item.command.name,
             args: item.command.args,
         };
+        if (item.command.name == "ssubscribe" && err.message.includes("MOVED")) {
+            this.redis.emit("moved");
+            return;
+        }
         this.redis.handleReconnection(err, item);
     }
     returnReply(reply) {

package/built/Redis.d.ts

@@ -81,7 +81,8 @@ declare class Redis extends Commander implements DataHandledable {
      * unless `lazyConnect: true` is passed.
      *
      * When calling this method manually, a Promise is returned, which will
-     * be resolved when the connection status is ready.
+     * be resolved when the connection status is ready. The promise can reject
+     * if the connection fails, times out, or if Redis is already connecting/connected.
      */
     connect(callback?: Callback<void>): Promise<void>;
     /**

package/built/Redis.js

@@ -97,7 +97,8 @@ class Redis extends Commander_1.default {
      * unless `lazyConnect: true` is passed.
      *
      * When calling this method manually, a Promise is returned, which will
-     * be resolved when the connection status is ready.
+     * be resolved when the connection status is ready. The promise can reject
+     * if the connection fails, times out, or if Redis is already connecting/connected.
      */
     connect(callback) {
         const promise = new Promise((resolve, reject) => {

package/built/cluster/ClusterSubscriber.js

@@ -131,6 +131,9 @@ class ClusterSubscriber {
         });
         // Ignore the errors since they're handled in the connection pool.
         this.subscriber.on("error", utils_1.noop);
+        this.subscriber.on("moved", () => {
+            this.emitter.emit("forceRefresh");
+        });
         // The node we lost connection to may not come back up in a
         // reasonable amount of time (e.g. a slave that's taken down
         // for maintainence), we could potentially miss many published

package/built/cluster/ClusterSubscriberGroup.d.ts

@@ -23,7 +23,7 @@ export default class ClusterSubscriberGroup {
      *
      * @param cluster
      */
-    constructor(cluster: Cluster);
+    constructor(cluster: Cluster, refreshSlotsCacheCallback: () => void);
     /**
      * Get the responsible subscriber.
      *

package/built/cluster/ClusterSubscriberGroup.js

@@ -23,7 +23,7 @@ class ClusterSubscriberGroup {
      *
      * @param cluster
      */
-    constructor(cluster) {
+    constructor(cluster, refreshSlotsCacheCallback) {
         this.cluster = cluster;
         this.shardedSubscribers = new Map();
         this.clusterSlots = [];
@@ -39,6 +39,9 @@ class ClusterSubscriberGroup {
         cluster.on("refresh", () => {
             this._refreshSlots(cluster);
         });
+        cluster.on("forceRefresh", () => {
+            refreshSlotsCacheCallback();
+        });
     }
     /**
      * Get the responsible subscriber.

package/built/cluster/index.js

@@ -63,7 +63,7 @@ class Cluster extends Commander_1.default {
         this.startupNodes = startupNodes;
         this.options = (0, utils_1.defaults)({}, options, ClusterOptions_1.DEFAULT_CLUSTER_OPTIONS, this.options);
         if (this.options.shardedSubscribers == true)
-            this.shardedSubscribers = new ClusterSubscriberGroup_1.default(this);
+            this.shardedSubscribers = new ClusterSubscriberGroup_1.default(this, this.refreshSlotsCache.bind(this));
         if (this.options.redisOptions &&
             this.options.redisOptions.keyPrefix &&
             !this.options.keyPrefix) {

package/built/redis/RedisOptions.d.ts

@@ -36,6 +36,18 @@ export interface CommonRedisOptions extends CommanderOptions {
      * @link https://redis.io/commands/client-setname
      */
     connectionName?: string;
+    /**
+     * If true, skips setting library info via CLIENT SETINFO.
+     * @link https://redis.io/docs/latest/commands/client-setinfo/
+     * @default false
+     */
+    disableClientInfo?: boolean;
+    /**
+     * 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;
     /**
      * 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.
@@ -154,7 +166,8 @@ export interface CommonRedisOptions extends CommanderOptions {
     /**
      * 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.
+     * explicitly. When `redis.connect()` is called explicitly, a Promise is returned, which will be resolved
+     * when the connection is ready or rejected when it fails. The rejection should be handled by the user.
      *
      * @default false
      */

package/built/redis/RedisOptions.js

@@ -14,6 +14,8 @@ exports.DEFAULT_REDIS_OPTIONS = {
     keepAlive: 0,
     noDelay: true,
     connectionName: null,
+    disableClientInfo: false,
+    clientInfoTag: undefined,
     // Sentinel
     sentinels: null,
     name: null,

package/built/redis/event_handler.js

@@ -199,6 +199,7 @@ function errorHandler(self) {
 exports.errorHandler = errorHandler;
 function readyHandler(self) {
     return function () {
+        var _a, _b;
         self.setStatus("ready");
         self.retryAttempts = 0;
         if (self.options.monitor) {
@@ -223,6 +224,25 @@ function readyHandler(self) {
             debug("set the connection name [%s]", self.options.connectionName);
             self.client("setname", self.options.connectionName).catch(utils_1.noop);
         }
+        if (!((_a = self.options) === null || _a === void 0 ? void 0 : _a.disableClientInfo)) {
+            debug("set the client info");
+            let version = null;
+            (0, utils_1.getPackageMeta)()
+                .then((packageMeta) => {
+                version = packageMeta === null || packageMeta === void 0 ? void 0 : packageMeta.version;
+            })
+                .catch(utils_1.noop)
+                .finally(() => {
+                self
+                    .client("SETINFO", "LIB-VER", version)
+                    .catch(utils_1.noop);
+            });
+            self
+                .client("SETINFO", "LIB-NAME", ((_b = self.options) === null || _b === void 0 ? void 0 : _b.clientInfoTag)
+                ? `ioredis(${self.options.clientInfoTag})`
+                : "ioredis")
+                .catch(utils_1.noop);
+        }
         if (self.options.readOnly) {
             debug("set the connection to readonly mode");
             self.readonly().catch(utils_1.noop);
@@ -249,8 +269,10 @@ function readyHandler(self) {
                 }
                 const ssubscribeChannels = condition.subscriber.channels("ssubscribe");
                 if (ssubscribeChannels.length) {
-                    debug("ssubscribe %d channels", ssubscribeChannels.length);
-                    self.ssubscribe(ssubscribeChannels);
+                    debug("ssubscribe %s", ssubscribeChannels.length);
+                    for (const channel of ssubscribeChannels) {
+                        self.ssubscribe(channel);
+                    }
                 }
             }
         }

package/built/utils/RedisCommander.d.ts

@@ -2247,6 +2247,22 @@ interface RedisCommander<Context extends ClientContext = {
      * - _since_: 2.0.0
      */
     hexists(key: RedisKey, field: string | Buffer, callback?: Callback<number>): Result<number, Context>;
+    /**
+     * Set expiry for hash field using relative time to expire (seconds)
+     * - _group_: hash
+     * - _complexity_: O(N) where N is the number of specified fields
+     * - _since_: 7.4.0
+     */
+    hexpire(...args: [key: RedisKey, seconds: number | string, fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hexpire(...args: [key: RedisKey, seconds: number | string, fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    hexpire(...args: [key: RedisKey, seconds: number | string, nx: 'NX', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hexpire(...args: [key: RedisKey, seconds: number | string, nx: 'NX', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    hexpire(...args: [key: RedisKey, seconds: number | string, xx: 'XX', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hexpire(...args: [key: RedisKey, seconds: number | string, xx: 'XX', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    hexpire(...args: [key: RedisKey, seconds: number | string, gt: 'GT', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hexpire(...args: [key: RedisKey, seconds: number | string, gt: 'GT', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    hexpire(...args: [key: RedisKey, seconds: number | string, lt: 'LT', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hexpire(...args: [key: RedisKey, seconds: number | string, lt: 'LT', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
     /**
      * Get the value of a hash field
      * - _group_: hash
@@ -2325,6 +2341,22 @@ interface RedisCommander<Context extends ClientContext = {
         callback: Callback<"OK">
     ]): Result<"OK", Context>;
     hmset(...args: [key: RedisKey, ...fieldValues: (string | Buffer | number)[]]): Result<"OK", Context>;
+    /**
+     * Set expiry for hash field using relative time to expire (milliseconds)
+     * - _group_: hash
+     * - _complexity_: O(N) where N is the number of specified fields
+     * - _since_: 7.4.0
+     */
+    hpexpire(...args: [key: RedisKey, milliseconds: number | string, fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hpexpire(...args: [key: RedisKey, milliseconds: number | string, fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    hpexpire(...args: [key: RedisKey, milliseconds: number | string, nx: 'NX', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hpexpire(...args: [key: RedisKey, milliseconds: number | string, nx: 'NX', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    hpexpire(...args: [key: RedisKey, milliseconds: number | string, xx: 'XX', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hpexpire(...args: [key: RedisKey, milliseconds: number | string, xx: 'XX', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    hpexpire(...args: [key: RedisKey, milliseconds: number | string, gt: 'GT', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hpexpire(...args: [key: RedisKey, milliseconds: number | string, gt: 'GT', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    hpexpire(...args: [key: RedisKey, milliseconds: number | string, lt: 'LT', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hpexpire(...args: [key: RedisKey, milliseconds: number | string, lt: 'LT', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
     /**
      * Get one or multiple random fields from a hash
      * - _group_: hash
@@ -5315,6 +5347,70 @@ interface RedisCommander<Context extends ClientContext = {
         callback: Callback<number>
     ]): Result<number, Context>;
     xdel(...args: [key: RedisKey, ...ids: (string | Buffer | number)[]]): Result<number, Context>;
+    /**
+     * Deletes one or multiple entries from the stream.
+     * - _group_: stream
+     * - _complexity_: O(1) for each single item to delete in the stream, regardless of the stream size.
+     * - _since_: 8.2.0
+     */
+    xdelex(...args: [
+        key: RedisKey,
+        idsToken: "IDS",
+        numids: number | string,
+        ...ids: (string | Buffer | number)[],
+        callback: Callback<unknown>
+    ]): Result<unknown, Context>;
+    xdelex(...args: [
+        key: RedisKey,
+        idsToken: "IDS",
+        numids: number | string,
+        ...ids: (string | Buffer | number)[]
+    ]): Result<unknown, Context>;
+    xdelex(...args: [
+        key: RedisKey,
+        keepref: "KEEPREF",
+        idsToken: "IDS",
+        numids: number | string,
+        ...ids: (string | Buffer | number)[],
+        callback: Callback<unknown>
+    ]): Result<unknown, Context>;
+    xdelex(...args: [
+        key: RedisKey,
+        keepref: "KEEPREF",
+        idsToken: "IDS",
+        numids: number | string,
+        ...ids: (string | Buffer | number)[]
+    ]): Result<unknown, Context>;
+    xdelex(...args: [
+        key: RedisKey,
+        delref: "DELREF",
+        idsToken: "IDS",
+        numids: number | string,
+        ...ids: (string | Buffer | number)[],
+        callback: Callback<unknown>
+    ]): Result<unknown, Context>;
+    xdelex(...args: [
+        key: RedisKey,
+        delref: "DELREF",
+        idsToken: "IDS",
+        numids: number | string,
+        ...ids: (string | Buffer | number)[]
+    ]): Result<unknown, Context>;
+    xdelex(...args: [
+        key: RedisKey,
+        acked: "ACKED",
+        idsToken: "IDS",
+        numids: number | string,
+        ...ids: (string | Buffer | number)[],
+        callback: Callback<unknown>
+    ]): Result<unknown, Context>;
+    xdelex(...args: [
+        key: RedisKey,
+        acked: "ACKED",
+        idsToken: "IDS",
+        numids: number | string,
+        ...ids: (string | Buffer | number)[]
+    ]): Result<unknown, Context>;
     /**
      * Create a consumer group.
      * - _group_: stream
@@ -5788,23 +5884,59 @@ interface RedisCommander<Context extends ClientContext = {
     xsetid(key: RedisKey, lastId: string | Buffer | number, entriesAddedToken: "ENTRIESADDED", entriesAdded: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
     xsetid(key: RedisKey, lastId: string | Buffer | number, entriesAddedToken: "ENTRIESADDED", entriesAdded: number | string, maxDeletedEntryIdToken: "MAXDELETEDID", maxDeletedEntryId: string | Buffer | number, callback?: Callback<unknown>): Result<unknown, Context>;
     /**
-     * Trims the stream to (approximately if '~' is passed) a certain size
+     * Deletes messages from the beginning of a stream.
      * - _group_: stream
      * - _complexity_: O(N), with N being the number of evicted entries. Constant times are very small however, since entries are organized in macro nodes containing multiple entries that can be released with a single deallocation.
      * - _since_: 5.0.0
      */
     xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | Buffer | number, keepref: "KEEPREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | Buffer | number, delref: "DELREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | Buffer | number, acked: "ACKED", callback?: Callback<number>): Result<number, Context>;
     xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, keepref: "KEEPREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, delref: "DELREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, acked: "ACKED", callback?: Callback<number>): Result<number, Context>;
     xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | Buffer | number, keepref: "KEEPREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | Buffer | number, delref: "DELREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | Buffer | number, acked: "ACKED", callback?: Callback<number>): Result<number, Context>;
     xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, keepref: "KEEPREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, delref: "DELREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, acked: "ACKED", callback?: Callback<number>): Result<number, Context>;
     xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | Buffer | number, keepref: "KEEPREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | Buffer | number, delref: "DELREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | Buffer | number, acked: "ACKED", callback?: Callback<number>): Result<number, Context>;
     xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, keepref: "KEEPREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, delref: "DELREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, acked: "ACKED", callback?: Callback<number>): Result<number, Context>;
     xtrim(key: RedisKey, minid: "MINID", threshold: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", threshold: string | Buffer | number, keepref: "KEEPREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", threshold: string | Buffer | number, delref: "DELREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", threshold: string | Buffer | number, acked: "ACKED", callback?: Callback<number>): Result<number, Context>;
     xtrim(key: RedisKey, minid: "MINID", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, keepref: "KEEPREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, delref: "DELREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, acked: "ACKED", callback?: Callback<number>): Result<number, Context>;
     xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | Buffer | number, keepref: "KEEPREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | Buffer | number, delref: "DELREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | Buffer | number, acked: "ACKED", callback?: Callback<number>): Result<number, Context>;
     xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, keepref: "KEEPREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, delref: "DELREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, acked: "ACKED", callback?: Callback<number>): Result<number, Context>;
     xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | Buffer | number, keepref: "KEEPREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | Buffer | number, delref: "DELREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | Buffer | number, acked: "ACKED", callback?: Callback<number>): Result<number, Context>;
     xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, keepref: "KEEPREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, delref: "DELREF", callback?: Callback<number>): Result<number, Context>;
+    xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | Buffer | number, countToken: "LIMIT", count: number | string, acked: "ACKED", callback?: Callback<number>): Result<number, Context>;
     /**
      * Add one or more members to a sorted set, or update its score if it already exists
      * - _group_: sorted-set

package/built/utils/index.d.ts

@@ -112,4 +112,13 @@ export declare function shuffle<T>(array: T[]): T[];
  */
 export declare const CONNECTION_CLOSED_ERROR_MSG = "Connection is closed.";
 export declare function zipMap<K, V>(keys: K[], values: V[]): Map<K, V>;
+/**
+ * Retrieves cached package metadata from package.json.
+ *
+ * @internal
+ * @returns {Promise<{version: string} | null>} Package metadata or null if unavailable
+ */
+export declare function getPackageMeta(): Promise<{
+    version: string;
+}>;
 export { Debug, defaults, noop };

package/built/utils/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.noop = exports.defaults = exports.Debug = exports.zipMap = exports.CONNECTION_CLOSED_ERROR_MSG = exports.shuffle = exports.sample = exports.resolveTLSProfile = exports.parseURL = exports.optimizeErrorStack = exports.toArg = exports.convertMapToArray = exports.convertObjectToArray = exports.timeout = exports.packObject = exports.isInt = exports.wrapMultiResult = exports.convertBufferToString = void 0;
+exports.noop = exports.defaults = exports.Debug = exports.getPackageMeta = exports.zipMap = exports.CONNECTION_CLOSED_ERROR_MSG = exports.shuffle = exports.sample = exports.resolveTLSProfile = exports.parseURL = exports.optimizeErrorStack = exports.toArg = exports.convertMapToArray = exports.convertObjectToArray = exports.timeout = exports.packObject = exports.isInt = exports.wrapMultiResult = exports.convertBufferToString = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
 const url_1 = require("url");
 const lodash_1 = require("./lodash");
 Object.defineProperty(exports, "defaults", { enumerable: true, get: function () { return lodash_1.defaults; } });
@@ -295,3 +297,36 @@ function zipMap(keys, values) {
     return map;
 }
 exports.zipMap = zipMap;
+/**
+ * Memoized package metadata to avoid repeated file system reads.
+ *
+ * @internal
+ */
+let cachedPackageMeta = null;
+/**
+ * Retrieves cached package metadata from package.json.
+ *
+ * @internal
+ * @returns {Promise<{version: string} | null>} Package metadata or null if unavailable
+ */
+async function getPackageMeta() {
+    if (cachedPackageMeta) {
+        return cachedPackageMeta;
+    }
+    try {
+        const filePath = (0, path_1.resolve)(__dirname, "..", "..", "package.json");
+        const data = await fs_1.promises.readFile(filePath, "utf8");
+        const parsed = JSON.parse(data);
+        cachedPackageMeta = {
+            version: parsed.version,
+        };
+        return cachedPackageMeta;
+    }
+    catch (err) {
+        cachedPackageMeta = {
+            version: "error-fetching-version",
+        };
+        return cachedPackageMeta;
+    }
+}
+exports.getPackageMeta = getPackageMeta;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ioredis",
-  "version": "5.6.1",
+  "version": "5.8.0",
   "description": "A robust, performance-focused and full-featured Redis client for Node.js.",
   "main": "./built/index.js",
   "types": "./built/index.d.ts",
@@ -8,10 +8,12 @@
     "built/"
   ],
   "scripts": {
+    "cluster:setup": "docker compose -f test/cluster/docker-compose.cluster.yml up -d --wait",
+    "cluster:teardown": "docker compose -f test/cluster/docker-compose.cluster.yml down --volumes --remove-orphans",
     "test:tsd": "npm run build && tsd",
     "test:js": "TS_NODE_TRANSPILE_ONLY=true NODE_ENV=test mocha \"test/helpers/*.ts\" \"test/unit/**/*.ts\" \"test/functional/**/*.ts\"",
     "test:cov": "nyc npm run test:js",
-    "test:js:cluster": "TS_NODE_TRANSPILE_ONLY=true NODE_ENV=test mocha \"test/cluster/**/*.ts\"",
+    "test:cluster": "TS_NODE_TRANSPILE_ONLY=true NODE_ENV=test mocha \"test/cluster/**/*.ts\"",
     "test": "npm run test:js && npm run test:tsd",
     "lint": "eslint --ext .js,.ts ./lib",
     "docs": "npx typedoc --logLevel Error --excludeExternals --excludeProtected --excludePrivate --readme none lib/index.ts",
@@ -41,7 +43,7 @@
     "url": "https://opencollective.com/ioredis"
   },
   "dependencies": {
-    "@ioredis/commands": "^1.1.1",
+    "@ioredis/commands": "1.4.0",
     "cluster-key-slot": "^1.1.0",
     "debug": "^4.3.4",
     "denque": "^2.1.0",