mongoose 6.4.7 → 6.5.2

package/lib/model.js

@@ -22,6 +22,8 @@ const ServerSelectionError = require('./error/serverSelection');
 const ValidationError = require('./error/validation');
 const VersionError = require('./error/version');
 const ParallelSaveError = require('./error/parallelSave');
+const applyDefaultsHelper = require('./helpers/document/applyDefaults');
+const applyDefaultsToPOJO = require('./helpers/model/applyDefaultsToPOJO');
 const applyQueryMiddleware = require('./helpers/query/applyQueryMiddleware');
 const applyHooks = require('./helpers/model/applyHooks');
 const applyMethods = require('./helpers/model/applyMethods');
@@ -35,6 +37,7 @@ const castBulkWrite = require('./helpers/model/castBulkWrite');
 const createPopulateQueryFilter = require('./helpers/populate/createPopulateQueryFilter');
 const getDefaultBulkwriteResult = require('./helpers/getDefaultBulkwriteResult');
 const discriminator = require('./helpers/model/discriminator');
+const firstKey = require('./helpers/firstKey');
 const each = require('./helpers/each');
 const get = require('./helpers/get');
 const getConstructorName = require('./helpers/getConstructorName');
@@ -54,6 +57,7 @@ const leanPopulateMap = require('./helpers/populate/leanPopulateMap');
 const modifiedPaths = require('./helpers/update/modifiedPaths');
 const parallelLimit = require('./helpers/parallelLimit');
 const prepareDiscriminatorPipeline = require('./helpers/aggregate/prepareDiscriminatorPipeline');
+const pushNestedArrayPaths = require('./helpers/model/pushNestedArrayPaths');
 const removeDeselectedForeignField = require('./helpers/populate/removeDeselectedForeignField');
 const setDottedPath = require('./helpers/path/setDottedPath');
 const util = require('util');
@@ -589,6 +593,7 @@ function operand(self, where, delta, data, val, op) {
     case '$pullAll':
     case '$push':
     case '$addToSet':
+    case '$inc':
       break;
     default:
       // nothing to do
@@ -764,15 +769,21 @@ Model.prototype.$__delta = function() {
       value = value.toObject();
       operand(this, where, delta, data, value);
     } else {
-      value = utils.clone(value, {
-        depopulate: true,
-        transform: false,
-        virtuals: false,
-        getters: false,
-        omitUndefined: true,
-        _isNested: true
-      });
-      operand(this, where, delta, data, value);
+      if (this.$__.primitiveAtomics && this.$__.primitiveAtomics[data.path] != null) {
+        const val = this.$__.primitiveAtomics[data.path];
+        const op = firstKey(val);
+        operand(this, where, delta, data, val[op], op);
+      } else {
+        value = utils.clone(value, {
+          depopulate: true,
+          transform: false,
+          virtuals: false,
+          getters: false,
+          omitUndefined: true,
+          _isNested: true
+        });
+        operand(this, where, delta, data, value);
+      }
     }
   }
 
@@ -3109,10 +3120,9 @@ Model.create = function create(doc, options, callback) {
     }
     const _done = (error, res) => {
       const savedDocs = [];
-      const len = res.length;
-      for (let i = 0; i < len; ++i) {
-        if (res[i].doc) {
-          savedDocs.push(res[i].doc);
+      for (const val of res) {
+        if (val.doc) {
+          savedDocs.push(val.doc);
         }
       }
 
@@ -3167,6 +3177,7 @@ Model.create = function create(doc, options, callback) {
  *
  * @param {Array} [pipeline]
  * @param {Object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/3.0/api/Collection.html#watch)
+ * @param {Boolean} [options.hydrate=false] if true and `fullDocument: 'updateLookup'` is set, Mongoose will automatically hydrate `fullDocument` into a fully fledged Mongoose document
  * @return {ChangeStream} mongoose-specific change stream wrapper, inherits from EventEmitter
  * @api public
  */
@@ -3191,6 +3202,9 @@ Model.watch = function(pipeline, options) {
     }
   };
 
+  options = options || {};
+  options.model = this;
+
   return new ChangeStream(changeStreamThunk, pipeline, options);
 };
 
@@ -3560,13 +3574,17 @@ Model.bulkWrite = function(ops, options, callback) {
         return cb(null, getDefaultBulkwriteResult());
       }
 
-      this.$__collection.bulkWrite(ops, options, (error, res) => {
-        if (error) {
-          return cb(error);
-        }
+      try {
+        this.$__collection.bulkWrite(ops, options, (error, res) => {
+          if (error) {
+            return cb(error);
+          }
 
-        cb(null, res);
-      });
+          cb(null, res);
+        });
+      } catch (err) {
+        return cb(err);
+      }
     });
   }, this.events);
 };
