@nullix/zod-mongoose-studio 1.0.12 → 2.0.0

package/.output/server/node_modules/mongoose/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;
@@ -34,9 +33,9 @@ const setOptionsForDefaults = { _skipMarkModified: true };
  *     const schema = new Schema({ name: String });
  *     schema.path('name') instanceof SchemaType; // true
  *
- * @param {String} path
+ * @param {string} path
  * @param {SchemaTypeOptions} [options] See [SchemaTypeOptions docs](https://mongoosejs.com/docs/api/schematypeoptions.html)
- * @param {String} [instance]
+ * @param {string} [instance]
  * @param {Schema} [parentSchema]
  * @api public
  */
@@ -100,11 +99,11 @@ function SchemaType(path, options, instance, parentSchema) {
           const index = this._index;
           if (typeof index === 'object' && index != null) {
             if (index.unique) {
-              throw new Error('Path "' + this.path + '" may not have `index` ' +
+              throw new MongooseError('Path "' + this.path + '" may not have `index` ' +
                 'set to false and `unique` set to true');
             }
             if (index.sparse) {
-              throw new Error('Path "' + this.path + '" may not have `index` ' +
+              throw new MongooseError('Path "' + this.path + '" may not have `index` ' +
                 'set to false and `sparse` set to true');
             }
           }
@@ -171,7 +170,6 @@ SchemaType.prototype.path;
  *     const schematype = schema.path('name');
  *     console.log(schematype.toJSON());
  *
- * @function toJSON
  * @memberOf SchemaType
  * @instance
  * @api public
@@ -183,6 +181,40 @@ SchemaType.prototype.toJSON = function toJSON() {
   return res;
 };
 
+/**
+ * Helper for creating `{ type: 'object' }` vs `{ bsonType: 'object' }` vs nullable variants.
+ *
+ * @param {string} type
+ * @param {string} bsonType
+ * @param {object} [options]
+ * @param {boolean} [options.useBsonType=false]
+ * @param {boolean} [options._defaultRequired=false]
+ * @param {boolean} [options._overrideRequired]
+ * @returns {object}
+ * @api private
+ */
+
+SchemaType.prototype._createJSONSchemaTypeDefinition = function _createJSONSchemaTypeDefinition(type, bsonType, options) {
+  const useBsonType = options?.useBsonType;
+  const isRequired = options?._overrideRequired ??
+    (this.options.required == null ?
+      (options?._defaultRequired === true || this.path === '_id') :
+      this.options.required && typeof this.options.required !== 'function');
+  const allowNull = this.options.allowNull !== false;
+
+  if (useBsonType) {
+    if (isRequired || !allowNull) {
+      return { bsonType };
+    }
+    return { bsonType: [bsonType, 'null'] };
+  }
+
+  if (isRequired || !allowNull) {
+    return { type };
+  }
+  return { type: [type, 'null'] };
+};
+
 /**
  * The validators that Mongoose should run to validate properties at this SchemaType's path.
  *
@@ -217,9 +249,9 @@ SchemaType.prototype.validators;
 SchemaType.prototype.isRequired;
 
 /**
- * Split the current dottet path into segments
+ * Split the current dotted path into segments
  *
- * @return {String[]|undefined}
+ * @return {string[]|undefined}
  * @api private
  */
 
@@ -312,14 +344,14 @@ SchemaType.prototype.castFunction = function castFunction(caster, message) {
 /**
  * The function that Mongoose calls to cast arbitrary values to this SchemaType.
  *
- * @param {Object} value value to cast
+ * @param {object} value value to cast
  * @param {Document} doc document that triggers the casting
- * @param {Boolean} init
+ * @param {boolean} init
  * @api public
  */
 
 SchemaType.prototype.cast = function cast() {
-  throw new Error('Base SchemaType class does not implement a `cast()` function');
+  throw new MongooseError('Base SchemaType class does not implement a `cast()` function');
 };
 
 /**
@@ -330,8 +362,8 @@ SchemaType.prototype.cast = function cast() {
  *     // Make all strings be trimmed by default
  *     mongoose.SchemaTypes.String.set('trim', true);
  *
- * @param {String} option The name of the option you'd like to set (e.g. trim, lowercase, etc...)
- * @param {Any} value The value of the option you'd like to set.
+ * @param {string} option The name of the option you'd like to set (e.g. trim, lowercase, etc...)
+ * @param {any} value The value of the option you'd like to set.
  * @return {void}
  * @static
  * @memberOf SchemaType
@@ -382,10 +414,10 @@ SchemaType.get = function(getter) {
  * #### Example:
  *
  *     // values are cast:
- *     const schema = new Schema({ aNumber: { type: Number, default: 4.815162342 }})
+ *     const schema = new Schema({ num: { type: Number, default: 4.815162342 }})
  *     const M = db.model('M', schema)
  *     const m = new M;
- *     console.log(m.aNumber) // 4.815162342
+ *     console.log(m.num) // 4.815162342
  *
  *     // default unique objects for Mixed types:
  *     const schema = new Schema({ mixed: Schema.Types.Mixed });
@@ -406,7 +438,7 @@ SchemaType.get = function(getter) {
  *     console.log(m2.mixed); // { added: 1 }
  *
  * @param {Function|any} val The default value to set
- * @return {Any|undefined} Returns the set default value.
+ * @return {any|undefined} Returns the set default value.
  * @api public
  */
 
@@ -417,7 +449,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.');
     }
@@ -445,14 +477,7 @@ 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
+ * @param {object|boolean|string|number} options
  * @return {SchemaType} this
  * @api public
  */
@@ -489,8 +514,8 @@ SchemaType.prototype.index = function(options) {
  * Note that the above syntax does **not** work for `bulkWrite()` or `insertMany()`. `bulkWrite()` and `insertMany()`
  * will still throw MongoDB's default `E11000 duplicate key error` message.
  *
- * @param {Boolean} value
- * @param {String} [message]
+ * @param {boolean} value
+ * @param {string} [message]
  * @return {SchemaType} this
  * @api public
  */
@@ -500,7 +525,7 @@ SchemaType.prototype.unique = function unique(value, message) {
     if (!value) {
       return;
     }
-    throw new Error('Path "' + this.path + '" may not have `index` set to ' +
+    throw new MongooseError('Path "' + this.path + '" may not have `index` set to ' +
       'false and `unique` set to true');
   }
 
@@ -529,7 +554,7 @@ SchemaType.prototype.unique = function unique(value, message) {
  *      const s = new Schema({ name : { type: String, text : true } })
  *      s.path('name').index({ text : true });
  *
- * @param {Boolean} bool
+ * @param {boolean} bool
  * @return {SchemaType} this
  * @api public
  */
@@ -539,7 +564,7 @@ SchemaType.prototype.text = function(bool) {
     if (!bool) {
       return this;
     }
-    throw new Error('Path "' + this.path + '" may not have `index` set to ' +
+    throw new MongooseError('Path "' + this.path + '" may not have `index` set to ' +
       'false and `text` set to true');
   }
 
@@ -566,7 +591,7 @@ SchemaType.prototype.text = function(bool) {
  *     const s = new Schema({ name: { type: String, sparse: true } });
  *     s.path('name').index({ sparse: true });
  *
- * @param {Boolean} bool
+ * @param {boolean} bool
  * @return {SchemaType} this
  * @api public
  */
@@ -576,7 +601,7 @@ SchemaType.prototype.sparse = function(bool) {
     if (!bool) {
       return this;
     }
-    throw new Error('Path "' + this.path + '" may not have `index` set to ' +
+    throw new MongooseError('Path "' + this.path + '" may not have `index` set to ' +
       'false and `sparse` set to true');
   }
 
@@ -631,7 +656,7 @@ SchemaType.prototype.sparse = function(bool) {
  *     // the property is immutable.
  *     Model.updateOne({}, { name: 'test2' }, { strict: false });
  *
- * @param {Boolean} bool
+ * @param {boolean} bool
  * @return {SchemaType} this
  * @see isNew https://mongoosejs.com/docs/api/document.html#Document.prototype.isNew()
  * @api public
@@ -795,7 +820,7 @@ SchemaType.prototype.set = function(fn) {
  *     // defining within the schema
  *     const s = new Schema({ born: { type: Date, get: dob })
  *
- *     // or by retreiving its SchemaType
+ *     // or by retrieving its SchemaType
  *     const s = new Schema({ born: Date })
  *     s.path('born').get(dob)
  *
@@ -856,8 +881,8 @@ SchemaType.prototype.get = function(fn) {
  * Adds multiple validators for this document path.
  * Calls `validate()` for every element in validators.
  *
- * @param {Array<RegExp|Function|Object>} validators
- * @returns this
+ * @param {(RegExp|Function|object)[]} validators
+ * @returns {SchemaType}
  */
 
 SchemaType.prototype.validateAll = function(validators) {
@@ -945,7 +970,7 @@ SchemaType.prototype.validateAll = function(validators) {
  *       }
  *     });
  *
- * You might use asynchronous validators to retreive other documents from the database to validate against or to meet other I/O bound validation needs.
+ * You might use asynchronous validators to retrieve other documents from the database to validate against or to meet other I/O bound validation needs.
  *
  * Validation occurs `pre('save')` or whenever you manually execute [document#validate](https://mongoosejs.com/docs/api/document.html#Document.prototype.validate()).
  *
@@ -964,12 +989,12 @@ SchemaType.prototype.validateAll = function(validators) {
  *     // registering an error listener on the Model lets us handle errors more locally
  *     Product.on('error', handleError);
  *
- * @param {RegExp|Function|Object} obj validator function, or hash describing options
+ * @param {RegExp|Function|object} obj validator function, or hash describing options
  * @param {Function} [obj.validator] validator function. If the validator function returns `undefined` or a truthy value, validation succeeds. If it returns [falsy](https://masteringjs.io/tutorials/fundamentals/falsy) (except `undefined`) or throws an error, validation fails.
- * @param {String|Function} [obj.message] optional error message. If function, should return the error message as a string
- * @param {Boolean} [obj.propsParameter=false] If true, Mongoose will pass the validator properties object (with the `validator` function, `message`, etc.) as the 2nd arg to the validator function. This is disabled by default because many validators [rely on positional args](https://github.com/chriso/validator.js#validators), so turning this on may cause unpredictable behavior in external validators.
- * @param {String|Function} [errorMsg] optional error message. If function, should return the error message as a string
- * @param {String} [type] optional validator type
+ * @param {string|Function} [obj.message] optional error message. If function, should return the error message as a string
+ * @param {boolean} [obj.propsParameter=false] If true, Mongoose will pass the validator properties object (with the `validator` function, `message`, etc.) as the 2nd arg to the validator function. This is disabled by default because many validators [rely on positional args](https://github.com/chriso/validator.js#validators), so turning this on may cause unpredictable behavior in external validators.
+ * @param {string|Function} [errorMsg] optional error message. If function, should return the error message as a string
+ * @param {string} [type] optional validator type
  * @return {SchemaType} this
  * @api public
  */
@@ -1012,7 +1037,7 @@ SchemaType.prototype.validate = function(obj, message, type) {
         + arg
         + '. See https://mongoosejs.com/docs/api/schematype.html#SchemaType.prototype.validate()';
 
-      throw new Error(msg);
+      throw new MongooseError(msg);
     }
     this.validate(arg.validator, arg);
   }
@@ -1072,10 +1097,10 @@ SchemaType.prototype.validate = function(obj, message, type) {
  * the value is not null nor undefined). However, most built-in mongoose schema
  * types override the default `checkRequired` function:
  *
- * @param {Boolean|Function|Object} required enable/disable the validator, or function that returns required boolean, or options object
- * @param {Boolean|Function} [options.isRequired] enable/disable the validator, or function that returns required boolean
+ * @param {boolean|Function|object} required enable/disable the validator, or function that returns required boolean, or options object
+ * @param {boolean|Function} [options.isRequired] enable/disable the validator, or function that returns required boolean
  * @param {Function} [options.ErrorConstructor] custom error constructor. The constructor receives 1 parameter, an object containing the validator properties.
- * @param {String} [message] optional custom error message
+ * @param {string} [message] optional custom error message
  * @return {SchemaType} this
  * @see Customized Error Messages https://mongoosejs.com/docs/api/error.html#Error.messages
  * @see SchemaArray#checkRequired https://mongoosejs.com/docs/api/schemaarray.html#SchemaArray.prototype.checkRequired()
@@ -1118,9 +1143,15 @@ SchemaType.prototype.required = function(required, message) {
 
   const _this = this;
   this.isRequired = true;
+  this.originalRequiredValue = required;
+
+  if (typeof this.originalRequiredValue !== 'function' &&
+      (utils.hasUserDefinedProperty(this.options, 'allowNull') || this.allowNullValidator != null)) {
+    throw new MongooseError('Path "' + this.path + '" may not have `allowNull` specified when `required` is 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)) {
@@ -1142,8 +1173,6 @@ SchemaType.prototype.required = function(required, message) {
 
     return _this.checkRequired(v, this);
   };
-  this.originalRequiredValue = required;
-
   if (typeof required === 'string') {
     message = required;
     required = undefined;
@@ -1159,6 +1188,53 @@ SchemaType.prototype.required = function(required, message) {
   return this;
 };
 
+/**
+ * Adds a validator that disallows `null` for this path without making the path
+ * required. `undefined` values still pass validation.
+ *
+ * #### Example:
+ *
+ *     const schema = new Schema({
+ *       name: { type: String, allowNull: false }
+ *     });
+ *
+ *     new Model({ name: undefined }).validateSync(); // OK
+ *     new Model({ name: null }).validateSync(); // ValidationError
+ *
+ * @param {boolean} allowNull
+ * @return {SchemaType} this
+ * @api public
+ */
+
+SchemaType.prototype.allowNull = function(allowNull) {
+  if (arguments.length > 0 && this.isRequired && typeof this.originalRequiredValue !== 'function') {
+    throw new MongooseError('Path "' + this.path + '" may not have `allowNull` specified when `required` is true');
+  }
+
+  this.validators = this.validators.filter(function(v) {
+    return v.validator !== this.allowNullValidator;
+  }, this);
+
+  if (allowNull !== false) {
+    delete this.options.allowNull;
+    delete this.allowNullValidator;
+    return this;
+  }
+
+  this.options.allowNull = false;
+  this.allowNullValidator = function(v) {
+    return v !== null;
+  };
+
+  this.validators.push({
+    validator: this.allowNullValidator,
+    message: MongooseError.messages.general.allowNull,
+    type: 'allowNull'
+  });
+
+  return this;
+};
+
 /**
  * Set the model that this path refers to. This is the option that [populate](https://mongoosejs.com/docs/populate.html)
  * looks at to determine the foreign collection it should query.
@@ -1179,7 +1255,7 @@ SchemaType.prototype.required = function(required, message) {
  *       user: { type: mongoose.ObjectId, ref: User }
  *     });
  *
- * @param {String|Model|Function} ref either a model name, a [Model](https://mongoosejs.com/docs/models.html), or a function that returns a model name or model.
+ * @param {string|Model|Function} ref either a model name, a [Model](https://mongoosejs.com/docs/models.html), or a function that returns a model name or model.
  * @return {SchemaType} this
  * @api public
  */
@@ -1192,43 +1268,51 @@ SchemaType.prototype.ref = function(ref) {
 /**
  * Gets the default value
  *
- * @param {Object} scope the scope which callback are executed
- * @param {Boolean} init
- * @return {Any} The Stored default value.
+ * @param {object} parentDoc
+ * @param {boolean} init
+ * @param {object} options
+ * @param {object} [options.context]
+ * @param {boolean} [options.skipCast]
+ * @return {any} The Stored default value.
  * @api private
  */
 
-SchemaType.prototype.getDefault = function(scope, init, options) {
+SchemaType.prototype.getDefault = function getDefault(parentDoc, init, options) {
   let ret;
   if (this.defaultValue == null) {
     return this.defaultValue;
   }
   if (typeof this.defaultValue === 'function') {
+    // In setDefaultsOnInsert, we pass the Query as `context` option. This is used to
+    // avoid passing the query as the parent doc to `applySetters()` below, because
+    // applySetters assumes parentDoc is a document or null. Queries run setters
+    // separately anyway.
+    const context = options?.context ?? parentDoc;
     if (
       this.defaultValue === Date.now ||
       this.defaultValue === Array ||
       this.defaultValue.name.toLowerCase() === 'objectid'
     ) {
-      ret = this.defaultValue.call(scope);
+      ret = this.defaultValue.call(context);
     } else {
-      ret = this.defaultValue.call(scope, scope);
+      ret = this.defaultValue.call(context, context);
     }
   } else {
     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) {
-      return this._applySetters(ret, scope);
+    if (options?.skipCast) {
+      return this._applySetters(ret, parentDoc);
     }
 
-    const casted = this.applySetters(ret, scope, init, undefined, setOptionsForDefaults);
+    const casted = this.applySetters(ret, parentDoc, init, undefined, setOptionsForDefaults);
     if (casted && !Array.isArray(casted) && casted.$isSingleNested) {
-      casted.$__parent = scope;
+      casted.$__parent = parentDoc;
     }
     return casted;
   }
@@ -1238,11 +1322,11 @@ SchemaType.prototype.getDefault = function(scope, init, options) {
 /**
  * Applies setters without casting
  *
- * @param {Any} value
- * @param {Any} scope
- * @param {Boolean} init
- * @param {Any} priorVal
- * @param {Object} [options]
+ * @param {any} value
+ * @param {any} scope
+ * @param {boolean} init
+ * @param {any} priorVal
+ * @param {object} [options]
  * @instance
  * @api private
  */
@@ -1272,10 +1356,10 @@ SchemaType.prototype._castNullish = function _castNullish(v) {
 /**
  * Applies setters
  *
- * @param {Object} value
- * @param {Object} scope
- * @param {Boolean} init
- * @return {Any}
+ * @param {any} value
+ * @param {object} scope
+ * @param {boolean} init
+ * @return {any}
  * @api private
  */
 
@@ -1293,9 +1377,9 @@ SchemaType.prototype.applySetters = function(value, scope, init, priorVal, optio
 /**
  * Applies getters to a value
  *
- * @param {Object} value
- * @param {Object} scope
- * @return {Any}
+ * @param {object} value
+ * @param {object} scope
+ * @return {any}
  * @api private
  */
 
@@ -1327,7 +1411,7 @@ SchemaType.prototype.applyGetters = function(value, scope) {
  *     // .. unless overridden;
  *     T.find().select('-x').exec(callback);
  *
- * @param {Boolean} val
+ * @param {boolean} val
  * @return {SchemaType} this
  * @api public
  */
@@ -1340,63 +1424,53 @@ 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]
- * @return {Any} If no validators, returns the output from calling `fn`, otherwise no return
+ * @param {any} value
+ * @param {object} scope
+ * @param {object} [options]
+ * @param {string} [options.path]
+ * @return {any} If no validators, returns the output from calling `fn`, otherwise no return
  * @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;
 
     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') {
       validatorProperties.length = value.length;
-      if (validatorProperties.value.length > 30) {
-        validatorProperties.value = validatorProperties.value.slice(0, 30) + '...';
-      }
     }
 
-    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;
     }
 
@@ -1414,39 +1488,36 @@ 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 {
+    if (typeof ok?.then === 'function') {
+      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);
 };
 
 
@@ -1466,10 +1537,10 @@ function _validate(ok, validatorProperties) {
  *
  * This method ignores the asynchronous validators.
  *
- * @param {Any} value
- * @param {Object} scope
- * @param {Object} [options]
- * @param {Object} [options.path]
+ * @param {any} value
+ * @param {object} scope
+ * @param {object} [options]
+ * @param {string} [options.path]
  * @return {MongooseError|null}
  * @api private
  */
@@ -1503,14 +1574,11 @@ 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') {
       validatorProperties.length = value.length;
-      if (validatorProperties.value.length > 30) {
-        validatorProperties.value = validatorProperties.value.slice(0, 30) + '...';
-      }
     }
     let ok = false;
 
@@ -1542,7 +1610,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);
@@ -1558,18 +1626,18 @@ SchemaType.prototype.doValidateSync = function(value, scope, options) {
  * Determines if value is a valid Reference.
  *
  * @param {SchemaType} self
- * @param {Object} value
+ * @param {object} value
  * @param {Document} doc
- * @param {Boolean} init
- * @return {Boolean}
+ * @param {boolean} init
+ * @return {boolean}
  * @api private
  */
 
 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
@@ -1703,10 +1771,10 @@ SchemaType.prototype.$conditionalHandlers = {
 /**
  * Cast the given value with the given optional query operator.
  *
- * @param {String} [$conditional] query operator, like `$eq` or `$in`
- * @param {Any} val
+ * @param {string} [$conditional] query operator, like `$eq` or `$in`
+ * @param {any} val
  * @param {Query} context
- * @return {Any}
+ * @return {any}
  * @api private
  */
 
@@ -1715,7 +1783,7 @@ SchemaType.prototype.castForQuery = function($conditional, val, context) {
   if ($conditional != null) {
     handler = this.$conditionalHandlers[$conditional];
     if (!handler) {
-      throw new Error('Can\'t use ' + $conditional);
+      throw new MongooseError('Can\'t use ' + $conditional);
     }
     return handler.call(this, val, context);
   }
@@ -1759,8 +1827,8 @@ SchemaType.checkRequired = function(fn) {
 /**
  * Default check for if this path satisfies the `required` validator.
  *
- * @param {Any} val
- * @return {Boolean} `true` when the value is not `null`, `false` otherwise
+ * @param {any} val
+ * @return {boolean} `true` when the value is not `null`, `false` otherwise
  * @api private
  */
 
@@ -1780,6 +1848,7 @@ SchemaType.prototype.clone = function() {
   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.allowNullValidator !== undefined) schematype.allowNullValidator = this.allowNullValidator;
   if (this.defaultValue !== undefined) schematype.defaultValue = this.defaultValue;
   if (this.$immutable !== undefined && this.options.immutable === undefined) {
     schematype.$immutable = this.$immutable;
@@ -1811,7 +1880,7 @@ SchemaType.prototype.clone = function() {
  */
 
 SchemaType.prototype.getEmbeddedSchemaType = function getEmbeddedSchemaType() {
-  return this.$embeddedSchemaType;
+  return this.embeddedSchemaType;
 };
 
 /*!
@@ -1825,13 +1894,13 @@ SchemaType.prototype._duplicateKeyErrorMessage = null;
 /**
  * Returns this schema type's representation in a JSON schema.
  *
- * @param [options]
- * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
- * @returns {Object} JSON schema properties
+ * @param {object} [options]
+ * @param {boolean} [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {object} JSON schema properties
  */
 
 SchemaType.prototype.toJSONSchema = function toJSONSchema(_options) { // eslint-disable-line no-unused-vars
-  throw new Error(`Converting unsupported SchemaType to JSON Schema: ${this.instance} at path "${this.path}"`);
+  throw new MongooseError(`Converting unsupported SchemaType to JSON Schema: ${this.instance} at path "${this.path}"`);
 };
 
 /**