Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface CommonRedisOptions

Hierarchy

  • CommanderOptions
    • CommonRedisOptions

Index

Properties

Methods

Properties

Optional Connector

Connector?: ConnectorConstructor

Optional autoPipeliningIgnoredCommands

autoPipeliningIgnoredCommands?: string[]
default

[]

Optional autoResendUnfulfilledCommands

autoResendUnfulfilledCommands?: boolean

Whether or not to resend unfulfilled commands on reconnect. Unfulfilled commands are most likely to be blocking commands such as brpop or blpop.

default

true

Optional autoResubscribe

autoResubscribe?: boolean

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

default

true

Optional commandQueue

commandQueue?: boolean

Optional commandTimeout

commandTimeout?: number

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

Optional connectTimeout

connectTimeout?: number

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

default

10000

Optional connectionName

connectionName?: string

Set the name of the connection to make it easier to identity the connection in client list.

link

https://redis.io/commands/client-setname

Optional db

db?: number

Database index to use.

default

0

Optional enableAutoPipelining

enableAutoPipelining?: boolean
default

false

Optional enableOfflineQueue

enableOfflineQueue?: boolean

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

default

true

Optional enableReadyCheck

enableReadyCheck?: boolean

The client will sent an INFO command to check whether the server is still loading data from the disk ( which happens when the server is just launched) when the connection is established, and only wait until the loading process is finished before emitting the ready event.

default

true

Optional keepAlive

keepAlive?: number

Enable/disable keep-alive functionality.

link

https://nodejs.org/api/net.html#socketsetkeepaliveenable-initialdelay

default

0

Optional keyPrefix

keyPrefix?: string

Optional lazyConnect

lazyConnect?: boolean

When a Redis instance is initialized, a connection to the server is immediately established. Set this to true will delay the connection to the server until the first command is sent or redis.connect() is called explicitly.

default

false

Optional maxLoadingRetryTime

maxLoadingRetryTime?: number
default

10000

Optional maxRetriesPerRequest

maxRetriesPerRequest?: number

The commands that don't get a reply due to the connection to the server is lost are put into a queue and will be resent on reconnect (if allowed by the retryStrategy option). This option is used to configure how many reconnection attempts should be allowed before the queue is flushed with a MaxRetriesPerRequestError error. Set this options to null instead of a number to let commands wait forever until the connection is alive again.

default

20

Optional monitor

monitor?: boolean

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

default

false

Optional noDelay

noDelay?: boolean

Enable/disable the use of Nagle's algorithm.

link

https://nodejs.org/api/net.html#socketsetnodelaynodelay

default

true

Optional offlineQueue

offlineQueue?: boolean

Optional password

password?: string

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

Optional readOnly

readOnly?: boolean
default

false

Optional reconnectOnError

reconnectOnError?: ReconnectOnError

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
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;`
    }
  },
});
default

null

Optional scripts

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

undefined

Optional showFriendlyErrorStack

showFriendlyErrorStack?: boolean

Optional socketTimeout

socketTimeout?: number

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)

Optional stringNumbers

stringNumbers?: boolean

When enabled, numbers returned by Redis will be converted to JavaScript strings instead of numbers. This is necessary if you want to handle big numbers (above Number.MAX_SAFE_INTEGER === 2^53).

default

false

Optional username

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

Methods

Optional retryStrategy

  • retryStrategy(times: number): number | void

Generated using TypeDoc