Realtime chat app backend

How Socket.io Works in the WisdomWalk Backend

I'll explain how Socket.io works in the implementation and how it integrates with the ChatController and other parts of your application.

Socket.io Architecture Overview

Socket.io is a library that enables real-time, bidirectional communication between web clients and servers. Here's how it's structured in your application:

Server (Express)
    │
    ├── HTTP Routes (REST API)
    │   └── Controllers (e.g., ChatController)
    │
    └── Socket.io Server
        ├── Connection Management
        ├── Authentication
        ├── Room Management
        └── Event Handlers
            ├── Chat Events
            ├── Notification Events
            ├── Group Events
            └── Presence Events

How Socket.io and ChatController Work Together

1. Dual Communication Channels

Your application now has two communication channels:

REST API (HTTP requests) - For traditional request/response operations
Socket.io (WebSocket) - For real-time, bidirectional communication

2. Integration Points

The key integration happens in these places:

// In server.js
const io = initializeSocket(server);
app.set("io", io);  // Make io available to routes

This makes the Socket.io instance available to your Express routes and controllers.

3. ChatController + Socket.io Flow

Let's look at how sending a message works with both systems:

// In chatController.js - sendMessage function
const sendMessage = async (req, res) => {
  try {
    // ... validate request and create message ...
    
    const message = new Message(messageData);
    await message.save();
    
    // Update chat's last message and activity
    chat.lastMessage = message._id;
    chat.lastActivity = new Date();
    await chat.save();
    
    // REST API response
    res.status(201).json({
      success: true,
      message: "Message sent successfully",
      data: message,
    });
    
    // Socket.io real-time broadcast
    const io = req.app.get("io");
    if (io) {
      broadcastMessageToChat(io, chatId, message, userId);
    }
  } catch (error) {
    // ... error handling ...
  }
}

When a user sends a message through the REST API:

The message is saved to the database
A success response is sent back to the sender
The message is broadcast via Socket.io to all connected clients in that chat room

How Socket.io Really Works

1. Connection Establishment

// In socket/index.js
io.on("connection", (socket) => {
  console.log(`User ${socket.user.firstName} connected: ${socket.id}`);
  
  // Store user connection
  activeUsers.set(socket.userId, {
    socketId: socket.id,
    user: socket.user,
    lastSeen: new Date(),
    status: "online",
  });
  
  // Join user to their personal room
  socket.join(`user:${socket.userId}`);
  
  // Join user to their group rooms
  socket.user.joinedGroups.forEach((group) => {
    socket.join(`group:${group.groupType}`);
  });
  
  // Initialize handlers
  chatHandler(io, socket, activeUsers, userSockets);
  notificationHandler(io, socket, activeUsers, userSockets);
  groupHandler(io, socket, activeUsers, userSockets);
  presenceHandler(io, socket, activeUsers, userSockets);
  
  // ... handle disconnection and errors ...
});

When a user connects:

Socket.io authenticates them using JWT (same as your REST API)
The user is added to the active users map
The user joins their personal room and group rooms
Event handlers are initialized for this socket

2. Room-Based Communication

Socket.io uses "rooms" to organize connections:

user:${userId} - Personal room for direct messages to a specific user
chat:${chatId} - Room for a specific chat conversation
group:${groupType} - Room for a specific group type

// Join a chat room
socket.on("chat:join", async (data) => {
  try {
    const { chatId } = data;
    
    // Verify user has access to this chat
    const chat = await Chat.findOne({
      _id: chatId,
      participants: socket.userId,
    });
    
    if (!chat) {
      socket.emit("error", { message: "Chat not found or access denied" });
      return;
    }
    
    // Join the chat room
    socket.join(`chat:${chatId}`);
    
    // Notify others in the chat that user joined
    socket.to(`chat:${chatId}`).emit("chat:user_joined", {
      userId: socket.userId,
      userName: `${socket.user.firstName} ${socket.user.lastName}`,
      timestamp: new Date(),
    });
  } catch (error) {
    // ... error handling ...
  }
});

