Mongodb Question posted in
The official documentation can be found here.

Mongodb – updating related relations in database

  1. i have created groups , which has members , each member has a group array displaying which they are part of . if i delete a group i want that user’s group array also updates. i am using express and mongodb for my project here is my code:

  2. group controller

    const Group = require("../models/Group");
const User = require("../models/User");

const createGroup = async (req, res) => {
  try {
    const { name, members } = req.body;
    const adminId = req.user.userId;

    // Get admin details
    const admin = await User.findById(adminId);

    // Process members array
    const groupMembers = await Promise.all(
      members.map(async (member) => {
        if (member.email) {
          const user = await User.findOne({ email: member.email });
          if (user) {
            return { user: user._id, name: user.name, email: user.email };
          }
        }
        return { name: member.name, email: member.email };
      })
    );

    // Add admin as the first member
    groupMembers.unshift({
      user: admin._id,
      name: admin.name,
      email: admin.email,
    });

    const group = new Group({
      name,
      admin: adminId,
      members: groupMembers,
    });

    await group.save();


    // **Update each member's groups array**
    for (const member of groupMembers) {
      if (member.user) {
        const user = await User.findById(member.user);
        user.groups.push(group._id);
        await user.save();
      }
    }
    res.status(201).json({ message: "Group created successfully", group });
  } catch (error) {
    console.error("Error creating group:", error);
    res.status(500).json({ error: "Failed to create group" });
  }
};

const addMember = async (req, res) => {
  try {
    const { groupId, member } = req.body;
    const userId = req.user.userId;

    const group = await Group.findById(groupId);
    if (!group) {
      return res.status(404).json({ error: "Group not found" });
    }

    if (group.admin.toString() !== userId) {
      return res
        .status(403)
        .json({ error: "Only the group admin can add members" });
    }

    const newMember = member.email
      ? await User.findOne({ email: member.email })
      : null;

    group.members.push(
      newMember
        ? { user: newMember._id, name: newMember.name, email: newMember.email }
        : { name: member.name, email: member.email }
    );
    // **Update the new member's groups array**
    await group.save();
    if (newMember) {
      newMember.groups.push(group._id);
      await newMember.save();
    }

    res.status(200).json({ message: "Member added successfully", group });
  } catch (error) {
    console.error("Error adding member:", error);
    res.status(500).json({ error: "Failed to add member" });
  }
};

const removeMember = async (req, res) => {
  try {
    const { groupId, memberId } = req.body;
    const userId = req.user.userId;

    const group = await Group.findById(groupId);
    if (!group) {
      return res.status(404).json({ error: "Group not found" });
    }

    if (group.admin.toString() !== userId) {
      return res
        .status(403)
        .json({ error: "Only the group admin can remove members" });
    }

    group.members = group.members.filter(
      (member) => member._id.toString() !== memberId
    );
    await group.save();
    // **Update the member's groups array**
    const member = await User.findById(memberId);
    if (member) {
      member.groups = member.groups.filter(
        (group) => group.toString() !== groupId
      );
      await member.save();
    }

    res.status(200).json({ message: "Member removed successfully", group });
  } catch (error) {
    console.error("Error removing member:", error);
    res.status(500).json({ error: "Failed to remove member" });
  }
};

const leaveGroup = async (req, res) => {
  try {
    const { groupId } = req.body;
    const userId = req.user.userId;

    const group = await Group.findById(groupId);
    if (!group) {
      return res.status(404).json({ error: "Group not found" });
    }

    // If the admin is leaving
    if (group.admin.toString() === userId) {
      // Transfer admin rights to the next member
      const nextAdmin = group.members.find(
        (member) => member.user && member.user.toString() !== userId
      );
      if (!nextAdmin) {
        return res
          .status(400)
          .json({
            error: "Cannot leave the group without transferring admin rights",
          });
      }
      group.admin = nextAdmin.user;
    }

    // Remove the member from the group
    group.members = group.members.filter((member) =>
      member.user ? member.user.toString() !== userId : true
    );
    await group.save();
    // **Update the user's groups array**
    const user = await User.findById(userId);
    user.groups = user.groups.filter((group) => group.toString() !== groupId);
    await user.save();

    res.status(200).json({ message: "Left group successfully", group });
  } catch (error) {
    console.error("Error leaving group:", error);
    res.status(500).json({ error: "Failed to leave group" });
  }
};

