Merge branch 'master' into 9.0

Author: vkarpov15

docs/compatibility.md

@@ -11,7 +11,7 @@
     }
 </style>
 
-Mongoose relies on the [MongoDB Node.js Driver](http://mongodb.github.io/node-mongodb-native/) to talk to MongoDB.  
+Mongoose relies on the [MongoDB Node.js Driver](http://mongodb.github.io/node-mongodb-native/) to talk to MongoDB.
 You can refer to [this table](https://www.mongodb.com/docs/drivers/node/current/compatibility/) for up-to-date information as to which version of the MongoDB driver supports which version of MongoDB.
 
 Below are the [semver](http://semver.org/) ranges representing which versions of mongoose are compatible with the listed versions of MongoDB server.
@@ -32,4 +32,6 @@ Below are the [semver](http://semver.org/) ranges representing which versions of
 |    `2.6.x`     |          `^3.8.8 \| ^4.0.0 \| ^5.0.0`          |
 |    `2.4.x`     |                `^3.8.0 \| ^4.0.0`              |
 
+Mongoose `^6.5.0` also works with MongoDB server 7.x. But not all new MongoDB server 7.x features are supported by Mongoose 6.x.
+
 Note that Mongoose `5.x` dropped support for all versions of MongoDB before `3.0.0`. If you need to use MongoDB `2.6` or older, use Mongoose `4.x`.

docs/migrating_to_7.md

@@ -106,6 +106,7 @@ They always return promises.
 * `Connection.prototype.close`
 * `Connection.prototype.destroy`
 * `Document.prototype.populate`
+* `Document.prototype.save`
 * `Document.prototype.validate`
 * `Mongoose.prototype.connect`
 * `Mongoose.prototype.createConnection`

lib/cursor/queryCursor.js

@@ -84,6 +84,9 @@ function QueryCursor(query) {
       // Max out the number of documents we'll populate in parallel at 5000.
       this.options._populateBatchSize = Math.min(this.options.batchSize, 5000);
     }
+    if (query._mongooseOptions._asyncIterator) {
+      this._mongooseOptions._asyncIterator = true;
+    }
 
     if (model.collection._shouldBufferCommands() && model.collection.buffer) {
       model.collection.queue.push([
@@ -382,29 +385,6 @@ QueryCursor.prototype.addCursorFlag = function(flag, value) {
   return this;
 };
 
-/*!
- * ignore
- */
-
-QueryCursor.prototype.transformNull = function(val) {
-  if (arguments.length === 0) {
-    val = true;
-  }
-  this._mongooseOptions.transformNull = val;
-  return this;
-};
-
-/*!
- * ignore
- */
-
-QueryCursor.prototype._transformForAsyncIterator = function() {
-  if (this._transforms.indexOf(_transformForAsyncIterator) === -1) {
-    this.map(_transformForAsyncIterator);
-  }
-  return this;
-};
-
 /**
  * Returns an asyncIterator for use with [`for/await/of` loops](https://thecodebarbarian.com/getting-started-with-async-iterators-in-node-js).
  * You do not need to call this function explicitly, the JavaScript runtime
@@ -436,19 +416,13 @@ QueryCursor.prototype._transformForAsyncIterator = function() {
  */
 
 if (Symbol.asyncIterator != null) {
-  QueryCursor.prototype[Symbol.asyncIterator] = function() {
-    return this.transformNull()._transformForAsyncIterator();
+  QueryCursor.prototype[Symbol.asyncIterator] = function queryCursorAsyncIterator() {
+    // Set so QueryCursor knows it should transform results for async iterators into `{ value, done }` syntax
+    this._mongooseOptions._asyncIterator = true;
+    return this;
   };
 }
 
-/*!
- * ignore
- */
-
-function _transformForAsyncIterator(doc) {
-  return doc == null ? { done: true } : { value: doc, done: false };
-}
-
 /**
  * Get the next doc from the underlying cursor and mongooseify it
  * (populate, etc.)
@@ -459,16 +433,38 @@ function _transformForAsyncIterator(doc) {
 
 function _next(ctx, cb) {
   let callback = cb;
-  if (ctx._transforms.length) {
-    callback = function(err, doc) {
-      if (err || (doc === null && !ctx._mongooseOptions.transformNull)) {
-        return cb(err, doc);
+
+  // Create a custom callback to handle transforms, async iterator, and transformNull
+  callback = function(err, doc) {
+    if (err) {
+      return cb(err);
+    }
+
+    // Handle null documents - if asyncIterator, we need to return `done: true`, otherwise just
+    // skip. In either case, avoid transforms.
+    if (doc === null) {
+      if (ctx._mongooseOptions._asyncIterator) {
+        return cb(null, { done: true });
+      } else {
+        return cb(null, null);
       }
-      cb(err, ctx._transforms.reduce(function(doc, fn) {
+    }
+
+    // Apply transforms
+    if (ctx._transforms.length && doc !== null) {
+      doc = ctx._transforms.reduce(function(doc, fn) {
         return fn.call(ctx, doc);
-      }, doc));
-    };
-  }
+      }, doc);
+    }
+
+    // This option is set in `Symbol.asyncIterator` code paths.
+    // For async iterator, we need to convert to {value, done} format
+    if (ctx._mongooseOptions._asyncIterator) {
+      return cb(null, { value: doc, done: false });
+    }
+
+    return cb(null, doc);
+  };
 
   if (ctx._error) {
     return immediate(function() {

lib/query.js

@@ -5420,8 +5420,10 @@ Query.prototype.nearSphere = function() {
  */
 
 if (Symbol.asyncIterator != null) {
-  Query.prototype[Symbol.asyncIterator] = function() {
-    return this.cursor().transformNull()._transformForAsyncIterator();
+  Query.prototype[Symbol.asyncIterator] = function queryAsyncIterator() {
+    // Set so QueryCursor knows it should transform results for async iterators into `{ value, done }` syntax
+    this._mongooseOptions._asyncIterator = true;
+    return this.cursor();
   };
 }
 

test/query.test.js

@@ -2354,6 +2354,19 @@ describe('Query', function() {
     assert.strictEqual(called, 1);
   });
 
+  it('transform with for/await and cursor', async function() {
+    const Model = db.model('Test', new Schema({ name: String }));
+
+    await Model.create({ name: 'test' });
+    const cursor = Model.find().transform(doc => doc.name.toUpperCase()).cursor();
+    const names = [];
+    for await (const name of cursor) {
+      names.push(name);
+    }
+
+    assert.deepStrictEqual(names, ['TEST']);
+  });
+
   describe('orFail (gh-6841)', function() {
     let Model;
 

test/types/queries.test.ts

@@ -187,6 +187,8 @@ expectError(Test.find({}, { 'docs.profiles': { name: 'aa' } })); // should suppo
 expectError(Test.find({}, { endDate: { toString: 1 } }));
 expectError(Test.find({}, { tags: { trim: 1 } }));
 expectError(Test.find({}, { child: { toJSON: 1 } }));
+Test.find({}, { age: 1, _id: 0 });
+Test.find({}, { name: 0, age: 0, _id: 1 });
 
 // Manual Casting using ProjectionType
 Test.find({}, { docs: { unknownParams: 1 } } as ProjectionType<ITest>);

types/index.d.ts

@@ -685,10 +685,16 @@ declare module 'mongoose' {
         }
         : Element;
   type _IDType = { _id?: boolean | 1 | 0 };
-  export type InclusionProjection<T> = IsItRecordAndNotAny<T> extends true ? Projector<WithLevel1NestedPaths<T>, true | 1> & _IDType : AnyObject;
-  export type ExclusionProjection<T> = IsItRecordAndNotAny<T> extends true ? Projector<WithLevel1NestedPaths<T>, false | 0> & _IDType : AnyObject;
-
-  export type ProjectionType<T> = (InclusionProjection<T> & AnyObject) | (ExclusionProjection<T> & AnyObject) | string;
+  export type InclusionProjection<T> = IsItRecordAndNotAny<T> extends true
+    ? Omit<Projector<WithLevel1NestedPaths<T>, true | 1>, '_id'> & _IDType
+    : AnyObject;
+  export type ExclusionProjection<T> = IsItRecordAndNotAny<T> extends true
+    ? Omit<Projector<WithLevel1NestedPaths<T>, false | 0>, '_id'> & _IDType
+    : AnyObject;
+
+  export type ProjectionType<T> = (InclusionProjection<T> & AnyObject)
+    | (ExclusionProjection<T> & AnyObject)
+    | string;
   export type SortValues = SortOrder;
 
   export type SortOrder = -1 | 1 | 'asc' | 'ascending' | 'desc' | 'descending';

types/pipelinestage.d.ts

@@ -319,10 +319,11 @@ declare module 'mongoose' {
     export interface VectorSearch {
       /** [`$vectorSearch` reference](https://www.mongodb.com/docs/atlas/atlas-vector-search/vector-search-stage/) */
       $vectorSearch: {
+        exact?: boolean;
         index: string,
         path: string,
         queryVector: number[],
-        numCandidates: number,
+        numCandidates?: number,
         limit: number,
         filter?: Expression,
       }