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.

Practice

1. What is the main benefit of integrating Redis as a distributed cache in an Express application?

easy

A. It speeds up data access by storing shared data in memory across servers.

B. It replaces the need for a database entirely.

C. It automatically scales the Express server instances.

D. It provides a user interface for managing Express routes.

Solution

1. Step 1: Understand Redis role in caching

   Redis stores data in memory, making data access very fast compared to disk-based storage.

2. Step 2: Recognize distributed cache benefit

   Redis can be shared across multiple servers, so all Express instances access the same cached data, improving speed and consistency.

3. Final Answer:

   It speeds up data access by storing shared data in memory across servers. -> Option A

4. Quick Check:

   Redis cache = fast shared data [OK]

Hint: Redis caches shared data in memory for speed [OK]

Common Mistakes:

• Thinking Redis replaces the database
• Confusing Redis with server scaling tool
• Assuming Redis manages Express routes

2. Which of the following is the correct way to create a Redis client in an Express app using the latest redis package?

easy

A. const client = new Redis(); client.start();

B. const client = redis.createClient(); client.connect();

C. const client = redis.connectClient();

D. const client = redis.create(); client.open();

Solution

1. Step 1: Recall redis package usage

   The modern redis package uses createClient() to create a client instance.

2. Step 2: Connect the client

   After creating, you must call client.connect() to establish connection asynchronously.

3. Final Answer:

   const client = redis.createClient(); client.connect(); -> Option B

4. Quick Check:

   createClient + connect = correct syntax [OK]

Hint: Use createClient() then connect() to start Redis client [OK]

Common Mistakes:

• Using non-existent methods like start() or open()
• Calling connectClient() which does not exist
• Instantiating Redis with new Redis() incorrectly

3. Given this Express route using Redis cache:

app.get('/data', async (req, res) => {
  const cacheKey = 'myData';
  const cached = await client.get(cacheKey);
  if (cached) return res.send(JSON.parse(cached));
  const data = { value: 42 };
  await client.set(cacheKey, JSON.stringify(data), { EX: 10 });
  res.send(data);
});

What happens when you call /data twice within 10 seconds?

medium

A. The first call stores data in cache, second call returns cached data.

B. The first call fetches from cache, second call fetches fresh data.

C. Both calls fetch fresh data and store it in cache.

D. Both calls return cached data without storing anything.

Solution

1. Step 1: Analyze first call behavior

   On first call, cache is empty, so data is created and stored with 10 seconds expiration.

2. Step 2: Analyze second call within 10 seconds

   Second call finds cached data and returns it directly without recreating or resetting cache.

3. Final Answer:

   The first call stores data in cache, second call returns cached data. -> Option A

4. Quick Check:

   Cache empty first, then hit cache [OK]

Hint: First call caches, second call uses cache within expiry [OK]

Common Mistakes:

• Assuming cache is refreshed on every call
• Thinking cache is never used
• Ignoring expiration time effect

4. Consider this Express code snippet using Redis:

app.get('/count', async (req, res) => {
  const count = await client.get('count');
  const newCount = count + 1;
  await client.set('count', newCount);
  res.send({ count: newCount });
});

What issue will occur when this route is called?

medium

A. SyntaxError due to incorrect async function syntax.

B. ReferenceError because client is not defined.

C. count is a string from Redis, so count + 1 performs string concatenation instead of numeric addition.

D. No error; the count increments correctly.

Solution

1. Step 1: Identify data type of count

   Redis stores values as strings, so count is a string when retrieved (null on first call).

2. Step 2: Analyze addition operation

   Adding number 1 to a string (after first call) results in string concatenation (e.g., "1" + 1 = "11").

3. Step 3: Predict issue

   This causes incorrect count values like 1, "11", "111", etc., instead of proper increments 1, 2, 3.

4. Final Answer:

   count is a string from Redis, so count + 1 performs string concatenation instead of numeric addition. -> Option C

5. Quick Check:

   String + number without conversion = concatenation [OK]

Hint: Convert Redis string to number before adding [OK]

Common Mistakes:

• Assuming Redis returns numbers directly
• Ignoring async/await correctness
• Thinking no error occurs

5. You want to cache user profile data in Redis with a 5-minute expiration in an Express app. Which code snippet correctly sets the cache with expiration and handles errors properly?

hard

A. client.set('user:123', JSON.stringify(profile)); setTimeout(() => client.del('user:123'), 300000);

B. client.set('user:123', JSON.stringify(profile), 300);
console.log('Cache set');

C. await client.set('user:123', profile, { expire: 300 });

D. try {
await client.set('user:123', JSON.stringify(profile), { EX: 300 });
} catch (err) {
console.error('Cache error:', err);
}

Solution

1. Step 1: Use correct Redis set syntax with expiration

   The redis client set method accepts options with EX for expiration in seconds, so { EX: 300 } is correct.

2. Step 2: Handle errors with try-catch

   Since set is async, wrapping in try-catch ensures errors are caught and logged properly.

3. Step 3: Check other options for mistakes

   client.set('user:123', JSON.stringify(profile), 300); console.log('Cache set'); misses async/await and uses wrong expiration argument; C uses wrong option key; D manually deletes cache but is less efficient.

4. Final Answer:

   try { await client.set('user:123', JSON.stringify(profile), { EX: 300 }); } catch (err) { console.error('Cache error:', err); } -> Option D

5. Quick Check:

   set with EX + try-catch = correct [OK]

Hint: Use { EX: seconds } option and try-catch for errors [OK]

Common Mistakes:

• Passing expiration as a separate argument
• Not stringifying objects before caching
• Ignoring async error handling