mongoose 8.19.4 → 9.0.0-rc0

package/lib/schema.js

@@ -23,6 +23,7 @@ const merge = require('./helpers/schema/merge');
 const mpath = require('mpath');
 const setPopulatedVirtualValue = require('./helpers/populate/setPopulatedVirtualValue');
 const setupTimestamps = require('./helpers/timestamps/setupTimestamps');
+const symbols = require('./schema/symbols');
 const utils = require('./utils');
 const validateRef = require('./helpers/populate/validateRef');
 
@@ -31,7 +32,7 @@ const hasNumericSubpathRegex = /\.\d+(\.|$)/;
 let MongooseTypes;
 
 const queryHooks = require('./constants').queryMiddlewareFunctions;
-const documentHooks = require('./helpers/model/applyHooks').middlewareFunctions;
+const documentHooks = require('./constants').documentMiddlewareFunctions;
 const hookNames = queryHooks.concat(documentHooks).
   reduce((s, hook) => s.add(hook), new Set());
 
@@ -372,6 +373,29 @@ Schema.prototype.paths;
 
 Schema.prototype.tree;
 
+/**
+ * Creates a new schema with the given definition and options. Equivalent to `new Schema(definition, options)`.
+ *
+ * `Schema.create()` is primarily useful for automatic schema type inference in TypeScript.
+ *
+ * #### Example:
+ *
+ *     const schema = Schema.create({ name: String }, { toObject: { virtuals: true } });
+ *     // Equivalent:
+ *     const schema2 = new Schema({ name: String }, { toObject: { virtuals: true } });
+ *
+ * @param {Object} definition
+ * @param {Object} [options]
+ * @return {Schema} the new schema
+ * @api public
+ * @memberOf Schema
+ * @static
+ */
+
+Schema.create = function create(definition, options) {
+  return new Schema(definition, options);
+};
+
 /**
  * Returns a deep copy of the schema
  *
@@ -660,6 +684,33 @@ Schema.prototype.discriminator = function(name, schema, options) {
   return this;
 };
 
+/*!
+ * Get the document middleware for this schema, filtering out any hooks that are specific to queries.
+ */
+Schema.prototype._getDocumentMiddleware = function _getDocumentMiddleware() {
+  return this.s.hooks.
+    filter(hook => {
+      if (hook.name === 'updateOne' || hook.name === 'deleteOne') {
+        return !!hook['document'];
+      }
+      if (hook.name === 'remove' || hook.name === 'init') {
+        return hook['document'] == null || !!hook['document'];
+      }
+      if (hook.query != null || hook.document != null) {
+        return hook.document !== false;
+      }
+      return true;
+    }).
+    filter(hook => {
+      // If user has overwritten the method, don't apply built-in middleware
+      if (this.methods[hook.name]) {
+        return !hook.fn[symbols.builtInMiddleware];
+      }
+
+      return true;
+    });
+};
+
 /*!
  * Get this schema's default toObject/toJSON options, including Mongoose global
  * options.
@@ -1300,7 +1351,7 @@ Schema.prototype.path = function(path, obj) {
     if (schemaType.$__schemaType.$isSingleNested) {
       this.childSchemas.push({
         schema: schemaType.$__schemaType.schema,
-        model: schemaType.$__schemaType.caster,
+        model: schemaType.$__schemaType.Constructor,
         path: path
       });
     }
@@ -1329,10 +1380,10 @@ Schema.prototype.path = function(path, obj) {
       value: this.base
     });
 
-    schemaType.caster.base = this.base;
+    schemaType.Constructor.base = this.base;
     this.childSchemas.push({
       schema: schemaType.schema,
-      model: schemaType.caster,
+      model: schemaType.Constructor,
       path: path
     });
   } else if (schemaType.$isMongooseDocumentArray) {
@@ -1343,15 +1394,15 @@ Schema.prototype.path = function(path, obj) {
       value: this.base
     });
 
-    schemaType.casterConstructor.base = this.base;
+    schemaType.Constructor.base = this.base;
     this.childSchemas.push({
       schema: schemaType.schema,
-      model: schemaType.casterConstructor,
+      model: schemaType.Constructor,
       path: path
     });
   }
 
-  if (schemaType.$isMongooseArray && schemaType.caster instanceof SchemaType) {
+  if (schemaType.$isMongooseArray && !schemaType.$isMongooseDocumentArray) {
     let arrayPath = path;
     let _schemaType = schemaType;
 
@@ -1359,16 +1410,9 @@ Schema.prototype.path = function(path, obj) {
     while (_schemaType.$isMongooseArray) {
       arrayPath = arrayPath + '.$';
 
-      // Skip arrays of document arrays
-      if (_schemaType.$isMongooseDocumentArray) {
-        _schemaType.$embeddedSchemaType._arrayPath = arrayPath;
-        _schemaType.$embeddedSchemaType._arrayParentPath = path;
-        _schemaType = _schemaType.$embeddedSchemaType;
-      } else {
-        _schemaType.caster._arrayPath = arrayPath;
-        _schemaType.caster._arrayParentPath = path;
-        _schemaType = _schemaType.caster;
-      }
+      _schemaType.embeddedSchemaType._arrayPath = arrayPath;
+      _schemaType.embeddedSchemaType._arrayParentPath = path;
+      _schemaType = _schemaType.embeddedSchemaType;
 
       this.subpaths[arrayPath] = _schemaType;
     }
@@ -1420,13 +1464,13 @@ Schema.prototype._gatherChildSchemas = function _gatherChildSchemas() {
     if (schematype.$isMongooseDocumentArray || schematype.$isSingleNested) {
       childSchemas.push({
         schema: schematype.schema,
-        model: schematype.caster,
+        model: schematype.Constructor,
         path: path
       });
     } else if (schematype.$isSchemaMap && schematype.$__schemaType.$isSingleNested) {
       childSchemas.push({
         schema: schematype.$__schemaType.schema,
-        model: schematype.$__schemaType.caster,
+        model: schematype.$__schemaType.Constructor,
         path: path
       });
     }
@@ -1572,7 +1616,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
   let name;
 
   if (utils.isPOJO(type) || type === 'mixed') {
-    return new MongooseTypes.Mixed(path, obj);
+    return new MongooseTypes.Mixed(path, obj, null, this);
   }
 
   if (Array.isArray(type) || type === Array || type === 'array' || type === MongooseTypes.Array) {
@@ -1595,7 +1639,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
             `${path}: new Schema(...)`);
         }
       }
-      return new MongooseTypes.DocumentArray(path, cast, obj);
+      return new MongooseTypes.DocumentArray(path, cast, obj, null, this);
     }
     if (cast &&
         cast[options.typeKey] &&
@@ -1612,14 +1656,14 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
             `${path}: new Schema(...)`);
         }
       }
-      return new MongooseTypes.DocumentArray(path, cast[options.typeKey], obj, cast);
+      return new MongooseTypes.DocumentArray(path, cast[options.typeKey], obj, cast, this);
     }
     if (typeof cast !== 'undefined') {
       if (Array.isArray(cast) || cast.type === Array || cast.type == 'Array') {
         if (cast && cast.type == 'Array') {
           cast.type = Array;
         }
-        return new MongooseTypes.Array(path, this.interpretAsType(path, cast, options), obj);
+        return new MongooseTypes.Array(path, this.interpretAsType(path, cast, options), obj, null, this);
       }
     }
 
@@ -1660,10 +1704,10 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
 
         const childSchema = new Schema(castFromTypeKey, childSchemaOptions);
         childSchema.$implicitlyCreated = true;
-        return new MongooseTypes.DocumentArray(path, childSchema, obj);
+        return new MongooseTypes.DocumentArray(path, childSchema, obj, null, this);
       } else {
         // Special case: empty object becomes mixed
-        return new MongooseTypes.Array(path, MongooseTypes.Mixed, obj);
+        return new MongooseTypes.Array(path, MongooseTypes.Mixed, obj, null, this);
       }
     }
 
@@ -1672,7 +1716,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
         ? cast[options.typeKey]
         : cast;
       if (Array.isArray(type)) {
-        return new MongooseTypes.Array(path, this.interpretAsType(path, type, options), obj);
+        return new MongooseTypes.Array(path, this.interpretAsType(path, type, options), obj, null, this);
       }
 
       name = typeof type === 'string'
@@ -1700,11 +1744,11 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
       }
     }
 
-    return new MongooseTypes.Array(path, cast || MongooseTypes.Mixed, obj, options);
+    return new MongooseTypes.Array(path, cast || MongooseTypes.Mixed, obj, options, this);
   }
 
   if (type && type.instanceOfSchema) {
-    return new MongooseTypes.Subdocument(type, path, obj);
+    return new MongooseTypes.Subdocument(type, path, obj, this);
   }
 
   if (Buffer.isBuffer(type)) {
@@ -1743,53 +1787,11 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
       'https://bit.ly/mongoose-schematypes for a list of valid schema types.');
   }
 
-  if (name === 'Union') {
-    obj.parentSchema = this;
-  }
-  const schemaType = new MongooseTypes[name](path, obj, options);
-
-  if (schemaType.$isSchemaMap) {
-    createMapNestedSchemaType(this, schemaType, path, obj, options);
-  }
+  const schemaType = new MongooseTypes[name](path, obj, options, this);
 
   return schemaType;
 };
 
-/*!
- * ignore
- */
-
-function createMapNestedSchemaType(schema, schemaType, path, obj, options) {
-  const mapPath = path + '.$*';
-  let _mapType = { type: {} };
-  if (utils.hasUserDefinedProperty(obj, 'of')) {
-    const isInlineSchema = utils.isPOJO(obj.of) &&
-      Object.keys(obj.of).length > 0 &&
-      !utils.hasUserDefinedProperty(obj.of, schema.options.typeKey);
-    if (isInlineSchema) {
-      _mapType = { [schema.options.typeKey]: new Schema(obj.of) };
-    } else if (utils.isPOJO(obj.of)) {
-      _mapType = Object.assign({}, obj.of);
-    } else {
-      _mapType = { [schema.options.typeKey]: obj.of };
-    }
-
-    if (_mapType[schema.options.typeKey] && _mapType[schema.options.typeKey].instanceOfSchema) {
-      const subdocumentSchema = _mapType[schema.options.typeKey];
-      subdocumentSchema.eachPath((subpath, type) => {
-        if (type.options.select === true || type.options.select === false) {
-          throw new MongooseError('Cannot use schema-level projections (`select: true` or `select: false`) within maps at path "' + path + '.' + subpath + '"');
-        }
-      });
-    }
-
-    if (utils.hasUserDefinedProperty(obj, 'ref')) {
-      _mapType.ref = obj.ref;
-    }
-  }
-  schemaType.$__schemaType = schema.interpretAsType(mapPath, _mapType, options);
-}
-
 /**
  * Iterates the schemas paths similar to Array#forEach.
  *
@@ -1987,10 +1989,10 @@ function getPositionalPathType(self, path, cleanPath) {
 
     if (i === last && val && !/\D/.test(subpath)) {
       if (val.$isMongooseDocumentArray) {
-        val = val.$embeddedSchemaType;
+        val = val.embeddedSchemaType;
       } else if (val instanceof MongooseTypes.Array) {
         // StringSchema, NumberSchema, etc
-        val = val.caster;
+        val = val.embeddedSchemaType;
       } else {
         val = undefined;
       }
@@ -2001,7 +2003,7 @@ function getPositionalPathType(self, path, cleanPath) {
     if (!/\D/.test(subpath)) {
       // Nested array
       if (val instanceof MongooseTypes.Array && i !== last) {
-        val = val.caster;
+        val = val.embeddedSchemaType;
       }
       continue;
     }
@@ -2064,23 +2066,21 @@ Schema.prototype.queue = function(name, args) {
  *
  *     const toySchema = new Schema({ name: String, created: Date });
  *
- *     toySchema.pre('save', function(next) {
+ *     toySchema.pre('save', function() {
  *       if (!this.created) this.created = new Date;
- *       next();
  *     });
  *
- *     toySchema.pre('validate', function(next) {
+ *     toySchema.pre('validate', function() {
  *       if (this.name !== 'Woody') this.name = 'Woody';
- *       next();
  *     });
  *
  *     // Equivalent to calling `pre()` on `find`, `findOne`, `findOneAndUpdate`.
- *     toySchema.pre(/^find/, function(next) {
+ *     toySchema.pre(/^find/, function() {
  *       console.log(this.getFilter());
  *     });
  *
  *     // Equivalent to calling `pre()` on `updateOne`, `findOneAndUpdate`.
- *     toySchema.pre(['updateOne', 'findOneAndUpdate'], function(next) {
+ *     toySchema.pre(['updateOne', 'findOneAndUpdate'], function() {
  *       console.log(this.getFilter());
  *     });
  *
@@ -2497,8 +2497,8 @@ Object.defineProperty(Schema, 'indexTypes', {
  *       registeredAt: { type: Date, index: true }
  *     });
  *
- *     // [ [ { email: 1 }, { unique: true, background: true } ],
- *     //   [ { registeredAt: 1 }, { background: true } ] ]
+ *     // [ [ { email: 1 }, { unique: true } ],
+ *     //   [ { registeredAt: 1 }, {} ] ]
  *     userSchema.indexes();
  *
  * [Plugins](https://mongoosejs.com/docs/plugins.html) can use the return value of this function to modify a schema's indexes.
@@ -2896,11 +2896,11 @@ Schema.prototype._getSchema = function(path) {
       if (foundschema) {
         resultPath.push(trypath);
 
-        if (foundschema.caster) {
+        if (foundschema.embeddedSchemaType || foundschema.Constructor) {
           // array of Mixed?
-          if (foundschema.caster instanceof MongooseTypes.Mixed) {
-            foundschema.caster.$fullPath = resultPath.join('.');
-            return foundschema.caster;
+          if (foundschema.embeddedSchemaType instanceof MongooseTypes.Mixed) {
+            foundschema.embeddedSchemaType.$fullPath = resultPath.join('.');
+            return foundschema.embeddedSchemaType;
           }
 
           // Now that we found the array, we need to check if there
@@ -2910,8 +2910,8 @@ Schema.prototype._getSchema = function(path) {
           // If there is no foundschema.schema we are dealing with
           // a path like array.$
           if (p !== parts.length) {
-            if (p + 1 === parts.length && foundschema.$embeddedSchemaType && (parts[p] === '$' || isArrayFilter(parts[p]))) {
-              return foundschema.$embeddedSchemaType;
+            if (p + 1 === parts.length && foundschema.embeddedSchemaType && (parts[p] === '$' || isArrayFilter(parts[p]))) {
+              return foundschema.embeddedSchemaType;
             }
 
             if (foundschema.schema) {
@@ -2919,7 +2919,7 @@ Schema.prototype._getSchema = function(path) {
               if (parts[p] === '$' || isArrayFilter(parts[p])) {
                 if (p + 1 === parts.length) {
                   // comments.$
-                  return foundschema.$embeddedSchemaType;
+                  return foundschema.embeddedSchemaType;
                 }
                 // comments.$.comments.$.title
                 ret = search(parts.slice(p + 1), foundschema.schema);
@@ -2999,9 +2999,9 @@ Schema.prototype._getPathType = function(path) {
       trypath = parts.slice(0, p).join('.');
       foundschema = schema.path(trypath);
       if (foundschema) {
-        if (foundschema.caster) {
+        if (foundschema.embeddedSchemaType || foundschema.Constructor) {
           // array of Mixed?
-          if (foundschema.caster instanceof MongooseTypes.Mixed) {
+          if (foundschema.embeddedSchemaType instanceof MongooseTypes.Mixed) {
             return { schema: foundschema, pathType: 'mixed' };
           }
 

package/lib/schemaType.js

@@ -12,7 +12,6 @@ const clone = require('./helpers/clone');
 const handleImmutable = require('./helpers/schematype/handleImmutable');
 const isAsyncFunction = require('./helpers/isAsyncFunction');
 const isSimpleValidator = require('./helpers/isSimpleValidator');
-const immediate = require('./helpers/immediate');
 const schemaTypeSymbol = require('./helpers/symbols').schemaTypeSymbol;
 const utils = require('./utils');
 const validatorErrorSymbol = require('./helpers/symbols').validatorErrorSymbol;
@@ -37,10 +36,11 @@ const setOptionsForDefaults = { _skipMarkModified: true };
  * @param {String} path
  * @param {SchemaTypeOptions} [options] See [SchemaTypeOptions docs](https://mongoosejs.com/docs/api/schematypeoptions.html)
  * @param {String} [instance]
+ * @param {Schema} [parentSchema]
  * @api public
  */
 
