syncIndexes and diffIndexes does not correctly find compound indexes involving text and non-text indexe

[rdeavila94]

Prerequisites

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

Mongoose version

5.x

Node.js version

14.x

MongoDB server version

4.x

Typescript version (if applicable)

No response

Description

Given a schema with the following:

      const Test = new Schema({
        title: {
          type: String
        },
        description: {
          type: String
        },
        age: {
          type: Number
        }
      }, {
        autoIndex: false
      })

Calling syncIndexes on that schema ALWAYS attempts to delete and create it.
Calling diffIndexes on that schema, even after it's been synced, always returns the compound index as both a toDrop entry and a toCreate entry

Steps to Reproduce

Run the following tests in test/model.indexes.test.js

    it('should not re-create a compound text index that involves non-text indexes, using syncIndexes', function(done) {
      const Test = new Schema({
        title: {
          type: String
        },
        description: {
          type: String
        },
        age: {
          type: Number
        }
      }, {
        autoIndex: false
      })
  
      Test.index({
        title:'text',
        description:'text',
        age: 1
      });

      const TestModel = db.model('Test', Test);
      TestModel.syncIndexes().then((results1) => {
        assert.strictEqual(results1, []);
        // second call to syncIndexes should return an empty array, representing 0 deleted indexes
        TestModel.syncIndexes().then((results2) => {
          assert.strictEqual(results2, []);
          done();
        })
      })
    })

    it('should not find a diff when calling diffIndexes after syncIndexes involving a text and non-text compound index', function(done) {
      const Test = new Schema({
        title: {
          type: String
        },
        description: {
          type: String
        },
        age: {
          type: Number
        }
      }, {
        autoIndex: false
      })
  
      Test.index({
        title:'text',
        description:'text',
        age: 1
      });

      const TestModel = db.model('Test', Test);
      
      TestModel.diffIndexes().then((diff) => {
        assert.deepEqual(diff, {toCreate: [{age: 1, title: 'text', description:'text'}], toDrop: []});
        TestModel.syncIndexes().then(() => {
          TestModel.diffIndexes().then((diff2) => {
            assert.deepEqual(diff2, {toCreate: [], toDrop: []});
            done();
          })
        })
      })
    })

Expected Behavior

The above tests to pass.

Calling diffIndexes on a schema that's been synced, where that schema contains a compound index involving both text and non-text indexes, should not return any diff at all.

[rdeavila94]

Opened up a PR to fix this. Created this issue to have a github issue reference number