How to Fallback to MemoryStore When Redis Connection Fails in Node.js Express Sessions

You need to restructure your app initialization so that you decide which session store to use before registering the middleware. In other words, wait for (or at least check) the Redis connection status and then pass either the RedisStore or no setter (letting express‑session fall back to its default MemoryStore).

One common way to do this is to wrap your server startup in an asynchronous function. For example:

JAVASCRIPTCopied
const { RedisStore } = require('connect-redis');
const { createClient } = require('redis');
const express = require('express');
const session = require('express-session');
const http = require('http');

// Redis connection settings
const redisOptions = {
  url: 'MY_URL',
  password: 'MY_PW'
};

(async () => {
  let sessionStore;
  const client = createClient(redisOptions);

  try {
    await client.connect();
    await client.ping();
    console.log('Redis connected successfully, using RedisStore');
    sessionStore = new RedisStore({ client });
  } catch (error) {
    console.error('Redis connection failed, falling back to MemoryStore.');
    console.error(error);
    // Do not set sessionStore to anything. express-session will use MemoryStore by default.
    sessionStore = null;
  }

  // Now create the app and decide which session options to use
  const app = express();
  // Customize your cookie configuration as needed
  const cookieConfig = { secure: false, maxAge: 60000 };
  
  const sessionOptions = {
    secret: 'MY_SECRET',
    key: 'MY_KEY',
    resave: false,
    saveUninitialized: false,
    cookie: cookieConfig
  };

  // Only add the Redis store if the connection was successful
  if (sessionStore) {
    sessionOptions.store = sessionStore;
  }

  app.use(session(sessionOptions));

  // Your Express routes, middleware, etc.
  app.get('/', (req, res) => {
    res.send('Hello World!');
  });
  
  const port = 2002;
  const hostname = '127.0.0.1';
  const server = http.createServer(app);
  server.listen(port, hostname, () => {
    console.log(`Server running at http://${hostname}:${port}/`);
  });
})();

How This Works

1. Delayed Initialization:
   The app (and its middleware) is only created after we attempt to connect to Redis. This allows us to decide which session store to use.

2. Fallback Logic:
   If the Redis connection throws an error, we do not add a store to the session options. In this case, express‑session uses its default MemoryStore.

3. Graceful Degradation:
   The server still starts even if Redis fails. This ensures that your application remains functional with a fallback backend for sessions.

This approach ensures that the Redis connection is tested before setting up the session middleware and your server listens only once the decision of which store to use is made.