Hey there! Let's work through your problem—first fixing that misbehaving unique: true schema setting, then making sure updateOne doesn't create duplicate signatures.

The unique: true flag in your Mongoose schema is just a declaration—it doesn't automatically create the actual unique index in MongoDB, especially if your collection existed before adding this setting. Here's what to do:

• Manually create the unique index (the most reliable fix):
  You can run this directly in your MongoDB shell:

  db.userSignatures.createIndex({ signature: 1 }, { unique: true })
  

  Or do it via Mongoose when your app starts (great for dev environments):

  const UserSignature = mongoose.model('UserSignature', yourSchema);
  await UserSignature.createIndexes(); // This ensures all schema-declared indexes exist
  

• Clean up existing duplicates first:
  If your collection already has duplicate signature values, the index creation will fail. Run this to find and remove duplicates (adjust based on your other fields, like keeping the most recent entry):

  const duplicates = await UserSignature.aggregate([
    { $group: { _id: "$signature", count: { $sum: 1 }, ids: { $push: "$_id" } } },
    { $match: { count: { $gt: 1 } } }
  ]);
  
  for (const dup of duplicates) {
    dup.ids.shift(); // Keep the first entry, delete the rest
    await UserSignature.deleteMany({ _id: { $in: dup.ids } });
  }
  

• Check your autoIndex setting:
  Mongoose disables autoIndex by default in production (for performance). If you want indexes to auto-create in dev, add this to your schema options:

  const userSignatureSchema = new mongoose.Schema({
    signature: { type: String, unique: true, required: true },
    // Other fields (e.g., userId, createdAt)
  }, { autoIndex: process.env.NODE_ENV !== 'production' });
  

Once your unique index is working, updateOne will respect the constraint—but you need to structure your call correctly, depending on your use case:

Case 1: Update/insert based on the signature itself #

If you want to update an existing entry matching the signature, or insert it if it doesn't exist, use upsert: true with the signature as your query condition. MongoDB will throw a duplicate key error if the signature already exists, which you can catch and handle:

try {
  const updateResult = await UserSignature.updateOne(
    { signature: "My unique signature" }, // Match by signature
    { $set: { userId: "123", updatedAt: new Date() } }, // Fields to update/set
    { upsert: true, new: true } // Upsert = insert if no match exists
  );
  console.log(updateResult);
} catch (err) {
  if (err.code === 11000) {
    // Handle duplicate signature error
    console.error("This signature is already in use—please choose another!");
  } else {
    // Re-throw other errors
    throw err;
  }
}

Case 2: Update based on another field (e.g., userId) but enforce unique signature #

If you're updating a user's signature (matching by userId), you need to first check if the new signature is already taken and not owned by the same user. For atomicity (to avoid race conditions in high traffic), combine a query that checks both userId and the absence of the new signature:

try {
  const newSignature = "My new signature";
  const userId = "123";

  const updateResult = await UserSignature.updateOne(
    { 
      userId: userId,
      // Ensure no other user has this signature
      signature: { $ne: newSignature }
    },
    { $set: { signature: newSignature, updatedAt: new Date() } },
    { runValidators: true } // Ensure Mongoose validations run
  );

  if (updateResult.matchedCount === 0) {
    // Either the user doesn't exist, or the signature is taken by someone else
    console.error("Either this user doesn't exist, or the signature is already in use.");
  }
} catch (err) {
  if (err.code === 11000) {
    console.error("This signature is already in use!");
  } else {
    throw err;
  }
}

Key Note: #

Never rely solely on Mongoose schema validations to block duplicates—they run in your app layer, so high concurrency can lead to race conditions. The database-level unique index is the only reliable way to enforce uniqueness.

内容的提问来源于stack exchange，提问作者user9591909