@@ -3579,41 +3597,50 @@ Model.bulkWrite = function(ops, options, callback) {
  *
  * @param {Array<Document>} documents
  * @param {Object} [options] options passed to the underlying `bulkWrite()`
+ * @param {Boolean} [options.timestamps] defaults to `null`, when set to false, mongoose will not add/update timestamps to the documents.
  * @param {ClientSession} [options.session=null] The session associated with this bulk write. See [transactions docs](/docs/transactions.html).
  * @param {String|number} [options.w=1] The [write concern](https://docs.mongodb.com/manual/reference/write-concern/). See [`Query#w()`](/docs/api.html#query_Query-w) for more information.
  * @param {number} [options.wtimeout=null] The [write concern timeout](https://docs.mongodb.com/manual/reference/write-concern/#wtimeout).
  * @param {Boolean} [options.j=true] If false, disable [journal acknowledgement](https://docs.mongodb.com/manual/reference/write-concern/#j-option)
  *
  */
-Model.bulkSave = function(documents, options) {
-  const preSavePromises = documents.map(buildPreSavePromise);
-
-  const writeOperations = this.buildBulkWriteOperations(documents, { skipValidation: true });
-
-  let bulkWriteResultPromise;
-  return Promise.all(preSavePromises)
-    .then(() => bulkWriteResultPromise = this.bulkWrite(writeOperations, options))
-    .then(() => documents.map(buildSuccessfulWriteHandlerPromise))
-    .then(() => bulkWriteResultPromise)
-    .catch((err) => {
-      if (!(err && err.writeErrors && err.writeErrors.length)) {
-        throw err;
-      }
-      return Promise.all(
-        documents.map((document) => {
-          const documentError = err.writeErrors.find(writeError => {
-            const writeErrorDocumentId = writeError.err.op._id || writeError.err.op.q._id;
-            return writeErrorDocumentId.toString() === document._id.toString();
-          });
+Model.bulkSave = async function(documents, options) {
+  options = options || {};
 
-          if (documentError == null) {
-            return buildSuccessfulWriteHandlerPromise(document);
-          }
-        })
-      ).then(() => {
-        throw err;
+  const writeOperations = this.buildBulkWriteOperations(documents, { skipValidation: true, timestamps: options.timestamps });
+
+  if (options.timestamps != null) {
+    for (const document of documents) {
+      document.$__.saveOptions = document.$__.saveOptions || {};
+      document.$__.saveOptions.timestamps = options.timestamps;
+    }
+  }
+
+  await Promise.all(documents.map(buildPreSavePromise));
+
+  const { bulkWriteResult, bulkWriteError } = await this.bulkWrite(writeOperations, options).then(
+    (res) => ({ bulkWriteResult: res, bulkWriteError: null }),
+    (err) => ({ bulkWriteResult: null, bulkWriteError: err })
+  );
+
+  await Promise.all(
+    documents.map(async(document) => {
+      const documentError = bulkWriteError && bulkWriteError.writeErrors.find(writeError => {
+        const writeErrorDocumentId = writeError.err.op._id || writeError.err.op.q._id;
+        return writeErrorDocumentId.toString() === document._id.toString();
       });
-    });
+
+      if (documentError == null) {
+        await handleSuccessfulWrite(document);
+      }
+    })
+  );
+
+  if (bulkWriteError && bulkWriteError.writeErrors && bulkWriteError.writeErrors.length) {
+    throw bulkWriteError;
+  }
+
+  return bulkWriteResult;
 };
 
 function buildPreSavePromise(document) {
@@ -3628,26 +3655,138 @@ function buildPreSavePromise(document) {
   });
 }
 
-function buildSuccessfulWriteHandlerPromise(document) {
+function handleSuccessfulWrite(document) {
   return new Promise((resolve, reject) => {
-    handleSuccessfulWrite(document, resolve, reject);
+    if (document.$isNew) {
+      _setIsNew(document, false);
+    }
+
+    document.$__reset();
+    document.schema.s.hooks.execPost('save', document, {}, (err) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve();
+    });
+
   });
 }
 
-function handleSuccessfulWrite(document, resolve, reject) {
-  if (document.$isNew) {
-    _setIsNew(document, false);
+/**
+ * Apply defaults to the given document or POJO.
+ *
+ * @param {Object|Document} obj object or document to apply defaults on
+ * @returns {Object|Document}
+ * @api public
+ */
+
+Model.applyDefaults = function applyDefaults(doc) {
+  if (doc.$__ != null) {
+    applyDefaultsHelper(doc, doc.$__.fields, doc.$__.exclude);
+
+    for (const subdoc of doc.$getAllSubdocs()) {
+      applyDefaults(subdoc, subdoc.$__.fields, subdoc.$__.exclude);
+    }
+
+    return doc;
   }
 
-  document.$__reset();
-  document.schema.s.hooks.execPost('save', document, {}, (err) => {
-    if (err) {
-      reject(err);
-      return;
+  applyDefaultsToPOJO(doc, this.schema);
+
+  return doc;
+};
+
+/**
+ * Cast the given POJO to the model's schema
+ *
+ * #### Example:
+ *
+ *     const Test = mongoose.model('Test', Schema({ num: Number }));
+ *
+ *     const obj = Test.castObject({ num: '42' });
+ *     obj.num; // 42 as a number
+ *
+ *     Test.castObject({ num: 'not a number' }); // Throws a ValidationError
+ *
+ * @param {Object} obj object or document to cast
+ * @returns {Object} POJO casted to the model's schema
+ * @throws {ValidationError} if casting failed for at least one path
+ * @api public
+ */
+
+Model.castObject = function castObject(obj) {
+  const ret = {};
+
+  const schema = this.schema;
+  const paths = Object.keys(schema.paths);
+
+  for (const path of paths) {
+    const schemaType = schema.path(path);
+    if (!schemaType || !schemaType.$isMongooseArray) {
+      continue;
     }
-    resolve();
-  });
-}
+
+    const val = get(obj, path);
+    pushNestedArrayPaths(paths, val, path);
+  }
+
+  let error = null;
+
+  for (const path of paths) {
+    const schemaType = schema.path(path);
+    if (schemaType == null) {
+      continue;
+    }
+
+    let val = get(obj, path, void 0);
+
+    if (val == null) {
+      continue;
+    }
+
+    const pieces = path.indexOf('.') === -1 ? [path] : path.split('.');
+    let cur = ret;
+    for (let i = 0; i < pieces.length - 1; ++i) {
+      if (cur[pieces[i]] == null) {
+        cur[pieces[i]] = isNaN(pieces[i + 1]) ? {} : [];
+      }
+      cur = cur[pieces[i]];
+    }
+
+    if (schemaType.$isMongooseDocumentArray) {
+      continue;
+    }
+    if (schemaType.$isSingleNested || schemaType.$isMongooseDocumentArrayElement) {
+      try {
+        val = Model.castObject.call(schemaType.caster, val);
+      } catch (err) {
+        error = error || new ValidationError();
+        error.addError(path, err);
+        continue;
+      }
+
+      cur[pieces[pieces.length - 1]] = val;
+      continue;
+    }
+
+    try {
+      val = schemaType.cast(val);
+      cur[pieces[pieces.length - 1]] = val;
+    } catch (err) {
+      error = error || new ValidationError();
+      error.addError(path, err);
+
+      continue;
+    }
+  }
+
+  if (error != null) {
+    throw error;
+  }
+
+  return ret;
+};
 
 /**
  * Build bulk write operations for `bulkSave()`.
@@ -3655,9 +3794,11 @@ function handleSuccessfulWrite(document, resolve, reject) {
  * @param {Array<Document>} documents The array of documents to build write operations of
  * @param {Object} options
  * @param {Boolean} options.skipValidation defaults to `false`, when set to true, building the write operations will bypass validating the documents.
+ * @param {Boolean} options.timestamps defaults to `null`, when set to false, mongoose will not add/update timestamps to the documents.
  * @return {Array<Promise>} Returns a array of all Promises the function executes to be awaited.
  * @api private
  */
+
 Model.buildBulkWriteOperations = function buildBulkWriteOperations(documents, options) {
   if (!Array.isArray(documents)) {
     throw new Error(`bulkSave expects an array of documents to be passed, received \`${documents}\` instead`);
@@ -3678,9 +3819,9 @@ Model.buildBulkWriteOperations = function buildBulkWriteOperations(documents, op
 
     const isANewDocument = document.isNew;
     if (isANewDocument) {
-      accumulator.push({
-        insertOne: { document }
-      });
+      const writeOperation = { insertOne: { document } };
+      utils.injectTimestampsOption(writeOperation.insertOne, options.timestamps);
+      accumulator.push(writeOperation);
 
       return accumulator;
     }
@@ -3695,13 +3836,9 @@ Model.buildBulkWriteOperations = function buildBulkWriteOperations(documents, op
       _applyCustomWhere(document, where);
 
       document.$__version(where, delta);
-
-      accumulator.push({
-        updateOne: {
-          filter: where,
-          update: changes
-        }
-      });
+      const writeOperation = { updateOne: { filter: where, update: changes } };
+      utils.injectTimestampsOption(writeOperation.updateOne, options.timestamps);
+      accumulator.push(writeOperation);
 
       return accumulator;
     }
@@ -3720,6 +3857,7 @@ Model.buildBulkWriteOperations = function buildBulkWriteOperations(documents, op
   }
 };
 
+
 /**
  * Shortcut for creating a new Document from existing raw data, pre-saved in the DB.
  * The document returned has no paths marked as modified initially.
@@ -3731,11 +3869,13 @@ Model.buildBulkWriteOperations = function buildBulkWriteOperations(documents, op
  *
  * @param {Object} obj
  * @param {Object|String|String[]} [projection] optional projection containing which fields should be selected for this document
+ * @param {Object} [options] optional options
+ * @param {Boolean} [options.setters=false] if true, apply schema setters when hydrating
  * @return {Document} document instance
  * @api public
  */
 
-Model.hydrate = function(obj, projection) {
+Model.hydrate = function(obj, projection, options) {
   _checkContext(this, 'hydrate');
 
   if (projection != null) {
@@ -3746,7 +3886,7 @@ Model.hydrate = function(obj, projection) {
   }
 
   const document = require('./queryhelpers').createModel(this, obj, projection);
-  document.$init(obj);
+  document.$init(obj, options);
   return document;
 };
 
@@ -3843,6 +3983,7 @@ Model.update = function update(conditions, doc, options, callback) {
  * and `post('updateMany')` instead.
  *
  * #### Example:
+ *
  *     const res = await Person.updateMany({ name: /Stark$/ }, { isDeleted: true });
  *     res.matchedCount; // Number of documents matched
  *     res.modifiedCount; // Number of documents modified
@@ -3883,6 +4024,7 @@ Model.updateMany = function updateMany(conditions, doc, options, callback) {
  * - Use `replaceOne()` if you want to overwrite an entire document rather than using atomic operators like `$set`.
  *
  * #### Example:
+ *
  *     const res = await Person.updateOne({ name: 'Jean-Luc Picard' }, { ship: 'USS Enterprise' });
  *     res.matchedCount; // Number of documents matched
  *     res.modifiedCount; // Number of documents modified
@@ -3920,6 +4062,7 @@ Model.updateOne = function updateOne(conditions, doc, options, callback) {
  * given document (no atomic operators like `$set`).
  *
  * #### Example:
+ *
  *     const res = await Person.replaceOne({ _id: 24601 }, { name: 'Jean Valjean' });
  *     res.matchedCount; // Number of documents matched
  *     res.modifiedCount; // Number of documents modified
@@ -4049,7 +4192,7 @@ function _update(model, op, conditions, doc, options, callback) {
  * @param {String} [opts.out.reduce] add the results to collectionName: if dups are detected, uses the reducer / finalize functions
  * @param {String} [opts.out.merge] add the results to collectionName: if dups exist the new docs overwrite the old
  * @param {Function} [callback] optional callback
- * @see https://www.mongodb.org/display/DOCS/MapReduce
+ * @see MongoDB MapReduce https://www.mongodb.org/display/DOCS/MapReduce
  * @return {Promise}
  * @api public
  */
@@ -4245,7 +4388,7 @@ Model.validate = function validate(obj, pathsToValidate, context, callback) {
       }
 
       const val = get(obj, path);
-      pushNestedArrayPaths(val, path);
+      pushNestedArrayPaths(paths, val, path);
     }
 
     let remaining = paths.length;
@@ -4258,7 +4401,7 @@ Model.validate = function validate(obj, pathsToValidate, context, callback) {
         continue;
       }
 
-      const pieces = path.split('.');
+      const pieces = path.indexOf('.') === -1 ? [path] : path.split('.');
       let cur = obj;
       for (let i = 0; i < pieces.length - 1; ++i) {
         cur = cur[pieces[i]];
@@ -4282,32 +4425,12 @@ Model.validate = function validate(obj, pathsToValidate, context, callback) {
       schemaType.doValidate(val, err => {
         if (err) {
           error = error || new ValidationError();
-          if (err instanceof ValidationError) {
-            for (const _err of Object.keys(err.errors)) {
-              error.addError(`${path}.${err.errors[_err].path}`, _err);
-            }
-          } else {
-            error.addError(err.path, err);
-          }
+          error.addError(path, err);
         }
         _checkDone();
       }, context, { path: path });
     }
 
-    function pushNestedArrayPaths(nestedArray, path) {
-      if (nestedArray == null) {
-        return;
-      }
-
-      for (let i = 0; i < nestedArray.length; ++i) {
-        if (Array.isArray(nestedArray[i])) {
-          pushNestedArrayPaths(nestedArray[i], path + '.' + i);
-        } else {
-          paths.push(path + '.' + i);
-        }
-      }
-    }
-
     function _checkDone() {
       if (--remaining <= 0) {
         return cb(error);
@@ -4479,6 +4602,17 @@ function populate(model, docs, options, callback) {
       mod.options.options.sort || void 0;
     assignmentOpts.excludeId = excludeIdReg.test(select) || (select && select._id === 0);
 
+    // Lean transform may delete `_id`, which would cause assignment
+    // to fail. So delay running lean transform until _after_
+    // `_assign()`
+    if (mod.options &&
+        mod.options.options &&
+        mod.options.options.lean &&
+        mod.options.options.lean.transform) {
+      mod.options.options._leanTransform = mod.options.options.lean.transform;
+      mod.options.options.lean = true;
+    }
+
     if (ids.length === 0 || ids.every(utils.isNullOrUndefined)) {
       // Ensure that we set to 0 or empty array even
       // if we don't actually execute a query to make sure there's a value
@@ -4553,6 +4687,14 @@ function populate(model, docs, options, callback) {
     for (const arr of params) {
       removeDeselectedForeignField(arr[0].foreignField, arr[0].options, vals);
     }
+    for (const arr of params) {
+      const mod = arr[0];
+      if (mod.options && mod.options.options && mod.options.options._leanTransform) {
+        for (const doc of vals) {
+          mod.options.options._leanTransform(doc);
+        }
+      }
+    }
     callback();
   }
 }

package/lib/options/SchemaArrayOptions.js

@@ -52,6 +52,25 @@ Object.defineProperty(SchemaArrayOptions.prototype, 'enum', opts);
 
 Object.defineProperty(SchemaArrayOptions.prototype, 'of', opts);
 
+/**
+ * If set to `false`, will always deactivate casting non-array values to arrays.
+ * If set to `true`, will cast non-array values to arrays if `init` and `SchemaArray.options.castNonArrays` are also `true`
+ *
+ * #### Example:
+ *
+ *     const Model = db.model('Test', new Schema({ x1: { castNonArrays: false, type: [String] } }));
+ *     const doc = new Model({ x1: "some non-array value" });
+ *     await doc.validate(); // Errors with "CastError"
+ *
+ * @api public
+ * @property castNonArrays
+ * @memberOf SchemaArrayOptions
+ * @type {Boolean}
+ * @instance
+ */
+
+Object.defineProperty(SchemaArrayOptions.prototype, 'castNonArrays', opts);
+
 /*!
  * ignore
  */

package/lib/options/SchemaNumberOptions.js

@@ -50,6 +50,7 @@ Object.defineProperty(SchemaNumberOptions.prototype, 'max', opts);
  * equal to one of the given values.
  *
  * #### Example:
+ *
  *     const schema = new Schema({
  *       favoritePrime: {
  *         type: Number,
@@ -71,6 +72,7 @@ Object.defineProperty(SchemaNumberOptions.prototype, 'enum', opts);
  * Sets default [populate options](/docs/populate.html#query-conditions).
  *
  * #### Example:
+ *
  *     const schema = new Schema({
  *       child: {
  *         type: Number,

package/lib/options/SchemaObjectIdOptions.js

@@ -35,6 +35,7 @@ Object.defineProperty(SchemaObjectIdOptions.prototype, 'auto', opts);
  * Sets default [populate options](/docs/populate.html#query-conditions).
  *
  * #### Example:
+ *
  *     const schema = new Schema({
  *       child: {
  *         type: 'ObjectId',

package/lib/plugins/trackTransaction.js

@@ -23,14 +23,14 @@ module.exports = function trackTransaction(schema) {
         initialState.versionKey = this.get(this.$__schema.options.versionKey);
       }
 
-      initialState.modifiedPaths = new Set(Object.keys(this.$__.activePaths.states.modify));
+      initialState.modifiedPaths = new Set(Object.keys(this.$__.activePaths.getStatePaths('modify')));
       initialState.atomics = _getAtomics(this);
 
       session[sessionNewDocuments].set(this, initialState);
     } else {
       const state = session[sessionNewDocuments].get(this);
 
-      for (const path of Object.keys(this.$__.activePaths.states.modify)) {
+      for (const path of Object.keys(this.$__.activePaths.getStatePaths('modify'))) {
         state.modifiedPaths.add(path);
       }
       state.atomics = _getAtomics(this, state.atomics);