const editGroup = async (req, res) => {
  try {
    const { groupId, name } = req.body;
    const userId = req.user.userId;

    const group = await Group.findById(groupId);
    if (!group) {
      return res.status(404).json({ error: "Group not found" });
    }

    if (group.admin.toString() !== userId) {
      return res
        .status(403)
        .json({ error: "Only the group admin can edit group details" });
    }

    group.name = name;
    await group.save();

    res
      .status(200)
      .json({ message: "Group details updated successfully", group });
  } catch (error) {
    console.error("Error editing group:", error);
    res.status(500).json({ error: "Failed to edit group" });
  }
};

const addFriendstoGroup = async (req, res) => {
  try {
    const { groupId, friendId } = req.body;
    const userId = req.user.userId;

    const group = await Group.findById(groupId);
    if (!group) {
      return res.status(404).json({ error: "Group not found" });
    }

    if (group.admin.toString() !== userId) {
      return res
        .status(403)
        .json({ error: "Only the group admin can add members" });
    }
    const friend = await User.findById(friendId);
    if (!friend) {
      return res.status(404).json({ error: "Friend not found" });
    }

    const isAlreadyMember = group.members.some(
      (member) => member.user && member.user.toString() == friendId
    );
    if (isAlreadyMember) {
      res.status(404).json({ error: "Friend is already a member of group" });
    }

    group.members.push({
      user: friend._id,
      name: friend.name,
      email: friend.email,
    });
    await group.save();
    // **Update the friend's groups array**
    friend.groups.push(group._id);
    await friend.save();
    res
      .status(201)
      .json({ message: "Friend added to group successfully", group });
  } catch (error) {
    console.error("Error adding friend to group:", error);
    res.status(500).json({ error: "Failed to add friend to group" });
  }
};

module.exports = {
  createGroup,
  addMember,
  removeMember,
  leaveGroup,
  editGroup,
  addFriendstoGroup,
};

  3. my user model :

    const mongoose = require("mongoose");
const bcrypt = require("bcrypt");

const userSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true,
  },
  email: {
    type: String,
    required: true,
    unique: true,
  },
  password: {
    type: String,
    required: true,
  },
  friends: [
    {
      type: mongoose.Schema.Types.ObjectId,
      ref: "User",
    },
  ],
  groups: [
    {
      type: mongoose.Schema.Types.ObjectId,
      ref: "Group",
    },
  ],
  createdAt: {
    type: Date,
    default: Date.now,
  },
});

userSchema.pre("save", async function (next) {
  if (this.isModified("password") || this.isNew) {
    this.password = await bcrypt.hash(this.password, 10);
  }
  next();
});

module.exports = mongoose.model("User", userSchema, "User");

i deleted a record from database and i was expecting that it would update the arrays

Tags:

2

Answers


  1. 0

    If you are directly making changes in the database, such as deleting a group document from the Group collection, it won’t automatically update the groups array in each user’s document. This approach can lead to data inconsistencies because user documents will still reference the deleted groups. You need to create a delete group api for handling updates to user’s group array.

    Login or Signup to reply.
  2. 0

    You can use Group.findByIdAndDelete to delete the group. Then use User.updateMany to remove the groupId from the groups array with the $pull operator. This will be executed for each User as soon as you delete the Group document like so:

    const deleteGroup = async (req, res) => {
    try {
        const { groupId } = req.body;

        const group = await Group.findByIdAndDelete(groupId);
        if (!group) {
            return res.status(404).json({ error: "Group not found" });
        }

        const results = await User.updateMany({groups: group._id}, {$pull: {groups: group._id}});
        console.log('Deleting group from users result:', results);
        
        res.status(200).json({ message: "Group deleted and removed from users", group });
    } catch (error) {
        console.error("Error removing group:", error);
        res.status(500).json({ error: "Failed to remove group" });
    }
};
    Login or Signup to reply.
Please signup or login to give your own answer.

Back To Top
Search