mongoose 8.19.4 → 8.20.0

package/lib/cast.js

@@ -210,7 +210,7 @@ module.exports = function cast(schema, obj, options, context) {
           }
 
           if (geo) {
-            const numbertype = new Types.Number('__QueryCasting__');
+            const numbertype = new Types.Number('__QueryCasting__', null, null, schema);
             let value = val[geo];
 
             if (val.$maxDistance != null) {

package/lib/error/divergentArray.js

@@ -23,8 +23,8 @@ class DivergentArrayError extends MongooseError {
             + 'the entire array is not supported. The following '
             + 'path(s) would have been modified unsafely:\n'
             + '  ' + paths.join('\n  ') + '\n'
-            + 'Use Model.updateOne() to update these arrays instead.';
-    // TODO write up a docs page (FAQ) and link to it
+            + 'Use Model.updateOne() to update these arrays instead. '
+            + 'See https://mongoosejs.com/docs/faq.html#divergent-array-error for more information.';
     super(msg);
   }
 }

package/lib/helpers/discriminator/mergeDiscriminatorSchema.js

@@ -3,6 +3,7 @@ const schemaMerge = require('../schema/merge');
 const specialProperties = require('../../helpers/specialProperties');
 const isBsonType = require('../../helpers/isBsonType');
 const ObjectId = require('../../types/objectid');
+const SchemaType = require('../../schemaType');
 const isObject = require('../../helpers/isObject');
 /**
  * Merges `from` into `to` without overwriting existing properties.
@@ -69,6 +70,15 @@ module.exports = function mergeDiscriminatorSchema(to, from, path, seen) {
         } else if (isBsonType(from[key], 'ObjectId')) {
           to[key] = new ObjectId(from[key]);
           continue;
+        } else if (from[key] instanceof SchemaType) {
+          if (to[key] == null) {
+            to[key] = from[key].clone();
+          }
+          // For container types with nested schemas, we need to continue to the
+          // recursive merge below to properly merge the nested schemas
+          if (!from[key].$isMongooseDocumentArray && !from[key].$isSingleNested) {
+            continue;
+          }
         }
       }
       mergeDiscriminatorSchema(to[key], from[key], path ? path + '.' + key : key, seen);

package/lib/helpers/query/castUpdate.js

@@ -428,7 +428,7 @@ function walkUpdatePath(schema, obj, op, options, context, filter, prefix) {
           if (obj[key] == null) {
             throw new CastError('String', obj[key], `${prefix}${key}.$rename`);
           }
-          const schematype = new SchemaString(`${prefix}${key}.$rename`);
+          const schematype = new SchemaString(`${prefix}${key}.$rename`, null, null, schema);
           obj[key] = schematype.castForQuery(null, obj[key], context);
           continue;
         }

package/lib/schema/array.js

@@ -38,11 +38,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);
 
@@ -92,7 +93,11 @@ function SchemaArray(key, cast, options, schemaOptions) {
         !caster.$isArraySubdocument &&
         !caster.$isSchemaMap) {
       const path = this.caster instanceof EmbeddedDoc ? null : key;
-      this.caster = new caster(path, castOptions);
+      if (caster === SchemaArray) {
+        this.caster = new caster(path, castOptions, schemaOptions, null, parentSchema);
+      } else {
+        this.caster = new caster(path, castOptions, schemaOptions, parentSchema);
+      }
     } else {
       this.caster = caster;
       if (!(this.caster instanceof EmbeddedDoc)) {
@@ -105,7 +110,7 @@ function SchemaArray(key, cast, options, schemaOptions) {
 
   this.$isMongooseArray = true;
 
-  SchemaType.call(this, key, options, 'Array');
+  SchemaType.call(this, key, options, 'Array', parentSchema);
 
   let defaultArr;
   let fn;
@@ -494,7 +499,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.caster, options, this.schemaOptions, this.parentSchema);
   schematype.validators = this.validators.slice();
   if (this.requiredValidator !== undefined) {
     schematype.requiredValidator = this.requiredValidator;

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');
   }
@@ -59,7 +60,7 @@ function SchemaDocumentArray(key, schema, options, schemaOptions) {
   const EmbeddedDocument = _createConstructor(schema, options);
   EmbeddedDocument.prototype.$basePath = key;
 
-  SchemaArray.call(this, key, EmbeddedDocument, options);
+  SchemaArray.call(this, key, EmbeddedDocument, options, null, parentSchema);
 
   this.schema = schema;
   // EmbeddedDocument schematype options
@@ -83,10 +84,15 @@ function SchemaDocumentArray(key, schema, options, schemaOptions) {
   }
 
   const $parentSchemaType = this;
-  this.$embeddedSchemaType = new DocumentArrayElement(key + '.$', {
-    ...(schemaOptions || {}),
-    $parentSchemaType
-  });
+  this.$embeddedSchemaType = new DocumentArrayElement(
+    key + '.$',
+    {
+      ...(schemaOptions || {}),
+      $parentSchemaType
+    },
+    schemaOptions,
+    parentSchema
+  );
 
   this.$embeddedSchemaType.caster = this.Constructor;
   this.$embeddedSchemaType.schema = this.schema;
@@ -529,7 +535,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;

package/lib/schema/documentArrayElement.js

@@ -14,18 +14,20 @@ const getConstructor = require('../helpers/discriminator/getConstructor');
  *
  * @param {String} path
  * @param {Object} options
+ * @param {Object} schemaOptions
+ * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
  */
 
-function SchemaDocumentArrayElement(path, options) {
+function SchemaDocumentArrayElement(path, options, _schemaOptions, 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;
 }

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);
 }
 
 /**

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');
   }
@@ -55,7 +56,7 @@ function SchemaSubdocument(schema, path, options) {
   this.schema = schema;
   this.$isSingleNested = true;
   this.base = schema.base;
-  SchemaType.call(this, path, options, 'Embedded');
+  SchemaType.call(this, path, options, 'Embedded', parentSchema);
 }
 
 /*!
@@ -415,7 +416,8 @@ 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) {

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

@@ -37,12 +37,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');
+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) {