mongoose 9.0.1 → 9.1.0

package/lib/schema/documentArrayElement.js

@@ -26,7 +26,7 @@ const getConstructor = require('../helpers/discriminator/getConstructor');
  */
 
 function SchemaDocumentArrayElement(path, schema, options, parentSchema) {
-  this.$parentSchemaType = options && options.$parentSchemaType;
+  this.$parentSchemaType = options?.$parentSchemaType;
   if (!this.$parentSchemaType) {
     throw new MongooseError('Cannot create DocumentArrayElement schematype without a parent');
   }
@@ -35,7 +35,7 @@ function SchemaDocumentArrayElement(path, schema, options, parentSchema) {
   SchemaType.call(this, path, options, 'DocumentArrayElement', parentSchema);
 
   this.$isMongooseDocumentArrayElement = true;
-  this.Constructor = options && options.Constructor;
+  this.Constructor = options?.Constructor;
   this.schema = schema;
 }
 
@@ -76,7 +76,7 @@ SchemaDocumentArrayElement.prototype.doValidate = async function doValidate(valu
   const Constructor = getConstructor(this.Constructor, value);
 
   if (value && !(value instanceof Constructor)) {
-    value = new Constructor(value, scope, null, null, options && options.index != null ? options.index : null);
+    value = new Constructor(value, scope, null, null, options?.index ?? null);
   }
 
   return SchemaSubdocument.prototype.doValidate.call(this, value, scope, options);

package/lib/schema/map.js

@@ -172,7 +172,7 @@ SchemaMap.prototype._createNestedSchemaType = function _createNestedSchemaType(s
   let _mapType = { type: {} };
   if (utils.hasUserDefinedProperty(obj, 'of')) {
     const isInlineSchema = utils.isPOJO(obj.of) &&
-      Object.keys(obj.of).length > 0 &&
+      utils.hasOwnKeys(obj.of) &&
       !utils.hasUserDefinedProperty(obj.of, schema.options.typeKey);
     if (isInlineSchema) {
       _mapType = { [schema.options.typeKey]: new Schema(obj.of) };

package/lib/schema/mixed.js

@@ -21,12 +21,12 @@ const utils = require('../utils');
  */
 
 function SchemaMixed(path, options, _schemaOptions, parentSchema) {
-  if (options && options.default) {
+  if (options?.default) {
     const def = options.default;
     if (Array.isArray(def) && def.length === 0) {
       // make sure empty array defaults are handled
       options.default = Array;
-    } else if (!options.shared && isObject(def) && Object.keys(def).length === 0) {
+    } else if (!options.shared && isObject(def) && utils.hasOwnKeys(def) === false) {
       // prevent odd "shared" objects between documents
       options.default = function() {
         return {};

package/lib/schema/number.js

@@ -221,7 +221,7 @@ SchemaNumber.prototype.min = function(value, message) {
     }, this);
   }
 
-  if (value !== null && value !== undefined) {
+  if (value != null) {
     let msg = message || MongooseError.messages.Number.min;
     msg = msg.replace(/{MIN}/, value);
     this.validators.push({
@@ -275,7 +275,7 @@ SchemaNumber.prototype.max = function(value, message) {
     }, this);
   }
 
-  if (value !== null && value !== undefined) {
+  if (value != null) {
     let msg = message || MongooseError.messages.Number.max;
     msg = msg.replace(/{MAX}/, value);
     this.validators.push({
@@ -335,7 +335,25 @@ SchemaNumber.prototype.enum = function(values, message) {
     }
 
     if (utils.isPOJO(values)) {
-      values = Object.values(values);
+      // TypeScript numeric enums produce objects with reverse
+      // mappings, e.g. { 0: 'Zero', 1: 'One', Zero: 0, One: 1 }.
+      // Object.values on that will yield ['Zero','One',0,1].
+      // For Number schema enums we only want the numeric values,
+      // otherwise casting the name strings to Number will throw.
+      const keys = Object.keys(values).sort();
+      const objVals = Object.values(values).sort();
+      // If keys and values are equal and half of values are numbers,
+      // this is likely a TS enum with reverse mapping, so use only the numbers.
+      if (
+        keys.length === objVals.length &&
+        keys.every((k, i) => k === String(objVals[i])) &&
+        objVals.filter(v => typeof v === 'number').length === Math.floor(objVals.length / 2)
+      ) {
+        values = objVals.filter(v => typeof v === 'number');
+      } else {
+        // Avoid sorting the values to preserve user-specified order
+        values = Object.values(values);
+      }
     }
     message = message || MongooseError.messages.Number.enum;
   }
@@ -376,7 +394,7 @@ SchemaNumber.prototype.cast = function(value, doc, init, prev, options) {
     }
   }
 
-  const val = value && typeof value._id !== 'undefined' ?
+  const val = value?._id !== undefined ?
     value._id : // documents
     value;
 

package/lib/schema/objectId.js

@@ -29,7 +29,7 @@ let Document;
 
 function SchemaObjectId(key, options, _schemaOptions, parentSchema) {
   const isKeyHexStr = typeof key === 'string' && key.length === 24 && /^[a-f0-9]+$/i.test(key);
-  const suppressWarning = options && options.suppressWarning;
+  const suppressWarning = options?.suppressWarning;
   if ((isKeyHexStr || typeof key === 'undefined') && !suppressWarning) {
     utils.warn('mongoose: To create a new ObjectId please try ' +
       '`Mongoose.Types.ObjectId` instead of using ' +

package/lib/schema/operators/exists.js

@@ -7,6 +7,6 @@ const castBoolean = require('../../cast/boolean');
  */
 
 module.exports = function(val) {
-  const path = this != null ? this.path : null;
+  const path = this?.path ?? null;
   return castBoolean(val, path);
 };

package/lib/schema/operators/geospatial.js

@@ -25,7 +25,7 @@ function cast$near(val) {
 
   _castMinMaxDistance(this, val);
 
-  if (val && val.$geometry) {
+  if (val?.$geometry) {
     return cast$geometry(val, this);
   }
 

package/lib/schema/string.js

@@ -416,7 +416,7 @@ SchemaString.prototype.minlength = function(value, message) {
     }, this);
   }
 
-  if (value !== null && value !== undefined) {
+  if (value != null) {
     let msg = message || MongooseError.messages.String.minlength;
     msg = msg.replace(/{MINLENGTH}/, value);
     this.validators.push({
@@ -472,7 +472,7 @@ SchemaString.prototype.maxlength = function(value, message) {
     }, this);
   }
 
-  if (value !== null && value !== undefined) {
+  if (value != null) {
     let msg = message || MongooseError.messages.String.maxlength;
     msg = msg.replace(/{MAXLENGTH}/, value);
     this.validators.push({

package/lib/schema/subdocument.js

@@ -41,8 +41,7 @@ function SchemaSubdocument(schema, path, options, parentSchema) {
   if (schema.options.timeseries) {
     throw new InvalidSchemaOptionError(path, 'timeseries');
   }
-  const schemaTypeIdOption = SchemaSubdocument.defaultOptions &&
-    SchemaSubdocument.defaultOptions._id;
+  const schemaTypeIdOption = SchemaSubdocument.defaultOptions?._id;
   if (schemaTypeIdOption != null) {
     options = options || {};
     options._id = schemaTypeIdOption;
@@ -87,7 +86,7 @@ function _createConstructor(schema, baseClass, options) {
 
   schema._preCompile();
 
-  const proto = baseClass != null ? baseClass.prototype : SubdocumentType.prototype;
+  const proto = baseClass?.prototype ?? SubdocumentType.prototype;
   _embedded.prototype = Object.create(proto);
   _embedded.prototype.$__setSchema(schema);
   _embedded.prototype.constructor = _embedded;
@@ -177,7 +176,7 @@ Object.defineProperty(SchemaSubdocument.prototype, '$conditionalHandlers', {
  */
 
 SchemaSubdocument.prototype.cast = function(val, doc, init, priorVal, options) {
-  if (val && val.$isSingleNested && val.parent === doc) {
+  if (val?.$isSingleNested && val.parent === doc) {
     return val;
   }
 
@@ -192,7 +191,7 @@ SchemaSubdocument.prototype.cast = function(val, doc, init, priorVal, options) {
   let subdoc;
 
   // Only pull relevant selected paths and pull out the base path
-  const parentSelected = doc && doc.$__ && doc.$__.selected;
+  const parentSelected = doc?.$__?.selected;
   const path = this.path;
   const selected = parentSelected == null ? null : Object.keys(parentSelected).reduce((obj, key) => {
     if (key.startsWith(path + '.')) {
@@ -216,7 +215,7 @@ SchemaSubdocument.prototype.cast = function(val, doc, init, priorVal, options) {
     applyDefaults(subdoc, selected, exclude);
   } else {
     options = Object.assign({}, options, { priorDoc: priorVal });
-    if (Object.keys(val).length === 0) {
+    if (utils.hasOwnKeys(val) === false) {
       return new Constructor({}, selected, doc, options);
     }
 
@@ -256,9 +255,7 @@ SchemaSubdocument.prototype.castForQuery = function($conditional, val, context,
     val = this._applySetters(val, context);
   }
 
-  const overrideStrict = options != null && options.strict != null ?
-    options.strict :
-    void 0;
+  const overrideStrict = options?.strict ?? void 0;
 
   try {
     val = new Constructor(val, overrideStrict);
@@ -282,10 +279,10 @@ SchemaSubdocument.prototype.doValidate = async function doValidate(value, scope,
   const Constructor = getConstructor(this.Constructor, value);
 
   if (value && !(value instanceof Constructor)) {
-    value = new Constructor(value, null, (scope != null && scope.$__ != null) ? scope : null);
+    value = new Constructor(value, null, scope?.$__ != null ? scope : null);
   }
 
-  if (options && options.skipSchemaValidators) {
+  if (options?.skipSchemaValidators) {
     if (!value) {
       return;
     }
@@ -305,7 +302,7 @@ SchemaSubdocument.prototype.doValidate = async function doValidate(value, scope,
  */
 
 SchemaSubdocument.prototype.doValidateSync = function(value, scope, options) {
-  if (!options || !options.skipSchemaValidators) {
+  if (!options?.skipSchemaValidators) {
     const schemaTypeError = SchemaType.prototype.doValidateSync.call(this, value, scope);
     if (schemaTypeError) {
       return schemaTypeError;

package/lib/schema/union.js

@@ -24,7 +24,7 @@ class Union extends SchemaType {
    */
   constructor(key, options, schemaOptions, parentSchema) {
     super(key, options, 'Union', parentSchema);
-    if (!options || !Array.isArray(options.of) || options.of.length === 0) {
+    if (!Array.isArray(options?.of) || options.of.length === 0) {
       throw new Error('Union schema type requires an array of types');
     }
     this.schemaTypes = options.of.map(obj => parentSchema.interpretAsType(key, obj, schemaOptions));

package/lib/schema.js

@@ -78,7 +78,7 @@ const numberRE = /^\d+$/;
  * - [validateBeforeSave](https://mongoosejs.com/docs/guide.html#validateBeforeSave) - bool - defaults to `true`
  * - [validateModifiedOnly](https://mongoosejs.com/docs/api/document.html#Document.prototype.validate()) - bool - defaults to `false`
  * - [versionKey](https://mongoosejs.com/docs/guide.html#versionKey): string or object - defaults to "__v"
- * - [optimisticConcurrency](https://mongoosejs.com/docs/guide.html#optimisticConcurrency): bool or string[] or { exclude: string[] } - defaults to false. Set to true to enable [optimistic concurrency](https://thecodebarbarian.com/whats-new-in-mongoose-5-10-optimistic-concurrency.html). Set to string array to enable optimistic concurrency for only certain fields, or `{ exclude: string[] }` to define a list of fields to ignore for optimistic concurrency.
+ * - [optimisticConcurrency](https://mongoosejs.com/docs/guide.html#optimisticConcurrency): bool or string[] or { exclude: string[] } - defaults to false. Set to true to enable [optimistic concurrency](https://thecodebarbarian.com/whats-new-in-mongoose-5-10-optimistic-concurrency.html) for all fields. Set to a string array to enable optimistic concurrency only for the specified fields; note that this **replaces** the default array versioning behavior. Set to `{ exclude: string[] }` to enable optimistic concurrency for all fields except the specified ones; this also replaces the default array versioning.
  * - [collation](https://mongoosejs.com/docs/guide.html#collation): object - defaults to null (which means use no collation)
  * - [timeseries](https://mongoosejs.com/docs/guide.html#timeseries): object - defaults to null (which means this schema's collection won't be a timeseries collection)
  * - [selectPopulatedPaths](https://mongoosejs.com/docs/guide.html#selectPopulatedPaths): boolean - defaults to `true`
@@ -88,6 +88,7 @@ const numberRE = /^\d+$/;
  * - [virtuals](https://mongoosejs.com/docs/tutorials/virtuals.html#virtuals-via-schema-options): object - virtuals to define, alias for [`.virtual`](https://mongoosejs.com/docs/api/schema.html#Schema.prototype.virtual())
  * - [collectionOptions]: object with options passed to [`createCollection()`](https://www.mongodb.com/docs/manual/reference/method/db.createCollection/) when calling `Model.createCollection()` or `autoCreate` set to true.
  * - [encryptionType]: the encryption type for the schema.  Valid options are `csfle` or `queryableEncryption`.  See https://mongoosejs.com/docs/field-level-encryption.
+ * - [lean]: boolean - set to true to make all queries use [lean](https://mongoosejs.com/docs/tutorials/lean.html) by default. Defaults to false.
  *
  * #### Options for Nested Schemas:
  *
@@ -120,11 +121,11 @@ function Schema(obj, options) {
   this.callQueue = [];
   this._indexes = [];
   this._searchIndexes = [];
-  this.methods = (options && options.methods) || {};
+  this.methods = options?.methods || {};
   this.methodOptions = {};
-  this.statics = (options && options.statics) || {};
+  this.statics = options?.statics || {};
   this.tree = {};
-  this.query = (options && options.query) || {};
+  this.query = options?.query || {};
   this.childSchemas = [];
   this.plugins = [];
   // For internal debugging. Do not use this to try to save a schema in MDB.
@@ -147,7 +148,7 @@ function Schema(obj, options) {
   }
 
   // build virtual paths
-  if (options && options.virtuals) {
+  if (options?.virtuals) {
     const virtuals = options.virtuals;
     const pathNames = Object.keys(virtuals);
     for (const pathName of pathNames) {
@@ -165,7 +166,7 @@ function Schema(obj, options) {
   }
 
   // check if _id's value is a subdocument (gh-2276)
-  const _idSubDoc = obj && obj._id && utils.isObject(obj._id);
+  const _idSubDoc = obj?._id && utils.isObject(obj._id);
 
   // ensure the documents get an auto _id unless disabled
   const auto_id = !this.paths['_id'] &&
@@ -602,7 +603,7 @@ Schema.prototype.omit = function(paths, options) {
 
 Schema.prototype.defaultOptions = function(options) {
   this._userProvidedOptions = options == null ? {} : clone(options);
-  const baseOptions = this.base && this.base.options || {};
+  const baseOptions = this.base?.options || {};
   const strict = 'strict' in baseOptions ? baseOptions.strict : true;
   const strictQuery = 'strictQuery' in baseOptions ? baseOptions.strictQuery : false;
   const id = 'id' in baseOptions ? baseOptions.id : true;
@@ -722,9 +723,7 @@ Schema.prototype._defaultToObjectOptions = function(json) {
     return this._defaultToObjectOptionsMap[path];
   }
 
-  const baseOptions = this.base &&
-    this.base.options &&
-    this.base.options[path] || {};
+  const baseOptions = this.base?.options?.[path] || {};
   const schemaOptions = this.options[path] || {};
   // merge base default options with Schema's set default options if available.
   // `clone` is necessary here because `utils.options` directly modifies the second input.
@@ -771,7 +770,7 @@ Schema.prototype.encryptionType = function encryptionType(encryptionType) {
  */
 
 Schema.prototype.add = function add(obj, prefix) {
-  if (obj instanceof Schema || (obj != null && obj.instanceOfSchema)) {
+  if (obj instanceof Schema || obj?.instanceOfSchema) {
     merge(this, obj);
     return this;
   }
@@ -811,7 +810,7 @@ Schema.prototype.add = function add(obj, prefix) {
     let isMongooseTypeString = false;
     if (typeof val === 'string') {
       // Handle the case in which the type is specified as a string (eg. 'date', 'oid', ...)
-      const MongooseTypes = this.base != null ? this.base.Schema.Types : Schema.Types;
+      const MongooseTypes = this.base?.Schema.Types ?? Schema.Types;
       const upperVal = val.charAt(0).toUpperCase() + val.substring(1);
       isMongooseTypeString = MongooseTypes[upperVal] != null;
     }
@@ -824,7 +823,7 @@ Schema.prototype.add = function add(obj, prefix) {
         `a valid type at path \`${key}\`. See ` +
         'https://bit.ly/mongoose-schematypes for a list of valid schema types.');
     }
-    if (val instanceof VirtualType || (val.constructor && val.constructor.name || null) === 'VirtualType') {
+    if (val instanceof VirtualType || (val.constructor?.name ?? null) === 'VirtualType') {
       this.virtual(val);
       continue;
     }
@@ -841,13 +840,13 @@ Schema.prototype.add = function add(obj, prefix) {
         this.nested[prefix.substring(0, prefix.length - 1)] = true;
       }
       this.path(prefix + key, val);
-      if (val[0] != null && !(val[0].instanceOfSchema) && utils.isPOJO(val[0].discriminators)) {
+      if (!val[0]?.instanceOfSchema && utils.isPOJO(val[0]?.discriminators)) {
         const schemaType = this.path(prefix + key);
         for (const key in val[0].discriminators) {
           schemaType.discriminator(key, val[0].discriminators[key]);
         }
       }
-    } else if (Object.keys(val).length < 1) {
+    } else if (utils.hasOwnKeys(val) === false) {
       // Special-case: {} always interpreted as Mixed path so leaf at this node
       if (prefix) {
         this.nested[prefix.substring(0, prefix.length - 1)] = true;
@@ -862,7 +861,7 @@ Schema.prototype.add = function add(obj, prefix) {
     } else {
       // There IS a bona-fide type key that may also be a POJO
       const _typeDef = val[typeKey];
-      if (isPOJO(_typeDef) && Object.keys(_typeDef).length > 0) {
+      if (isPOJO(_typeDef) && utils.hasOwnKeys(_typeDef)) {
         // If a POJO is the value of a type key, make it a subdocument
         if (prefix) {
           this.nested[prefix.substring(0, prefix.length - 1)] = true;
@@ -893,7 +892,7 @@ Schema.prototype.add = function add(obj, prefix) {
           this.nested[prefix.substring(0, prefix.length - 1)] = true;
         }
         this.path(prefix + key, val);
-        if (val != null && !(val.instanceOfSchema) && utils.isPOJO(val.discriminators)) {
+        if (!val?.instanceOfSchema && utils.isPOJO(val?.discriminators)) {
           const schemaType = this.path(prefix + key);
           for (const key in val.discriminators) {
             schemaType.discriminator(key, val.discriminators[key]);
@@ -965,7 +964,7 @@ Schema.prototype._removeEncryptedField = function _removeEncryptedField(path) {
  * @returns {boolean}
  */
 Schema.prototype._hasEncryptedFields = function _hasEncryptedFields() {
-  return Object.keys(this.encryptedFields).length > 0;
+  return utils.hasOwnKeys(this.encryptedFields);
 };
 
 /**
@@ -1585,8 +1584,8 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
 
   // If this schema has an associated Mongoose object, use the Mongoose object's
   // copy of SchemaTypes re: gh-7158 gh-6933
-  const MongooseTypes = this.base != null ? this.base.Schema.Types : Schema.Types;
-  const Types = this.base != null ? this.base.Types : require('./types');
+  const MongooseTypes = this.base?.Schema.Types ?? Schema.Types;
+  const Types = this.base?.Types ?? require('./types');
 
   if (!utils.isPOJO(obj) && !(obj instanceof SchemaTypeOptions)) {
     const constructorName = utils.getFunctionName(obj.constructor);
@@ -1626,7 +1625,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
       : type[0];
 
     // new Schema({ path: [new Schema({ ... })] })
-    if (cast && cast.instanceOfSchema) {
+    if (cast?.instanceOfSchema) {
       if (!(cast instanceof Schema)) {
         if (this.options._isMerging) {
           cast = new Schema(cast);
@@ -1660,7 +1659,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
     }
     if (typeof cast !== 'undefined') {
       if (Array.isArray(cast) || cast.type === Array || cast.type == 'Array') {
-        if (cast && cast.type == 'Array') {
+        if (cast?.type == 'Array') {
           cast.type = Array;
         }
         return new MongooseTypes.Array(path, this.interpretAsType(path, cast, options), obj, null, this);
@@ -1674,7 +1673,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
     if (typeof cast === 'string') {
       cast = MongooseTypes[cast.charAt(0).toUpperCase() + cast.substring(1)];
     } else if (utils.isPOJO(castFromTypeKey)) {
-      if (Object.keys(castFromTypeKey).length) {
+      if (utils.hasOwnKeys(castFromTypeKey)) {
         // The `minimize` and `typeKey` options propagate to child schemas
         // declared inline, like `{ arr: [{ val: { $type: String } }] }`.
         // See gh-3560
@@ -1747,7 +1746,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
     return new MongooseTypes.Array(path, cast || MongooseTypes.Mixed, obj, options, this);
   }
 
-  if (type && type.instanceOfSchema) {
+  if (type?.instanceOfSchema) {
     return new MongooseTypes.Subdocument(type, path, obj, this);
   }
 
@@ -2008,7 +2007,7 @@ function getPositionalPathType(self, path, cleanPath) {
       continue;
     }
 
-    if (!(val && val.schema)) {
+    if (!val?.schema) {
       val = undefined;
       break;
     }
@@ -2206,7 +2205,7 @@ Schema.prototype.plugin = function(fn, opts) {
   }
 
 
-  if (opts && opts.deduplicate) {
+  if (opts?.deduplicate) {
     for (const plugin of this.plugins) {
       if (plugin.fn === fn) {
         return this;
@@ -2655,9 +2654,9 @@ Schema.prototype.virtual = function(name, options) {
     return mem[part];
   }, this.tree);
 
-  if (options && options.applyToArray && parts.length > 1) {
+  if (options?.applyToArray && parts.length > 1) {
     const path = this.path(parts.slice(0, -1).join('.'));
-    if (path && path.$isMongooseArray) {
+    if (path?.$isMongooseArray) {
       return path.virtual(parts[parts.length - 1], options);
     } else {
       throw new MongooseError(`Path "${path}" is not an array`);

package/lib/schemaType.js

@@ -416,7 +416,7 @@ SchemaType.prototype.default = function(val) {
       return void 0;
     }
 
-    if (val != null && val.instanceOfSchema) {
+    if (val?.instanceOfSchema) {
       throw new MongooseError('Cannot set default value of path `' + this.path +
         '` to a mongoose Schema instance.');
     }
@@ -1112,7 +1112,7 @@ SchemaType.prototype.required = function(required, message) {
   this.isRequired = true;
 
   this.requiredValidator = function(v) {
-    const cachedRequired = this && this.$__ && this.$__.cachedRequired;
+    const cachedRequired = this?.$__?.cachedRequired;
 
     // no validation when this path wasn't selected in the query.
     if (cachedRequired != null && !this.$__isSelected(_this.path) && !this[documentIsModified](_this.path)) {
@@ -1209,12 +1209,12 @@ SchemaType.prototype.getDefault = function(scope, init, options) {
     ret = this.defaultValue;
   }
 
-  if (ret !== null && ret !== undefined) {
-    if (typeof ret === 'object' && (!this.options || !this.options.shared)) {
+  if (ret != null) {
+    if (typeof ret === 'object' && !this.options?.shared) {
       ret = clone(ret);
     }
 
-    if (options && options.skipCast) {
+    if (options?.skipCast) {
       return this._applySetters(ret, scope);
     }
 
@@ -1359,7 +1359,7 @@ SchemaType.prototype.doValidate = async function doValidate(value, scope, option
     let ok;
 
     const validatorProperties = isSimpleValidator(v) ? Object.assign({}, v) : clone(v);
-    validatorProperties.path = options && options.path ? options.path : path;
+    validatorProperties.path = options?.path || path;
     validatorProperties.fullPath = this.$fullPath;
     validatorProperties.value = value;
     if (typeof value === 'string') {
@@ -1399,7 +1399,7 @@ SchemaType.prototype.doValidate = async function doValidate(value, scope, option
       }
     }
 
-    if (ok != null && typeof ok.then === 'function') {
+    if (typeof ok?.then === 'function') {
       promises.push(
         ok.then(
           function(ok) {
@@ -1485,7 +1485,7 @@ SchemaType.prototype.doValidateSync = function(value, scope, options) {
 
     const validator = v.validator;
     const validatorProperties = isSimpleValidator(v) ? Object.assign({}, v) : clone(v);
-    validatorProperties.path = options && options.path ? options.path : path;
+    validatorProperties.path = options?.path || path;
     validatorProperties.fullPath = this.$fullPath;
     validatorProperties.value = value;
     if (typeof value === 'string') {
@@ -1524,7 +1524,7 @@ 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') {
+    if (typeof ok?.then === 'function') {
       continue;
     }
     err = _validate(ok, validatorProperties);
@@ -1549,9 +1549,9 @@ SchemaType.prototype.doValidateSync = function(value, scope, options) {
 
 SchemaType._isRef = function(self, value, doc, init) {
   // fast path
-  let ref = init && self.options && (self.options.ref || self.options.refPath);
+  let ref = init && (self.options?.ref || self.options?.refPath);
 
-  if (!ref && doc && doc.$__ != null) {
+  if (!ref && doc?.$__ != null) {
     // checks for
     // - this populated with adhoc model and no ref was set in schema OR
     // - setting / pushing values after population

package/lib/types/array/index.js

@@ -72,7 +72,7 @@ function MongooseArray(values, path, doc, schematype) {
     internals[arrayAtomicsSymbol] = values[arrayAtomicsSymbol];
   }
 
-  if (doc != null && doc.$__) {
+  if (doc?.$__) {
     internals[arrayParentSymbol] = doc;
     internals[arraySchemaSymbol] = schematype || doc.schema.path(path);
   }
@@ -85,7 +85,7 @@ function MongooseArray(values, path, doc, schematype) {
       if (Object.hasOwn(mongooseArrayMethods, prop)) {
         return mongooseArrayMethods[prop];
       }
-      if (schematype && schematype.virtuals && Object.hasOwn(schematype.virtuals, prop)) {
+      if (schematype?.virtuals && Object.hasOwn(schematype.virtuals, prop)) {
         return schematype.virtuals[prop].applyGetters(undefined, target);
       }
       if (typeof prop === 'string' && numberRE.test(prop) && schematype?.embeddedSchemaType != null) {

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

@@ -10,6 +10,7 @@ const mpath = require('mpath');
 const utils = require('../../../utils');
 const isBsonType = require('../../../helpers/isBsonType');
 
+const arrayAtomicsBackupSymbol = require('../../../helpers/symbols').arrayAtomicsBackupSymbol;
 const arrayAtomicsSymbol = require('../../../helpers/symbols').arrayAtomicsSymbol;
 const arrayParentSymbol = require('../../../helpers/symbols').arrayParentSymbol;
 const arrayPathSymbol = require('../../../helpers/symbols').arrayPathSymbol;
@@ -59,9 +60,9 @@ const methods = {
         val = val.toObject(opts);
       } else if (Array.isArray(val)) {
         val = this.toObject.call(val, opts);
-      } else if (val != null && Array.isArray(val.$each)) {
+      } else if (Array.isArray(val?.$each)) {
         val.$each = this.toObject.call(val.$each, opts);
-      } else if (val != null && typeof val.valueOf === 'function') {
+      } else if (typeof val?.valueOf === 'function') {
         val = val.valueOf();
       }
 
@@ -75,6 +76,36 @@ const methods = {
     return ret;
   },
 
+  /**
+   * Public API for getting atomics. Alias for $__getAtomics() that can be
+   * implemented by custom container types.
+   *
+   * @return {Array}
+   * @method getAtomics
+   * @memberOf MongooseArray
+   * @instance
+   * @api public
+   */
+
+  getAtomics() {
+    return this.$__getAtomics();
+  },
+
+  /**
+   * Clears all pending atomic operations. Called by Mongoose after save().
+   *
+   * @return {void}
+   * @method clearAtomics
+   * @memberOf MongooseArray
+   * @instance
+   * @api public
+   */
+
+  clearAtomics() {
+    this[arrayAtomicsBackupSymbol] = this[arrayAtomicsSymbol];
+    this[arrayAtomicsSymbol] = {};
+  },
+
   /*!
    * ignore
    */
@@ -230,7 +261,7 @@ const methods = {
       populated = parent.$populated(this[arrayPathSymbol], true);
     }
 
-    if (populated && value !== null && value !== undefined) {
+    if (populated && value != null) {
       // cast to the populated Models schema
       Model = populated.options[populateModelSymbol];
       if (Model == null) {
@@ -246,8 +277,7 @@ const methods = {
 
       // gh-2399
       // we should cast model only when it's not a discriminator
-      const isDisc = value.schema && value.schema.discriminatorMapping &&
-          value.schema.discriminatorMapping.key !== undefined;
+      const isDisc = value.schema?.discriminatorMapping?.key !== undefined;
       if (!isDisc) {
         value = new Model(value);
       }
@@ -338,7 +368,7 @@ const methods = {
 
     // check for impossible $atomic combos (Mongo denies more than one
     // $atomic op on a single path
-    if (atomics.$set || Object.keys(atomics).length && !(op in atomics)) {
+    if (atomics.$set || utils.hasOwnKeys(atomics) && !(op in atomics)) {
       // a different op was previously registered.
       // save the entire thing.
       this[arrayAtomicsSymbol] = { $set: this };
@@ -895,7 +925,7 @@ const methods = {
 
   toObject(options) {
     const arr = utils.isMongooseArray(this) ? this.__array : this;
-    if (options && options.depopulate) {
+    if (options?.depopulate) {
       options = clone(options);
       options._isNested = true;
       // Ensure return value is a vanilla array, because in Node.js 6+ `map()`
@@ -995,7 +1025,7 @@ function _minimizePath(obj, parts, i) {
   }
 
   _minimizePath(obj[parts[0]], parts, i + 1);
-  if (obj[parts[0]] != null && typeof obj[parts[0]] === 'object' && Object.keys(obj[parts[0]]).length === 0) {
+  if (obj[parts[0]] != null && typeof obj[parts[0]] === 'object' && utils.hasOwnKeys(obj[parts[0]]) === false) {
     delete obj[parts[0]];
   }
 }