mongoose 5.2.3 → 5.2.7

package/.eslintignore

@@ -5,3 +5,4 @@ test/model.discriminator.test.js
 tools/
 test/es6/
 test/files/
+dist/

package/.travis.yml

@@ -16,6 +16,6 @@ before_script:
   - ./mongodb-linux-x86_64-3.6.4/bin/mongod --fork --nopreallocj --dbpath ./data/db/27017 --syslog --port 27017
 script:
   - npm test
-  - npm run lint
+  - node tools/checkNodeVersion.js "4.x || 5.x" || npm run lint
 notifications:
   email: false

package/History.md

@@ -1,3 +1,61 @@
+5.2.7 / 2018-08-06
+==================
+ * fix(model): check `expireAfterSeconds` option when diffing indexes in syncIndexes() #6820 #6819 [christopherhex](https://github.com/christopherhex)
+ * chore: fix some common test flakes in travis #6816 [Fonger](https://github.com/Fonger)
+ * chore: bump eslint and webpack to avoid bad versions of eslint-scope #6814
+ * test(model): add delay to session tests to improve pass rate #6811 [Fonger](https://github.com/Fonger)
+ * fix(model): support options in `deleteMany` #6810 [Fonger](https://github.com/Fonger)
+ * fix(query): don't use $each when pushing an array into an array #6809 [lineus](https://github.com/lineus)
+ * chore: bump mquery so eslint isn't a prod dependency #6800
+ * fix(populate): correctly get schema type when calling `populate()` on already populated path #6798
+ * fix(populate): propagate readConcern options in populate from parent query #6792 #6785 [Fonger](https://github.com/Fonger)
+ * docs(connection): add description of useNewUrlParser option #6789
+ * fix(query): make select('+path') a no-op if no select prop in schema #6785
+ * docs(schematype+validation): document using function syntax for custom validator message #6772
+ * fix(update): throw CastError if updating with `$inc: null` #6770
+ * fix(connection): throw helpful error when calling `createConnection(undefined)` #6763
+
+5.2.6 / 2018-07-30
+==================
+ * fix(document): don't double-call deeply nested custom getters when using `get()` #6779 #6637
+ * fix(query): upgrade mquery for readConcern() helper #6777
+ * docs(schematypes): clean up typos #6773 [sajadtorkamani](https://github.com/sajadtorkamani)
+ * refactor(browser): fix webpack warnings #6771 #6705
+ * fix(populate): make error reported when no `localField` specified catchable #6767
+ * docs(connection): use correct form in createConnection example #6766 [lineus](https://github.com/lineus)
+ * fix(connection): throw helpful error when using legacy `mongoose.connect()` syntax #6756
+ * fix(document): handle overwriting `$session` in `execPopulate()` #6754
+ * fix(query): propagate top-level session down to `populate()` #6754
+ * fix(aggregate): add `session()` helper for consistency with query api #6752
+ * fix(map): avoid infinite recursion when update overwrites a map #6750
+ * fix(model): be consistent about passing noop callback to mongoose.model() `init()` as well as db.model() #6707
+
+5.2.5 / 2018-07-23
+==================
+ * fix(boolean): expose `convertToTrue` and `convertToFalse` for custom boolean casting #6758
+ * docs(schematypes): add note about what values are converted to booleans #6758
+ * fix(document): fix(document): report castError when setting single nested doc to array #6753
+ * docs: prefix mongoose.Schema call with new operator #6751 [sajadtorkamani](https://github.com/sajadtorkamani)
+ * docs(query): add examples and links to schema writeConcern option for writeConcern helpers #6748
+ * docs(middleware): clarify that init middleware is sync #6747
+ * perf(model): create error rather than modifying stack for source map perf #6735
+ * fix(model): throw helpful error when passing object to aggregate() #6732
+ * fix(model): pass Model instance as context to applyGetters when calling getters for virtual populate #6726 [lineus](https://github.com/lineus)
+ * fix(documentarray): remove `isNew` and `save` listeners on CastError because otherwise they never get removed #6723
+ * docs(model+query): clarify when to use `countDocuments()` vs `estimatedDocumentCount()` #6713
+ * fix(populate): correctly set virtual nestedSchemaPath when calling populate() multiple times #6644
+ * docs(connections): add note about the `family` option for IPv4 vs IPv6 and add port to example URIs #6566
+
+5.2.4 / 2018-07-16
+==================
+ * docs: Model.insertMany rawResult option in api docs #6724 [lineus](https://github.com/lineus)
+ * docs: fix typo on migrating to 5 guide #6722 [iagowp](https://github.com/iagowp)
+ * docs: update doc about keepalive #6719 #6718 [simllll](https://github.com/simllll)
+ * fix: ensure debug mode doesn't crash with sessions #6712
+ * fix(document): report castError when setting single nested doc to primitive value #6710
+ * fix(connection): throw helpful error if using `new db.model(foo)(bar)` #6698
+ * fix(model): throw readable error with better stack trace when non-cb passed to $wrapCallback() #6640
+
 5.2.3 / 2018-07-11
 ==================
  * fix(populate): if a getter is defined on the localField, use it when populating #6702 #6618 [lineus](https://github.com/lineus)

