mongoose 8.20.0 → 9.0.0-rc1

package/lib/schema/subdocument.js

@@ -50,9 +50,9 @@ function SchemaSubdocument(schema, path, options, parentSchema) {
 
   schema = handleIdOption(schema, options);
 
-  this.caster = _createConstructor(schema, null, options);
-  this.caster.path = path;
-  this.caster.prototype.$basePath = path;
+  this.Constructor = _createConstructor(schema, null, options);
+  this.Constructor.path = path;
+  this.Constructor.prototype.$basePath = path;
   this.schema = schema;
   this.$isSingleNested = true;
   this.base = schema.base;
@@ -181,13 +181,13 @@ SchemaSubdocument.prototype.cast = function(val, doc, init, priorVal, options) {
     return val;
   }
 
-  if (val != null && (typeof val !== 'object' || Array.isArray(val))) {
+  if (!init && val != null && (typeof val !== 'object' || Array.isArray(val))) {
     throw new ObjectExpectedError(this.path, val);
   }
 
   const discriminatorKeyPath = this.schema.path(this.schema.options.discriminatorKey);
   const defaultDiscriminatorValue = discriminatorKeyPath == null ? null : discriminatorKeyPath.getDefault(doc);
-  const Constructor = getConstructor(this.caster, val, defaultDiscriminatorValue);
+  const Constructor = getConstructor(this.Constructor, val, defaultDiscriminatorValue);
 
   let subdoc;
 
@@ -202,7 +202,7 @@ SchemaSubdocument.prototype.cast = function(val, doc, init, priorVal, options) {
     return obj;
   }, null);
   if (init) {
-    subdoc = new Constructor(void 0, selected, doc, false, { defaults: false });
+    subdoc = new Constructor(void 0, selected, doc, { defaults: false });
     delete subdoc.$__.defaults;
     // Don't pass `path` to $init - it's only for the subdocument itself, not its fields.
     // For change tracking, subdocuments use relative paths internally.
@@ -217,10 +217,10 @@ SchemaSubdocument.prototype.cast = function(val, doc, init, priorVal, options) {
   } else {
     options = Object.assign({}, options, { priorDoc: priorVal });
     if (Object.keys(val).length === 0) {
-      return new Constructor({}, selected, doc, undefined, options);
+      return new Constructor({}, selected, doc, options);
     }
 
-    return new Constructor(val, selected, doc, undefined, options);
+    return new Constructor(val, selected, doc, options);
   }
 
   return subdoc;
@@ -247,7 +247,7 @@ SchemaSubdocument.prototype.castForQuery = function($conditional, val, context,
     return val;
   }
 
-  const Constructor = getConstructor(this.caster, val);
+  const Constructor = getConstructor(this.Constructor, val);
   if (val instanceof Constructor) {
     return val;
   }
@@ -275,11 +275,11 @@ SchemaSubdocument.prototype.castForQuery = function($conditional, val, context,
 /**
  * Async validation on this single nested doc.
  *
- * @api private
+ * @api public
  */
 
-SchemaSubdocument.prototype.doValidate = function(value, fn, scope, options) {
-  const Constructor = getConstructor(this.caster, value);
+SchemaSubdocument.prototype.doValidate = async function doValidate(value, scope, options) {
+  const Constructor = getConstructor(this.Constructor, value);
 
   if (value && !(value instanceof Constructor)) {
     value = new Constructor(value, null, (scope != null && scope.$__ != null) ? scope : null);
@@ -287,21 +287,15 @@ SchemaSubdocument.prototype.doValidate = function(value, fn, scope, options) {
 
   if (options && options.skipSchemaValidators) {
     if (!value) {
-      return fn(null);
+      return;
     }
-    return value.validate().then(() => fn(null), err => fn(err));
+    return value.validate();
   }
 
-  SchemaType.prototype.doValidate.call(this, value, function(error) {
-    if (error) {
-      return fn(error);
-    }
-    if (!value) {
-      return fn(null);
-    }
-
-    value.validate().then(() => fn(null), err => fn(err));
-  }, scope, options);
+  await SchemaType.prototype.doValidate.call(this, value, scope, options);
+  if (value != null) {
+    await value.validate();
+  }
 };
 
 /**
@@ -355,11 +349,11 @@ SchemaSubdocument.prototype.discriminator = function(name, schema, options) {
     schema = schema.clone();
   }
 
-  schema = discriminator(this.caster, name, schema, value, null, null, options.overwriteExisting);
+  schema = discriminator(this.Constructor, name, schema, value, null, null, options.overwriteExisting);
 
-  this.caster.discriminators[name] = _createConstructor(schema, this.caster);
+  this.Constructor.discriminators[name] = _createConstructor(schema, this.Constructor);
 
-  return this.caster.discriminators[name];
+  return this.Constructor.discriminators[name];
 };
 
 /*!
@@ -423,7 +417,7 @@ SchemaSubdocument.prototype.clone = function() {
   if (this.requiredValidator !== undefined) {
     schematype.requiredValidator = this.requiredValidator;
   }
-  schematype.caster.discriminators = Object.assign({}, this.caster.discriminators);
+  schematype.Constructor.discriminators = Object.assign({}, this.Constructor.discriminators);
   schematype._appliedDiscriminators = this._appliedDiscriminators;
   return schematype;
 };

package/lib/schema/uuid.js

@@ -4,7 +4,6 @@
 
 'use strict';
 
-const MongooseBuffer = require('../types/buffer');
 const SchemaType = require('../schemaType');
 const CastError = SchemaType.CastError;
 const castUUID = require('../cast/uuid');
@@ -13,7 +12,6 @@ const utils = require('../utils');
 const handleBitwiseOperator = require('./operators/bitwise');
 
 const UUID_FORMAT = castUUID.UUID_FORMAT;
-const Binary = MongooseBuffer.Binary;
 
 /**
  * Convert binary to a uuid string
@@ -45,21 +43,6 @@ function binaryToString(uuidBin) {
 
 function SchemaUUID(key, options, _schemaOptions, parentSchema) {
   SchemaType.call(this, key, options, 'UUID', parentSchema);
-  this.getters.push(function(value) {
-    // For populated
-    if (value != null && value.$__ != null) {
-      return value;
-    }
-    if (Buffer.isBuffer(value)) {
-      return binaryToString(value);
-    } else if (value instanceof Binary) {
-      return binaryToString(value.buffer);
-    } else if (utils.isPOJO(value) && value.type === 'Buffer' && Array.isArray(value.data)) {
-      // Cloned buffers look like `{ type: 'Buffer', data: [5, 224, ...] }`
-      return binaryToString(Buffer.from(value.data));
-    }
-    return value;
-  });
 }
 
 /**
@@ -251,11 +234,7 @@ const $conditionalHandlers = {
   $bitsAllSet: handleBitwiseOperator,
   $bitsAnySet: handleBitwiseOperator,
   $all: handleArray,
-  $gt: handleSingle,
-  $gte: handleSingle,
   $in: handleArray,
-  $lt: handleSingle,
-  $lte: handleSingle,
   $ne: handleSingle,
   $nin: handleArray
 };

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
       });
     }
@@ -1945,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;
       }
@@ -1959,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;
     }
@@ -2022,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());
  *     });
  *
@@ -2455,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.
@@ -2854,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
@@ -2868,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) {
@@ -2877,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);
@@ -2957,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;
@@ -445,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
@@ -1341,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]
@@ -1349,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;
@@ -1386,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;
     }
 
@@ -1415,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);
 };
 
 
@@ -1811,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);
 }
 
 /*!