Method "collection.aggregate()" accepts at most two arguments

Do you want to request a feature or report a bug? Bug

What is the current behavior? Error: Method "collection.aggregate()" accepts at most two arguments

MongoInvalidArgumentError: Method "collection.aggregate()" accepts at most two arguments
    at Collection.aggregate (/home/dave/projects/asd/node_modules/mongodb/lib/collection.js:367:19)
    at NativeCollection.<computed> [as aggregate] (/home/dave/projects/asd/node_modules/mongoose/lib/drivers/node-mongodb-native/collection.js:200:33)
    at NativeCollection.Collection.doQueue (/home/dave/projects/asd/node_modules/mongoose/lib/collection.js:135:23)
    at /home/dave/projects/asd/node_modules/mongoose/lib/collection.js:82:24
    at processTicksAndRejections (internal/process/task_queues.js:77:11)

If the current behavior is a bug, please provide the steps to reproduce.

    import Client from '../models/client';
    ...
    const clients = await Client.aggregate([
      { $match: { active: true } },
      { $project: {
          name: 1,
          image: 1,
          maxContract: {
            $arrayElemAt: [ '$contracts', { $indexOfArray: ['$contracts.endDate', { $max: '$contracts.endDate' }] } ]
          }
        }
      },
      { $match: { 'maxContract.endDate': { $lte: date, $gte: new Date() } } },
      { $sort: { 'maxContract.endDate': 1 } }
    ]);

Happens also with a simple match query inside aggregate:

    import Client from '../models/client';
    ...
    const clients = await Client.aggregate([
      { $match: { active: true } }
    ]);

What is the expected behavior? Working as v5?

What are the versions of Node.js, Mongoose and MongoDB you are using? Note that “latest” is not a version. Node: v14.17.6, Mongoose: v6.0.5, TypeScript: v4.2.4

I have this error since v6, it’s working fine with v5. I can’t find where the breaking change is documented tbh… Any help is appreciated, thanks.

Also, TypeScript aggregate signature is:

(method) Model<IClient, {}, {}>.aggregate<any>(pipeline?: any[]): Aggregate<any[]> (+1 overload)

But if the arguments must be different, TypeScript should tell before compiling.

[vkarpov15]

Confirmed this bug, fix will be in 6.0.7 on Monday 👍

[IslandRhythms]

Modify script below to reproduce your error and I will try again.

import * as mongoose from 'mongoose';

const ClientSchema = new mongoose.Schema({
  name: { type: String, required: true, trim: true },
  image: { type: String, default: '' },
  contracts: [{
    id: Number,
    name: String,
    startDate: Date, 
    endDate: Date,
    created_at: Date,
    updated_at: Date
  }],
  active: { type: Boolean, default: true },
});

export interface IClient extends Document {
  _id: any;
  name: string;
  image: string;
  contracts: any[];
  active: boolean;
}

const Client = mongoose.model<IClient>('Client', ClientSchema);

async function test() {
    await mongoose.connect('mongodb://localhost:27017/');
    await mongoose.connection.dropDatabase();
    const clients = await Client.aggregate([
        { $match: { active: true } },
        { $project: {
            name: 1,
            image: 1,
            maxContract: {
              $arrayElemAt: [ '$contracts', { $indexOfArray: ['$contracts.endDate', { $max: '$contracts.endDate' }] } ]
            }
          }
        },
        { $match: { 'maxContract.endDate': { $lte: new Date(), $gte: new Date() } } },
        { $sort: { 'maxContract.endDate': 1 } }
      ]);
      
      const test = await Client.aggregate([ { $match: { active: true } }]);
      console.log('done');
}




test();