package/README.md

@@ -80,14 +80,14 @@ Once connected, the `open` event is fired on the `Connection` instance. If you'r
 Models are defined through the `Schema` interface.
 
 ```js
-const Schema = mongoose.Schema,
-    ObjectId = Schema.ObjectId;
+const Schema = mongoose.Schema;
+const ObjectId = Schema.ObjectId;
 
 const BlogPost = new Schema({
- author: ObjectId,
- title: String,
- body: String,
- date: Date
+  author: ObjectId,
+  title: String,
+  body: String,
+  date: Date
 });
 ```
 

package/lib/aggregate.js

@@ -633,6 +633,27 @@ Aggregate.prototype.hint = function(value) {
   return this;
 };
 
+/**
+ * Sets the session for this aggregation. Useful for [transactions](/docs/transactions.html).
+ *
+ * ####Example:
+ *
+ *     const session = await Model.startSession();
+ *     await Model.aggregate(..).session(session);
+ *
+ * @param {ClientSession} session
+ * @see mongodb http://docs.mongodb.org/manual/reference/command/aggregate/
+ */
+
+Aggregate.prototype.session = function(session) {
+  if (session == null) {
+    delete this.options.session;
+    return;
+  }
+  this.options.session = session;
+  return this;
+};
+
 /**
  * Lets you set arbitrary options, for middleware or plugins.
  *
@@ -645,6 +666,7 @@ Aggregate.prototype.hint = function(value) {
  * @param [options.maxTimeMS] number limits the time this aggregation will run, see [MongoDB docs on `maxTimeMS`](https://docs.mongodb.com/manual/reference/operator/meta/maxTimeMS/)
  * @param [options.allowDiskUse] boolean if true, the MongoDB server will use the hard drive to store data during this aggregation
  * @param [options.collation] object see [`Aggregate.prototype.collation()`](./docs/api.html#aggregate_Aggregate-collation)
+ * @param [options.session] ClientSession see [`Aggregate.prototype.session()`](./docs/api.html#aggregate_Aggregate-session)
  * @see mongodb http://docs.mongodb.org/manual/reference/command/aggregate/
  * @return {Aggregate} this
  * @api public

package/lib/browser.js

@@ -1,5 +1,7 @@
 /* eslint-env browser */
 
+require('./driver').set(require('./drivers/browser'));
+
 var DocumentProvider = require('./document_provider.js');
 var PromiseProvider = require('./promise_provider');
 

package/lib/cast/boolean.js

@@ -2,9 +2,6 @@
 
 const CastError = require('../error/cast');
 
