How to fix DivergentArrayError: For your own good, using document.save() to update an array which was selected using an $elemMatch projection will not work in MongoDB

// This causes DivergentArrayError
const doc = await Post.findOne(
  { _id: postId },
  { comments: { $elemMatch: { _id: commentId } } }  // Projection returns 1 comment
);

doc.comments[0].text = "Updated comment";
await doc.save();  // ERROR: Divergent array detected!

// Correct approach - update directly without save()
const result = await Post.updateOne(
  { _id: postId, "comments._id": commentId },
  { $set: { "comments.$.text": "Updated comment" } }
);

if (result.matchedCount === 0) {
  throw new Error("Post or comment not found");
}

// Mongoose updateOne with field updates
await User.updateOne(
  { _id: userId, "posts._id": postId },
  {
    $set: { "posts.$.title": "New Title", "posts.$.updatedAt": new Date() },
    $inc: { "posts.$.viewCount": 1 }
  }
);

// MongoDB native driver
const result = await collection.updateOne(
  { _id: postId, "comments._id": commentId },
  {
    $set: { "comments.$.text": "Updated comment", "comments.$.edited": true },
    $currentDate: { "comments.$.lastModified": true }
  }
);

const doc = await Post.findOne({ _id: postId }, { comments: { $elemMatch: { active: true } } });
// Now doc.comments has only active comments
doc.comments[0].text = "update";
await doc.save();  // ERROR

// Option 1: Load entire array, then save
const doc = await Post.findOne({ _id: postId });  // No projection
const comment = doc.comments.find(c => c._id.equals(commentId));
if (comment) {
  comment.text = "Updated";
  await doc.save();  // Safe - full array loaded
}

// Option 2: Use updateOne (recommended for performance)
await Post.updateOne(
  { _id: postId, "comments._id": commentId },
  { $set: { "comments.$.text": "Updated" } }
);

// Query finds the document and matches array element
// $ refers to that matched element's position
const result = await Post.updateOne(
  { _id: postId, "comments._id": commentId },  // Find doc and comment
  { $set: { "comments.$.text": "New text" } }   // Update matched comment
);

console.log(`Matched: ${result.matchedCount}, Modified: ${result.modifiedCount}`);

// Update nested fields within array element
await Post.updateOne(
  { _id: postId, "comments._id": commentId },
  {
    $set: {
      "comments.$.text": "Updated text",
      "comments.$.author.name": "New Name",
      "comments.$.editedAt": new Date(),
      "comments.$.edited": true
    },
    $inc: { "comments.$.editCount": 1 }
  }
);

// Conditional update with multiple operators
const comment = await Post.updateOne(
  { _id: postId, "comments._id": commentId, "comments.author": userId },
  {
    $set: { "comments.$.text": "Updated" },
    $push: { "comments.$.history": { text: oldText, editedAt: new Date() } }
  }
);

// This only updates the FIRST comment with status="pending"
await Post.updateOne(
  { _id: postId, "comments.status": "pending" },
  { $set: { "comments.$.status": "approved" } }
);

// To update ALL matching elements, use updateMany or $[] (MongoDB 3.6+)
await Post.updateMany(
  { _id: postId },
  { $set: { "comments.$[elem].status": "approved" } },
  { arrayFilters: [{ "elem.status": "pending" }] }
);

// Mongoose handles $[] syntax in updateOne/updateMany
await Post.updateMany(
  { _id: postId },
  { $set: { "comments.$[elem].status": "approved" } },
  { arrayFilters: [{ "elem.status": "pending" }] }
);

const post = await Post.findByIdAndUpdate(
  postId,
  { $set: { "comments.$.text": "Updated" } },
  { new: true }  // Return updated document
);

// This is equivalent to updateOne but more concise for single document updates

// If you need post-save hooks, load then save
const post = await Post.findById(postId);

// Modify the comment
const comment = post.comments.find(c => c._id.equals(commentId));
if (comment) {
  comment.text = "Updated";
  comment.editedAt = new Date();
  comment.edited = true;
}

// Save triggers any pre/post save hooks
await post.save();

// If you must use save() with arrays, load without projection
const post = await Post.findOne({ _id: postId });  // No projection!

const comment = post.comments.id(commentId);  // Mongoose convenience method
if (comment) {
  comment.text = "Updated";
  await post.save();  // Now safe - full array loaded
}

// Querying with projection just to read one comment
const post = await Post.findOne(
  { _id: postId },
  { comments: { $elemMatch: { _id: commentId } } }
);

const text = post.comments[0].text;
console.log(text);  // You only needed this, but loaded partial array

// Then later:
post.comments[0].text = "update";
await post.save();  // ERROR - divergent array

// If you only need to read one comment
const post = await Post.findOne(
  { _id: postId },
  { "comments.$": 1 }  // Positional projection
);
const text = post.comments[0].text;
console.log(text);

// Then to update (separate operation):
await Post.updateOne(
  { _id: postId, "comments._id": commentId },
  { $set: { "comments.$.text": "updated" } }
);

// If you frequently access single comments, consider storing them separately
const commentSchema = new Schema({
  _id: ObjectId,
  postId: ObjectId,
  text: String,
  author: String
});

// Query for comment directly
const comment = await Comment.findById(commentId);
comment.text = "updated";
await comment.save();  // Much simpler!

// BAD - projection + save combo
const doc = await Model.findOne(query, { array: { $elemMatch: condition } });
doc.array[0].field = value;
await doc.save();  // ERROR

// GOOD - use update operators
await Model.updateOne(query, { $set: { "array.$.field": value } });

// GOOD - load full array if needed
const doc = await Model.findOne(query);  // No projection
doc.array.find(el => condition(el)).field = value;
await doc.save();