mongoose 8.19.4 → 9.0.0-rc0

package/lib/schema/array.js

@@ -28,7 +28,6 @@ const getDiscriminatorByValue = require('../helpers/discriminator/getDiscriminat
 let MongooseArray;
 let EmbeddedDoc;
 
-const isNestedArraySymbol = Symbol('mongoose#isNestedArray');
 const emptyOpts = Object.freeze({});
 
 /**
@@ -38,11 +37,12 @@ const emptyOpts = Object.freeze({});
  * @param {SchemaType} cast
  * @param {Object} options
  * @param {Object} schemaOptions
+ * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
  */
 
-function SchemaArray(key, cast, options, schemaOptions) {
+function SchemaArray(key, cast, options, schemaOptions, parentSchema) {
   // lazy load
   EmbeddedDoc || (EmbeddedDoc = require('../types').Embedded);
 
@@ -80,32 +80,26 @@ function SchemaArray(key, cast, options, schemaOptions) {
       : utils.getFunctionName(cast);
 
     const Types = require('./index.js');
-    const caster = Types.hasOwnProperty(name) ? Types[name] : cast;
+    const schemaTypeDefinition = Types.hasOwnProperty(name) ? Types[name] : cast;
 
-    this.casterConstructor = caster;
-
-    if (this.casterConstructor instanceof SchemaArray) {
-      this.casterConstructor[isNestedArraySymbol] = true;
-    }
-
-    if (typeof caster === 'function' &&
-        !caster.$isArraySubdocument &&
-        !caster.$isSchemaMap) {
-      const path = this.caster instanceof EmbeddedDoc ? null : key;
-      this.caster = new caster(path, castOptions);
-    } else {
-      this.caster = caster;
-      if (!(this.caster instanceof EmbeddedDoc)) {
-        this.caster.path = key;
+    if (typeof schemaTypeDefinition === 'function') {
+      if (schemaTypeDefinition === SchemaArray) {
+        this.embeddedSchemaType = new schemaTypeDefinition(key, castOptions, schemaOptions, null, parentSchema);
+      } else {
+        this.embeddedSchemaType = new schemaTypeDefinition(key, castOptions, schemaOptions, parentSchema);
+      }
+    } else if (schemaTypeDefinition instanceof SchemaType) {
+      this.embeddedSchemaType = schemaTypeDefinition;
+      if (!(this.embeddedSchemaType instanceof EmbeddedDoc)) {
+        this.embeddedSchemaType.path = key;
       }
     }
 
-    this.$embeddedSchemaType = this.caster;
   }
 
   this.$isMongooseArray = true;
 
-  SchemaType.call(this, key, options, 'Array');
+  SchemaType.call(this, key, options, 'Array', parentSchema);
 
   let defaultArr;
   let fn;
@@ -262,10 +256,10 @@ SchemaArray.prototype.enum = function() {
   let arr = this;
   while (true) {
     const instance = arr &&
-    arr.caster &&
-    arr.caster.instance;
+    arr.embeddedSchemaType &&
+    arr.embeddedSchemaType.instance;
     if (instance === 'Array') {
-      arr = arr.caster;
+      arr = arr.embeddedSchemaType;
       continue;
     }
     if (instance !== 'String' && instance !== 'Number') {
@@ -280,7 +274,7 @@ SchemaArray.prototype.enum = function() {
     enumArray = utils.object.vals(enumArray);
   }
 
-  arr.caster.enum.apply(arr.caster, enumArray);
+  arr.embeddedSchemaType.enum.apply(arr.embeddedSchemaType, enumArray);
   return this;
 };
 
@@ -303,9 +297,8 @@ SchemaArray.prototype.applyGetters = function(value, scope) {
 };
 
 SchemaArray.prototype._applySetters = function(value, scope, init, priorVal) {
-  if (this.casterConstructor.$isMongooseArray &&
-      SchemaArray.options.castNonArrays &&
-      !this[isNestedArraySymbol]) {
+  if (this.embeddedSchemaType.$isMongooseArray &&
+      SchemaArray.options.castNonArrays) {
     // Check nesting levels and wrap in array if necessary
     let depth = 0;
     let arr = this;
@@ -313,7 +306,7 @@ SchemaArray.prototype._applySetters = function(value, scope, init, priorVal) {
       arr.$isMongooseArray &&
       !arr.$isMongooseDocumentArray) {
       ++depth;
-      arr = arr.casterConstructor;
+      arr = arr.embeddedSchemaType;
     }
 
     // No need to wrap empty arrays
@@ -387,9 +380,9 @@ SchemaArray.prototype.cast = function(value, doc, init, prev, options) {
       return value;
     }
 
-    const caster = this.caster;
+    const caster = this.embeddedSchemaType;
     const isMongooseArray = caster.$isMongooseArray;
-    if (caster && this.casterConstructor !== Mixed) {
+    if (caster && this.embeddedSchemaType.constructor !== Mixed) {
       try {
         const len = rawValue.length;
         for (i = 0; i < len; i++) {
@@ -444,19 +437,18 @@ SchemaArray.prototype._castForPopulate = function _castForPopulate(value, doc) {
     const rawValue = value.__array ? value.__array : value;
     const len = rawValue.length;
 
-    const caster = this.caster;
-    if (caster && this.casterConstructor !== Mixed) {
+    if (this.embeddedSchemaType && this.embeddedSchemaType.constructor !== Mixed) {
       try {
         for (i = 0; i < len; i++) {
           const opts = {};
           // Perf: creating `arrayPath` is expensive for large arrays.
           // We only need `arrayPath` if this is a nested array, so
           // skip if possible.
-          if (caster.$isMongooseArray && caster._arrayParentPath != null) {
+          if (this.embeddedSchemaType.$isMongooseArray && this.embeddedSchemaType._arrayParentPath != null) {
             opts.arrayPathIndex = i;
           }
 
-          rawValue[i] = caster.cast(rawValue[i], doc, false, void 0, opts);
+          rawValue[i] = this.embeddedSchemaType.cast(rawValue[i], doc, false, void 0, opts);
         }
       } catch (e) {
         // rethrow
@@ -479,11 +471,10 @@ SchemaArray.prototype.$toObject = SchemaArray.prototype.toObject;
 SchemaArray.prototype.discriminator = function(...args) {
   let arr = this;
   while (arr.$isMongooseArray && !arr.$isMongooseDocumentArray) {
-    arr = arr.casterConstructor;
-    if (arr == null || typeof arr === 'function') {
-      throw new MongooseError('You can only add an embedded discriminator on ' +
-        'a document array, ' + this.path + ' is a plain array');
-    }
+    arr = arr.embeddedSchemaType;
+  }
+  if (!arr.$isMongooseDocumentArray) {
+    throw new MongooseError('You can only add an embedded discriminator on a document array, ' + this.path + ' is a plain array');
   }
   return arr.discriminator(...args);
 };
@@ -494,7 +485,7 @@ SchemaArray.prototype.discriminator = function(...args) {
 
 SchemaArray.prototype.clone = function() {
   const options = Object.assign({}, this.options);
-  const schematype = new this.constructor(this.path, this.caster, options, this.schemaOptions);
+  const schematype = new this.constructor(this.path, this.embeddedSchemaType, options, this.schemaOptions, this.parentSchema);
   schematype.validators = this.validators.slice();
   if (this.requiredValidator !== undefined) {
     schematype.requiredValidator = this.requiredValidator;
@@ -503,30 +494,21 @@ SchemaArray.prototype.clone = function() {
 };
 
 SchemaArray.prototype._castForQuery = function(val, context) {
-  let Constructor = this.casterConstructor;
-
-  if (val &&
-      Constructor.discriminators &&
-      Constructor.schema &&
-      Constructor.schema.options &&
-      Constructor.schema.options.discriminatorKey) {
-    if (typeof val[Constructor.schema.options.discriminatorKey] === 'string' &&
-        Constructor.discriminators[val[Constructor.schema.options.discriminatorKey]]) {
-      Constructor = Constructor.discriminators[val[Constructor.schema.options.discriminatorKey]];
+  let embeddedSchemaType = this.embeddedSchemaType;
+  const discriminatorKey = embeddedSchemaType?.schema?.options?.discriminatorKey;
+  const discriminators = embeddedSchemaType?.discriminators;
+
+  if (val && discriminators && typeof discriminatorKey === 'string') {
+    if (discriminators[val[discriminatorKey]]) {
+      embeddedSchemaType = discriminators[val[discriminatorKey]];
     } else {
-      const constructorByValue = getDiscriminatorByValue(Constructor.discriminators, val[Constructor.schema.options.discriminatorKey]);
+      const constructorByValue = getDiscriminatorByValue(discriminators, val[discriminatorKey]);
       if (constructorByValue) {
-        Constructor = constructorByValue;
+        embeddedSchemaType = constructorByValue;
       }
     }
   }
 
-  const proto = this.casterConstructor.prototype;
-  const protoCastForQuery = proto && proto.castForQuery;
-  const protoCast = proto && proto.cast;
-  const constructorCastForQuery = Constructor.castForQuery;
-  const caster = this.caster;
-
   if (Array.isArray(val)) {
     this.setters.reverse().forEach(setter => {
       val = setter.call(this, val, this);
@@ -535,30 +517,10 @@ SchemaArray.prototype._castForQuery = function(val, context) {
       if (utils.isObject(v) && v.$elemMatch) {
         return v;
       }
-      if (protoCastForQuery) {
-        v = protoCastForQuery.call(caster, null, v, context);
-        return v;
-      } else if (protoCast) {
-        v = protoCast.call(caster, v);
-        return v;
-      } else if (constructorCastForQuery) {
-        v = constructorCastForQuery.call(caster, null, v, context);
-        return v;
-      }
-      if (v != null) {
-        v = new Constructor(v);
-        return v;
-      }
-      return v;
+      return embeddedSchemaType.castForQuery(null, v, context);
     });
-  } else if (protoCastForQuery) {
-    val = protoCastForQuery.call(caster, null, val, context);
-  } else if (protoCast) {
-    val = protoCast.call(caster, val);
-  } else if (constructorCastForQuery) {
-    val = constructorCastForQuery.call(caster, null, val, context);
-  } else if (val != null) {
-    val = new Constructor(val);
+  } else {
+    val = embeddedSchemaType.castForQuery(null, val, context);
   }
 
   return val;
@@ -624,12 +586,12 @@ function cast$all(val, context) {
       return v;
     }
     if (v.$elemMatch != null) {
-      return { $elemMatch: cast(this.casterConstructor.schema, v.$elemMatch, null, this && this.$$context) };
+      return { $elemMatch: cast(this.embeddedSchemaType.schema, v.$elemMatch, null, this && this.$$context) };
     }
 
     const o = {};
     o[this.path] = v;
-    return cast(this.casterConstructor.schema, o, null, this && this.$$context)[this.path];
+    return cast(this.embeddedSchemaType.schema, o, null, this && this.$$context)[this.path];
   }, this);
 
   return this.castForQuery(null, val, context);
@@ -677,7 +639,7 @@ function createLogicalQueryOperatorHandler(op) {
 
     const ret = [];
     for (const obj of val) {
-      ret.push(cast(this.casterConstructor.schema ?? context.schema, obj, null, this && this.$$context));
+      ret.push(cast(this.embeddedSchemaType.schema ?? context.schema, obj, null, this && this.$$context));
     }
 
     return ret;

package/lib/schema/bigint.js

@@ -14,12 +14,14 @@ const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeD
  *
  * @param {String} path
  * @param {Object} options
+ * @param {Object} schemaOptions
+ * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
  */
 
-function SchemaBigInt(path, options) {
-  SchemaType.call(this, path, options, 'BigInt');
+function SchemaBigInt(path, options, _schemaOptions, parentSchema) {
+  SchemaType.call(this, path, options, 'BigInt', parentSchema);
 }
 
 /**

package/lib/schema/boolean.js

@@ -14,12 +14,14 @@ const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeD
  *
  * @param {String} path
  * @param {Object} options
+ * @param {Object} schemaOptions
+ * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
  */
 
-function SchemaBoolean(path, options) {
-  SchemaType.call(this, path, options, 'Boolean');
+function SchemaBoolean(path, options, _schemaOptions, parentSchema) {
+  SchemaType.call(this, path, options, 'Boolean', parentSchema);
 }
 
 /**

package/lib/schema/buffer.js

@@ -19,12 +19,14 @@ const CastError = SchemaType.CastError;
  *
  * @param {String} key
  * @param {Object} options
+ * @param {Object} schemaOptions
+ * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
  */
 
-function SchemaBuffer(key, options) {
-  SchemaType.call(this, key, options, 'Buffer');
+function SchemaBuffer(key, options, _schemaOptions, parentSchema) {
+  SchemaType.call(this, key, options, 'Buffer', parentSchema);
 }
 
 /**

package/lib/schema/date.js

@@ -19,12 +19,14 @@ const CastError = SchemaType.CastError;
  *
  * @param {String} key
  * @param {Object} options
+ * @param {Object} schemaOptions
+ * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
  */
 
-function SchemaDate(key, options) {
-  SchemaType.call(this, key, options, 'Date');
+function SchemaDate(key, options, _schemaOptions, parentSchema) {
+  SchemaType.call(this, key, options, 'Date', parentSchema);
 }
 
 /**

package/lib/schema/decimal128.js

@@ -15,12 +15,14 @@ const isBsonType = require('../helpers/isBsonType');
  *
  * @param {String} key
  * @param {Object} options
+ * @param {Object} schemaOptions
+ * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
  */
 
-function SchemaDecimal128(key, options) {
-  SchemaType.call(this, key, options, 'Decimal128');
+function SchemaDecimal128(key, options, _schemaOptions, parentSchema) {
+  SchemaType.call(this, key, options, 'Decimal128', parentSchema);
 }
 
 /**

package/lib/schema/documentArray.js

@@ -35,11 +35,12 @@ let Subdocument;
  * @param {Schema} schema
  * @param {Object} options
  * @param {Object} schemaOptions
+ * @param {Schema} parentSchema
  * @inherits SchemaArray
  * @api public
  */
 
-function SchemaDocumentArray(key, schema, options, schemaOptions) {
+function SchemaDocumentArray(key, schema, options, schemaOptions, parentSchema) {
   if (schema.options && schema.options.timeseries) {
     throw new InvalidSchemaOptionError(key, 'timeseries');
   }
@@ -56,18 +57,26 @@ function SchemaDocumentArray(key, schema, options, schemaOptions) {
     schema = handleIdOption(schema, options);
   }
 
-  const EmbeddedDocument = _createConstructor(schema, options);
-  EmbeddedDocument.prototype.$basePath = key;
+  const Constructor = _createConstructor(schema, options);
+  Constructor.prototype.$basePath = key;
+  Constructor.path = key;
 
-  SchemaArray.call(this, key, EmbeddedDocument, options);
+  const $parentSchemaType = this;
+  const embeddedSchemaType = new DocumentArrayElement(key + '.$', schema, {
+    ...(schemaOptions || {}),
+    $parentSchemaType,
+    Constructor
+  });
+
+  SchemaArray.call(this, key, embeddedSchemaType, options, null, parentSchema);
 
   this.schema = schema;
   // EmbeddedDocument schematype options
   this.schemaOptions = schemaOptions || {};
   this.$isMongooseDocumentArray = true;
-  this.Constructor = EmbeddedDocument;
+  this.Constructor = Constructor;
 
-  EmbeddedDocument.base = schema.base;
+  Constructor.base = schema.base;
 
   const fn = this.defaultValue;
 
@@ -81,15 +90,6 @@ function SchemaDocumentArray(key, schema, options, schemaOptions) {
       return arr;
     });
   }
-
-  const $parentSchemaType = this;
-  this.$embeddedSchemaType = new DocumentArrayElement(key + '.$', {
-    ...(schemaOptions || {}),
-    $parentSchemaType
-  });
-
-  this.$embeddedSchemaType.caster = this.Constructor;
-  this.$embeddedSchemaType.schema = this.schema;
 }
 
 /**
@@ -212,93 +212,62 @@ SchemaDocumentArray.prototype.discriminator = function(name, schema, options) {
     schema = schema.clone();
   }
 
-  schema = discriminator(this.casterConstructor, name, schema, tiedValue, null, null, options?.overwriteExisting);
+  schema = discriminator(this.Constructor, name, schema, tiedValue, null, null, options?.overwriteExisting);
 
-  const EmbeddedDocument = _createConstructor(schema, null, this.casterConstructor);
-  EmbeddedDocument.baseCasterConstructor = this.casterConstructor;
+  const EmbeddedDocument = _createConstructor(schema, null, this.Constructor);
+  EmbeddedDocument.baseCasterConstructor = this.Constructor;
 
-  try {
-    Object.defineProperty(EmbeddedDocument, 'name', {
-      value: name
-    });
-  } catch (error) {
-    // Ignore error, only happens on old versions of node
-  }
+  Object.defineProperty(EmbeddedDocument, 'name', {
+    value: name
+  });
 
-  this.casterConstructor.discriminators[name] = EmbeddedDocument;
+  this.Constructor.discriminators[name] = EmbeddedDocument;
 
-  return this.casterConstructor.discriminators[name];
+  return this.Constructor.discriminators[name];
 };
 
 /**
  * Performs local validations first, then validations on each embedded doc
  *
- * @api private
+ * @api public
  */
 
-SchemaDocumentArray.prototype.doValidate = function(array, fn, scope, options) {
+SchemaDocumentArray.prototype.doValidate = async function doValidate(array, scope, options) {
   // lazy load
   MongooseDocumentArray || (MongooseDocumentArray = require('../types/documentArray'));
 
-  const _this = this;
-  try {
-    SchemaType.prototype.doValidate.call(this, array, cb, scope);
-  } catch (err) {
-    return fn(err);
+  await SchemaType.prototype.doValidate.call(this, array, scope);
+  if (options?.updateValidator) {
+    return;
+  }
+  if (!utils.isMongooseDocumentArray(array)) {
+    array = new MongooseDocumentArray(array, this.path, scope);
   }
 
-  function cb(err) {
-    if (err) {
-      return fn(err);
-    }
-
-    let count = array && array.length;
-    let error;
-
-    if (!count) {
-      return fn();
-    }
-    if (options && options.updateValidator) {
-      return fn();
-    }
-    if (!utils.isMongooseDocumentArray(array)) {
-      array = new MongooseDocumentArray(array, _this.path, scope);
-    }
-
+  const promises = [];
+  for (let i = 0; i < array.length; ++i) {
     // handle sparse arrays, do not use array.forEach which does not
     // iterate over sparse elements yet reports array.length including
     // them :(
-
-    function callback(err) {
-      if (err != null) {
-        error = err;
-      }
-      --count || fn(error);
+    let doc = array[i];
+    if (doc == null) {
+      continue;
+    }
+    // If you set the array index directly, the doc might not yet be
+    // a full fledged mongoose subdoc, so make it into one.
+    if (!(doc instanceof Subdocument)) {
+      const Constructor = getConstructor(this.Constructor, array[i]);
+      doc = array[i] = new Constructor(doc, array, undefined, undefined, i);
     }
 
-    for (let i = 0, len = count; i < len; ++i) {
-      // sidestep sparse entries
-      let doc = array[i];
-      if (doc == null) {
-        --count || fn(error);
-        continue;
-      }
-
-      // If you set the array index directly, the doc might not yet be
-      // a full fledged mongoose subdoc, so make it into one.
-      if (!(doc instanceof Subdocument)) {
-        const Constructor = getConstructor(_this.casterConstructor, array[i]);
-        doc = array[i] = new Constructor(doc, array, undefined, undefined, i);
-      }
-
-      if (options != null && options.validateModifiedOnly && !doc.$isModified()) {
-        --count || fn(error);
-        continue;
-      }
-
-      doc.$__validate(null, options, callback);
+    if (options != null && options.validateModifiedOnly && !doc.$isModified()) {
+      continue;
     }
+
+    promises.push(doc.$__validate(null, options));
   }
+
+  await Promise.all(promises);
 };
 
 /**
@@ -339,7 +308,7 @@ SchemaDocumentArray.prototype.doValidateSync = function(array, scope, options) {
     // If you set the array index directly, the doc might not yet be
     // a full fledged mongoose subdoc, so make it into one.
     if (!(doc instanceof Subdocument)) {
-      const Constructor = getConstructor(this.casterConstructor, array[i]);
+      const Constructor = getConstructor(this.Constructor, array[i]);
       doc = array[i] = new Constructor(doc, array, undefined, undefined, i);
     }
 
@@ -384,7 +353,7 @@ SchemaDocumentArray.prototype.getDefault = function(scope, init, options) {
   ret = new MongooseDocumentArray(ret, this.path, scope);
 
   for (let i = 0; i < ret.length; ++i) {
-    const Constructor = getConstructor(this.casterConstructor, ret[i]);
+    const Constructor = getConstructor(this.Constructor, ret[i]);
     const _subdoc = new Constructor({}, ret, undefined,
       undefined, i);
     _subdoc.$init(ret[i]);
@@ -462,7 +431,7 @@ SchemaDocumentArray.prototype.cast = function(value, doc, init, prev, options) {
       continue;
     }
 
-    const Constructor = getConstructor(this.casterConstructor, rawArray[i]);
+    const Constructor = getConstructor(this.Constructor, rawArray[i]);
 
     const spreadDoc = handleSpreadDoc(rawArray[i], true);
     if (rawArray[i] !== spreadDoc) {
@@ -529,7 +498,13 @@ SchemaDocumentArray.prototype.cast = function(value, doc, init, prev, options) {
 
 SchemaDocumentArray.prototype.clone = function() {
   const options = Object.assign({}, this.options);
-  const schematype = new this.constructor(this.path, this.schema, options, this.schemaOptions);
+  const schematype = new this.constructor(
+    this.path,
+    this.schema,
+    options,
+    this.schemaOptions,
+    this.parentSchema
+  );
   schematype.validators = this.validators.slice();
   if (this.requiredValidator !== undefined) {
     schematype.requiredValidator = this.requiredValidator;
@@ -647,21 +622,21 @@ function cast$elemMatch(val, context) {
   // Is this an embedded discriminator and is the discriminator key set?
   // If so, use the discriminator schema. See gh-7449
   const discriminatorKey = this &&
-    this.casterConstructor &&
-    this.casterConstructor.schema &&
-    this.casterConstructor.schema.options &&
-    this.casterConstructor.schema.options.discriminatorKey;
+    this.Constructor &&
+    this.Constructor.schema &&
+    this.Constructor.schema.options &&
+    this.Constructor.schema.options.discriminatorKey;
   const discriminators = this &&
-  this.casterConstructor &&
-  this.casterConstructor.schema &&
-  this.casterConstructor.schema.discriminators || {};
+  this.Constructor &&
+  this.Constructor.schema &&
+  this.Constructor.schema.discriminators || {};
   if (discriminatorKey != null &&
       val[discriminatorKey] != null &&
       discriminators[val[discriminatorKey]] != null) {
     return cast(discriminators[val[discriminatorKey]], val, null, this && this.$$context);
   }
 
-  const schema = this.casterConstructor.schema ?? context.schema;
+  const schema = this.Constructor.schema ?? context.schema;
   return cast(schema, val, null, this && this.$$context);
 }