mongoose 5.5.0 → 5.5.4

package/lib/schematype.js

@@ -51,6 +51,21 @@ function SchemaType(path, options, instance) {
     if (this[prop] && typeof this[prop] === 'function') {
       // { unique: true, index: true }
       if (prop === 'index' && this._index) {
+        if (options.index === false) {
+          const index = this._index;
+          if (typeof index === 'object' && index != null) {
+            if (index.unique) {
+              throw new Error('Path "' + this.path + '" may not have `index` ' +
+                'set to false and `unique` set to true');
+            }
+            if (index.sparse) {
+              throw new Error('Path "' + this.path + '" may not have `index` ' +
+                'set to false and `sparse` set to true');
+            }
+          }
+
+          this._index = false;
+        }
         continue;
       }
 
@@ -263,6 +278,14 @@ SchemaType.prototype.unique = function(bool) {
  */
 
 SchemaType.prototype.text = function(bool) {
+  if (this._index === false) {
+    if (!bool) {
+      return;
+    }
+    throw new Error('Path "' + this.path + '" may not have `index` set to ' +
+      'false and `text` set to true');
+  }
+
   if (this._index === null || this._index === undefined ||
     typeof this._index === 'boolean') {
     this._index = {};
@@ -288,8 +311,15 @@ SchemaType.prototype.text = function(bool) {
  */
 
 SchemaType.prototype.sparse = function(bool) {
-  if (this._index === null || this._index === undefined ||
-    typeof this._index === 'boolean') {
+  if (this._index === false) {
+    if (!bool) {
+      return;
+    }
+    throw new Error('Path "' + this.path + '" may not have `index` set to ' +
+      'false and `sparse` set to true');
+  }
+
+  if (this._index == null || typeof this._index === 'boolean') {
     this._index = {};
   } else if (typeof this._index === 'string') {
     this._index = {type: this._index};

package/lib/types/array.js

@@ -13,6 +13,8 @@ const internalToObjectOptions = require('../options').internalToObjectOptions;
 const utils = require('../utils');
 const util = require('util');
 
+const arrayParentSymbol = require('../helpers/symbols').arrayParentSymbol;
+const arraySchemaSymbol = require('../helpers/symbols').arraySchemaSymbol;
 const isMongooseObject = utils.isMongooseObject;
 
 /**
@@ -43,7 +45,7 @@ function MongooseArray(values, path, doc) {
   arr.isMongooseArray = true;
   arr.validators = [];
   arr._atomics = {};
-  arr._schema = void 0;
+  arr[arraySchemaSymbol] = void 0;
   if (util.inspect.custom) {
     arr[util.inspect.custom] = arr.inspect;
   }
@@ -53,8 +55,8 @@ function MongooseArray(values, path, doc) {
   // RB Jun 17, 2015 updated to check for presence of expected paths instead
   // to make more proof against unusual node environments
   if (doc && doc instanceof Document) {
-    arr._parent = doc;
-    arr._schema = doc.schema.path(path);
+    arr[arrayParentSymbol] = doc;
+    arr[arraySchemaSymbol] = doc.schema.path(path);
   }
 
   return arr;
@@ -77,15 +79,21 @@ MongooseArray.mixin = {
 
   _atomics: undefined,
 
-  /**
-   * Parent owner document
-   *
-   * @property _parent
-   * @api private
-   * @memberOf MongooseArray
+  /*!
+   * ignore
    */
 
-  _parent: undefined,
+  $parent: function() {
+    return this[arrayParentSymbol];
+  },
+
+  /*!
+   * ignore
+   */
+
+  $schema: function() {
+    return this[arraySchemaSymbol];
+  },
 
   /**
    * Casts a member based on this arrays schema.
@@ -101,8 +109,8 @@ MongooseArray.mixin = {
     let populated = false;
     let Model;
 
-    if (this._parent) {
-      populated = this._parent.populated(this._path, true);
+    if (this[arrayParentSymbol]) {
+      populated = this[arrayParentSymbol].populated(this._path, true);
     }
 
     if (populated && value !== null && value !== undefined) {
@@ -123,10 +131,10 @@ MongooseArray.mixin = {
       if (!isDisc) {
         value = new Model(value);
       }
-      return this._schema.caster.applySetters(value, this._parent, true);
+      return this[arraySchemaSymbol].caster.applySetters(value, this[arrayParentSymbol], true);
     }
 
-    return this._schema.caster.applySetters(value, this._parent, false);
+    return this[arraySchemaSymbol].caster.applySetters(value, this[arrayParentSymbol], false);
   },
 
   /**
@@ -142,7 +150,7 @@ MongooseArray.mixin = {
    */
 
   _markModified: function(elem, embeddedPath) {
-    const parent = this._parent;
+    const parent = this[arrayParentSymbol];
     let dirtyPath;
 
     if (parent) {
@@ -179,7 +187,7 @@ MongooseArray.mixin = {
       // $set takes precedence over all other ops.
       // mark entire array modified.
       this._atomics = {$set: val};
-      cleanModifiedSubpaths(this._parent, this._path);
+      cleanModifiedSubpaths(this[arrayParentSymbol], this._path);
       this._markModified();
       return this;
     }
@@ -189,7 +197,7 @@ MongooseArray.mixin = {
     // reset pop/shift after save
     if (op === '$pop' && !('$pop' in atomics)) {
       const _this = this;
-      this._parent.once('save', function() {
+      this[arrayParentSymbol].once('save', function() {
         _this._popped = _this._shifted = null;
       });
     }
@@ -322,7 +330,7 @@ MongooseArray.mixin = {
   push: function() {
     _checkManualPopulation(this, arguments);
     let values = [].map.call(arguments, this._mapCast, this);
-    values = this._schema.applySetters(values, this._parent, undefined,
+    values = this[arraySchemaSymbol].applySetters(values, this[arrayParentSymbol], undefined,
       undefined, { skipDocumentArrayCast: true });
     const ret = [].push.apply(this, values);
 
@@ -527,7 +535,7 @@ MongooseArray.mixin = {
 
   pull: function() {
     const values = [].map.call(arguments, this._cast, this);
-    const cur = this._parent.get(this._path);
+    const cur = this[arrayParentSymbol].get(this._path);
     let i = cur.length;
     let mem;
 
@@ -559,7 +567,7 @@ MongooseArray.mixin = {
     // `doc.children[1].name = 'test';` followed by
     // `doc.children.remove(doc.children[0]);`. In this case we fall back
     // to a `$set` on the whole array. See #3511
-    if (cleanModifiedSubpaths(this._parent, this._path) > 0) {
+    if (cleanModifiedSubpaths(this[arrayParentSymbol], this._path) > 0) {
       this._registerAtomic('$set', this);
     }
 
@@ -613,7 +621,7 @@ MongooseArray.mixin = {
     _checkManualPopulation(this, arguments);
 
     let values = [].map.call(arguments, this._cast, this);
-    values = this._schema.applySetters(values, this._parent);
+    values = this[arraySchemaSymbol].applySetters(values, this[arrayParentSymbol]);
     [].unshift.apply(this, values);
     this._registerAtomic('$set', this);
     this._markModified();
@@ -659,7 +667,7 @@ MongooseArray.mixin = {
     _checkManualPopulation(this, arguments);
 
     let values = [].map.call(arguments, this._mapCast, this);
-    values = this._schema.applySetters(values, this._parent);
+    values = this[arraySchemaSymbol].applySetters(values, this[arrayParentSymbol]);
     const added = [];
     let type = '';
     if (values[0] instanceof EmbeddedDocument) {
@@ -787,6 +795,20 @@ MongooseArray.mixin = {
       }
     }
     return -1;
+  },
+
+  /**
+   * Return whether or not the `obj` is included in the array.
+   *
+   * @param {Object} obj the item to check
+   * @return {Boolean}
+   * @api public
+   * @method includes
+   * @memberOf MongooseArray
+   */
+
+  includes: function includes(obj) {
+    return this.indexOf(obj) !== -1;
   }
 };
 
@@ -831,11 +853,13 @@ function _isAllSubdocs(docs, ref) {
  */
 
 function _checkManualPopulation(arr, docs) {
-  const ref = get(arr, '_schema.caster.options.ref', null);
+  const ref = arr == null ?
+    null :
+    get(arr[arraySchemaSymbol], 'caster.options.ref', null);
   if (arr.length === 0 &&
       docs.length > 0) {
     if (_isAllSubdocs(docs, ref)) {
-      arr._parent.populated(arr._path, [], { model: docs[0].constructor });
+      arr[arrayParentSymbol].populated(arr._path, [], { model: docs[0].constructor });
     }
   }
 }

package/lib/types/documentarray.js

@@ -8,12 +8,13 @@ const Document = require('../document');
 const MongooseArray = require('./array');
 const ObjectId = require('./objectid');
 const castObjectId = require('../cast/objectid');
-const get = require('../helpers/get');
 const getDiscriminatorByValue = require('../queryhelpers').getDiscriminatorByValue;
 const internalToObjectOptions = require('../options').internalToObjectOptions;
 const util = require('util');
 const utils = require('../utils');
 
+const arrayParentSymbol = require('../helpers/symbols').arrayParentSymbol;
+const arraySchemaSymbol = require('../helpers/symbols').arraySchemaSymbol;
 const documentArrayParent = require('../helpers/symbols').documentArrayParent;
 
 /*!
@@ -49,14 +50,14 @@ function MongooseDocumentArray(values, path, doc) {
     isMongooseDocumentArray: true,
     validators: [],
     _atomics: {},
-    _schema: void 0,
+    [arraySchemaSymbol]: void 0,
     _handlers: void 0
   };
 
   if (Array.isArray(values)) {
     if (values instanceof CoreMongooseArray &&
         values._path === path &&
-        values._parent === doc) {
+        values[arrayParentSymbol] === doc) {
       props._atomics = Object.assign({}, values._atomics);
     }
     values.forEach(v => {
@@ -93,22 +94,24 @@ function MongooseDocumentArray(values, path, doc) {
   // RB Jun 17, 2015 updated to check for presence of expected paths instead
   // to make more proof against unusual node environments
   if (doc && doc instanceof Document) {
-    arr._parent = doc;
-    arr._schema = doc.schema.path(path);
+    arr[arrayParentSymbol] = doc;
+    arr[arraySchemaSymbol] = doc.schema.path(path);
 
     // `schema.path()` doesn't drill into nested arrays properly yet, see
     // gh-6398, gh-6602. This is a workaround because nested arrays are
     // always plain non-document arrays, so once you get to a document array
     // nesting is done. Matryoshka code.
-    while (get(arr, '_schema.$isMongooseArray') &&
-        !get(arr, '_schema.$isMongooseDocumentArray')) {
-      arr._schema = arr._schema.casterConstructor;
+    while (arr != null &&
+        arr[arraySchemaSymbol] != null &&
+        arr[arraySchemaSymbol].$isMongooseArray &&
+        !arr[arraySchemaSymbol].$isMongooseDocumentArray) {
+      arr[arraySchemaSymbol] = arr[arraySchemaSymbol].casterConstructor;
     }
 
     // Tricky but this may be a document array embedded in a normal array,
     // in which case `path` would point to the embedded array. See #6405, #6398
-    if (arr._schema && !arr._schema.$isMongooseDocumentArray) {
-      arr._schema = arr._schema.casterConstructor;
+    if (arr[arraySchemaSymbol] && !arr[arraySchemaSymbol].$isMongooseDocumentArray) {
+      arr[arraySchemaSymbol] = arr[arraySchemaSymbol].casterConstructor;
     }
 
     arr._handlers = {
@@ -144,7 +147,7 @@ MongooseDocumentArray.mixin = {
    */
 
   _cast: function(value, index) {
-    let Constructor = this._schema.casterConstructor;
+    let Constructor = this[arraySchemaSymbol].casterConstructor;
     const isInstance = Constructor.$isMongooseDocumentArray ?
       value && value.isMongooseDocumentArray :
       value instanceof Constructor;
@@ -153,7 +156,7 @@ MongooseDocumentArray.mixin = {
         (value && value.constructor && value.constructor.baseCasterConstructor === Constructor)) {
       if (!(value[documentArrayParent] && value.__parentArray)) {
         // value may have been created using array.create()
-        value[documentArrayParent] = this._parent;
+        value[documentArrayParent] = this[arrayParentSymbol];
         value.__parentArray = this;
       }
       value.$setIndex(index);
@@ -293,7 +296,7 @@ MongooseDocumentArray.mixin = {
    */
 
   create: function(obj) {
-    let Constructor = this._schema.casterConstructor;
+    let Constructor = this[arraySchemaSymbol].casterConstructor;
     if (obj &&
         Constructor.discriminators &&
         Constructor.schema &&

package/lib/types/embedded.js

@@ -30,7 +30,7 @@ const validatorErrorSymbol = require('../helpers/symbols').validatorErrorSymbol;
 function EmbeddedDocument(obj, parentArr, skipId, fields, index) {
   if (parentArr) {
     this.__parentArray = parentArr;
-    this[documentArrayParent] = parentArr._parent;
+    this[documentArrayParent] = parentArr.$parent();
   } else {
     this.__parentArray = undefined;
     this[documentArrayParent] = undefined;

package/lib/types/map.js

@@ -83,6 +83,11 @@ class MongooseMap extends Map {
     }
   }
 
+  delete(key) {
+    this.set(key, undefined);
+    super.delete(key);
+  }
+
   toBSON() {
     return new Map(this);
   }

package/lib/types/subdocument.js

@@ -18,13 +18,30 @@ module.exports = Subdocument;
 
 function Subdocument(value, fields, parent, skipId, options) {
   this.$isSingleNested = true;
+
+  const hasPriorDoc = options != null && options.priorDoc;
+  let initedPaths = null;
+  if (hasPriorDoc) {
+    this._doc = Object.assign({}, options.priorDoc._doc);
+    delete this._doc[this.schema.options.discriminatorKey];
+    initedPaths = Object.keys(options.priorDoc._doc || {}).
+      filter(key => key !== this.schema.options.discriminatorKey);
+  }
   if (parent != null) {
     // If setting a nested path, should copy isNew from parent re: gh-7048
     options = Object.assign({}, options, { isNew: parent.isNew });
   }
   Document.call(this, value, fields, skipId, options);
 
-  delete this.$__.$options.priorDoc;
+  if (hasPriorDoc) {
+    for (const key of initedPaths) {
+      if (!this.$__.activePaths.states.modify[key] &&
+          !this.$__.activePaths.states.default[key] &&
+          !this.$__.$setCalled.has(key)) {
+        delete this._doc[key];
+      }
+    }
+  }
 }
 
 Subdocument.prototype = Object.create(Document.prototype);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "5.5.0",
+  "version": "5.5.4",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -25,7 +25,7 @@
     "mongodb": "3.2.2",
     "mongodb-core": "3.2.2",
     "mongoose-legacy-pluralize": "1.0.2",
-    "mpath": "0.5.1",
+    "mpath": "0.5.2",
     "mquery": "3.2.0",
     "ms": "2.1.1",
     "regexp-clone": "0.0.1",