3. Event-Based Communication

Socket.io uses events for communication:

// Client emits an event to the server
socket.on("chat:send_message", async (data) => {
  try {
    // ... process message ...
    
    // Emit to all participants in the chat
    io.to(`chat:${chatId}`).emit("chat:new_message", {
      message,
      chatId,
      timestamp: new Date(),
    });
  } catch (error) {
    // ... error handling ...
  }
});

// Server emits events to clients
io.to(`chat:${chatId}`).emit("chat:new_message", {
  message,
  chatId,
  timestamp: new Date(),
});

Real-Time Flow Example: Sending a Message

Let's trace the complete flow of sending a message:

Via REST API:

Client sends HTTP POST to /api/chats/:chatId/messages
chatController.sendMessage processes the request
Message is saved to database
Controller emits Socket.io event to all chat participants
HTTP response is sent back to the original sender

Via Socket.io:

Client emits chat:send_message event with message data
Server's chatHandler.js processes the event
Message is saved to database
Handler emits chat:new_message event to all chat participants
All connected clients (including sender) receive the event and update their UI

Key Socket.io Concepts in Your Implementation

1. Authentication Middleware

const authenticateSocket = async (socket, next) => {
  try {
    const token = socket.handshake.auth.token || socket.handshake.headers.authorization?.split(" ")[1];
    
    if (!token) {
      return next(new Error("Authentication token required"));
    }
    
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    const user = await User.findById(decoded.userId).select("-password");
    
    if (!user || !user.canAccess()) {
      return next(new Error("Invalid token or user access denied"));
    }
    
    socket.userId = user._id.toString();
    socket.user = user;
    next();
  } catch (error) {
    next(new Error("Authentication failed"));
  }
};

// Apply authentication middleware
io.use(authenticateSocket);

This ensures only authenticated users can connect to Socket.io.

2. Room Management

// Join user to their personal room
socket.join(`user:${socket.userId}`);

// Join user to their group rooms
socket.user.joinedGroups.forEach((group) => {
  socket.join(`group:${group.groupType}`);
});

// Join a specific chat room
socket.join(`chat:${chatId}`);

Rooms allow targeted broadcasting of events.

3. Presence Management

// Store user connection
activeUsers.set(socket.userId, {
  socketId: socket.id,
  user: socket.user,
  lastSeen: new Date(),
  status: "online",
});

// Handle disconnection
socket.on("disconnect", (reason) => {
  // Remove socket from user's socket list
  const userSocketList = userSockets.get(socket.userId);
  if (userSocketList) {
    const updatedSockets = userSocketList.filter((id) => id !== socket.id);
    if (updatedSockets.length === 0) {
      // User has no more active connections
      userSockets.delete(socket.userId);
      activeUsers.delete(socket.userId);
      
      // Broadcast user offline status
      broadcastUserStatus(io, socket.userId, "offline");
    } else {
      userSockets.set(socket.userId, updatedSockets);
    }
  }
});

This tracks which users are online and their status.

Practical Example: Real-Time Chat Flow

User A and User B both connect to Socket.io and join chat:123
User A sends a message via REST API or Socket.io
The message is saved to the database
The server emits chat:new_message to chat:123
Both User A and User B receive the event and update their UI
User B's client emits chat:mark_read when they view the message
The server updates the database and emits chat:message_read to chat:123
User A receives the event and updates the read receipt UI

This entire flow happens in real-time without page refreshes, creating a seamless chat experience.

Benefits of This Dual Approach

Backward Compatibility: REST API still works for clients that don't support WebSockets
Reliability: If WebSocket connection fails, the app can fall back to REST API
Flexibility: Use the appropriate channel for each type of communication
Scalability: Socket.io can be scaled horizontally with Redis adapter (not implemented yet)

This implementation gives you the best of both worlds: the reliability of REST APIs and the real-time capabilities of WebSockets through Socket.io.

To configure the generation, complete these steps:

Setup Integrations