FAQ

Q. Why don’t my changes to arrays get saved when I update an element directly?

  1. doc.array[3] = 'changed';
  2. doc.save();

A. Mongoose doesn’t create getters/setters for array indexes; without them mongoose never gets notified of the change and so doesn’t know to persist the new value. The work-around is to use MongooseArray#set available in Mongoose >= 3.2.0.

  1. // 3.2.0
  2. doc.array.set(3, 'changed');
  3. doc.save();
  5. // if running a version less than 3.2.0, you must mark the array modified before saving.
  6. doc.array[3] = 'changed';
  7. doc.markModified('array');
  8. doc.save();

Q. I declared a schema property as unique but I can still save duplicates. What gives?

A. Mongoose doesn’t handle unique on its own: { name: { type: String, unique: true } } is just a shorthand for creating a MongoDB unique index on name. For example, if MongoDB doesn’t already have a unique index on name, the below code will not error despite the fact that unique is true.

  1. var schema = new mongoose.Schema({
  2.   name: { type: String, unique: true }
  3. });
  4. var Model = db.model('Test', schema);
  6. Model.create([{ name: 'Val' }, { name: 'Val' }], function(err) {
  7.   console.log(err); // No error, unless index was already built
  8. });

However, if you wait for the index to build using the Model.on('index') event, attempts to save duplicates will correctly error.

  1. var schema = new mongoose.Schema({
  2.   name: { type: String, unique: true }
  3. });
  4. var Model = db.model('Test', schema);
  6. Model.on('index', function(err) { // <-- Wait for model's indexes to finish
  7.   assert.ifError(err);
  8.   Model.create([{ name: 'Val' }, { name: 'Val' }], function(err) {
  9.     console.log(err);
  10.   });
  11. });
  13. // Promise based alternative. `init()` returns a promise that resolves
  14. // when the indexes have finished building successfully. The `init()`
  15. // function is idempotent, so don't worry about triggering an index rebuild.
  16. Model.init().then(function() {
  17.   assert.ifError(err);
  18.   Model.create([{ name: 'Val' }, { name: 'Val' }], function(err) {
  19.     console.log(err);
  20.   });
  21. });