-const convertToTrue = [true, 'true', 1, '1', 'yes'];
-const convertToFalse = [false, 'false', 0, '0', 'no'];
-
 /*!
  * Given a value, cast it to a boolean, or throw a `CastError` if the value
  * cannot be casted. `null` and `undefined` are considered valid.
@@ -21,12 +18,14 @@ module.exports = function castBoolean(value, path) {
     return value;
   }
 
-  // strict mode (throws if value is not a boolean, instead of converting)
-  if (convertToTrue.indexOf(value) !== -1) {
+  if (module.exports.convertToTrue.has(value)) {
     return true;
   }
-  if (convertToFalse.indexOf(value) !== -1) {
+  if (module.exports.convertToFalse.has(value)) {
     return false;
   }
   throw new CastError('boolean', value, path);
 };
+
+module.exports.convertToTrue = new Set([true, 'true', 1, '1', 'yes']);
+module.exports.convertToFalse = new Set([false, 'false', 0, '0', 'no']);

package/lib/cast/number.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const CastError = require('../error/cast');
+
+/*!
+ * Given a value, cast it to a number, or throw a `CastError` if the value
+ * cannot be casted. `null` and `undefined` are considered valid.
+ *
+ * @param {Any} value
+ * @param {String} [path] optional the path to set on the CastError
+ * @return {Boolean|null|undefined}
+ * @throws {CastError} if `value` is not one of the allowed values
+ * @api private
+ */
+
+module.exports = function castNumber(val, path) {
+  if (isNaN(val)) {
+    throw new CastError('number', val, path);
+  }
+
+  if (val == null) {
+    return val;
+  }
+  if (val === '') {
+    return null;
+  }
+
+  if (typeof val === 'string' || typeof val === 'boolean') {
+    val = Number(val);
+  }
+
+  if (isNaN(val)) {
+    throw new CastError('number', val, path);
+  }
+  if (val instanceof Number) {
+    return val;
+  }
+  if (typeof val === 'number') {
+    return val;
+  }
+  if (!Array.isArray(val) && typeof val.valueOf === 'function') {
+    return Number(val.valueOf());
+  }
+  if (val.toString && !Array.isArray(val) && val.toString() == Number(val)) {
+    return new Number(val);
+  }
+
+  throw new CastError('number', val, path);
+};

package/lib/collection.js

@@ -6,7 +6,7 @@
 
 const EventEmitter = require('events').EventEmitter;
 const STATES = require('./connectionstate');
-const utils = require('./utils');
+const immediate = require('./helpers/immediate');
 
 /**
  * Abstract Collection constructor
@@ -83,10 +83,7 @@ Collection.prototype.conn;
 
 Collection.prototype.onOpen = function() {
   this.buffer = false;
-  var _this = this;
-  utils.immediate(function() {
-    _this.doQueue();
-  });
+  immediate(() => this.doQueue());
 };
 
 /**

package/lib/connection.js

@@ -5,9 +5,8 @@
  */
 
 const EventEmitter = require('events').EventEmitter;
-const driver = global.MONGOOSE_DRIVER_PATH || './drivers/node-mongodb-native';
 const Schema = require('./schema');
-const Collection = require(driver + '/collection');
+const Collection = require('./driver').get().Collection;
 const STATES = require('./connectionstate');
 const MongooseError = require('./error');
 const PromiseProvider = require('./promise_provider');
@@ -414,6 +413,19 @@ Connection.prototype.openUri = function(uri, options, callback) {
     options = null;
   }
 
+  if (['string', 'number'].indexOf(typeof options) !== -1) {
+    throw new MongooseError('Mongoose 5.x no longer supports ' +
+      '`mongoose.connect(host, dbname, port)` or ' +
+      '`mongoose.createConnection(host, dbname, port)`. See ' +
+      'http://mongoosejs.com/docs/connections.html for supported connection syntax');
+  }
+
+  if (typeof uri !== 'string') {
+    throw new MongooseError('The `uri` parameter to `openUri()` must be a ' +
+      `string, got "${typeof uri}". Make sure the first parameter to ` +
+      '`mongoose.connect()` or `mongoose.createConnection()` is a string.');
+  }
+
   const Promise = PromiseProvider.get();
   const _this = this;
 
