Connect Node.js to Redis | Async Promises & Pub/Sub

# CHAPTER 16

Redis with Node.js Applications #

1. Introduction #

2. Learning Objectives #

• Install the official redis npm package.

• Instantiate an asynchronous Redis client in Node.js.

• Execute basic caching commands using async/await.

• Serialize JavaScript Objects into Redis Hashes.

• Architect a real-time Node.js Pub/Sub listener.

3. Installation and Setup #

npm init -y
npm install redis

Create a file named app.js.

4. Establishing the Async Connection #

const redis = require('redis');

async function initRedis() {
    // 1. Create the client (defaults to localhost:6379)
    const client = redis.createClient();

    // 2. Setup Error Event Listeners
    client.on('error', (err) => console.log('Redis Client Error', err));

    // 3. Await the connection
    await client.connect();
    console.log('Successfully connected to Redis!');
    
    return client;
}

initRedis();

5. Executing Commands (Async/Await) #

async function runOperations() {
    const client = await initRedis();

    // SET a string
    await client.set('node_framework', 'Express.js');

    // GET a string
    const framework = await client.get('node_framework');
    console.log('Cached Framework:', framework);

    // Atomic INCR
    await client.set('api_hits', 0);
    await client.incr('api_hits');
    const hits = await client.get('api_hits');
    console.log('API Hits:', hits);

    // Disconnect gracefully
    await client.disconnect();
}

runOperations();

6. Working with JSON and Hashes #

async function storeUser() {
    const client = await initRedis();

    // Using HSET to store a complex object natively in memory!
    await client.hSet('user:888', {
        name: 'Jane Doe',
        email: 'jane@example.com',
        status: 'Active'
    });

    // Retrieve specific field
    const name = await client.hGet('user:888', 'name');
    
    // Retrieve entire object
    const userObj = await client.hGetAll('user:888');
    
    console.log('User Data:', userObj);
    // Outputs: { name: 'Jane Doe', email: 'jane@example.com', status: 'Active' }
}

7. Node.js Pub/Sub (The Killer Feature) #

async function setupPubSub() {
    const publisher = redis.createClient();
    const subscriber = publisher.duplicate(); // Clones the connection settings

    await publisher.connect();
    await subscriber.connect();

    // 1. Setup the Listener (Subscriber)
    await subscriber.subscribe('global_chat', (message) => {
        console.log(`[LIVE CHAT DETECTED]: ${message}`);
        // Here, Node.js would push the message to all connected WebSockets!
    });

    // 2. Broadcast a Message (Publisher)
    setTimeout(async () => {
        await publisher.publish('global_chat', 'Hello to all servers!');
    }, 2000);
}

8. Mini Project: Express.js Caching Middleware #

const express = require('express');
const app = express();
// (Assume 'client' is connected)

// The Caching Middleware
async function checkCache(req, res, next) {
    const { id } = req.params;
    const data = await client.get(`api_user:${id}`);
    
    if (data) {
        console.log("Serving from Cache!");
        return res.json(JSON.parse(data));
    }
    next(); // Cache Miss! Proceed to the actual route.
}

// The Actual Route
app.get('/user/:id', checkCache, async (req, res) => {
    const { id } = req.params;
    console.log("Fetching from slow database...");
    
    // Simulate DB query
    const dbData = { id: id, name: "Alice", type: "Premium" };
    
    // Save to Cache for 60 seconds
    await client.setEx(`api_user:${id}`, 60, JSON.stringify(dbData));
    
    res.json(dbData);
});

9. Common Mistakes #

• Forgetting await: If you write const name = client.get('key');, the name variable will not contain the string. It will contain a Promise { <pending> } object. You must explicitly write await client.get('key') to force the V8 engine to pause and wait for the network packet to return from the Redis server.

10. Best Practices #

• Connection Reuse: Do not run redis.createClient() and .connect() inside every single API route. This will open thousands of TCP connections and crash the database. Create one single global client connection when your Node.js server boots up, and reuse that identical connection object across all of your routes.

11. Exercises #

1. 1. What Node.js JavaScript keyword is mandatory when executing Redis commands to ensure the code waits for the network response?

1. 2. When implementing a real-time Pub/Sub architecture in Node.js, why must you call publisher.duplicate() to create a secondary client object?

12. Redis Challenges #

13. MCQ Quiz with Answers #

14. Interview Questions #

• Q: Walk through the architectural code flow of building an Express.js Caching Middleware block. Explain exactly how the next() function is utilized during a Cache Miss to fall back to the primary database.

• Q: Explain why a Node.js server utilizing Redis Pub/Sub must explicitly instantiate two entirely separate TCP client connections (createClient and duplicate). How does this structural requirement relate to the blocking nature of the SUBSCRIBE command?

15. FAQs #

16. Summary #

17. Next Chapter Recommendation #