Updates to documents that have subdocuments with timestamps enabled will get a property named "null" with a timestamp added at the root of the document

[NanoDylan]

Prerequisites

• I have written a descriptive issue title
• I have searched existing issues to ensure the bug has not already been reported

Mongoose version

6.11.0

Node.js version

18.14.2

MongoDB server version

5.0.6

Description

Updates to documents that have subdocuments with timestamps enabled will get a property named "null" with a timestamp added at the root of the document in the MongoDB database. However, you will only see this "null" property if you look at the raw document in MongoDB. If you are only interfacing with MongoDB via the mongoose model interface, the "null" property will be obscured.
As a workaround, it is possible to disable automatic timestamp updating for the query, and still update the updatedAt property as part of the $set in the update query.

Steps to Reproduce

const mongoose = require('mongoose');
const assert = require('assert');
mongoose.set('strictQuery', false);

/**
 * Schema for a subdocument with no timestamp option
 */
const subNoTimestampSchema = new mongoose.Schema ({
  subName: {
    type: String,
    default: 'anonymous',
    required: true
  }
});

/**
 * Schema for a subdocument with its own timestamp option enabled
 */
const subWithTimestampSchema = new mongoose.Schema ({
  subName: {
    type: String,
    default: 'anonymous',
    required: true
  }
});
subWithTimestampSchema.set('timestamps', true);

/**
 * Alpha has no timestamps and no subdocuments
 */
const alphaSchema = new mongoose.Schema({
  name: String,
}, { collection: 'alphas' });

/**
 * Bravo has timestamps and no subdocuments
 */
const bravoSchema = new mongoose.Schema({
  name: String,
});
bravoSchema.set('timestamps', true);

/**
 * Charlie has timestamps and subdocument without its own timestamp
 */
const charlieSchema = new mongoose.Schema({
  name: String,
  sub: { type: subNoTimestampSchema }
});
charlieSchema.set('timestamps', true);

/**
 * Delta document has no timestamps but subdocument has its own timestamp
 */
const deltaSchema = new mongoose.Schema({
  name: String,
  sub: { type: subWithTimestampSchema }
});

/**
 * Echo document has timestamps and subdocument has its own timestamp
 */
const echoSchema = new mongoose.Schema({
  name: String,
  sub: { type: subWithTimestampSchema }
});
echoSchema.set('timestamps', true);

/**
 * Foxtrot document has no timestamps but subdocument has its own timestamp (same as Delta)
 */
const foxtrotSchema = new mongoose.Schema({
  name: String,
  sub: { type: subWithTimestampSchema }
});

/**
 * Golf document has timestamps and subdocument has its own timestamp (same as Echo)
 */
const golfSchema = new mongoose.Schema({
  name: String,
  sub: { type: subWithTimestampSchema }
});
golfSchema.set('timestamps', true);

/**
 * Hotel document has timestamps and subdocument has its own timestamp (same as Echo and Golf)
 */
const hotelSchema = new mongoose.Schema({
  name: String,
  sub: { type: subWithTimestampSchema }
});
hotelSchema.set('timestamps', true);

const Alpha = mongoose.model('Alpha', alphaSchema);
const Bravo = mongoose.model('Bravo', bravoSchema);
const Charlie = mongoose.model('Charlie', charlieSchema);
const Delta = mongoose.model('Delta', deltaSchema);
const Echo = mongoose.model('Echo', echoSchema);
const Foxtrot = mongoose.model('Foxtrot', foxtrotSchema);
const Golf = mongoose.model('Golf', golfSchema);
const Hotel = mongoose.model('Hotel', hotelSchema);

