mongoose 6.2.0 → 6.2.1

package/lib/helpers/populate/markArraySubdocsPopulated.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const utils = require('../../utils');
+
 /*!
  * If populating a path within a document array, make sure each
  * subdoc within the array knows its subpaths are populated.
@@ -29,7 +31,7 @@ module.exports = function markArraySubdocsPopulated(doc, populated) {
         continue;
       }
 
-      if (val.isMongooseDocumentArray) {
+      if (utils.isMongooseDocumentArray(val)) {
         for (let j = 0; j < val.length; ++j) {
           val[j].populated(rest, item._docs[id] == null ? void 0 : item._docs[id][j], item);
         }

package/lib/helpers/populate/modelNamesFromRefPath.js

@@ -7,6 +7,8 @@ const mpath = require('mpath');
 const util = require('util');
 const utils = require('../../utils');
 
+const hasNumericPropRE = /(\.\d+$|\.\d+\.)/g;
+
 module.exports = function modelNamesFromRefPath(refPath, doc, populatedPath, modelSchema, queryProjection) {
   if (refPath == null) {
     return [];
@@ -20,10 +22,9 @@ module.exports = function modelNamesFromRefPath(refPath, doc, populatedPath, mod
   // If populated path has numerics, the end `refPath` should too. For example,
   // if populating `a.0.b` instead of `a.b` and `b` has `refPath = a.c`, we
   // should return `a.0.c` for the refPath.
-  const hasNumericProp = /(\.\d+$|\.\d+\.)/g;
 
-  if (hasNumericProp.test(populatedPath)) {
-    const chunks = populatedPath.split(hasNumericProp);
+  if (hasNumericPropRE.test(populatedPath)) {
+    const chunks = populatedPath.split(hasNumericPropRE);
 
     if (chunks[chunks.length - 1] === '') {
       throw new Error('Can\'t populate individual element in an array');

package/lib/helpers/query/castUpdate.js

@@ -41,9 +41,10 @@ module.exports = function castUpdate(schema, obj, options, context, filter) {
     }
     return obj;
   }
+
   if (schema.options.strict === 'throw' && obj.hasOwnProperty(schema.options.discriminatorKey)) {
     throw new StrictModeError(schema.options.discriminatorKey);
-  } else if (context._mongooseOptions != null && !context._mongooseOptions.overwriteDiscriminatorKey) {
+  } else if (!options.overwriteDiscriminatorKey) {
     delete obj[schema.options.discriminatorKey];
   }
   if (options.upsert) {
@@ -353,7 +354,10 @@ function walkUpdatePath(schema, obj, op, options, context, filter, pref) {
         }
 
         if (Array.isArray(obj[key]) && (op === '$addToSet' || op === '$push') && key !== '$each') {
-          if (schematype && schematype.caster && !schematype.caster.$isMongooseArray) {
+          if (schematype &&
+              schematype.caster &&
+              !schematype.caster.$isMongooseArray &&
+              !schematype.caster[schemaMixedSymbol]) {
             obj[key] = { $each: obj[key] };
           }
         }

package/lib/helpers/schema/getPath.js

@@ -5,6 +5,8 @@
  * needing to put `.0.`, so `getPath(schema, 'docArr.elProp')` works.
  */
 
