mongoose 7.4.0 → 7.4.1

package/lib/document.js

@@ -2521,21 +2521,17 @@ Document.prototype.isDirectSelected = function isDirectSelected(path) {
  *
  * #### Note:
  *
- * This method is called `pre` save and if a validation rule is violated, [save](https://mongoosejs.com/docs/api/model.html#Model.prototype.save()) is aborted and the error is returned to your `callback`.
+ * This method is called `pre` save and if a validation rule is violated, [save](https://mongoosejs.com/docs/api/model.html#Model.prototype.save()) is aborted and the error is thrown.
  *
  * #### Example:
  *
- *     doc.validate(function (err) {
- *       if (err) handleError(err);
- *       else // validation passed
- *     });
+ *     await doc.validate({ validateModifiedOnly: false, pathsToSkip: ['name', 'email']});
  *
  * @param {Array|String} [pathsToValidate] list of paths to validate. If set, Mongoose will validate only the modified paths that are in the given list.
  * @param {Object} [options] internal options
  * @param {Boolean} [options.validateModifiedOnly=false] if `true` mongoose validates only modified paths.
  * @param {Array|string} [options.pathsToSkip] list of paths to skip. If set, Mongoose will validate every modified path that is not in this list.
- * @param {Function} [callback] optional callback called after validation completes, passing an error if one occurred
- * @return {Promise} Returns a Promise if no `callback` is given.
+ * @return {Promise} Returns a Promise.
  * @api public
  */
 
@@ -3325,8 +3321,8 @@ Document.prototype.$__reset = function reset() {
   const resetArrays = new Set();
   for (const subdoc of subdocs) {
     const fullPathWithIndexes = subdoc.$__fullPathWithIndexes();
+    subdoc.$__reset();
     if (this.isModified(fullPathWithIndexes) || isParentInit(fullPathWithIndexes)) {
-      subdoc.$__reset();
       if (subdoc.$isDocumentArrayElement) {
         resetArrays.add(subdoc.parentArray());
       } else {

package/lib/helpers/schema/applyWriteConcern.js

@@ -3,6 +3,9 @@
 const get = require('../get');
 
 module.exports = function applyWriteConcern(schema, options) {
+  if (options.writeConcern != null) {
+    return;
+  }
   const writeConcern = get(schema, 'options.writeConcern', {});
   if (Object.keys(writeConcern).length != 0) {
     options.writeConcern = {};

package/lib/model.js

@@ -3045,8 +3045,10 @@ Model.startSession = function() {
  *
  * #### Example:
  *
- *     const arr = [{ name: 'Star Wars' }, { name: 'The Empire Strikes Back' }];
- *     Movies.insertMany(arr, function(error, docs) {});
+ *     await Movies.insertMany([
+ *       { name: 'Star Wars' },
+ *       { name: 'The Empire Strikes Back' }
+ *     ]);
  *
  * @param {Array|Object|*} doc(s)
  * @param {Object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#insertMany)

package/lib/query.js

@@ -1968,7 +1968,6 @@ Query.prototype._optionsForExec = function(model) {
   if (!model) {
     return options;
   }
-
   // Apply schema-level `writeConcern` option
   applyWriteConcern(model.schema, options);
 

package/lib/schema.js

@@ -748,10 +748,10 @@ Schema.prototype.add = function add(obj, prefix) {
           childSchemaOptions.strict = this._userProvidedOptions.strict;
         }
         if (this._userProvidedOptions.toObject != null) {
-          childSchemaOptions.toObject = this._userProvidedOptions.toObject;
+          childSchemaOptions.toObject = utils.omit(this._userProvidedOptions.toObject, ['transform']);
         }
         if (this._userProvidedOptions.toJSON != null) {
-          childSchemaOptions.toJSON = this._userProvidedOptions.toJSON;
+          childSchemaOptions.toJSON = utils.omit(this._userProvidedOptions.toJSON, ['transform']);
         }
 
         const _schema = new Schema(_typeDef, childSchemaOptions);
@@ -1346,10 +1346,10 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
           childSchemaOptions.strictQuery = options.strictQuery;
         }
         if (options.hasOwnProperty('toObject')) {
-          childSchemaOptions.toObject = options.toObject;
+          childSchemaOptions.toObject = utils.omit(options.toObject, ['transform']);
         }
         if (options.hasOwnProperty('toJSON')) {
-          childSchemaOptions.toJSON = options.toJSON;
+          childSchemaOptions.toJSON = utils.omit(options.toJSON, ['transform']);
         }
 
         if (this._userProvidedOptions.hasOwnProperty('_id')) {

package/lib/types/ArraySubdocument.js

@@ -33,7 +33,15 @@ function ArraySubdocument(obj, parentArr, skipId, fields, index) {
   this.$setIndex(index);
   this.$__parent = this[documentArrayParent];
 
-  Subdocument.call(this, obj, fields, this[documentArrayParent], skipId, { isNew: true });
+  let options;
+  if (typeof skipId === 'object' && skipId != null) {
+    options = { isNew: true, ...skipId };
+    skipId = undefined;
+  } else {
+    options = { isNew: true };
+  }
+
+  Subdocument.call(this, obj, fields, this[documentArrayParent], skipId, options);
 }
 
 /*!

package/lib/types/DocumentArray/methods/index.js

@@ -38,7 +38,7 @@ const methods = {
    * @memberOf MongooseDocumentArray
    */
 
-  _cast(value, index) {
+  _cast(value, index, options) {
     if (this[arraySchemaSymbol] == null) {
       return value;
     }
@@ -89,7 +89,7 @@ const methods = {
     if (Constructor.$isMongooseDocumentArray) {
       return Constructor.cast(value, this, undefined, undefined, index);
     }
-    const ret = new Constructor(value, this, undefined, undefined, index);
+    const ret = new Constructor(value, this, options, undefined, index);
     ret.isNew = true;
     return ret;
   },

package/lib/types/array/methods/index.js

@@ -595,7 +595,7 @@ const methods = {
    */
 
   pull() {
-    const values = [].map.call(arguments, this._cast, this);
+    const values = [].map.call(arguments, (v, i) => this._cast(v, i, { defaults: false }), this);
     const cur = this[arrayParentSymbol].get(this[arrayPathSymbol]);
     let i = cur.length;
     let mem;

package/lib/types/subdocument.js

@@ -16,6 +16,10 @@ module.exports = Subdocument;
  */
 
 function Subdocument(value, fields, parent, skipId, options) {
+  if (typeof skipId === 'object' && skipId != null && options == null) {
+    options = skipId;
+    skipId = undefined;
+  }
   if (parent != null) {
     // If setting a nested path, should copy isNew from parent re: gh-7048
     const parentOptions = { isNew: parent.isNew };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "7.4.0",
+  "version": "7.4.1",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",

package/types/index.d.ts

@@ -378,11 +378,22 @@ declare module 'mongoose' {
     pre<T = never>(method: MongooseQueryOrDocumentMiddleware | MongooseQueryOrDocumentMiddleware[] | RegExp, options: SchemaPreOptions & { document: false, query: false }, fn: PreMiddlewareFunction<T>): this;
     pre<T = never>(method: MongooseDistinctQueryMiddleware|MongooseDistinctQueryMiddleware[], options: SchemaPreOptions & { document: boolean, query: false }, fn: PreMiddlewareFunction<T>): this;
     pre<T = never>(method: MongooseDistinctDocumentMiddleware | MongooseDistinctDocumentMiddleware[] | RegExp, options: SchemaPreOptions & { document: false, query: boolean }, fn: PreMiddlewareFunction<T>): this;
+    // this = Union of Document and Query, could be called with any of them
+    pre<T = THydratedDocumentType | Query<any, any>>(
+      method: MongooseQueryAndDocumentMiddleware | MongooseQueryAndDocumentMiddleware[] | RegExp,
+      options: SchemaPreOptions & { document: true, query: true },
+      fn: PreMiddlewareFunction<T>
+    ): this;
     // this = Document
     pre<T = THydratedDocumentType>(method: 'save', fn: PreSaveMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType>(method: 'save', options: SchemaPreOptions, fn: PreSaveMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType>(method: MongooseDistinctDocumentMiddleware|MongooseDistinctDocumentMiddleware[], fn: PreMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType>(method: MongooseDistinctDocumentMiddleware|MongooseDistinctDocumentMiddleware[], options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
+    pre<T = THydratedDocumentType>(
+      method: MongooseQueryAndDocumentMiddleware | MongooseQueryAndDocumentMiddleware[] | RegExp,
+      options: SchemaPreOptions & { document: true },
+      fn: PreMiddlewareFunction<T>
+    ): this;
     pre<T = THydratedDocumentType>(method: MongooseQueryOrDocumentMiddleware | MongooseQueryOrDocumentMiddleware[] | RegExp, options: SchemaPreOptions & { document: true, query: false }, fn: PreMiddlewareFunction<T>): this;
     // this = Query
     pre<T = Query<any, any>>(method: MongooseDefaultQueryMiddleware|MongooseDefaultQueryMiddleware[], fn: PreMiddlewareFunction<T>): this;

package/types/inferschematype.d.ts

@@ -218,10 +218,11 @@ type ResolvePathType<PathValueType, Options extends SchemaTypeOptions<PathValueT
                                         PathValueType extends 'uuid' | 'UUID' | typeof Schema.Types.UUID ? Buffer :
                                           IfEquals<PathValueType, Schema.Types.UUID> extends true ? Buffer :
                                             PathValueType extends MapConstructor ? Map<string, ResolvePathType<Options['of']>> :
-                                              PathValueType extends ArrayConstructor ? any[] :
-                                                PathValueType extends typeof Schema.Types.Mixed ? any:
-                                                  IfEquals<PathValueType, ObjectConstructor> extends true ? any:
-                                                    IfEquals<PathValueType, {}> extends true ? any:
-                                                      PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
-                                                        PathValueType extends Record<string, any> ? ObtainDocumentType<PathValueType, any, { typeKey: TypeKey }> :
-                                                          unknown;
+                                              IfEquals<PathValueType, typeof Schema.Types.Map> extends true ? Map<string, ResolvePathType<Options['of']>> :
+                                                PathValueType extends ArrayConstructor ? any[] :
+                                                  PathValueType extends typeof Schema.Types.Mixed ? any:
+                                                    IfEquals<PathValueType, ObjectConstructor> extends true ? any:
+                                                      IfEquals<PathValueType, {}> extends true ? any:
+                                                        PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
+                                                          PathValueType extends Record<string, any> ? ObtainDocumentType<PathValueType, any, { typeKey: TypeKey }> :
+                                                            unknown;

package/types/query.d.ts

@@ -136,6 +136,10 @@ declare module 'mongoose' {
      * Another alias for the `new` option. `returnOriginal` is deprecated so this should be used.
      */
     returnDocument?: 'before' | 'after';
+    /**
+     * Set to true to enable `update validators`
+     * (https://mongoosejs.com/docs/validation.html#update-validators). Defaults to false.
+     */
     runValidators?: boolean;
     /* Set to `true` to automatically sanitize potentially unsafe user-generated query projections */
     sanitizeProjection?: boolean;