ioredis

constructor

constructor(disconnectTimeout: number);

property connecting

protected connecting: boolean;

property firstError

firstError?: Error;

property stream

protected stream: any;

method check

check: (info: any) => boolean;

method connect

abstract connect: (_: ErrorEmitter) => Promise<NetStream>;

method disconnect

disconnect: () => void;

constructor

constructor(startupNodes: ClusterNode[], options?: ClusterOptions);

• Creates an instance of Cluster.

property autoPipelineQueueSize

readonly autoPipelineQueueSize: number;

• Get the number of commands queued in automatic pipelines.

  This is not available (and returns 0) until the cluster is connected and slots information have been received.

property isCluster

isCluster: boolean;

property options

options: ClusterOptions;

property slots

slots: string[][];

property status

status: ClusterStatus;

method connect

connect: () => Promise<void>;

• Connect to a cluster

method delayUntilReady

delayUntilReady: (callback: Callback) => void;

• This is needed in order not to install a listener for each auto pipeline

method disconnect

disconnect: (reconnect?: boolean) => void;

• Disconnect from every node in the cluster.

method duplicate

duplicate: (overrideStartupNodes?: any[], overrideOptions?: {}) => Cluster;

• Create a new instance with the same startup nodes and options as the current one.

  Example 1

  var cluster = new Redis.Cluster([{ host: "127.0.0.1", port: "30001" }]);
  var anotherCluster = cluster.duplicate();

method handleError

handleError: (error: Error, ttl: { value?: any }, handlers: any) => void;

method hscanBufferStream

hscanBufferStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method hscanStream

hscanStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method nodes

nodes: (role?: NodeRole) => Redis[];

• Get nodes with the specified role

method quit

quit: (callback?: Callback<'OK'>) => Promise<'OK'>;

• Quit the cluster gracefully.

method refreshSlotsCache

refreshSlotsCache: (callback?: Callback<void>) => void;

• Refresh the slot cache

method sendCommand

sendCommand: (command: Command, stream?: WriteableStream, node?: any) => unknown;

method sscanBufferStream

sscanBufferStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method sscanStream

sscanStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method zscanBufferStream

zscanBufferStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method zscanStream

zscanStream: (key: string, options?: ScanStreamOptions) => ScanStream;

constructor

constructor(
    name: string,
    args?: any[],
    options?: CommandOptions,
    callback?: Callback<any>
);

• Creates an instance of Command.

  Parameter name

  Command name

  Parameter args

  An array of command arguments

  Parameter options

  Parameter callback

  The callback that handles the response. If omit, the response will be handled via Promise

property args

args: any[];

property FLAGS

static FLAGS: {
    VALID_IN_SUBSCRIBER_MODE: [
        'subscribe',
        'psubscribe',
        'unsubscribe',
        'punsubscribe',
        'ssubscribe',
        'sunsubscribe',
        'ping',
        'quit'
    ];
    VALID_IN_MONITOR_MODE: ['monitor', 'auth'];
    ENTER_SUBSCRIBER_MODE: ['subscribe', 'psubscribe', 'ssubscribe'];
    EXIT_SUBSCRIBER_MODE: ['unsubscribe', 'punsubscribe', 'sunsubscribe'];
    WILL_DISCONNECT: ['quit'];
    HANDSHAKE_COMMANDS: ['auth', 'select', 'client', 'readonly', 'info'];
    IGNORE_RECONNECT_ON_ERROR: ['client'];
    BLOCKING_COMMANDS: [
        'blpop',
        'brpop',
        'brpoplpush',
        'blmove',
        'bzpopmin',
        'bzpopmax',
        'bzmpop',
        'blmpop',
        'xread',
        'xreadgroup'
    ];
    LAST_ARG_TIMEOUT_COMMANDS: [
        'blpop',
        'brpop',
        'brpoplpush',
        'blmove',
        'bzpopmin',
        'bzpopmax'
    ];
    FIRST_ARG_TIMEOUT_COMMANDS: ['bzmpop', 'blmpop'];
    BLOCK_OPTION_COMMANDS: ['xread', 'xreadgroup'];
};

property ignore

ignore?: boolean;

property inTransaction

inTransaction: boolean;

property isReadOnly