async function run() {
  await mongoose.connect('mongodb://localhost:27017');
  await mongoose.connection.dropDatabase();

  /**
   * Create 3 Alpha documents which are saved to the database. No timestamps. No subdocuments.
   * Example document:
   * {
   *     "_id" : ObjectId("645506478b6d568fe54aaabf"),
   *     "name" : "alpha-1",
   *     "__v" : NumberInt(0)
   * }
   */
  await Alpha.create([
    { name: 'alpha-1' },{ name: 'alpha-2' },{ name: 'alpha-3' }
  ]);

  //
  /**
   * Create 3 Bravo documents which are saved to the database. Timestamps. No subdocuments.
   * Example document:
   * {
   *     "_id" : ObjectId("6455070c56d0da4b5d95ac9c"),
   *     "name" : "bravo-1",
   *     "createdAt" : ISODate("2023-05-05T13:39:24.865+0000"),
   *     "updatedAt" : ISODate("2023-05-05T13:39:24.865+0000"),
   *     "__v" : NumberInt(0)
   * }
   */
  await Bravo.create([
    { name: 'bravo-1' },{ name: 'bravo-2' },{ name: 'bravo-3' }
  ]);

  /**
   * Create 3 Charlie documents which are saved to the database. Timestamps. Subdocuments without their own timestamps.
   * Example document:
   * {
   *     "_id" : ObjectId("6455070c56d0da4b5d95aca1"),
   *     "name" : "charlie-1",
   *     "sub" : {
   *         "subName" : "sub-charlie-1",
   *         "_id" : ObjectId("6455070c56d0da4b5d95aca2")
   *     },
   *     "createdAt" : ISODate("2023-05-05T13:39:24.871+0000"),
   *     "updatedAt" : ISODate("2023-05-05T13:39:24.871+0000"),
   *     "__v" : NumberInt(0)
   * }
   */
  await Charlie.create([
    { name: 'charlie-1', sub: { subName: 'sub-charlie-1'}  },{ name: 'charlie-2', sub: { subName: 'sub-charlie-2'} },{ name: 'charlie-3', sub: { subName: 'sub-charlie-3'} }
  ]);

  /**
   * Create 3 Delta documents which are saved to the database. No timestamps in root document. Subdocuments have their own timestamps.
   * Example document:
   * {
   *     "_id" : ObjectId("6455183bbcac1686cc6a293d"),
   *     "name" : "delta-1",
   *     "sub" : {
   *         "subName" : "sub-delta-1",
   *         "_id" : ObjectId("6455183bbcac1686cc6a293e"),
   *         "createdAt" : ISODate("2023-05-05T14:52:43.630+0000"),
   *         "updatedAt" : ISODate("2023-05-05T14:52:43.630+0000")
   *     },
   *     "__v" : NumberInt(0)
   * }
   */
  await Delta.create([
    { name: 'delta-1', sub: { subName: 'sub-delta-1'}  },{ name: 'delta-2', sub: { subName: 'sub-delta-2'} },{ name: 'delta-3', sub: { subName: 'sub-delta-3'} }
  ]);

  /**
   * Create 3 Echo documents have their own timestamps in the document root which are saved to the database. Subdocuments have their own timestamps.
   * Example document.
   * {
   *     "_id" : ObjectId("645522975caad579a0e2a946"),
   *     "name" : "echo-1",
   *     "sub" : {
   *         "subName" : "sub-echo-1",
   *         "_id" : ObjectId("645522975caad579a0e2a947"),
   *         "createdAt" : ISODate("2023-05-05T15:36:55.621+0000"),
   *         "updatedAt" : ISODate("2023-05-05T15:36:55.621+0000")
   *     },
   *     "createdAt" : ISODate("2023-05-05T15:36:55.621+0000"),
   *     "updatedAt" : ISODate("2023-05-05T15:36:55.621+0000"),
   *     "__v" : NumberInt(0)
   * }
   */
  await Echo.create([
    { name: 'echo-1', sub: { subName: 'sub-echo-1'}  },{ name: 'echo-2', sub: { subName: 'sub-echo-2'} },{ name: 'echo-3', sub: { subName: 'sub-echo-3'} }
  ]);

  /**
   * Create 3 Foxtrot documents which are saved to the database. No timestamps in root document. Subdocuments have their own timestamps.
   * Document will be the same as Delta
   */
  await Foxtrot.create([
    { name: 'foxtrot-1', sub: { subName: 'sub-foxtrot-1'}  },{ name: 'foxtrot-2', sub: { subName: 'sub-foxtrot-2'} },{ name: 'foxtrot-3', sub: { subName: 'sub-foxtrot-3'} }
  ]);

  /**
   * Create 3 Golf documents have their own timestamps in the document root which are saved to the database. Subdocuments have their own timestamps.
   * Document will be the same as Echo.
   */
  await Golf.create([
    { name: 'golf-1', sub: { subName: 'sub-golf-1'}  },{ name: 'golf-2', sub: { subName: 'sub-golf-2'} },{ name: 'golf-3', sub: { subName: 'sub-golf-3'} }
  ]);

  /**
   * Create 3 Hotel documents have their own timestamps in the document root which are saved to the database. Subdocuments have their own timestamps.
   * Document will be the same as Echo and Golf.
   */
  await Hotel.create([
    { name: 'hotel-1', sub: { subName: 'sub-hotel-1'}  },{ name: 'hotel-2', sub: { subName: 'sub-hotel-2'} },{ name: 'hotel-3', sub: { subName: 'sub-hotel-3'} }
  ]);

  // Circumvent Mongoose and query using the Mongo driver directly.
  const alphaDocumentCount = await Alpha.collection.countDocuments({"name": /^alpha/});
  const bravoDocumentCount = await Bravo.collection.countDocuments({"name": /^bravo/});
  const charlieDocumentCount = await Charlie.collection.countDocuments({"name": /^charlie/});
  const deltaDocumentCount = await Delta.collection.countDocuments({"name": /^delta/});
  const echoDocumentCount = await Echo.collection.countDocuments({"name": /^echo/});
  const foxtrotDocumentCount = await Foxtrot.collection.countDocuments({"name": /^foxtrot/});
  const golfDocumentCount = await Golf.collection.countDocuments({"name": /^golf/});
  const hotelDocumentCount = await Hotel.collection.countDocuments({"name": /^hotel/});

  // Circumvent Mongoose and query using the Mongo driver directly.
  const alphaDocumentNullCountBeforeUpdateMany = await Alpha.collection.countDocuments({"null": {$exists: true}});
  const bravoDocumentNullCountBeforeUpdateMany = await Bravo.collection.countDocuments({"null": {$exists:true}});
  const charlieDocumentNullCountBeforeUpdateMany = await Charlie.collection.countDocuments({"null": {$exists:true}});
  const deltaDocumentNullCountBeforeUpdateMany = await Delta.collection.countDocuments({"null": {$exists:true}});
  const echoDocumentNullCountBeforeUpdateMany = await Echo.collection.countDocuments({"null": {$exists:true}});
  const foxtrotDocumentNullCountBeforeUpdateMany = await Foxtrot.collection.countDocuments({"null": {$exists:true}});
  const golfDocumentNullCountBeforeUpdateMany = await Golf.collection.countDocuments({"null": {$exists:true}});
  const hotelDocumentNullCountBeforeUpdateMany = await Hotel.collection.countDocuments({"null": {$exists:true}});

  // Mongoose model updateMany
  await Alpha.updateMany({}, [{ $set: { "updateCounter": 1 }}]);
  await Bravo.updateMany({}, [{ $set: { "updateCounter": 1 }}]);
  await Charlie.updateMany({}, [{ $set: { "updateCounter": 1, "sub.updateCounter": 1 }}]);
  await Delta.updateMany({}, [{ $set: { "updateCounter": 1, "sub.updateCounter": 1, "sub.updatedAt": new Date() }}], {timestamps: false}); // Workaround. Disable timestamps and update updatedAt as part of the $set.
  await Echo.updateMany({}, [{ $set: { "updateCounter": 1, "updatedAt": new Date() }}], {timestamps: false}); // Workaround. Disable timestamps and update updatedAt as part of the $set.
  await Foxtrot.updateMany({}, [{ $set: { "updateCounter": 1 }}]); // Simple update of a property only in the root document. No properties being updated in the subdocument.
  await Golf.updateMany({}, [{ $set: { "updateCounter": 1 }}]); // Simple update of a property only in the root document. No properties being updated in the subdocument.
  await Hotel.updateMany({}, [{ $set: { "sub.updateCounter": 1 }}]); // No updates to properties in the root document. A property does get updated in the subdocument.

  // Circumvent Mongoose and query using the Mongo driver directly.
  // When Mongoose returns the document(s), the "null" property gets filtered out, and we would not be aware that the document data in MongoDB has an undesired "null" property.
  const alphaDocumentNullCountAfterUpdateMany = await Alpha.collection.countDocuments({"null": {$exists: true}});
  const bravoDocumentNullCountAfterUpdateMany = await Bravo.collection.countDocuments({"null": {$exists:true}});
  const charlieDocumentNullCountAfterUpdateMany = await Charlie.collection.countDocuments({"null": {$exists:true}});
  const deltaDocumentNullCountAfterUpdateMany = await Delta.collection.countDocuments({"null": {$exists:true}});
  const echoDocumentNullCountAfterUpdateMany = await Echo.collection.countDocuments({"null": {$exists:true}});
  const foxtrotDocumentNullCountAfterUpdateMany = await Foxtrot.collection.countDocuments({"null": {$exists:true}});
  const golfDocumentNullCountAfterUpdateMany = await Golf.collection.countDocuments({"null": {$exists:true}});
  const hotelDocumentNullCountAfterUpdateMany = await Hotel.collection.countDocuments({"null": {$exists:true}});

  const foxtrotExample = await Foxtrot.collection.findOne({});
  console.log('Note that the foxtrotExample document has a root level property called "null" with a date value, which is not expected. As expected, no updates to sub.updatedAt.');
  console.log(JSON.stringify(foxtrotExample, null, 2));
  const golfExample = await Golf.collection.findOne({});
  console.log('Note that the golfExample document has a root level property called "null" with a date value, which is not expected. As expected, updatedAt has a new timestamp, and sub.updatedAt has not been updated.');
  console.log(JSON.stringify(golfExample, null, 2));
  const hotelExample = await Hotel.collection.findOne({});
  console.log('Note that the hotelExample document has a root level property called "null" with a date value, which is not expected. A property of the subdocument was updated.');
  console.log('If a property of the subdocument was updated, should we see the timestamp updatedAt property of the root document and/or the subdocument get a new timestamp?');
  console.log('Currently, the document root updatedAt gets a new timestamp, even though it was a subdocument property that got updated.');
  // https://mongoosejs.com/docs/timestamps.html#timestamps-on-subdocuments
  console.log(JSON.stringify(hotelExample, null, 2));

  assert.strictEqual(alphaDocumentCount, 3);
  assert.strictEqual(bravoDocumentCount, 3);
  assert.strictEqual(charlieDocumentCount, 3);
  assert.strictEqual(deltaDocumentCount, 3);
  assert.strictEqual(echoDocumentCount, 3);
  assert.strictEqual(foxtrotDocumentCount, 3);
  assert.strictEqual(golfDocumentCount, 3);
  assert.strictEqual(hotelDocumentCount, 3);

  assert.strictEqual(alphaDocumentNullCountBeforeUpdateMany, 0);
  assert.strictEqual(bravoDocumentNullCountBeforeUpdateMany, 0);
  assert.strictEqual(charlieDocumentNullCountBeforeUpdateMany, 0);
  assert.strictEqual(deltaDocumentNullCountBeforeUpdateMany, 0);
  assert.strictEqual(echoDocumentNullCountBeforeUpdateMany, 0);
  assert.strictEqual(foxtrotDocumentNullCountBeforeUpdateMany, 0);
  assert.strictEqual(golfDocumentNullCountBeforeUpdateMany, 0);
  assert.strictEqual(hotelDocumentNullCountBeforeUpdateMany, 0);

  assert.strictEqual(alphaDocumentNullCountAfterUpdateMany, 0);
  assert.strictEqual(bravoDocumentNullCountAfterUpdateMany, 0);
  assert.strictEqual(charlieDocumentNullCountAfterUpdateMany, 0);
  assert.strictEqual(deltaDocumentNullCountAfterUpdateMany, 0);
  assert.strictEqual(echoDocumentNullCountAfterUpdateMany, 0);
  assert.strictEqual(foxtrotDocumentNullCountAfterUpdateMany, 0); // This assertion fails because there is a "null" property with a date value added to the document.
  assert.strictEqual(golfDocumentNullCountAfterUpdateMany, 0); // This assertion fails because there is a "null" property with a date value added to the document.
  assert.strictEqual(hotelDocumentNullCountAfterUpdateMany, 0); // This assertion fails because there is a "null" property with a date value added to the document.

  mongoose.connection.close();
}

