mongoose 9.0.1 → 9.1.0

package/lib/document.js

@@ -149,7 +149,7 @@ function Document(obj, fields, options) {
 
   // determine if this doc is a result of a query with
   // excluded fields
-  if (utils.isPOJO(fields) && Object.keys(fields).length > 0) {
+  if (utils.isPOJO(fields) && utils.hasOwnKeys(fields)) {
     exclude = isExclusive(fields);
     this.$__.selected = fields;
     this.$__.exclude = exclude;
@@ -648,6 +648,10 @@ Document.prototype.init = function(doc, opts, fn) {
     opts = null;
   }
 
+  if (doc == null) {
+    throw new ObjectParameterError(doc, 'doc', 'init');
+  }
+
   this.$__init(doc, opts);
 
   if (fn) {
@@ -677,6 +681,9 @@ Document.prototype.$init = function() {
  */
 
 Document.prototype.$__init = function(doc, opts) {
+  if (doc == null) {
+    throw new ObjectParameterError(doc, 'doc', 'init');
+  }
   this.$isNew = false;
   opts = opts || {};
 
@@ -695,7 +702,7 @@ Document.prototype.$__init = function(doc, opts) {
         continue;
       }
       for (const child of item._childDocs) {
-        if (child == null || child.$__ == null) {
+        if (child?.$__ == null) {
           continue;
         }
         child.$__.parent = this;
@@ -794,7 +801,7 @@ function init(self, obj, doc, opts, prefix) {
 
         if (schemaType && !wasPopulated && !opts.hydratedPopulatedDocs) {
           try {
-            if (opts && opts.setters) {
+            if (opts?.setters) {
               // Call applySetters with `init = false` because otherwise setters are a noop
               const overrideInit = false;
               doc[i] = schemaType.applySetters(value, self, overrideInit, null, opts);
@@ -813,7 +820,7 @@ function init(self, obj, doc, opts, prefix) {
         } else if (schemaType && opts.hydratedPopulatedDocs) {
           doc[i] = schemaType.cast(value, self, true, undefined, { hydratedPopulatedDocs: true });
 
-          if (doc[i] && doc[i].$__ && doc[i].$__.wasPopulated) {
+          if (doc[i]?.$__?.wasPopulated) {
             self.$populated(path, doc[i].$__.wasPopulated.value, doc[i].$__.wasPopulated.options);
           } else if (Array.isArray(doc[i]) && doc[i].length && doc[i][0]?.$__?.wasPopulated) {
             self.$populated(path, doc[i].map(populatedDoc => populatedDoc?.$__?.wasPopulated?.value).filter(val => val != null), doc[i][0].$__.wasPopulated.options);
@@ -842,7 +849,7 @@ function init(self, obj, doc, opts, prefix) {
  *  - same as in [Model.updateOne](https://mongoosejs.com/docs/api/model.html#Model.updateOne)
  *
  * @see Model.updateOne https://mongoosejs.com/docs/api/model.html#Model.updateOne
- * @param {Object} doc
+ * @param {Object} update
  * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
  * @param {Object} [options.lean] if truthy, mongoose will return the document as a plain JavaScript object rather than a mongoose document. See [`Query.lean()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.lean()) and the [Mongoose lean tutorial](https://mongoosejs.com/docs/tutorials/lean.html).
  * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
@@ -853,33 +860,33 @@ function init(self, obj, doc, opts, prefix) {
  * @instance
  */
 
-Document.prototype.updateOne = function updateOne(doc, options) {
-  const query = this.constructor.updateOne({ _id: this._doc._id }, doc, options);
+Document.prototype.updateOne = function updateOne(update, options) {
+  const query = this.constructor.updateOne();
   const self = this;
   query.pre(async function queryPreUpdateOne() {
-    const res = await self._execDocumentPreHooks('updateOne', self);
+    const res = await self._execDocumentPreHooks('updateOne', self, update, options);
     // `self` is passed to pre hooks as argument for backwards compatibility, but that
     // isn't the actual arguments passed to the wrapped function.
-    if (res?.length !== 1 || res[0] !== self) {
+    if (res[0] !== self || res[1] !== update || res[2] !== options) {
       throw new Error('Document updateOne pre hooks cannot overwrite arguments');
     }
+    query.updateOne({ _id: self._doc._id }, update, options);
     // Apply custom where conditions _after_ document updateOne middleware for
     // consistency with save() - sharding plugin needs to set $where
     if (self.$where != null) {
       this.where(self.$where);
     }
+    if (self.$session() != null) {
+      if (!('session' in query.options)) {
+        query.options.session = self.$session();
+      }
+    }
     return res;
   });
   query.post(function queryPostUpdateOne() {
     return self._execDocumentPostHooks('updateOne');
   });
 
-  if (this.$session() != null) {
-    if (!('session' in query.options)) {
-      query.options.session = this.$session();
-    }
-  }
-
   return query;
 };
 
@@ -931,14 +938,14 @@ Document.prototype.replaceOne = function replaceOne() {
 
 Document.prototype.$session = function $session(session) {
   if (arguments.length === 0) {
-    if (this.$__.session != null && this.$__.session.hasEnded) {
+    if (this.$__.session?.hasEnded) {
       this.$__.session = null;
       return null;
     }
     return this.$__.session;
   }
 
-  if (session != null && session.hasEnded) {
+  if (session?.hasEnded) {
     throw new MongooseError('Cannot set a document\'s session to a session that has ended. Make sure you haven\'t ' +
       'called `endSession()` on the session you are passing to `$session()`.');
   }
@@ -1015,17 +1022,21 @@ Document.prototype.$timestamps = function $timestamps(value) {
  */
 
 Document.prototype.overwrite = function overwrite(obj) {
-  const keys = Array.from(new Set(Object.keys(this._doc).concat(Object.keys(obj))));
+  const keys = new Set(Object.keys(this._doc));
+  for (const key of Object.keys(obj)) {
+    keys.add(key);
+  }
 
+  const schemaOptions = this.$__schema.options;
   for (const key of keys) {
     if (key === '_id') {
       continue;
     }
     // Explicitly skip version key
-    if (this.$__schema.options.versionKey && key === this.$__schema.options.versionKey) {
+    if (schemaOptions.versionKey && key === schemaOptions.versionKey) {
       continue;
     }
-    if (this.$__schema.options.discriminatorKey && key === this.$__schema.options.discriminatorKey) {
+    if (schemaOptions.discriminatorKey && key === schemaOptions.discriminatorKey) {
       continue;
     }
     this.$set(key, obj[key]);
@@ -1055,7 +1066,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
     type = undefined;
   }
 
-  const merge = options && options.merge;
+  const merge = options?.merge;
   const adhoc = type && type !== true;
   const constructing = type === true;
   let adhocs;
@@ -1101,7 +1112,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
 
     // `_skipMinimizeTopLevel` is because we may have deleted the top-level
     // nested key to ensure key order.
-    const _skipMinimizeTopLevel = options && options._skipMinimizeTopLevel || false;
+    const _skipMinimizeTopLevel = options?._skipMinimizeTopLevel || false;
     if (len === 0 && _skipMinimizeTopLevel) {
       delete options._skipMinimizeTopLevel;
       if (val) {
@@ -1415,7 +1426,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
 
     let didPopulate = false;
     if (refMatches && val instanceof Document && (!val.$__.wasPopulated || utils.deepEqual(val.$__.wasPopulated.value, val._doc._id))) {
-      const unpopulatedValue = (schema && schema.$isSingleNested) ? schema.cast(val, this) : val._doc._id;
+      const unpopulatedValue = schema?.$isSingleNested ? schema.cast(val, this) : val._doc._id;
       this.$populated(path, unpopulatedValue, { [populateModelSymbol]: val.constructor });
       val.$__.wasPopulated = { value: unpopulatedValue };
       didPopulate = true;
@@ -1447,7 +1458,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
       if (this.$__schema.singleNestedPaths[path] != null && parts.length > 1) {
         setterContext = getDeepestSubdocumentForPath(this, parts, this.schema);
       }
-      if (options != null && options.overwriteImmutable) {
+      if (options?.overwriteImmutable) {
         val = schema.applySetters(val, setterContext, false, priorVal, { path, overwriteImmutable: true });
       } else {
         val = schema.applySetters(val, setterContext, false, priorVal, { path });
@@ -1458,9 +1469,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
         !Array.isArray(schema) &&
         schema.$isMongooseDocumentArray &&
         val.length !== 0 &&
-        val[0] != null &&
-        val[0].$__ != null &&
-        val[0].$__.populated != null) {
+        val[0]?.$__?.populated != null) {
       const populatedPaths = Object.keys(val[0].$__.populated);
       for (const populatedPath of populatedPaths) {
         this.$populated(path + '.' + populatedPath,
@@ -1625,7 +1634,7 @@ Document.prototype.set = Document.prototype.$set;
  */
 
 Document.prototype.$__shouldModify = function(pathToMark, path, options, constructing, parts, schema, val, priorVal) {
-  if (options && options._skipMarkModified) {
+  if (options?._skipMarkModified) {
     return false;
   }
   if (this.$isNew) {
@@ -1695,9 +1704,9 @@ Document.prototype.$__set = function(pathToMark, path, options, constructing, pa
     schema, val, priorVal);
 
   if (shouldModify) {
-    if (this.$__.primitiveAtomics && this.$__.primitiveAtomics[path]) {
+    if (this.$__.primitiveAtomics?.[path]) {
       delete this.$__.primitiveAtomics[path];
-      if (Object.keys(this.$__.primitiveAtomics).length === 0) {
+      if (utils.hasOwnKeys(this.$__.primitiveAtomics) === false) {
         delete this.$__.primitiveAtomics;
       }
     }
@@ -1939,7 +1948,7 @@ Document.prototype.get = function(path, type, options) {
     return obj;
   }
 
-  if (schema != null && schema.instance === 'Mixed') {
+  if (schema?.instance === 'Mixed') {
     const virtual = this.$__schema.virtualpath(path);
     if (virtual != null) {
       schema = virtual;
@@ -1956,7 +1965,7 @@ Document.prototype.get = function(path, type, options) {
   }
 
   for (let i = 0, l = pieces.length; i < l; i++) {
-    if (obj && obj._doc) {
+    if (obj?._doc) {
       obj = obj._doc;
     }
 
@@ -2284,7 +2293,7 @@ Document.prototype[documentModifiedPaths] = Document.prototype.modifiedPaths;
 
 Document.prototype.isModified = function(paths, options, modifiedPaths) {
   if (paths) {
-    const ignoreAtomics = options && options.ignoreAtomics;
+    const ignoreAtomics = options?.ignoreAtomics;
     const directModifiedPathsObj = this.$__.activePaths.states.modify;
     if (directModifiedPathsObj == null) {
       return false;
@@ -2309,7 +2318,7 @@ Document.prototype.isModified = function(paths, options, modifiedPaths) {
     if (ignoreAtomics) {
       directModifiedPaths = directModifiedPaths.filter(path => {
         const value = this.$__getValue(path);
-        if (value != null && value[arrayAtomicsSymbol] != null && value[arrayAtomicsSymbol].$set === undefined) {
+        if (value?.[arrayAtomicsSymbol] != null && value[arrayAtomicsSymbol].$set === undefined) {
           return false;
         }
         return true;
@@ -2431,7 +2440,7 @@ Document.prototype.isDirectModified = function(path) {
     for (let i = 0; i < pieces.length - 1; ++i) {
       const subpath = pieces.slice(0, i + 1).join('.');
       const subdoc = this.$get(subpath);
-      if (subdoc != null && subdoc.$__ != null && subdoc.isDirectModified(pieces.slice(i + 1).join('.'))) {
+      if (subdoc?.$__ != null && subdoc.isDirectModified(pieces.slice(i + 1).join('.'))) {
         return true;
       }
     }
@@ -2649,7 +2658,7 @@ Document.prototype.validate = async function validate(pathsToValidate, options)
     const isOnePathOnly = options.pathsToSkip.indexOf(' ') === -1;
     options.pathsToSkip = isOnePathOnly ? [options.pathsToSkip] : options.pathsToSkip.split(' ');
   }
-  const _skipParallelValidateCheck = options && options._skipParallelValidateCheck;
+  const _skipParallelValidateCheck = options?._skipParallelValidateCheck;
 
   if (this.$isSubdocument != null) {
     // Skip parallel validate check for subdocuments
@@ -2690,7 +2699,7 @@ function _evaluateRequiredFunctions(doc) {
 
     const p = doc.$__schema.path(path);
 
-    if (p != null && typeof p.originalRequiredValue === 'function') {
+    if (typeof p?.originalRequiredValue === 'function') {
       doc.$__.cachedRequired = doc.$__.cachedRequired || {};
       try {
         doc.$__.cachedRequired[path] = p.originalRequiredValue.call(doc, doc);
@@ -2750,7 +2759,7 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip, isNestedValidate
         }
       } else if (schemaType.$isMongooseDocumentArray) {
         const arr = doc.$get(path);
-        if (arr && arr.length) {
+        if (arr?.length) {
           for (const subdoc of arr) {
             if (subdoc) {
               topLevelSubdocs.push(subdoc);
@@ -2903,7 +2912,7 @@ function _addArrayPathsToValidate(doc, paths) {
         // it unless we have a case of #6364
         (!Array.isArray(_pathType) &&
           _pathType.$isMongooseDocumentArray &&
-          !(_pathType && _pathType.schemaOptions && _pathType.schemaOptions.required))) {
+          !_pathType?.schemaOptions?.required)) {
       continue;
     }
 
@@ -2970,7 +2979,7 @@ Document.prototype.$__validate = async function $__validate(pathsToValidate, opt
       (typeof options === 'object') &&
       ('validateModifiedOnly' in options);
 
-  const pathsToSkip = (options && options.pathsToSkip) || null;
+  const pathsToSkip = options?.pathsToSkip || null;
 
   let shouldValidateModifiedOnly;
   if (hasValidateModifiedOnlyOption) {
@@ -2979,7 +2988,7 @@ Document.prototype.$__validate = async function $__validate(pathsToValidate, opt
     shouldValidateModifiedOnly = this.$__schema.options.validateModifiedOnly;
   }
 
-  const validateAllPaths = options && options.validateAllPaths;
+  const validateAllPaths = options?.validateAllPaths;
   if (validateAllPaths) {
     if (pathsToSkip) {
       throw new TypeError('Cannot set both `validateAllPaths` and `pathsToSkip`');
@@ -3006,7 +3015,7 @@ Document.prototype.$__validate = async function $__validate(pathsToValidate, opt
           delete validationError.errors[errPath];
         }
       }
-      if (Object.keys(validationError.errors).length === 0) {
+      if (utils.hasOwnKeys(validationError.errors) === false) {
         validationError = void 0;
       }
     }
@@ -3037,7 +3046,7 @@ Document.prototype.$__validate = async function $__validate(pathsToValidate, opt
     // the children as well
     for (const path of paths) {
       const schemaType = this.$__schema.path(path);
-      if (!schemaType || !schemaType.$isMongooseArray) {
+      if (!schemaType?.$isMongooseArray) {
         continue;
       }
       const val = this.$__getValue(path);
@@ -3049,7 +3058,7 @@ Document.prototype.$__validate = async function $__validate(pathsToValidate, opt
     paths = [...paths];
     doValidateOptionsByPath = {};
   } else {
-    const pathDetails = _getPathsToValidate(this, pathsToValidate, pathsToSkip, options && options._nestedValidate);
+    const pathDetails = _getPathsToValidate(this, pathsToValidate, pathsToSkip, options?._nestedValidate);
     paths = shouldValidateModifiedOnly ?
       pathDetails[0].filter((path) => this.$isModified(path)) :
       pathDetails[0];
@@ -3117,7 +3126,7 @@ Document.prototype.$__validate = async function $__validate(pathsToValidate, opt
     let pop;
     if ((pop = _this.$populated(path))) {
       val = pop;
-    } else if (val != null && val.$__ != null && val.$__.wasPopulated) {
+    } else if (val?.$__?.wasPopulated) {
       // Array paths, like `somearray.1`, do not show up as populated with `$populated()`,
       // so in that case pull out the document's id
       val = val._doc._id;
@@ -3233,9 +3242,9 @@ Document.prototype.validateSync = function(pathsToValidate, options) {
     shouldValidateModifiedOnly = this.$__schema.options.validateModifiedOnly;
   }
 
-  let pathsToSkip = options && options.pathsToSkip;
+  let pathsToSkip = options?.pathsToSkip;
 
-  const validateAllPaths = options && options.validateAllPaths;
+  const validateAllPaths = options?.validateAllPaths;
   if (validateAllPaths) {
     if (pathsToSkip) {
       throw new TypeError('Cannot set both `validateAllPaths` and `pathsToSkip`');
@@ -3261,7 +3270,7 @@ Document.prototype.validateSync = function(pathsToValidate, options) {
     // the children as well
     for (const path of paths) {
       const schemaType = this.$__schema.path(path);
-      if (!schemaType || !schemaType.$isMongooseArray) {
+      if (!schemaType?.$isMongooseArray) {
         continue;
       }
       const val = this.$__getValue(path);
@@ -3402,12 +3411,12 @@ Document.prototype.invalidate = function(path, err, val, kind) {
  */
 
 Document.prototype.$markValid = function(path) {
-  if (!this.$__.validationError || !this.$__.validationError.errors[path]) {
+  if (!this.$__.validationError?.errors[path]) {
     return;
   }
 
   delete this.$__.validationError.errors[path];
-  if (Object.keys(this.$__.validationError.errors).length === 0) {
+  if (utils.hasOwnKeys(this.$__.validationError.errors) === false) {
     this.$__.validationError = null;
   }
 };
@@ -3427,7 +3436,7 @@ function _markValidSubpaths(doc, path) {
       delete doc.$__.validationError.errors[key];
     }
   }
-  if (Object.keys(doc.$__.validationError.errors).length === 0) {
+  if (utils.hasOwnKeys(doc.$__.validationError.errors) === false) {
     doc.$__.validationError = null;
   }
 }
@@ -3502,7 +3511,7 @@ function _checkImmutableSubpaths(subdoc, schematype, priorVal) {
  */
 
 Document.prototype.$isValid = function(path) {
-  if (this.$__.validationError == null || Object.keys(this.$__.validationError.errors).length === 0) {
+  if (this.$__.validationError == null || utils.hasOwnKeys(this.$__.validationError.errors) === false) {
     return true;
   }
   if (path == null) {
@@ -3534,7 +3543,7 @@ Document.prototype.$__reset = function reset() {
 
   // Skip for subdocuments
   const subdocs = !this.$isSubdocument ? this.$getAllSubdocs({ useCache: true }) : null;
-  if (subdocs && subdocs.length > 0) {
+  if (subdocs?.length > 0) {
     for (const subdoc of subdocs) {
       subdoc.$__reset();
     }
@@ -3544,7 +3553,9 @@ Document.prototype.$__reset = function reset() {
   this.$__dirty().forEach(function(dirt) {
     const type = dirt.value;
 
-    if (type && type[arrayAtomicsSymbol]) {
+    if (type && typeof type.clearAtomics === 'function') {
+      type.clearAtomics();
+    } else if (type && type[arrayAtomicsSymbol]) {
       type[arrayAtomicsBackupSymbol] = type[arrayAtomicsSymbol];
       type[arrayAtomicsSymbol] = {};
     }
@@ -3576,7 +3587,7 @@ Document.prototype.$__reset = function reset() {
  */
 
 Document.prototype.$__undoReset = function $__undoReset() {
-  if (this.$__.backup == null || this.$__.backup.activePaths == null) {
+  if (this.$__.backup?.activePaths == null) {
     return;
   }
 
@@ -3589,7 +3600,7 @@ Document.prototype.$__undoReset = function $__undoReset() {
   for (const dirt of this.$__dirty()) {
     const type = dirt.value;
 
-    if (type && type[arrayAtomicsSymbol] && type[arrayAtomicsBackupSymbol]) {
+    if (type?.[arrayAtomicsSymbol] && type[arrayAtomicsBackupSymbol]) {
       type[arrayAtomicsSymbol] = type[arrayAtomicsBackupSymbol];
     }
   }
@@ -3757,14 +3768,14 @@ Document.prototype.$getAllSubdocs = function(options) {
       }
       if (Array.isArray(val)) {
         for (const el of val) {
-          if (el != null && el.$__) {
+          if (el?.$__) {
             newSubdocs.push(el);
           }
         }
       }
       if (val instanceof Map) {
         for (const el of val.values()) {
-          if (el != null && el.$__) {
+          if (el?.$__) {
             newSubdocs.push(el);
           }
         }
@@ -3811,7 +3822,7 @@ Document.prototype.$__handleReject = function handleReject(err) {
   // emit on the Model if listening
   if (this.$listeners('error').length) {
     this.$emit('error', err);
-  } else if (this.constructor.listeners && this.constructor.listeners('error').length) {
+  } else if (this.constructor.listeners?.('error').length) {
     this.constructor.emit('error', err);
   }
 };
@@ -3840,7 +3851,7 @@ Document.prototype.$toObject = function(options, json) {
     _minimize = options.minimize;
   } else if (this.$__schemaTypeOptions?.minimize != null) {
     _minimize = this.$__schemaTypeOptions.minimize;
-  } else if (defaultOptions != null && defaultOptions.minimize != null) {
+  } else if (defaultOptions?.minimize != null) {
     _minimize = defaultOptions.minimize;
   } else {
     _minimize = this.$__schema.options.minimize;
@@ -4164,7 +4175,7 @@ function applyVirtuals(self, json, options, toObjectOptions) {
   let assignPath;
   let cur = self._doc;
   let v;
-  const aliases = typeof (toObjectOptions && toObjectOptions.aliases) === 'boolean'
+  const aliases = typeof toObjectOptions?.aliases === 'boolean'
     ? toObjectOptions.aliases
     : true;
 
@@ -4172,7 +4183,7 @@ function applyVirtuals(self, json, options, toObjectOptions) {
   let virtualsToApply = null;
   if (Array.isArray(options.virtuals)) {
     virtualsToApply = new Set(options.virtuals);
-  } else if (options.virtuals && options.virtuals.pathsToSkip) {
+  } else if (options.virtuals?.pathsToSkip) {
     virtualsToApply = new Set(paths);
     for (let i = 0; i < options.virtuals.pathsToSkip.length; i++) {
       if (virtualsToApply.has(options.virtuals.pathsToSkip[i])) {
@@ -4380,7 +4391,7 @@ function omitDeselectedFields(self, json) {
     selected = {};
     queryhelpers.applyPaths(selected, schema);
   }
-  if (selected == null || Object.keys(selected).length === 0) {
+  if (selected == null || utils.hasOwnKeys(selected) === false) {
     return json;
   }
 
@@ -4462,6 +4473,20 @@ Document.prototype.parent = function() {
 
 Document.prototype.$parent = Document.prototype.parent;
 
+/**
+ * Set the parent of this document.
+ *
+ * @param {Document} parent
+ * @api private
+ * @method $__setParent
+ * @memberOf Document
+ * @instance
+ */
+
+Document.prototype.$__setParent = function $__setParent(parent) {
+  this.$__.parent = parent;
+};
+
 /**
  * Helper for console.log
  *
@@ -4717,7 +4742,7 @@ Document.prototype.populated = function(path, val, options) {
   for (let i = 0; i < pieces.length - 1; ++i) {
     const subpath = pieces.slice(0, i + 1).join('.');
     const subdoc = this.$get(subpath);
-    if (subdoc != null && subdoc.$__ != null && this.$populated(subpath)) {
+    if (subdoc?.$__ != null && this.$populated(subpath)) {
       const rest = pieces.slice(i + 1).join('.');
       subdoc.$populated(rest, val, options);
       // No need to continue because the above recursion should take care of
@@ -4808,7 +4833,7 @@ Document.prototype.depopulate = function(path) {
 
   let populatedIds;
   const virtualKeys = this.$$populatedVirtuals ? Object.keys(this.$$populatedVirtuals) : [];
-  const populated = this.$__ && this.$__.populated || {};
+  const populated = this.$__?.populated || {};
 
   if (arguments.length === 0) {
     // Depopulate all
@@ -4957,7 +4982,13 @@ Document.prototype.$__delta = function $__delta() {
     if (Array.isArray(optimisticConcurrency)) {
       const optCon = new Set(optimisticConcurrency);
       const modPaths = this.modifiedPaths();
-      if (modPaths.find(path => optCon.has(path))) {
+      if (modPaths.some(path => optCon.has(path))) {
+        this.$__.version = dirty.length ? VERSION_ALL : VERSION_WHERE;
+      }
+    } else if (Array.isArray(optimisticConcurrency?.exclude)) {
+      const excluded = new Set(optimisticConcurrency.exclude);
+      const modPaths = this.modifiedPaths();
+      if (modPaths.some(path => !excluded.has(path))) {
         this.$__.version = dirty.length ? VERSION_ALL : VERSION_WHERE;
       }
     } else {
@@ -4977,7 +5008,7 @@ Document.prototype.$__delta = function $__delta() {
   where._id = this._doc._id;
   // If `_id` is an object, need to depopulate, but also need to be careful
   // because `_id` can technically be null (see gh-6406)
-  if ((where && where._id && where._id.$__ || null) != null) {
+  if (where?._id?.$__ != null) {
     where._id = where._id.toObject({ transform: false, depopulate: true });
   }
   for (; d < len; ++d) {
@@ -5028,15 +5059,15 @@ Document.prototype.$__delta = function $__delta() {
       operand(this, where, delta, data, 1, '$unset');
     } else if (value === null) {
       operand(this, where, delta, data, null);
-    } else if (utils.isMongooseArray(value) && value.$path() && value[arrayAtomicsSymbol]) {
-      // arrays and other custom types (support plugins etc)
+    } else if (typeof value.getAtomics === 'function') {
+      // arrays and other custom container types
       handleAtomics(this, where, delta, data, value);
     } else if (value[MongooseBuffer.pathSymbol] && Buffer.isBuffer(value)) {
       // MongooseBuffer
       value = value.toObject();
       operand(this, where, delta, data, value);
     } else {
-      if (this.$__.primitiveAtomics && this.$__.primitiveAtomics[data.path] != null) {
+      if (this.$__.primitiveAtomics?.[data.path] != null) {
         const val = this.$__.primitiveAtomics[data.path];
         const op = firstKey(val);
         operand(this, where, delta, data, val[op], op);
@@ -5062,7 +5093,7 @@ Document.prototype.$__delta = function $__delta() {
     this.$__version(where, delta);
   }
 
-  if (Object.keys(delta).length === 0) {
+  if (utils.hasOwnKeys(delta) === false) {
     return [where, null];
   }
 
@@ -5107,14 +5138,14 @@ function checkDivergentArray(doc, path, array) {
   // elements of the array and potentially would overwrite data.
   const check = pop.options.match ||
       pop.options.options && Object.hasOwn(pop.options.options, 'limit') || // 0 is not permitted
-      pop.options.options && pop.options.options.skip || // 0 is permitted
+      pop.options.options?.skip || // 0 is permitted
       pop.options.select && // deselected _id?
       (pop.options.select._id === 0 ||
       /\s?-_id\s?/.test(pop.options.select));
 
   if (check) {
     const atomics = array[arrayAtomicsSymbol];
-    if (Object.keys(atomics).length === 0 || atomics.$set || atomics.$pop) {
+    if (utils.hasOwnKeys(atomics) === false || atomics.$set || atomics.$pop) {
       return path;
     }
   }
@@ -5147,7 +5178,11 @@ function operand(self, where, delta, data, val, op) {
   // already marked for versioning?
   if (VERSION_ALL === (VERSION_ALL & self.$__.version)) return;
 
-  if (self.$__schema.options.optimisticConcurrency) {
+  if (
+    self.$__schema.options.optimisticConcurrency === true ||
+      Array.isArray(self.$__schema.options.optimisticConcurrency) ||
+      Array.isArray(self.$__schema.options.optimisticConcurrency?.exclude)
+  ) {
     return;
   }
 
@@ -5174,7 +5209,7 @@ function operand(self, where, delta, data, val, op) {
     if (/\.\d+\.|\.\d+$/.test(data.path)) {
       self.$__.version = VERSION_ALL;
     } else {
-      self.$__.version = VERSION_INC;
+      self.$__.version |= VERSION_INC;
     }
   } else if (/^\$p/.test(op)) {
     // potentially changing array positions
@@ -5185,7 +5220,7 @@ function operand(self, where, delta, data, val, op) {
   } else if (/\.\d+\.|\.\d+$/.test(data.path)) {
     // now handling $set, $unset
     // subpath of array
-    self.$__.version = VERSION_WHERE;
+    self.$__.version |= VERSION_WHERE;
   }
 }
 
@@ -5201,11 +5236,20 @@ function operand(self, where, delta, data, val, op) {
  */
 
 function handleAtomics(self, where, delta, data, value) {
-  if (delta.$set && delta.$set[data.path]) {
+  if (delta.$set?.[data.path]) {
     // $set has precedence over other atomics
     return;
   }
 
+  if (typeof value.getAtomics === 'function') {
+    value.getAtomics().forEach(function(atomic) {
+      const op = atomic[0];
+      const val = atomic[1];
+      operand(self, where, delta, data, val, op);
+    });
+    return;
+  }
+
   if (typeof value.$__getAtomics === 'function') {
     value.$__getAtomics().forEach(function(atomic) {
       const op = atomic[0];
@@ -5294,7 +5338,7 @@ Document.prototype.$clone = function() {
   const clonedDoc = new Model();
   clonedDoc.$isNew = this.$isNew;
   if (this._doc) {
-    clonedDoc._doc = clone(this._doc, { retainDocuments: true });
+    clonedDoc._doc = clone(this._doc, { retainDocuments: true, parentDoc: clonedDoc });
   }
   if (this.$__) {
     const Cache = this.$__.constructor;
@@ -5305,7 +5349,10 @@ Document.prototype.$clone = function() {
       }
       clonedCache[key] = clone(this.$__[key]);
     }
-    Object.assign(clonedCache.activePaths, clone({ ...this.$__.activePaths }));
+    Object.assign(
+      clonedCache.activePaths,
+      clone({ ...this.$__.activePaths })
+    );
     clonedDoc.$__ = clonedCache;
   }
   return clonedDoc;