isReadOnly?: boolean;

property isResolved

isResolved: boolean;

property isTraced

isTraced: boolean;

property name

name: string;

property pipelineIndex

pipelineIndex?: number;

property promise

promise: Promise<any>;

property reject

reject: (err: Error) => void;

property resolve

resolve: (result: any) => void;

method checkFlag

static checkFlag: <T extends keyof CommandNameFlags>(
    flagName: T,
    commandName: string
) => commandName is CommandNameFlags[T][number];

• Check whether the command has the flag

method extractBlockingTimeout

extractBlockingTimeout: () => number | null | undefined;

• Extract the blocking timeout from the command arguments.

  Returns

  The timeout in seconds, null for indefinite blocking (timeout of 0), or undefined if this is not a blocking command

method getKeys

getKeys: () => Array<string | Buffer>;

method getSlot

getSlot: () => number;

method setArgumentTransformer

static setArgumentTransformer: (name: string, func: ArgumentTransformer) => void;

method setBlockingTimeout

setBlockingTimeout: (ms: number) => void;

• Set a timeout for blocking commands. When the timeout expires, the command resolves with null (matching Redis behavior). This handles the case of undetectable network failures (e.g., docker network disconnect) where the TCP connection becomes a zombie and no close event fires.

method setReplyTransformer

static setReplyTransformer: (name: string, func: ReplyTransformer) => void;

method setTimeout

setTimeout: (ms: number) => void;

• Set the wait time before terminating the attempt to execute a command and generating an error.

method stringifyArguments

stringifyArguments: () => void;

method toWritable

toWritable: (_socket: object) => string | Buffer;

• Convert command to writable buffer or string

method transformReply

transformReply: (
    result: Buffer | Buffer[]
) => string | string[] | Buffer | Buffer[];

• Convert buffer/buffer[] to string/string[], and apply reply transformer.

constructor

constructor(redis: Cluster | Redis);

property isCluster

isCluster: boolean;

property isPipeline

isPipeline: boolean;

property leftRedirections

leftRedirections: { value?: number };

property promise

promise: Promise<unknown>;

property redis

redis: Cluster | Redis;

property reject

reject: (error: Error) => void;

property resolve

resolve: (result: unknown) => void;

method addBatch

addBatch: (commands: any) => this;

method fillResult

fillResult: (value: unknown[], position: number) => void;

method sendCommand

sendCommand: (command: Command) => unknown;

constructor

constructor(port: number, host: string, options: RedisOptions);

constructor

constructor(path: string, options: RedisOptions);

constructor

constructor(port: number, options: RedisOptions);

constructor

constructor(port: number, host: string);

constructor

constructor(options: RedisOptions);

constructor

constructor(port: number);

constructor

constructor(path: string);

constructor

constructor();

property autoPipelineQueueSize

readonly autoPipelineQueueSize: number;

property Cluster

static Cluster: typeof Cluster;

property Command

static Command: typeof Command;

property commandQueue

commandQueue: Deque<CommandItem>;

property condition

condition: Condition;

property isCluster

isCluster: boolean;

property mode

readonly mode: 'normal' | 'subscriber' | 'monitor';

• Mode of the connection.

  One of "normal", "subscriber", or "monitor". When the connection is not in "normal" mode, certain commands are not allowed.

property options

options: RedisOptions;

property status

status: RedisStatus;

property stream

stream: any;

method connect

connect: (callback?: Callback<void>) => Promise<void>;

• Create a connection to Redis. This method will be invoked automatically when creating a new Redis instance unless lazyConnect: true is passed.

  When calling this method manually, a Promise is returned, which will 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.

method createClient

static createClient: () => Redis;

• Create a Redis instance. This is the same as new Redis() but is included for compatibility with node-redis.

method disconnect

disconnect: (reconnect?: boolean) => void;

• Disconnect from Redis.

  This method closes the connection immediately, and may lose some pending replies that haven't written to client. If you want to wait for the pending replies, use Redis#quit instead.

method duplicate

duplicate: (override?: Partial<RedisOptions>) => Redis;

• Create a new instance with the same options as the current one.

  Example 1

  var redis = new Redis(6380);
  var anotherRedis = redis.duplicate();

method end

end: () => void;