+const numberRE = /^\d+$/;
+
 module.exports = function getPath(schema, path) {
   let schematype = schema.path(path);
   if (schematype != null) {
@@ -16,7 +18,7 @@ module.exports = function getPath(schema, path) {
   let isArray = false;
 
   for (const piece of pieces) {
-    if (/^\d+$/.test(piece) && isArray) {
+    if (isArray && numberRE.test(piece)) {
       continue;
     }
     cur = cur.length === 0 ? piece : cur + '.' + piece;
@@ -25,7 +27,7 @@ module.exports = function getPath(schema, path) {
     if (schematype != null && schematype.schema) {
       schema = schematype.schema;
       cur = '';
-      if (schematype.$isMongooseDocumentArray) {
+      if (!isArray && schematype.$isMongooseDocumentArray) {
         isArray = true;
       }
     }

package/lib/helpers/timestamps/setupTimestamps.js

@@ -47,20 +47,15 @@ module.exports = function setupTimestamps(schema, timestamps) {
     const defaultTimestamp = currentTime != null ?
       currentTime() :
       this.ownerDocument().constructor.base.now();
-    const auto_id = this._id && this._id.auto;
 
     if (!skipCreatedAt && this.isNew && createdAt && !this.$__getValue(createdAt) && this.$__isSelected(createdAt)) {
-      this.$set(createdAt, auto_id ? this._id.getTimestamp() : defaultTimestamp);
+      this.$set(createdAt, defaultTimestamp);
     }
 
     if (!skipUpdatedAt && updatedAt && (this.isNew || this.$isModified())) {
       let ts = defaultTimestamp;
-      if (this.isNew) {
-        if (createdAt != null) {
-          ts = this.$__getValue(createdAt);
-        } else if (auto_id) {
-          ts = this._id.getTimestamp();
-        }
+      if (this.isNew && createdAt != null) {
+        ts = this.$__getValue(createdAt);
       }
       this.$set(updatedAt, ts);
     }

package/lib/index.js

@@ -951,6 +951,8 @@ Mongoose.prototype.ObjectId = SchemaTypes.ObjectId;
  *     mongoose.isValidObjectId({ test: 42 }); // false
  *
  * @method isValidObjectId
+ * @param {Any} value
+ * @returns {boolean} true if it is a valid ObjectId
  * @api public
  */
 

package/lib/internal.js

@@ -10,7 +10,7 @@ const ActiveRoster = StateMachine.ctor('require', 'modify', 'init', 'default', '
 module.exports = exports = InternalCache;
 
 function InternalCache() {
-  this.activePaths = new ActiveRoster;
+  this.activePaths = new ActiveRoster();
   this.strictMode = undefined;
 }
 

package/lib/model.js

@@ -380,7 +380,12 @@ Model.prototype.$__save = function(options, callback) {
       });
     }
     let numAffected = 0;
-    if (get(options, 'safe.w') !== 0 && get(options, 'w') !== 0) {
+    const writeConcern = options != null ?
+      options.writeConcern != null ?
+        options.writeConcern.w :
+        options.w :
+      0;
+    if (writeConcern !== 0) {
       // Skip checking if write succeeded if writeConcern is set to
       // unacknowledged writes, because otherwise `numAffected` will always be 0
       if (result != null) {
@@ -392,8 +397,10 @@ Model.prototype.$__save = function(options, callback) {
           numAffected = result;
         }
       }
+
+      const versionBump = this.$__.version || this.$__schema.options.optimisticConcurrency;
       // was this an update that required a version bump?
-      if (this.$__.version && !this.$__.inserting) {
+      if (versionBump && !this.$__.inserting) {
         const doIncrement = VERSION_INC === (VERSION_INC & this.$__.version);
         this.$__.version = undefined;
         const key = this.$__schema.options.versionKey;
@@ -741,7 +748,7 @@ Model.prototype.$__delta = function() {
       operand(this, where, delta, data, 1, '$unset');
     } else if (value === null) {
       operand(this, where, delta, data, null);
-    } else if (value.isMongooseArray && value.$path() && value[arrayAtomicsSymbol]) {
+    } else if (utils.isMongooseArray(value) && value.$path() && value[arrayAtomicsSymbol]) {
       // arrays and other custom types (support plugins etc)
       handleAtomics(this, where, delta, data, value);
     } else if (value[MongooseBuffer.pathSymbol] && Buffer.isBuffer(value)) {
@@ -793,7 +800,7 @@ function checkDivergentArray(doc, path, array) {
     }
   }
 
-  if (!(pop && array && array.isMongooseArray)) return;
+  if (!(pop && utils.isMongooseArray(array))) return;
 
   // If the array was populated using options that prevented all
   // documents from being returned (match, skip, limit) or they
@@ -3374,7 +3381,7 @@ Model.$__insertMany = function(arr, options, callback) {
       return doc != null;
     });
     // Quickly escape while there aren't any valid docAttributes
-    if (docAttributes.length < 1) {
+    if (docAttributes.length === 0) {
       if (rawResult) {
         const res = {
           mongoose: {
@@ -4456,9 +4463,16 @@ const excludeIdRegGlobal = /\s?-_id\s?/g;
 
 function populate(model, docs, options, callback) {
   const populateOptions = { ...options };
-  if (model.base.options.strictPopulate != null && options.strictPopulate == null) {
-    populateOptions.strictPopulate = model.base.options.strictPopulate;
+  if (options.strictPopulate == null) {
+    if (options._localModel != null && options._localModel.schema._userProvidedOptions.strictPopulate != null) {
+      populateOptions.strictPopulate = options._localModel.schema._userProvidedOptions.strictPopulate;
+    } else if (options._localModel != null && model.base.options.strictPopulate != null) {
+      populateOptions.strictPopulate = model.base.options.strictPopulate;
+    } else if (model.base.options.strictPopulate != null) {
+      populateOptions.strictPopulate = model.base.options.strictPopulate;
+    }
   }
+
   // normalize single / multiple docs passed
   if (!Array.isArray(docs)) {
     docs = [docs];
@@ -4529,7 +4543,7 @@ function populate(model, docs, options, callback) {
   }
   if (!hasOne) {
     // If models but no docs, skip further deep populate.
-    if (modelsMap.length > 0) {
+    if (modelsMap.length !== 0) {
       return callback();
     }
     // If no models to populate but we have a nested populate,

package/lib/plugins/trackTransaction.js

@@ -2,6 +2,7 @@
 
 const arrayAtomicsSymbol = require('../helpers/symbols').arrayAtomicsSymbol;
 const sessionNewDocuments = require('../helpers/symbols').sessionNewDocuments;
+const utils = require('../utils');
 
 module.exports = function trackTransaction(schema) {
   schema.pre('save', function() {
@@ -47,10 +48,10 @@ function _getAtomics(doc, previous) {
     const val = doc.$__getValue(path);
     if (val != null &&
         val instanceof Array &&
-        val.isMongooseDocumentArray &&
+        utils.isMongooseDocumentArray(val) &&
         val.length &&
         val[arrayAtomicsSymbol] != null &&
-        Object.keys(val[arrayAtomicsSymbol]).length > 0) {
+        Object.keys(val[arrayAtomicsSymbol]).length !== 0) {
       const existing = previous.get(path) || {};
       pathToAtomics.set(path, mergeAtomics(existing, val[arrayAtomicsSymbol]));
     }
@@ -61,7 +62,7 @@ function _getAtomics(doc, previous) {
     const path = dirt.path;
 
     const val = dirt.value;
-    if (val != null && val[arrayAtomicsSymbol] != null && Object.keys(val[arrayAtomicsSymbol]).length > 0) {
+    if (val != null && val[arrayAtomicsSymbol] != null && Object.keys(val[arrayAtomicsSymbol]).length !== 0) {
       const existing = previous.get(path) || {};
       pathToAtomics.set(path, mergeAtomics(existing, val[arrayAtomicsSymbol]));
     }

package/lib/query.js

@@ -120,7 +120,7 @@ function Query(conditions, options, model, collection) {
  * inherit mquery
  */
 
-Query.prototype = new mquery;
+Query.prototype = new mquery();
 Query.prototype.constructor = Query;
 Query.base = mquery.prototype;
 
@@ -4848,7 +4848,8 @@ Query.prototype._castUpdate = function _castUpdate(obj, overwrite) {
     overwrite: overwrite,
     strict: this._mongooseOptions.strict,
     upsert: upsert,
-    arrayFilters: this.options.arrayFilters
+    arrayFilters: this.options.arrayFilters,
+    overwriteDiscriminatorKey: this._mongooseOptions.overwriteDiscriminatorKey
   }, this, this._conditions);
 };
 

package/lib/queryhelpers.js

@@ -212,7 +212,7 @@ exports.applyPaths = function applyPaths(fields, schema) {
 
       let addedPath = analyzePath(path, type);
       // arrays
-      if (addedPath == null && type.$isMongooseArray && !type.$isMongooseDocumentArray) {
+      if (addedPath == null && !Array.isArray(type) && type.$isMongooseArray && !type.$isMongooseDocumentArray) {
         addedPath = analyzePath(path, type.caster);
       }
       if (addedPath != null) {

package/lib/schema/array.js

@@ -112,14 +112,12 @@ function SchemaArray(key, cast, options, schemaOptions) {
 
   if (!('defaultValue' in this) || this.defaultValue !== void 0) {
     const defaultFn = function() {
-      let arr = [];
-      if (fn) {
-        arr = defaultArr.call(this);
-      } else if (defaultArr != null) {
-        arr = arr.concat(defaultArr);
-      }
       // Leave it up to `cast()` to convert the array
-      return arr;
+      return fn
+        ? defaultArr.call(this)
+        : defaultArr != null
+          ? [].concat(defaultArr)
+          : [];
     };
     defaultFn.$runBeforeSetters = !fn;
     this.default(defaultFn);
@@ -275,7 +273,7 @@ SchemaArray.prototype.applyGetters = function(value, scope) {
 
   const ret = SchemaType.prototype.applyGetters.call(this, value, scope);
   if (Array.isArray(ret)) {
-    const rawValue = ret.isMongooseArrayProxy ? ret.__array : ret;
+    const rawValue = utils.isMongooseArray(ret) ? ret.__array : ret;
     const len = rawValue.length;
     for (let i = 0; i < len; ++i) {
       rawValue[i] = this.caster.applyGetters(rawValue[i], scope);
@@ -299,7 +297,7 @@ SchemaArray.prototype._applySetters = function(value, scope, init, priorVal) {
     }
 
     // No need to wrap empty arrays
-    if (value != null && value.length > 0) {
+    if (value != null && value.length !== 0) {
       const valueDepth = arrayDepth(value);
       if (valueDepth.min === valueDepth.max && valueDepth.max < depth && valueDepth.containsNonArrayItem) {
         for (let i = valueDepth.max; i < depth; ++i) {
@@ -357,7 +355,7 @@ SchemaArray.prototype.cast = function(value, doc, init, prev, options) {
 
     options = options || emptyOpts;
 
-    let rawValue = value.isMongooseArrayProxy ? value.__array : value;
+    let rawValue = utils.isMongooseArray(value) ? value.__array : value;
     value = MongooseArray(rawValue, options.path || this._arrayPath || this.path, doc, this);
     rawValue = value.__array;
 
@@ -557,12 +555,16 @@ function cast$all(val) {
   }
 
   val = val.map(function(v) {
-    if (utils.isObject(v)) {
-      const o = {};
-      o[this.path] = v;
-      return cast(this.casterConstructor.schema, o)[this.path];
+    if (!utils.isObject(v)) {
+      return v;
+    }
+    if (v.$elemMatch != null) {
+      return { $elemMatch: cast(this.casterConstructor.schema, v.$elemMatch) };
     }
-    return v;
+
+    const o = {};
+    o[this.path] = v;
+    return cast(this.casterConstructor.schema, o)[this.path];
   }, this);
 
   return this.castForQuery(val);

package/lib/schema/documentarray.js

@@ -228,7 +228,7 @@ DocumentArrayPath.prototype.doValidate = function(array, fn, scope, options) {
     if (options && options.updateValidator) {
       return fn();
     }
-    if (!array.isMongooseDocumentArray) {
+    if (!utils.isMongooseDocumentArray(array)) {
       array = new MongooseDocumentArray(array, _this.path, scope);
     }
 
@@ -398,12 +398,9 @@ DocumentArrayPath.prototype.cast = function(value, doc, init, prev, options) {
     return this.cast([value], doc, init, prev, options);
   }
 
-  if (!(value && value.isMongooseDocumentArray) &&
-      !options.skipDocumentArrayCast) {
-    value = new MongooseDocumentArray(value, this.path, doc);
-  } else if (value && value.isMongooseDocumentArray) {
-    // We need to create a new array, otherwise change tracking will
-    // update the old doc (gh-4449)
+  // We need to create a new array, otherwise change tracking will
+  // update the old doc (gh-4449)
+  if (!options.skipDocumentArrayCast || utils.isMongooseDocumentArray(value)) {
     value = new MongooseDocumentArray(value, this.path, doc);
   }
 
@@ -415,7 +412,7 @@ DocumentArrayPath.prototype.cast = function(value, doc, init, prev, options) {
     value[arrayPathSymbol] = this.path + '.' + options.arrayPathIndex;
   }
 
-  const rawArray = value.isMongooseDocumentArrayProxy ? value.__array : value;
+  const rawArray = utils.isMongooseDocumentArray(value) ? value.__array : value;
 
   const len = rawArray.length;
   const initDocumentOptions = { skipId: true, willInit: true };

package/lib/schema/objectid.js

@@ -281,7 +281,7 @@ function resetId(v) {
 
   if (this instanceof Document) {
     if (v === void 0) {
-      const _v = new oid;
+      const _v = new oid();
       this.$__._id = _v;
       return _v;
     }

package/lib/schematype.js

@@ -1125,7 +1125,7 @@ SchemaType.prototype.getDefault = function(scope, init) {
     }
 
     const casted = this.applySetters(ret, scope, init);
-    if (casted && casted.$isSingleNested) {
+    if (casted && !Array.isArray(casted) && casted.$isSingleNested) {
       casted.$__parent = scope;
     }
     return casted;
@@ -1328,6 +1328,16 @@ SchemaType.prototype.doValidate = function(value, fn, scope, options) {
   }
 };
 
+
+function _validate(ok, validatorProperties) {
+  if (ok !== undefined && !ok) {
+    const ErrorConstructor = validatorProperties.ErrorConstructor || ValidatorError;
+    const err = new ErrorConstructor(validatorProperties);
+    err[validatorErrorSymbol] = true;
+    return err;
+  }
+}
+
 /**
  * Performs a validation of `value` using the validators declared for this SchemaType.
  *
@@ -1351,7 +1361,7 @@ SchemaType.prototype.doValidateSync = function(value, scope, options) {
 
   let validators = this.validators;
   if (value === void 0) {
-    if (this.validators.length > 0 && this.validators[0].type === 'required') {
+    if (this.validators.length !== 0 && this.validators[0].type === 'required') {
       validators = [this.validators[0]];
     } else {
       return null;
@@ -1359,34 +1369,35 @@ SchemaType.prototype.doValidateSync = function(value, scope, options) {
   }
 
   let err = null;
-  validators.forEach(function(v) {
-    if (err) {
-      return;
-    }
+  let i = 0;
+  const len = validators.length;
+  for (i = 0; i < len; ++i) {
+
+    const v = validators[i];
 
     if (v == null || typeof v !== 'object') {
-      return;
+      continue;
     }
 
     const validator = v.validator;
     const validatorProperties = utils.clone(v);
     validatorProperties.path = options && options.path ? options.path : path;
     validatorProperties.value = value;
-    let ok;
+    let ok = false;
 
     // Skip any explicit async validators. Validators that return a promise
     // will still run, but won't trigger any errors.
     if (isAsyncFunction(validator)) {
-      return;
+      continue;
     }
 
     if (validator instanceof RegExp) {
-      validate(validator.test(value), validatorProperties);
-      return;
+      err = _validate(validator.test(value), validatorProperties);
+      continue;
     }
 
     if (typeof validator !== 'function') {
-      return;
+      continue;
     }
 
     try {
@@ -1403,23 +1414,15 @@ SchemaType.prototype.doValidateSync = function(value, scope, options) {
     // Skip any validators that return a promise, we can't handle those
     // synchronously
     if (ok != null && typeof ok.then === 'function') {
-      return;
+      continue;
     }
-    validate(ok, validatorProperties);
-  });
-
-  return err;
-
-  function validate(ok, validatorProperties) {
+    err = _validate(ok, validatorProperties);
     if (err) {
-      return;
-    }
-    if (ok !== undefined && !ok) {
-      const ErrorConstructor = validatorProperties.ErrorConstructor || ValidatorError;
-      err = new ErrorConstructor(validatorProperties);
-      err[validatorErrorSymbol] = true;
+      break;
     }
   }
+
+  return err;
 };
 
 /**
@@ -1630,7 +1633,7 @@ SchemaType.prototype._castForQuery = function(val) {
  */
 
 SchemaType.checkRequired = function(fn) {
-  if (arguments.length > 0) {
+  if (arguments.length !== 0) {
     this._checkRequired = fn;
   }
 

package/lib/types/ArraySubdocument.js

@@ -6,6 +6,7 @@
 
 const EventEmitter = require('events').EventEmitter;
 const Subdocument = require('./subdocument');
+const utils = require('../utils');
 
 const documentArrayParent = require('../helpers/symbols').documentArrayParent;
 
@@ -20,7 +21,7 @@ const documentArrayParent = require('../helpers/symbols').documentArrayParent;
  */
 
 function ArraySubdocument(obj, parentArr, skipId, fields, index) {
-  if (parentArr != null && parentArr.isMongooseDocumentArray) {
+  if (utils.isMongooseDocumentArray(parentArr)) {
     this.__parentArray = parentArr;
     this[documentArrayParent] = parentArr.$parent();
   } else {

package/lib/types/DocumentArray/index.js

@@ -15,7 +15,7 @@ const arrayPathSymbol = require('../../helpers/symbols').arrayPathSymbol;
 const arraySchemaSymbol = require('../../helpers/symbols').arraySchemaSymbol;
 
 const _basePush = Array.prototype.push;
-
+const numberRE = /^\d+$/;
 /**
  * DocumentArray constructor
  *
@@ -29,7 +29,7 @@ const _basePush = Array.prototype.push;
  */
 
 function MongooseDocumentArray(values, path, doc) {
-  const arr = [];
+  const __array = [];
 
   const internals = {
     [arrayAtomicsSymbol]: {},
@@ -45,10 +45,11 @@ function MongooseDocumentArray(values, path, doc) {
       internals[arrayAtomicsSymbol] = Object.assign({}, values[arrayAtomicsSymbol]);
     }
     values.forEach(v => {
-      _basePush.call(arr, v);
+      _basePush.call(__array, v);
     });
   }
   internals[arrayPathSymbol] = path;
+  internals.__array = __array;
 
   // Because doc comes from the context of another function, doc === global
   // can happen if there was a null somewhere up the chain (see #3020 && #3034)
@@ -69,7 +70,7 @@ function MongooseDocumentArray(values, path, doc) {
     }
   }
 
-  const proxy = new Proxy(arr, {
+  const proxy = new Proxy(__array, {
     get: function(target, prop) {
       if (prop === 'isMongooseArray' ||
           prop === 'isMongooseArrayProxy' ||
@@ -77,12 +78,6 @@ function MongooseDocumentArray(values, path, doc) {
           prop === 'isMongooseDocumentArrayProxy') {
         return true;
       }
-      if (prop === '__array') {
-        return arr;
-      }
-      if (prop === 'set') {
-        return set;
-      }
       if (internals.hasOwnProperty(prop)) {
         return internals[prop];
       }
@@ -93,15 +88,15 @@ function MongooseDocumentArray(values, path, doc) {
         return ArrayMethods[prop];
       }
 
-      return arr[prop];
+      return __array[prop];
     },
     set: function(target, prop, value) {
-      if (typeof prop === 'string' && /^\d+$/.test(prop)) {
-        set.call(proxy, prop, value);
+      if (typeof prop === 'string' && numberRE.test(prop)) {
+        DocumentArrayMethods.set.call(proxy, prop, value, false);
       } else if (internals.hasOwnProperty(prop)) {
         internals[prop] = value;
       } else {
-        arr[prop] = value;
+        __array[prop] = value;
       }
 
       return true;
@@ -111,18 +106,6 @@ function MongooseDocumentArray(values, path, doc) {
   return proxy;
 }
 
-function set(i, val, skipModified) {
-  const arr = this.__array;
-  if (skipModified) {
-    arr[i] = val;
-    return arr;
-  }
-  const value = DocumentArrayMethods._cast.call(this, val, i);
-  arr[i] = value;
-  DocumentArrayMethods._markModified.call(this, i);
-  return arr;
-}
-
 /*!
  * Module exports.
  */

package/lib/types/DocumentArray/isMongooseDocumentArray.js

@@ -0,0 +1,5 @@
+'use strict';
+
+exports.isMongooseDocumentArray = function(mongooseDocumentArray) {
+  return Array.isArray(mongooseDocumentArray) && mongooseDocumentArray.isMongooseDocumentArray;
+};

package/lib/types/DocumentArray/methods/index.js

@@ -36,7 +36,7 @@ const methods = {
     }
     let Constructor = this[arraySchemaSymbol].casterConstructor;
     const isInstance = Constructor.$isMongooseDocumentArray ?
-      value && value.isMongooseDocumentArray :
+      utils.isMongooseDocumentArray(value) :
       value instanceof Constructor;
     if (isInstance ||
         // Hack re: #5001, see #5005
@@ -295,7 +295,7 @@ const methods = {
             break;
         }
 
-        if (_arr[i].isMongooseArray) {
+        if (utils.isMongooseArray(_arr[i])) {
           notify(val, _arr[i]);
         } else if (_arr[i]) {
           _arr[i].emit(event, val);
@@ -304,6 +304,18 @@ const methods = {
     };
   },
 
+  set(i, val, skipModified) {
+    const arr = this.__array;
+    if (skipModified) {
+      arr[i] = val;
+      return this;
+    }
+    const value = methods._cast.call(this, val, i);
+    arr[i] = value;
+    methods._markModified.call(this, i);
+    return this;
+  },
+
   _markModified(elem, embeddedPath) {
     const parent = this[arrayParentSymbol];
     let dirtyPath;
@@ -326,7 +338,7 @@ const methods = {
         return this;
       }
 
-      parent.markModified(dirtyPath, arguments.length > 0 ? elem : parent);
+      parent.markModified(dirtyPath, arguments.length !== 0 ? elem : parent);
     }
 
     return this;