mongoose 6.4.7 → 6.5.2

package/lib/helpers/document/applyDefaults.js

@@ -0,0 +1,115 @@
+'use strict';
+
+module.exports = function applyDefaults(doc, fields, exclude, hasIncludedChildren, isBeforeSetters, pathsToSkip) {
+  const paths = Object.keys(doc.$__schema.paths);
+  const plen = paths.length;
+
+  for (let i = 0; i < plen; ++i) {
+    let def;
+    let curPath = '';
+    const p = paths[i];
+
+    if (p === '_id' && doc.$__.skipId) {
+      continue;
+    }
+
+    const type = doc.$__schema.paths[p];
+    const path = type.splitPath();
+    const len = path.length;
+    let included = false;
+    let doc_ = doc._doc;
+    for (let j = 0; j < len; ++j) {
+      if (doc_ == null) {
+        break;
+      }
+
+      const piece = path[j];
+      curPath += (!curPath.length ? '' : '.') + piece;
+
+      if (exclude === true) {
+        if (curPath in fields) {
+          break;
+        }
+      } else if (exclude === false && fields && !included) {
+        const hasSubpaths = type.$isSingleNested || type.$isMongooseDocumentArray;
+        if (curPath in fields || (hasSubpaths && hasIncludedChildren != null && hasIncludedChildren[curPath])) {
+          included = true;
+        } else if (hasIncludedChildren != null && !hasIncludedChildren[curPath]) {
+          break;
+        }
+      }
+
+      if (j === len - 1) {
+        if (doc_[piece] !== void 0) {
+          break;
+        }
+
+        if (isBeforeSetters != null) {
+          if (typeof type.defaultValue === 'function') {
+            if (!type.defaultValue.$runBeforeSetters && isBeforeSetters) {
+              break;
+            }
+            if (type.defaultValue.$runBeforeSetters && !isBeforeSetters) {
+              break;
+            }
+          } else if (!isBeforeSetters) {
+            // Non-function defaults should always run **before** setters
+            continue;
+          }
+        }
+
+        if (pathsToSkip && pathsToSkip[curPath]) {
+          break;
+        }
+
+        if (fields && exclude !== null) {
+          if (exclude === true) {
+            // apply defaults to all non-excluded fields
+            if (p in fields) {
+              continue;
+            }
+
+            try {
+              def = type.getDefault(doc, false);
+            } catch (err) {
+              doc.invalidate(p, err);
+              break;
+            }
+
+            if (typeof def !== 'undefined') {
+              doc_[piece] = def;
+              doc.$__.activePaths.default(p);
+            }
+          } else if (included) {
+            // selected field
+            try {
+              def = type.getDefault(doc, false);
+            } catch (err) {
+              doc.invalidate(p, err);
+              break;
+            }
+
+            if (typeof def !== 'undefined') {
+              doc_[piece] = def;
+              doc.$__.activePaths.default(p);
+            }
+          }
+        } else {
+          try {
+            def = type.getDefault(doc, false);
+          } catch (err) {
+            doc.invalidate(p, err);
+            break;
+          }
+
+          if (typeof def !== 'undefined') {
+            doc_[piece] = def;
+            doc.$__.activePaths.default(p);
+          }
+        }
+      } else {
+        doc_ = doc_[piece];
+      }
+    }
+  }
+};

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/helpers/populate/markArraySubdocsPopulated.js

@@ -7,6 +7,7 @@ const utils = require('../../utils');
  * subdoc within the array knows its subpaths are populated.
  *
  * #### Example:
+ *
  *     const doc = await Article.findOne().populate('comments.author');
  *     doc.comments[0].populated('author'); // Should be set
  */

package/lib/helpers/projection/hasIncludedChildren.js

@@ -5,6 +5,7 @@
  * the projection.
  *
  * #### Example:
+ *
  *     const res = hasIncludedChildren({ 'a.b.c': 0 });
  *     res.a; // 1
  *     res['a.b']; // 1

package/lib/helpers/promiseOrCallback.js

@@ -7,23 +7,32 @@ const emittedSymbol = Symbol('mongoose:emitted');
 
 module.exports = function promiseOrCallback(callback, fn, ee, Promise) {
   if (typeof callback === 'function') {
-    return fn(function(error) {
-      if (error != null) {
-        if (ee != null && ee.listeners != null && ee.listeners('error').length > 0 && !error[emittedSymbol]) {
-          error[emittedSymbol] = true;
-          ee.emit('error', error);
+    try {
+      return fn(function(error) {
+        if (error != null) {
+          if (ee != null && ee.listeners != null && ee.listeners('error').length > 0 && !error[emittedSymbol]) {
+            error[emittedSymbol] = true;
+            ee.emit('error', error);
+          }
+          try {
+            callback(error);
+          } catch (error) {
+            return immediate(() => {
+              throw error;
+            });
+          }
+          return;
         }
-        try {
-          callback(error);
-        } catch (error) {
-          return immediate(() => {
-            throw error;
-          });
-        }
-        return;
+        callback.apply(this, arguments);
+      });
+    } catch (error) {
+      if (ee != null && ee.listeners != null && ee.listeners('error').length > 0 && !error[emittedSymbol]) {
+        error[emittedSymbol] = true;
+        ee.emit('error', error);
       }
-      callback.apply(this, arguments);
-    });
+
+      return callback(error);
+    }
   }
 
   Promise = Promise || PromiseProvider.get();

package/lib/helpers/update/applyTimestampsToChildren.js

@@ -82,12 +82,15 @@ function applyTimestampsToChildren(now, update, schema) {
 function applyTimestampsToDocumentArray(arr, schematype, now) {
   const timestamps = schematype.schema.options.timestamps;
 
+  const len = arr.length;
+
   if (!timestamps) {
+    for (let i = 0; i < len; ++i) {
+      applyTimestampsToChildren(now, arr[i], schematype.schema);
+    }
     return;
   }
 
-  const len = arr.length;
-
   const createdAt = handleTimestampOption(timestamps, 'createdAt');
   const updatedAt = handleTimestampOption(timestamps, 'updatedAt');
   for (let i = 0; i < len; ++i) {
@@ -105,6 +108,7 @@ function applyTimestampsToDocumentArray(arr, schematype, now) {
 function applyTimestampsToSingleNested(subdoc, schematype, now) {
   const timestamps = schematype.schema.options.timestamps;
   if (!timestamps) {
+    applyTimestampsToChildren(now, subdoc, schematype.schema);
     return;
   }
 

package/lib/index.js

@@ -51,6 +51,7 @@ const objectIdHexRegexp = /^[0-9A-Fa-f]{24}$/;
  * Most apps will only use this one instance.
  *
  * #### Example:
+ *
  *     const mongoose = require('mongoose');
  *     mongoose instanceof mongoose.Mongoose; // true
  *
@@ -687,7 +688,7 @@ Mongoose.prototype._applyPlugins = function(schema, options) {
  * @param {Function} fn plugin callback
  * @param {Object} [opts] optional options
  * @return {Mongoose} this
- * @see plugins ./plugins.html
+ * @see plugins /docs/plugins
  * @api public
  */
 

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.