MongoDB persists indexes, so you only need to rebuild indexes if you’re starting with a fresh database or you ran db.dropDatabase(). In a production environment, you should [create your indexes using the MongoDB shell])(https://docs.mongodb.com/manual/reference/method/db.collection.createIndex/) rather than relying on mongoose to do it for you. The unique option for schemas is convenient for development and documentation, but mongoose is not an index management solution.

Q. When I have a nested property in a schema, mongoose adds empty objects by default. Why?

  1. var schema = new mongoose.Schema({
  2.   nested: {
  3.     prop: String
  4.   }
  5. });
  6. var Model = db.model('Test', schema);
  8. // The below prints `{ _id: /* ... */, nested: {} }`, mongoose assigns
  9. // `nested` to an empty object `{}` by default.
  10. console.log(new Model());

A. This is a performance optimization. These empty objects are not saved to the database, nor are they in the result toObject(), nor do they show up in JSON.stringify() output unless you turn off the minimize option.

The reason for this behavior is that Mongoose’s change detection and getters/setters are based on Object.defineProperty(). In order to support change detection on nested properties without incurring the overhead of running Object.defineProperty() every time a document is created, mongoose defines properties on the Model prototype when the model is compiled. Because mongoose needs to define getters and setters for nested.prop, nested must always be defined as an object on a mongoose document, even if nested is undefined on the underlying POJO.

Q. I’m using an arrow function for a virtual, getter/setter, or method and the value of this is wrong.

A. Arrow functions handle the this keyword much differently than conventional functions. Mongoose getters/setters depend on this to give you access to the document that you’re writing to, but this functionality does not work with arrow functions. Do not use arrow functions for mongoose getters/setters unless do not intend to access the document in the getter/setter.

  1. // Do **NOT** use arrow functions as shown below unless you're certain
  2. // that's what you want. If you're reading this FAQ, odds are you should
  3. // just be using a conventional function.
  4. var schema = new mongoose.Schema({
  5.   propWithGetter: {
  6.     type: String,
  7.     get: v => {
  8.       // Will **not** be the doc, do **not** use arrow functions for getters/setters
  9.       console.log(this);
  10.       return v;
  11.     }
  12.   }
  13. });
  15. // `this` will **not** be the doc, do **not** use arrow functions for methods
  16. schema.method.arrowMethod = () => this;
  17. schema.virtual('virtualWithArrow').get(() => {
  18.   // `this` will **not** be the doc, do **not** use arrow functions for virtuals
  19.   console.log(this);
  20. });

Q. I have an embedded property named type like this:

  1. const holdingSchema = new Schema({
  2.   // You might expect `asset` to be an object that has 2 properties,
  3.   // but unfortunately `type` is special in mongoose so mongoose
  4.   // interprets this schema to mean that `asset` is a string
  5.   asset: {
  6.     type: String,
  7.     ticker: String
  8.   }
  9. });

But mongoose gives me a CastError telling me that it can’t cast an object to a string when I try to save a Holding with an asset object. Why is this?

  1. Holding.create({ asset: { type: 'stock', ticker: 'MDB' } }).catch(error => {
  2.   // Cast to String failed for value "{ type: 'stock', ticker: 'MDB' }" at path "asset"
  3.   console.error(error);
  4. });

A. The type property is special in mongoose, so when you say type: String, mongoose interprets it as a type declaration. In the above schema, mongoose thinks asset is a string, not an object. Do this instead:

  1. const holdingSchema = new Schema({
  2.   // This is how you tell mongoose you mean `asset` is an object with
  3.   // a string property `type`, as opposed to telling mongoose that `asset`
  4.   // is a string.
  5.   asset: {
  6.     type: { type: String },
  7.     ticker: String
  8.   }
  9. });

Q. Why don’t in-place modifications to date objects (e.g. date.setMonth(1);) get saved?

  1. doc.createdAt.setDate(2011, 5, 1);
  2. doc.save(); // createdAt changes won't get saved!

A. Mongoose currently doesn’t watch for in-place updates to date objects. If you have need for this feature, feel free to discuss on this GitHub issue. There are several workarounds:

  1. doc.createdAt.setDate(2011, 5, 1);
  2. doc.markModified('createdAt');
  3. doc.save(); // Works
  1. doc.createdAt = new Date(2011, 5, 1).setHours(4);
  2. doc.save(); // Works

Q. I’m populating a nested property under an array like the below code:

new Schema({ arr: [{ child: { ref: 'OtherModel', type: Schema.Types.ObjectId } }] });

.populate({ path: 'arr.child', options: { sort: 'name' } }) won’t sort by arr.child.name?

A. See this GitHub issue. It’s a known issue but one that’s exceptionally difficult to fix.

Q. All function calls on my models hang, what am I doing wrong?

A. By default, mongoose will buffer your function calls until it can connect to MongoDB. Read the buffering section of the connection docs for more information.

Q. How can I enable debugging?

A. Set the debug option to true:

  1. mongoose.set('debug', true)

All executed collection methods will log output of their arguments to your console.

Q. My save() callback never executes. What am I doing wrong?

A. All collection actions (insert, remove, queries, etc.) are queued until the connection opens. It is likely that an error occurred while attempting to connect. Try adding an error handler to your connection.

  1. // if connecting on the default mongoose connection
  2. mongoose.connect(..);
  3. mongoose.connection.on('error', handleError);
  5. // if connecting on a separate connection
  6. var conn = mongoose.createConnection(..);
  7. conn.on('error', handleError);

Q. Should I create/destroy a new connection for each database operation?

A. No. Open your connection when your application starts up and leave it open until the application shuts down.

Q. Why do I get “OverwriteModelError: Cannot overwrite .. model once compiled” when I use nodemon / a testing framework?

A. mongoose.model('ModelName', schema) requires ‘ModelName’ to be unique, so you can access the model by using mongoose.model('ModelName'). If you put mongoose.model('ModelName', schema); in a mocha beforeEach() hook, this code will attempt to create a new model named ‘ModelName’ before every test, and so you will get an error. Make sure you only create a new model with a given name once. If you need to create multiple models with the same name, create a new connection and bind the model to the connection.

  1. var mongoose = require('mongoose');
  2. var connection = mongoose.createConnection(..);
  4. // use mongoose.Schema
  5. var kittySchema = mongoose.Schema({ name: String });
  7. // use connection.model
  8. var Kitten = connection.model('Kitten', kittySchema);

Something to add?

If you’d like to contribute to this page, please visit it on github and use the Edit button to send a pull request.