mongoose 5.0.18 → 5.1.0

package/lib/schema.js

@@ -1,3 +1,5 @@
+'use strict';
+
 /*!
  * Module dependencies.
  */
@@ -72,6 +74,7 @@ function Schema(obj, options) {
   this.callQueue = [];
   this._indexes = [];
   this.methods = {};
+  this.methodOptions = {};
   this.statics = {};
   this.tree = {};
   this.query = {};
@@ -239,6 +242,7 @@ Schema.prototype.clone = function() {
   s.options = utils.clone(this.options);
   s.callQueue = this.callQueue.map(function(f) { return f; });
   s.methods = utils.clone(this.methods);
+  s.methodOptions = utils.clone(this.methodOptions);
   s.statics = utils.clone(this.statics);
   s.query = utils.clone(this.query);
   s.plugins = Array.prototype.slice.call(this.plugins);
@@ -381,6 +385,7 @@ Schema.prototype.add = function add(obj, prefix) {
  */
 
 Schema.reserved = Object.create(null);
+Schema.prototype.reserved = Schema.reserved;
 var reserved = Schema.reserved;
 // Core object
 reserved['prototype'] =
@@ -443,6 +448,17 @@ Schema.prototype.path = function(path, obj) {
       return this.singleNestedPaths[path];
     }
 
+    // Look for maps
+    for (let _path of Object.keys(this.paths)) {
+      if (!_path.includes('.$*')) {
+        continue;
+      }
+      const re = new RegExp('^' + _path.replace(/\.\$\*/g, '.[^.]+') + '$');
+      if (re.test(path)) {
+        return this.paths[_path];
+      }
+    }
+
     // subpaths?
     return /\.\d+\.?.*$/.test(path)
       ? getPositionalPath(this, path)
@@ -459,16 +475,16 @@ Schema.prototype.path = function(path, obj) {
   }
 
   // update the tree
-  var subpaths = path.split(/\./),
-      last = subpaths.pop(),
-      branch = this.tree;
+  const subpaths = path.split(/\./);
+  let last = subpaths.pop();
+  let branch = this.tree;
 
   subpaths.forEach(function(sub, i) {
     if (!branch[sub]) {
       branch[sub] = {};
     }
     if (typeof branch[sub] !== 'object') {
-      var msg = 'Cannot set nested path `' + path + '`. '
+      const msg = 'Cannot set nested path `' + path + '`. '
           + 'Parent path `'
           + subpaths.slice(0, i).concat([sub]).join('.')
           + '` already set to type ' + branch[sub].name
@@ -478,17 +494,26 @@ Schema.prototype.path = function(path, obj) {
     branch = branch[sub];
   });
 
-
   branch[last] = utils.clone(obj);
 
   this.paths[path] = Schema.interpretAsType(path, obj, this.options);
 
+  if (this.paths[path].$isSchemaMap) {
+    // Maps can have arbitrary keys, so `$*` is internal shorthand for "any key"
+    // The '$' is to imply this path should never be stored in MongoDB so we
+    // can easily build a regexp out of this path, and '*' to imply "any key."
+    const mapPath = path + '.$*';
+    this.paths[path + '.$*'] = Schema.interpretAsType(mapPath,
+      obj.of || { type: {} }, this.options);
+    this.paths[path].$__schemaType = this.paths[path + '.$*'];
+  }
+
   if (this.paths[path].$isSingleNested) {
-    for (var key in this.paths[path].schema.paths) {
+    for (let key in this.paths[path].schema.paths) {
       this.singleNestedPaths[path + '.' + key] =
           this.paths[path].schema.paths[key];
     }
-    for (key in this.paths[path].schema.singleNestedPaths) {
+    for (let key in this.paths[path].schema.singleNestedPaths) {
       this.singleNestedPaths[path + '.' + key] =
           this.paths[path].schema.singleNestedPaths[key];
     }
@@ -722,6 +747,17 @@ Schema.prototype.pathType = function(path) {
     return 'real';
   }
 
+  // Look for maps
+  for (let _path of Object.keys(this.paths)) {
+    if (!_path.includes('.$*')) {
+      continue;
+    }
+    const re = new RegExp('^' + _path.replace(/\.\$\*/g, '.[^.]+') + '$');
+    if (re.test(path)) {
+      return this.paths[_path];
+    }
+  }
+
   if (/\.\d+\.|\.\d+$/.test(path)) {
     return getPositionalPathType(this, path);
   }
@@ -1183,13 +1219,15 @@ Schema.prototype.plugin = function(fn, opts) {
  * @api public
  */
 
-Schema.prototype.method = function(name, fn) {
+Schema.prototype.method = function(name, fn, options) {
   if (typeof name !== 'string') {
-    for (var i in name) {
+    for (const i in name) {
       this.methods[i] = name[i];
+      this.methodOptions[i] = utils.clone(options);
     }
   } else {
     this.methods[name] = fn;
+    this.methodOptions[name] = utils.clone(options);
   }
   return this;
 };

package/lib/schematype.js

@@ -1035,6 +1035,24 @@ function handleArray(val) {
   });
 }
 
+/*!
+ * Just like handleArray, except also allows `[]` because surprisingly
+ * `$in: [1, []]` works fine
+ */
+
+function handle$in(val) {
+  var _this = this;
+  if (!Array.isArray(val)) {
+    return [this.castForQuery(val)];
+  }
+  return val.map(function(m) {
+    if (Array.isArray(m) && m.length === 0) {
+      return m;
+    }
+    return _this.castForQuery(m);
+  });
+}
+
 /*!
  * ignore
  */
@@ -1042,7 +1060,7 @@ function handleArray(val) {
 SchemaType.prototype.$conditionalHandlers = {
   $all: handleArray,
   $eq: handleSingle,
-  $in: handleArray,
+  $in: handle$in,
   $ne: handleSingle,
   $nin: handleArray,
   $exists: $exists,

package/lib/services/model/applyMethods.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const get = require('lodash.get');
+
 /*!
  * Register methods for this model
  *
@@ -20,13 +22,21 @@ module.exports = function applyMethods(model, schema) {
       configurable: true
     });
   }
-  for (var method in schema.methods) {
+  for (const method of Object.keys(schema.methods)) {
+    const fn = schema.methods[method];
     if (schema.tree.hasOwnProperty(method)) {
       throw new Error('You have a method and a property in your schema both ' +
         'named "' + method + '"');
     }
-    if (typeof schema.methods[method] === 'function') {
-      model.prototype[method] = schema.methods[method];
+    if (schema.reserved[method] &&
+        !get(schema, `methodOptions.${method}.suppressWarning`, false)) {
+      console.warn(`mongoose: the method name "${method}" is used by mongoose ` +
+        'internally, overwriting it may cause bugs. If you\'re sure you know ' +
+        'what you\'re doing, you can suppress this error by using ' +
+        `\`schema.method('${method}', fn, { suppressWarning: true })\`.`);
+    }
+    if (typeof fn === 'function') {
+      model.prototype[method] = fn;
     } else {
       apply(method, schema);
     }
@@ -34,7 +44,7 @@ module.exports = function applyMethods(model, schema) {
 
   // Recursively call `applyMethods()` on child schemas
   model.$appliedMethods = true;
-  for (var i = 0; i < schema.childSchemas.length; ++i) {
+  for (let i = 0; i < schema.childSchemas.length; ++i) {
     if (schema.childSchemas[i].model.$appliedMethods) {
       continue;
     }

package/lib/services/query/completeMany.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const helpers = require('../../queryhelpers');
+
+module.exports = completeMany;
+
+/*!
+ * Given a model and an array of docs, hydrates all the docs to be instances
+ * of the model. Used to initialize docs returned from the db from `find()`
+ *
+ * @param {Model} model
+ * @param {Array} docs
+ * @param {Object} fields the projection used, including `select` from schemas
+ * @param {Object} userProvidedFields the user-specified projection
+ * @param {Object} opts
+ * @param {Array} [opts.populated]
+ * @param {ClientSession} [opts.session]
+ * @param {Function} callback
+ */
+
+function completeMany(model, docs, fields, userProvidedFields, opts, callback) {
+  const arr = [];
+  let count = docs.length;
+  const len = count;
+  let error = null;
+
+  function init(_error) {
+    if (_error != null) {
+      error = error || _error;
+    }
+    if (error != null) {
+      --count || process.nextTick(() => callback(error));
+      return;
+    }
+    --count || process.nextTick(() => callback(error, arr));
+  }
+
+  for (let i = 0; i < len; ++i) {
+    arr[i] = helpers.createModel(model, docs[i], fields, userProvidedFields);
+    try {
+      arr[i].init(docs[i], opts, init);
+    } catch (error) {
+      init(error);
+    }
+    arr[i].$session(opts.session);
+  }
+}

package/lib/types/embedded.js

@@ -107,7 +107,20 @@ EmbeddedDocument.prototype.populate = function() {
  * @api private
  */
 
-EmbeddedDocument.prototype.save = function(fn) {
+EmbeddedDocument.prototype.save = function(options, fn) {
+  if (typeof options === 'function') {
+    fn = options;
+    options = {};
+  }
+  options = options || {};
+
+  if (!options.suppressWarning) {
+    console.warn('mongoose: calling `save()` on a subdoc does **not** save ' +
+      'the document to MongoDB, it only runs save middleware. ' +
+      'Use `subdoc.save({ suppressWarning: true })` to hide this warning ' +
+      'if you\'re sure this behavior is right for your app.');
+  }
+
   return utils.promiseOrCallback(fn, cb => {
     this.$__save(cb);
   });
@@ -274,6 +287,25 @@ EmbeddedDocument.prototype.$markValid = function(path) {
   }
 };
 
+/*!
+ * ignore
+ */
+
+EmbeddedDocument.prototype.$ignore = function(path) {
+  Document.prototype.$ignore.call(this, path);
+
+  if (!this.__parent) {
+    return;
+  }
+
+  var index = this.__index;
+  if (typeof index !== 'undefined') {
+    var parentPath = this.__parentArray._path;
+    var fullPath = [parentPath, index, path].join('.');
+    this.__parent.$ignore(fullPath);
+  }
+};
+
 /**
  * Checks if a path is invalid
  *

package/lib/types/index.js

@@ -13,4 +13,6 @@ exports.DocumentArray = require('./documentarray');
 exports.Decimal128 = require('./decimal128');
 exports.ObjectId = require('./objectid');
 
+exports.Map = require('./map');
+
 exports.Subdocument = require('./subdocument');

package/lib/types/map.js

@@ -0,0 +1,144 @@
+'use strict';
+
+/*!
+ * ignore
+ */
+
+class MongooseMap extends Map {
+  constructor(v, path, doc, schemaType) {
+    if (v != null && v.constructor.name === 'Object') {
+      v = Object.keys(v).reduce((arr, key) => arr.concat([[key, v[key]]]), []);
+    }
+    super(v);
+
+    this.$__parent = doc;
+    this.$__path = path;
+    this.$__schemaType = schemaType;
+
+    this.$__runDeferred();
+  }
+
+  $init(key, value) {
+    if (key.startsWith('$')) {
+      throw new Error('Mongoose maps do not support keys that start with ' +
+        '`$`, got "' + key + '"');
+    }
+    if (key.indexOf('.') !== -1) {
+      throw new Error('Mongoose maps do not support keys that contain `.`, ' +
+        'got "' + key + '"');
+    }
+
+    super.set(key, value);
+
+    if (value != null && value.$isSingleNested) {
+      value.$basePath = this.$__path + '.' + key;
+    }
+  }
+
+  set(key, value) {
+    if (key.startsWith('$')) {
+      throw new Error('Mongoose maps do not support keys that start with ' +
+        '`$`, got "' + key + '"');
+    }
+    if (key.indexOf('.') !== -1) {
+      throw new Error('Mongoose maps do not support keys that contain `.`, ' +
+        'got "' + key + '"');
+    }
+
+    // Weird, but because you can't assign to `this` before calling `super()`
+    // you can't get access to `$__schemaType` to cast in the initial call to
+    // `set()` from the `super()` constructor.
+
+    if (this.$__schemaType == null) {
+      this.$__deferred = this.$__deferred || [];
+      this.$__deferred.push({ key: key, value: value });
+      return;
+    }
+
+    const fullPath = this.$__path + '.' + key;
+    const populated = this.$__parent != null && this.$__parent.$__ ?
+      this.$__parent.populated(fullPath) || this.$__parent.populated(this.$__path) :
+      null;
+
+    if (populated != null) {
+      if (value.$__ == null) {
+        value = new populated.options.model(value);
+      }
+      value.$__.wasPopulated = true;
+    } else {
+      try {
+        value = this.$__schemaType.
+          applySetters(value, this.$__parent, false, this.get(key));
+      } catch (error) {
+        this.$__parent.invalidate(fullPath, error);
+        return;
+      }
+    }
+
+    super.set(key, value);
+
+    if (value != null && value.$isSingleNested) {
+      value.$basePath = this.$__path + '.' + key;
+    }
+
+    if (this.$__parent != null && this.$__parent.$__) {
+      this.$__parent.markModified(this.$__path + '.' + key);
+    }
+  }
+
+  toBSON() {
+    return new Map(this);
+  }
+
+  toJSON() {
+    return new Map(this);
+  }
+
+  inspect() {
+    return new Map(this);
+  }
+
+  $__runDeferred() {
+    if (!this.$__deferred) {
+      return;
+    }
+    for (let i = 0; i < this.$__deferred.length; ++i) {
+      this.set(this.$__deferred[i].key, this.$__deferred[i].value);
+    }
+    this.$__deferred = null;
+  }
+}
+
+Object.defineProperty(MongooseMap.prototype, '$__parent', {
+  enumerable: false,
+  writable: true,
+  configurable: false
+});
+
+Object.defineProperty(MongooseMap.prototype, '$__path', {
+  enumerable: false,
+  writable: true,
+  configurable: false
+});
+
+Object.defineProperty(MongooseMap.prototype, '$__schemaType', {
+  enumerable: false,
+  writable: true,
+  configurable: false
+});
+
+Object.defineProperty(MongooseMap.prototype, '$isMongooseMap', {
+  enumerable: false,
+  writable: false,
+  configurable: false,
+  value: true
+});
+
+Object.defineProperty(MongooseMap.prototype, '$__deferredCalls', {
+  enumerable: false,
+  writable: false,
+  configurable: false,
+  value: true
+});
+
+module.exports = MongooseMap;

package/lib/types/objectid.js

@@ -10,4 +10,16 @@
 
 var ObjectId = require('../drivers').ObjectId;
 
+/*!
+ * Getter for convenience with populate, see gh-6115
+ */
+
+Object.defineProperty(ObjectId.prototype, '_id', {
+  enumerable: false,
+  configurable: true,
+  get: function() {
+    return this;
+  }
+});
+
 module.exports = ObjectId;

package/lib/types/subdocument.js

@@ -36,7 +36,20 @@ Subdocument.prototype.toBSON = function() {
  * @api private
  */
 
-Subdocument.prototype.save = function(fn) {
+Subdocument.prototype.save = function(options, fn) {
+  if (typeof options === 'function') {
+    fn = options;
+    options = {};
+  }
+  options = options || {};
+
+  if (!options.suppressWarning) {
+    console.warn('mongoose: calling `save()` on a subdoc does **not** save ' +
+      'the document to MongoDB, it only runs save middleware. ' +
+      'Use `subdoc.save({ suppressWarning: true })` to hide this warning ' +
+      'if you\'re sure this behavior is right for your app.');
+  }
+
   return utils.promiseOrCallback(fn, cb => {
     this.$__save(cb);
   });
@@ -67,6 +80,7 @@ Subdocument.prototype.$isValid = function(path) {
 
 Subdocument.prototype.markModified = function(path) {
   Document.prototype.markModified.call(this, path);
+
   if (this.$parent && this.$basePath) {
     if (this.$parent.isDirectModified(this.$basePath)) {
       return;
@@ -82,6 +96,10 @@ Subdocument.prototype.$markValid = function(path) {
   }
 };
 
+/*!
+ * ignore
+ */
+
 Subdocument.prototype.invalidate = function(path, err, val) {
   // Hack: array subdocuments' validationError is equal to the owner doc's,
   // so validating an array subdoc gives the top-level doc back. Temporary
@@ -97,6 +115,17 @@ Subdocument.prototype.invalidate = function(path, err, val) {
   }
 };
 
+/*!
+ * ignore
+ */
+
+Subdocument.prototype.$ignore = function(path) {
+  Document.prototype.$ignore.call(this, path);
+  if (this.$parent && this.$basePath) {
+    this.$parent.$ignore([this.$basePath, path].join('.'));
+  }
+};
+
 /**
  * Returns the top level document of this sub-document.
  *

package/lib/utils.js

@@ -446,9 +446,11 @@ exports.isMongooseObject = function(v) {
   MongooseArray || (MongooseArray = require('./types').Array);
   MongooseBuffer || (MongooseBuffer = require('./types').Buffer);
 
-  return v instanceof Document ||
-      (v && v.isMongooseArray) ||
-      (v && v.isMongooseBuffer);
+  if (v == null) {
+    return false;
+  }
+
+  return v.$__ != null || v.isMongooseArray || v.isMongooseBuffer;
 };
 var isMongooseObject = exports.isMongooseObject;
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "5.0.18",
+  "version": "5.1.0",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",