mongoose 8.19.4 → 9.0.0-rc0

package/lib/schema/documentArrayElement.js

@@ -10,24 +10,33 @@ const SchemaSubdocument = require('./subdocument');
 const getConstructor = require('../helpers/discriminator/getConstructor');
 
 /**
- * DocumentArrayElement SchemaType constructor.
+ * DocumentArrayElement SchemaType constructor. Mongoose calls this internally when you define a new document array in your schema.
+ *
+ * #### Example:
+ *     const schema = new Schema({ users: [{ name: String }] });
+ *     schema.path('users.$'); // SchemaDocumentArrayElement with schema `new Schema({ name: String })`
  *
  * @param {String} path
+ * @param {Schema} schema
+ * @param {Object} options
  * @param {Object} options
+ * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
  */
 
-function SchemaDocumentArrayElement(path, options) {
+function SchemaDocumentArrayElement(path, schema, options, parentSchema) {
   this.$parentSchemaType = options && options.$parentSchemaType;
   if (!this.$parentSchemaType) {
     throw new MongooseError('Cannot create DocumentArrayElement schematype without a parent');
   }
   delete options.$parentSchemaType;
 
-  SchemaType.call(this, path, options, 'DocumentArrayElement');
+  SchemaType.call(this, path, options, 'DocumentArrayElement', parentSchema);
 
   this.$isMongooseDocumentArrayElement = true;
+  this.Constructor = options && options.Constructor;
+  this.schema = schema;
 }
 
 /**
@@ -58,21 +67,19 @@ SchemaDocumentArrayElement.prototype.cast = function(...args) {
 };
 
 /**
- * Casts contents for queries.
+ * Async validation on this individual array element
  *
- * @param {String} $cond
- * @param {any} [val]
- * @api private
+ * @api public
  */
 
-SchemaDocumentArrayElement.prototype.doValidate = function(value, fn, scope, options) {
-  const Constructor = getConstructor(this.caster, value);
+SchemaDocumentArrayElement.prototype.doValidate = async function doValidate(value, scope, options) {
+  const Constructor = getConstructor(this.Constructor, value);
 
   if (value && !(value instanceof Constructor)) {
     value = new Constructor(value, scope, null, null, options && options.index != null ? options.index : null);
   }
 
-  return SchemaSubdocument.prototype.doValidate.call(this, value, fn, scope, options);
+  return SchemaSubdocument.prototype.doValidate.call(this, value, scope, options);
 };
 
 /**
@@ -87,7 +94,7 @@ SchemaDocumentArrayElement.prototype.clone = function() {
   const ret = SchemaType.prototype.clone.apply(this, arguments);
   delete this.options.$parentSchemaType;
 
-  ret.caster = this.caster;
+  ret.Constructor = this.Constructor;
   ret.schema = this.schema;
 
   return ret;

package/lib/schema/double.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 SchemaDouble(path, options) {
-  SchemaType.call(this, path, options, 'Double');
+function SchemaDouble(path, options, _schemaOptions, parentSchema) {
+  SchemaType.call(this, path, options, 'Double', parentSchema);
 }
 
 /**

package/lib/schema/int32.js

@@ -15,12 +15,14 @@ const handleBitwiseOperator = require('./operators/bitwise');
  *
  * @param {String} path
  * @param {Object} options
+ * @param {Object} schemaOptions
+ * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
  */
 
-function SchemaInt32(path, options) {
-  SchemaType.call(this, path, options, 'Int32');
+function SchemaInt32(path, options, _schemaOptions, parentSchema) {
+  SchemaType.call(this, path, options, 'Int32', parentSchema);
 }
 
 /**

package/lib/schema/map.js

@@ -8,21 +8,51 @@ const MongooseMap = require('../types/map');
 const SchemaMapOptions = require('../options/schemaMapOptions');
 const SchemaType = require('../schemaType');
 const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
-
-/*!
- * ignore
- */
+const MongooseError = require('../error/mongooseError');
+const Schema = require('../schema');
+const utils = require('../utils');
 
 class SchemaMap extends SchemaType {
-  constructor(key, options) {
-    super(key, options, 'Map');
+  /**
+   * Map SchemaType constructor.
+   *
+   * @param {String} path
+   * @param {Object} options
+   * @param {Object} schemaOptions
+   * @param {Schema} parentSchema
+   * @inherits SchemaType
+   * @api public
+   */
+
+  constructor(key, options, schemaOptions, parentSchema) {
+    super(key, options, 'Map', parentSchema);
     this.$isSchemaMap = true;
+    // Create the nested schema type for the map values
+    this._createNestedSchemaType(parentSchema, key, options, schemaOptions);
   }
 
+  /**
+   * Sets a default option for all Map instances.
+   *
+   * @param {String} option The option you'd like to set the value for
+   * @param {Any} value value for option
+   * @return {undefined}
+   * @function set
+   * @api public
+   */
+
   set(option, value) {
     return SchemaType.set(option, value);
   }
 
+  /**
+   * Casts to Map
+   *
+   * @param {Object} value
+   * @param {Object} model this value is optional
+   * @api private
+   */
+
   cast(val, doc, init, prev, options) {
     if (val instanceof MongooseMap) {
       return val;
@@ -65,6 +95,12 @@ class SchemaMap extends SchemaType {
     return new MongooseMap(val, path, doc, this.$__schemaType, options);
   }
 
+  /**
+   * Creates a copy of this map schema type.
+   *
+   * @api private
+   */
+
   clone() {
     const schematype = super.clone();
 
@@ -76,7 +112,10 @@ class SchemaMap extends SchemaType {
 
   /**
    * Returns the embedded schema type (i.e. the `.$*` path)
+   *
+   * @api public
    */
+
   getEmbeddedSchemaType() {
     return this.$__schemaType;
   }
@@ -100,6 +139,12 @@ class SchemaMap extends SchemaType {
     return result;
   }
 
+  /**
+   * Returns the auto encryption type for this schema type.
+   *
+   * @api public
+   */
+
   autoEncryptionType() {
     return 'object';
   }
@@ -111,10 +156,46 @@ class SchemaMap extends SchemaType {
  *
  * @api public
  */
+
 SchemaMap.schemaName = 'Map';
 
 SchemaMap.prototype.OptionsConstructor = SchemaMapOptions;
 
 SchemaMap.defaultOptions = {};
 
+/*!
+ * ignore
+ */
+
+SchemaMap.prototype._createNestedSchemaType = function _createNestedSchemaType(schema, 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;
+    }
+  }
+  this.$__schemaType = schema.interpretAsType(mapPath, _mapType, options);
+};
+
 module.exports = SchemaMap;

package/lib/schema/mixed.js

@@ -14,11 +14,13 @@ const utils = require('../utils');
  *
  * @param {String} path
  * @param {Object} options
+ * @param {Object} _schemaOptions
+ * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
  */
 
-function SchemaMixed(path, options) {
+function SchemaMixed(path, options, _schemaOptions, parentSchema) {
   if (options && options.default) {
     const def = options.default;
     if (Array.isArray(def) && def.length === 0) {
@@ -32,7 +34,7 @@ function SchemaMixed(path, options) {
     }
   }
 
-  SchemaType.call(this, path, options, 'Mixed');
+  SchemaType.call(this, path, options, 'Mixed', parentSchema);
 
   this[symbols.schemaMixedSymbol] = true;
 }

package/lib/schema/number.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 SchemaNumber(key, options) {
-  SchemaType.call(this, key, options, 'Number');
+function SchemaNumber(key, options, _schemaOptions, parentSchema) {
+  SchemaType.call(this, key, options, 'Number', parentSchema);
 }
 
 /**

package/lib/schema/objectId.js

@@ -21,11 +21,13 @@ let Document;
  *
  * @param {String} key
  * @param {Object} options
+ * @param {Object} schemaOptions
+ * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
  */
 
-function SchemaObjectId(key, options) {
+function SchemaObjectId(key, options, _schemaOptions, parentSchema) {
   const isKeyHexStr = typeof key === 'string' && key.length === 24 && /^[a-f0-9]+$/i.test(key);
   const suppressWarning = options && options.suppressWarning;
   if ((isKeyHexStr || typeof key === 'undefined') && !suppressWarning) {
@@ -34,7 +36,7 @@ function SchemaObjectId(key, options) {
       '`Mongoose.Schema.ObjectId`. Set the `suppressWarning` option if ' +
       'you\'re trying to create a hex char path in your schema.');
   }
-  SchemaType.call(this, key, options, 'ObjectId');
+  SchemaType.call(this, key, options, 'ObjectId', parentSchema);
 }
 
 /**

package/lib/schema/string.js

@@ -19,14 +19,16 @@ const CastError = SchemaType.CastError;
  *
  * @param {String} key
  * @param {Object} options
+ * @param {Object} schemaOptions
+ * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
  */
 
-function SchemaString(key, options) {
+function SchemaString(key, options, _schemaOptions, parentSchema) {
   this.enumValues = [];
   this.regExp = null;
-  SchemaType.call(this, key, options, 'String');
+  SchemaType.call(this, key, options, 'String', parentSchema);
 }
 
 /**
@@ -603,7 +605,7 @@ SchemaString.prototype.cast = function(value, doc, init, prev, options) {
 
   try {
     return castString(value);
-  } catch (error) {
+  } catch {
     throw new CastError('string', value, this.path, null, this);
   }
 };

package/lib/schema/subdocument.js

@@ -32,11 +32,12 @@ module.exports = SchemaSubdocument;
  * @param {Schema} schema
  * @param {String} path
  * @param {Object} options
+ * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
  */
 
-function SchemaSubdocument(schema, path, options) {
+function SchemaSubdocument(schema, path, options, parentSchema) {
   if (schema.options.timeseries) {
     throw new InvalidSchemaOptionError(path, 'timeseries');
   }
@@ -49,13 +50,13 @@ function SchemaSubdocument(schema, path, options) {
 
   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;
-  SchemaType.call(this, path, options, 'Embedded');
+  SchemaType.call(this, path, options, 'Embedded', parentSchema);
 }
 
 /*!
@@ -180,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;
 
@@ -201,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.
@@ -216,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;
@@ -246,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;
   }
@@ -274,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);
@@ -286,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();
+  }
 };
 
 /**
@@ -354,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];
 };
 
 /*!
@@ -415,13 +410,14 @@ SchemaSubdocument.prototype.clone = function() {
   const schematype = new this.constructor(
     this.schema,
     this.path,
-    { ...this.options, _skipApplyDiscriminators: true }
+    { ...this.options, _skipApplyDiscriminators: true },
+    this.parentSchema
   );
   schematype.validators = this.validators.slice();
   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/union.js

@@ -14,12 +14,20 @@ const firstValueSymbol = Symbol('firstValue');
  */
 
 class Union extends SchemaType {
-  constructor(key, options, schemaOptions = {}) {
-    super(key, options, 'Union');
+  /**
+   * Create a Union schema type.
+   *
+   * @param {String} key the path in the schema for this schema type
+   * @param {Object} options SchemaType-specific options (must have 'of' as array)
+   * @param {Object} schemaOptions additional options from the schema this schematype belongs to
+   * @param {Schema} parentSchema the schema this schematype belongs to
+   */
+  constructor(key, options, schemaOptions, parentSchema) {
+    super(key, options, 'Union', parentSchema);
     if (!options || !Array.isArray(options.of) || options.of.length === 0) {
       throw new Error('Union schema type requires an array of types');
     }
-    this.schemaTypes = options.of.map(obj => options.parentSchema.interpretAsType(key, obj, schemaOptions));
+    this.schemaTypes = options.of.map(obj => parentSchema.interpretAsType(key, obj, schemaOptions));
   }
 
   cast(val, doc, init, prev, options) {

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
@@ -37,27 +35,14 @@ function binaryToString(uuidBin) {
  *
  * @param {String} key
  * @param {Object} options
+ * @param {Object} _schemaOptions
+ * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
  */
 
-function SchemaUUID(key, options) {
-  SchemaType.call(this, key, options, 'UUID');
-  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;
-  });
+function SchemaUUID(key, options, _schemaOptions, parentSchema) {
+  SchemaType.call(this, key, options, 'UUID', parentSchema);
 }
 
 /**
@@ -249,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
 };