How to use pool for redis connection with express-session and connect-redis

You are correct: to implement connection pooling for Redis in your Express.js application using express-session and connect-redis, you can indeed use the ioredis package.
ioredis supports connection pooling, meaning it manages multiple connections under the hood.

 Express App
    │
    ├─> express-session
    │      │
    │      └─> RedisStore ──> ioredis (Redis Client)
    │
    └─> Redis Server

But you seem to be under the impression that you need to explicitly configure or manage connection pooling for Redis within their application.

However, ioredis automatically handles connection pooling. When you a new instance of Redis, as you did with var redisClient = new Redis({ host: 'redis', port: 6379 }), ioredis is already managing the connections efficiently. Each command issued through ioredis is queued and executed using an available connection in a pool managed internally by ioredis.
There is no need to manually set up pooling mechanisms as ioredis optimizes connection usage and management out of the box.

The only additional considerations would be around fine-tuning the Redis client configurations:

const Redis = require('ioredis');
const session = require('express-session');
const RedisStore = require('connect-redis')(session);

// ioredis automatically manages a pool of connections
var redisClient = new Redis({
  host: 'redis',
  port: 6379,
  // Additional options to manage the pool:
  maxRetriesPerRequest: null,  // Do not give up on a request
  enableReadyCheck: true,      // Only use ready instances
  retryStrategy: (times) => Math.min(times * 50, 2000)  // Increase delay between retries
});

redisClient.on('ready', () => { console.log(`Redis is ready @${redisClient.options.host}`) });
redisClient.on('error', (err) => { console.log('Redis error: ', err) });

const sessionAge = 24 * 60 * 60 * 1000;  // Fixed to correct unit (milliseconds for one day)

module.exports = session({
  store: new RedisStore({ client: redisClient }),
  key: 'sid',
  secret: 'secret',
  saveUninitialized: false,
  resave: false,
  rolling: false,
  cookie: { secure: false, maxAge: sessionAge, sameSite: 'lax' },
  expires: sessionAge
});

Note: redis/ioredis issue 470 uses new redis.Cluster() for connection pooling, but for a single Redis instance, ioredis handles connection pooling internally.

The sessionAge was corrected to use milliseconds equivalent to 24 hours as express-session expects this value in milliseconds.
The error handling and logging in place will provide visibility into the health of the Redis connection.

Do you mean a single connection is created?"

When using ioredis, a single connection is not created per request. Instead, ioredis manages a pool of connections internally. That means when you create a new instance of the Redis class, it handles multiple connections under the hood, reusing and managing these connections efficiently across multiple requests. So, for every request, your application does not create a new Redis connection; it uses the pool managed by ioredis.

Your solution involves manually managing a connection pool using a third-party library, ioredis-conn-pool, which is not part of the standard ioredis package. It allows for explicit control over the number of connections (with a minimum and maximum threshold), which can be beneficial in scenarios where very granular control over connection management is needed. You modify the methods of RedisStore to manage fetching and releasing connections from the pool for each session operation (get, set, destroy, touch), which adds complexity but offers full control over how connections are utilized.

That seems… a bit harder to maintain and debug. And it relies on an additional third-party library (ioredis-conn-pool), which might have its own maintenance and compatibility issues.