mongoose 7.2.0 → 7.2.1

package/lib/cursor/QueryCursor.js

@@ -8,6 +8,7 @@ const MongooseError = require('../error/mongooseError');
 const Readable = require('stream').Readable;
 const eachAsync = require('../helpers/cursor/eachAsync');
 const helpers = require('../queryhelpers');
+const kareem = require('kareem');
 const immediate = require('../helpers/immediate');
 const util = require('util');
 
@@ -39,6 +40,7 @@ function QueryCursor(query, options) {
   Readable.call(this, { autoDestroy: true, objectMode: true });
 
   this.cursor = null;
+  this.skipped = false;
   this.query = query;
   const _this = this;
   const model = query.model;
@@ -46,9 +48,25 @@ function QueryCursor(query, options) {
   this._transforms = [];
   this.model = model;
   this.options = options || {};
-
   model.hooks.execPre('find', query, (err) => {
     if (err != null) {
+      if (err instanceof kareem.skipWrappedFunction) {
+        const resultValue = err.args[0];
+        if (resultValue != null && (!Array.isArray(resultValue) || resultValue.length)) {
+          const err = new MongooseError(
+            'Cannot `skipMiddlewareFunction()` with a value when using ' +
+            '`.find().cursor()`, value must be nullish or empty array, got "' +
+            util.inspect(resultValue) +
+            '".'
+          );
+          _this._markError(err);
+          _this.listeners('error').length > 0 && _this.emit('error', err);
+          return;
+        }
+        this.skipped = true;
+        _this.emit('cursor', null);
+        return;
+      }
       _this._markError(err);
       _this.listeners('error').length > 0 && _this.emit('error', err);
       return;
@@ -66,6 +84,7 @@ function QueryCursor(query, options) {
       // Max out the number of documents we'll populate in parallel at 5000.
       this.options._populateBatchSize = Math.min(this.options.batchSize, 5000);
     }
+    Object.assign(this.options, query._optionsForExec());
     model.collection.find(query._conditions, this.options, (err, cursor) => {
       if (err != null) {
         _this._markError(err);
@@ -393,6 +412,9 @@ function _next(ctx, cb) {
       callback(ctx._error);
     });
   }
+  if (ctx.skipped) {
+    return immediate(() => callback(null, null));
+  }
 
   if (ctx.cursor) {
     if (ctx.query._mongooseOptions.populate && !ctx._pop) {
@@ -448,6 +470,9 @@ function _next(ctx, cb) {
     ctx.once('cursor', function(cursor) {
       ctx.removeListener('error', cb);
       if (cursor == null) {
+        if (ctx.skipped) {
+          return cb(null, null);
+        }
         return;
       }
       _next(ctx, cb);

package/lib/helpers/model/castBulkWrite.js

@@ -1,10 +1,12 @@
 'use strict';
 
+const MongooseError = require('../../error/mongooseError');
 const getDiscriminatorByValue = require('../../helpers/discriminator/getDiscriminatorByValue');
 const applyTimestampsToChildren = require('../update/applyTimestampsToChildren');
 const applyTimestampsToUpdate = require('../update/applyTimestampsToUpdate');
 const cast = require('../../cast');
 const castUpdate = require('../query/castUpdate');
+const { inspect } = require('util');
 const setDefaultsOnInsert = require('../setDefaultsOnInsert');
 
 /**
@@ -212,7 +214,8 @@ module.exports = function castBulkWrite(originalModel, op, options) {
     };
   } else {
     return (callback) => {
-      callback(new Error('Invalid op passed to `bulkWrite()`'), null);
+      const error = new MongooseError(`Invalid op passed to \`bulkWrite()\`: ${inspect(op)}`);
+      callback(error, null);
     };
   }
 };

package/lib/helpers/update/applyTimestampsToUpdate.js

@@ -44,11 +44,12 @@ function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, optio
 
   if (Array.isArray(updates)) {
     // Update with aggregation pipeline
+    if (updatedAt == null) {
+      return updates;
+    }
     updates.push({ $set: { [updatedAt]: now } });
-
     return updates;
   }
-
   updates.$set = updates.$set || {};
   if (!skipUpdatedAt && updatedAt &&
       (!currentUpdate.$currentDate || !currentUpdate.$currentDate[updatedAt])) {

package/lib/query.js

@@ -3289,19 +3289,15 @@ Query.prototype._findOneAndUpdate = async function _findOneAndUpdate() {
     throw this.error();
   }
 
-  this._applyPaths();
-  this._fields = this._castFields(this._fields);
   applyGlobalMaxTimeMS(this.options, this.model);
   applyGlobalDiskUse(this.options, this.model);
 
-  const opts = this._optionsForExec(this.model);
-  this._applyTranslateAliases(opts);
-
-  if ('strict' in opts) {
-    this._mongooseOptions.strict = opts.strict;
+  if ('strict' in this.options) {
+    this._mongooseOptions.strict = this.options.strict;
   }
-  const options = { projection: this._fields, ...opts };
+  const options = this._optionsForExec(this.model);
   convertNewToReturnDocument(options);
+  this._applyTranslateAliases(options);
 
   this._update = this._castUpdate(this._update, false);
 
@@ -3312,7 +3308,7 @@ Query.prototype._findOneAndUpdate = async function _findOneAndUpdate() {
     this._update, _opts);
 
   if (!this._update || Object.keys(this._update).length === 0) {
-    if (opts.upsert) {
+    if (options.upsert) {
       // still need to do the upsert to empty doc
       const doc = clone(this._update);
       delete doc._id;
@@ -3488,18 +3484,8 @@ Query.prototype._findOneAndDelete = async function _findOneAndDelete() {
   }
 
   const filter = this._conditions;
-  const options = this._optionsForExec();
+  const options = this._optionsForExec(this.model);
   this._applyTranslateAliases(options);
-  let fields = null;
-
-  this._applyPaths();
-  if (this._fields != null) {
-    options.projection = this._castFields(clone(this._fields));
-    fields = options.projection;
-    if (fields instanceof Error) {
-      throw fields;
-    }
-  }
 
   let res = await this._collection.collection.findOneAndDelete(filter, options);
   for (const fn of this._transforms) {
@@ -5021,6 +5007,7 @@ Query.prototype.cursor = function cursor(opts) {
   }
 
   const options = this._optionsForExec();
+
   try {
     this.cast(this.model);
   } catch (err) {

package/lib/schema/array.js

@@ -359,7 +359,11 @@ SchemaArray.prototype.cast = function(value, doc, init, prev, options) {
     options = options || emptyOpts;
 
     let rawValue = utils.isMongooseArray(value) ? value.__array : value;
-    value = MongooseArray(rawValue, options.path || this._arrayPath || this.path, doc, this);
+    let path = options.path || this.path;
+    if (options.arrayPathIndex != null) {
+      path += '.' + options.arrayPathIndex;
+    }
+    value = MongooseArray(rawValue, path, doc, this);
     rawValue = value.__array;
 
     if (init && doc != null && doc.$__ != null && doc.$populated(this.path)) {

package/lib/schematype.js

@@ -822,10 +822,12 @@ SchemaType.prototype.get = function(fn) {
  *
  * #### Error message templates:
  *
- * From the examples above, you may have noticed that error messages support
- * basic templating. There are a few other template keywords besides `{PATH}`
- * and `{VALUE}` too. To find out more, details are available
- * [here](./error.html#Error.prototype.name).
+ * Below is a list of supported template keywords:
+ *
+ * - PATH: The schema path where the error is being triggered.
+ * - VALUE: The value assigned to the PATH that is triggering the error.
+ * - KIND: The validation property that triggered the error i.e. required.
+ * - REASON: The error object that caused this error if there was one.
  *
  * If Mongoose's built-in error message templating isn't enough, Mongoose
  * supports setting the `message` property to a function.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "7.2.0",
+  "version": "7.2.1",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",