run();

Expected Behavior

By default, automated timestamps are enabled. When they are enabled, an update to the related document will update the 'updatedAt' property value related to the updated document with a new timestamp. No property named "null" should get added. If a subdocument has its own timestamps, and a property of the subdocument gets updated, then only the subdocument 'updatedAt' property should get a new timestamp, not the root document's updatedAt. I can see that there might be reasons why that isn't the case. Regardless, the MongoDB document should be getting a property named "null" added to the root of the document.

[IslandRhythms]

Fails on 7.1.1 as well

[IslandRhythms]

Simplified script

const mongoose = require('mongoose');
const assert = require('assert');
mongoose.set('strictQuery', false);

/**
 * Schema for a subdocument with its own timestamp option enabled
 */
const subWithTimestampSchema = new mongoose.Schema ({
  subName: {
    type: String,
    default: 'anonymous',
    required: true
  }
});
subWithTimestampSchema.set('timestamps', true);
/**
 * Foxtrot document has no timestamps but subdocument has its own timestamp (same as Delta)
 */
const foxtrotSchema = new mongoose.Schema({
  name: String,
  sub: { type: subWithTimestampSchema }
});

/**
 * Golf document has timestamps and subdocument has its own timestamp (same as Echo)
 */
const golfSchema = new mongoose.Schema({
  name: String,
  sub: { type: subWithTimestampSchema }
});
golfSchema.set('timestamps', true);

