mongoose 5.4.23 → 5.5.3

package/lib/helpers/model/applyHooks.js

@@ -14,6 +14,7 @@ module.exports = applyHooks;
  */
 
 applyHooks.middlewareFunctions = [
+  'deleteOne',
   'save',
   'validate',
   'remove',
@@ -71,7 +72,7 @@ function applyHooks(model, schema, options) {
 
   const middleware = schema.s.hooks.
     filter(hook => {
-      if (hook.name === 'updateOne') {
+      if (hook.name === 'updateOne' || hook.name === 'deleteOne') {
         return !!hook['document'];
       }
       if (hook.name === 'remove') {
@@ -96,6 +97,8 @@ function applyHooks(model, schema, options) {
     createWrapper('validate', objToDecorate.$__validate, null, kareemOptions);
   objToDecorate.$__remove = middleware.
     createWrapper('remove', objToDecorate.$__remove, null, kareemOptions);
+  objToDecorate.$__deleteOne = middleware.
+    createWrapper('deleteOne', objToDecorate.$__deleteOne, null, kareemOptions);
   objToDecorate.$__init = middleware.
     createWrapperSync('init', objToDecorate.$__init, null, kareemOptions);
 

package/lib/helpers/model/applyStaticHooks.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const utils = require('../../utils');
+
+module.exports = function applyStaticHooks(model, hooks, statics) {
+  const kareemOptions = {
+    useErrorHandlers: true,
+    numCallbackParams: 1
+  };
+
+  hooks = hooks.filter(hook => hook.model !== false);
+
+  model.$__insertMany = hooks.createWrapper('insertMany',
+    model.$__insertMany, model, kareemOptions);
+
+  for (const key of Object.keys(statics)) {
+    if (hooks.hasHooks(key)) {
+      const original = model[key];
+
+      model[key] = function() {
+        const numArgs = arguments.length;
+        const lastArg = numArgs > 0 ? arguments[numArgs - 1] : null;
+        const cb = typeof lastArg === 'function' ? lastArg : null;
+        const args = Array.prototype.slice.
+          call(arguments, 0, cb == null ? numArgs : numArgs - 1);
+        // Special case: can't use `Kareem#wrap()` because it doesn't currently
+        // support wrapped functions that return a promise.
+        return utils.promiseOrCallback(cb, callback => {
+          hooks.execPre(key, model, args, function(err) {
+            if (err != null) {
+              return callback(err);
+            }
+
+            let postCalled = 0;
+            const ret = original.apply(model, args.concat(post));
+            if (ret != null && typeof ret.then === 'function') {
+              ret.then(res => post(null, res), err => post(err));
+            }
+
+            function post(error, res) {
+              if (postCalled++ > 0) {
+                return;
+              }
+
+              if (error != null) {
+                return callback(error);
+              }
+
+              hooks.execPost(key, model, [res], function(error) {
+                if (error != null) {
+                  return callback(error);
+                }
+                callback(null, res);
+              });
+            }
+          });
+        }, model.events);
+      };
+    }
+  }
+};

package/lib/helpers/populate/assignVals.js

@@ -6,6 +6,7 @@ const get = require('../get');
 const getVirtual = require('./getVirtual');
 const leanPopulateMap = require('./leanPopulateMap');
 const mpath = require('mpath');
+const sift = require('sift').default;
 const utils = require('../../utils');
 
 module.exports = function assignVals(o) {
@@ -48,7 +49,16 @@ module.exports = function assignVals(o) {
       continue;
     }
 
-    let valueToSet = count ? numDocs(rawIds[i]) : rawIds[i];
+    let valueToSet;
+    if (count) {
+      valueToSet = numDocs(rawIds[i]);
+    } else if (Array.isArray(o.match)) {
+      valueToSet = Array.isArray(rawIds[i]) ?
+        sift(o.match[i], rawIds[i]) :
+        sift(o.match[i], [rawIds[i]])[0];
+    } else {
+      valueToSet = rawIds[i];
+    }
 
     // If we're populating a map, the existing value will be an object, so
     // we need to transform again

package/lib/helpers/query/applyQueryMiddleware.js

@@ -15,6 +15,7 @@ applyQueryMiddleware.middlewareFunctions = [
   'countDocuments',
   'deleteMany',
   'deleteOne',
+  'distinct',
   'estimatedDocumentCount',
   'find',
   'findOne',
@@ -44,7 +45,7 @@ function applyQueryMiddleware(Query, model) {
   };
 
   const middleware = model.hooks.filter(hook => {
-    if (hook.name === 'updateOne') {
+    if (hook.name === 'updateOne' || hook.name === 'deleteOne') {
       return hook.query == null || !!hook.query;
     }
     if (hook.name === 'remove') {
@@ -56,9 +57,12 @@ function applyQueryMiddleware(Query, model) {
   // `update()` thunk has a different name because `_update` was already taken
   Query.prototype._execUpdate = middleware.createWrapper('update',
     Query.prototype._execUpdate, null, kareemOptions);
+  // `distinct()` thunk has a different name because `_distinct` was already taken
+  Query.prototype.__distinct = middleware.createWrapper('distinct',
+    Query.prototype.__distinct, null, kareemOptions);
 
   applyQueryMiddleware.middlewareFunctions.
-    filter(v => v !== 'update').
+    filter(v => v !== 'update' && v !== 'distinct').
     forEach(fn => {
       Query.prototype[`_${fn}`] = middleware.createWrapper(fn,
         Query.prototype[`_${fn}`], null, kareemOptions);

package/lib/helpers/query/castUpdate.js

@@ -392,8 +392,6 @@ function castUpdateVal(schema, val, op, $conditional, context, path) {
       tmp = tmp[0];
     }
     return tmp;
-  } else if (cond && op === '$set') {
-    return schema.cast(val);
   }
 
   if (op in noCastOps) {

package/lib/helpers/schema/applyPlugins.js

@@ -0,0 +1,43 @@
+'use strict';
+
+module.exports = function applyPlugins(schema, plugins, options, cacheKey) {
+  if (schema[cacheKey]) {
+    return;
+  }
+  schema[cacheKey] = true;
+
+  if (!options || !options.skipTopLevel) {
+    for (let i = 0; i < plugins.length; ++i) {
+      schema.plugin(plugins[i][0], plugins[i][1]);
+    }
+  }
+
+  options = Object.assign({}, options);
+  delete options.skipTopLevel;
+
+  for (const path of Object.keys(schema.paths)) {
+    const type = schema.paths[path];
+    if (type.schema != null) {
+      applyPlugins(type.schema, plugins, options, cacheKey);
+
+      // Recompile schema because plugins may have changed it, see gh-7572
+      type.caster.prototype.$__setSchema(type.schema);
+    }
+  }
+
+  const discriminators = schema.discriminators;
+  if (discriminators == null) {
+    return;
+  }
+
+  const applyPluginsToDiscriminators = options.applyPluginsToDiscriminators;
+
+  const keys = Object.keys(discriminators);
+  for (let i = 0; i < keys.length; ++i) {
+    const discriminatorKey = keys[i];
+    const discriminatorSchema = discriminators[discriminatorKey];
+
+    applyPlugins(discriminatorSchema, plugins,
+      { skipTopLevel: !applyPluginsToDiscriminators }, cacheKey);
+  }
+};

package/lib/helpers/symbols.js

@@ -1,13 +1,9 @@
 'use strict';
 
-exports.validatorErrorSymbol = Symbol.for('mongoose:validatorError');
-
+exports.arrayParentSymbol = Symbol('mongoose#Array#_parent');
 exports.documentArrayParent = Symbol.for('mongoose:documentArrayParent');
-
-exports.modelSymbol = Symbol.for('mongoose#Model');
-
 exports.getSymbol = Symbol.for('mongoose#Document#get');
-
+exports.modelSymbol = Symbol.for('mongoose#Model');
 exports.objectIdSymbol = Symbol.for('mongoose#ObjectId');
-
-exports.schemaTypeSymbol = Symbol.for('mongoose#schemaType');
+exports.schemaTypeSymbol = Symbol.for('mongoose#schemaType');
+exports.validatorErrorSymbol = Symbol.for('mongoose:validatorError');

package/lib/index.js

@@ -5,7 +5,12 @@
  */
 
 if (global.MONGOOSE_DRIVER_PATH) {
-  require('./driver').set(require(global.MONGOOSE_DRIVER_PATH));
+  const deprecationWarning = 'The `MONGOOSE_DRIVER_PATH` global property is ' +
+    'deprecated. Use `mongoose.driver.set()` instead.';
+  const setDriver = require('util').deprecate(function() {
+    require('./driver').set(require(global.MONGOOSE_DRIVER_PATH));
+  }, deprecationWarning);
+  setDriver();
 } else {
   require('./driver').set(require('./drivers/node-mongodb-native'));
 }
@@ -19,6 +24,7 @@ const Types = require('./types');
 const Query = require('./query');
 const Model = require('./model');
 const Document = require('./document');
+const applyPlugins = require('./helpers/schema/applyPlugins');
 const get = require('./helpers/get');
 const legacyPluralize = require('mongoose-legacy-pluralize');
 const utils = require('./utils');
@@ -103,6 +109,18 @@ function Mongoose(options) {
  */
 Mongoose.prototype.STATES = STATES;
 
+/**
+ * The underlying driver this Mongoose instance uses to communicate with
+ * the database. A driver is a Mongoose-specific interface that defines functions
+ * like `find()`.
+ *
+ * @memberOf Mongoose
+ * @property driver
+ * @api public
+ */
+
+Mongoose.prototype.driver = require('./driver');
+
 /**
  * Sets mongoose options
  *
@@ -553,42 +571,10 @@ Mongoose.prototype.modelNames = function() {
  */
 
 Mongoose.prototype._applyPlugins = function(schema, options) {
-  if (schema.$globalPluginsApplied) {
-    return;
-  }
-  schema.$globalPluginsApplied = true;
-
-  if (!options || !options.skipTopLevel) {
-    for (let i = 0; i < this.plugins.length; ++i) {
-      schema.plugin(this.plugins[i][0], this.plugins[i][1]);
-    }
-  }
-
-  for (const path of Object.keys(schema.paths)) {
-    const type = schema.paths[path];
-    if (type.schema != null) {
-      this._applyPlugins(type.schema);
-
-      // Recompile schema because plugins may have changed it, see gh-7572
-      type.caster.prototype.$__setSchema(type.schema);
-    }
-  }
-
-  const discriminators = schema.discriminators;
-  if (discriminators == null) {
-    return;
-  }
-
-  const applyPluginsToDiscriminators = get(this,
+  options = options || {};
+  options.applyPluginsToDiscriminators = get(this,
     'options.applyPluginsToDiscriminators', false);
-
-  const keys = Object.keys(discriminators);
-  for (let i = 0; i < keys.length; ++i) {
-    const discriminatorKey = keys[i];
-    const discriminatorSchema = discriminators[discriminatorKey];
-
-    this._applyPlugins(discriminatorSchema, { skipTopLevel: !applyPluginsToDiscriminators });
-  }
+  applyPlugins(schema, this.plugins, options, '$globalPluginsApplied');
 };
 
 /**

package/lib/internal.js

@@ -30,6 +30,7 @@ function InternalCache() {
   this.pathsToScopes = {};
   this.cachedRequired = {};
   this.session = null;
+  this.$setCalled = new Set();
 
   // embedded docs
   this.ownerDocument = undefined;

package/lib/model.js

@@ -11,6 +11,7 @@ const DocumentNotFoundError = require('./error').DocumentNotFoundError;
 const DivergentArrayError = require('./error').DivergentArrayError;
 const Error = require('./error');
 const EventEmitter = require('events').EventEmitter;
+const MongooseBuffer = require('./types/buffer');
 const OverwriteModelError = require('./error').OverwriteModelError;
 const PromiseProvider = require('./promise_provider');
 const Query = require('./query');
@@ -21,6 +22,7 @@ const ParallelSaveError = require('./error').ParallelSaveError;
 const applyQueryMiddleware = require('./helpers/query/applyQueryMiddleware');
 const applyHooks = require('./helpers/model/applyHooks');
 const applyMethods = require('./helpers/model/applyMethods');
+const applyStaticHooks = require('./helpers/model/applyStaticHooks');
 const applyStatics = require('./helpers/model/applyStatics');
 const applyWriteConcern = require('./helpers/schema/applyWriteConcern');
 const assignVals = require('./helpers/populate/assignVals');
@@ -689,7 +691,7 @@ Model.prototype.$__delta = function() {
     } else if (value._path && value._atomics) {
       // arrays and other custom types (support plugins etc)
       handleAtomics(this, where, delta, data, value);
-    } else if (value._path && Buffer.isBuffer(value)) {
+    } else if (value[MongooseBuffer.pathSymbol] && Buffer.isBuffer(value)) {
       // MongooseBuffer
       value = value.toObject();
       operand(this, where, delta, data, value);
@@ -905,6 +907,37 @@ Model.prototype.remove = function remove(options, fn) {
 
 Model.prototype.delete = Model.prototype.remove;
 
+/**
+ * Removes this document from the db. Equivalent to `.remove()`.
+ *
+ * ####Example:
+ *     product = await product.deleteOne();
+ *     await Product.findById(product._id); // null
+ *
+ * @param {function(err,product)} [fn] optional callback
+ * @return {Promise} Promise
+ * @api public
+ */
+
+Model.prototype.deleteOne = function deleteOne(options, fn) {
+  if (typeof options === 'function') {
+    fn = options;
+    options = undefined;
+  }
+
+  if (!options) {
+    options = {};
+  }
+
+  if (fn) {
+    fn = this.constructor.$wrapCallback(fn);
+  }
+
+  return utils.promiseOrCallback(fn, cb => {
+    this.$__deleteOne(options, cb);
+  }, this.constructor.events);
+};
+
 /*!
  * ignore
  */
@@ -940,6 +973,12 @@ Model.prototype.$__remove = function $__remove(options, cb) {
   });
 };
 
+/*!
+ * ignore
+ */
+
+Model.prototype.$__deleteOne = Model.prototype.$__remove;
+
 /**
  * Returns another Model instance.
  *
@@ -1081,14 +1120,6 @@ Model.init = function init(callback) {
     return this.$init;
   }
 
-  // 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
-  this.db.$internalEmitter.once('dropDatabase', () => {
-    delete this.$init;
-  });
-
   const Promise = PromiseProvider.get();
   const autoIndex = this.schema.options.autoIndex == null ?
     this.db.config.autoIndex :
@@ -2803,6 +2834,20 @@ Model.create = function create(doc, options, callback) {
     } else {
       args = utils.args(arguments);
     }
+
+    if (args.length === 2 &&
+        args[0] != null &&
+        args[1] != null &&
+        args[0].session == null &&
+        last.session != null &&
+        last.session.constructor.name === 'ClientSession' &&
+        !this.schema.path('session')) {
+      // Probably means the user is running into the common mistake of trying
+      // to use a spread to specify options, see gh-7535
+      console.warn('WARNING: to pass a `session` to `Model.create()` in ' +
+        'Mongoose, you **must** pass an array as the first argument. See: ' +
+        'https://mongoosejs.com/docs/api.html#model_Model.create');
+    }
   }
 
   if (cb) {
@@ -2844,6 +2889,11 @@ Model.create = function create(doc, options, callback) {
           }
         }
 
+        // Make sure session is available in middleware
+        if (options.session != null) {
+          toSave.$session(options.session);
+        }
+
         toSave.save(options, callbackWrapper);
       });
     });
@@ -3118,7 +3168,32 @@ Model.$__insertMany = function(arr, options, callback) {
  *      console.log(res.insertedCount, res.modifiedCount, res.deletedCount);
  *     });
  *
+ * The [supported operations](https://docs.mongodb.com/manual/reference/method/db.collection.bulkWrite/#db.collection.bulkWrite) are:
+ *
+ * - `insertOne`
+ * - `updateOne`
+ * - `updateMany`
+ * - `deleteOne`
+ * - `deleteMany`
+ * - `replaceOne`
+ *
  * @param {Array} ops
+ * @param {Object} [ops.insertOne.document] The document to insert
+ * @param {Object} [opts.updateOne.filter] Update the first document that matches this filter
+ * @param {Object} [opts.updateOne.update] An object containing [update operators](https://docs.mongodb.com/manual/reference/operator/update/)
+ * @param {Boolean} [opts.updateOne.upsert=false] If true, insert a doc if none match
+ * @param {Object} [opts.updateOne.collation] The [MongoDB collation](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-34-collations) to use
+ * @param {Array} [opts.updateOne.arrayFilters] The [array filters](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-36-array-filters.html) used in `update`
+ * @param {Object} [opts.updateMany.filter] Update all the documents that match this filter
+ * @param {Object} [opts.updateMany.update] An object containing [update operators](https://docs.mongodb.com/manual/reference/operator/update/)
+ * @param {Boolean} [opts.updateMany.upsert=false] If true, insert a doc if no documents match `filter`
+ * @param {Object} [opts.updateMany.collation] The [MongoDB collation](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-34-collations) to use
+ * @param {Array} [opts.updateMany.arrayFilters] The [array filters](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-36-array-filters.html) used in `update`
+ * @param {Object} [opts.deleteOne.filter] Delete the first document that matches this filter
+ * @param {Object} [opts.deleteMany.filter] Delete all documents that match this filter
+ * @param {Object} [opts.replaceOne.filter] Replace the first document that matches this filter
+ * @param {Object} [opts.replaceOne.replacement] The replacement document
+ * @param {Boolean} [opts.replaceOne.upsert=false] If true, insert a doc if no documents match `filter`
  * @param {Object} [options]
  * @param {Boolean} [options.ordered=true] If true, execute writes in order and stop at the first error. If false, execute writes in parallel and continue until all writes have either succeeded or errored.
  * @param {ClientSession} [options.session=null] The session associated with this bulk write. See [transactions docs](/docs/transactions.html).
@@ -3255,9 +3330,17 @@ Model.hydrate = function(obj) {
  * @param {Object} conditions
  * @param {Object} doc
  * @param {Object} [options] optional see [`Query.prototype.setOptions()`](http://mongoosejs.com/docs/api.html#query_Query-setOptions)
+ * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](http://mongoosejs.com/docs/guide.html#strict)
+ * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
+ * @param {Object} [options.writeConcern=null] sets the [write concern](https://docs.mongodb.com/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](/docs/guide.html#writeConcern)
+ * @param {Boolean} [options.omitUndefined=false] If true, delete any properties whose value is `undefined` when casting an update. In other words, if this is set, Mongoose will delete `baz` from the update in `Model.updateOne({}, { foo: 'bar', baz: undefined })` before sending the update to the server.
+ * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
+ * @param {Function} [callback] params are (error, writeOpResult)
  * @param {Function} [callback]
  * @return {Query}
  * @see MongoDB docs https://docs.mongodb.com/manual/reference/command/update/#update-command-output
+ * @see writeOpResult http://mongodb.github.io/node-mongodb-native/2.2/api/Collection.html#~WriteOpResult
+ * @see Query docs https://mongoosejs.com/docs/queries.html
  * @api public
  */
 
@@ -3286,10 +3369,15 @@ Model.update = function update(conditions, doc, options, callback) {
  * @param {Object} doc
  * @param {Object} [options] optional see [`Query.prototype.setOptions()`](http://mongoosejs.com/docs/api.html#query_Query-setOptions)
  * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](http://mongoosejs.com/docs/guide.html#strict)
+ * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
+ * @param {Object} [options.writeConcern=null] sets the [write concern](https://docs.mongodb.com/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](/docs/guide.html#writeConcern)
  * @param {Boolean} [options.omitUndefined=false] If true, delete any properties whose value is `undefined` when casting an update. In other words, if this is set, Mongoose will delete `baz` from the update in `Model.updateOne({}, { foo: 'bar', baz: undefined })` before sending the update to the server.
- * @param {Function} [callback]
+ * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
+ * @param {Function} [callback] `function(error, res) {}` where `res` has 3 properties: `n`, `nModified`, `ok`.
  * @return {Query}
+ * @see Query docs https://mongoosejs.com/docs/queries.html
  * @see MongoDB docs https://docs.mongodb.com/manual/reference/command/update/#update-command-output
+ * @see writeOpResult http://mongodb.github.io/node-mongodb-native/2.2/api/Collection.html#~WriteOpResult
  * @api public
  */
 
@@ -3317,10 +3405,15 @@ Model.updateMany = function updateMany(conditions, doc, options, callback) {
  * @param {Object} doc
  * @param {Object} [options] optional see [`Query.prototype.setOptions()`](http://mongoosejs.com/docs/api.html#query_Query-setOptions)
  * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](http://mongoosejs.com/docs/guide.html#strict)
+ * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
+ * @param {Object} [options.writeConcern=null] sets the [write concern](https://docs.mongodb.com/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](/docs/guide.html#writeConcern)
  * @param {Boolean} [options.omitUndefined=false] If true, delete any properties whose value is `undefined` when casting an update. In other words, if this is set, Mongoose will delete `baz` from the update in `Model.updateOne({}, { foo: 'bar', baz: undefined })` before sending the update to the server.
- * @param {Function} [callback]
+ * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
+ * @param {Function} [callback] params are (error, writeOpResult)
  * @return {Query}
+ * @see Query docs https://mongoosejs.com/docs/queries.html
  * @see MongoDB docs https://docs.mongodb.com/manual/reference/command/update/#update-command-output
+ * @see writeOpResult http://mongodb.github.io/node-mongodb-native/2.2/api/Collection.html#~WriteOpResult
  * @api public
  */
 
@@ -3345,8 +3438,14 @@ Model.updateOne = function updateOne(conditions, doc, options, callback) {
  * @param {Object} doc
  * @param {Object} [options] optional see [`Query.prototype.setOptions()`](http://mongoosejs.com/docs/api.html#query_Query-setOptions)
  * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](http://mongoosejs.com/docs/guide.html#strict)
+ * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
+ * @param {Object} [options.writeConcern=null] sets the [write concern](https://docs.mongodb.com/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](/docs/guide.html#writeConcern)
  * @param {Boolean} [options.omitUndefined=false] If true, delete any properties whose value is `undefined` when casting an update. In other words, if this is set, Mongoose will delete `baz` from the update in `Model.updateOne({}, { foo: 'bar', baz: undefined })` before sending the update to the server.
- * @param {Function} [callback]
+ * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
+ * @param {Function} [callback] `function(error, res) {}` where `res` has 3 properties: `n`, `nModified`, `ok`.
+ * @return {Query}
+ * @see Query docs https://mongoosejs.com/docs/queries.html
+ * @see writeOpResult http://mongodb.github.io/node-mongodb-native/2.2/api/Collection.html#~WriteOpResult
  * @return {Query}
  * @api public
  */
@@ -3728,6 +3827,7 @@ Model.geoSearch = function(conditions, options, callback) {
  * @param {boolean} [options.retainNullValues=false] by default, Mongoose removes null and undefined values from populated arrays. Use this option to make `populate()` retain `null` and `undefined` array entries.
  * @param {boolean} [options.getters=false] if true, Mongoose will call any getters defined on the `localField`. By default, Mongoose gets the raw value of `localField`. For example, you would need to set this option to `true` if you wanted to [add a `lowercase` getter to your `localField`](/docs/schematypes.html#schematype-options).
  * @param {boolean} [options.clone=false] When you do `BlogPost.find().populate('author')`, blog posts with the same author will share 1 copy of an `author` doc. Enable this option to make Mongoose clone populated docs before assigning them.
+ * @param {Object|Function} [options.match=null] Add an additional filter to the populate query. Can be a filter object containing [MongoDB query syntax](https://docs.mongodb.com/manual/tutorial/query-documents/), or a function that returns a filter object.
  * @param {Function} [callback(err,doc)] Optional callback, executed upon completion. Receives `err` and the `doc(s)`.
  * @return {Promise}
  * @api public
@@ -3827,15 +3927,7 @@ function populate(model, docs, options, callback) {
   for (let i = 0; i < len; ++i) {
     mod = modelsMap[i];
     select = mod.options.select;
-
-    if (mod.options.match) {
-      match = utils.object.shallowCopy(mod.options.match);
-    } else if (get(mod, 'options.options.match')) {
-      match = utils.object.shallowCopy(mod.options.options.match);
-      delete mod.options.options.match;
-    } else {
-      match = {};
-    }
+    match = _formatMatch(mod.match);
 
     let ids = utils.array.flatten(mod.ids, flatten);
     ids = utils.array.unique(ids);
@@ -3852,10 +3944,16 @@ function populate(model, docs, options, callback) {
         match[foreignField] = { $in: ids };
       }
     } else {
-      match.$or = [];
+      const $or = [];
+      if (Array.isArray(match.$or)) {
+        match.$and = [{ $or: match.$or }, { $or: $or }];
+        delete match.$or;
+      } else {
+        match.$or = $or;
+      }
       for (const foreignField of mod.foreignField) {
         if (foreignField !== '_id' || !match['_id']) {
-          match.$or.push({ [foreignField]: { $in: ids } });
+          $or.push({ [foreignField]: { $in: ids } });
         }
       }
     }
@@ -4029,11 +4127,27 @@ function populate(model, docs, options, callback) {
       allOptions: mod,
       lean: lean,
       virtual: mod.virtual,
-      count: mod.count
+      count: mod.count,
+      match: mod.match
     });
   }
 }
 
+/*!
+ * Format `mod.match` given that it may be an array that we need to $or if
+ * the client has multiple docs with match functions
+ */
+
+function _formatMatch(match) {
+  if (Array.isArray(match)) {
+    if (match.length > 1) {
+      return { $or: [].concat(match.map(m => Object.assign({}, m))) };
+    }
+    return Object.assign({}, match[0]);
+  }
+  return Object.assign({}, match);
+}
+
 function getModelsMapForPopulate(model, docs, options) {
   let i;
   let doc;
@@ -4187,6 +4301,15 @@ function getModelsMapForPopulate(model, docs, options) {
     const id = String(utils.getValue(foreignField, doc));
     options._docs[id] = Array.isArray(ret) ? ret.slice() : ret;
 
+    let match = get(options, 'match', null) ||
+      get(currentOptions, 'match', null) ||
+      get(options, 'virtual.options.options.match', null);
+
+    const hasMatchFunction = typeof match === 'function';
+    if (hasMatchFunction) {
+      match = match.call(doc, doc);
+    }
+
     let k = modelNames.length;
     while (k--) {
       modelName = modelNames[k];
@@ -4225,6 +4348,7 @@ function getModelsMapForPopulate(model, docs, options) {
         available[modelName] = {
           model: Model,
           options: currentOptions,
+          match: hasMatchFunction ? [match] : match,
           docs: [doc],
           ids: [ids],
           allIds: [ret],
@@ -4242,6 +4366,9 @@ function getModelsMapForPopulate(model, docs, options) {
         available[modelName].docs.push(doc);
         available[modelName].ids.push(ids);
         available[modelName].allIds.push(ret);
+        if (hasMatchFunction) {
+          available[modelName].match.push(match);
+        }
       }
     }
   }
@@ -4360,7 +4487,7 @@ function convertTo_id(val) {
       }
     }
     if (val.isMongooseArray && val._schema) {
-      return val._schema.cast(val, val._parent);
+      return val._schema.cast(val, val.$parent());
     }
 
     return [].concat(val);
@@ -4469,7 +4596,8 @@ Model.compile = function compile(name, schema, collectionName, connection, base)
 
   const collectionOptions = {
     bufferCommands: bufferCommands,
-    capped: schema.options.capped
+    capped: schema.options.capped,
+    Promise: model.base.Promise
   };
 
   model.prototype.collection = connection.collection(
@@ -4482,6 +4610,7 @@ Model.compile = function compile(name, schema, collectionName, connection, base)
   applyMethods(model, schema);
   applyStatics(model, schema);
   applyHooks(model, schema);
+  applyStaticHooks(model, schema.s.hooks, schema.statics);
 
   model.schema = model.prototype.schema;
   model.collection = model.prototype.collection;
@@ -4495,13 +4624,6 @@ Model.compile = function compile(name, schema, collectionName, connection, base)
   applyQueryMiddleware(model.Query, model);
   applyQueryMethods(model, schema.query);
 
-  const kareemOptions = {
-    useErrorHandlers: true,
-    numCallbackParams: 1
-  };
-  model.$__insertMany = model.hooks.createWrapper('insertMany',
-    model.$__insertMany, model, kareemOptions);
-
   return model;
 };