After upgrading to Mongoose 6, an updateOne() with returns "acknowledged:false" when schema typo is a POJO

[markstos]

After uppgrading to Mongoose 6, an updateOne() statement started to return { acknowledged: false }.

No logging is generated to explain /why/ it was not acknowledged, which would be super-useful. The query is not sent to MongoDB.

The Mongoose docs say a positive acknowledgement means "everything meant smoothly". This is not helpful enough to know what the cause is when things don't go smoothly.

I eventually tracked the issue down to some code we wrote in 2017 which required an optional sub-document. At that time, multiple StackOverflow posts from the era recommended using a type key in the schema that points to a POJO. Here's one such post:

https://stackoverflow.com/questions/38248365/mongoose-schema-with-nested-optional-object/38250186#38250186

Mongoose changed related behavior in Mongoose 6, which is referenced in this issue:
#8107

There's a note in the migration guide here:
https://mongoosejs.com/docs/6.x/docs/migrating_to_6.html#typepojotomixed

But the migration guide note make it sounds like the old schemas would keep working, but they do not. Rather than have a migration note, I would rather that Mongoose just crash at schema creation type with a note that such schema definitions where type points to a POJO like this are no longer supported. The code could only exist in the Mongoose 6 branch.

Otherwise, I recommend updating the migration guide:

Setting type in a schema to a POJO is no longer recommended and may result in some queries returning acknowledged: false. See the Schema docs for options to set the type to Mixed or use a sub-document instead.

Repro code

Code like this works in Mongoose 5, but fails in Mongoose 6 until you remove the type: wrapper object.

When running the code, look for whether acknowledged:true or acknowledged:false is returned in the result.

const mongoose = require('mongoose');

async function main() {
  await mongoose.connect('mongodb://localhost/test');

  const UserSchema = new mongoose.Schema({
    top: {
        type: {
          credentials: {
            access_token: { type: String },
          },
        },
        recentNotifications: [
          {
            notificationDate: { type: Date, required: true },
          },
        ],
      }
  });

  
  const User = mongoose.model('User', UserSchema);

  mongoose.set('debug', true);

  const res = await User.updateOne(
    { _id: '66fead1406c6a2afa4a6953e' },
     {"$push":{
       "top.recentNotifications":{
           "$each":[
             {
              "notificationDate":"2024-10-03T14:41:24.137Z",
             }
           ],
         }
       }
     }
  );
  console.log('result was:', res)
}

main();

[vkarpov15]

Here's an extremely simplified repro. The idea is that Mongoose returns { acknowledged: false } when you try to send an updateOne() with an empty update. This behavior was for backwards compatibility when the MongoDB server changed to throwing an error when it receives an empty update several years ago.

const mongoose = require('mongoose');
async function main() {
  await mongoose.connect('mongodb://localhost/test');
  const UserSchema = new mongoose.Schema({
    integrations: {
      mine: {
        required: false,
        select: false,
        algorithm: {
          type: String,
          enum: ['first','second'],
        },
        type: {
          credentials: {
            access_token: { type: String },
            refresh_token: { type: String },
            expires_at: { type: Number },
          },
          lastDataDate: { type: 'Date', default: null },
          profile: {
            id: { type: Number },
         },
         recentNotifications: [
          {
            notificationDate: { type: Date, required: true },
            externalId: { type: Number, required: false },
            tripDetected: { type: Boolean, required: true },
            logs: { type: [String], required: true },
          },
        ],
      }
    }
    }
  });

  const User = mongoose.model('User', UserSchema);

  const res = await User.updateOne({ _id: '66fead1406c6a2afa4a6953e' }, {});
  console.log('result was:', res)
}
main();

The most likely explanation is that there's some sort of issue where Mongoose doesn't think the field you're trying to update is in your schema. Try executing your update with strict: 'throw' to see if that's the case:

  const res = await User.updateOne({ _id: '66fead1406c6a2afa4a6953e' }, { $push: { ... } }, { strict: 'throw' });
  console.log('result was:', res)

[markstos]

Thanks, I updated the original question to explain what's going on, which is the legacy use of type: to point to a POJO, which was recommended in 2016/2017 but broke during the Mongoose 6 upgrade.

[vkarpov15]

That makes sense, I'm sorry for the trouble. For what it is worth, the code suggested in https://stackoverflow.com/questions/38248365/mongoose-schema-with-nested-optional-object/38250186#38250186 never actually worked as you might expect. In Mongoose 5 and older, the following schema would have nested as an optional Mixed type. So yes nested would be optional, but there would be no casting or validation.

{
  data1: String,
  nested: {
    type: {
       nestedProp1: String,
       nestedSub: [String]
    },
    required: false
  }
}

As of Mongoose 6, there shouldn't be anything wrong with setting type to a POJO, the above would be equivalent to:

{
  data1: String,
  nested: {
    type: new Schema({
       nestedProp1: String,
       nestedSub: [String]
    }),
    required: false
  }
}

Do you have any more info on what your schema looks like? The fact that you're seeing this issue could be indicative of a update casting issue.

[markstos]

Do you have any more info on what your schema looks like?

I gave some examples above where type: {} contained a POJO. We fixed it by removing removing the type:{} nesting and inlining the POJO it pointed to. I'm not completely sure what we trying to solve or what was going wrong back in 2016/2017 that led us to find and follow that StackOverflow exception. It seems that the at the time there may have been a problem with fieids that were nested-by-optional. Not sure. The important thing is that we now have the code working with Mongoose 6. 😀 Once we get this upgrade done, we can proceed to the Mongoose 7 and 8 upgrades.

[vkarpov15]

Ok, let me know if you run into any more issues upgrading to Mongoose 6 👍