Redis integration for distributed cache in Express - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when fetching a cached value?

Given this Express route using Redis as a cache, what will be the response if the key 'user:123' exists with value 'Alice' in Redis?

Express

import express from 'express';
import { createClient } from 'redis';

const app = express();
const redisClient = createClient();
await redisClient.connect();

app.get('/user/:id', async (req, res) => {
  const userId = req.params.id;
  const cachedUser = await redisClient.get(`user:${userId}`);
  if (cachedUser) {
    res.send(`Cached User: ${cachedUser}`);
  } else {
    res.send('User not found in cache');
  }
});

A Error: redisClient.get is not a function

B User not found in cache

C Cached User: Alice

D Cached User: undefined

💡 Hint

Think about what happens when the key exists in Redis and is retrieved.

If the key 'user:123' exists with value 'Alice', redisClient.get returns 'Alice', so the response is 'Cached User: Alice'.

📝 Syntax

intermediate

Which option correctly initializes Redis client in Express?

Choose the correct way to create and connect a Redis client using the modern redis package in an Express app.

A

import { createClient } from 'redis';
const client = createClient;
client.connect();

B

import { createClient } from 'redis';
const client = createClient();
await client.connect();

C

import redis from 'redis';
const client = redis.createClient();
client.connect();

D

const redis = require('redis');
const client = redis.createClient();
client.connect();

💡 Hint

The modern redis package uses createClient function and connect returns a promise.

Option B correctly imports createClient, creates a client instance, and awaits the asynchronous connect call.

🔧 Debug

advanced

Why does this Redis cache middleware cause a runtime error?

Examine the middleware below. Why does it cause a runtime error when used in an Express app?

Express

async function cache(req, res, next) {
  const key = req.originalUrl;
  const cachedData = redisClient.get(key);
  if (cachedData) {
    res.send(cachedData);
  } else {
    next();
  }
}

A redisClient.get returns a promise but code treats it as synchronous, causing res.send to get a promise object.

B redisClient.get is undefined because redisClient was not imported.

C The middleware does not call next() in any case, causing request hang.

D The key variable is not a string, causing redisClient.get to throw a TypeError.

💡 Hint

Check if redisClient.get is asynchronous and how its result is used.

redisClient.get returns a promise. Without awaiting it, cachedData is a promise, so res.send sends a promise object, causing unexpected behavior.

❓ state_output

advanced

What is the value of 'cacheHit' after this Express route runs?

Consider this Express route using Redis cache. What is the value of 'cacheHit' after a request to '/data' if the cache was empty initially?

Express

let cacheHit = false;

app.get('/data', async (req, res) => {
  const cached = await redisClient.get('data');
  if (cached) {
    cacheHit = true;
    res.send(cached);
  } else {
    cacheHit = false;
    const freshData = 'fresh data';
    await redisClient.set('data', freshData);
    res.send(freshData);
  }
});

A undefined

B null

C true

D false

💡 Hint

Think about the cache state before the request and what the code does when cache is empty.

Since the cache is empty initially, cached is null, so cacheHit is set to false after the request.

🧠 Conceptual

expert

Which Redis feature best supports distributed cache invalidation across multiple Express instances?

You have multiple Express servers using Redis as a distributed cache. Which Redis feature helps notify all servers to invalidate a cache key when data changes?

A Redis Pub/Sub to publish invalidation messages to all servers

B Redis persistence (RDB snapshots) to save cache state

C Redis transactions to atomically update cache keys

D Redis Lua scripting to run cache logic on server

💡 Hint

Think about how servers can communicate cache changes in real time.

Redis Pub/Sub allows servers to subscribe to channels and receive messages instantly, enabling coordinated cache invalidation.