mongoose 6.4.7 → 6.5.0

package/lib/helpers/document/cleanModifiedSubpaths.js

@@ -13,7 +13,7 @@ module.exports = function cleanModifiedSubpaths(doc, path, options) {
     return deleted;
   }
 
-  for (const modifiedPath of Object.keys(doc.$__.activePaths.states.modify)) {
+  for (const modifiedPath of Object.keys(doc.$__.activePaths.getStatePaths('modify'))) {
     if (skipDocArrays) {
       const schemaType = doc.$__schema.path(modifiedPath);
       if (schemaType && schemaType.$isMongooseDocumentArray) {
@@ -21,13 +21,13 @@ module.exports = function cleanModifiedSubpaths(doc, path, options) {
       }
     }
     if (modifiedPath.startsWith(path + '.')) {
-      delete doc.$__.activePaths.states.modify[modifiedPath];
+      doc.$__.activePaths.clearPath(modifiedPath);
       ++deleted;
 
       if (doc.$isSubdocument) {
         const owner = doc.ownerDocument();
         const fullPath = doc.$__fullPath(modifiedPath);
-        delete owner.$__.activePaths.states.modify[fullPath];
+        owner.$__.activePaths.clearPath(fullPath);
       }
     }
   }

package/lib/helpers/document/compile.js

@@ -17,6 +17,13 @@ const isPOJO = utils.isPOJO;
 exports.compile = compile;
 exports.defineKey = defineKey;
 
+const _isEmptyOptions = Object.freeze({
+  minimize: true,
+  virtuals: false,
+  getters: false,
+  transform: false
+});
+
 /*!
  * Compiles schemas.
  */
@@ -130,12 +137,6 @@ function defineKey({ prop, subprops, prototype, prefix, options }) {
             value: true
           });
 
-          const _isEmptyOptions = Object.freeze({
-            minimize: true,
-            virtuals: false,
-            getters: false,
-            transform: false
-          });
           Object.defineProperty(nested, '$isEmpty', {
             enumerable: false,
             configurable: true,

package/lib/helpers/firstKey.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = function firstKey(obj) {
+  if (obj == null) {
+    return null;
+  }
+  return Object.keys(obj)[0];
+};

package/lib/helpers/model/applyDefaultsToPOJO.js

@@ -0,0 +1,52 @@
+'use strict';
+
+module.exports = function applyDefaultsToPOJO(doc, schema) {
+  const paths = Object.keys(schema.paths);
+  const plen = paths.length;
+
+  for (let i = 0; i < plen; ++i) {
+    let curPath = '';
+    const p = paths[i];
+
+    const type = schema.paths[p];
+    const path = type.splitPath();
+    const len = path.length;
+    let doc_ = doc;
+    for (let j = 0; j < len; ++j) {
+      if (doc_ == null) {
+        break;
+      }
+
+      const piece = path[j];
+      curPath += (!curPath.length ? '' : '.') + piece;
+
+      if (j === len - 1) {
+        if (typeof doc_[piece] !== 'undefined') {
+          if (type.$isSingleNested) {
+            applyDefaultsToPOJO(doc_[piece], type.caster.schema);
+          } else if (type.$isMongooseDocumentArray && Array.isArray(doc_[piece])) {
+            doc_[piece].forEach(el => applyDefaultsToPOJO(el, type.schema));
+          }
+
+          break;
+        }
+
+        const def = type.getDefault(doc, false, { skipCast: true });
+        if (typeof def !== 'undefined') {
+          doc_[piece] = def;
+
+          if (type.$isSingleNested) {
+            applyDefaultsToPOJO(def, type.caster.schema);
+          } else if (type.$isMongooseDocumentArray && Array.isArray(def)) {
+            def.forEach(el => applyDefaultsToPOJO(el, type.schema));
+          }
+        }
+      } else {
+        if (doc_[piece] == null) {
+          doc_[piece] = {};
+        }
+        doc_ = doc_[piece];
+      }
+    }
+  }
+};

package/lib/helpers/model/castBulkWrite.js

@@ -20,7 +20,7 @@ module.exports = function castBulkWrite(originalModel, op, options) {
       const model = decideModelByObject(originalModel, op['insertOne']['document']);
 
       const doc = new model(op['insertOne']['document']);
-      if (model.schema.options.timestamps) {
+      if (model.schema.options.timestamps && options.timestamps !== false) {
         doc.initializeTimestamps();
       }
       if (options.session != null) {

package/lib/helpers/model/pushNestedArrayPaths.js

@@ -0,0 +1,15 @@
+'use strict';
+
+module.exports = function pushNestedArrayPaths(paths, nestedArray, path) {
+  if (nestedArray == null) {
+    return;
+  }
+
+  for (let i = 0; i < nestedArray.length; ++i) {
+    if (Array.isArray(nestedArray[i])) {
+      pushNestedArrayPaths(paths, nestedArray[i], path + '.' + i);
+    } else {
+      paths.push(path + '.' + i);
+    }
+  }
+};

package/lib/internal.js

@@ -13,8 +13,9 @@ function InternalCache() {
   this.activePaths = new ActiveRoster();
 }
 
+InternalCache.prototype.strictMode = true;
+
 InternalCache.prototype.fullPath = undefined;
-InternalCache.prototype.strictMode = undefined;
 InternalCache.prototype.selected = undefined;
 InternalCache.prototype.shardval = undefined;
 InternalCache.prototype.saveError = undefined;
@@ -28,6 +29,7 @@ InternalCache.prototype._id = undefined;
 InternalCache.prototype.ownerDocument = undefined;
 InternalCache.prototype.populate = undefined; // what we want to populate in this doc
 InternalCache.prototype.populated = undefined;// the _ids that have been populated
+InternalCache.prototype.primitiveAtomics = undefined;
 
 /**
  * If `false`, this document was not the result of population.

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);
+      }
     }
   }
 
@@ -3167,6 +3178,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 +3203,9 @@ Model.watch = function(pipeline, options) {
     }
   };
 
+  options = options || {};
+  options.model = this;
+
   return new ChangeStream(changeStreamThunk, pipeline, options);
 };
 
@@ -3579,41 +3594,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 +3652,137 @@ 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 +3790,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 +3815,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 +3832,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 +3853,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 +3865,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 +3882,7 @@ Model.hydrate = function(obj, projection) {
   }
 
   const document = require('./queryhelpers').createModel(this, obj, projection);
-  document.$init(obj);
+  document.$init(obj, options);
   return document;
 };
 
@@ -4245,7 +4381,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 +4394,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 +4418,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);

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/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);

package/lib/query.js

@@ -1632,6 +1632,9 @@ Query.prototype.setOptions = function(options, overwrite) {
     this._mongooseOptions.defaults = options.defaults;
     // deleting options.defaults will cause 7287 to fail
   }
+  if (options.lean == null && this.schema && 'lean' in this.schema.options) {
+    this._mongooseOptions.lean = this.schema.options.lean;
+  }
 
   if (typeof options.limit === 'string') {
     try {

package/lib/schema/array.js

@@ -393,7 +393,8 @@ SchemaArray.prototype.cast = function(value, doc, init, prev, options) {
     return value;
   }
 
-  if (init || SchemaArray.options.castNonArrays) {
+  const castNonArraysOption = this.options.castNonArrays != null ? this.options.castNonArrays : SchemaArray.options.castNonArrays;
+  if (init || castNonArraysOption) {
     // gh-2442: if we're loading this from the db and its not an array, mark
     // the whole array as modified.
     if (!!doc && !!init) {