mongoose 5.12.13 → 5.12.14

package/index.d.ts

@@ -368,7 +368,7 @@ declare module 'mongoose' {
   }
 
   class Document<T = any, TQueryHelpers = any> {
-    constructor(doc?: T | any);
+    constructor(doc?: any);
 
     /** This documents _id. */
     _id?: T;
@@ -1225,7 +1225,7 @@ declare module 'mongoose' {
     statics: { [name: string]: (this: M, ...args: any[]) => any };
 
     /** Creates a virtual type with the given name. */
-    virtual(name: string, options?: any): VirtualType;
+    virtual(name: string, options?: VirtualTypeOptions): VirtualType;
 
     /** Object of currently defined virtuals on this schema */
     virtuals: any;
@@ -1618,17 +1618,64 @@ declare module 'mongoose' {
     validator: ValidateFn<T> | LegacyAsyncValidateFn<T> | AsyncValidateFn<T>;
   }
 
+  interface VirtualTypeOptions {
+    /** If `ref` is not nullish, this becomes a populated virtual. */
+    ref?: string | Function;
+
+    /**  The local field to populate on if this is a populated virtual. */
+    localField?: string | Function;
+
+    /** The foreign field to populate on if this is a populated virtual. */
+    foreignField?: string | Function;
+
+    /**
+     * By default, a populated virtual is an array. If you set `justOne`,
+     * the populated virtual will be a single doc or `null`.
+     */
+    justOne?: boolean;
+
+    /** If you set this to `true`, Mongoose will call any custom getters you defined on this virtual. */
+    getters?: boolean;
+
+    /**
+     * If you set this to `true`, `populate()` will set this virtual to the number of populated
+     * documents, as opposed to the documents themselves, using `Query#countDocuments()`.
+     */
+    count?: boolean;
+
+    /** Add an extra match condition to `populate()`. */
+    match?: FilterQuery<any> | Function;
+
+    /** Add a default `limit` to the `populate()` query. */
+    limit?: number;
+
+    /** Add a default `skip` to the `populate()` query. */
+    skip?: number;
+
+    /**
+     * For legacy reasons, `limit` with `populate()` may give incorrect results because it only
+     * executes a single query for every document being populated. If you set `perDocumentLimit`,
+     * Mongoose will ensure correct `limit` per document by executing a separate query for each
+     * document to `populate()`. For example, `.find().populate({ path: 'test', perDocumentLimit: 2 })`
+     * will execute 2 additional queries if `.find()` returns 2 documents.
+     */
+    perDocumentLimit?: number;
+
+    /** Additional options like `limit` and `lean`. */
+    options?: QueryOptions;
+  }
+
   class VirtualType {
     /** Applies getters to `value`. */
     applyGetters(value: any, doc: Document): any;
+
     /** Applies setters to `value`. */
     applySetters(value: any, doc: Document): any;
 
     /** Adds a custom getter to this virtual. */
-    // eslint-disable-next-line @typescript-eslint/ban-types
     get(fn: Function): this;
+
     /** Adds a custom setter to this virtual. */
-    // eslint-disable-next-line @typescript-eslint/ban-types
     set(fn: Function): this;
   }
 
@@ -2760,7 +2807,7 @@ declare module 'mongoose' {
     export class ValidationError extends Error {
       name: 'ValidationError';
 
-      errors: { [path: string]: ValidatorError | CastError };
+      errors: { [path: string]: ValidatorError | CastError | ValidationError };
     }
 
     export class ValidatorError extends Error {

package/lib/document.js

@@ -2928,8 +2928,8 @@ Document.prototype.$__reset = function reset() {
       doc.$__reset();
       if (doc.$__parent === _this) {
         _this.$__.activePaths.init(doc.$basePath);
-      } else if (doc.$__parent != null) {
-        // If map path underneath nested path, may end up with a case where
+      } else if (doc.$__parent != null && doc.$__parent.ownerDocument) {
+        // If map path underneath subdocument, may end up with a case where
         // map path is modified but parent still needs to be reset. See gh-10295
         doc.$__parent.$__reset();
       }

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

@@ -7,6 +7,7 @@
 const MongooseCollection = require('../../collection');
 const MongooseError = require('../../error/mongooseError');
 const Collection = require('mongodb').Collection;
+const ObjectId = require('./objectid');
 const get = require('../../helpers/get');
 const sliced = require('sliced');
 const stream = require('stream');
@@ -21,9 +22,11 @@ const util = require('util');
  * @api private
  */
 
-function NativeCollection(name, options) {
+function NativeCollection(name, conn, options) {
   this.collection = null;
   this.Promise = options.Promise || Promise;
+  this.modelName = options.modelName;
+  delete options.modelName;
   this._closed = false;
   MongooseCollection.apply(this, arguments);
 }
@@ -128,6 +131,7 @@ function iter(i) {
     const _this = this;
     const debug = get(_this, 'conn.base.options.debug');
     const lastArg = arguments[arguments.length - 1];
+    const opId = new ObjectId();
 
     // If user force closed, queueing will hang forever. See #5664
     if (this.conn.$wasForceClosed) {
@@ -141,12 +145,20 @@ function iter(i) {
       }
     }
 
+    let _args = args;
+    let callback = null;
     if (this._shouldBufferCommands() && this.buffer) {
       if (syncCollectionMethods[i]) {
         throw new Error('Collection method ' + i + ' is synchronous');
       }
 
-      this.conn.emit('buffer', { method: i, args: args });
+      this.conn.emit('buffer', {
+        _id: opId,
+        modelName: _this.modelName,
+        collectionName: _this.name,
+        method: i,
+        args: args
+      });
 
       let callback;
       let _args;
@@ -182,7 +194,9 @@ function iter(i) {
         if (removed) {
           const message = 'Operation `' + this.name + '.' + i + '()` buffering timed out after ' +
             bufferTimeoutMS + 'ms';
-          callback(new MongooseError(message));
+          const err = new MongooseError(message);
+          this.conn.emit('buffer-end', { _id: opId, modelName: _this.modelName, collectionName: _this.name, method: i, error: err });
+          callback(err);
         }
       }, bufferTimeoutMS);
 
@@ -192,6 +206,16 @@ function iter(i) {
       }
 
       return promise;
+    } else if (!syncCollectionMethods[i] && typeof lastArg === 'function') {
+      callback = function collectionOperationCallback(err, res) {
+        if (err != null) {
+          _this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: _this.name, method: i, error: err });
+        } else {
+          _this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: _this.name, method: i, result: res });
+        }
+        return lastArg.apply(this, arguments);
+      };
+      _args = args.slice(0, args.length - 1).concat([callback]);
     }
 
     if (debug) {
@@ -207,6 +231,8 @@ function iter(i) {
       }
     }
 
+    this.conn.emit('operation-start', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, params: _args });
+
     try {
       if (collection == null) {
         const message = 'Cannot call `' + this.name + '.' + i + '()` before initial connection ' +
@@ -214,13 +240,30 @@ function iter(i) {
           'you have `bufferCommands = false`.';
         throw new MongooseError(message);
       }
-      return collection[i].apply(collection, args);
+      const ret = collection[i].apply(collection, _args);
+      if (ret != null && typeof ret.then === 'function') {
+        return ret.then(
+          res => {
+            this.conn.emit('operation-end', { _id: opId, modelName: this.modelName, collectionName: this.name, method: i, result: res });
+            return res;
+          },
+          err => {
+            this.conn.emit('operation-end', { _id: opId, modelName: this.modelName, collectionName: this.name, method: i, error: err });
+            throw err;
+          }
+        );
+      }
+      return ret;
     } catch (error) {
       // Collection operation may throw because of max bson size, catch it here
       // See gh-3906
-      if (args.length > 0 &&
-          typeof args[args.length - 1] === 'function') {
-        args[args.length - 1](error);
+      if (typeof callback === 'function') {
+        callback(error);
+      } else {
+        this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, error: error });
+      }
+      if (typeof lastArg === 'function') {
+        lastArg(error);
       } else {
         throw error;
       }

package/lib/helpers/arrayDepth.js

@@ -9,6 +9,9 @@ function arrayDepth(arr) {
   if (arr.length === 0) {
     return { min: 1, max: 1, containsNonArrayItem: false };
   }
+  if (arr.length === 1 && !Array.isArray(arr[0])) {
+    return { min: 1, max: 1, containsNonArrayItem: false };
+  }
 
   const res = arrayDepth(arr[0]);
 

package/lib/helpers/populate/getModelsMapForPopulate.js

@@ -53,7 +53,7 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
     }
     // Populating a nested path should always be a no-op re: #9073.
     // People shouldn't do this, but apparently they do.
-    if (modelSchema.nested[options.path]) {
+    if (options._localModel != null && options._localModel.schema.nested[options.path]) {
       continue;
     }
     const isUnderneathDocArray = schema && schema.$isUnderneathDocArray;

package/lib/model.js

@@ -1073,6 +1073,7 @@ Model.prototype.model = function model(name) {
  * - `findOne()`
  *
  * @param {Object} filter
+ * @param {Object} [options] optional see [`Query.prototype.setOptions()`](http://mongoosejs.com/docs/api.html#query_Query-setOptions)
  * @param {Function} [callback] callback
  * @return {Promise}
  */
@@ -4744,7 +4745,8 @@ Model.compile = function compile(name, schema, collectionName, connection, base)
   const collectionOptions = {
     schemaUserProvidedOptions: _userProvidedOptions,
     capped: schema.options.capped,
-    Promise: model.base.Promise
+    Promise: model.base.Promise,
+    modelName: name
   };
   if (schema.options.autoCreate !== void 0) {
     collectionOptions.autoCreate = schema.options.autoCreate;

package/lib/queryhelpers.js

@@ -31,6 +31,10 @@ exports.preparePopulationOptions = function preparePopulationOptions(query, opti
       forEach(makeLean(options.lean));
   }
 
+  pop.forEach(opts => {
+    opts._localModel = query.model;
+  });
+
   return pop;
 };
 
@@ -71,6 +75,9 @@ exports.preparePopulationOptionsMQ = function preparePopulationOptionsMQ(query,
   pop.forEach(p => {
     p._queryProjection = projection;
   });
+  pop.forEach(opts => {
+    opts._localModel = query.model;
+  });
 
   return pop;
 };

package/lib/schema/array.js

@@ -282,14 +282,14 @@ SchemaArray.prototype.applyGetters = function(value, scope) {
 };
 
 SchemaArray.prototype._applySetters = function(value, scope, init, priorVal) {
-  if (this.casterConstructor instanceof SchemaArray &&
+  if (this.casterConstructor.$isMongooseArray &&
       SchemaArray.options.castNonArrays &&
       !this[isNestedArraySymbol]) {
     // Check nesting levels and wrap in array if necessary
     let depth = 0;
     let arr = this;
     while (arr != null &&
-      arr instanceof SchemaArray &&
+      arr.$isMongooseArray &&
       !arr.$isMongooseDocumentArray) {
       ++depth;
       arr = arr.casterConstructor;
@@ -361,20 +361,22 @@ SchemaArray.prototype.cast = function(value, doc, init, prev, options) {
     }
 
     const caster = this.caster;
+    const isMongooseArray = caster.$isMongooseArray;
+    const isArrayOfNumbers = caster.instance === 'Number';
     if (caster && this.casterConstructor !== Mixed) {
       try {
         for (i = 0; i < len; i++) {
           // Special case: number arrays disallow undefined.
           // Re: gh-840
           // See commit 1298fe92d2c790a90594bd08199e45a4a09162a6
-          if (caster.instance === 'Number' && value[i] === void 0) {
+          if (isArrayOfNumbers && value[i] === void 0) {
             throw new MongooseError('Mongoose number arrays disallow storing undefined');
           }
           const opts = {};
           // Perf: creating `arrayPath` is expensive for large arrays.
           // We only need `arrayPath` if this is a nested array, so
           // skip if possible.
-          if (caster.$isMongooseArray) {
+          if (isMongooseArray) {
             if (options.arrayPath != null) {
               opts.arrayPathIndex = i;
             } else if (caster._arrayParentPath != null) {

package/lib/schema.js

@@ -694,6 +694,10 @@ Schema.prototype.path = function(path, obj) {
         !utils.hasUserDefinedProperty(obj.of, this.options.typeKey);
       _mapType = isInlineSchema ? new Schema(obj.of) : obj.of;
     }
+    if (utils.hasUserDefinedProperty(obj, 'ref')) {
+      _mapType = { type: _mapType, ref: obj.ref };
+    }
+
     this.paths[mapPath] = this.interpretAsType(mapPath,
       _mapType, this.options);
     this.mapPaths.push(this.paths[mapPath]);
@@ -773,12 +777,18 @@ Schema.prototype.path = function(path, obj) {
 
   if (schemaType.$isMongooseDocumentArray) {
     for (const key of Object.keys(schemaType.schema.paths)) {
-      this.subpaths[path + '.' + key] = schemaType.schema.paths[key];
-      schemaType.schema.paths[key].$isUnderneathDocArray = true;
+      const _schemaType = schemaType.schema.paths[key];
+      this.subpaths[path + '.' + key] = _schemaType;
+      if (typeof _schemaType === 'object' && _schemaType != null) {
+        _schemaType.$isUnderneathDocArray = true;
+      }
     }
     for (const key of Object.keys(schemaType.schema.subpaths)) {
-      this.subpaths[path + '.' + key] = schemaType.schema.subpaths[key];
-      schemaType.schema.subpaths[key].$isUnderneathDocArray = true;
+      const _schemaType = schemaType.schema.subpaths[key];
+      this.subpaths[path + '.' + key] = _schemaType;
+      if (typeof _schemaType === 'object' && _schemaType != null) {
+        _schemaType.$isUnderneathDocArray = true;
+      }
     }
     for (const key of Object.keys(schemaType.schema.singleNestedPaths)) {
       const _schemaType = schemaType.schema.singleNestedPaths[key];

package/lib/types/array.js

@@ -5,7 +5,6 @@
 'use strict';
 
 const CoreMongooseArray = require('./core_array');
-const Document = require('../document');
 
 const arrayAtomicsSymbol = require('../helpers/symbols').arrayAtomicsSymbol;
 const arrayParentSymbol = require('../helpers/symbols').arrayParentSymbol;
@@ -56,22 +55,18 @@ function MongooseArray(values, path, doc, schematype) {
 
     if (values[arrayAtomicsSymbol] != null) {
       arr[arrayAtomicsSymbol] = values[arrayAtomicsSymbol];
-    } else {
-      arr[arrayAtomicsSymbol] = {};
     }
   } else {
     arr = new CoreMongooseArray();
-    arr[arrayAtomicsSymbol] = {};
   }
 
   arr[arrayPathSymbol] = path;
-  arr[arraySchemaSymbol] = void 0;
 
   // Because doc comes from the context of another function, doc === global
   // can happen if there was a null somewhere up the chain (see #3020)
   // RB Jun 17, 2015 updated to check for presence of expected paths instead
   // to make more proof against unusual node environments
-  if (doc && doc instanceof Document) {
+  if (doc != null && doc.$__ != null) {
     arr[arrayParentSymbol] = doc;
     arr[arraySchemaSymbol] = schematype || doc.schema.path(path);
   }

package/lib/types/core_array.js

@@ -94,7 +94,7 @@ class CoreMongooseArray extends Array {
    */
 
   $atomics() {
-    return this[arrayAtomicsSymbol];
+    return this[arrayAtomicsSymbol] || {};
   }
 
   /*!
@@ -328,6 +328,8 @@ class CoreMongooseArray extends Array {
       return this;
     }
 
+    this[arrayAtomicsSymbol] || (this[arrayAtomicsSymbol] = {});
+
     const atomics = this[arrayAtomicsSymbol];
 
     // reset pop/shift after save

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "5.12.13",
+  "version": "5.12.14",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -40,7 +40,6 @@
     "acquit": "1.x",
     "acquit-ignore": "0.1.x",
     "acquit-require": "0.1.x",
-    "async": "2.6.2",
     "babel-loader": "8.1.0",
     "benchmark": "2.1.4",
     "bluebird": "3.5.5",