NodeJS async API Error, when querying embedded array of models - node.js

Question

Thanks for taking the time to read this.
I am currently getting this error in my API endpoint for node express when calling this async endpoint.
(node:32308) UnhandledPromiseRejectionWarning: ValidationError: Conversation validation failed: participants.0: Path `participants.0` is required., participants.1: Path `participants.1` is required.
at model.Document.invalidate (D:\cliquenext\flutter\stashify\backend\node_modules\mongoose\lib\document.js:2976:32)
at D:\cliquenext\flutter\stashify\backend\node_modules\mongoose\lib\document.js:2765:17
at D:\cliquenext\flutter\stashify\backend\node_modules\mongoose\lib\schematype.js:1334:9
at processTicksAndRejections (internal/process/task_queues.js:79:11)
(Use `node --trace-warnings ...` to show where the warning was created)
(node:32308) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). To terminate the node process on unhandled promise rejection, use the CLI flag `--unhandled-rejections=strict` (see https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode). (rejection id: 1)
(node:32308) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.
Basically I am trying to get a conversation, with its messages and its participants and return it.
The conversation object model is like so:
const conversationSchema = new Schema(
{
isGroup: {
type: Boolean,
required: true,
},
creator: {
type: Schema.Types.ObjectId,
ref: 'User',
},
passwordProtected: {
type: Boolean,
default: false,
},
password: {
type: String,
},
participants: [
{
type: Schema.Types.ObjectId,
ref: 'User',
required: true,
},
],
deleted: [
{
type: Schema.Types.ObjectId,
ref: 'User',
},
],
seen: [
{
type: Schema.Types.ObjectId,
ref: 'User',
},
],
messages: [
{
type: Schema.Types.ObjectId,
ref: 'Message',
},
],
},
{ timestamps: true },
);
and this is my endpoint:
exports.getMessagesFromUser = async (req, res, next) => {
try {
// variables
const senderId = req.userId;
const receiverId = req.body.receiverId;
// get users
const sender = await User.findOne({ _id: senderId });
const receiver = await User.findOne({ _id: receiverId });
const ids = [senderId, receiverId];
// look for an existing conversation between two users
// where the participants include both users
// where the conversation is a single conversation
// that the sender hasn't deleted
// if sender chooses to send a message, any undeleted conversations will be resurrected
let conversation = await Conversation.findOne({
isGroup: false,
participants: {
$all: ids,
},
})
.select('participants deleted seen messages')
.populate({ path: 'messages', select: 'sender message deleted seen createdAt' })
.populate({ path: 'participants', select: '_id' })
.populate({ path: 'participants', select: 'nickname' });
if (conversation) {
// conversation exists
let senderBlocked = false;
let receiverBlocked = false;
let conversationDeleted = false;
let filter;
// check if sender has blocked the receiver
filter = sender.blocked.filter((u) => u._id == receiverId);
if (filter.length > 0) {
senderBlocked = true;
}
filter = null;
// check if receiver has blocked the sender
filter = receiver.blocked.filter((u) => u._id == senderId);
if (filter.length > 0) {
receiverBlocked = true;
}
filter = null;
// check if sender has deleted the conversation
filter = conversation.deleted.filter((u) => u._id == senderId);
if (filter.length > 0) {
conversationDeleted = true;
}
// get, map and return the messageSchema
res.status(200).json({
message: 'Conversations fetched successfully!',
conversation: conversation,
senderBlocked: senderBlocked,
receiverBlocked: receiverBlocked,
conversationDeleted: conversationDeleted,
});
} else {
// if conversation does not exist, return empty array
// conversations will be created upon initial message between users
res.status(200).json({
message: 'No Conversations Yet.',
conversation: [],
senderBlocked: false,
receiverBlocked: false,
conversationDeleted: false,
});
}
} catch (e) {
e.statusCode = 500;
next(e);
}
};
I was able to determine the error was throwing inside this endpoint but couldn't for the life of me figure out why. I have added a try, catch and next block. Made sure I had the appropriate awaits in order, etc. My only guess here is the mongoose query of populate and select is wrong somehow? What do you think I am doing wrong here? Please and thank you.

Answer 1

As jimmy pointed out, the problem wasn't there. it was in another socket route where I was trying to save new conversations if they didnt exist.
So I had something like:
socket.on('join-inbox-rooms', async (data) => {
// decode json string
const decodedData = await JSON.parse(data);
// get conversation
let conversation = await Conversation.findOne({
isGroup: false,
participants: {
$all: [decodedData.senderId, decodedData.receiverId],
},
});
if (!conversation) {
conversation = new Conversation({
isGroup: false,
creator: decodedData.senderId,
passwordProtected: false,
paassword: null,
participants: [
decodedData.senderId,
decodedData.receiverId,
],
deleted: [],
seen: [],
messages: [],
});
await conversation.save();
}
Now I was getting the ids from the front end as strings. They should be mongo objects.
I ended up fixing it like so:
const { ObjectId } = require('mongodb');
if (!conversation) {
conversation = new Conversation({
isGroup: false,
creator: decodedData.senderId,
passwordProtected: false,
paassword: null,
participants: [
ObjectId(decodedData.senderId),
ObjectId(decodedData.receiverId),
],
deleted: [],
seen: [],
messages: [],
});
await conversation.save();
}