mongoose 5.7.4 → 5.7.8

package/lib/options/SchemaNumberOptions.js

@@ -2,6 +2,19 @@
 
 const SchemaTypeOptions = require('./SchemaTypeOptions');
 
+/**
+ * The options defined on a Number schematype.
+ *
+ * ####Example:
+ *
+ *     const schema = new Schema({ count: Number });
+ *     schema.path('count').options; // SchemaNumberOptions instance
+ *
+ * @api public
+ * @inherits SchemaTypeOptions
+ * @constructor SchemaNumberOptions
+ */
+
 class SchemaNumberOptions extends SchemaTypeOptions {}
 
 const opts = {

package/lib/options/SchemaObjectIdOptions.js

@@ -2,6 +2,19 @@
 
 const SchemaTypeOptions = require('./SchemaTypeOptions');
 
+/**
+ * The options defined on an ObjectId schematype.
+ *
+ * ####Example:
+ *
+ *     const schema = new Schema({ testId: mongoose.ObjectId });
+ *     schema.path('testId').options; // SchemaObjectIdOptions instance
+ *
+ * @api public
+ * @inherits SchemaTypeOptions
+ * @constructor SchemaObjectIdOptions
+ */
+
 class SchemaObjectIdOptions extends SchemaTypeOptions {}
 
 const opts = {

package/lib/options/SchemaStringOptions.js

@@ -2,6 +2,19 @@
 
 const SchemaTypeOptions = require('./SchemaTypeOptions');
 
+/**
+ * The options defined on a string schematype.
+ *
+ * ####Example:
+ *
+ *     const schema = new Schema({ name: String });
+ *     schema.path('name').options; // SchemaStringOptions instance
+ *
+ * @api public
+ * @inherits SchemaTypeOptions
+ * @constructor SchemaStringOptions
+ */
+
 class SchemaStringOptions extends SchemaTypeOptions {}
 
 const opts = {
@@ -75,6 +88,32 @@ Object.defineProperty(SchemaStringOptions.prototype, 'trim', opts);
 
 Object.defineProperty(SchemaStringOptions.prototype, 'uppercase', opts);
 
+/**
+ * If set, Mongoose will add a custom validator that ensures the given
+ * string's `length` is at least the given number.
+ *
+ * @api public
+ * @property minlength
+ * @memberOf SchemaStringOptions
+ * @type Number
+ * @instance
+ */
+
+Object.defineProperty(SchemaStringOptions.prototype, 'minlength', opts);
+
+/**
+ * If set, Mongoose will add a custom validator that ensures the given
+ * string's `length` is at most the given number.
+ *
+ * @api public
+ * @property maxlength
+ * @memberOf SchemaStringOptions
+ * @type Number
+ * @instance
+ */
+
+Object.defineProperty(SchemaStringOptions.prototype, 'maxlength', opts);
+
 /*!
  * ignore
  */

package/lib/options/SchemaTypeOptions.js

@@ -2,6 +2,18 @@
 
 const utils = require('../utils');
 
+/**
+ * The options defined on a schematype.
+ *
+ * ####Example:
+ *
+ *     const schema = new Schema({ name: String });
+ *     schema.path('name').options instanceof mongoose.SchemaTypeOptions; // true
+ *
+ * @api public
+ * @constructor SchemaTypeOptions
+ */
+
 class SchemaTypeOptions {
   constructor(obj) {
     if (obj == null) {
@@ -95,7 +107,8 @@ Object.defineProperty(SchemaTypeOptions.prototype, 'ref', opts);
 Object.defineProperty(SchemaTypeOptions.prototype, 'select', opts);
 
 /**
- * If truthy, Mongoose will build an index on this path when the model is
+ * If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose will
+ * build an index on this path when the model is
  * compiled.
  *
  * @api public
@@ -108,7 +121,8 @@ Object.defineProperty(SchemaTypeOptions.prototype, 'select', opts);
 Object.defineProperty(SchemaTypeOptions.prototype, 'index', opts);
 
 /**
- * If truthy, Mongoose will build a unique index on this path when the
+ * If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose
+ * will build a unique index on this path when the
  * model is compiled. [The `unique` option is **not** a validator](/docs/validation.html#the-unique-option-is-not-a-validator).
  *
  * @api public
@@ -121,7 +135,8 @@ Object.defineProperty(SchemaTypeOptions.prototype, 'index', opts);
 Object.defineProperty(SchemaTypeOptions.prototype, 'unique', opts);
 
 /**
- * If truthy, Mongoose will disallow changes to this path once the document
+ * If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose will
+ * disallow changes to this path once the document
  * is saved to the database for the first time. Read more about [immutability in Mongoose here](http://thecodebarbarian.com/whats-new-in-mongoose-5-6-immutable-properties.html).
  *
  * @api public
@@ -134,7 +149,8 @@ Object.defineProperty(SchemaTypeOptions.prototype, 'unique', opts);
 Object.defineProperty(SchemaTypeOptions.prototype, 'immutable', opts);
 
 /**
- * If truthy, Mongoose will build a sparse index on this path.
+ * If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose will
+ * build a sparse index on this path.
  *
  * @api public
  * @property sparse
@@ -146,7 +162,8 @@ Object.defineProperty(SchemaTypeOptions.prototype, 'immutable', opts);
 Object.defineProperty(SchemaTypeOptions.prototype, 'sparse', opts);
 
 /**
- * If truthy, Mongoose will build a text index on this path.
+ * If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose
+ * will build a text index on this path.
  *
  * @api public
  * @property text

package/lib/query.js

@@ -1941,7 +1941,7 @@ Query.prototype._find = wrapThunk(function(callback) {
  *     // Using callbacks
  *     Movie.find({ year: { $gte: 1980, $lte: 1989 } }, function(err, arr) {});
  *
- * @param {Object} [filter] mongodb selector. If not specified, returns all documents.
+ * @param {Object|ObjectId} [filter] mongodb selector. If not specified, returns all documents.
  * @param {Function} [callback]
  * @return {Query} this
  * @api public

package/lib/queryhelpers.js

@@ -107,7 +107,7 @@ exports.getDiscriminatorByValue = getDiscriminatorByValue;
  * @param {Object} doc
  * @param {Object} fields
  *
- * @return {Model}
+ * @return {Document}
  */
 exports.createModel = function createModel(model, doc, fields, userProvidedFields) {
   model.hooks.execPreSync('createModel', doc);

package/lib/schema/SingleNestedPath.js

@@ -274,17 +274,19 @@ SingleNestedPath.prototype.doValidateSync = function(value, scope, options) {
  *     const shapeSchema = Schema({ name: String }, { discriminatorKey: 'kind' });
  *     const schema = Schema({ shape: shapeSchema });
  *
- *     const singleNestedPath = parentSchema.path('child');
+ *     const singleNestedPath = parentSchema.path('shape');
  *     singleNestedPath.discriminator('Circle', Schema({ radius: Number }));
  *
  * @param {String} name
  * @param {Schema} schema fields to add to the schema for instances of this sub-class
+ * @param {String} [value] the string stored in the `discriminatorKey` property. If not specified, Mongoose uses the `name` parameter.
+ * @return {Function} the constructor Mongoose will use for creating instances of this discriminator model
  * @see discriminators /docs/discriminators.html
  * @api public
  */
 
-SingleNestedPath.prototype.discriminator = function(name, schema, tiedValue) {
-  discriminator(this.caster, name, schema, tiedValue);
+SingleNestedPath.prototype.discriminator = function(name, schema, value) {
+  discriminator(this.caster, name, schema, value);
 
   this.caster.discriminators[name] = _createConstructor(schema, this.caster);
 

package/lib/schema/array.js

@@ -196,8 +196,8 @@ SchemaArray.prototype.checkRequired = function checkRequired(value, doc) {
  */
 
 SchemaArray.prototype.enum = function() {
-  let arr = this; /* eslint consistent-this: 0 */
-  while (true) { /* eslint no-constant-condition: 0 */
+  let arr = this;
+  while (true) {
     const instance = get(arr, 'caster.instance');
     if (instance === 'Array') {
       arr = arr.caster;

package/lib/schema/documentarray.js

@@ -9,6 +9,7 @@ const CastError = require('../error/cast');
 const EventEmitter = require('events').EventEmitter;
 const SchemaType = require('../schematype');
 const discriminator = require('../helpers/model/discriminator');
+const get = require('../helpers/get');
 const util = require('util');
 const utils = require('../utils');
 const getConstructor = require('../helpers/discriminator/getConstructor');
@@ -29,7 +30,7 @@ let Subdocument;
  * @api public
  */
 
-function DocumentArray(key, schema, options, schemaOptions) {
+function DocumentArrayPath(key, schema, options, schemaOptions) {
   const EmbeddedDocument = _createConstructor(schema, options);
   EmbeddedDocument.prototype.$basePath = key;
 
@@ -54,6 +55,17 @@ function DocumentArray(key, schema, options, schemaOptions) {
       return arr;
     });
   }
+
+  const parentSchemaType = this;
+  this.$embeddedSchemaType = new SchemaType(key + '.$', {
+    required: get(this, 'schemaOptions.required', false)
+  });
+  this.$embeddedSchemaType.cast = function(value, doc, init) {
+    return parentSchemaType.cast(value, doc, init)[0];
+  };
+  this.$embeddedSchemaType.$isMongooseDocumentArrayElement = true;
+  this.$embeddedSchemaType.caster = this.Constructor;
+  this.$embeddedSchemaType.schema = this.schema;
 }
 
 /**
@@ -62,24 +74,23 @@ function DocumentArray(key, schema, options, schemaOptions) {
  *
  * @api public
  */
-DocumentArray.schemaName = 'DocumentArray';
+DocumentArrayPath.schemaName = 'DocumentArray';
 
 /**
  * Options for all document arrays.
  *
  * - `castNonArrays`: `true` by default. If `false`, Mongoose will throw a CastError when a value isn't an array. If `true`, Mongoose will wrap the provided value in an array before casting.
  *
- * @static options
  * @api public
  */
 
-DocumentArray.options = { castNonArrays: true };
+DocumentArrayPath.options = { castNonArrays: true };
 
 /*!
  * Inherits from ArrayType.
  */
-DocumentArray.prototype = Object.create(ArrayType.prototype);
-DocumentArray.prototype.constructor = DocumentArray;
+DocumentArrayPath.prototype = Object.create(ArrayType.prototype);
+DocumentArrayPath.prototype.constructor = DocumentArrayPath;
 
 /*!
  * Ignore
@@ -122,11 +133,25 @@ function _createConstructor(schema, options, baseClass) {
   return EmbeddedDocument;
 }
 
-/*!
- * Ignore
+/**
+ * Adds a discriminator to this document array.
+ *
+ * ####Example:
+ *     const shapeSchema = Schema({ name: String }, { discriminatorKey: 'kind' });
+ *     const schema = Schema({ shapes: [shapeSchema] });
+ *
+ *     const docArrayPath = parentSchema.path('shapes');
+ *     docArrayPath.discriminator('Circle', Schema({ radius: Number }));
+ *
+ * @param {String} name
+ * @param {Schema} schema fields to add to the schema for instances of this sub-class
+ * @param {String} [value] the string stored in the `discriminatorKey` property. If not specified, Mongoose uses the `name` parameter.
+ * @see discriminators /docs/discriminators.html
+ * @return {Function} the constructor Mongoose will use for creating instances of this discriminator model
+ * @api public
  */
 
-DocumentArray.prototype.discriminator = function(name, schema, tiedValue) {
+DocumentArrayPath.prototype.discriminator = function(name, schema, tiedValue) {
   if (typeof name === 'function') {
     name = utils.getFunctionName(name);
   }
@@ -155,7 +180,7 @@ DocumentArray.prototype.discriminator = function(name, schema, tiedValue) {
  * @api private
  */
 
-DocumentArray.prototype.doValidate = function(array, fn, scope, options) {
+DocumentArrayPath.prototype.doValidate = function(array, fn, scope, options) {
   // lazy load
   MongooseDocumentArray || (MongooseDocumentArray = require('../types/documentarray'));
 
@@ -231,7 +256,7 @@ DocumentArray.prototype.doValidate = function(array, fn, scope, options) {
  * @api private
  */
 
-DocumentArray.prototype.doValidateSync = function(array, scope) {
+DocumentArrayPath.prototype.doValidateSync = function(array, scope) {
   const schemaTypeError = SchemaType.prototype.doValidateSync.call(this, array, scope);
   if (schemaTypeError != null) {
     schemaTypeError.$isArrayValidatorError = true;
@@ -277,7 +302,7 @@ DocumentArray.prototype.doValidateSync = function(array, scope) {
  * ignore
  */
 
-DocumentArray.prototype.getDefault = function(scope) {
+DocumentArrayPath.prototype.getDefault = function(scope) {
   let ret = typeof this.defaultValue === 'function'
     ? this.defaultValue.call(scope)
     : this.defaultValue;
@@ -316,7 +341,7 @@ DocumentArray.prototype.getDefault = function(scope) {
  * @api private
  */
 
-DocumentArray.prototype.cast = function(value, doc, init, prev, options) {
+DocumentArrayPath.prototype.cast = function(value, doc, init, prev, options) {
   // lazy load
   MongooseDocumentArray || (MongooseDocumentArray = require('../types/documentarray'));
 
@@ -326,7 +351,7 @@ DocumentArray.prototype.cast = function(value, doc, init, prev, options) {
   const _opts = { transform: false, virtuals: false };
 
   if (!Array.isArray(value)) {
-    if (!init && !DocumentArray.options.castNonArrays) {
+    if (!init && !DocumentArrayPath.options.castNonArrays) {
       throw new CastError('DocumentArray', util.inspect(value), this.path);
     }
     // gh-2442 mark whole array as modified if we're initializing a doc from
@@ -416,7 +441,7 @@ DocumentArray.prototype.cast = function(value, doc, init, prev, options) {
  * ignore
  */
 
-DocumentArray.prototype.clone = function() {
+DocumentArrayPath.prototype.clone = function() {
   const options = Object.assign({}, this.options);
   const schematype = new this.constructor(this.path, this.schema, options, this.schemaOptions);
   schematype.validators = this.validators.slice();
@@ -429,7 +454,7 @@ DocumentArray.prototype.clone = function() {
  * Scopes paths selected in a query to this array.
  * Necessary for proper default application of subdocument values.
  *
- * @param {DocumentArray} array - the array to scope `fields` paths
+ * @param {DocumentArrayPath} array - the array to scope `fields` paths
  * @param {Object|undefined} fields - the root fields selected in the query
  * @param {Boolean|undefined} init - if we are being created part of a query result
  */
@@ -469,4 +494,4 @@ function scopePaths(array, fields, init) {
  * Module exports.
  */
 
-module.exports = DocumentArray;
+module.exports = DocumentArrayPath;

package/lib/schema/string.js

@@ -43,7 +43,12 @@ SchemaString.schemaName = 'String';
  */
 SchemaString.prototype = Object.create(SchemaType.prototype);
 SchemaString.prototype.constructor = SchemaString;
-SchemaString.prototype.OptionsConstructor = SchemaStringOptions;
+Object.defineProperty(SchemaString.prototype, 'OptionsConstructor', {
+  configurable: false,
+  enumerable: false,
+  writable: false,
+  value: SchemaStringOptions
+});
 
 /*!
  * ignore
@@ -574,17 +579,23 @@ function handleArray(val) {
   });
 }
 
-SchemaString.prototype.$conditionalHandlers =
-    utils.options(SchemaType.prototype.$conditionalHandlers, {
-      $all: handleArray,
-      $gt: handleSingle,
-      $gte: handleSingle,
-      $lt: handleSingle,
-      $lte: handleSingle,
-      $options: String,
-      $regex: handleSingle,
-      $not: handleSingle
-    });
+const $conditionalHandlers = utils.options(SchemaType.prototype.$conditionalHandlers, {
+  $all: handleArray,
+  $gt: handleSingle,
+  $gte: handleSingle,
+  $lt: handleSingle,
+  $lte: handleSingle,
+  $options: String,
+  $regex: handleSingle,
+  $not: handleSingle
+});
+
+Object.defineProperty(SchemaString.prototype, '$conditionalHandlers', {
+  configurable: false,
+  enumerable: false,
+  writable: false,
+  value: Object.freeze($conditionalHandlers)
+});
 
 /**
  * Casts contents for queries.

package/lib/schema.js

@@ -402,7 +402,6 @@ Schema.prototype.add = function add(obj, prefix) {
   // the `_id` option. This behavior never worked before 5.4.11 but numerous
   // codebases use it (see gh-7516, gh-7512).
   if (obj._id === false && prefix == null) {
-    delete obj._id;
     this.options._id = false;
   }
 
@@ -417,6 +416,10 @@ Schema.prototype.add = function add(obj, prefix) {
       throw new TypeError('Invalid value for schema path `' + fullPath +
         '`, got value "' + obj[key] + '"');
     }
+    // Retain `_id: false` but don't set it as a path, re: gh-8274.
+    if (key === '_id' && obj[key] === false) {
+      continue;
+    }
 
     if (Array.isArray(obj[key]) && obj[key].length === 1 && obj[key][0] == null) {
       throw new TypeError('Invalid value for schema Array path `' + fullPath +
@@ -1179,16 +1182,7 @@ function getPositionalPathType(self, path) {
 
     if (i === last && val && !/\D/.test(subpath)) {
       if (val.$isMongooseDocumentArray) {
-        const oldVal = val;
-        val = new SchemaType(subpath, {
-          required: get(val, 'schemaOptions.required', false)
-        });
-        val.cast = function(value, doc, init) {
-          return oldVal.cast(value, doc, init)[0];
-        };
-        val.$isMongooseDocumentArrayElement = true;
-        val.caster = oldVal.caster;
-        val.schema = oldVal.schema;
+        val = val.$embeddedSchemaType;
       } else if (val instanceof MongooseTypes.Array) {
         // StringSchema, NumberSchema, etc
         val = val.caster;
@@ -1637,8 +1631,8 @@ Schema.prototype.indexes = function() {
  * @param {String|Model} [options.ref] model name or model instance. Marks this as a [populate virtual](populate.html#populate-virtuals).
  * @param {String|Function} [options.localField] Required for populate virtuals. See [populate virtual docs](populate.html#populate-virtuals) for more information.
  * @param {String|Function} [options.foreignField] Required for populate virtuals. See [populate virtual docs](populate.html#populate-virtuals) for more information.
- * @param {Boolean|Function} [options.justOne=false] Only works with populate virtuals. If truthy, will be a single doc or `null`. Otherwise, the populate virtual will be an array.
- * @param {Boolean} [options.count=false] Only works with populate virtuals. If truthy, this populate virtual will contain the number of documents rather than the documents themselves when you `populate()`.
+ * @param {Boolean|Function} [options.justOne=false] Only works with populate virtuals. If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), will be a single doc or `null`. Otherwise, the populate virtual will be an array.
+ * @param {Boolean} [options.count=false] Only works with populate virtuals. If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), this populate virtual will contain the number of documents rather than the documents themselves when you `populate()`.
  * @return {VirtualType}
  */
 

package/lib/schematype.js

@@ -29,7 +29,7 @@ const ValidatorError = MongooseError.ValidatorError;
  *     schema.path('name') instanceof SchemaType; // true
  *
  * @param {String} path
- * @param {Object} [options]
+ * @param {SchemaTypeOptions} [options] See [SchemaTypeOptions docs](/docs/api/schematypeoptions.html)
  * @param {String} [instance]
  * @api public
  */
@@ -664,7 +664,7 @@ SchemaType.prototype.get = function(fn) {
  *     Product.on('error', handleError);
  *
  * @param {RegExp|Function|Object} obj validator function, or hash describing options
- * @param {Function} [obj.validator] validator function. If the validator function returns `undefined` or a truthy value, validation succeeds. If it returns falsy (except `undefined`) or throws an error, validation fails.
+ * @param {Function} [obj.validator] validator function. If the validator function returns `undefined` or a truthy value, validation succeeds. If it returns [falsy](https://masteringjs.io/tutorials/fundamentals/falsy) (except `undefined`) or throws an error, validation fails.
  * @param {String|Function} [obj.message] optional error message. If function, should return the error message as a string
  * @param {Boolean} [obj.propsParameter=false] If true, Mongoose will pass the validator properties object (with the `validator` function, `message`, etc.) as the 2nd arg to the validator function. This is disabled by default because many validators [rely on positional args](https://github.com/chriso/validator.js#validators), so turning this on may cause unpredictable behavior in external validators.
  * @param {String|Function} [errorMsg] optional error message. If function, should return the error message as a string
@@ -1265,7 +1265,7 @@ SchemaType._isRef = function(self, value, doc, init) {
     // - setting / pushing values after population
     const path = doc.$__fullPath(self.path);
     const owner = doc.ownerDocument ? doc.ownerDocument() : doc;
-    ref = owner.populated(path);
+    ref = owner.populated(path) || doc.populated(self.path);
   }
 
   if (ref) {

package/lib/types/core_array.js

@@ -628,8 +628,9 @@ class CoreMongooseArray extends Array {
 
     _checkManualPopulation(this, arguments);
 
+    const parent = this[arrayParentSymbol];
     let values = [].map.call(arguments, this._mapCast, this);
-    values = this[arraySchemaSymbol].applySetters(values, this[arrayParentSymbol], undefined,
+    values = this[arraySchemaSymbol].applySetters(values, parent, undefined,
       undefined, { skipDocumentArrayCast: true });
     const ret = [].push.apply(this, values);
 
@@ -723,6 +724,7 @@ class CoreMongooseArray extends Array {
    * @api public
    * @method sort
    * @memberOf MongooseArray
+   * @see https://masteringjs.io/tutorials/fundamentals/array-sort
    */
 
   sort() {
@@ -741,6 +743,7 @@ class CoreMongooseArray extends Array {
    * @api public
    * @method splice
    * @memberOf MongooseArray
+   * @see https://masteringjs.io/tutorials/fundamentals/array-splice
    */
 
   splice() {

package/lib/types/documentarray.js

@@ -172,6 +172,64 @@ class CoreDocumentArray extends CoreMongooseArray {
     }));
   }
 
+  /**
+   * Wraps [`Array#push`](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/push) with proper change tracking.
+   *
+   * @param {Object} [args...]
+   * @api public
+   * @method push
+   * @memberOf MongooseDocumentArray
+   */
+
+  push() {
+    const ret = super.push.apply(this, arguments);
+
+    _updateParentPopulated(this);
+
+    return ret;
+  }
+
+  /**
+   * Pulls items from the array atomically.
+   *
+   * @param {Object} [args...]
+   * @api public
+   * @method pull
+   * @memberOf MongooseDocumentArray
+   */
+
+  pull() {
+    const ret = super.pull.apply(this, arguments);
+
+    _updateParentPopulated(this);
+
+    return ret;
+  }
+
+  /**
+   * Wraps [`Array#shift`](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/unshift) with proper change tracking.
+   */
+
+  shift() {
+    const ret = super.shift.apply(this, arguments);
+
+    _updateParentPopulated(this);
+
+    return ret;
+  }
+
+  /**
+   * Wraps [`Array#splice`](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/splice) with proper change tracking and casting.
+   */
+
+  splice() {
+    const ret = super.splice.apply(this, arguments);
+
+    _updateParentPopulated(this);
+
+    return ret;
+  }
+
   /**
    * Helper for console.log
    *
@@ -254,6 +312,29 @@ if (util.inspect.custom) {
     CoreDocumentArray.prototype.inspect;
 }
 
+/*!
+ * If this is a document array, each element may contain single
+ * populated paths, so we need to modify the top-level document's
+ * populated cache. See gh-8247, gh-8265.
+ */
+
+function _updateParentPopulated(arr) {
+  const parent = arr[arrayParentSymbol];
+  if (parent.$__.populated != null) {
+    const populatedPaths = Object.keys(parent.$__.populated).
+      filter(p => p.startsWith(arr[arrayPathSymbol] + '.'));
+
+    for (const path of populatedPaths) {
+      const remnant = path.slice((arr[arrayPathSymbol] + '.').length);
+      if (!Array.isArray(parent.$__.populated[path].value)) {
+        continue;
+      }
+
+      parent.$__.populated[path].value = arr.map(val => val.populated(remnant));
+    }
+  }
+}
+
 /**
  * DocumentArray constructor
  *

package/lib/types/subdocument.js

@@ -115,6 +115,19 @@ Subdocument.prototype.markModified = function(path) {
   }
 };
 
+Subdocument.prototype.isModified = function(paths, modifiedPaths) {
+  if (this.$parent && this.$basePath) {
+    if (Array.isArray(paths) || typeof paths === 'string') {
+      paths = (Array.isArray(paths) ? paths : paths.split(' '));
+      paths = paths.map(p => [this.$basePath, p].join('.'));
+    }
+
+    return this.$parent.isModified(paths, modifiedPaths);
+  }
+
+  return Document.prototype.isModified(paths, modifiedPaths);
+};
+
 /**
  * Marks a path as valid, removing existing validation errors.
  *