fix(model): make overwriteImmutable work on createdAt regardless of timestamps value

Author: AbdelrahmanHafez

lib/helpers/model/castBulkWrite.js

@@ -119,7 +119,8 @@ module.exports.castUpdateOne = function castUpdateOne(originalModel, updateOne,
     const createdAt = model.schema.$timestamps.createdAt;
     const updatedAt = model.schema.$timestamps.updatedAt;
     applyTimestampsToUpdate(now, createdAt, updatedAt, update, {
-      timestamps: updateOne.timestamps
+      timestamps: updateOne.timestamps,
+      overwriteImmutable: updateOne.overwriteImmutable
     });
   }
 
@@ -189,7 +190,8 @@ module.exports.castUpdateMany = function castUpdateMany(originalModel, updateMan
     const createdAt = model.schema.$timestamps.createdAt;
     const updatedAt = model.schema.$timestamps.updatedAt;
     applyTimestampsToUpdate(now, createdAt, updatedAt, updateMany['update'], {
-      timestamps: updateMany.timestamps
+      timestamps: updateMany.timestamps,
+      overwriteImmutable: updateMany.overwriteImmutable
     });
   }
   if (doInitTimestamps) {

lib/helpers/update/applyTimestampsToUpdate.js

@@ -80,33 +80,46 @@ function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, optio
   }
 
   if (!skipCreatedAt && createdAt) {
-    if (currentUpdate[createdAt]) {
-      delete currentUpdate[createdAt];
-    }
-    if (currentUpdate.$set && currentUpdate.$set[createdAt]) {
-      delete currentUpdate.$set[createdAt];
-    }
-    let timestampSet = false;
-    if (createdAt.indexOf('.') !== -1) {
-      const pieces = createdAt.split('.');
-      for (let i = 1; i < pieces.length; ++i) {
-        const remnant = pieces.slice(-i).join('.');
-        const start = pieces.slice(0, -i).join('.');
-        if (currentUpdate[start] != null) {
-          currentUpdate[start][remnant] = now;
-          timestampSet = true;
-          break;
-        } else if (currentUpdate.$set && currentUpdate.$set[start]) {
-          currentUpdate.$set[start][remnant] = now;
-          timestampSet = true;
-          break;
+    const overwriteImmutable = get(options, 'overwriteImmutable', false);
+    const hasUserCreatedAt = currentUpdate[createdAt] != null || currentUpdate?.$set[createdAt] != null;
+
+    // If overwriteImmutable is true and user provided createdAt, keep their value
+    if (overwriteImmutable && hasUserCreatedAt) {
+      // Move createdAt from top-level to $set if needed
+      if (currentUpdate[createdAt] != null) {
+        updates.$set[createdAt] = currentUpdate[createdAt];
+        delete currentUpdate[createdAt];
+      }
+      // User's value is already in $set, nothing more to do
+    } else {
+      if (currentUpdate[createdAt]) {
+        delete currentUpdate[createdAt];
+      }
+      if (currentUpdate.$set && currentUpdate.$set[createdAt]) {
+        delete currentUpdate.$set[createdAt];
+      }
+      let timestampSet = false;
+      if (createdAt.indexOf('.') !== -1) {
+        const pieces = createdAt.split('.');
+        for (let i = 1; i < pieces.length; ++i) {
+          const remnant = pieces.slice(-i).join('.');
+          const start = pieces.slice(0, -i).join('.');
+          if (currentUpdate[start] != null) {
+            currentUpdate[start][remnant] = now;
+            timestampSet = true;
+            break;
+          } else if (currentUpdate.$set && currentUpdate.$set[start]) {
+            currentUpdate.$set[start][remnant] = now;
+            timestampSet = true;
+            break;
+          }
         }
       }
-    }
 
-    if (!timestampSet) {
-      updates.$setOnInsert = updates.$setOnInsert || {};
-      updates.$setOnInsert[createdAt] = now;
+      if (!timestampSet) {
+        updates.$setOnInsert = updates.$setOnInsert || {};
+        updates.$setOnInsert[createdAt] = now;
+      }
     }
   }
 

test/model.updateOne.test.js

@@ -2685,45 +2685,88 @@ describe('model: updateOne: ', function() {
       // Arrange
       const { User } = createTestContext();
       const user = await User.create({ name: 'John', ssn: '123-45-6789' });
+      const customCreatedAt = new Date('2020-01-01');
 
       // Act
       await User.bulkWrite([{
         updateOne: {
           filter: { _id: user._id },
-          update: { ssn: '999-99-9999' },
+          update: { createdAt: customCreatedAt, ssn: '999-99-9999' },
           overwriteImmutable: true
         }
       }]);
 
       // Assert
       const updatedUser = await User.findById(user._id);
       assert.strictEqual(updatedUser.ssn, '999-99-9999');
+      assert.strictEqual(updatedUser.createdAt.valueOf(), customCreatedAt.valueOf());
     });
 
     it('updateMany can update immutable field with overwriteImmutable: true', async function() {
       // Arrange
       const { User } = createTestContext();
       const user = await User.create({ name: 'Alice', ssn: '111-11-1111' });
+      const customCreatedAt = new Date('2020-01-01');
 
       // Act
       await User.bulkWrite([{
         updateMany: {
           filter: { _id: user._id },
-          update: { ssn: '000-00-0000' },
+          update: { createdAt: customCreatedAt, ssn: '000-00-0000' },
           overwriteImmutable: true
         }
       }]);
 
       // Assert
       const updatedUser = await User.findById(user._id);
       assert.strictEqual(updatedUser.ssn, '000-00-0000');
+      assert.strictEqual(updatedUser.createdAt.valueOf(), customCreatedAt.valueOf());
     });
 
+    for (const timestamps of [true, false, null, undefined])
+      it(`overwriting immutable createdAt with bulkWrite (gh-15781) when \`timestamps\` is \`${timestamps}\``, async function() {
+        // Arrange
+        const schema = Schema({ name: String }, { timestamps: true });
+
+        const Model = db.model('Test', schema);
+
+        const doc1 = await Model.create({ name: 'gh-15781-1' });
+        const doc2 = await Model.create({ name: 'gh-15781-2' });
+
+        // Act
+        const createdAt = new Date('2011-06-01');
+
+        await Model.bulkWrite([
+          {
+            updateOne: {
+              filter: { _id: doc1._id },
+              update: { createdAt },
+              overwriteImmutable: true,
+              timestamps
+            }
+          },
+          {
+            updateMany: {
+              filter: { _id: doc2._id },
+              update: { createdAt },
+              overwriteImmutable: true,
+              timestamps
+            }
+          }
+        ]);
+
+        // Assert
+        const updatesDocs = await Model.find({ _id: { $in: [doc1._id, doc2._id] } });
+
+        assert.equal(updatesDocs[0].createdAt.valueOf(), createdAt.valueOf());
+        assert.equal(updatesDocs[1].createdAt.valueOf(), createdAt.valueOf());
+      });
+
     function createTestContext() {
       const userSchema = new Schema({
         name: String,
         ssn: { type: String, immutable: true }
-      });
+      }, { timestamps: true });
       const User = db.model('User', userSchema);
       return { User };
     }