mongoose 8.2.1 → 8.2.2

package/lib/document.js

@@ -742,7 +742,7 @@ function init(self, obj, doc, opts, prefix) {
     if (i === '__proto__' || i === 'constructor') {
       return;
     }
-    path = prefix + i;
+    path = prefix ? prefix + i : i;
     schemaType = docSchema.path(path);
     // Should still work if not a model-level discriminator, but should not be
     // necessary. This is *only* to catch the case where we queried using the
@@ -751,7 +751,8 @@ function init(self, obj, doc, opts, prefix) {
       return;
     }
 
-    if (!schemaType && utils.isPOJO(obj[i])) {
+    const value = obj[i];
+    if (!schemaType && utils.isPOJO(value)) {
       // assume nested object
       if (!doc[i]) {
         doc[i] = {};
@@ -759,29 +760,30 @@ function init(self, obj, doc, opts, prefix) {
           self[i] = doc[i];
         }
       }
-      init(self, obj[i], doc[i], opts, path + '.');
+      init(self, value, doc[i], opts, path + '.');
     } else if (!schemaType) {
-      doc[i] = obj[i];
+      doc[i] = value;
       if (!strict && !prefix) {
-        self[i] = obj[i];
+        self[i] = value;
       }
     } else {
       // Retain order when overwriting defaults
-      if (doc.hasOwnProperty(i) && obj[i] !== void 0 && !opts.hydratedPopulatedDocs) {
+      if (doc.hasOwnProperty(i) && value !== void 0 && !opts.hydratedPopulatedDocs) {
         delete doc[i];
       }
-      if (obj[i] === null) {
+      if (value === null) {
         doc[i] = schemaType._castNullish(null);
-      } else if (obj[i] !== undefined) {
-        const wasPopulated = obj[i].$__ == null ? null : obj[i].$__.wasPopulated;
-        if ((schemaType && !wasPopulated) && !opts.hydratedPopulatedDocs) {
+      } else if (value !== undefined) {
+        const wasPopulated = value.$__ == null ? null : value.$__.wasPopulated;
+
+        if (schemaType && !wasPopulated && !opts.hydratedPopulatedDocs) {
           try {
             if (opts && opts.setters) {
               // Call applySetters with `init = false` because otherwise setters are a noop
               const overrideInit = false;
-              doc[i] = schemaType.applySetters(obj[i], self, overrideInit);
+              doc[i] = schemaType.applySetters(value, self, overrideInit);
             } else {
-              doc[i] = schemaType.cast(obj[i], self, true);
+              doc[i] = schemaType.cast(value, self, true);
             }
           } catch (e) {
             self.invalidate(e.path, new ValidatorError({
@@ -793,7 +795,7 @@ function init(self, obj, doc, opts, prefix) {
             }));
           }
         } else {
-          doc[i] = obj[i];
+          doc[i] = value;
         }
       }
       // mark as hydrated
@@ -1388,6 +1390,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
     if (schema.options &&
         Array.isArray(schema.options[typeKey]) &&
         schema.options[typeKey].length &&
+        schema.options[typeKey][0] &&
         schema.options[typeKey][0].ref &&
         _isManuallyPopulatedArray(val, schema.options[typeKey][0].ref)) {
       popOpts = { [populateModelSymbol]: val[0].constructor };

package/lib/drivers/node-mongodb-native/collection.js

@@ -136,11 +136,10 @@ function iter(i) {
       let promise = null;
       let timeout = null;
       if (syncCollectionMethods[i] && typeof lastArg === 'function') {
-        this.addQueue(() => {
-          lastArg.call(this, null, this[i].apply(this, _args.slice(0, _args.length - 1)));
-        }, []);
+        this.addQueue(i, _args);
+        callback = lastArg;
       } else if (syncCollectionMethods[i]) {
-        promise = new Promise((resolve, reject) => {
+        promise = new this.Promise((resolve, reject) => {
           callback = function collectionOperationCallback(err, res) {
             if (timeout != null) {
               clearTimeout(timeout);

package/lib/model.js

@@ -351,12 +351,22 @@ Model.prototype.$__handleSave = function(options, callback) {
 
     const update = delta[1];
     if (this.$__schema.options.minimize) {
-      minimize(update);
-      // minimize might leave us with an empty object, which would
-      // lead to MongoDB throwing a "Update document requires atomic operators" error
-      if (Object.keys(update).length === 0) {
-        handleEmptyUpdate.call(this);
-        return;
+      for (const updateOp of Object.values(update)) {
+        if (updateOp == null) {
+          continue;
+        }
+        for (const key of Object.keys(updateOp)) {
+          if (updateOp[key] == null || typeof updateOp[key] !== 'object') {
+            continue;
+          }
+          if (!utils.isPOJO(updateOp[key])) {
+            continue;
+          }
+          minimize(updateOp[key]);
+          if (Object.keys(updateOp[key]).length === 0) {
+            updateOp[key] = null;
+          }
+        }
       }
     }
 
@@ -3075,7 +3085,7 @@ Model.startSession = function() {
  * @param {Object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#insertMany)
  * @param {Boolean} [options.ordered=true] if true, will fail fast on the first error encountered. If false, will insert all the documents it can and report errors later. An `insertMany()` with `ordered = false` is called an "unordered" `insertMany()`.
  * @param {Boolean} [options.rawResult=false] if false, the returned promise resolves to the documents that passed mongoose document validation. If `true`, will return the [raw result from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/InsertManyResult.html) with a `mongoose` property that contains `validationErrors` and `results` if this is an unordered `insertMany`.
- * @param {Boolean} [options.lean=false] if `true`, skips hydrating and validating the documents. This option is useful if you need the extra performance, but Mongoose won't validate the documents before inserting.
+ * @param {Boolean} [options.lean=false] if `true`, skips hydrating the documents. This means Mongoose will **not** cast or validate any of the documents passed to `insertMany()`. This option is useful if you need the extra performance, but comes with data integrity risk. Consider using with [`castObject()`](https://mongoosejs.com/docs/api/model.html#Model.castObject()).
  * @param {Number} [options.limit=null] this limits the number of documents being processed (validation/casting) by mongoose in parallel, this does **NOT** send the documents in batches to MongoDB. Use this option if you're processing a large number of documents and your app is running out of memory.
  * @param {String|Object|Array} [options.populate=null] populates the result documents. This option is a no-op if `rawResult` is set.
  * @param {Boolean} [options.throwOnValidationError=false] If true and `ordered: false`, throw an error if one of the operations failed validation, but all valid operations completed successfully.
@@ -3136,6 +3146,13 @@ Model.$__insertMany = function(arr, options, callback) {
   const results = ordered ? null : new Array(arr.length);
   const toExecute = arr.map((doc, index) =>
     callback => {
+      // If option `lean` is set to true bypass validation and hydration
+      if (lean) {
+        // we have to execute callback at the nextTick to be compatible
+        // with parallelLimit, as `results` variable has TDZ issue if we
+        // execute the callback synchronously
+        return immediate(() => callback(null, doc));
+      }
       if (!(doc instanceof _this)) {
         if (doc != null && typeof doc !== 'object') {
           return callback(new ObjectParameterError(doc, 'arr.' + index, 'insertMany'));
@@ -3216,7 +3233,7 @@ Model.$__insertMany = function(arr, options, callback) {
       callback(null, []);
       return;
     }
-    const docObjects = docAttributes.map(function(doc) {
+    const docObjects = lean ? docAttributes : docAttributes.map(function(doc) {
       if (doc.$__schema.options.versionKey) {
         doc[doc.$__schema.options.versionKey] = 0;
       }
@@ -3229,9 +3246,11 @@ Model.$__insertMany = function(arr, options, callback) {
 
     _this.$__collection.insertMany(docObjects, options).then(
       res => {
-        for (const attribute of docAttributes) {
-          attribute.$__reset();
-          _setIsNew(attribute, false);
+        if (!lean) {
+          for (const attribute of docAttributes) {
+            attribute.$__reset();
+            _setIsNew(attribute, false);
+          }
         }
 
         if (ordered === false && throwOnValidationError && validationErrors.length > 0) {
@@ -3333,6 +3352,9 @@ Model.$__insertMany = function(arr, options, callback) {
             return !isErrored;
           }).
           map(function setIsNewForInsertedDoc(doc) {
+            if (lean) {
+              return doc;
+            }
             doc.$__reset();
             _setIsNew(doc, false);
             return doc;
@@ -3375,6 +3397,7 @@ function _setIsNew(doc, val) {
  * trip to MongoDB.
  *
  * Mongoose will perform casting on all operations you provide.
+ * The only exception is [setting the `update` operator for `updateOne` or `updateMany` to a pipeline](https://www.mongodb.com/docs/manual/reference/method/db.collection.bulkWrite/#updateone-and-updatemany): Mongoose does **not** cast update pipelines.
  *
  * This function does **not** trigger any middleware, neither `save()`, nor `update()`.
  * If you need to trigger
@@ -3410,6 +3433,15 @@ function _setIsNew(doc, val) {
  *      console.log(res.insertedCount, res.modifiedCount, res.deletedCount);
  *     });
  *
+ *     // Mongoose does **not** cast update pipelines, so no casting for the `update` option below.
+ *     // Mongoose does still cast `filter`
+ *     await Character.bulkWrite([{
+ *       updateOne: {
+ *         filter: { name: 'Annika Hansen' },
+ *         update: [{ $set: { name: 7 } }] // Array means update pipeline, so Mongoose skips casting
+ *       }
+ *     }]);
+ *
  * The [supported operations](https://www.mongodb.com/docs/manual/reference/method/db.collection.bulkWrite/#db.collection.bulkWrite) are:
  *
  * - `insertOne`
@@ -3939,7 +3971,7 @@ Model.hydrate = function(obj, projection, options) {
  * - `updateMany()`
  *
  * @param {Object} filter
- * @param {Object|Array} update
+ * @param {Object|Array} update. If array, this update will be treated as an update pipeline and not casted.
  * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
  * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
  * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
@@ -3979,7 +4011,7 @@ Model.updateMany = function updateMany(conditions, doc, options) {
  * - `updateOne()`
  *
  * @param {Object} filter
- * @param {Object|Array} update
+ * @param {Object|Array} update. If array, this update will be treated as an update pipeline and not casted.
  * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
  * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
  * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document

package/lib/mongoose.js

@@ -506,12 +506,14 @@ Mongoose.prototype.pluralize = function(fn) {
  *
  *     // or
  *
- *     const collectionName = 'actor'
- *     const M = mongoose.model('Actor', schema, collectionName)
+ *     const collectionName = 'actor';
+ *     const M = mongoose.model('Actor', schema, collectionName);
  *
  * @param {String|Function} name model name or class extending Model
  * @param {Schema} [schema] the schema to use.
  * @param {String} [collection] name (optional, inferred from model name)
+ * @param {Object} [options]
+ * @param {Boolean} [options.overwriteModels=false] If true, overwrite existing models with the same name to avoid `OverwriteModelError`
  * @return {Model} The model associated with `name`. Mongoose will create the model if it doesn't already exist.
  * @api public
  */

package/lib/query.js

@@ -3880,7 +3880,7 @@ Query.prototype._replaceOne = async function _replaceOne() {
  * - `updateMany()`
  *
  * @param {Object} [filter]
- * @param {Object|Array} [update] the update command
+ * @param {Object|Array} [update] the update command. If array, this update will be treated as an update pipeline and not casted.
  * @param {Object} [options]
  * @param {Boolean} [options.multipleCastError] by default, mongoose only returns the first error that occurred in casting the query. Turn on this option to aggregate all the cast errors.
  * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
@@ -3950,7 +3950,7 @@ Query.prototype.updateMany = function(conditions, doc, options, callback) {
  * - `updateOne()`
  *
  * @param {Object} [filter]
- * @param {Object|Array} [update] the update command
+ * @param {Object|Array} [update] the update command. If array, this update will be treated as an update pipeline and not casted.
  * @param {Object} [options]
  * @param {Boolean} [options.multipleCastError] by default, mongoose only returns the first error that occurred in casting the query. Turn on this option to aggregate all the cast errors.
  * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)

package/lib/schema.js

@@ -1014,6 +1014,9 @@ reserved.collection = 1;
 
 Schema.prototype.path = function(path, obj) {
   if (obj === undefined) {
+    if (this.paths[path] != null) {
+      return this.paths[path];
+    }
     // Convert to '.$' to check subpaths re: gh-6405
     const cleanPath = _pathToPositionalSyntax(path);
     let schematype = _getPath(this, path, cleanPath);

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

@@ -698,22 +698,21 @@ const methods = {
 
       if ((atomics.$push && atomics.$push.$each && atomics.$push.$each.length || 0) !== 0 &&
           atomics.$push.$position != atomic.$position) {
-        throw new MongooseError('Cannot call `Array#push()` multiple times ' +
-          'with different `$position`');
-      }
+        if (atomic.$position != null) {
+          [].splice.apply(arr, [atomic.$position, 0].concat(values));
+          ret = arr.length;
+        } else {
+          ret = [].push.apply(arr, values);
+        }
 
-      if (atomic.$position != null) {
+        this._registerAtomic('$set', this);
+      } else if (atomic.$position != null) {
         [].splice.apply(arr, [atomic.$position, 0].concat(values));
         ret = this.length;
       } else {
         ret = [].push.apply(arr, values);
       }
     } else {
-      if ((atomics.$push && atomics.$push.$each && atomics.$push.$each.length || 0) !== 0 &&
-          atomics.$push.$position != null) {
-        throw new MongooseError('Cannot call `Array#push()` multiple times ' +
-          'with different `$position`');
-      }
       atomic = values;
       ret = _basePush.apply(arr, values);
     }

package/lib/types/arraySubdocument.js

@@ -145,7 +145,7 @@ ArraySubdocument.prototype.$__fullPath = function(path, skipIndex) {
  */
 
 ArraySubdocument.prototype.$__pathRelativeToParent = function(path, skipIndex) {
-  if (this.__index == null) {
+  if (this.__index == null || (!this.__parentArray || !this.__parentArray.$path)) {
     return null;
   }
   if (skipIndex) {

package/package.json

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

package/types/inferschematype.d.ts

@@ -229,7 +229,7 @@ type ResolvePathType<PathValueType, Options extends SchemaTypeOptions<PathValueT
               ObtainDocumentPathType<Item, TypeKey>[] :
               // If the type key isn't callable, then this is an array of objects, in which case
               // we need to call ObtainDocumentType to correctly infer its type.
-              ObtainDocumentType<Item, any, { typeKey: TypeKey }>[] :
+              Types.DocumentArray<ObtainDocumentType<Item, any, { typeKey: TypeKey }>> :
             IsSchemaTypeFromBuiltinClass<Item> extends true ?
               ObtainDocumentPathType<Item, TypeKey>[] :
               IsItRecordAndNotAny<Item> extends true ?

package/types/models.d.ts

@@ -156,6 +156,85 @@ declare module 'mongoose' {
 
   const Model: Model<any>;
 
+  export type AnyBulkWriteOperation<TSchema = AnyObject> = {
+    insertOne: InsertOneModel<TSchema>;
+  } | {
+    replaceOne: ReplaceOneModel<TSchema>;
+  } | {
+    updateOne: UpdateOneModel<TSchema>;
+  } | {
+    updateMany: UpdateManyModel<TSchema>;
+  } | {
+    deleteOne: DeleteOneModel<TSchema>;
+  } | {
+    deleteMany: DeleteManyModel<TSchema>;
+  };
+
+  export interface InsertOneModel<TSchema> {
+    document: mongodb.OptionalId<TSchema>
+  }
+
+  export interface ReplaceOneModel<TSchema = AnyObject> {
+    /** The filter to limit the replaced document. */
+    filter: FilterQuery<TSchema>;
+    /** The document with which to replace the matched document. */
+    replacement: mongodb.WithoutId<TSchema>;
+    /** Specifies a collation. */
+    collation?: mongodb.CollationOptions;
+    /** The index to use. If specified, then the query system will only consider plans using the hinted index. */
+    hint?: mongodb.Hint;
+    /** When true, creates a new document if no document matches the query. */
+    upsert?: boolean;
+  }
+
+  export interface UpdateOneModel<TSchema = AnyObject> {
+    /** The filter to limit the updated documents. */
+    filter: FilterQuery<TSchema>;
+    /** A document or pipeline containing update operators. */
+    update: UpdateQuery<TSchema>;
+    /** A set of filters specifying to which array elements an update should apply. */
+    arrayFilters?: AnyObject[];
+    /** Specifies a collation. */
+    collation?: mongodb.CollationOptions;
+    /** The index to use. If specified, then the query system will only consider plans using the hinted index. */
+    hint?: mongodb.Hint;
+    /** When true, creates a new document if no document matches the query. */
+    upsert?: boolean;
+  }
+
+  export interface UpdateManyModel<TSchema = AnyObject> {
+    /** The filter to limit the updated documents. */
+    filter: FilterQuery<TSchema>;
+    /** A document or pipeline containing update operators. */
+    update: UpdateQuery<TSchema>;
+    /** A set of filters specifying to which array elements an update should apply. */
+    arrayFilters?: AnyObject[];
+    /** Specifies a collation. */
+    collation?: mongodb.CollationOptions;
+    /** The index to use. If specified, then the query system will only consider plans using the hinted index. */
+    hint?: mongodb.Hint;
+    /** When true, creates a new document if no document matches the query. */
+    upsert?: boolean;
+  }
+
+  export interface DeleteOneModel<TSchema = AnyObject> {
+    /** The filter to limit the deleted documents. */
+    filter: FilterQuery<TSchema>;
+    /** Specifies a collation. */
+    collation?: mongodb.CollationOptions;
+    /** The index to use. If specified, then the query system will only consider plans using the hinted index. */
+    hint?: mongodb.Hint;
+  }
+
+  export interface DeleteManyModel<TSchema = AnyObject> {
+    /** The filter to limit the deleted documents. */
+    filter: FilterQuery<TSchema>;
+    /** Specifies a collation. */
+    collation?: mongodb.CollationOptions;
+    /** The index to use. If specified, then the query system will only consider plans using the hinted index. */
+    hint?: mongodb.Hint;
+  }
+
   /**
    * Models are fancy constructors compiled from `Schema` definitions.
    * An instance of a model is called a document.
@@ -201,17 +280,11 @@ declare module 'mongoose' {
      * round trip to the MongoDB server.
      */
     bulkWrite<DocContents = TRawDocType>(
-      writes: Array<
-        mongodb.AnyBulkWriteOperation<
-          DocContents extends mongodb.Document ? DocContents : any
-        > & MongooseBulkWritePerWriteOptions>,
+      writes: Array<AnyBulkWriteOperation<DocContents extends Document ? any : (DocContents extends {} ? DocContents : any)>>,
       options: mongodb.BulkWriteOptions & MongooseBulkWriteOptions & { ordered: false }
     ): Promise<mongodb.BulkWriteResult & { mongoose?: { validationErrors: Error[] } }>;
     bulkWrite<DocContents = TRawDocType>(
-      writes: Array<
-        mongodb.AnyBulkWriteOperation<
-          DocContents extends mongodb.Document ? DocContents : any
-        > & MongooseBulkWritePerWriteOptions>,
+      writes: Array<AnyBulkWriteOperation<DocContents extends Document ? any : (DocContents extends {} ? DocContents : any)>>,
       options?: mongodb.BulkWriteOptions & MongooseBulkWriteOptions
     ): Promise<mongodb.BulkWriteResult>;
 

package/types/pipelinestage.d.ts

@@ -36,7 +36,8 @@ declare module 'mongoose' {
     | PipelineStage.SortByCount
     | PipelineStage.UnionWith
     | PipelineStage.Unset
-    | PipelineStage.Unwind;
+    | PipelineStage.Unwind
+    | PipelineStage.VectorSearch;
 
   export namespace PipelineStage {
     export interface AddFields {
@@ -308,5 +309,17 @@ declare module 'mongoose' {
       /** [`$unwind` reference](https://www.mongodb.com/docs/manual/reference/operator/aggregation/unwind/) */
       $unwind: string | { path: string; includeArrayIndex?: string; preserveNullAndEmptyArrays?: boolean }
     }
+    export interface VectorSearch {
+      /** [`$vectorSearch` reference](https://www.mongodb.com/docs/atlas/atlas-vector-search/vector-search-stage/) */
+      $vectorSearch: {
+        index: string,
+        path: string,
+        queryVector: number[],
+        numCandidates: number,
+        limit: number,
+        filter?: Expression,
+      }
+    }
+
   }
 }

package/types/query.d.ts

@@ -627,6 +627,12 @@ declare module 'mongoose' {
       QueryOp
     >;
 
+    /** Add pre middleware to this query instance. Doesn't affect other queries. */
+    pre(fn: Function): this;
+
+    /** Add post middleware to this query instance. Doesn't affect other queries. */
+    post(fn: Function): this;
+
     /** Get/set the current projection (AKA fields). Pass `null` to remove the current projection. */
     projection(fields?: ProjectionFields<DocType> | string): ProjectionFields<DocType>;
     projection(fields: null): null;