How should I go about using Redis for creating notifications with express/nodejs?

Question

Okay so I have a Nodejs/Express app that has an endpoint which allows users to receive notifications by opening up a connection to said endpoint:

var practitionerStreams = [] // this is a list of all the streams opened by pract users to the 
backend

async function notificationEventsHandler(req, res){ 
  const headers ={
      'Content-Type': 'text/event-stream',
      'Connection': 'keep-alive',
      'Cache-Control': 'no-cache'
  } 

  const practEmail = req.headers.practemail
  console.log("PRACT EMAIL", practEmail)

  const data = await ApptNotificationData.findAll({
      where: {
          practEmail: practEmail
      }
  })

  //console.log("DATA", data)

  res.writeHead(200, headers)
  await res.write(`data:${JSON.stringify(data)}\n\n`) 

  // create a new stream
  const newPractStream = {
    practEmail: practEmail,
    res
  }

  // add the new stream to list of streams
  practitionerStreams.push(newPractStream)


  req.on('close', () => {
    console.log(`${practEmail} Connection closed`);
    practitionerStreams = practitionerStreams.filter(pract => pract.practEmail !== pract.practEmail);
  });
  
  return res

}

async function sendApptNotification(newNotification, practEmail){
    var updatedPractitionerStream = practitionerStreams.map((stream) => 
    // iterate through the array and find the stream that contains the pract email we want
    // then write the new notification to that stream
    
    { 
      if (stream["practEmail"]==practEmail){
        console.log("IF")
        stream.res.write(`data:${JSON.stringify(newNotification)}\n\n`)
        
        return stream
    }
    else {
      // if it doesnt contain the stream we want leave it unchanged
      console.log("ELSE")
      return stream
    }
    }
  )
  
  practitionerStreams = updatedPractitionerStream  
  }

Basically when the user connects it takes the response object (that will stay open), will put that in an Object along with a unique email, and write to it in the future in sendApptNotification

But obviously this is slow for a full app, how exactly do I replace this with Redis? Would I still have a Response object that I write to? Or would that be replaced with a redis stream that I can subscribe to on the frontend? I also assume I would store all my streams on redis as well

edit: from what examples I've seen people are writing events from redis to the response object

Thank you in advance

Answer 1

If you want to use Redis Stream as notification system, you can follow this official guide: https://redis.com/blog/how-to-create-notification-services-with-redis-websockets-and-vue-js/ . To get this data as real time you need to create a websocket connection. I prefer to send to you an official guide instead of create it for you it's because the quality of this guide. It's perfect to anyone understand how to create it, but you need to adapt for your reality, of course.

However like I've said to you in the comments, I just believe that it's more simple to do requests in your api endpoint like /api/v1/notifications with setInterval in your frontend code and do requests each 5 seconds for example. If you prefer to use a notification system as real time I think you need to understand why do you need it, so in the future you can change your system if you think you need it. Basically it's a trade-off you must to do!

For my example imagine two tables in a relational database, one as Users and the second as Notifications. The tables of this example:

UsersTable
id  name
1   andrew
2   mark

NotificationTable
id  message    userId  isRead
1   message1    1       true
2   message2    1       false
3   message3    2       false

The endpoint of this example will return all cached notifications that isn't read by the user. If the cache doesn't exists, it will return the data from the database, put it on the cache and return to the user. In the next call from API, you'll get the result from cache. There some points to complete in this example, for example the query on the database to get the notifications, the configuration of time expiration from cache and the another important thing is: if you want to update all the time the notifications in the cache, you need to create a middleware and trigger it in the parts of your code that needs to notify the notifications user. In this case you'll only update the database and cache. But I think you can complete these points.

const redis = require('redis');
const redisClient = redis.createClient();

app.get('/notifications', async (request, response) => {
    const userId = request.user.id;
    const cacheResult = await redisClient.get(`user:${userId}:notifications`)

    if (cacheResult) return response.send(cacheResult);

    const notifications = getUserNotificationsFromDatabase(userId); 

    redisClient.set(`user:${userId}:notifications`, notifications);

    response.send(notifications);
})

Besides that there's another way, you can simple use only the redis or only the database to manage this notification. Your relational database with the correct index will send to your the results as faster as you expect. You'll only think about how much notifications you'll have been.