How to send data from redis subscriber to express route - express

Question

I have a redis pubsub client where publisher is in one file and subscriber is in another file working perfectly
I have 2 controllers a home controller that handles '/' route and a data controller that handles '/data' route
Inside my redis subscriber I want to update the state of a variable that I continuously get from publisher
How do I send this state to both controllers when they do a request
I was doing
app.get('/', (req, res) => {
c = redis.createClient()
c.on("message", (channel, message) => {
// Send data here
})
})
This does not look like a good idea, it is creating a new CLIENT for every request to the '/' endpoint
I want to be able to do
// home controller file
app.get('/', (req, res) => {
res.json(state)
})
// data controller file
app.get('/data', (req, res) => {
res.json(state)
})
How to implement this state

Answer 1

After doing some research, I decided to use Node's native events module to solve this. This example uses ioredis rather than node_redis, but the principle is the same.
First, I instantiate three redis clients. One for regular db work, a publisher and a subscriber
/* redis.js */
const Redis = require('ioredis');
const redis = new Redis();
const publisher = new Redis();
const subscriber = new Redis();
// redis is the defaut export
// publisher and subscriber are "named" exports
const client = (module.exports = redis);
client.publisher = publisher;
client.subscriber = subscriber;
Next we create an EventEmitter in node that will emit an event every time the subscriber receives a message from a channel in redis.
/* emitter.js */
const EventEmitter = require('events');
const { subscriber } = require('./redis');
const eventEmitter = new EventEmitter();
subscriber.subscribe('my-channel', err => {
if (err) { return console.log('Unable to subscribe to my-event channel') };
console.log('Subscription to my-event channel successful');
});
subscriber.on('message', (channel, message) => {
eventEmitter.emit('my-event', message);
});
module.exports = eventEmitter;
Here we have two routes. The first handles a PUT request that sets a field in redis and then publishes a message to a channel with the key of the hash that was updated. The second route handles a GET request that stays open (as an EventSource for an SSE connection for example). It listens to an event from emitter and then sends the data of the updated key from redis
/* route.js*/
const express = require('express');
const redis = require('./redis');
const { publisher } = require('./redis');
const { eventEmitter } = require('./emitter');
const router = express.Router();
router.put('/content', async (req, res) => {
const { key, field, content } = req.body;
try {
await redis.hset(key, field, content);
res.sendStatus(200);
return publisher.publish('my-channel', key);
} catch(err) {
res.status(500).send(err.message);
}
});
router.get('/content-stream', (req, res) => {
res.writeHead(200, {
'Content-Type': 'text/event-stream',
'Cache-Control': 'no-cache',
Connection: 'keep-alive'
});
res.write('\n');
const handleEvent = async key => {
try {
const query = await redis.hgetall(key);
res.write(`data: ${JSON.stringify(query)}\n\n`);
} catch(err) {
console.log('Something went wrong');
}
}
eventEmitter.addListener('my-event', handleEvent);
req.on('close', eventEmitter.removeListener('my-event', handleEvent));
module.exports = router;
This will effectively allow you to avoid instantiating new redis clients with every connection. There may be better ways of doing this, but this is what worked for me.