How do you implement optimistic locking in a Node.js application?

Question

Accepted Answer

**Optimistic locking** — prevents lost updates using a version column.

```javascript
// Schema with version
const userSchema = new mongoose.Schema({
    name: String,
    email: String,
    version: { type: Number, default: 0 },
});

// Update with version check
async function updateUser(id, updates, expectedVersion) {
    const result = await User.findOneAndUpdate(
        { _id: id, version: expectedVersion },
        { $set: updates, $inc: { version: 1 } },
        { new: true }
    );

if (!result) {
        throw new Error("Conflict: data was modified by another user");
    }
    return result;
}

// Usage
app.put("/users/:id", async (req, res) => {
    try {
        const user = await updateUser(
            req.params.id,
            req.body,
            req.body.version
        );
        res.json(user);
    } catch (err) {
        res.status(409).json({ error: err.message });
    }
});
```

**SQL version:**
```sql
UPDATE users SET name = $1, version = version + 1
WHERE id = $2 AND version = $3
```

**Key points:**
- Detect conflicts without locks.
- Retry on conflict.
- Good for read-heavy workloads.

Node.js: How do you implement optimistic locking in a Node.js application?