Merge pull request #14053 from Automattic/vkarpov15/gh-14022

fix(document): avoid unmarking modified on nested path if no initial value stored and already modified

Author: vkarpov15

lib/document.js

@@ -1204,6 +1204,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
         this.invalidate(path, new MongooseError.CastError('Object', val, path));
         return this;
       }
+      const wasModified = this.$isModified(path);
       const hasInitialVal = this.$__.savedState != null && this.$__.savedState.hasOwnProperty(path);
       if (this.$__.savedState != null && !this.$isNew && !this.$__.savedState.hasOwnProperty(path)) {
         const initialVal = this.$__getValue(path);
@@ -1226,9 +1227,11 @@ Document.prototype.$set = function $set(path, val, type, options) {
 
       this.$__setValue(path, {});
       for (const key of keys) {
-        this.$set(path + '.' + key, val[key], constructing, options);
+        this.$set(path + '.' + key, val[key], constructing, { ...options, _skipMarkModified: true });
       }
-      if (priorVal != null && utils.deepEqual(hasInitialVal ? this.$__.savedState[path] : priorVal, val)) {
+      if (priorVal != null &&
+          (!wasModified || hasInitialVal) &&
+          utils.deepEqual(hasInitialVal ? this.$__.savedState[path] : priorVal, val)) {
         this.unmarkModified(path);
       } else {
         this.markModified(path);

test/document.test.js

@@ -3731,6 +3731,11 @@ describe('document', function() {
 
       assert.deepEqual(
         kitty.modifiedPaths(),
+        ['surnames']
+      );
+
+      assert.deepEqual(
+        kitty.modifiedPaths({ includeChildren: true }),
         ['surnames', 'surnames.docarray']
       );
     });
@@ -9239,6 +9244,49 @@ describe('document', function() {
     assert.ok(foo.isModified('subdoc.bar'));
   });
 
+  it('does not unmark modified if there is no initial value (gh-9396)', async function() {
+    const IClientSchema = new Schema({
+      jwt: {
+        token_crypt: { type: String, template: false, maxSize: 8 * 1024 },
+        token_salt: { type: String, template: false }
+      }
+    });
+
+    const encrypt = function(doc, path, value) {
+      doc.set(path + '_crypt', value + '_crypt');
+      doc.set(path + '_salt', value + '_salt');
+    };
+
+    const decrypt = function(doc, path) {
+      return doc.get(path + '_crypt').replace('_crypt', '');
+    };
+
+    IClientSchema.virtual('jwt.token')
+      .get(function() {
+        return decrypt(this, 'jwt.token');
+      })
+      .set(function(value) {
+        encrypt(this, 'jwt.token', value);
+      });
+
+
+    const iclient = db.model('Test', IClientSchema);
+    const test = new iclient({
+      jwt: {
+        token: 'firstToken'
+      }
+    });
+
+    await test.save();
+    const entry = await iclient.findById(test._id).orFail();
+    entry.set('jwt.token', 'secondToken');
+    entry.set(entry.toJSON());
+    await entry.save();
+
+    const { jwt } = await iclient.findById(test._id).orFail();
+    assert.strictEqual(jwt.token, 'secondToken');
+  });
+
   it('correctly tracks saved state for deeply nested objects (gh-10773) (gh-9396)', async function() {
     const PaymentSchema = Schema({ status: String }, { _id: false });
     const OrderSchema = new Schema({
@@ -12312,6 +12360,29 @@ describe('document', function() {
     const nestedProjectionDoc = await User.findOne({}, { name: 1, 'sub.propertyA': 1, 'sub.propertyB': 1 });
     assert.strictEqual(nestedProjectionDoc.sub.propertyA, 'A');
   });
+
+  it('avoids adding nested paths to markModified() output if adding a new field (gh-14024)', async function() {
+    const eventSchema = new Schema({
+      name: { type: String },
+      __stateBeforeSuspension: {
+        field1: { type: String },
+        field2: { type: String },
+        jsonField: {
+          name: { type: String },
+          name1: { type: String }
+        }
+      }
+    });
+    const Event = db.model('Event', eventSchema);
+    const eventObj = new Event({ name: 'event object', __stateBeforeSuspension: { field1: 'test', jsonField: { name: 'test3' } } });
+    await eventObj.save();
+    const newObject = { field1: 'test', jsonField: { name: 'test3', name1: 'test4' } };
+    eventObj.set('__stateBeforeSuspension', newObject);
+    assert.deepEqual(
+      eventObj.modifiedPaths(),
+      ['__stateBeforeSuspension', '__stateBeforeSuspension.jsonField']
+    );
+  });
 });
 
 describe('Check if instance function that is supplied in schema option is availabe', function() {