mongoose 7.2.1 → 7.2.2

package/lib/connection.js

@@ -1128,9 +1128,10 @@ Connection.prototype.onClose = function(force) {
 };
 
 /**
- * Retrieves a collection, creating it if not cached.
- *
- * Not typically needed by applications. Just talk to your collection through your model.
+ * Retrieves a raw collection instance, creating it if not cached.
+ * This method returns a thin wrapper around a [MongoDB Node.js driver collection]([MongoDB Node.js driver collection](https://mongodb.github.io/node-mongodb-native/Next/classes/Collection.html)).
+ * Using a Collection bypasses Mongoose middleware, validation, and casting,
+ * letting you use [MongoDB Node.js driver](https://mongodb.github.io/node-mongodb-native/) functionality directly.
  *
  * @param {String} name of the collection
  * @param {Object} [options] optional collection options
@@ -1582,7 +1583,7 @@ Connection.prototype.syncIndexes = async function syncIndexes(options = {}) {
 };
 
 /**
- * Switches to a different database using the same connection pool.
+ * Switches to a different database using the same [connection pool](https://mongoosejs.com/docs/api/connectionshtml#connection_pools).
  *
  * Returns a new connection object, with the new db.
  *

package/lib/cursor/QueryCursor.js

@@ -42,7 +42,6 @@ function QueryCursor(query, options) {
   this.cursor = null;
   this.skipped = false;
   this.query = query;
-  const _this = this;
   const model = query.model;
   this._mongooseOptions = {};
   this._transforms = [];
@@ -59,16 +58,16 @@ function QueryCursor(query, options) {
             util.inspect(resultValue) +
             '".'
           );
-          _this._markError(err);
-          _this.listeners('error').length > 0 && _this.emit('error', err);
+          this._markError(err);
+          this.listeners('error').length > 0 && this.emit('error', err);
           return;
         }
         this.skipped = true;
-        _this.emit('cursor', null);
+        this.emit('cursor', null);
         return;
       }
-      _this._markError(err);
-      _this.listeners('error').length > 0 && _this.emit('error', err);
+      this._markError(err);
+      this.listeners('error').length > 0 && this.emit('error', err);
       return;
     }
     this._transforms = this._transforms.concat(query._transforms.slice());
@@ -87,17 +86,17 @@ function QueryCursor(query, options) {
     Object.assign(this.options, query._optionsForExec());
     model.collection.find(query._conditions, this.options, (err, cursor) => {
       if (err != null) {
-        _this._markError(err);
-        _this.listeners('error').length > 0 && _this.emit('error', _this._error);
+        this._markError(err);
+        this.listeners('error').length > 0 && this.emit('error', this._error);
         return;
       }
 
-      if (_this._error) {
+      if (this._error) {
         cursor.close(function() {});
-        _this.listeners('error').length > 0 && _this.emit('error', _this._error);
+        this.listeners('error').length > 0 && this.emit('error', this._error);
       }
-      _this.cursor = cursor;
-      _this.emit('cursor', cursor);
+      this.cursor = cursor;
+      this.emit('cursor', cursor);
     });
   });
 }
@@ -113,21 +112,20 @@ util.inherits(QueryCursor, Readable);
  */
 
 QueryCursor.prototype._read = function() {
-  const _this = this;
-  _next(this, function(error, doc) {
+  _next(this, (error, doc) => {
     if (error) {
-      return _this.emit('error', error);
+      return this.emit('error', error);
     }
     if (!doc) {
-      _this.push(null);
-      _this.cursor.close(function(error) {
+      this.push(null);
+      this.cursor.close(function(error) {
         if (error) {
-          return _this.emit('error', error);
+          return this.emit('error', error);
         }
       });
       return;
     }
-    _this.push(doc);
+    this.push(doc);
   });
 };
 
@@ -223,9 +221,8 @@ QueryCursor.prototype.close = async function close() {
  */
 
 QueryCursor.prototype.rewind = function() {
-  const _this = this;
-  _waitForCursor(this, function() {
-    _this.cursor.rewind();
+  _waitForCursor(this, () => {
+    this.cursor.rewind();
   });
   return this;
 };
@@ -281,14 +278,13 @@ QueryCursor.prototype.next = async function next() {
  */
 
 QueryCursor.prototype.eachAsync = function(fn, opts, callback) {
-  const _this = this;
   if (typeof opts === 'function') {
     callback = opts;
     opts = {};
   }
   opts = opts || {};
 
-  return eachAsync(function(cb) { return _next(_this, cb); }, fn, opts, callback);
+  return eachAsync((cb) => _next(this, cb), fn, opts, callback);
 };
 
 /**
@@ -312,9 +308,8 @@ QueryCursor.prototype.options;
  */
 
 QueryCursor.prototype.addCursorFlag = function(flag, value) {
-  const _this = this;
-  _waitForCursor(this, function() {
-    _this.cursor.addCursorFlag(flag, value);
+  _waitForCursor(this, () => {
+    this.cursor.addCursorFlag(flag, value);
   });
   return this;
 };
@@ -521,13 +516,12 @@ function _populateBatch() {
   if (!this.ctx._batchDocs.length) {
     return this.callback(null, null);
   }
-  const _this = this;
   this.ctx.query.model.populate(this.ctx._batchDocs, this.ctx._pop).then(
     () => {
-      _nextDoc(_this.ctx, _this.ctx._batchDocs.shift(), _this.ctx._pop, _this.callback);
+      _nextDoc(this.ctx, this.ctx._batchDocs.shift(), this.ctx._pop, this.callback);
     },
     err => {
-      _this.callback(err);
+      this.callback(err);
     }
   );
 }

package/lib/helpers/query/castUpdate.js

@@ -360,7 +360,7 @@ function walkUpdatePath(schema, obj, op, options, context, filter, pref) {
         try {
           if (prefix.length === 0 || key.indexOf('.') === -1) {
             obj[key] = castUpdateVal(schematype, val, op, key, context, prefix + key);
-          } else {
+          } else if (isStrict !== false || schematype != null) {
             // Setting a nested dotted path that's in the schema. We don't allow paths with '.' in
             // a schema, so replace the dotted path with a nested object to avoid ending up with
             // dotted properties in the updated object. See (gh-10200)

package/lib/helpers/schema/merge.js

@@ -9,7 +9,9 @@ module.exports = function merge(s1, s2, skipConflictingPaths) {
     }
     pathsToAdd[key] = s2.tree[key];
   }
-  s1.add(pathsToAdd);
+  s1.options._isMerging = true;
+  s1.add(pathsToAdd, null);
+  delete s1.options._isMerging;
 
   s1.callQueue = s1.callQueue.concat(s2.callQueue);
   s1.method(s2.methods);
@@ -17,8 +19,7 @@ module.exports = function merge(s1, s2, skipConflictingPaths) {
 
   for (const [option, value] of Object.entries(s2._userProvidedOptions)) {
     if (!(option in s1._userProvidedOptions)) {
-      s1._userProvidedOptions[option] = value;
-      s1.options[option] = value;
+      s1.set(option, value);
     }
   }
 

package/lib/model.js

@@ -145,7 +145,9 @@ Model.prototype.$isMongooseModelPrototype = true;
 Model.prototype.db;
 
 /**
- * Collection the model uses.
+ * The collection instance this model uses.
+ * A Mongoose collection is a thin wrapper around a [MongoDB Node.js driver collection]([MongoDB Node.js driver collection](https://mongodb.github.io/node-mongodb-native/Next/classes/Collection.html)).
+ * Using `Model.collection` means you bypass Mongoose middleware, validation, and casting.
  *
  * This property is read-only. Modifying this property is a no-op.
  *

package/lib/schema.js

@@ -1285,12 +1285,16 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
     // new Schema({ path: [new Schema({ ... })] })
     if (cast && cast.instanceOfSchema) {
       if (!(cast instanceof Schema)) {
-        throw new TypeError('Schema for array path `' + path +
-          '` is from a different copy of the Mongoose module. ' +
-          'Please make sure you\'re using the same version ' +
-          'of Mongoose everywhere with `npm list mongoose`. If you are still ' +
-          'getting this error, please add `new Schema()` around the path: ' +
-          `${path}: new Schema(...)`);
+        if (this.options._isMerging) {
+          cast = new Schema(cast);
+        } else {
+          throw new TypeError('Schema for array path `' + path +
+            '` is from a different copy of the Mongoose module. ' +
+            'Please make sure you\'re using the same version ' +
+            'of Mongoose everywhere with `npm list mongoose`. If you are still ' +
+            'getting this error, please add `new Schema()` around the path: ' +
+            `${path}: new Schema(...)`);
+        }
       }
       return new MongooseTypes.DocumentArray(path, cast, obj);
     }
@@ -1298,12 +1302,16 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
         cast[options.typeKey] &&
         cast[options.typeKey].instanceOfSchema) {
       if (!(cast[options.typeKey] instanceof Schema)) {
-        throw new TypeError('Schema for array path `' + path +
-          '` is from a different copy of the Mongoose module. ' +
-          'Please make sure you\'re using the same version ' +
-          'of Mongoose everywhere with `npm list mongoose`. If you are still ' +
-          'getting this error, please add `new Schema()` around the path: ' +
-          `${path}: new Schema(...)`);
+        if (this.options._isMerging) {
+          cast[options.typeKey] = new Schema(cast[options.typeKey]);
+        } else {
+          throw new TypeError('Schema for array path `' + path +
+            '` is from a different copy of the Mongoose module. ' +
+            'Please make sure you\'re using the same version ' +
+            'of Mongoose everywhere with `npm list mongoose`. If you are still ' +
+            'getting this error, please add `new Schema()` around the path: ' +
+            `${path}: new Schema(...)`);
+        }
       }
       return new MongooseTypes.DocumentArray(path, cast[options.typeKey], obj, cast);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "7.2.1",
+  "version": "7.2.2",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -64,7 +64,7 @@
     "q": "1.5.1",
     "sinon": "15.0.4",
     "stream-browserify": "3.0.0",
-    "tsd": "0.25.0",
+    "tsd": "0.28.1",
     "typescript": "5.0.4",
     "uuid": "9.0.0",
     "webpack": "5.81.0",

package/types/index.d.ts

@@ -161,7 +161,7 @@ declare module 'mongoose' {
     [k: string]: string;
   }
 
-  export interface ToObjectOptions {
+  export interface ToObjectOptions<THydratedDocumentType = HydratedDocument<unknown>> {
     /** apply all getters (path and virtual getters) */
     getters?: boolean;
     /** apply virtual getters (can override getters option) */
@@ -171,7 +171,11 @@ declare module 'mongoose' {
     /** remove empty objects (defaults to true) */
     minimize?: boolean;
     /** if set, mongoose will call this function to allow you to transform the returned object */
-    transform?: boolean | ((doc: any, ret: any, options: any) => any);
+    transform?: boolean | ((
+      doc: THydratedDocumentType,
+      ret: Record<string, any>,
+      options: ToObjectOptions<THydratedDocumentType>
+    ) => any);
     /** if true, replace any conventionally populated paths with the original id in the output. Has no affect on virtual populated paths. */
     depopulate?: boolean;
     /** if false, exclude the version key (`__v` by default) from the output */

package/types/schemaoptions.d.ts

@@ -133,14 +133,14 @@ declare module 'mongoose' {
      */
     strictQuery?: boolean | 'throw';
     /** Exactly the same as the toObject option but only applies when the document's toJSON method is called. */
-    toJSON?: ToObjectOptions;
+    toJSON?: ToObjectOptions<THydratedDocumentType>;
     /**
      * Documents have a toObject method which converts the mongoose document into a plain JavaScript object.
      * This method accepts a few options. Instead of applying these options on a per-document basis, we may
      * declare the options at the schema level and have them applied to all of the schema's documents by
      * default.
      */
-    toObject?: ToObjectOptions;
+    toObject?: ToObjectOptions<THydratedDocumentType>;
     /**
      * By default, if you have an object with key 'type' in your schema, mongoose will interpret it as a
      * type declaration. However, for applications like geoJSON, the 'type' property is important. If you want to

package/types/types.d.ts

@@ -42,8 +42,8 @@ declare module 'mongoose' {
       shift(): T;
 
       /** Returns a native js Array. */
-      toObject(options?: ToObjectOptions): any;
-      toObject<T>(options?: ToObjectOptions): T;
+      toObject(options?: ToObjectOptions<T>): any;
+      toObject<T>(options?: ToObjectOptions<T>): T;
 
       /** Wraps [`Array#unshift`](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/unshift) with proper change tracking. */
       unshift(...args: any[]): number;