Room participants not updating in the host secction

const Room = require("../models/room");
const  {User:Client} = require("../models/client")
const RoomParticipants = require("../models/roomParticipants");
const { v4: uuidv4 } = require("uuid");
const { isUserAllowed } = require("../utils/user");
const DirectMessage = require("../models/directMessage") 


module.exports = async function(io,rooms,connectedUsers){
  // const rooms = await Room.find({})
  // const roomUsers = await RoomParticipants.find({})

// socket.io handlers


const createNewRoomHandler = async (data, socket) => {
  console.log("host is creating new room");
const {userId,title="Nice title"} = data
 const userAllowed = await isUserAllowed(userId)
if(!userAllowed.status) socket.emit("server-message",userAllowed.message)
  // const roomId = 1234567;  
  
  const client =  await Client.findOne({user:userId})
if(!client) socket.emit("server-message",userAllowed.message)

const room = await new Room({owner:userId,title,dateCreated:Date.now()}).save()
console.log("room-->",room)

const roomParticipant = await new RoomParticipants({room:room._id,userId,
  user:userAllowed.user._id,
  isRoomHost:true,socketId:socket.id,connected:true}).save()

const roomParticipants = await RoomParticipants.find({room:room._id,connected:true})

  // join socket.io room
  socket.join(room._id);


  // emit to that client which created that room roomId
  socket.emit("room-id", { roomId:room._id });

  // emit an event to all users connected
  // to that room about new users which are right in this room
  console.log("room-->",room)
  console.log("roomParticipants-->",roomParticipants)
  console.log("roomParticipant-->",roomParticipant)

  socket.emit("room-update", { connectedUsers: roomParticipants });
};



const joinRoomHandler = async (data, socket) => {
  const { roomId,userId } = data;
  console.log(data)
const roomParticipants  = await RoomParticipants.find({room:roomId})

const roomParticipant = roomParticipants.find(user=>user.user===userId)
if(roomParticipant){
  await RoomParticipants.findOneAndUpdate({user:userId},{connected:true,socketId:socket.id},{new:true})
}else{
  await new RoomParticipants({room:roomId,user:userId,socketId:socket.id,connected:true}).save()
}


  // join socket.io room
  socket.join(roomId);


  console.log(roomParticipants)
  // emit to all users which are already in this room to prepare peer connection
  roomParticipants.map((user) => {
    if (user.socketId !== socket.id) {
      const data = {
        connUserSocketId: socket.id,
      };

      io.to(user.socketId).emit("conn-prepare", data);
    }
  });

  io.to(roomId).emit("room-update", { connectedUsers: roomParticipants });
};

const disconnectHandler = async (socket) => {
  const roomParticipants = await RoomParticipants.find({})
  // find if user has been registered - if yes remove him from room and connected users array
  //const user = connectedUsers.find((user) => user.socketId === socket.id);
  const user = roomParticipants.find(user=>user.socketId===socket.id)

  if (user) {
    // remove user from room in server
    //const room = rooms.find((room) => room.id === user.roomId);

    // room.connectedUsers = room.connectedUsers.filter(
    //   (user) => user.socketId !== socket.id
    // );

    await RoomParticipants.findOneAndUpdate(user.roomId,{connected:false},{new:true})

    // leave socket io room
    socket.leave(user.roomId);

    // close the room if amount of the users which will stay in room will be 0
    if (roomParticipants?.length > 0) {
      // emit to all users which are still in the room that user disconnected
      io.to(user.roomId).emit("user-disconnected", { socketId: socket.id });

      const roomParticipants =  await RoomParticipants.find({room:user.room,connected:true})
      // emit an event to rest of the users which left in the toom new connectedUsers in room
      io.to(user.roomId).emit("room-update", {
        connectedUsers: roomParticipants,
      });
    } else {
      const rooms = await Room.find({})
     return rooms?.filter((r) => r._id !== user.roomId);
    }
  }
};

const signalingHandler = (data, socket) => {
  const { connUserSocketId, signal } = data;

  const signalingData = { signal, connUserSocketId: socket.id };
  io.to(connUserSocketId).emit("conn-signal", signalingData);
};

// information from clients which are already in room that They have preapred for incoming connection
const initializeConnectionHandler = (data, socket) => {
  const { connUserSocketId } = data;

  const initData = { connUserSocketId: socket.id };
  io.to(connUserSocketId).emit("conn-init", initData);
};

const directMessageHandler = async (data, socket) => {

  const {receiverId,receiverSocketId,messageContent,name,roomId,senderId,senderSocketId} = data;
  const roomParticipant = await RoomParticipants.findOne({roomId,socketId:receiverSocketId})


  // const directMessage = await new DirectMessage({
  //   name,
  //   receiver:{userId:receiverId,socketId:receiverSocketId},
  //   sender:{userId:senderId, socketId:senderSocketId},
  // })

  if (roomParticipant) {

    // const receiverData = {
    //   authorSocketId: socket.id,
    //   content: data.messageContent,
    //   isAuthor: false,
    //   identity: data.identity,
    // };
    const receiverDirectMessage = await new DirectMessage({
      name,
      receiver:receiverId,
      sender:senderId,
      content:messageContent,
      isAuthor:false,
    }).save()

  
    socket.to(receiverSocketId).emit("direct-message", receiverDirectMessage);

    // const authorData = {
    //   receiverSocketId: data.receiverSocketId,
    //   messageContent: data.messageContent,
    //   isAuthor: true,
    //   identity: data.identity,
    // };
   
    const senderDirectMessage = await new DirectMessage({
      name,
      receiver:receivertId,
      sender:senderId,
      content:messageContent,
      isAuthor:true 
    }).save()

    socket.emit("direct-message", senderDirectMessage);
  }
};


    io.on("connection", (socket) => {
        console.log(`user connected ${socket.id}`);
      
        socket.on("create-new-room", async (data) => {    
        await createNewRoomHandler(data, socket);
        });
      
        socket.on("join-room", async (data) => {
        await joinRoomHandler(data, socket);
        });
      
        socket.on("disconnect", async () => {
         await disconnectHandler(socket);
        });
      
        socket.on("conn-signal", (data) => {
        signalingHandler(data, socket);
        });
      
        socket.on("conn-init", (data) => {
           initializeConnectionHandler(data, socket);
        });
      
        socket.on("direct-message", async (data) => {
         await directMessageHandler(data, socket);
        });
      });

     
}