mongoose 5.4.23 → 5.5.3

package/History.md

@@ -1,3 +1,53 @@
+5.5.3 / 2019-04-22
+==================
+ * fix: add findAndModify deprecation warning that references the useFindAndModify option #7644
+ * fix(document): handle pushing a doc onto a discriminator that contains a doc array #7704
+ * fix(update): run setters on array elements when doing $set #7679
+ * fix: correct usage of arguments while buffering commands #7718 [rzymek](https://github.com/rzymek)
+ * fix(document): avoid error clearing modified subpaths if doc not defined #7715 [bitflower](https://github.com/bitflower)
+ * refactor(array): move `_parent` property behind a symbol #7726 #7700
+ * docs(model): list out all operations and options for `bulkWrite()` #7055
+ * docs(aggregate): use `eachAsync()` instead of nonexistent `each()` #7699
+ * docs(validation): add CastError validation example #7514
+ * docs(query+model): list out all options and callback details for Model.updateX() and Query#updateX() #7646
+
+5.5.2 / 2019-04-16
+==================
+ * fix(document): support setting nested path to non-POJO object #7639
+ * perf(connection): remove leaked event handler in `Model.init()` so `deleteModel()` frees all memory #7682
+ * fix(timestamps): handle custom statics that conflict with built-in functions (like mongoose-delete plugin) #7698
+ * fix(populate): make `Document#populated()` work for populated subdocs #7685
+ * fix(document): support `.set()` on document array underneath embedded discriminator path #7656
+
+5.5.1 / 2019-04-11
+==================
+ * fix(document): correctly overwrite all properties when setting a single nested subdoc #7660 #7681
+ * fix(array): allow customization of array required validator #7696 [freewil](https://github.com/freewil)
+ * fix(discriminator): handle embedded discriminators when casting array defaults #7687
+ * fix(collection): ensure collection functions return a promise even if disconnected #7676
+ * fix(schematype): avoid indexing properties with `{ unique: false, index: false }` #7620
+ * fix(aggregate): make `Aggregate#model()` with no arguments return the aggregation's model #7608
+
+5.5.0 / 2019-04-08
+==================
+ * feat(model): support applying hooks to custom static functions #5982
+ * feat(populate): support specifying a function as `match` #7397
+ * perf(buffer): avoid calling `defineProperties()` in Buffer constructor #7331
+ * feat(connection): add `plugin()` for connection-scoped plugins #7378
+ * feat(model): add Model#deleteOne() and corresponding hooks #7538
+ * feat(query): support hooks for `Query#distinct()` #5938
+ * feat(model): print warning when calling create() incorrectly with a session #7535
+ * feat(document): add Document#isEmpty() and corresponding helpers for nested paths #5369
+ * feat(document): add `getters` option to Document#get() #7233
+ * feat(query): add Query#projection() to get or overwrite the current projection #7384
+ * fix(document): set full validator path on validatorProperties if `propsParameter` set on validator #7447
+ * feat(document): add Document#directModifiedPaths() #7373
+ * feat(document): add $locals property #7691
+ * feat(document): add validateUpdatedOnly option that only validates modified paths in `save()` #7492 [captaincaius](https://github.com/captaincaius)
+ * chore: upgrade MongoDB driver to v3.2.0 #7641
+ * fix(schematype): deprecate `isAsync` option for custom validators #6700
+ * chore(mongoose): deprecate global.MONGOOSE_DRIVER_PATH so we can be webpack-warning-free in 6.0 #7501
+
 5.4.23 / 2019-04-08
 ===================
  * fix(document): report cast error when string path in schema is an array in MongoDB #7619

package/lib/aggregate.js

