"strictPopulate" not working after upgrading from v5 to v6

[sambhav2612]

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.12.0

Node.js version

16.20.0

MongoDB server version

6.0.10

Typescript version (if applicable)

4.7.4

Description

Hi,

We are trying to upgrade our atlas cluster from v5 to v6, for which, we tried upgrading mongoose to prevent any server-level compatibility issues however we keep getting errors around strictPopulate.

Seemingly the type-declaration for global override has been already added (ref: #11006) which did not work.

This is inside NestJS v7 (@nestjs/mongoose: ^7.2.4)

Steps to Reproduce

Example Code Throwing Error:

async migrateSomething(): Promise<any> {
    let response = await this.modelX
      .find(filter)
      .populate({
        path: 'a b c', // direct keys available in schema for X
        populate: {
          path: 'd c', // direct keys available in schema for A (not X)
          populate: 'e', // indirect keys outside of schema for X
          strictPopulate: false, // <== not working
        },
      });
    
...
...
...
...

  }

Expected Behavior

Should not throw any error or allow server to run while gracefully putting a warning

[IslandRhythms]

https://mongoosejs.com/docs/migrating_to_6.html#strictpopulate

[IslandRhythms]

const mongoose = require('mongoose');

const testSchema = new mongoose.Schema({
  name: String,
  location: String,
  occupation: String,
});

const ASchema = new mongoose.Schema({
  name: String,
  age: Number,
  weight: Number,
  dModel: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'DModel'
  },
  fModel: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'FModel'
  }
});

const XSchema = new mongoose.Schema({
  name: String,
  car: String,
  make: String,
  model: String,
  aModel: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'AModel'
  },
  testModel: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'Test'
  },
  cModel: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'CModel'
  }
});

const CSchema = new mongoose.Schema({
  name: String,
  hobbies: String
})

const DSchema = new mongoose.Schema({
  name: String,
});

const FSchema = new mongoose.Schema({
  name: String,
});

const GSchema = new mongoose.Schema({
  name: String
});

const Test = mongoose.model('Test', testSchema);
const AModel = mongoose.model('AModel', ASchema);
const XModel = mongoose.model('XModel', XSchema);
const CModel = mongoose.model('CModel', CSchema);
const DModel = mongoose.model('DModel', DSchema);
const FModel = mongoose.model('FModel', FSchema);
const GModel = mongoose.model('GModel', GSchema);

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

  const gDoc = await GModel.create({
    name: 'G-Man'
  });
  const dDoc = await DModel.create({
    name: 'Dirty Dan',
  });

  const fDoc = await FModel.create({
    name: 'Filthy Frank',
  });

  const testDoc = await Test.create({
    name: 'Test Testserson',
    location: 'Florida',
    occupation: 'Tester'
  });

  const aDoc = await AModel.create({
    name: 'A-men',
    age: 4,
    weight: 404,
    dModel: dDoc._id,
    fModel: fDoc._id
  });

  const cDoc = await CModel.create({
    name: 'C-ya',
    hobbies: 'Leaving'
  });

  await XModel.create({
    name: 'XCOM',
    aModel: aDoc._id,
    cModel: cDoc._id,
    testModel: testDoc._id
  });

  const res = await XModel.find().populate({
    path: 'aModel testModel cModel',
    populate: {
      path: 'dModel fModel',
      populate: 'gModel',
      strictPopulate: false
    }
  });

  console.log('what is res', res[0]);
  console.log('==============================');
  console.log('what is amodel in the doc', res[0].aModel)

  console.log('done');

}

run();

[vkarpov15]

I did some debugging and it looks like this is expected behavior. You need to apply strictPopulate on the e populate, as written you've set strictPopulate on the d c populate. Do the following instead:

      .populate({
        path: 'a b c', // direct keys available in schema for X
        populate: {
          path: 'd c', // direct keys available in schema for A (not X)
          populate: { path: 'e', strictPopulate: false } // indirect keys outside of schema for X
        },
      });