/**
 * Hotel document has timestamps and subdocument has its own timestamp (same as Echo and Golf)
 */
const hotelSchema = new mongoose.Schema({
  name: String,
  sub: { type: subWithTimestampSchema }
});
hotelSchema.set('timestamps', true);

const Foxtrot = mongoose.model('Foxtrot', foxtrotSchema);
const Golf = mongoose.model('Golf', golfSchema);
const Hotel = mongoose.model('Hotel', hotelSchema);

async function run() {
  await mongoose.connect('mongodb://localhost:27017');
  await mongoose.connection.dropDatabase();

  /**
   * Create 3 Foxtrot documents which are saved to the database. No timestamps in root document. Subdocuments have their own timestamps.
   * Document will be the same as Delta
   */
  await Foxtrot.create([
    { name: 'foxtrot-1', sub: { subName: 'sub-foxtrot-1'}  },{ name: 'foxtrot-2', sub: { subName: 'sub-foxtrot-2'} },{ name: 'foxtrot-3', sub: { subName: 'sub-foxtrot-3'} }
  ]);

  /**
   * Create 3 Golf documents have their own timestamps in the document root which are saved to the database. Subdocuments have their own timestamps.
   * Document will be the same as Echo.
   */
  await Golf.create([
    { name: 'golf-1', sub: { subName: 'sub-golf-1'}  },{ name: 'golf-2', sub: { subName: 'sub-golf-2'} },{ name: 'golf-3', sub: { subName: 'sub-golf-3'} }
  ]);

  /**
   * Create 3 Hotel documents have their own timestamps in the document root which are saved to the database. Subdocuments have their own timestamps.
   * Document will be the same as Echo and Golf.
   */
  await Hotel.create([
    { name: 'hotel-1', sub: { subName: 'sub-hotel-1'}  },{ name: 'hotel-2', sub: { subName: 'sub-hotel-2'} },{ name: 'hotel-3', sub: { subName: 'sub-hotel-3'} }
  ]);

  // Circumvent Mongoose and query using the Mongo driver directly.
  const foxtrotDocumentCount = await Foxtrot.collection.countDocuments({"name": /^foxtrot/});
  const golfDocumentCount = await Golf.collection.countDocuments({"name": /^golf/});
  const hotelDocumentCount = await Hotel.collection.countDocuments({"name": /^hotel/});

  // Circumvent Mongoose and query using the Mongo driver directly.
  const foxtrotDocumentNullCountBeforeUpdateMany = await Foxtrot.collection.countDocuments({"null": {$exists:true}});
  const golfDocumentNullCountBeforeUpdateMany = await Golf.collection.countDocuments({"null": {$exists:true}});
  const hotelDocumentNullCountBeforeUpdateMany = await Hotel.collection.countDocuments({"null": {$exists:true}});

  // Mongoose model updateMany
  await Foxtrot.updateMany({}, [{ $set: { "updateCounter": 1 }}]); // Simple update of a property only in the root document. No properties being updated in the subdocument.
  await Golf.updateMany({}, [{ $set: { "updateCounter": 1 }}]); // Simple update of a property only in the root document. No properties being updated in the subdocument.
  await Hotel.updateMany({}, [{ $set: { "sub.updateCounter": 1 }}]); // No updates to properties in the root document. A property does get updated in the subdocument.

  // Circumvent Mongoose and query using the Mongo driver directly.
  // When Mongoose returns the document(s), the "null" property gets filtered out, and we would not be aware that the document data in MongoDB has an undesired "null" property.
  const foxtrotDocumentNullCountAfterUpdateMany = await Foxtrot.collection.countDocuments({"null": {$exists:true}});
  const golfDocumentNullCountAfterUpdateMany = await Golf.collection.countDocuments({"null": {$exists:true}});
  const hotelDocumentNullCountAfterUpdateMany = await Hotel.collection.countDocuments({"null": {$exists:true}});

  const foxtrotExample = await Foxtrot.collection.findOne({});
  console.log('Note that the foxtrotExample document has a root level property called "null" with a date value, which is not expected. As expected, no updates to sub.updatedAt.');
  console.log(JSON.stringify(foxtrotExample, null, 2));
  const golfExample = await Golf.collection.findOne({});
  console.log('Note that the golfExample document has a root level property called "null" with a date value, which is not expected. As expected, updatedAt has a new timestamp, and sub.updatedAt has not been updated.');
  console.log(JSON.stringify(golfExample, null, 2));
  const hotelExample = await Hotel.collection.findOne({});
  console.log('Note that the hotelExample document has a root level property called "null" with a date value, which is not expected. A property of the subdocument was updated.');
  console.log('If a property of the subdocument was updated, should we see the timestamp updatedAt property of the root document and/or the subdocument get a new timestamp?');
  console.log('Currently, the document root updatedAt gets a new timestamp, even though it was a subdocument property that got updated.');
  // https://mongoosejs.com/docs/timestamps.html#timestamps-on-subdocuments
  console.log(JSON.stringify(hotelExample, null, 2));

  assert.strictEqual(foxtrotDocumentCount, 3);
  assert.strictEqual(golfDocumentCount, 3);
  assert.strictEqual(hotelDocumentCount, 3);


  assert.strictEqual(foxtrotDocumentNullCountBeforeUpdateMany, 0);
  assert.strictEqual(golfDocumentNullCountBeforeUpdateMany, 0);
  assert.strictEqual(hotelDocumentNullCountBeforeUpdateMany, 0);

  assert.strictEqual(foxtrotDocumentNullCountAfterUpdateMany, 0); // This assertion fails because there is a "null" property with a date value added to the document.
  assert.strictEqual(golfDocumentNullCountAfterUpdateMany, 0); // This assertion fails because there is a "null" property with a date value added to the document.
  assert.strictEqual(hotelDocumentNullCountAfterUpdateMany, 0); // This assertion fails because there is a "null" property with a date value added to the document.

  mongoose.connection.close();
}

run();