@@ -80,14 +80,26 @@ function Aggregate(pipeline) {
 Aggregate.prototype.options;
 
 /**
- * Binds this aggregate to a model.
+ * Get/set the model that this aggregation will execute on.
  *
- * @param {Model} model the model to which the aggregate is to be bound
- * @return {Aggregate}
+ * ####Example:
+ *     const aggregate = MyModel.aggregate([{ $match: { answer: 42 } }]);
+ *     aggregate.model() === MyModel; // true
+ *
+ *     // Change the model. There's rarely any reason to do this.
+ *     aggregate.model(SomeOtherModel);
+ *     aggregate.model() === SomeOtherModel; // true
+ *
+ * @param {Model} [model] the model to which the aggregate is to be bound
+ * @return {Aggregate|Model} if model is passed, will return `this`, otherwise will return the model
  * @api public
  */
 
 Aggregate.prototype.model = function(model) {
+  if (arguments.length === 0) {
+    return this._model;
+  }
+
   this._model = model;
   if (model.schema != null) {
     if (this.options.readPreference == null &&
@@ -790,7 +802,7 @@ Aggregate.prototype.option = function(value) {
  * ####Example:
  *
  *     var cursor = Model.aggregate(..).cursor({ batchSize: 1000 }).exec();
- *     cursor.each(function(error, doc) {
+ *     cursor.eachAsync(function(error, doc) {
  *       // use doc
  *     });
  *

package/lib/connection.js

@@ -10,6 +10,7 @@ const Collection = require('./driver').get().Collection;
 const STATES = require('./connectionstate');
 const MongooseError = require('./error');
 const PromiseProvider = require('./promise_provider');
+const applyPlugins = require('./helpers/schema/applyPlugins');
 const get = require('./helpers/get');
 const mongodb = require('mongodb');
 const utils = require('./utils');
@@ -59,6 +60,7 @@ function Connection(base) {
   this._readyState = STATES.disconnected;
   this._closeCalled = false;
   this._hasOpened = false;
+  this.plugins = [];
 
   this.$internalEmitter = new EventEmitter();
   this.$internalEmitter.setMaxListeners(0);
@@ -147,6 +149,29 @@ Connection.prototype.collections;
 
 Connection.prototype.name;
 
+/**
+ * The plugins that will be applied to all models created on this connection.
+ *
+ * ####Example:
+ *
+ *     const db = mongoose.createConnection('mongodb://localhost:27017/mydb');
+ *     db.plugin(() => console.log('Applied'));
+ *     db.plugins.length; // 1
+ *
+ *     db.model('Test', new Schema({})); // Prints "Applied"
+ *
+ * @property plugins
+ * @memberOf Connection
+ * @instance
+ * @api public
+ */
+
+Object.defineProperty(Connection.prototype, 'plugins', {
+  configurable: false,
+  enumerable: true,
+  writable: true
+});
+
 /**
  * The host name portion of the URI. If multiple hosts, such as a replica set,
  * this will contain the first host name in the URI
@@ -336,7 +361,13 @@ Connection.prototype.dropCollection = _wrapConnHelper(function dropCollection(co
  */
 
 Connection.prototype.dropDatabase = _wrapConnHelper(function dropDatabase(cb) {
-  this.$internalEmitter.emit('dropDatabase');
+  // If `dropDatabase()` is called, this model's collection will not be
+  // init-ed. It is sufficiently common to call `dropDatabase()` after
+  // `mongoose.connect()` but before creating models that we want to
+  // support this. See gh-6967
+  for (const name of Object.keys(this.models)) {
+    delete this.models[name].$init;
+  }
   this.db.dropDatabase(cb);
 });
 
@@ -729,6 +760,30 @@ Connection.prototype.collection = function(name, options) {
   return this.collections[name];
 };
 
+/**
+ * Declares a plugin executed on all schemas you pass to `conn.model()`
+ *
+ * Equivalent to calling `.plugin(fn)` on each schema you create.
+ *
+ * ####Example:
+ *     const db = mongoose.createConnection('mongodb://localhost:27017/mydb');
+ *     db.plugin(() => console.log('Applied'));
+ *     db.plugins.length; // 1
+ *
+ *     db.model('Test', new Schema({})); // Prints "Applied"
+ *
+ * @param {Function} fn plugin callback
+ * @param {Object} [opts] optional options
+ * @return {Connection} this
+ * @see plugins ./plugins.html
+ * @api public
+ */
+
+Connection.prototype.plugin = function(fn, opts) {
+  this.plugins.push([fn, opts]);
+  return this;
+};
+
 /**
  * Defines or retrieves a model.
  *
@@ -800,6 +855,8 @@ Connection.prototype.model = function(name, schema, collection) {
   let model;
 
   if (schema && schema.instanceOfSchema) {
+    applyPlugins(schema, this.plugins, null, '$connectionPluginsApplied');
+
     // compile a model
     model = this.base.model(fn || name, schema, collection, opts);
 

package/lib/document.js

@@ -100,13 +100,15 @@ function Document(obj, fields, skipId, options) {
     $__hasIncludedChildren(fields) :
     {};
 
-  this.$__buildDoc(obj, fields, skipId, exclude, hasIncludedChildren, false);
+  if (this._doc == null) {
+    this.$__buildDoc(obj, fields, skipId, exclude, hasIncludedChildren, false);
 
-  // By default, defaults get applied **before** setting initial values
-  // Re: gh-6155
-  $__applyDefaults(this, fields, skipId, exclude, hasIncludedChildren, true, {
-    isNew: this.isNew
-  });
+    // By default, defaults get applied **before** setting initial values
+    // Re: gh-6155
+    $__applyDefaults(this, fields, skipId, exclude, hasIncludedChildren, true, {
+      isNew: this.isNew
+    });
+  }
 
   if (obj) {
     if (obj instanceof Document) {
@@ -136,6 +138,7 @@ function Document(obj, fields, skipId, options) {
   }
 
   this.$__._id = this._id;
+  this.$locals = {};
 
   if (!schema.options.strict && obj) {
     const _this = this;
@@ -177,6 +180,35 @@ Document.prototype.constructor = Document;
 
 Document.prototype.schema;
 
+/**
+ * Empty object that you can use for storing properties on the document. This
+ * is handy for passing data to middleware without conflicting with Mongoose
+ * internals.
+ *
+ * ####Example:
+ *
+ *     schema.pre('save', function() {
+ *       // Mongoose will set `isNew` to `false` if `save()` succeeds
+ *       this.$locals.wasNew = this.isNew;
+ *     });
+ *
+ *     schema.post('save', function() {
+ *       // Prints true if `isNew` was set before `save()`
+ *       console.log(this.$locals.wasNew);
+ *     });
+ *
+ * @api public
+ * @property $locals
+ * @memberOf Document
+ * @instance
+ */
+
+Object.defineProperty(Document.prototype, '$locals', {
+  configurable: false,
+  enumerable: false,
+  writable: true
+});
+
 /**
  * Boolean flag specifying if the document is new.
  *
@@ -758,6 +790,8 @@ Document.prototype.$set = function $set(path, val, type, options) {
 
       return this;
     }
+  } else {
+    this.$__.$setCalled.add(path);
   }
 
   function _handleIndex(i) {
@@ -776,7 +810,8 @@ Document.prototype.$set = function $set(path, val, type, options) {
       delete this._doc[key];
     }
 
-    if (utils.isPOJO(path[key]) &&
+    if (typeof path[key] === 'object' &&
+        path[key] != null &&
         pathtype !== 'virtual' &&
         pathtype !== 'real' &&
         !(this.$__path(pathName) instanceof MixedSchema) &&
@@ -819,7 +854,10 @@ Document.prototype.$set = function $set(path, val, type, options) {
     }
   }
 
-  const pathType = this.schema.pathType(path);
+  let pathType = this.schema.pathType(path);
+  if (pathType === 'adhocOrUndefined') {
+    pathType = getEmbeddedDiscriminatorPath(this, path, { typeOnly: true });
+  }
 
   // Assume this is a Mongoose document that was copied into a POJO using
   // `Object.assign()` or `{...doc}`
@@ -828,7 +866,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
   }
 
   if (pathType === 'nested' && val) {
-    if (utils.isPOJO(val)) {
+    if (typeof val === 'object' && val != null) {
       if (!merge) {
         this.setValue(path, null);
         cleanModifiedSubpaths(this, path);
@@ -1026,25 +1064,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
     // a single nested doc. That's to make sure we get the correct context.
     // Otherwise we would double-call the setter, see gh-7196.
     if (this.schema.singleNestedPaths[path] == null) {
-      // Init the new subdoc to the previous values of the doc, so
-      // getters/setters see the correct current state. We pass the new subdoc
-      // instead of the old subdoc because otherwise side effects in setters
-      // wouldn't work, see gh-7585
-      if (constructing && this.$__.$options.priorDoc) {
-        const priorVal = Object.assign({}, this.$__.$options.priorDoc._doc);
-        delete priorVal[this.schema.options.discriminatorKey];
-        init(this, priorVal, this._doc);
-      }
-
       val = schema.applySetters(val, this, false, priorVal);
-
-      if (constructing && this.$__.$options.priorDoc) {
-        // Clear init-ed paths afterwards, because those should be paths that
-        // were in the previous doc and should not be in the new one.
-        for (const path of Object.keys(this.$__.activePaths.states.init)) {
-          delete this._doc[path];
-        }
-      }
     }
 
     if (!didPopulate && this.$__.populated) {
@@ -1277,6 +1297,9 @@ Document.prototype.setValue = function(path, val) {
  *
  * @param {String} path
  * @param {Schema|String|Number|Buffer|*} [type] optionally specify a type for on-the-fly attributes
+ * @param {Object} [options]
+ * @param {Boolean} [options.virtuals=false] Apply virtuals before getting this path
+ * @param {Boolean} [options.getters=true] If false, skip applying getters and just get the raw value
  * @api public
  */
 
@@ -1323,7 +1346,7 @@ Document.prototype.get = function(path, type, options) {
     obj = adhoc.cast(obj);
   }
 
-  if (schema != null) {
+  if (schema != null && options.getters !== false) {
     obj = schema.applyGetters(obj, this);
   } else if (this.schema.nested[path] && options.virtuals) {
     // Might need to apply virtuals if this is a nested path
@@ -1420,6 +1443,95 @@ Document.prototype.$ignore = function(path) {
   this.$__.activePaths.ignore(path);
 };
 
+/**
+ * Returns the list of paths that have been directly modified. A direct
+ * modified path is a path that you explicitly set, whether via `doc.foo = 'bar'`,
+ * `Object.assign(doc, { foo: 'bar' })`, or `doc.set('foo', 'bar')`.
+ *
+ * A path `a` may be in `modifiedPaths()` but not in `directModifiedPaths()`
+ * because a child of `a` was directly modified.
+ *
+ * ####Example
+ *     const schema = new Schema({ foo: String, nested: { bar: String } });
+ *     const Model = mongoose.model('Test', schema);
+ *     await Model.create({ foo: 'original', nested: { bar: 'original' } });
+ *
+ *     const doc = await Model.findOne();
+ *     doc.nested.bar = 'modified';
+ *     doc.directModifiedPaths(); // ['nested.bar']
+ *     doc.modifiedPaths(); // ['nested', 'nested.bar']
+ *
+ * @return {Array}
+ * @api public
+ */
+
+Document.prototype.directModifiedPaths = function() {
+  return Object.keys(this.$__.activePaths.states.modify);
+};
+
+/**
+ * Returns true if the given path is nullish or only contains empty objects.
+ * Useful for determining whether this subdoc will get stripped out by the
+ * [minimize option](/docs/guide.html#minimize).
+ *
+ * ####Example:
+ *     const schema = new Schema({ nested: { foo: String } });
+ *     const Model = mongoose.model('Test', schema);
+ *     const doc = new Model({});
+ *     doc.$isEmpty('nested'); // true
+ *     doc.nested.$isEmpty(); // true
+ *
+ *     doc.nested.foo = 'bar';
+ *     doc.$isEmpty('nested'); // false
+ *     doc.nested.$isEmpty(); // false
+ *
+ * @memberOf Document
+ * @instance
+ * @api public
+ * @method $isEmpty
+ * @return {Boolean}
+ */
+
+Document.prototype.$isEmpty = function(path) {
+  const isEmptyOptions = {
+    minimize: true,
+    virtuals: false,
+    getters: false,
+    transform: false
+  };
+
+  if (arguments.length > 0) {
+    const v = this.get(path);
+    if (v == null) {
+      return true;
+    }
+    if (typeof v !== 'object') {
+      return false;
+    }
+    if (utils.isPOJO(v)) {
+      return _isEmpty(v);
+    }
+    return Object.keys(v.toObject(isEmptyOptions)).length === 0;
+  }
+
+  return Object.keys(this.toObject(isEmptyOptions)).length === 0;
+};
+
+function _isEmpty(v) {
+  if (v == null) {
+    return true;
+  }
+  if (typeof v !== 'object' || Array.isArray(v)) {
+    return false;
+  }
+  for (const key of Object.keys(v)) {
+    if (!_isEmpty(v[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
 /**
  * Returns the list of paths that have been modified.
  *
@@ -1757,7 +1869,7 @@ Document.prototype.validate = function(options, callback) {
     options = null;
   }
 
-  return utils.promiseOrCallback(callback, cb => this.$__validate(function(error) {
+  return utils.promiseOrCallback(callback, cb => this.$__validate(options, function(error) {
     cb(error);
   }), this.constructor.events);
 };
@@ -1889,7 +2001,23 @@ function _getPathsToValidate(doc) {
  * ignore
  */
 
-Document.prototype.$__validate = function(callback) {
+Document.prototype.$__validate = function(options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = null;
+  }
+
+  const hasValidateModifiedOnlyOption = options &&
+      (typeof options === 'object') &&
+      ('validateModifiedOnly' in options);
+
+  let shouldValidateModifiedOnly;
+  if (hasValidateModifiedOnlyOption) {
+    shouldValidateModifiedOnly = !!options.validateModifiedOnly;
+  } else {
+    shouldValidateModifiedOnly = this.schema.options.validateModifiedOnly;
+  }
+
   const _this = this;
   const _complete = () => {
     const err = this.$__.validationError;
@@ -1911,7 +2039,9 @@ Document.prototype.$__validate = function(callback) {
 
   // only validate required fields when necessary
   const pathDetails = _getPathsToValidate(this);
-  const paths = pathDetails[0];
+  const paths = shouldValidateModifiedOnly ?
+    pathDetails[0].filter((path) => this.isModified(path)) :
+    pathDetails[0];
   const skipSchemaValidators = pathDetails[1];
 
   if (paths.length === 0) {
@@ -1975,7 +2105,7 @@ Document.prototype.$__validate = function(callback) {
           _this.invalidate(path, err, undefined, true);
         }
         --total || complete();
-      }, scope, { skipSchemaValidators: skipSchemaValidators[path] });
+      }, scope, { skipSchemaValidators: skipSchemaValidators[path], path: path });
     });
   };
 
@@ -2006,16 +2136,29 @@ Document.prototype.$__validate = function(callback) {
  * @api public
  */
 
-Document.prototype.validateSync = function(pathsToValidate) {
+Document.prototype.validateSync = function(pathsToValidate, options) {
   const _this = this;
 
+  const hasValidateModifiedOnlyOption = options &&
+      (typeof options === 'object') &&
+      ('validateModifiedOnly' in options);
+
+  let shouldValidateModifiedOnly;
+  if (hasValidateModifiedOnlyOption) {
+    shouldValidateModifiedOnly = !!options.validateModifiedOnly;
+  } else {
+    shouldValidateModifiedOnly = this.schema.options.validateModifiedOnly;
+  }
+
   if (typeof pathsToValidate === 'string') {
     pathsToValidate = pathsToValidate.split(' ');
   }
 
   // only validate required fields when necessary
   const pathDetails = _getPathsToValidate(this);
-  let paths = pathDetails[0];
+  let paths = shouldValidateModifiedOnly ?
+    pathDetails[0].filter((path) => this.isModified(path)) :
+    pathDetails[0];
   const skipSchemaValidators = pathDetails[1];
 
   if (pathsToValidate && pathsToValidate.length) {
@@ -2047,7 +2190,8 @@ Document.prototype.validateSync = function(pathsToValidate) {
 
     const val = _this.getValue(path);
     const err = p.doValidateSync(val, _this, {
-      skipSchemaValidators: skipSchemaValidators[path]
+      skipSchemaValidators: skipSchemaValidators[path],
+      path: path
     });
     if (err && (!p.$isMongooseDocumentArray || err.$isArrayValidatorError)) {
       if (p.$isSingleNested &&
@@ -3110,7 +3254,6 @@ Document.prototype.populated = function(path, val, options) {
   }
 
   // internal
-
   if (val === true) {
     if (!this.$__.populated) {
       return undefined;
@@ -3120,6 +3263,22 @@ Document.prototype.populated = function(path, val, options) {
 
   this.$__.populated || (this.$__.populated = {});
   this.$__.populated[path] = {value: val, options: options};
+
+  // If this was a nested populate, make sure each populated doc knows
+  // about its populated children (gh-7685)
+  const pieces = path.split('.');
+  for (let i = 0; i < pieces.length - 1; ++i) {
+    const subpath = pieces.slice(0, i + 1).join('.');
+    const subdoc = this.get(subpath);
+    if (subdoc != null && subdoc.$__ != null && this.populated(subpath)) {
+      const rest = pieces.slice(i + 1).join('.');
+      subdoc.populated(rest, val, options);
+      // No need to continue because the above recursion should take care of
+      // marking the rest of the docs as populated
+      break;
+    }
+  }
+
   return val;
 };
 

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

@@ -20,8 +20,9 @@ const util = require('util');
  * @api private
  */
 
-function NativeCollection() {
+function NativeCollection(name, options) {
   this.collection = null;
+  this.Promise = options.Promise || Promise;
   MongooseCollection.apply(this, arguments);
 }
 
@@ -115,9 +116,10 @@ const syncCollectionMethods = { watch: true };
 function iter(i) {
   NativeCollection.prototype[i] = function() {
     const collection = this.collection;
-    const args = arguments;
+    const args = Array.from(arguments);
     const _this = this;
     const debug = get(_this, 'conn.base.options.debug');
+    const lastArg = arguments[arguments.length - 1];
 
     // If user force closed, queueing will hang forever. See #5664
     if (this.opts.$wasForceClosed) {
@@ -127,8 +129,18 @@ function iter(i) {
       if (syncCollectionMethods[i]) {
         throw new Error('Collection method ' + i + ' is synchronous');
       }
-      this.addQueue(i, arguments);
-      return;
+      if (typeof lastArg === 'function') {
+        this.addQueue(i, args);
+        return;
+      }
+      return new this.Promise((resolve, reject) => {
+        this.addQueue(i, [].concat(args).concat([(err, res) => {
+          if (err != null) {
+            return reject(err);
+          }
+          resolve(res);
+        }]));
+      });
     }
 
     if (debug) {

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

@@ -8,4 +8,4 @@ exports.Binary = require('./binary');
 exports.Collection = require('./collection');
 exports.Decimal128 = require('./decimal128');
 exports.ObjectId = require('./objectid');
-exports.ReadPreference = require('./ReadPreference');
+exports.ReadPreference = require('./ReadPreference');

package/lib/helpers/document/cleanModifiedSubpaths.js

@@ -9,6 +9,9 @@ module.exports = function cleanModifiedSubpaths(doc, path, options) {
   const skipDocArrays = options.skipDocArrays;
 
   let deleted = 0;
+  if (!doc) {
+    return deleted;
+  }
   for (const modifiedPath of Object.keys(doc.$__.activePaths.states.modify)) {
     if (skipDocArrays) {
       const schemaType = doc.schema.path(modifiedPath);

package/lib/helpers/document/compile.js

@@ -100,6 +100,21 @@ function defineKey(prop, subprops, prototype, prefix, keys, options) {
             value: true
           });
 
+          const _isEmptyOptions = Object.freeze({
+            minimize: true,
+            virtuals: false,
+            getters: false,
+            transform: false
+          });
+          Object.defineProperty(nested, '$isEmpty', {
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            value: function() {
+              return Object.keys(this.get(path, null, _isEmptyOptions) || {}).length === 0;
+            }
+          });
+
           compile(subprops, nested, path, options);
           this.$__.getters[path] = nested;
         }
@@ -140,7 +155,7 @@ function getOwnPropertyDescriptors(object) {
       delete result[key];
       return;
     }
-    result[key].enumerable = ['isNew', '$__', 'errors', '_doc'].indexOf(key) === -1;
+    result[key].enumerable = ['isNew', '$__', 'errors', '_doc', '$locals'].indexOf(key) === -1;
   });
 
   return result;

package/lib/helpers/document/getEmbeddedDiscriminatorPath.js

@@ -18,8 +18,12 @@ module.exports = function getEmbeddedDiscriminatorPath(doc, path, options) {
     const subpath = parts.slice(0, i + 1).join('.');
     schema = doc.schema.path(subpath);
     if (schema == null) {
+      type = 'adhocOrUndefined';
       continue;
     }
+    if (schema.instance === 'Mixed') {
+      return typeOnly ? 'real' : schema;
+    }
     type = doc.schema.pathType(subpath);
     if ((schema.$isSingleNested || schema.$isMongooseDocumentArrayElement) &&
         schema.schema.discriminators != null) {
@@ -30,11 +34,7 @@ module.exports = function getEmbeddedDiscriminatorPath(doc, path, options) {
         continue;
       }
       const rest = parts.slice(i + 1).join('.');
-      schema = discriminators[discriminatorKey].path(rest);
-      if (schema != null) {
-        type = discriminators[discriminatorKey].pathType(rest);
-        break;
-      }
+      return getEmbeddedDiscriminatorPath(doc.get(subpath), rest, options);
     }
   }