-function SchemaType(path, options, instance) {
+function SchemaType(path, options, instance, parentSchema) {
   this[schemaTypeSymbol] = true;
   this.path = path;
   this.instance = instance;
@@ -73,6 +73,7 @@ function SchemaType(path, options, instance) {
 
   const Options = this.OptionsConstructor || SchemaTypeOptions;
   this.options = new Options(options);
+  this.parentSchema = parentSchema;
   this._index = null;
 
   if (utils.hasUserDefinedProperty(this.options, 'immutable')) {
@@ -157,6 +158,30 @@ SchemaType.prototype.OptionsConstructor = SchemaTypeOptions;
 
 SchemaType.prototype.path;
 
+/**
+ * Returns a plain JavaScript object representing this SchemaType.
+ *
+ * Typically used by `JSON.stringify()` or when calling `.toJSON()` on a SchemaType instance.
+ * Omits certain internal properties such as `parentSchema` that can cause circular references.
+ *
+ * #### Example:
+ *
+ *     const schema = new Schema({ name: String });
+ *     const schematype = schema.path('name');
+ *     console.log(schematype.toJSON());
+ *
+ * @function toJSON
+ * @memberOf SchemaType
+ * @instance
+ * @api public
+ */
+
+SchemaType.prototype.toJSON = function toJSON() {
+  const res = { ...this };
+  delete res.parentSchema;
+  return res;
+};
+
 /**
  * The validators that Mongoose should run to validate properties at this SchemaType's path.
  *
@@ -419,13 +444,6 @@ SchemaType.prototype.default = function(val) {
  *     s.path('my.date').index({ expires: 60 });
  *     s.path('my.path').index({ unique: true, sparse: true });
  *
- * #### Note:
- *
- * _Indexes are created [in the background](https://www.mongodb.com/docs/manual/core/index-creation/#index-creation-background)
- * by default. If `background` is set to `false`, MongoDB will not execute any
- * read/write operations you send until the index build.
- * Specify `background: false` to override Mongoose's default._
- *
  * @param {Object|Boolean|String|Number} options
  * @return {SchemaType} this
  * @api public
@@ -1315,7 +1333,6 @@ SchemaType.prototype.select = function select(val) {
  * Performs a validation of `value` using the validators declared for this SchemaType.
  *
  * @param {Any} value
- * @param {Function} callback
  * @param {Object} scope
  * @param {Object} [options]
  * @param {String} [options.path]
@@ -1323,28 +1340,20 @@ SchemaType.prototype.select = function select(val) {
  * @api public
  */
 
-SchemaType.prototype.doValidate = function(value, fn, scope, options) {
+SchemaType.prototype.doValidate = async function doValidate(value, scope, options) {
   let err = false;
   const path = this.path;
-  if (typeof fn !== 'function') {
-    throw new TypeError(`Must pass callback function to doValidate(), got ${typeof fn}`);
-  }
 
   // Avoid non-object `validators`
   const validators = this.validators.
     filter(v => typeof v === 'object' && v !== null);
 
-  let count = validators.length;
-
-  if (!count) {
-    return fn(null);
+  if (!validators.length) {
+    return;
   }
 
+  const promises = [];
   for (let i = 0, len = validators.length; i < len; ++i) {
-    if (err) {
-      break;
-    }
-
     const v = validators[i];
     const validator = v.validator;
     let ok;
@@ -1360,17 +1369,19 @@ SchemaType.prototype.doValidate = function(value, fn, scope, options) {
       }
     }
 
-    if (validator instanceof RegExp) {
-      validate(validator.test(value), validatorProperties, scope);
+    if (value === undefined && validator !== this.requiredValidator) {
       continue;
     }
-
-    if (typeof validator !== 'function') {
+    if (validator instanceof RegExp) {
+      ok = validator.test(value);
+      if (ok === false) {
+        const ErrorConstructor = validatorProperties.ErrorConstructor || ValidatorError;
+        err = new ErrorConstructor(validatorProperties, scope);
+        err[validatorErrorSymbol] = true;
+        throw err;
+      }
       continue;
-    }
-
-    if (value === undefined && validator !== this.requiredValidator) {
-      validate(true, validatorProperties, scope);
+    } else if (typeof validator !== 'function') {
       continue;
     }
 
@@ -1389,38 +1400,35 @@ SchemaType.prototype.doValidate = function(value, fn, scope, options) {
     }
 
     if (ok != null && typeof ok.then === 'function') {
-      ok.then(
-        function(ok) { validate(ok, validatorProperties, scope); },
-        function(error) {
-          validatorProperties.reason = error;
-          validatorProperties.message = error.message;
-          ok = false;
-          validate(ok, validatorProperties, scope);
-        });
-    } else {
-      validate(ok, validatorProperties, scope);
-    }
-  }
-
-  function validate(ok, validatorProperties, scope) {
-    if (err) {
-      return;
-    }
-    if (ok === undefined || ok) {
-      if (--count <= 0) {
-        immediate(function() {
-          fn(null);
-        });
-      }
-    } else {
+      promises.push(
+        ok.then(
+          function(ok) {
+            if (ok === false) {
+              const ErrorConstructor = validatorProperties.ErrorConstructor || ValidatorError;
+              err = new ErrorConstructor(validatorProperties, scope);
+              err[validatorErrorSymbol] = true;
+              throw err;
+            }
+          },
+          function(error) {
+            validatorProperties.reason = error;
+            validatorProperties.message = error.message;
+            ok = false;
+            const ErrorConstructor = validatorProperties.ErrorConstructor || ValidatorError;
+            err = new ErrorConstructor(validatorProperties, scope);
+            err[validatorErrorSymbol] = true;
+            throw err;
+          })
+      );
+    } else if (ok !== undefined && !ok) {
       const ErrorConstructor = validatorProperties.ErrorConstructor || ValidatorError;
       err = new ErrorConstructor(validatorProperties, scope);
       err[validatorErrorSymbol] = true;
-      immediate(function() {
-        fn(err);
-      });
+      throw err;
     }
   }
+
+  await Promise.all(promises);
 };
 
 
@@ -1751,7 +1759,7 @@ SchemaType.prototype.checkRequired = function(val) {
 
 SchemaType.prototype.clone = function() {
   const options = Object.assign({}, this.options);
-  const schematype = new this.constructor(this.path, options, this.instance);
+  const schematype = new this.constructor(this.path, options, this.instance, this.parentSchema);
   schematype.validators = this.validators.slice();
   if (this.requiredValidator !== undefined) schematype.requiredValidator = this.requiredValidator;
   if (this.defaultValue !== undefined) schematype.defaultValue = this.defaultValue;
@@ -1785,7 +1793,7 @@ SchemaType.prototype.clone = function() {
  */
 
 SchemaType.prototype.getEmbeddedSchemaType = function getEmbeddedSchemaType() {
-  return this.$embeddedSchemaType;
+  return this.embeddedSchemaType;
 };
 
 /*!

package/lib/types/array/index.js

@@ -88,8 +88,8 @@ function MongooseArray(values, path, doc, schematype) {
       if (schematype && schematype.virtuals && schematype.virtuals.hasOwnProperty(prop)) {
         return schematype.virtuals[prop].applyGetters(undefined, target);
       }
-      if (typeof prop === 'string' && numberRE.test(prop) && schematype?.$embeddedSchemaType != null) {
-        return schematype.$embeddedSchemaType.applyGetters(__array[prop], doc);
+      if (typeof prop === 'string' && numberRE.test(prop) && schematype?.embeddedSchemaType != null) {
+        return schematype.embeddedSchemaType.applyGetters(__array[prop], doc);
       }
 
       return __array[prop];

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

@@ -251,10 +251,10 @@ const methods = {
       if (!isDisc) {
         value = new Model(value);
       }
-      return this[arraySchemaSymbol].caster.applySetters(value, parent, true);
+      return this[arraySchemaSymbol].embeddedSchemaType.applySetters(value, parent, true);
     }
 
-    return this[arraySchemaSymbol].caster.applySetters(value, parent, false);
+    return this[arraySchemaSymbol].embeddedSchemaType.applySetters(value, parent, false);
   },
 
   /**
@@ -1007,7 +1007,7 @@ function _minimizePath(obj, parts, i) {
 function _checkManualPopulation(arr, docs) {
   const ref = arr == null ?
     null :
-    arr[arraySchemaSymbol] && arr[arraySchemaSymbol].caster && arr[arraySchemaSymbol].caster.options && arr[arraySchemaSymbol].caster.options.ref || null;
+    arr[arraySchemaSymbol]?.embeddedSchemaType?.options?.ref || null;
   if (arr.length === 0 &&
       docs.length !== 0) {
     if (_isAllSubdocs(docs, ref)) {
@@ -1025,7 +1025,7 @@ function _checkManualPopulation(arr, docs) {
 function _depopulateIfNecessary(arr, docs) {
   const ref = arr == null ?
     null :
-    arr[arraySchemaSymbol] && arr[arraySchemaSymbol].caster && arr[arraySchemaSymbol].caster.options && arr[arraySchemaSymbol].caster.options.ref || null;
+    arr[arraySchemaSymbol]?.embeddedSchemaType?.options?.ref || null;
   const parentDoc = arr[arrayParentSymbol];
   const path = arr[arrayPathSymbol];
   if (!ref || !parentDoc.populated(path)) {

package/lib/types/arraySubdocument.js

@@ -41,7 +41,7 @@ function ArraySubdocument(obj, parentArr, skipId, fields, index) {
     options = { isNew: true };
   }
 
-  Subdocument.call(this, obj, fields, this[documentArrayParent], skipId, options);
+  Subdocument.call(this, obj, fields, this[documentArrayParent], options);
 }
 
 /*!