mongoose 6.1.9 → 6.2.2

package/lib/helpers/clone.js

@@ -1,7 +1,5 @@
 'use strict';
 
-
-const cloneRegExp = require('regexp-clone');
 const Decimal = require('../types/decimal128');
 const ObjectId = require('../types/objectid');
 const specialProperties = require('./specialProperties');
@@ -34,7 +32,7 @@ function clone(obj, options, isArrayChild) {
   }
 
   if (Array.isArray(obj)) {
-    return cloneArray(obj, options);
+    return cloneArray(utils.isMongooseArray(obj) ? obj.__array : obj, options);
   }
 
   if (isMongooseObject(obj)) {
@@ -43,23 +41,34 @@ function clone(obj, options, isArrayChild) {
     if (options && options._skipSingleNestedGetters && obj.$isSingleNested) {
       options = Object.assign({}, options, { getters: false });
     }
+    const isSingleNested = obj.$isSingleNested;
 
     if (utils.isPOJO(obj) && obj.$__ != null && obj._doc != null) {
       return obj._doc;
     }
 
+    let ret;
     if (options && options.json && typeof obj.toJSON === 'function') {
-      return obj.toJSON(options);
+      ret = obj.toJSON(options);
+    } else {
+      ret = obj.toObject(options);
+    }
+
+    if (options && options.minimize && isSingleNested && Object.keys(ret).length === 0) {
+      return undefined;
     }
-    return obj.toObject(options);
+
+    return ret;
   }
 
-  if (obj.constructor) {
-    switch (getFunctionName(obj.constructor)) {
+  const objConstructor = obj.constructor;
+
+  if (objConstructor) {
+    switch (getFunctionName(objConstructor)) {
       case 'Object':
         return cloneObject(obj, options, isArrayChild);
       case 'Date':
-        return new obj.constructor(+obj);
+        return new objConstructor(+obj);
       case 'RegExp':
         return cloneRegExp(obj);
       default:
@@ -79,12 +88,12 @@ function clone(obj, options, isArrayChild) {
     return Decimal.fromString(obj.toString());
   }
 
-  if (!obj.constructor && isObject(obj)) {
-    // object created with Object.create(null)
+  // object created with Object.create(null)
+  if (!objConstructor && isObject(obj)) {
     return cloneObject(obj, options, isArrayChild);
   }
 
-  if (obj[symbols.schemaTypeSymbol]) {
+  if (typeof obj === 'object' && obj[symbols.schemaTypeSymbol]) {
     return obj.clone();
   }
 
@@ -95,7 +104,7 @@ function clone(obj, options, isArrayChild) {
     return obj;
   }
 
-  if (obj.valueOf != null) {
+  if (typeof obj.valueOf === 'function') {
     return obj.valueOf();
   }
 
@@ -112,25 +121,28 @@ function cloneObject(obj, options, isArrayChild) {
   const ret = {};
   let hasKeys;
 
-  if (obj[trustedSymbol]) {
+  if (trustedSymbol in obj) {
     ret[trustedSymbol] = obj[trustedSymbol];
   }
 
-  for (const k of Object.keys(obj)) {
-    if (specialProperties.has(k)) {
+  let i = 0;
+  let key = '';
+  const keys = Object.keys(obj);
+  const len = keys.length;
+
+  for (i = 0; i < len; ++i) {
+    if (specialProperties.has(key = keys[i])) {
       continue;
     }
 
     // Don't pass `isArrayChild` down
-    const val = clone(obj[k], options);
-
-    if (!minimize || (typeof val !== 'undefined')) {
-      if (minimize === false && typeof val === 'undefined') {
-        delete ret[k];
-      } else {
-        hasKeys || (hasKeys = true);
-        ret[k] = val;
-      }
+    const val = clone(obj[key], options, false);
+
+    if (minimize === false && typeof val === 'undefined') {
+      delete ret[key];
+    } else if (minimize !== true || (typeof val !== 'undefined')) {
+      hasKeys || (hasKeys = true);
+      ret[key] = val;
     }
   }
 
@@ -138,11 +150,21 @@ function cloneObject(obj, options, isArrayChild) {
 }
 
 function cloneArray(arr, options) {
-  const ret = [];
-
-  for (const item of arr) {
-    ret.push(clone(item, options, true));
+  let i = 0;
+  const len = arr.length;
+  const ret = new Array(len);
+  for (i = 0; i < len; ++i) {
+    ret[i] = clone(arr[i], options, true);
   }
 
   return ret;
-}
+}
+
+function cloneRegExp(regexp) {
+  const ret = new RegExp(regexp.source, regexp.flags);
+
+  if (ret.lastIndex !== regexp.lastIndex) {
+    ret.lastIndex = regexp.lastIndex;
+  }
+  return ret;
+}

package/lib/helpers/common.js

@@ -88,7 +88,7 @@ function modifiedPaths(update, path, result) {
         cur += '.' + sp[i];
       }
     }
-    if (isMongooseObject(val) && !Buffer.isBuffer(val)) {
+    if (!Buffer.isBuffer(val) && isMongooseObject(val)) {
       val = val.toObject({ transform: false, virtuals: false });
     }
     if (shouldFlatten(val)) {
@@ -108,7 +108,7 @@ function shouldFlatten(val) {
     typeof val === 'object' &&
     !(val instanceof Date) &&
     !(val instanceof ObjectId) &&
-    (!Array.isArray(val) || val.length > 0) &&
+    (!Array.isArray(val) || val.length !== 0) &&
     !(val instanceof Buffer) &&
     !(val instanceof Decimal128) &&
     !(val instanceof Binary);

package/lib/helpers/cursor/eachAsync.js

@@ -27,16 +27,15 @@ module.exports = function eachAsync(next, fn, options, callback) {
   const enqueue = asyncQueue();
 
   return promiseOrCallback(callback, cb => {
+
     if (batchSize != null) {
       if (typeof batchSize !== 'number') {
         throw new TypeError('batchSize must be a number');
-      }
-      if (batchSize < 1) {
+      } else if (!Number.isInteger(batchSize)) {
+        throw new TypeError('batchSize must be an integer');
+      } else if (batchSize < 1) {
         throw new TypeError('batchSize must be at least 1');
       }
-      if (batchSize !== Math.floor(batchSize)) {
-        throw new TypeError('batchSize must be a positive integer');
-      }
     }
 
     iterate(cb);
@@ -71,7 +70,7 @@ module.exports = function eachAsync(next, fn, options, callback) {
           drained = true;
           if (handleResultsInProgress <= 0) {
             finalCallback(null);
-          } else if (batchSize != null && documentsBatch.length) {
+          } else if (batchSize && documentsBatch.length) {
             handleNextResult(documentsBatch, currentDocumentIndex++, handleNextResultCallBack);
           }
           return done();
@@ -83,20 +82,20 @@ module.exports = function eachAsync(next, fn, options, callback) {
         // make sure we know that we still have a result to handle re: #8422
         immediate(() => done());
 
-        if (batchSize != null) {
+        if (batchSize) {
           documentsBatch.push(doc);
         }
 
         // If the current documents size is less than the provided patch size don't process the documents yet
-        if (batchSize != null && documentsBatch.length !== batchSize) {
-          setTimeout(() => enqueue(fetch), 0);
+        if (batchSize && documentsBatch.length !== batchSize) {
+          immediate(() => enqueue(fetch));
           return;
         }
 
-        const docsToProcess = batchSize != null ? documentsBatch : doc;
+        const docsToProcess = batchSize ? documentsBatch : doc;
 
         function handleNextResultCallBack(err) {
-          if (batchSize != null) {
+          if (batchSize) {
             handleResultsInProgress -= documentsBatch.length;
             documentsBatch = [];
           } else {
@@ -110,7 +109,7 @@ module.exports = function eachAsync(next, fn, options, callback) {
             return finalCallback(null);
           }
 
-          setTimeout(() => enqueue(fetch), 0);
+          immediate(() => enqueue(fetch));
         }
 
         handleNextResult(docsToProcess, currentDocumentIndex++, handleNextResultCallBack);
@@ -139,7 +138,10 @@ function asyncQueue() {
   let id = 0;
 
   return function enqueue(fn) {
-    if (_queue.length === 0 && inProgress == null) {
+    if (
+      inProgress === null &&
+      _queue.length === 0
+    ) {
       inProgress = id++;
       return fn(_step);
     }
@@ -147,11 +149,12 @@ function asyncQueue() {
   };
 
   function _step() {
-    inProgress = null;
-    if (_queue.length > 0) {
+    if (_queue.length !== 0) {
       inProgress = id++;
       const fn = _queue.shift();
       fn(_step);
+    } else {
+      inProgress = null;
     }
   }
 }

package/lib/helpers/document/compile.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const documentSchemaSymbol = require('../../helpers/symbols').documentSchemaSymbol;
-const get = require('../../helpers/get');
 const internalToObjectOptions = require('../../options').internalToObjectOptions;
 const utils = require('../../utils');
 
@@ -93,7 +92,11 @@ function defineKey({ prop, subprops, prototype, prefix, options }) {
             writable: false,
             value: function() {
               return utils.clone(_this.get(path, null, {
-                virtuals: get(this, 'schema.options.toObject.virtuals', null)
+                virtuals: this &&
+                  this.schema &&
+                  this.schema.options &&
+                  this.schema.options.toObject &&
+                  this.schema.options.toObject.virtuals || null
               }));
             }
           });
@@ -104,7 +107,7 @@ function defineKey({ prop, subprops, prototype, prefix, options }) {
             writable: false,
             value: function() {
               return _this.get(path, null, {
-                virtuals: get(this, 'schema.options.toObject.virtuals', null)
+                virtuals: this && this.schema && this.schema.options && this.schema.options.toObject && this.schema.options.toObject.virtuals || null
               });
             }
           });
@@ -115,7 +118,7 @@ function defineKey({ prop, subprops, prototype, prefix, options }) {
             writable: false,
             value: function() {
               return _this.get(path, null, {
-                virtuals: get(_this, 'schema.options.toJSON.virtuals', null)
+                virtuals: this && this.schema && this.schema.options && this.schema.options.toJSON && this.schema.options.toJSON.virtuals || null
               });
             }
           });

package/lib/helpers/getFunctionName.js

@@ -1,8 +1,10 @@
 'use strict';
 
+const functionNameRE = /^function\s*([^\s(]+)/;
+
 module.exports = function(fn) {
-  if (fn.name) {
-    return fn.name;
-  }
-  return (fn.toString().trim().match(/^function\s*([^\s(]+)/) || [])[1];
+  return (
+    fn.name ||
+    (fn.toString().trim().match(functionNameRE) || [])[1]
+  );
 };

package/lib/helpers/isMongooseObject.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const isMongooseArray = require('../types/array/isMongooseArray').isMongooseArray;
 /*!
  * Returns if `v` is a mongoose object that has a `toObject()` method we can use.
  *
@@ -10,12 +11,12 @@
  */
 
 module.exports = function(v) {
-  if (v == null) {
-    return false;
-  }
-
-  return v.$__ != null || // Document
-    v.isMongooseArray || // Array or Document Array
-    v.isMongooseBuffer || // Buffer
-    v.$isMongooseMap; // Map
+  return (
+    v != null && (
+      isMongooseArray(v) || // Array or Document Array
+      v.$__ != null || // Document
+      v.isMongooseBuffer || // Buffer
+      v.$isMongooseMap // Map
+    )
+  );
 };

package/lib/helpers/isObject.js

@@ -9,8 +9,8 @@
  */
 
 module.exports = function(arg) {
-  if (Buffer.isBuffer(arg)) {
-    return true;
-  }
-  return Object.prototype.toString.call(arg) === '[object Object]';
+  return (
+    Buffer.isBuffer(arg) ||
+    Object.prototype.toString.call(arg) === '[object Object]'
+  );
 };

package/lib/helpers/model/discriminator.js

@@ -17,6 +17,7 @@ const CUSTOMIZABLE_DISCRIMINATOR_OPTIONS = {
  */
 
 module.exports = function discriminator(model, name, schema, tiedValue, applyPlugins) {
+
   if (!(schema && schema.instanceOfSchema)) {
     throw new Error('You must pass a valid discriminator Schema');
   }
@@ -201,7 +202,7 @@ module.exports = function discriminator(model, name, schema, tiedValue, applyPlu
 
   model.schema.discriminators[name] = schema;
 
-  if (model.discriminators[name]) {
+  if (model.discriminators[name] && !schema.options.overwriteModels) {
     throw new Error('Discriminator with name "' + name + '" already exists');
   }
 

package/lib/helpers/path/parentPaths.js

@@ -1,12 +1,17 @@
 'use strict';
 
+const dotRE = /\./g;
 module.exports = function parentPaths(path) {
-  const pieces = path.split('.');
+  if (path.indexOf('.') === -1) {
+    return [path];
+  }
+  const pieces = path.split(dotRE);
+  const len = pieces.length;
+  const ret = new Array(len);
   let cur = '';
-  const ret = [];
-  for (let i = 0; i < pieces.length; ++i) {
-    cur += (cur.length > 0 ? '.' : '') + pieces[i];
-    ret.push(cur);
+  for (let i = 0; i < len; ++i) {
+    cur += (cur.length !== 0) ? '.' + pieces[i] : pieces[i];
+    ret[i] = cur;
   }
 
   return ret;

package/lib/helpers/populate/assignRawDocsToIdStructure.js

@@ -35,11 +35,13 @@ function assignRawDocsToIdStructure(rawIds, resultDocs, resultOrder, options, re
   let sid;
   let id;
 
-  if (rawIds.isMongooseArrayProxy) {
+  if (utils.isMongooseArray(rawIds)) {
     rawIds = rawIds.__array;
   }
 
-  for (let i = 0; i < rawIds.length; ++i) {
+  let i = 0;
+  const len = rawIds.length;
+  for (i = 0; i < len; ++i) {
     id = rawIds[i];
 
     if (Array.isArray(id)) {

package/lib/helpers/populate/assignVals.js

@@ -241,15 +241,19 @@ function valueFilter(val, assignmentOpts, populateOptions, allIds) {
       }
     }
 
+    const rLen = ret.length;
     // Since we don't want to have to create a new mongoosearray, make sure to
     // modify the array in place
-    while (val.length > ret.length) {
+    while (val.length > rLen) {
       Array.prototype.pop.apply(val, []);
     }
-    for (let i = 0; i < ret.length; ++i) {
-      if (val.isMongooseArrayProxy) {
+    let i = 0;
+    if (utils.isMongooseArray(val)) {
+      for (i = 0; i < rLen; ++i) {
         val.set(i, ret[i], true);
-      } else {
+      }
+    } else {
+      for (i = 0; i < rLen; ++i) {
         val[i] = ret[i];
       }
     }

package/lib/helpers/populate/getModelsMapForPopulate.js

@@ -43,7 +43,7 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
   let allSchemaTypes = getSchemaTypes(model, modelSchema, null, options.path);
   allSchemaTypes = Array.isArray(allSchemaTypes) ? allSchemaTypes : [allSchemaTypes].filter(v => v != null);
 
-  if (allSchemaTypes.length <= 0 && options.strictPopulate !== false && options._localModel != null) {
+  if (allSchemaTypes.length === 0 && options.strictPopulate !== false && options._localModel != null) {
     return new MongooseError('Cannot populate path `' + (options._fullPath || options.path) +
       '` because it is not in your schema. Set the `strictPopulate` option ' +
       'to false to override.');
@@ -607,7 +607,7 @@ function _getLocalFieldValues(doc, localField, model, options, virtual, schema)
   const getters = 'getters' in _populateOptions ?
     _populateOptions.getters :
     get(virtual, 'options.getters', false);
-  if (localFieldGetters.length > 0 && getters) {
+  if (localFieldGetters.length !== 0 && getters) {
     const hydratedDoc = (doc.$__ != null) ? doc : model.hydrate(doc);
     const localFieldValue = utils.getValue(localField, doc);
     if (Array.isArray(localFieldValue)) {
@@ -644,7 +644,7 @@ function convertTo_id(val, schema) {
         rawVal[i] = rawVal[i]._id;
       }
     }
-    if (val.isMongooseArray && val.$schema()) {
+    if (utils.isMongooseArray(val) && val.$schema()) {
       return val.$schema()._castForPopulate(val, val.$parent());
     }
 
@@ -694,7 +694,7 @@ function _findRefPathForDiscriminators(doc, modelSchema, data, options, normaliz
     if (schematype != null &&
         schematype.$isMongooseArray &&
         schematype.caster.discriminators != null &&
-        Object.keys(schematype.caster.discriminators).length > 0) {
+        Object.keys(schematype.caster.discriminators).length !== 0) {
       const subdocs = utils.getValue(cur, doc);
       const remnant = options.path.substring(cur.length + 1);
       const discriminatorKey = schematype.caster.schema.options.discriminatorKey;

package/lib/helpers/populate/markArraySubdocsPopulated.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const utils = require('../../utils');
+
 /*!
  * If populating a path within a document array, make sure each
  * subdoc within the array knows its subpaths are populated.
@@ -29,7 +31,7 @@ module.exports = function markArraySubdocsPopulated(doc, populated) {
         continue;
       }
 
-      if (val.isMongooseDocumentArray) {
+      if (utils.isMongooseDocumentArray(val)) {
         for (let j = 0; j < val.length; ++j) {
           val[j].populated(rest, item._docs[id] == null ? void 0 : item._docs[id][j], item);
         }

package/lib/helpers/populate/modelNamesFromRefPath.js

@@ -7,6 +7,8 @@ const mpath = require('mpath');
 const util = require('util');
 const utils = require('../../utils');
 
+const hasNumericPropRE = /(\.\d+$|\.\d+\.)/g;
+
 module.exports = function modelNamesFromRefPath(refPath, doc, populatedPath, modelSchema, queryProjection) {
   if (refPath == null) {
     return [];
@@ -20,10 +22,9 @@ module.exports = function modelNamesFromRefPath(refPath, doc, populatedPath, mod
   // If populated path has numerics, the end `refPath` should too. For example,
   // if populating `a.0.b` instead of `a.b` and `b` has `refPath = a.c`, we
   // should return `a.0.c` for the refPath.
-  const hasNumericProp = /(\.\d+$|\.\d+\.)/g;
 
-  if (hasNumericProp.test(populatedPath)) {
-    const chunks = populatedPath.split(hasNumericProp);
+  if (hasNumericPropRE.test(populatedPath)) {
+    const chunks = populatedPath.split(hasNumericPropRE);
 
     if (chunks[chunks.length - 1] === '') {
       throw new Error('Can\'t populate individual element in an array');

package/lib/helpers/printJestWarning.js

@@ -6,12 +6,12 @@ if (typeof jest !== 'undefined' && typeof window !== 'undefined') {
   utils.warn('Mongoose: looks like you\'re trying to test a Mongoose app ' +
     'with Jest\'s default jsdom test environment. Please make sure you read ' +
     'Mongoose\'s docs on configuring Jest to test Node.js apps: ' +
-    'http://mongoosejs.com/docs/jest.html');
+    'https://mongoosejs.com/docs/jest.html');
 }
 
 if (typeof jest !== 'undefined' && process.nextTick.toString().indexOf('nextTick') === -1) {
   utils.warn('Mongoose: looks like you\'re trying to test a Mongoose app ' +
     'with Jest\'s mock timers enabled. Please make sure you read ' +
     'Mongoose\'s docs on configuring Jest to test Node.js apps: ' +
-    'http://mongoosejs.com/docs/jest.html');
+    'https://mongoosejs.com/docs/jest.html');
 }

package/lib/helpers/projection/applyProjection.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const hasIncludedChildren = require('./hasIncludedChildren');
+const isExclusive = require('./isExclusive');
+const isInclusive = require('./isInclusive');
+const isPOJO = require('../../utils').isPOJO;
+
+module.exports = function applyProjection(doc, projection, _hasIncludedChildren) {
+  if (projection == null) {
+    return doc;
+  }
+  if (doc == null) {
+    return doc;
+  }
+
+  let exclude = null;
+  if (isInclusive(projection)) {
+    exclude = false;
+  } else if (isExclusive(projection)) {
+    exclude = true;
+  }
+
+  if (exclude == null) {
+    return doc;
+  } else if (exclude) {
+    _hasIncludedChildren = _hasIncludedChildren || hasIncludedChildren(projection);
+    return applyExclusiveProjection(doc, projection, _hasIncludedChildren);
+  } else {
+    _hasIncludedChildren = _hasIncludedChildren || hasIncludedChildren(projection);
+    return applyInclusiveProjection(doc, projection, _hasIncludedChildren);
+  }
+};
+
+function applyExclusiveProjection(doc, projection, hasIncludedChildren, projectionLimb, prefix) {
+  if (doc == null || typeof doc !== 'object') {
+    return doc;
+  }
+  const ret = { ...doc };
+  projectionLimb = prefix ? (projectionLimb || {}) : projection;
+
+  for (const key of Object.keys(ret)) {
+    const fullPath = prefix ? prefix + '.' + key : key;
+    if (projection.hasOwnProperty(fullPath) || projectionLimb.hasOwnProperty(key)) {
+      if (isPOJO(projection[fullPath]) || isPOJO(projectionLimb[key])) {
+        ret[key] = applyExclusiveProjection(ret[key], projection, hasIncludedChildren, projectionLimb[key], fullPath);
+      } else {
+        delete ret[key];
+      }
+    } else if (hasIncludedChildren[fullPath]) {
+      ret[key] = applyExclusiveProjection(ret[key], projection, hasIncludedChildren, projectionLimb[key], fullPath);
+    }
+  }
+  return ret;
+}
+
+function applyInclusiveProjection(doc, projection, hasIncludedChildren, projectionLimb, prefix) {
+  if (doc == null || typeof doc !== 'object') {
+    return doc;
+  }
+  const ret = { ...doc };
+  projectionLimb = prefix ? (projectionLimb || {}) : projection;
+
+  for (const key of Object.keys(ret)) {
+    const fullPath = prefix ? prefix + '.' + key : key;
+    if (projection.hasOwnProperty(fullPath) || projectionLimb.hasOwnProperty(key)) {
+      if (isPOJO(projection[fullPath]) || isPOJO(projectionLimb[key])) {
+        ret[key] = applyInclusiveProjection(ret[key], projection, hasIncludedChildren, projectionLimb[key], fullPath);
+      }
+      continue;
+    } else if (hasIncludedChildren[fullPath]) {
+      ret[key] = applyInclusiveProjection(ret[key], projection, hasIncludedChildren, projectionLimb[key], fullPath);
+    } else {
+      delete ret[key];
+    }
+  }
+  return ret;
+}

package/lib/helpers/projection/hasIncludedChildren.js

@@ -0,0 +1,36 @@
+'use strict';
+
+/*!
+ * Creates an object that precomputes whether a given path has child fields in
+ * the projection.
+ *
+ * ####Example:
+ *     const res = hasIncludedChildren({ 'a.b.c': 0 });
+ *     res.a; // 1
+ *     res['a.b']; // 1
+ *     res['a.b.c']; // 1
+ *     res['a.c']; // undefined
+ */
+
+module.exports = function hasIncludedChildren(fields) {
+  const hasIncludedChildren = {};
+  const keys = Object.keys(fields);
+
+  for (const key of keys) {
+    if (key.indexOf('.') === -1) {
+      hasIncludedChildren[key] = 1;
+      continue;
+    }
+    const parts = key.split('.');
+    let c = parts[0];
+
+    for (let i = 0; i < parts.length; ++i) {
+      hasIncludedChildren[c] = 1;
+      if (i + 1 < parts.length) {
+        c = c + '.' + parts[i + 1];
+      }
+    }
+  }
+
+  return hasIncludedChildren;
+};

package/lib/helpers/projection/isExclusive.js

@@ -21,8 +21,11 @@ module.exports = function isExclusive(projection) {
     while (ki--) {
       // Does this projection explicitly define inclusion/exclusion?
       // Explicitly avoid `$meta` and `$slice`
-      if (keys[ki] !== '_id' && isDefiningProjection(projection[keys[ki]])) {
-        exclude = !projection[keys[ki]];
+      const key = keys[ki];
+      if (key !== '_id' && isDefiningProjection(projection[key])) {
+        exclude = (projection[key] != null && typeof projection[key] === 'object') ?
+          isExclusive(projection[key]) :
+          !projection[key];
         break;
       }
     }