mongoose 6.1.10 → 6.2.3

package/lib/drivers/node-mongodb-native/collection.js

@@ -8,7 +8,6 @@ const MongooseCollection = require('../../collection');
 const MongooseError = require('../../error/mongooseError');
 const Collection = require('mongodb').Collection;
 const ObjectId = require('./objectid');
-const get = require('../../helpers/get');
 const getConstructorName = require('../../helpers/getConstructorName');
 const stream = require('stream');
 const util = require('util');
@@ -76,7 +75,11 @@ function iter(i) {
     const collection = this.collection;
     const args = Array.from(arguments);
     const _this = this;
-    const debug = get(_this, 'conn.base.options.debug');
+    const debug = _this &&
+      _this.conn &&
+      _this.conn.base &&
+      _this.conn.base.options &&
+      _this.conn.base.options.debug;
     const lastArg = arguments[arguments.length - 1];
     const opId = new ObjectId();
 
@@ -84,7 +87,7 @@ function iter(i) {
     if (this.conn.$wasForceClosed) {
       const error = new MongooseError('Connection was force closed');
       if (args.length > 0 &&
-          typeof args[args.length - 1] === 'function') {
+        typeof args[args.length - 1] === 'function') {
         args[args.length - 1](error);
         return;
       } else {
@@ -368,7 +371,12 @@ function format(obj, sub, color, shell) {
           formatDate(x, key, shell);
         } else if (_constructorName === 'ClientSession') {
           x[key] = inspectable('ClientSession("' +
-            get(x[key], 'id.id.buffer', '').toString('hex') + '")');
+            (
+              x[key] &&
+              x[key].id &&
+              x[key].id.id &&
+              x[key].id.id.buffer || ''
+            ).toString('hex') + '")');
         } else if (Array.isArray(x[key])) {
           x[key] = x[key].map(map);
         } else if (error != null) {

package/lib/drivers/node-mongodb-native/connection.js

@@ -137,6 +137,17 @@ NativeConnection.prototype.doClose = function(force, fn) {
     return this;
   }
 
+  let skipCloseClient = false;
+  if (force != null && typeof force === 'object') {
+    skipCloseClient = force.skipCloseClient;
+    force = force.force;
+  }
+
+  if (skipCloseClient) {
+    immediate(() => fn());
+    return this;
+  }
+
   this.client.close(force, (err, res) => {
     // Defer because the driver will wait at least 1ms before finishing closing
     // the pool, see https://github.com/mongodb-js/mongodb-core/blob/a8f8e4ce41936babc3b9112bf42d609779f03b39/lib/connection/pool.js#L1026-L1030.

package/lib/error/cast.js

@@ -5,7 +5,6 @@
  */
 
 const MongooseError = require('./mongooseError');
-const get = require('../helpers/get');
 const util = require('util');
 
 /**
@@ -111,7 +110,9 @@ function getValueType(value) {
 }
 
 function getMessageFormat(schemaType) {
-  const messageFormat = get(schemaType, 'options.cast', null);
+  const messageFormat = schemaType &&
+  schemaType.options &&
+  schemaType.options.cast || null;
   if (typeof messageFormat === 'string') {
     return messageFormat;
   }

package/lib/error/index.js

@@ -181,6 +181,17 @@ MongooseError.OverwriteModelError = require('./overwriteModel');
 
 MongooseError.MissingSchemaError = require('./missingSchema');
 
+/**
+ * Thrown when the MongoDB Node driver can't connect to a valid server
+ * to send an operation to.
+ *
+ * @api public
+ * @memberOf Error
+ * @static MongooseServerSelectionError
+ */
+
+MongooseError.MongooseServerSelectionError = require('./serverSelection');
+
 /**
  * An instance of this error will be returned if you used an array projection
  * and then modified the array in an unsafe way.

package/lib/error/syncIndexes.js

@@ -0,0 +1,30 @@
+'use strict';
+
+/*!
+ * Module dependencies.
+ */
+
+const MongooseError = require('./mongooseError');
+
+/**
+ * SyncIndexes Error constructor.
+ *
+ * @param {String} message
+ * @param {String} errorsMap
+ * @inherits MongooseError
+ * @api private
+ */
+
+class SyncIndexesError extends MongooseError {
+  constructor(message, errorsMap) {
+    super(message);
+    this.errors = errorsMap;
+  }
+}
+
+Object.defineProperty(SyncIndexesError.prototype, 'name', {
+  value: 'SyncIndexesError'
+});
+
+
+module.exports = SyncIndexesError;

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/indexes/decorateDiscriminatorIndexOptions.js

@@ -0,0 +1,14 @@
+'use strict';
+
+module.exports = function decorateDiscriminatorIndexOptions(schema, indexOptions) {
+  // If the model is a discriminator and has an index, add a
+  // partialFilterExpression by default so the index will only apply
+  // to that discriminator.
+  const discriminatorName = schema.discriminatorMapping && schema.discriminatorMapping.value;
+  if (discriminatorName && !('sparse' in indexOptions)) {
+    const discriminatorKey = schema.options.discriminatorKey;
+    indexOptions.partialFilterExpression = indexOptions.partialFilterExpression || {};
+    indexOptions.partialFilterExpression[discriminatorKey] = discriminatorName;
+  }
+  return indexOptions;
+};

package/lib/helpers/indexes/getRelatedIndexes.js

@@ -0,0 +1,59 @@
+'use strict';
+
+function getRelatedSchemaIndexes(model, schemaIndexes) {
+  return getRelatedIndexes({
+    baseModelName: model.baseModelName,
+    discriminatorMapping: model.schema.discriminatorMapping,
+    indexes: schemaIndexes,
+    indexesType: 'schema'
+  });
+}
+
+function getRelatedDBIndexes(model, dbIndexes) {
+  return getRelatedIndexes({
+    baseModelName: model.baseModelName,
+    discriminatorMapping: model.schema.discriminatorMapping,
+    indexes: dbIndexes,
+    indexesType: 'db'
+  });
+}
+
+module.exports = {
+  getRelatedSchemaIndexes,
+  getRelatedDBIndexes
+};
+
+function getRelatedIndexes({
+  baseModelName,
+  discriminatorMapping,
+  indexes,
+  indexesType
+}) {
+  const discriminatorKey = discriminatorMapping && discriminatorMapping.key;
+  const discriminatorValue = discriminatorMapping && discriminatorMapping.value;
+
+  if (!discriminatorKey) {
+    return indexes;
+  }
+
+  const isChildDiscriminatorModel = Boolean(baseModelName);
+  if (isChildDiscriminatorModel) {
+    return indexes.filter(index => {
+      const partialFilterExpression = getPartialFilterExpression(index, indexesType);
+      return partialFilterExpression && partialFilterExpression[discriminatorKey] === discriminatorValue;
+    });
+  }
+
+  return indexes.filter(index => {
+    const partialFilterExpression = getPartialFilterExpression(index, indexesType);
+    return !partialFilterExpression || !partialFilterExpression[discriminatorKey];
+  });
+}
+
+function getPartialFilterExpression(index, indexesType) {
+  if (indexesType === 'schema') {
+    const options = index[1];
+    return options && options.partialFilterExpression;
+  }
+  return index.partialFilterExpression;
+}

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

@@ -172,6 +172,10 @@ module.exports = function assignVals(o) {
       o.allOptions.options[populateModelSymbol] = o.allOptions.model;
       docs[i].$populated(_path, o.unpopulatedValues[i], o.allOptions.options);
 
+      if (valueToSet != null && valueToSet.$__ != null) {
+        valueToSet.$__.wasPopulated = { value: o.unpopulatedValues[i] };
+      }
+
       if (valueToSet instanceof Map && !valueToSet.$isMongooseMap) {
         valueToSet = new MongooseMap(valueToSet, _path, docs[i], docs[i].schema.path(_path).$__schemaType);
       }
@@ -241,15 +245,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];
       }
     }