Mongoose: Not able to add/push a new object to an array with $addToSet or $push

Question

I use Nodejs, Hapijs and Mongoose.

I 've a schema and model as follows.

var schema = {
    name: {
        type: String,
        required: true
    },
    lectures: {}
};

var mongooseSchema = new mongoose.Schema(schema, {
    collection: "Users"
});
mongoose.model("Users", mongooseSchema);

For some reason, I need to keep "lectures" as mixed type.

While saving/creating a document I create a nested property lectures.physics.topic[] where topic is an array.

Now, I'm trying to add/push a new object to "lectures.physics.topic" using $addToSet or $push.

userModel.findByIdAndUpdateAsync(user._id, {
    $addToSet: {
        "lectures.physics.topic": {
            "name": "Fluid Mechanics",
            "day": "Monday",
            "faculty": "Nancy Wagner"
        }
    }
});

But the document is simply not getting updated. I tried using $push too. Nothing worked. What could be the problem?

I tried to another approach using mongoclient , to update the db directly .It works please find the below code which works

db.collection("Users").update({
   "_id": user._id
 }, {
 $addToSet: {
        "lectures.physics.topic": {
            "name": "Fluid Mechanics",
            "day": "Monday",
            "faculty": "Nancy Wagner"
        }
    }
 }, function(err, result) {
   if (err) {
       console.log("Superman!");
       console.log(err);
       return;
   }
 console.log(result);     
 });

I have to start the mongo client every time a request is hit.This is not a feasible solution.

Answer 1

Mongoose loses the ability to auto detect and save changes made on Mixed types so you need to "tell" it that the value of a Mixed type has changed by calling the .markModified(path) method of the document passing the path to the Mixed type you just changed:

doc.mixed.type = 'changed';
doc.markModified('mixed.type');
doc.save() // changes to mixed.type are now persisted 

In your case, you could use findById() method to make your changes by calling the addToSet() method on the topic array and then triggering the save() method to persist the changes:

userModel.findById(user._id, function (err, doc){
    var item = {
        "name": "Fluid Mechanics",
        "day": "Monday",
        "faculty": "Nancy Wagner"
    };
    doc.lectures.physics.topic.addToSet(item);
    doc.markModified('lectures');
    doc.save() // changes to lectures are now persisted 
});

Answer 2

I'd be calling "bug" on this. Mongoose is clearly doing the wrong thing as can be evidenced in the logging as shown later. But here is a listing that calls .findOneAndUpdate() from the native driver with the same update you are trying to do:

var async = require('async'),
    mongoose = require('mongoose'),
    Schema = mongoose.Schema;

mongoose.connect('mongodb://localhost/school');
mongoose.set('debug',true);

var userSchema = new Schema({
  name: {
    type: String,
    required: true
  },
  lectures: { type: Schema.Types.Mixed }
});

var User = mongoose.model( "User", userSchema );

function logger(data) {
  return JSON.stringify(data, undefined, 2);
}

async.waterfall(
  [
    function(callback) {
      User.remove({},function(err) {
        callback(err);
      });
    },
    function(callback) {
      console.log("here");
      var user = new User({ "name": "bob" });
      user.save(function(err,user) {
        callback(err,user);
      });
    },
    function(user,callback) {
      console.log("Saved: %s", logger(user));
      User.collection.findOneAndUpdate(
        { "_id": user._id },
        {
          "$addToSet": {
            "lectures.physics.topic": {
              "name": "Fluid Mechanics",
              "day": "Monday",
              "faculty": "Nancy Wagner"
            }
          }
        },
        { "returnOriginal": false },
        function(err,user) {
          callback(err,user);
        }
      );
    }
  ],
  function(err,user) {
    if (err) throw err;
    console.log("Modified: %s", logger(user));
    mongoose.disconnect();
  }
);

This works perfectly with the result:

Saved: {
  "__v": 0,
  "name": "bob",
  "_id": "55cda1f5b5ee8b870e2f53bd"
}
Modified: {
  "lastErrorObject": {
    "updatedExisting": true,
    "n": 1
  },
  "value": {
    "_id": "55cda1f5b5ee8b870e2f53bd",
    "name": "bob",
    "__v": 0,
    "lectures": {
      "physics": {
        "topic": [
          {
            "name": "Fluid Mechanics",
            "day": "Monday",
            "faculty": "Nancy Wagner"
          }
        ]
      }
    }
  },
  "ok": 1
}

You neeed to be careful here as native driver methods are not aware of the connection status like the mongoose methods are. So you need to be sure a connection has been made by a "mongoose" method firing earlier, or wrap your app in a connection event like so:

mongoose.connection.on("connect",function(err) {
   // start app in here
});

---

As for the "bug", look at the logging output from this listing:

var async = require('async'),
    mongoose = require('mongoose'),
    Schema = mongoose.Schema;

mongoose.connect('mongodb://localhost/school');
mongoose.set('debug',true);

