Class RedisSentinelClient<M, F, S, RESP, TYPE_MAPPING>

constructor

• new RedisSentinelClient<M, F, S, RESP, TYPE_MAPPING>(internal, clientInfo, commandOptions?): RedisSentinelClient<M, F, S, RESP, TYPE_MAPPING>

• Type Parameters

  • M extends RedisModules

  • F extends RedisFunctions

  • S extends RedisScripts

  • RESP extends RespVersions

  • TYPE_MAPPING extends TypeMapping

  Parameters

  • internal: RedisSentinelInternal<M, F, S, RESP, TYPE_MAPPING>

  • clientInfo: ClientInfo

  • Optional commandOptions: CommandOptions<TYPE_MAPPING>

  Returns RedisSentinelClient<M, F, S, RESP, TYPE_MAPPING>

Readonly _self

multi

unwatch

watch

commandOptions

• get commandOptions(): undefined | CommandOptions<TYPE_MAPPING>

• Gets the command options configured for this client

  Returns undefined | CommandOptions<TYPE_MAPPING>

  The command options for this client or undefined if none were set

isOpen

• get isOpen(): boolean

• Indicates if the client connection is open

  Returns boolean

  true if the client connection is open, false otherwise

isReady

• get isReady(): boolean

• Indicates if the client connection is ready to accept commands

  Returns boolean

  true if the client connection is ready, false otherwise

MULTI

• MULTI(): RedisSentinelMultiCommandType<[], M, F, S, RESP, TYPE_MAPPING>

• Returns RedisSentinelMultiCommandType<[], M, F, S, RESP, TYPE_MAPPING>

UNWATCH

• UNWATCH(): Promise<"OK">

• Returns Promise<"OK">

WATCH

• WATCH(key): Promise<"OK">

• Parameters

  • key: RedisVariadicArgument

  Returns Promise<"OK">

_execute

• _execute<T>(isReadonly, fn): Promise<T>

• Type Parameters

  • T

  Parameters

  • isReadonly: undefined | boolean

  • fn: ((client) => Promise<T>)

    • • (client): Promise<T>

      • Parameters

        • client: RedisClient<RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping>

        Returns Promise<T>

  Returns Promise<T>

_executeMulti

• _executeMulti(isReadonly, commands): Promise<unknown[]>
• Internal

  f

  Parameters

  • isReadonly: undefined | boolean

  • commands: RedisMultiQueuedCommand[]

  Returns Promise<unknown[]>

_executePipeline

• _executePipeline(isReadonly, commands): Promise<unknown[]>
• Internal

  Parameters

  • isReadonly: undefined | boolean

  • commands: RedisMultiQueuedCommand[]

  Returns Promise<unknown[]>

release

• release(): undefined | Promise<void>

• Releases the client lease back to the pool

  After calling this method, the client instance should no longer be used as it will be returned to the client pool and may be given to other operations.

  Returns undefined | Promise<void>

  A promise that resolves when the client is ready to be reused, or undefined if the client was immediately ready

  Throws

  Error if the lease has already been released

sendCommand

• sendCommand<T>(isReadonly, args, options?): Promise<T>

• Type Parameters

  • T = ReplyUnion

  Parameters

  • isReadonly: undefined | boolean

  • args: CommandArguments

  • Optional options: CommandOptions<TypeMapping>

  Returns Promise<T>

withCommandOptions

• withCommandOptions<OPTIONS, TYPE_MAPPING>(options): RedisSentinelClientType<M, F, S, RESP, TYPE_MAPPING extends TypeMapping
      ? TYPE_MAPPING
      : {}>

• Type Parameters

  • OPTIONS extends CommandOptions<TYPE_MAPPING>

  • TYPE_MAPPING extends TypeMapping

  Parameters

  • options: OPTIONS

  Returns RedisSentinelClientType<M, F, S, RESP, TYPE_MAPPING extends TypeMapping
      ? TYPE_MAPPING
      : {}>

withTypeMapping

• withTypeMapping<TYPE_MAPPING>(typeMapping): RedisSentinelClientType<M, F, S, RESP, TYPE_MAPPING extends TypeMapping
      ? TYPE_MAPPING
      : {}>

• Override the typeMapping command option

  Type Parameters

  • TYPE_MAPPING extends TypeMapping

  Parameters

  • typeMapping: TYPE_MAPPING

  Returns RedisSentinelClientType<M, F, S, RESP, TYPE_MAPPING extends TypeMapping
      ? TYPE_MAPPING
      : {}>

Static create

• create<M, F, S, RESP, TYPE_MAPPING>(options, internal, clientInfo, commandOptions?): RedisSentinelClientType<M, F, S, RESP, TYPE_MAPPING>

• Type Parameters

  • M extends RedisModules = {}

  • F extends RedisFunctions = {}

  • S extends RedisScripts = {}

  • RESP extends RespVersions = 3

  • TYPE_MAPPING extends TypeMapping = {}

  Parameters

  • options: RedisSentinelOptions<M, F, S, RESP, TYPE_MAPPING>

  • internal: RedisSentinelInternal<M, F, S, RESP, TYPE_MAPPING>

  • clientInfo: ClientInfo

  • Optional commandOptions: CommandOptions<TYPE_MAPPING>

  Returns RedisSentinelClientType<M, F, S, RESP, TYPE_MAPPING>

Static factory

• factory<M, F, S, RESP, TYPE_MAPPING>(config?): ((internal, clientInfo, commandOptions?) => RedisSentinelClientType<M, F, S, RESP, TYPE_MAPPING>)

• Type Parameters

  • M extends RedisModules = {}

  • F extends RedisFunctions = {}

  • S extends RedisScripts = {}

  • RESP extends RespVersions = 3

  • TYPE_MAPPING extends TypeMapping = {}

  Parameters

  • Optional config: SentinelCommander<M, F, S, RESP, TYPE_MAPPING>

  Returns ((internal, clientInfo, commandOptions?) => RedisSentinelClientType<M, F, S, RESP, TYPE_MAPPING>)

  • • (internal, clientInfo, commandOptions?): RedisSentinelClientType<M, F, S, RESP, TYPE_MAPPING>

    • Parameters

      • internal: RedisSentinelInternal<M, F, S, RESP, TYPE_MAPPING>

      • clientInfo: ClientInfo

      • Optional commandOptions: CommandOptions<TYPE_MAPPING>

      Returns RedisSentinelClientType<M, F, S, RESP, TYPE_MAPPING>