Mongoose Unique - Javascript

Mongoose is an Object Data Modeling (ODM) library for MongoDB and Node.js. It provides a straightforward, schema-based solution to model your application data and includes built-in type casting, validation, query building, and more. One of its strengths is the ability to define unique constraints on fields in your schemas, making it easy to ensure that data is stored consistently.

Defining Unique Constraints in Mongoose

To define a unique constraint on a field in a Mongoose schema, you can use the unique property. Here is an example:

const mongoose = require('mongoose');

const schema = new mongoose.Schema({
  email: {
    type: String,
    required: true,
    unique: true,
  },
  password: {
    type: String,
    required: true,
  },
});

const User = mongoose.model('User', schema);

module.exports = User;

In the above example, we define a unique constraint on the email field by setting the unique property to true. This ensures that new documents cannot be saved with the same email address as an existing document in the collection.

Handling Unique Constraint Errors

When MongoDB detects a duplicate key error, it will return an error with the code 11000. You can use this error code to handle unique constraint violations in your application. Here is an example of how to handle duplicate email errors in Node.js:

const user = new User({
  email: 'example@email.com',
  password: 'password123',
});

user.save((err, user) => {
  if (err && err.code === 11000) {
    console.log('Email address already in use');
  } else if (err) {
    console.log('An error occurred while saving the user');
  } else {
    console.log('User saved successfully');
  }
});

In the above example, we check for the code property in the error object to see if it is a duplicate key error. If it is, we handle the error appropriately. Otherwise, we assume that the error was caused by something else.

Conclusion

Defining unique constraints in Mongoose is a powerful feature that can help ensure data consistency in your MongoDB collections. By setting the unique property on a field in your schema, you can ensure that documents cannot be saved with duplicate values in that field. Handling duplicate key errors is straightforward and allows you to provide appropriate feedback to users of your application.