• Disconnect from Redis.

  Deprecated

method handleReconnection

handleReconnection: (err: Error, item: CommandItem) => void;

method hscanBufferStream

hscanBufferStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method hscanStream

hscanStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method monitor

monitor: (callback?: Callback<Redis>) => Promise<Redis>;

• Listen for all requests received by the server in real time.

  This command will create a new connection to Redis and send a MONITOR command via the new connection in order to avoid disturbing the current connection.

  Parameter callback

  The callback function. If omit, a promise will be returned.

  Example 1

  var redis = new Redis();
  redis.monitor(function (err, monitor) {
    // Entering monitoring mode.
    monitor.on('monitor', function (time, args, source, database) {
      console.log(time + ": " + util.inspect(args));
    });
  });
  
  // supports promise as well as other commands
  redis.monitor().then(function (monitor) {
    monitor.on('monitor', function (time, args, source, database) {
      console.log(time + ": " + util.inspect(args));
    });
  });

method recoverFromFatalError

recoverFromFatalError: (
    _commandError: Error,
    err: Error,
    options: FlushQueueOptions
) => void;

method scanBufferStream

scanBufferStream: (options?: ScanStreamOptions) => ScanStream;

method scanStream

scanStream: (options?: ScanStreamOptions) => ScanStream;

method sendCommand

sendCommand: (command: Command, stream?: WriteableStream) => unknown;

• Send a command to Redis

  This method is used internally and in most cases you should not use it directly. If you need to send a command that is not supported by the library, you can use the call method:

  const redis = new Redis();
  
  redis.call('set', 'foo', 'bar');
  // or
  redis.call(['set', 'foo', 'bar']);

method silentEmit

silentEmit: (eventName: string, arg?: unknown) => boolean;

• Emit only when there's at least one listener.

method sscanBufferStream

sscanBufferStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method sscanStream

sscanStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method zscanBufferStream

zscanBufferStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method zscanStream

zscanStream: (key: string, options?: ScanStreamOptions) => ScanStream;

constructor

constructor(opt: Options);

method close

close: () => void;

constructor

constructor(options: SentinelConnectionOptions);

property emitter

emitter: any;

property options

protected options: SentinelConnectionOptions;

property sentinelIterator

protected sentinelIterator: SentinelIterator;

method check

check: (info: { role?: string }) => boolean;

method connect

connect: (eventEmitter: ErrorEmitter) => Promise<NetStream>;

method disconnect

disconnect: () => void;

constructor

constructor(sentinels: Partial<SentinelAddress>[]);

method add

add: (sentinel: SentinelAddress) => boolean;

method next

next: () => { done: boolean; value: Partial<SentinelAddress> };

method reset

reset: (moveCurrentEndpointToFirst: boolean) => void;

method toString

toString: () => string;

property batchMode

batchMode: 'MULTI';

property batchSize

batchSize: number;

property database

database: number;

property serverAddress

serverAddress: string;

property serverPort

serverPort: number | undefined;

property length

length: number;

property autoPipeliningIgnoredCommands

autoPipeliningIgnoredCommands?: string[] | undefined;

• See Redis class.

  []

property clusterNodeRetryStrategy

clusterNodeRetryStrategy?: ClusterNodeRetryStrategy;

• When a cluster node connection is closed, this function will be called to determine the retry delay (in ms). Returning null or a non-number disables reconnection for that node.

  By default this is null, meaning cluster nodes will NOT automatically reconnect — the cluster relies on MOVED errors to refresh topology. Set this to enable reconnection, e.g. for replica nodes that restart without any slot changes.

  Example 1

  clusterNodeRetryStrategy: (times) => Math.min(times * 100, 3000)

  null

property clusterRetryStrategy

clusterRetryStrategy?:
    | ((times: number, reason?: Error) => number | void | null)
    | null
    | undefined;

• See "Quick Start" section.

  (times) => Math.min(100 + times * 2, 2000)

property dnsLookup

dnsLookup?: DNSLookupFunction | undefined;

• Hostnames will be resolved to IP addresses via this function. This is needed when the addresses of startup nodes are hostnames instead of IPs.

  You may provide a custom lookup function when you want to customize the cache behavior of the default function.

  require('dns').lookup

property enableAutoPipelining