var userSchema = new Schema({
  name: {
    type: String,
    required: true
  },
  lectures: { type: Schema.Types.Mixed }
});

var User = mongoose.model( "User", userSchema );

function logger(data) {
  return JSON.stringify(data, undefined, 2);
}

async.waterfall(
  [
    function(callback) {
      User.remove({},function(err) {
        callback(err);
      });
    },
    function(callback) {
      console.log("here");
      var user = new User({ "name": "bob" });
      user.save(function(err,user) {
        callback(err,user);
      });
    },
    function(user,callback) {
      console.log("Saved: %s", logger(user));
      User.findByIdAndUpdate(
        user._id,
        {
          "$addToSet": {
            "lectures.physics.topic": {
              "name": "Fluid Mechanics",
              "day": "Monday",
              "faculty": "Nancy Wagner"
            }
          }
        },
        { "new": true },
        function(err,user) {
          callback(err,user);
        }
      );
    }
  ],
  function(err,user) {
    if (err) throw err;
    console.log("Modified: %s", logger(user));
    mongoose.disconnect();
  }
);

And the logged output with mongoose logging:

Mongoose: users.remove({}) {}
here
Mongoose: users.insert({ name: 'bob', _id: ObjectId("55cda2d2462283c90ea3f1ad"), __v: 0 })
Saved: {
  "__v": 0,
  "name": "bob",
  "_id": "55cda2d2462283c90ea3f1ad"
}
Mongoose: users.findOne({ _id: ObjectId("55cda2d2462283c90ea3f1ad") }) { new: true, fields: undefined }
Modified: {
  "_id": "55cda2d2462283c90ea3f1ad",
  "name": "bob",
  "__v": 0
}

So in true "What the Fudge?" style, there is a call there to .findOne()? Which is not what was asked. Moreover, nothing is altered in the database of course because the wrong call is made. So even the { "new": true } here is redundant.

This happens at all levels with "Mixed" schema types.

Personally I would not nest within "Objects" like this, and just make your "Object keys" part of the standard array as additional properties. Both MongoDB and mongoose are much happier with this, and it is much easier to query for information with such a structure.

var async = require('async'),
    mongoose = require('mongoose'),
    Schema = mongoose.Schema;

mongoose.connect('mongodb://localhost/school');
mongoose.set('debug',true);

var lectureSchema = new Schema({
  "subject": String,
  "topic": String,
  "day": String,
  "faculty": String
});

var userSchema = new Schema({
  name: {
    type: String,
    required: true
  },
  lectures: [lectureSchema]
});

var User = mongoose.model( "User", userSchema );

function logger(data) {
  return JSON.stringify(data, undefined, 2);
}

async.waterfall(
  [
    function(callback) {
      User.remove({},function(err) {
        callback(err);
      });
    },
    function(callback) {
      console.log("here");
      var user = new User({ "name": "bob" });
      user.save(function(err,user) {
        callback(err,user);
      });
    },
    function(user,callback) {
      console.log("Saved: %s", logger(user));
      User.findByIdAndUpdate(
        user._id,
        {
          "$addToSet": {
            "lectures": {
              "subject": "physics",
              "topic": "Fluid Mechanics",
              "day": "Monday",
              "faculty": "Nancy Wagner"
            }
          }
        },
        { "new": true },
        function(err,user) {
          callback(err,user);
        }
      );
    }
  ],
  function(err,user) {
    if (err) throw err;
    console.log("Modified: %s", logger(user));
    mongoose.disconnect();
  }
);

Output:

Mongoose: users.remove({}) {}
here
Mongoose: users.insert({ name: 'bob', _id: ObjectId("55cda4dc40f2a8fb0e5cdf8b"), lectures: [], __v: 0 })
Saved: {
  "__v": 0,
  "name": "bob",
  "_id": "55cda4dc40f2a8fb0e5cdf8b",
  "lectures": []
}
Mongoose: users.findAndModify({ _id: ObjectId("55cda4dc40f2a8fb0e5cdf8b") }) [] { '$addToSet': { lectures: { faculty: 'Nancy Wagner', day: 'Monday', topic: 'Fluid Mechanics', subject: 'physics', _id: ObjectId("55cda4dc40f2a8fb0e5cdf8c") } } } { new: true, upsert: false, remove: false }
Modified: {
  "_id": "55cda4dc40f2a8fb0e5cdf8b",
  "name": "bob",
  "__v": 0,
  "lectures": [
    {
      "faculty": "Nancy Wagner",
      "day": "Monday",
      "topic": "Fluid Mechanics",
      "subject": "physics",
      "_id": "55cda4dc40f2a8fb0e5cdf8c"
    }
  ]
}

So that works fine, and you don't need to dig to the native methods just to make it work.

Properties of an array make this much easy to query and filter, as well as "aggregate" information across the data, which for all of those MongoDB likes a "strict path" to reference all information. Otherwise you are diffing to only "specific keys", and those cannot be indexed or really searched without mentioning every possible "key combination".

Properties like this are a better way to go. And no bugs here.