@@ -710,6 +722,12 @@ Connection.prototype.collection = function(name, options) {
  */
 
 Connection.prototype.model = function(name, schema, collection) {
+  if (!(this instanceof Connection)) {
+    throw new MongooseError('`connection.model()` should not be run with ' +
+      '`new`. If you are doing `new db.model(foo)(bar)`, use ' +
+      '`db.model(foo)(bar)` instead');
+  }
+
   let fn;
   if (typeof name === 'function') {
     fn = name;
@@ -752,7 +770,8 @@ Connection.prototype.model = function(name, schema, collection) {
     }
 
     // Errors handled internally, so safe to ignore error
-    model.init(() => {});
+    model.init(function $modelInitNoop() {});
+
     return model;
   }
 

package/lib/document.js

@@ -396,7 +396,11 @@ Document.prototype.toBSON = function() {
 /**
  * Initializes the document without setters or marking anything modified.
  *
- * Called internally after a document is returned from mongodb.
+ * Called internally after a document is returned from mongodb. Normally,
+ * you do **not** need to call this function on your own.
+ *
+ * This function triggers `init` [middleware](/docs/middleware.html).
+ * Note that `init` hooks are [synchronous](/docs/middleware.html#synchronous).
  *
  * @param {Object} doc document returned by mongo
  * @api public
@@ -1111,6 +1115,8 @@ Document.prototype.get = function(path, type, options) {
       obj = void 0;
     } else if (obj instanceof Map) {
       obj = obj.get(pieces[i]);
+    } else if (i === l - 1) {
+      obj = utils.getValue(pieces[i], obj);
     } else {
       obj = obj[pieces[i]];
     }
@@ -2358,8 +2364,8 @@ Document.prototype.$toObject = function(options, json) {
  *
  * ####Options:
  *
- * - `getters` apply all getters (path and virtual getters)
- * - `virtuals` apply virtual getters (can override `getters` option)
+ * - `getters` apply all getters (path and virtual getters), defaults to false
+ * - `virtuals` apply virtual getters (can override `getters` option), defaults to false
  * - `minimize` remove empty objects (defaults to true)
  * - `transform` a transform function to apply to the resulting document before returning
  * - `depopulate` depopulate any populated paths, replacing them with their original refs (defaults to false)
@@ -2462,6 +2468,12 @@ Document.prototype.$toObject = function(options, json) {
  * _During save, no custom options are applied to the document before being sent to the database._
  *
  * @param {Object} [options]
+ * @param {Boolean} [options.getters=false] if true, apply all getters, including virtuals
+ * @param {Boolean} [options.virtuals=false] if true, apply virtuals. Use `{ getters: true, virtuals: false }` to just apply getters, not virtuals
+ * @param {Boolean} [options.minimize=true] if true, omit any empty objects from the output
+ * @param {Function|null} [options.transform=null] if set, mongoose will call this function to allow you to transform the returned object
+ * @param {Boolean} [options.depopulate=false] if true, replace any conventionally populated paths with the original id in the output. Has no affect on virtual populated paths.
+ * @param {Boolean} [options.versionKey=true] if false, exclude the version key (`__v` by default) from the output
  * @return {Object} js object
  * @see mongodb.Binary http://mongodb.github.com/node-mongodb-native/api-bson-generated/binary.html
  * @api public
@@ -2753,6 +2765,22 @@ Document.prototype.populate = function populate() {
         populateOptions.path = nestedPath + '.' + populateOptions.path;
       });
     }
+
+    // Use `$session()` by default if the document has an associated session
+    // See gh-6754
+    if (this.$session() != null) {
+      const session = this.$session();
+      paths.forEach(path => {
+        if (path.options == null) {
+          path.options = { session: session };
+          return;
+        }
+        if (!('session' in path.options)) {
+          path.options.session = session;
+        }
+      });
+    }
+
     topLevelModel.populate(this, paths, fn);
   }
 

package/lib/driver.js

@@ -0,0 +1,15 @@
+'use strict';
+
+/*!
+ * ignore
+ */
+
+let driver = null;
+
+module.exports.get = function() {
+  return driver;
+};
+
+module.exports.set = function(v) {
+  driver = v;
+};

package/lib/drivers/browser/index.js

@@ -3,6 +3,9 @@
  */
 
 exports.Binary = require('./binary');
+exports.Collection = function() {
+  throw new Error('Cannot create a collection from browser library');
+};
 exports.Decimal128 = require('./decimal128');
 exports.ObjectId = require('./objectid');
 exports.ReadPreference = require('./ReadPreference');

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

@@ -7,7 +7,7 @@
 const MongooseCollection = require('../../collection');
 const Collection = require('mongodb').Collection;
 const get = require('lodash.get');
-const utils = require('../../utils');
+const sliced = require('sliced');
 
 /**
  * A [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) collection implementation.
@@ -72,7 +72,7 @@ NativeCollection.prototype.onOpen = function() {
         }
       } else {
         // create
-        var opts = utils.clone(_this.opts.capped);
+        const opts = Object.assign({}, _this.opts.capped);
         opts.capped = true;
         _this.conn.db.createCollection(_this.name, opts, callback);
       }
@@ -132,7 +132,7 @@ function iter(i) {
     if (debug) {
       if (typeof debug === 'function') {
         debug.apply(_this,
-          [_this.name, i].concat(utils.args(args, 0, args.length - 1)));
+          [_this.name, i].concat(sliced(args, 0, args.length - 1)));
       } else {
         this.$print(_this.name, i, args);
       }
@@ -224,7 +224,7 @@ function format(obj, sub) {
     return obj;
   }
 
-  var x = utils.clone(obj, {transform: false});
+  var x = require('../../utils').clone(obj, {transform: false});
   var representation;
 
   if (x.constructor.name === 'Binary') {
@@ -242,8 +242,17 @@ function format(obj, sub) {
     for (var i = 0; i < numKeys; ++i) {
       key = keys[i];
       if (x[key]) {
+        let error;
         if (typeof x[key].toBSON === 'function') {
-          x[key] = x[key].toBSON();
+          try {
+            // `session.toBSON()` throws an error. This means we throw errors
+            // in debug mode when using transactions, see gh-6712. As a
+            // workaround, catch `toBSON()` errors, try to serialize without
+            // `toBSON()`, and rethrow if serialization still fails.
+            x[key] = x[key].toBSON();
+          } catch (_error) {
+            error = _error;
+          }
         }
         if (x[key].constructor.name === 'Binary') {
           x[key] = 'BinData(' + x[key].sub_type + ', "' +
@@ -260,6 +269,11 @@ function format(obj, sub) {
           x[key] = {inspect: function() { return representation; }};
         } else if (Array.isArray(x[key])) {
           x[key] = x[key].map(map);
+        } else if (error != null) {
+          // If there was an error with `toBSON()` and the object wasn't
+          // already converted to a string representation, rethrow it.
+          // Open to better ideas on how to handle this.
+          throw error;
         }
       }
     }
@@ -268,10 +282,10 @@ function format(obj, sub) {
     return x;
   }
 
-  return require('util')
-    .inspect(x, false, 10, true)
-    .replace(/\n/g, '')
-    .replace(/\s{2,}/g, ' ');
+  return require('util').
+    inspect(x, false, 10, true).
+    replace(/\n/g, '').
+    replace(/\s{2,}/g, ' ');
 }
 
 /**

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

@@ -3,6 +3,7 @@
  */
 
 exports.Binary = require('./binary');
+exports.Collection = require('./collection');
 exports.Decimal128 = require('./decimal128');
 exports.ObjectId = require('./objectid');
 exports.ReadPreference = require('./ReadPreference');

package/lib/helpers/immediate.js

@@ -0,0 +1,10 @@
+/*!
+ * Centralize this so we can more easily work around issues with people
+ * stubbing out `process.nextTick()` in tests using sinon:
+ * https://github.com/sinonjs/lolex#automatically-incrementing-mocked-time
+ * See gh-6074
+ */
+
+module.exports = function immediate(cb) {
+  return process.nextTick(cb);
+};

package/lib/helpers/populate/getSchemaTypes.js

@@ -4,8 +4,9 @@
  * ignore
  */
 
-var Mixed = require('../../schema/mixed');
-var mpath = require('mpath');
+const Mixed = require('../../schema/mixed');
+const get = require('lodash.get');
+const mpath = require('mpath');
 
 /*!
  * @param {Schema} schema
@@ -28,79 +29,96 @@ module.exports = function getSchemaTypes(schema, doc, path) {
     while (p--) {
       trypath = parts.slice(0, p).join('.');
       foundschema = schema.path(trypath);
-      if (foundschema) {
-        if (foundschema.caster) {
-          // array of Mixed?
-          if (foundschema.caster instanceof Mixed) {
-            return foundschema.caster;
-          }
 
-          let schemas = null;
-          if (doc != null && foundschema.schema != null && foundschema.schema.discriminators != null) {
-            const discriminators = foundschema.schema.discriminators;
-            const discriminatorKeyPath = trypath + '.' +
-              foundschema.schema.options.discriminatorKey;
-            const keys = mpath.get(discriminatorKeyPath, subdoc) || [];
-            schemas = Object.keys(discriminators).
-              reduce(function(cur, discriminator) {
-                if (keys.indexOf(discriminator) !== -1) {
-                  cur.push(discriminators[discriminator]);
-                }
-                return cur;
-              }, []);
-          }
+      if (foundschema == null) {
+        continue;
+      }
 
-          // Now that we found the array, we need to check if there
-          // are remaining document paths to look up for casting.
-          // Also we need to handle array.$.path since schema.path
-          // doesn't work for that.
-          // If there is no foundschema.schema we are dealing with
-          // a path like array.$
-          if (p !== parts.length && foundschema.schema) {
-            let ret;
-            if (parts[p] === '$') {
-              if (p + 1 === parts.length) {
-                // comments.$
-                return foundschema;
-              }
-              // comments.$.comments.$.title
-              ret = search(parts.slice(p + 1), schema, mpath.get(trypath, subdoc));
-              if (ret) {
-                ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
-                  !foundschema.schema.$isSingleNested;
-              }
-              return ret;
-            }
+      if (foundschema.caster) {
+        // array of Mixed?
+        if (foundschema.caster instanceof Mixed) {
+          return foundschema.caster;
+        }
 
-            if (schemas != null && schemas.length > 0) {
-              ret = [];
-              for (var i = 0; i < schemas.length; ++i) {
-                let _ret = search(parts.slice(p), schemas[i], mpath.get(trypath, subdoc));
-                if (_ret != null) {
-                  _ret.$isUnderneathDocArray = _ret.$isUnderneathDocArray ||
-                    !foundschema.schema.$isSingleNested;
-                  if (_ret.$isUnderneathDocArray) {
-                    ret.$isUnderneathDocArray = true;
-                  }
-                  ret.push(_ret);
-                }
+        let schemas = null;
+        if (doc != null && foundschema.schema != null && foundschema.schema.discriminators != null) {
+          const discriminators = foundschema.schema.discriminators;
+          const discriminatorKeyPath = trypath + '.' +
+            foundschema.schema.options.discriminatorKey;
+          const keys = mpath.get(discriminatorKeyPath, subdoc) || [];
+          schemas = Object.keys(discriminators).
+            reduce(function(cur, discriminator) {
+              if (keys.indexOf(discriminator) !== -1) {
+                cur.push(discriminators[discriminator]);
               }
-              return ret;
-            } else {
-              ret = search(parts.slice(p), foundschema.schema, mpath.get(trypath, subdoc));
+              return cur;
+            }, []);
+        }
+
+        // Now that we found the array, we need to check if there
+        // are remaining document paths to look up for casting.
+        // Also we need to handle array.$.path since schema.path
+        // doesn't work for that.
+        // If there is no foundschema.schema we are dealing with
+        // a path like array.$
+        if (p !== parts.length && foundschema.schema) {
+          let ret;
+          if (parts[p] === '$') {
+            if (p + 1 === parts.length) {
+              // comments.$
+              return foundschema;
+            }
+            // comments.$.comments.$.title
+            ret = search(parts.slice(p + 1), schema, mpath.get(trypath, subdoc));
+            if (ret) {
+              ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
+                !foundschema.schema.$isSingleNested;
+            }
+            return ret;
+          }
 
-              if (ret) {
-                ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
+          if (schemas != null && schemas.length > 0) {
+            ret = [];
+            for (var i = 0; i < schemas.length; ++i) {
+              let _ret = search(parts.slice(p), schemas[i], mpath.get(trypath, subdoc));
+              if (_ret != null) {
+                _ret.$isUnderneathDocArray = _ret.$isUnderneathDocArray ||
                   !foundschema.schema.$isSingleNested;
+                if (_ret.$isUnderneathDocArray) {
+                  ret.$isUnderneathDocArray = true;
+                }
+                ret.push(_ret);
               }
+            }
+            return ret;
+          } else {
+            ret = search(parts.slice(p), foundschema.schema, mpath.get(trypath, subdoc));
 
-              return ret;
+            if (ret) {
+              ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
+                !foundschema.schema.$isSingleNested;
             }
+
+            return ret;
           }
         }
+      }
+
+      if (doc.$__ && doc.populated(trypath)) {
+        const schema = get(doc.$__.populated[trypath], 'options.model.schema');
+        if (schema != null) {
+          const ret = search(parts.slice(p), schema, mpath.get(trypath, subdoc));
+
+          if (ret) {
+            ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
+              !schema.$isSingleNested;
+          }
 
-        return foundschema;
+          return ret;
+        }
       }
+
+      return foundschema;
     }
   }