mongoose 5.0.17 → 5.1.2

package/lib/schema/date.js

@@ -232,9 +232,12 @@ SchemaDate.prototype.cast = function(value) {
 
   if (value instanceof Number || typeof value === 'number') {
     date = new Date(value);
+  } else if (typeof value === 'string' && !isNaN(Number(value)) && (Number(value) >= 275761 || Number(value) < -271820)) {
+    // string representation of milliseconds take this path
+    date = new Date(Number(value));
   } else if (typeof value.valueOf === 'function') {
-    // support for moment.js. This is also the path strings will take because strings
-    // have a `valueOf()`
+    // support for moment.js. This is also the path strings will take because
+    // strings have a `valueOf()`
     date = new Date(value.valueOf());
   } else {
     // fallback

package/lib/schema/decimal128.js

@@ -128,6 +128,10 @@ Decimal128.prototype.cast = function(value, doc, init) {
     return Decimal128Type.fromString(String(value));
   }
 
+  if (typeof value.valueOf === 'function' && typeof value.valueOf() === 'string') {
+    return Decimal128Type.fromString(value.valueOf());
+  }
+
   throw new CastError('Decimal128', value, this.path);
 };
 

package/lib/schema/embedded.js

@@ -219,7 +219,7 @@ Embedded.prototype.castForQuery = function($conditional, val) {
  * @api private
  */
 
-Embedded.prototype.doValidate = function(value, fn, scope) {
+Embedded.prototype.doValidate = function(value, fn, scope, options) {
   var Constructor = this.caster;
   var discriminatorKey = Constructor.schema.options.discriminatorKey;
   if (value != null &&
@@ -235,6 +235,13 @@ Embedded.prototype.doValidate = function(value, fn, scope) {
     }
   }
 
+  if (options && options.skipSchemaValidators) {
+    if (!(value instanceof Constructor)) {
+      value = new Constructor(value, null, scope);
+    }
+
+    return value.validate(fn);
+  }
 
   SchemaType.prototype.doValidate.call(this, value, function(error) {
     if (error) {
@@ -244,10 +251,7 @@ Embedded.prototype.doValidate = function(value, fn, scope) {
       return fn(null);
     }
 
-    if (!(value instanceof Constructor)) {
-      value = new Constructor(value);
-    }
-    value.validate({__noPromise: true}, fn);
+    value.validate(fn);
   }, scope);
 };
 
@@ -257,10 +261,12 @@ Embedded.prototype.doValidate = function(value, fn, scope) {
  * @api private
  */
 
-Embedded.prototype.doValidateSync = function(value, scope) {
-  var schemaTypeError = SchemaType.prototype.doValidateSync.call(this, value, scope);
-  if (schemaTypeError) {
-    return schemaTypeError;
+Embedded.prototype.doValidateSync = function(value, scope, options) {
+  if (!options || !options.skipSchemaValidators) {
+    var schemaTypeError = SchemaType.prototype.doValidateSync.call(this, value, scope);
+    if (schemaTypeError) {
+      return schemaTypeError;
+    }
   }
   if (!value) {
     return;

package/lib/schema/index.js

@@ -25,6 +25,8 @@ exports.Mixed = require('./mixed');
 
 exports.Decimal128 = exports.Decimal = require('./decimal128');
 
+exports.Map = require('./map');
+
 // alias
 
 exports.Oid = exports.ObjectId;

package/lib/schema/map.js

@@ -0,0 +1,29 @@
+'use strict';
+
+/*!
+ * ignore
+ */
+
+const MongooseMap = require('../types/map');
+const SchemaType = require('../schematype');
+
+/*!
+ * ignore
+ */
+
+class SchemaMap extends SchemaType {
+  constructor(key, options) {
+    super(key, options, 'Map');
+    this.$isSchemaMap = true;
+  }
+
+  cast(val, doc) {
+    if (val instanceof MongooseMap) {
+      return val;
+    }
+
+    return new MongooseMap(val, this.path, doc, this.$__schemaType);
+  }
+}
+
+module.exports = SchemaMap;

package/lib/schema/objectid.js

@@ -178,26 +178,6 @@ ObjectId.prototype.$conditionalHandlers =
       $lte: handleSingle
     });
 
-/**
- * Casts contents for queries.
- *
- * @param {String} $conditional
- * @param {any} [val]
- * @api private
- */
-
-ObjectId.prototype.castForQuery = function($conditional, val) {
-  var handler;
-  if (arguments.length === 2) {
-    handler = this.$conditionalHandlers[$conditional];
-    if (!handler) {
-      throw new Error('Can\'t use ' + $conditional + ' with ObjectId.');
-    }
-    return handler.call(this, val);
-  }
-  return this._castForQuery($conditional);
-};
-
 /*!
  * ignore
  */

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);
   }
@@ -1178,18 +1214,22 @@ Schema.prototype.plugin = function(fn, opts) {
  *     fizz.purr();
  *     fizz.scratch();
  *
+ * NOTE: `Schema.method()` adds instance methods to the `Schema.methods` object. You can also add instance methods directly to the `Schema.methods` object as seen in the [guide](./guide.html#methods)
+ *
  * @param {String|Object} method name
  * @param {Function} [fn]
  * @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/applyHooks.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const utils = require('../../utils');
+
 /*!
  * ignore
  */
@@ -54,6 +56,13 @@ function applyHooks(model, schema, options) {
 
   // Support hooks for custom methods
   const customMethods = Object.keys(schema.methods);
+  const customMethodOptions = Object.assign({}, kareemOptions, {
+    // Only use `checkForPromise` for custom methods, because mongoose
+    // query thunks are not as consistent as I would like about returning
+    // a nullish value rather than the query. If a query thunk returns
+    // a query, `checkForPromise` causes infinite recursion
+    checkForPromise: true
+  });
   for (const method of customMethods) {
     if (!schema.s.hooks.hasHooks(method)) {
       // Don't wrap if there are no hooks for the custom method to avoid
@@ -61,7 +70,18 @@ function applyHooks(model, schema, options) {
       // so wrapping a sync method would break it.
       continue;
     }
-    objToDecorate[method] = schema.s.hooks.
-      createWrapper(method, objToDecorate[method], null, kareemOptions);
+    const originalMethod = objToDecorate[method];
+    objToDecorate[method] = function() {
+      const args = Array.prototype.slice.call(arguments);
+      const cb = utils.last(args);
+      const argsWithoutCallback = cb == null ? args :
+        args.slice(0, args.length - 1);
+      return utils.promiseOrCallback(cb, callback => {
+        this[`$__${method}`].apply(this,
+          argsWithoutCallback.concat([callback]));
+      });
+    };
+    objToDecorate[`$__${method}`] = schema.s.hooks.
+      createWrapper(method, originalMethod, null, customMethodOptions);
   }
 }

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/populate/getVirtual.js

@@ -23,6 +23,10 @@ function getVirtual(schema, name) {
       continue;
     }
 
+    if (schema.nested[cur]) {
+      continue;
+    }
+
     if (schema.paths[cur] && schema.paths[cur].schema) {
       schema = schema.paths[cur].schema;
 

package/lib/services/query/castUpdate.js

@@ -205,7 +205,7 @@ function walkUpdatePath(schema, obj, op, options, context, pref) {
           (utils.isObject(val) && Object.keys(val).length === 0);
       }
     } else {
-      var checkPath = (key === '$each' || key === '$or' || key === '$and') ?
+      var checkPath = (key === '$each' || key === '$or' || key === '$and' || key === '$in') ?
         pref : prefix + key;
       schematype = schema._getSchema(checkPath);
 

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/buffer.js

@@ -167,7 +167,7 @@ MongooseBuffer.mixin = {
     'writeFloat writeDouble fill ' +
     'utf8Write binaryWrite asciiWrite set ' +
 
-// node >= 0.5
+  // node >= 0.5
     'writeUInt16LE writeUInt16BE writeUInt32LE writeUInt32BE ' +
     'writeInt16LE writeInt16BE writeInt32LE writeInt32BE ' +
     'writeFloatLE writeFloatBE writeDoubleLE writeDoubleBE'

package/lib/types/documentarray.js

@@ -12,6 +12,18 @@ const utils = require('../utils');
 const Document = require('../document');
 const getDiscriminatorByValue = require('../queryhelpers').getDiscriminatorByValue;
 
+/*!
+ * ignore
+ */
+
+class CoreMongooseArray extends Array {
+  get isMongooseArray() {
+    return true;
+  }
+
+  remove() {}
+}
+
 /**
  * DocumentArray constructor
  *
@@ -25,11 +37,13 @@ const getDiscriminatorByValue = require('../queryhelpers').getDiscriminatorByVal
  */
 
 function MongooseDocumentArray(values, path, doc) {
-  var arr = [].concat(values);
+  // TODO: replace this with `new CoreMongooseArray().concat()` when we remove
+  // support for node 4.x and 5.x, see https://i.imgur.com/UAAHk4S.png
+  var arr = new CoreMongooseArray();
+  if (Array.isArray(values)) values.forEach(v => arr.push(v));
   arr._path = path;
 
   var props = {
-    isMongooseArray: true,
     isMongooseDocumentArray: true,
     validators: [],
     _atomics: {},

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');