ioredis 5.9.3 → 5.10.1

package/built/cluster/ClusterSubscriberGroup.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import * as EventEmitter from "events";
 import ShardedSubscriber from "./ShardedSubscriber";
+import { ClusterOptions } from "./ClusterOptions";
 /**
  * Redis distinguishes between "normal" and sharded PubSub. When using the normal PubSub feature,
  * exactly one subscriber exists per cluster instance because the Redis cluster bus forwards
@@ -12,6 +13,7 @@ import ShardedSubscriber from "./ShardedSubscriber";
  */
 export default class ClusterSubscriberGroup {
     private readonly subscriberGroupEmitter;
+    private readonly options;
     private shardedSubscribers;
     private clusterSlots;
     private subscriberToSlotsIndex;
@@ -27,7 +29,7 @@ export default class ClusterSubscriberGroup {
      *
      * @param cluster
      */
-    constructor(subscriberGroupEmitter: EventEmitter);
+    constructor(subscriberGroupEmitter: EventEmitter, options: ClusterOptions);
     /**
      * Get the responsible subscriber.
      *
@@ -102,4 +104,5 @@ export default class ClusterSubscriberGroup {
      * @param nodeKey
      */
     private handleSubscriberConnectSucceeded;
+    private shouldStartSubscriber;
 }

package/built/cluster/ClusterSubscriberGroup.js

@@ -20,8 +20,9 @@ class ClusterSubscriberGroup {
      *
      * @param cluster
      */
-    constructor(subscriberGroupEmitter) {
+    constructor(subscriberGroupEmitter, options) {
         this.subscriberGroupEmitter = subscriberGroupEmitter;
+        this.options = options;
         this.shardedSubscribers = new Map();
         this.clusterSlots = [];
         // Simple [min, max] slot ranges aren't enough because you can migrate single slots
@@ -68,7 +69,18 @@ class ClusterSubscriberGroup {
      */
     getResponsibleSubscriber(slot) {
         const nodeKey = this.clusterSlots[slot][0];
-        return this.shardedSubscribers.get(nodeKey);
+        const sub = this.shardedSubscribers.get(nodeKey);
+        if (sub && sub.subscriberStatus === "idle") {
+            sub
+                .start()
+                .then(() => {
+                this.handleSubscriberConnectSucceeded(sub.getNodeKey());
+            })
+                .catch((err) => {
+                this.handleSubscriberConnectFailed(err, sub.getNodeKey());
+            });
+        }
+        return sub;
     }
     /**
      * Adds a channel for which this subscriber group is responsible
@@ -130,7 +142,7 @@ class ClusterSubscriberGroup {
     start() {
         const startPromises = [];
         for (const s of this.shardedSubscribers.values()) {
-            if (!s.isStarted()) {
+            if (this.shouldStartSubscriber(s)) {
                 startPromises.push(s
                     .start()
                     .then(() => {
@@ -139,6 +151,7 @@ class ClusterSubscriberGroup {
                     .catch((err) => {
                     this.handleSubscriberConnectFailed(err, s.getNodeKey());
                 }));
+                this.subscriberGroupEmitter.emit("+subscriber");
             }
         }
         return Promise.all(startPromises);
@@ -162,9 +175,9 @@ class ClusterSubscriberGroup {
             // For each of the sharded subscribers
             for (const [nodeKey, shardedSubscriber] of this.shardedSubscribers) {
                 if (
-                // If the subscriber is still responsible for a slot range and is running then keep it
+                // If the subscriber is still responsible for a slot range and is healthy then keep it
                 this.subscriberToSlotsIndex.has(nodeKey) &&
-                    shardedSubscriber.isStarted()) {
+                    shardedSubscriber.isHealthy()) {
                     debug("Skipping deleting subscriber for %s", nodeKey);
                     continue;
                 }
@@ -177,11 +190,31 @@ class ClusterSubscriberGroup {
             const startPromises = [];
             // For each node in slots cache
             for (const [nodeKey, _] of this.subscriberToSlotsIndex) {
-                // If we already have a subscriber for this node then keep it
-                if (this.shardedSubscribers.has(nodeKey)) {
+                const existingSubscriber = this.shardedSubscribers.get(nodeKey);
+                // If we already have a subscriber for this node, only ensure it is healthy
+                // when it now owns slots with active channel subscriptions.
+                if (existingSubscriber && existingSubscriber.isHealthy()) {
                     debug("Skipping creating new subscriber for %s", nodeKey);
+                    if (!existingSubscriber.isStarted() &&
+                        this.shouldStartSubscriber(existingSubscriber)) {
+                        startPromises.push(existingSubscriber
+                            .start()
+                            .then(() => {
+                            this.handleSubscriberConnectSucceeded(nodeKey);
+                        })
+                            .catch((error) => {
+                            this.handleSubscriberConnectFailed(error, nodeKey);
+                        }));
+                    }
                     continue;
                 }
+                // If we have an existing subscriber but it is not healthy, stop it
+                if (existingSubscriber && !existingSubscriber.isHealthy()) {
+                    debug("Replacing subscriber for %s", nodeKey);
+                    existingSubscriber.stop();
+                    this.shardedSubscribers.delete(nodeKey);
+                    this.subscriberGroupEmitter.emit("-subscriber");
+                }
                 debug("Creating new subscriber for %s", nodeKey);
                 // Otherwise create a new subscriber
                 const redis = clusterNodes.find((node) => {
@@ -191,16 +224,18 @@ class ClusterSubscriberGroup {
                     debug("Failed to find node for key %s", nodeKey);
                     continue;
                 }
-                const sub = new ShardedSubscriber_1.default(this.subscriberGroupEmitter, redis.options);
+                const sub = new ShardedSubscriber_1.default(this.subscriberGroupEmitter, redis.options, this.options.redisOptions);
                 this.shardedSubscribers.set(nodeKey, sub);
-                startPromises.push(sub
-                    .start()
-                    .then(() => {
-                    this.handleSubscriberConnectSucceeded(nodeKey);
-                })
-                    .catch((error) => {
-                    this.handleSubscriberConnectFailed(error, nodeKey);
-                }));
+                if (this.shouldStartSubscriber(sub)) {
+                    startPromises.push(sub
+                        .start()
+                        .then(() => {
+                        this.handleSubscriberConnectSucceeded(nodeKey);
+                    })
+                        .catch((error) => {
+                        this.handleSubscriberConnectFailed(error, nodeKey);
+                    }));
+                }
                 this.subscriberGroupEmitter.emit("+subscriber");
             }
             // It's vital to await the start promises before resubscribing
@@ -228,7 +263,8 @@ class ClusterSubscriberGroup {
      */
     _refreshSlots(targetSlots) {
         //If there was an actual change, then reassign the slot ranges
-        if (this._slotsAreEqual(targetSlots)) {
+        // Also rebuild if subscriberToSlotsIndex is empty (e.g., after stop() was called)
+        if (this._slotsAreEqual(targetSlots) && this.subscriberToSlotsIndex.size > 0) {
             debug("Nothing to refresh because the new cluster map is equal to the previous one.");
             return false;
         }
@@ -262,7 +298,7 @@ class ClusterSubscriberGroup {
                         const redis = s.getInstance();
                         const channels = this.channels.get(ss);
                         if (channels && channels.length > 0) {
-                            if (redis.status === "end") {
+                            if (!redis || redis.status === "end") {
                                 return;
                             }
                             if (redis.status === "ready") {
@@ -309,10 +345,26 @@ class ClusterSubscriberGroup {
      * @returns true if any subscribers need to be recreated
      */
     hasUnhealthySubscribers() {
-        const hasFailedSubscribers = Array.from(this.shardedSubscribers.values()).some((sub) => !sub.isStarted());
+        const hasFailedSubscribers = Array.from(this.shardedSubscribers.values()).some((sub) => !sub.isHealthy());
         const hasMissingSubscribers = Array.from(this.subscriberToSlotsIndex.keys()).some((nodeKey) => !this.shardedSubscribers.has(nodeKey));
         return hasFailedSubscribers || hasMissingSubscribers;
     }
+    shouldStartSubscriber(sub) {
+        if (sub.isStarted()) {
+            return false;
+        }
+        if (!sub.isLazyConnect()) {
+            return true;
+        }
+        const subscriberSlots = this.subscriberToSlotsIndex.get(sub.getNodeKey());
+        if (!subscriberSlots) {
+            return false;
+        }
+        return subscriberSlots.some((slot) => {
+            const channels = this.channels.get(slot);
+            return Boolean(channels && channels.length > 0);
+        });
+    }
 }
 exports.default = ClusterSubscriberGroup;
 // Retry strategy

package/built/cluster/ShardedSubscriber.d.ts

@@ -2,19 +2,35 @@
 import EventEmitter = require("events");
 import { RedisOptions } from "./util";
 import Redis from "../Redis";
+import { ClusterOptions } from "./ClusterOptions";
+declare const SubscriberStatus: {
+    readonly IDLE: "idle";
+    readonly STARTING: "starting";
+    readonly CONNECTED: "connected";
+    readonly STOPPING: "stopping";
+    readonly ENDED: "ended";
+};
+declare type SubscriberStatus = typeof SubscriberStatus[keyof typeof SubscriberStatus];
 export default class ShardedSubscriber {
     private readonly emitter;
     private readonly nodeKey;
-    private started;
+    private status;
     private instance;
+    private connectPromise;
+    private lazyConnect;
     private readonly messageListeners;
-    constructor(emitter: EventEmitter, options: RedisOptions);
-    private onEnd;
-    private onError;
-    private onMoved;
+    constructor(emitter: EventEmitter, options: RedisOptions, redisOptions?: ClusterOptions["redisOptions"]);
     start(): Promise<void>;
     stop(): void;
     isStarted(): boolean;
+    get subscriberStatus(): SubscriberStatus;
+    isHealthy(): boolean;
     getInstance(): Redis | null;
     getNodeKey(): string;
+    isLazyConnect(): boolean;
+    private onEnd;
+    private onError;
+    private onMoved;
+    private updateStatus;
 }
+export {};

package/built/cluster/ShardedSubscriber.js

@@ -4,15 +4,42 @@ const util_1 = require("./util");
 const utils_1 = require("../utils");
 const Redis_1 = require("../Redis");
 const debug = (0, utils_1.Debug)("cluster:subscriberGroup:shardedSubscriber");
+const SubscriberStatus = {
+    IDLE: "idle",
+    STARTING: "starting",
+    CONNECTED: "connected",
+    STOPPING: "stopping",
+    ENDED: "ended",
+};
+const ALLOWED_STATUS_UPDATES = {
+    [SubscriberStatus.IDLE]: [
+        SubscriberStatus.STARTING,
+        SubscriberStatus.STOPPING,
+        SubscriberStatus.ENDED,
+    ],
+    [SubscriberStatus.STARTING]: [
+        SubscriberStatus.CONNECTED,
+        SubscriberStatus.STOPPING,
+        SubscriberStatus.ENDED,
+    ],
+    [SubscriberStatus.CONNECTED]: [
+        SubscriberStatus.STOPPING,
+        SubscriberStatus.ENDED,
+    ],
+    [SubscriberStatus.STOPPING]: [SubscriberStatus.ENDED],
+    [SubscriberStatus.ENDED]: [],
+};
 class ShardedSubscriber {
-    constructor(emitter, options) {
+    constructor(emitter, options, redisOptions) {
+        var _a;
         this.emitter = emitter;
-        this.started = false;
+        this.status = SubscriberStatus.IDLE;
         this.instance = null;
+        this.connectPromise = null;
         // Store listener references for cleanup
         this.messageListeners = new Map();
         this.onEnd = () => {
-            this.started = false;
+            this.updateStatus(SubscriberStatus.ENDED);
             this.emitter.emit("-node", this.instance, this.nodeKey);
         };
         this.onError = (error) => {
@@ -21,25 +48,21 @@ class ShardedSubscriber {
         this.onMoved = () => {
             this.emitter.emit("moved");
         };
-        this.instance = new Redis_1.default({
-            port: options.port,
-            host: options.host,
-            username: options.username,
-            password: options.password,
+        this.instance = new Redis_1.default((0, utils_1.defaults)({
             enableReadyCheck: false,
-            offlineQueue: true,
+            enableOfflineQueue: true,
             connectionName: (0, util_1.getConnectionName)("ssubscriber", options.connectionName),
-            lazyConnect: true,
-            tls: options.tls,
             /**
              * Disable auto reconnection for subscribers.
              * The ClusterSubscriberGroup will handle the reconnection.
              */
             retryStrategy: null,
-        });
+            lazyConnect: true,
+        }, options, redisOptions));
+        this.lazyConnect = (_a = redisOptions === null || redisOptions === void 0 ? void 0 : redisOptions.lazyConnect) !== null && _a !== void 0 ? _a : true;
         this.nodeKey = (0, util_1.getNodeKey)(options);
         // Register listeners
-        this.instance.once("end", this.onEnd);
+        this.instance.on("end", this.onEnd);
         this.instance.on("error", this.onError);
         this.instance.on("moved", this.onMoved);
         for (const event of ["smessage", "smessageBuffer"]) {
@@ -51,33 +74,55 @@ class ShardedSubscriber {
         }
     }
     async start() {
-        if (this.started) {
-            debug("already started %s", this.nodeKey);
+        if (this.connectPromise) {
+            return this.connectPromise;
+        }
+        if (this.status === SubscriberStatus.STARTING ||
+            this.status === SubscriberStatus.CONNECTED) {
             return;
         }
+        if (this.status === SubscriberStatus.ENDED || !this.instance) {
+            throw new Error(`Sharded subscriber ${this.nodeKey} cannot be restarted once ended.`);
+        }
+        this.updateStatus(SubscriberStatus.STARTING);
+        this.connectPromise = this.instance.connect();
         try {
-            await this.instance.connect();
-            debug("started %s", this.nodeKey);
-            this.started = true;
+            await this.connectPromise;
+            this.updateStatus(SubscriberStatus.CONNECTED);
         }
         catch (err) {
-            debug("failed to start %s: %s", this.nodeKey, err);
-            this.started = false;
-            throw err; // Re-throw so caller knows it failed
+            this.updateStatus(SubscriberStatus.ENDED);
+            throw err;
+        }
+        finally {
+            this.connectPromise = null;
         }
     }
     stop() {
-        this.started = false;
+        this.updateStatus(SubscriberStatus.STOPPING);
         if (this.instance) {
             this.instance.disconnect();
             this.instance.removeAllListeners();
             this.messageListeners.clear();
             this.instance = null;
         }
+        this.updateStatus(SubscriberStatus.ENDED);
         debug("stopped %s", this.nodeKey);
     }
     isStarted() {
-        return this.started;
+        return [
+            SubscriberStatus.CONNECTED,
+            SubscriberStatus.STARTING,
+        ].includes(this.status);
+    }
+    get subscriberStatus() {
+        return this.status;
+    }
+    isHealthy() {
+        return ((this.status === SubscriberStatus.IDLE ||
+            this.status === SubscriberStatus.CONNECTED ||
+            this.status === SubscriberStatus.STARTING) &&
+            this.instance !== null);
     }
     getInstance() {
         return this.instance;
@@ -85,5 +130,18 @@ class ShardedSubscriber {
     getNodeKey() {
         return this.nodeKey;
     }
+    isLazyConnect() {
+        return this.lazyConnect;
+    }
+    updateStatus(nextStatus) {
+        if (this.status === nextStatus) {
+            return;
+        }
+        if (!ALLOWED_STATUS_UPDATES[this.status].includes(nextStatus)) {
+            debug("Invalid status transition for %s: %s -> %s", this.nodeKey, this.status, nextStatus);
+            return;
+        }
+        this.status = nextStatus;
+    }
 }
 exports.default = ShardedSubscriber;

package/built/cluster/index.js

@@ -889,7 +889,7 @@ class Cluster extends Commander_1.default {
     }
     createShardedSubscriberGroup() {
         this.subscriberGroupEmitter = new events_1.EventEmitter();
-        this.shardedSubscribers = new ClusterSubscriberGroup_1.default(this.subscriberGroupEmitter);
+        this.shardedSubscribers = new ClusterSubscriberGroup_1.default(this.subscriberGroupEmitter, this.options);
         // 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

package/built/utils/RedisCommander.d.ts

@@ -2263,6 +2263,30 @@ interface RedisCommander<Context extends ClientContext = {
     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>;
+    /**
+     * Set expiry for hash field using an absolute Unix timestamp (seconds)
+     * - _group_: hash
+     * - _complexity_: O(N) where N is the number of specified fields
+     * - _since_: 7.4.0
+     */
+    hexpireat(...args: [key: RedisKey, unixTimeSeconds: number | string, fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hexpireat(...args: [key: RedisKey, unixTimeSeconds: number | string, fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    hexpireat(...args: [key: RedisKey, unixTimeSeconds: number | string, nx: 'NX', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hexpireat(...args: [key: RedisKey, unixTimeSeconds: number | string, nx: 'NX', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    hexpireat(...args: [key: RedisKey, unixTimeSeconds: number | string, xx: 'XX', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hexpireat(...args: [key: RedisKey, unixTimeSeconds: number | string, xx: 'XX', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    hexpireat(...args: [key: RedisKey, unixTimeSeconds: number | string, gt: 'GT', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hexpireat(...args: [key: RedisKey, unixTimeSeconds: number | string, gt: 'GT', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    hexpireat(...args: [key: RedisKey, unixTimeSeconds: number | string, lt: 'LT', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hexpireat(...args: [key: RedisKey, unixTimeSeconds: number | string, lt: 'LT', fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    /**
+     * Returns the expiration time of a hash field as a Unix timestamp, in seconds.
+     * - _group_: hash
+     * - _complexity_: O(N) where N is the number of specified fields
+     * - _since_: 7.4.0
+     */
+    hexpiretime(...args: [key: RedisKey, fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hexpiretime(...args: [key: RedisKey, fieldsToken: 'FIELDS', numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
     /**
      * Get the value of a hash field
      * - _group_: hash
@@ -2279,6 +2303,46 @@ interface RedisCommander<Context extends ClientContext = {
      */
     hgetall(key: RedisKey, callback?: Callback<Record<string, string>>): Result<Record<string, string>, Context>;
     hgetallBuffer(key: RedisKey, callback?: Callback<Record<string, Buffer>>): Result<Record<string, Buffer>, Context>;
+    /**
+     * Returns the value of a field and deletes it from the hash.
+     * - _group_: hash
+     * - _complexity_: O(N) where N is the number of specified fields
+     * - _since_: 8.0.0
+     */
+    hgetdel(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<(string | null)[]>]): Result<(string | null)[], Context>;
+    hgetdelBuffer(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<(Buffer | null)[]>]): Result<(Buffer | null)[], Context>;
+    hgetdel(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<(string | null)[], Context>;
+    hgetdelBuffer(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<(Buffer | null)[], Context>;
+    /**
+     * Get the value of one or more fields of a given hash key, and optionally set their expiration.
+     * - _group_: hash
+     * - _complexity_: O(N) where N is the number of specified fields
+     * - _since_: 8.0.0
+     */
+    hgetex(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<(string | null)[]>]): Result<(string | null)[], Context>;
+    hgetexBuffer(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<(Buffer | null)[]>]): Result<(Buffer | null)[], Context>;
+    hgetex(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<(string | null)[], Context>;
+    hgetexBuffer(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<(Buffer | null)[], Context>;
+    hgetex(...args: [key: RedisKey, secondsToken: "EX", seconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<(string | null)[]>]): Result<(string | null)[], Context>;
+    hgetexBuffer(...args: [key: RedisKey, secondsToken: "EX", seconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<(Buffer | null)[]>]): Result<(Buffer | null)[], Context>;
+    hgetex(...args: [key: RedisKey, secondsToken: "EX", seconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<(string | null)[], Context>;
+    hgetexBuffer(...args: [key: RedisKey, secondsToken: "EX", seconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<(Buffer | null)[], Context>;
+    hgetex(...args: [key: RedisKey, millisecondsToken: "PX", milliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<(string | null)[]>]): Result<(string | null)[], Context>;
+    hgetexBuffer(...args: [key: RedisKey, millisecondsToken: "PX", milliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<(Buffer | null)[]>]): Result<(Buffer | null)[], Context>;
+    hgetex(...args: [key: RedisKey, millisecondsToken: "PX", milliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<(string | null)[], Context>;
+    hgetexBuffer(...args: [key: RedisKey, millisecondsToken: "PX", milliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<(Buffer | null)[], Context>;
+    hgetex(...args: [key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<(string | null)[]>]): Result<(string | null)[], Context>;
+    hgetexBuffer(...args: [key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<(Buffer | null)[]>]): Result<(Buffer | null)[], Context>;
+    hgetex(...args: [key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<(string | null)[], Context>;
+    hgetexBuffer(...args: [key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<(Buffer | null)[], Context>;
+    hgetex(...args: [key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<(string | null)[]>]): Result<(string | null)[], Context>;
+    hgetexBuffer(...args: [key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<(Buffer | null)[]>]): Result<(Buffer | null)[], Context>;
+    hgetex(...args: [key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<(string | null)[], Context>;
+    hgetexBuffer(...args: [key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<(Buffer | null)[], Context>;
+    hgetex(...args: [key: RedisKey, persist: "PERSIST", fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<(string | null)[]>]): Result<(string | null)[], Context>;
+    hgetexBuffer(...args: [key: RedisKey, persist: "PERSIST", fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<(Buffer | null)[]>]): Result<(Buffer | null)[], Context>;
+    hgetex(...args: [key: RedisKey, persist: "PERSIST", fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<(string | null)[], Context>;
+    hgetexBuffer(...args: [key: RedisKey, persist: "PERSIST", fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<(Buffer | null)[], Context>;
     /**
      * Increment the integer value of a hash field by the given number
      * - _group_: hash
@@ -2341,6 +2405,14 @@ interface RedisCommander<Context extends ClientContext = {
         callback: Callback<"OK">
     ]): Result<"OK", Context>;
     hmset(...args: [key: RedisKey, ...fieldValues: (string | Buffer | number)[]]): Result<"OK", Context>;
+    /**
+     * Removes the expiration time for each specified field
+     * - _group_: hash
+     * - _complexity_: O(N) where N is the number of specified fields
+     * - _since_: 7.4.0
+     */
+    hpersist(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hpersist(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
     /**
      * Set expiry for hash field using relative time to expire (milliseconds)
      * - _group_: hash
@@ -2357,6 +2429,38 @@ interface RedisCommander<Context extends ClientContext = {
     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>;
+    /**
+     * Set expiry for hash field using an absolute Unix timestamp (milliseconds)
+     * - _group_: hash
+     * - _complexity_: O(N) where N is the number of specified fields
+     * - _since_: 7.4.0
+     */
+    hpexpireat(...args: [key: RedisKey, unixTimeMilliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hpexpireat(...args: [key: RedisKey, unixTimeMilliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    hpexpireat(...args: [key: RedisKey, unixTimeMilliseconds: number | string, nx: "NX", fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hpexpireat(...args: [key: RedisKey, unixTimeMilliseconds: number | string, nx: "NX", fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    hpexpireat(...args: [key: RedisKey, unixTimeMilliseconds: number | string, xx: "XX", fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hpexpireat(...args: [key: RedisKey, unixTimeMilliseconds: number | string, xx: "XX", fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    hpexpireat(...args: [key: RedisKey, unixTimeMilliseconds: number | string, gt: "GT", fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hpexpireat(...args: [key: RedisKey, unixTimeMilliseconds: number | string, gt: "GT", fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    hpexpireat(...args: [key: RedisKey, unixTimeMilliseconds: number | string, lt: "LT", fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hpexpireat(...args: [key: RedisKey, unixTimeMilliseconds: number | string, lt: "LT", fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    /**
+     * Returns the expiration time of a hash field as a Unix timestamp, in msec.
+     * - _group_: hash
+     * - _complexity_: O(N) where N is the number of specified fields
+     * - _since_: 7.4.0
+     */
+    hpexpiretime(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hpexpiretime(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
+    /**
+     * Returns the TTL in milliseconds of a hash field.
+     * - _group_: hash
+     * - _complexity_: O(N) where N is the number of specified fields
+     * - _since_: 7.4.0
+     */
+    hpttl(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    hpttl(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
     /**
      * Get one or multiple random fields from a hash
      * - _group_: hash
@@ -2397,6 +2501,48 @@ interface RedisCommander<Context extends ClientContext = {
         callback: Callback<number>
     ]): Result<number, Context>;
     hset(...args: [key: RedisKey, ...fieldValues: (string | Buffer | number)[]]): Result<number, Context>;
+    /**
+     * Set the value of one or more fields of a given hash key, and optionally set their expiration.
+     * - _group_: hash
+     * - _complexity_: O(N) where N is the number of fields being set.
+     * - _since_: 8.0.0
+     */
+    hsetex(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, secondsToken: "EX", seconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, secondsToken: "EX", seconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, millisecondsToken: "PX", milliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, millisecondsToken: "PX", milliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, keepttl: "KEEPTTL", fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, keepttl: "KEEPTTL", fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fnx: "FNX", fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fnx: "FNX", fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fnx: "FNX", secondsToken: "EX", seconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fnx: "FNX", secondsToken: "EX", seconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fnx: "FNX", millisecondsToken: "PX", milliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fnx: "FNX", millisecondsToken: "PX", milliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fnx: "FNX", unixTimeSecondsToken: "EXAT", unixTimeSeconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fnx: "FNX", unixTimeSecondsToken: "EXAT", unixTimeSeconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fnx: "FNX", unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fnx: "FNX", unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fnx: "FNX", keepttl: "KEEPTTL", fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fnx: "FNX", keepttl: "KEEPTTL", fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fxx: "FXX", fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fxx: "FXX", fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fxx: "FXX", secondsToken: "EX", seconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fxx: "FXX", secondsToken: "EX", seconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fxx: "FXX", millisecondsToken: "PX", milliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fxx: "FXX", millisecondsToken: "PX", milliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fxx: "FXX", unixTimeSecondsToken: "EXAT", unixTimeSeconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fxx: "FXX", unixTimeSecondsToken: "EXAT", unixTimeSeconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fxx: "FXX", unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fxx: "FXX", unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: number | string, fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fxx: "FXX", keepttl: "KEEPTTL", fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[], callback: Callback<number>]): Result<number, Context>;
+    hsetex(...args: [key: RedisKey, fxx: "FXX", keepttl: "KEEPTTL", fieldsToken: "FIELDS", numfields: number | string, ...data: (string | Buffer | number)[]]): Result<number, Context>;
     /**
      * Set the value of a hash field, only if the field does not exist
      * - _group_: hash
@@ -2411,6 +2557,14 @@ interface RedisCommander<Context extends ClientContext = {
      * - _since_: 3.2.0
      */
     hstrlen(key: RedisKey, field: string | Buffer, callback?: Callback<number>): Result<number, Context>;
+    /**
+     * Returns the TTL in seconds of a hash field.
+     * - _group_: hash
+     * - _complexity_: O(N) where N is the number of specified fields
+     * - _since_: 7.4.0
+     */
+    httl(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[], callback: Callback<number[]>]): Result<number[], Context>;
+    httl(...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: number | string, ...fields: (string | Buffer)[]]): Result<number[], Context>;
     /**
      * Get all the values in a hash
      * - _group_: hash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ioredis",
-  "version": "5.9.3",
+  "version": "5.10.1",
   "description": "A robust, performance-focused and full-featured Redis client for Node.js.",
   "main": "./built/index.js",
   "types": "./built/index.d.ts",
@@ -43,7 +43,7 @@
     "url": "https://opencollective.com/ioredis"
   },
   "dependencies": {
-    "@ioredis/commands": "1.5.0",
+    "@ioredis/commands": "1.5.1",
     "cluster-key-slot": "^1.1.0",
     "debug": "^4.3.4",
     "denque": "^2.1.0",