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

constructor

• new RedisPoolManager<
      M extends RedisModules = RedisDefaultModules,
      F extends RedisFunctions = RedisFunctions,
      S extends RedisScripts = RedisScripts,
      RESP extends RespVersions = 3,
      TYPE_MAPPING extends TypeMapping = TypeMapping,
  >(
      settings: RedisPoolManagerArg<M, F, S, RESP, TYPE_MAPPING>,
  ): RedisPoolManager<M, F, S, RESP, TYPE_MAPPING>

  Creates a new RedisPoolManager instance.

  Type Parameters

  • M extends RedisModules = RedisDefaultModules
  • F extends RedisFunctions = RedisFunctions
  • S extends RedisScripts = RedisScripts
  • RESP extends RespVersions = 3
  • TYPE_MAPPING extends TypeMapping = TypeMapping

  Parameters

  • settings: RedisPoolManagerArg<M, F, S, RESP, TYPE_MAPPING>

    Configuration settings for the manager

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

  Remarks

  The connection is created but not opened. You must call connect() to establish the connection. Connection events (error, connect, ready, end, reconnecting) are automatically registered and logged.

Static Readonlytype

close

• close(): Promise<void>

  Closes the Redis connection gracefully using the QUIT command.

  Returns Promise<void>

  A promise that resolves to the Redis server's response to the QUIT command

  Example

  await manager.close();
  Copy

closeConnection

• closeConnection(): Promise<void>

  Alias for close(). Closes the Redis connection gracefully.

  Returns Promise<void>

  A promise that resolves to the Redis server's response to the QUIT command

  Example

  await manager.closeConnection();
  Copy

connect

• connect(): Promise<RedisPoolManager<M, F, S, RESP, TYPE_MAPPING>>

  Establishes the connection to Redis.

  Returns Promise<RedisPoolManager<M, F, S, RESP, TYPE_MAPPING>>

  A promise that resolves to this manager instance for method chaining

  Throws

  If the connection cannot be established

  Example

  await manager.connect();
  Copy

createModel

• createModel<TSchema extends StandardSchemaV1<unknown, unknown>>(
      schema: Schema<TSchema>,
  ): Repository<TSchema>

  Creates a repository for the given schema, allowing interaction with the corresponding Redis data.

  Type Parameters

  • TSchema extends StandardSchemaV1<unknown, unknown>

  Parameters

  • schema: Schema<TSchema>

    The schema for which to create the repository

  Returns Repository<TSchema>

  A repository instance for the specified schema

getConnection

• getConnection(): RedisClientPoolType<M, F, S, RESP, TYPE_MAPPING>

  Gets the underlying Redis client connection.

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

  The Redis client instance

  Example

  const client = manager.getConnection();
  await client.set('mykey', 'myvalue');
  Copy

OptionalgetModel

• getModel?(_name: string): unknown

  Get a model by name (optional)

  Parameters

  • _name: string

  Returns unknown

  The model instance or undefined if not found

healthCheck

• healthCheck(): Promise<RedisHealthCheckResult>

  Performs a comprehensive health check on the Redis connection. Tests connectivity by sending a PING command and gathering connection metrics.

  Returns Promise<RedisHealthCheckResult>

  A promise that resolves to a detailed health check result including:

  • Connection status (open/ready)
  • Ping response
  • Registered models
  • Response latency
  • Error details (if unhealthy)

  Example

  const health = await manager.healthCheck();
  if (health.healthy) {
    console.log(`Redis is healthy. Latency: ${health.details.latency}`);
    console.log(`Models: ${health.details.models?.join(', ')}`);
  } else {
    console.error(`Redis is unhealthy: ${health.message}`);
  }
  Copy

isConnected

• isConnected(): Promise<boolean>

  Checks if the Redis connection is currently open.

  Returns Promise<boolean>

  A promise that resolves to true if connected, false otherwise

  Example

  if (await manager.isConnected()) {
    console.log('Redis is connected');
  }
  Copy

run

• run<R>(operation: () => Promise<R>): Promise<R>

  Executes an asynchronous operation with the Redis connection, ensuring that the connection is open, and enforcing a command timeout.

  Because node-redis' own command timeout stops once the command is written to the socket, so it does not protect against a frozen Redis.

  This method adds an additional layer of protection by enforcing a command timeout at the application level.

  The value of the command timeout is taken from the options provided during the client's initialization (commandOptions.timeout) or defaults to 5000 milliseconds if not specified.

  Type Parameters

  • R

  Parameters

  • operation: () => Promise<R>

    The asynchronous operation to execute with the Redis connection

  Returns Promise<R>

  A promise that resolves to the result of the operation or rejects with an error if the operation fails or times out

  Throws

  If the Redis connection is not open

  Throws

  If the operation exceeds the configured command timeout