How to fix ParallelSaveError: Can't save() the same doc multiple times in parallel in MongoDB

// Problematic pattern
const user = await User.findById(userId);

// Multiple async operations saving the same instance
await Promise.all([
  user.save(),  // First save
  user.save()   // Second save - will cause ParallelSaveError
]);

// Event-driven code that might trigger multiple saves
user.on('update', async () => {
  await user.save();  // Could be called multiple times
});

// Instead of modifying and saving:
user.name = 'New Name';
await user.save();  // Problematic in parallel

// Use findOneAndUpdate with atomic operators:
await User.findOneAndUpdate(
  { _id: userId },
  { $set: { name: 'New Name' } },
  { new: true }
);

// Or updateOne:
await User.updateOne(
  { _id: userId },
  { $set: { name: 'New Name' } }
);

// Using a simple in-memory lock
const locks = new Map();

async function safeSave(document) {
  const lockKey = document._id.toString();

  // Check if already locked
  if (locks.has(lockKey)) {
    throw new Error('Document is already being saved');
  }

  try {
    locks.set(lockKey, true);
    return await document.save();
  } finally {
    locks.delete(lockKey);
  }
}

// Or use a proper queuing system
const saveQueue = new PQueue({ concurrency: 1 });

async function queuedSave(document) {
  return saveQueue.add(() => document.save());
}

// Instead of sharing the same instance:
async function updateUser(userId) {
  const user = await User.findById(userId);

  // Operation A
  user.fieldA = 'valueA';
  await user.save();

  // Operation B (separate function/request)
  // DON'T use the same 'user' instance
  // Instead, fetch fresh:
  const freshUser = await User.findById(userId);
  freshUser.fieldB = 'valueB';
  await freshUser.save();
}

// Instead of multiple save() calls:
const updates = users.map(user => {
  user.status = 'active';
  return user.save();  // Problematic if same user appears multiple times
});

// Use bulkWrite:
await User.bulkWrite(
  users.map(user => ({
    updateOne: {
      filter: { _id: user._id },
      update: { $set: { status: 'active' } }
    }
  }))
);

async function saveWithRetry(document, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await document.save();
    } catch (error) {
      if (error.name === 'ParallelSaveError' && i < maxRetries - 1) {
        // Wait a bit and fetch fresh document
        await new Promise(resolve => setTimeout(resolve, 100 * (i + 1)));
        document = await document.constructor.findById(document._id);
        continue;
      }
      throw error;
    }
  }
}

// Usage
try {
  await saveWithRetry(user);
} catch (error) {
  console.error('Failed to save after retries:', error);
  // Fallback to atomic update
  await User.updateOne(
    { _id: user._id },
    { $set: user.toObject() }
  );
}