enableAutoPipelining?: boolean | undefined;

• See Redis class.

  false

property enableOfflineQueue

enableOfflineQueue?: boolean | undefined;

• See Redis class.

  true

property enableReadyCheck

enableReadyCheck?: boolean | undefined;

• When enabled, ioredis only emits "ready" event when CLUSTER INFO command reporting the cluster is ready for handling commands.

  true

property lazyConnect

lazyConnect?: boolean | undefined;

• By default, When a new Cluster instance is created, it will connect to the Redis cluster automatically. If you want to keep the instance disconnected until the first command is called, set this option to true.

  false

property maxRedirections

maxRedirections?: number | undefined;

• When a MOVED or ASK error is received, client will redirect the command to another node. This option limits the max redirections allowed to send a command.

  16

property natMap

natMap?: NatMap | undefined;

property redisOptions

redisOptions?:
    | Omit<
          RedisOptions,
          | 'port'
          | 'host'
          | 'path'
          | 'sentinels'
          | 'retryStrategy'
          | 'enableOfflineQueue'
          | 'readOnly'
      >
    | undefined;

• Passed to the constructor of Redis

  null

property resolveSrv

resolveSrv?: DNSResolveSrvFunction | undefined;

• SRV records will be resolved via this function.

  You may provide a custom resolveSrv function when you want to customize the cache behavior of the default function.

  require('dns').resolveSrv

property retryDelayOnClusterDown

retryDelayOnClusterDown?: number | undefined;

• When a CLUSTERDOWN error is received, client will retry if retryDelayOnClusterDown is valid delay time (in ms).

  100

property retryDelayOnFailover

retryDelayOnFailover?: 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 if retryDelayOnFailover is valid delay time (in ms).

  100

property retryDelayOnMoved

retryDelayOnMoved?: 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 the MOVED error. However, sometimes it takes time for a cluster to become state stabilized after a failover, so adding a delay before resending can prevent a ping pong effect.

  0

property retryDelayOnTryAgain

retryDelayOnTryAgain?: number | undefined;

• When a TRYAGAIN error is received, client will retry if retryDelayOnTryAgain is valid delay time (in ms).

  100

property scaleReads

scaleReads?: NodeRole | Function | undefined;

• Scale reads to the node with the specified role.

  "master"

property scripts

scripts?:
    | Record<
          string,
          {
              lua: string;
              numberOfKeys?: number;
              readOnly?: boolean;
          }
      >
    | undefined;

• Custom LUA commands

property shardedSubscribers

shardedSubscribers?: boolean | undefined;

• Use sharded subscribers instead of a single subscriber.

  If sharded subscribers are used, then one additional subscriber connection per master node is established. If you don't plan to use SPUBLISH/SSUBSCRIBE, then this should be disabled.

  false

property slotsRefreshInterval

slotsRefreshInterval?: number | undefined;

• The milliseconds between every automatic slots refresh.

  5000

property slotsRefreshTimeout

slotsRefreshTimeout?: number | undefined;

• The milliseconds before a timeout occurs while refreshing slots from the cluster.

  1000

property useSRVRecords

useSRVRecords?: boolean | undefined;

• Discover nodes using SRV records

  false

property args

args: string[];

property command

command: string;

property database

database: number;

property serverAddress

serverAddress: string;

property serverPort

serverPort: number | undefined;

property autoPipeliningIgnoredCommands

autoPipeliningIgnoredCommands?: string[] | undefined;

• []

property autoResendUnfulfilledCommands

autoResendUnfulfilledCommands?: 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. true

property autoResubscribe

autoResubscribe?: boolean | undefined;

• When the client reconnects, channels subscribed in the previous connection will be resubscribed automatically if autoResubscribe is true. true

property blockingTimeout

blockingTimeout?: 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.

property blockingTimeoutGrace

blockingTimeoutGrace?: number | undefined;

• Grace period (ms) added to blocking command timeouts. Only used when blockingTimeout is a positive number. Defaults to 100ms.

property clientInfoTag

clientInfoTag?: string | undefined;

• Tag to append to the library name in CLIENT SETINFO (ioredis(tag)). https://redis.io/docs/latest/commands/client-setinfo/ undefined

property commandQueue

commandQueue?: boolean | undefined;

