Using MongoDB for real-time chat database - node.js

Question

I am working on a personal project to increase my skill and experience with Nodejs, Express, Socket.io and MongoDB. I seem to have hit a wall in formulating how the database should work for this sort of app.I have been thinking about it and could use some help from anyone who can take some time. My application allows the user to enter a username and a choose a room title. After this they are loaded into the room and others can join that room and chat in real time. I want to persist the data, saving it for each room on disconnect and repopulating it on connect.
Each Room has a name associated with it and the messages themselves. Each message has a name of sender, the timestamp, and the text/content.
But when it comes to actually structuring the models and how to organize collections, I am getting confused. Can anyone help me out or set me on the right path for this kind of application?
server.js(backend)
require('dotenv').config();
const path = require('path');
const http = require('http');
const express = require('express');
const socketio = require('socket.io');
const mongoose = require('mongoose');
const formatMessage = require('./utils/messages');
const {
userJoin,
getCurrentUser,
userLeave,
getRoomUsers
} = require('./utils/users');
const app = express();
const server = http.createServer(app);
const io = socketio(server);
// Set static folder
app.use(express.static(path.join(__dirname, 'public')));
const botName = 'ChatCord Bot';
const messages = [];
//Database connection
const uri = process.env.ATLAS_URI;
mongoose.connect(uri, {
useNewUrlParser: true,
useUnifiedTopology: true,
useCreateIndex: true
});
const connection = mongoose.connection;
connection.once('open', () => {
console.log("MongoDB database connection established successfully");
})
// Run when client connects
io.on('connection', socket => {
socket.on('joinRoom', ({
username,
room
}) => {
const user = userJoin(socket.id, username, room);
socket.join(user.room);
// Welcome current user
socket.emit('message', formatMessage(botName, 'Welcome to ChatCord!'));
//Load messages for room from database
socket.broadcast.to(user.room).emit(
'message', formatMessage()
)
// Broadcast when a user connects
socket.broadcast
.to(user.room)
.emit(
'message',
formatMessage(botName, `${user.username} has joined the chat`)
);
// Send users and room info
io.to(user.room).emit('roomUsers', {
room: user.room,
users: getRoomUsers(user.room)
});
});
// Listen for chatMessage
socket.on('chatMessage', msg => {
const user = getCurrentUser(socket.id);
io.to(user.room).emit('message', formatMessage(user.username, msg));
});
// Runs when client disconnects
socket.on('disconnect', () => {
const user = userLeave(socket.id);
if (user) {
io.to(user.room).emit(
'message',
formatMessage(botName, `${user.username} has left the chat`)
);
// Send users and room info
io.to(user.room).emit('roomUsers', {
room: user.room,
users: getRoomUsers(user.room)
});
}
//Save messages for room to database
});
});
const PORT = process.env.PORT || 3000;
server.listen(PORT, () => console.log(`Server running on port ${PORT}`));
main.js(frontend)
const chatForm = document.getElementById('chat-form');
const chatMessages = document.querySelector('.chat-messages');
const roomName = document.getElementById('room-name');
const userList = document.getElementById('users');
//Get username and room from URL
const {username, room } = Qs.parse(location.search, {
ignoreQueryPrefix: true
});
console.log(username, room);
const socket = io();
//Join chatroom
socket.emit('joinRoom', {username, room});
//Get room and users
socket.on('roomUsers', ({ room, users }) => {
outputRoomName(room);
outputUsers(users);
})
socket.on('message', message => {
outputMessage(message);
//Scroll down on new message
chatMessages.scrollTop = chatMessages.scrollHeight;
});
//Message submit
chatForm.addEventListener('submit', (e) => {
e.preventDefault();
//Get message text
const msg = e.target.elements.msg.value;
//Emit message to server
socket.emit('chatMessage',msg);
//Clear input
e.target.elements.msg.value = '';
e.target.elements.msg.focus();
});
//Output message to DOM
function outputMessage(message) {
const div = document.createElement('div');
div.classList.add('message');
div.innerHTML = `<p class="meta">${message.username} <span>${message.time}</span></p>
<p class="text">
${message.text}
</p>`;
document.querySelector('.chat-messages').appendChild(div);
}
//Add room name to DOM
function outputRoomName(room) {
roomName.innerText = room;
}
//Add users to DOM
function outputUsers(users) {
userList.innerHTML = `${users.map(user => `<li>${user.username}</li>`).join('')}`;
}
room.model.js
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const roomSchema = new Schema({
id: mongoose.ObjectId,
messages: [
{
id: mongoose.ObjectId,
authorUsername: String,
time: Date,
content: String
}
]
});
const Room = mongoose.model("Room", roomSchema);
module.exports = Room;
users.js
const users = [];
//Join user to chat
function userJoin(id, username, room) {
const user = {id, username, room};
users.push(user);
return user;
}
//Get current user
function getCurrentUser(id) {
return users.find(user => user.id === id);
}
//User leaves chat
function userLeave(id) {
const index = users.findIndex(user => user.id === id);
if(index !== -1) {
return users.splice(index, 1)[0];
}
}
//Get room users
function getRoomUsers(room) {
return users.filter(user => user.room === room);
}
module.exports = {
userJoin,
getCurrentUser,
userLeave,
getRoomUsers
}

Answer 1

A simple approach is structuring the db with only one schema, the Room schema.
When a user sends a message in a room, push to the messages array of that same room.
Then, in socket.io (node) you emit a socket (with the room id) and send the message, and in the client side, set the user to receive all sockets of that room.
Room schema:
{
id,
messages: [
{
id,
authorUsername,
content
}
]
}