property commandTimeout

commandTimeout?: number | undefined;

• If a command does not return a reply within a set number of milliseconds, a "Command timed out" error will be thrown.

property connectionName

connectionName?: string | undefined;

• Set the name of the connection to make it easier to identity the connection in client list. https://redis.io/commands/client-setname

property Connector

Connector?: ConnectorConstructor | undefined;

property connectTimeout

connectTimeout?: number | undefined;

• How long the client will wait before killing a socket due to inactivity during initial connection. 10000

property db

db?: number | undefined;

• Database index to use.

  0

property disableClientInfo

disableClientInfo?: boolean | undefined;

• If true, skips setting library info via CLIENT SETINFO. https://redis.io/docs/latest/commands/client-setinfo/ false

property enableAutoPipelining

enableAutoPipelining?: boolean | undefined;

• false

property enableOfflineQueue

enableOfflineQueue?: boolean | undefined;

• By default, if the connection to Redis server has not been established, commands are added to a queue and are executed once the connection is "ready" (when enableReadyCheck is true, "ready" means the Redis server has loaded the database from disk, otherwise means the connection to the Redis server has been established). If this option is false, when execute the command when the connection isn't ready, an error will be returned.

  true

property enableReadyCheck

enableReadyCheck?: 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 the loading process is finished before emitting the ready event.

  true

property keepAlive

keepAlive?: number | undefined;

• Enable/disable keep-alive functionality. https://nodejs.org/api/net.html#socketsetkeepaliveenable-initialdelay 0

property lazyConnect

lazyConnect?: 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 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.

  false

property maxLoadingRetryTime

maxLoadingRetryTime?: number | undefined;

• 10000

property maxRetriesPerRequest

maxRetriesPerRequest?: number | null | 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). This option is used to configure how many reconnection attempts should be allowed before the queue is flushed with a MaxRetriesPerRequestError error. Set this options to null instead of a number to let commands wait forever until the connection is alive again.

  20

property monitor

monitor?: boolean | undefined;

• This option is used internally when you call redis.monitor() to tell Redis to enter the monitor mode when the connection is established.

  false

property noDelay

noDelay?: boolean | undefined;

• Enable/disable the use of Nagle's algorithm. https://nodejs.org/api/net.html#socketsetnodelaynodelay true

property offlineQueue

offlineQueue?: boolean | undefined;

property password

password?: string | undefined;

• If set, client will send AUTH command with the value of this option when connected.

property readOnly

readOnly?: boolean | undefined;

• false

property reconnectOnError

reconnectOnError?: ReconnectOnError | null | 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. You can pass a function that accepts an Redis error, and returns: - true or 1 to trigger a reconnection. - false or 0 to not reconnect. - 2 to reconnect and resend the failed command (who triggered the error) after reconnection.

  Example 1

  const redis = new Redis({
    reconnectOnError(err) {
      const targetError = "READONLY";
      if (err.message.includes(targetError)) {
        // Only reconnect when the error contains "READONLY"
        return true; // or `return 1;`
      }
    },
  });

  null

property retryStrategy

retryStrategy?: RetryStrategy;

property scripts

scripts?:
    | Record<
          string,
          {
              lua: string;
              numberOfKeys?: number | undefined;
              readOnly?: boolean | undefined;
          }
      >
    | undefined;

• undefined

property socketTimeout

socketTimeout?: 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)

property stringNumbers

stringNumbers?: 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). false

property username

username?: 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.

property connectionEpoch

connectionEpoch: number;

property serverAddress

serverAddress: string;

property serverPort

serverPort: number | undefined;

property length

length: number;

method on

on: {
    (event: 'message', cb: (channel: string, message: string) => void): this;
    (
        event: 'messageBuffer',
        cb: (channel: Buffer, message: Buffer) => void
    ): this;
    (
        event: 'pmessage',
        cb: (pattern: string, channel: string, message: string) => void
    ): this;
    (
        event: 'pmessageBuffer',
        cb: (pattern: string, channel: Buffer, message: Buffer) => void
    ): this;
    (event: 'error', cb: (error: Error) => void): this;
    (event: RedisStatus, cb: () => void): this;
    (event: string | symbol, listener: (...args: any[]) => void): this;
};