Merge branch 'master' into 8.1

Author: vkarpov15

CHANGELOG.md

@@ -1,3 +1,22 @@
+8.0.3 / 2023-12-07
+==================
+ * fix(schema): avoid creating unnecessary clone of schematype in nested array so nested document arrays use correct constructor #14128 #14101
+ * docs(connections): add example of registering connection event handlers #14150
+ * docs(populate): add example of using `refPath` and `ref` functions #14133 #13834
+ * types: handle using BigInt global class in schema definitions #14160 #14147
+ * types: make findOneAndDelete() without options return result doc, not ModifyResult #14153 #14130
+ * types(model): add no-generic override for insertMany() with options #14152 #13999
+ * types: add missing Type for applyDefaults #14159 [jaypea](https://github.com/jaypea)
+
+7.6.7 / 2023-12-06
+==================
+ * fix: avoid minimizing single nested subdocs if they are required #14151 #14058
+ * fix(populate): allow deselecting discriminator key when populating #14155 #3230
+ * fix: allow adding discriminators using Schema.prototype.discriminator() to subdocuments after defining parent schema #14131 #14109
+ * fix(schema): avoid creating unnecessary clone of schematype in nested array so nested document arrays use correct constructor #14128 #14101
+ * fix(populate): call transform object with single id instead of array when populating a justOne path under an array #14135 #14073
+ * types: add back mistakenly removed findByIdAndRemove() function signature #14136 #14132
+
 8.0.2 / 2023-11-28
 ==================
  * fix(populate): set populated docs in correct order when populating virtual underneath doc array with justOne #14105

docs/connections.md

@@ -267,18 +267,42 @@ connection may emit.
 
 * `connecting`: Emitted when Mongoose starts making its initial connection to the MongoDB server
 * `connected`: Emitted when Mongoose successfully makes its initial connection to the MongoDB server, or when Mongoose reconnects after losing connectivity. May be emitted multiple times if Mongoose loses connectivity.
-* `open`: Emitted after `'connected'` and `onOpen` is executed on all of this connection's models.
-* `disconnecting`: Your app called [`Connection#close()`](api/connection.html#connection_Connection-close) to disconnect from MongoDB
+* `open`: Emitted after `'connected'` and `onOpen` is executed on all of this connection's models. May be emitted multiple times if Mongoose loses connectivity.
+* `disconnecting`: Your app called [`Connection#close()`](api/connection.html#connection_Connection-close) to disconnect from MongoDB. This includes calling `mongoose.disconnect()`, which calls `close()` on all connections.
 * `disconnected`: Emitted when Mongoose lost connection to the MongoDB server. This event may be due to your code explicitly closing the connection, the database server crashing, or network connectivity issues.
 * `close`: Emitted after [`Connection#close()`](api/connection.html#connection_Connection-close) successfully closes the connection. If you call `conn.close()`, you'll get both a 'disconnected' event and a 'close' event.
 * `reconnected`: Emitted if Mongoose lost connectivity to MongoDB and successfully reconnected. Mongoose attempts to [automatically reconnect](https://thecodebarbarian.com/managing-connections-with-the-mongodb-node-driver.html) when it loses connection to the database.
 * `error`: Emitted if an error occurs on a connection, like a `parseError` due to malformed data or a payload larger than [16MB](https://www.mongodb.com/docs/manual/reference/limits/#BSON-Document-Size).
-* `fullsetup`: Emitted when you're connecting to a replica set and Mongoose has successfully connected to the primary and at least one secondary.
-* `all`: Emitted when you're connecting to a replica set and Mongoose has successfully connected to all servers specified in your connection string.
 
-When you're connecting to a single MongoDB server (a "standalone"), Mongoose will emit 'disconnected' if it gets
-disconnected from the standalone server, and 'connected' if it successfully connects to the standalone. In a
-replica set, Mongoose will emit 'disconnected' if it loses connectivity to the replica set primary, and 'connected' if it manages to reconnect to the replica set primary.
+When you're connecting to a single MongoDB server (a ["standalone"](https://www.mongodb.com/docs/cloud-manager/tutorial/deploy-standalone/)), Mongoose will emit `disconnected` if it gets
+disconnected from the standalone server, and `connected` if it successfully connects to the standalone. In a
+[replica set](https://www.mongodb.com/docs/manual/replication/), Mongoose will emit `disconnected` if it loses connectivity to the replica set primary, and `connected` if it manages to reconnect to the replica set primary.
+
+If you are using `mongoose.connect()`, you can use the following to listen to the above events:
+
+```javascript
+mongoose.connection.on('connected', () => console.log('connected'));
+mongoose.connection.on('open', () => console.log('open'));
+mongoose.connection.on('disconnected', () => console.log('disconnected'));
+mongoose.connection.on('reconnected', () => console.log('reconnected'));
+mongoose.connection.on('disconnecting', () => console.log('disconnecting'));
+mongoose.connection.on('close', () => console.log('close'));
+
+mongoose.connect('mongodb://127.0.0.1:27017/mongoose_test');
+```
+
+With `mongoose.createConnection()`, use the following instead:
+
+```javascript
+const conn = mongoose.createConnection('mongodb://127.0.0.1:27017/mongoose_test');
+
+conn.on('connected', () => console.log('connected'));
+conn.on('open', () => console.log('open'));
+conn.on('disconnected', () => console.log('disconnected'));
+conn.on('reconnected', () => console.log('reconnected'));
+conn.on('disconnecting', () => console.log('disconnecting'));
+conn.on('close', () => console.log('close'));
+```
 
 <h2 id="keepAlive"><a href="#keepAlive">A note about keepAlive</a></h2>
 

docs/version-support.md

@@ -10,9 +10,7 @@ We ship all new bug fixes and features to 7.x.
 
 ## Mongoose 6
 
-Mongoose 6.x (released August 24, 2021) is currently in legacy support.
-We will continue to ship bug fixes to Mongoose 6 until August 24, 2023.
-After August 24, 2023, we will only ship security fixes, and backport requested fixes to Mongoose 6.
+Mongoose 6.x (released August 24, 2021) is currently only receiving security fixes and requested bug fixes as of August 24, 2023.
 Please open a [bug report on GitHub](https://github.com/Automattic/mongoose/issues/new?assignees=&labels=&template=bug.yml) to request backporting a fix to Mongoose 6.
 
 We are **not** actively backporting any new features from Mongoose 7 into Mongoose 6.

lib/document.js

@@ -3691,8 +3691,7 @@ Document.prototype.$toObject = function(options, json) {
   const schemaOptions = this.$__schema && this.$__schema.options || {};
   // merge base default options with Schema's set default options if available.
   // `clone` is necessary here because `utils.options` directly modifies the second input.
-  defaultOptions = utils.options(defaultOptions, clone(baseOptions));
-  defaultOptions = utils.options(defaultOptions, clone(schemaOptions[path] || {}));
+  defaultOptions = { ...defaultOptions, ...baseOptions, ...schemaOptions[path] };
 
   // If options do not exist or is not an object, set it to empty object
   options = utils.isPOJO(options) ? { ...options } : {};
@@ -3754,7 +3753,7 @@ Document.prototype.$toObject = function(options, json) {
   }
 
   // merge default options with input options.
-  options = utils.options(defaultOptions, options);
+  options = { ...defaultOptions, ...options };
   options._isNested = true;
   options.json = json;
   options.minimize = _minimize;

lib/helpers/clone.js

@@ -54,7 +54,7 @@ function clone(obj, options, isArrayChild) {
       ret = obj.toObject(options);
     }
 
-    if (options && options.minimize && isSingleNested && Object.keys(ret).length === 0) {
+    if (options && options.minimize && !obj.constructor.$__required && isSingleNested && Object.keys(ret).length === 0) {
       return undefined;
     }
 

lib/helpers/discriminator/applyEmbeddedDiscriminators.js

@@ -0,0 +1,23 @@
+'use strict';
+
+module.exports = applyEmbeddedDiscriminators;
+
+function applyEmbeddedDiscriminators(schema, seen = new WeakSet()) {
+  if (seen.has(schema)) {
+    return;
+  }
+  seen.add(schema);
+  for (const path of Object.keys(schema.paths)) {
+    const schemaType = schema.paths[path];
+    if (!schemaType.schema) {
+      continue;
+    }
+    applyEmbeddedDiscriminators(schemaType.schema, seen);
+    if (!schemaType.schema._applyDiscriminators) {
+      continue;
+    }
+    for (const disc of schemaType.schema._applyDiscriminators.keys()) {
+      schemaType.discriminator(disc, schemaType.schema._applyDiscriminators.get(disc));
+    }
+  }
+}

lib/helpers/populate/assignVals.js

@@ -39,8 +39,10 @@ module.exports = function assignVals(o) {
   const options = o.options;
   const count = o.count && o.isVirtual;
   let i;
+  let setValueIndex = 0;
 
   function setValue(val) {
+    ++setValueIndex;
     if (count) {
       return val;
     }
@@ -80,11 +82,14 @@ module.exports = function assignVals(o) {
       return valueFilter(val[0], options, populateOptions, _allIds);
     } else if (o.justOne === false && !Array.isArray(val)) {
       return valueFilter([val], options, populateOptions, _allIds);
+    } else if (o.justOne === true && !Array.isArray(val) && Array.isArray(_allIds)) {
+      return valueFilter(val, options, populateOptions, val == null ? val : _allIds[setValueIndex - 1]);
     }
     return valueFilter(val, options, populateOptions, _allIds);
   }
 
   for (i = 0; i < docs.length; ++i) {
+    setValueIndex = 0;
     const _path = o.path.endsWith('.$*') ? o.path.slice(0, -3) : o.path;
     const existingVal = mpath.get(_path, docs[i], lookupLocalFields);
     if (existingVal == null && !getVirtual(o.originalModel.schema, _path)) {

lib/helpers/projection/isExclusive.js

@@ -12,13 +12,12 @@ module.exports = function isExclusive(projection) {
   }
 
   const keys = Object.keys(projection);
-  let ki = keys.length;
   let exclude = null;
 
-  if (ki === 1 && keys[0] === '_id') {
+  if (keys.length === 1 && keys[0] === '_id') {
     exclude = !projection._id;
   } else {
-    while (ki--) {
+    for (let ki = 0; ki < keys.length; ++ki) {
       // Does this projection explicitly define inclusion/exclusion?
       // Explicitly avoid `$meta` and `$slice`
       const key = keys[ki];

lib/model.js

@@ -4300,7 +4300,7 @@ function populate(model, docs, options, callback) {
         select = select.replace(excludeIdRegGlobal, ' ');
       } else {
         // preserve original select conditions by copying
-        select = utils.object.shallowCopy(select);
+        select = { ...select };
         delete select._id;
       }
     }

lib/mongoose.js

@@ -30,6 +30,7 @@ const sanitizeFilter = require('./helpers/query/sanitizeFilter');
 const isBsonType = require('./helpers/isBsonType');
 const MongooseError = require('./error/mongooseError');
 const SetOptionError = require('./error/setOptionError');
+const applyEmbeddedDiscriminators = require('./helpers/discriminator/applyEmbeddedDiscriminators');
 
 const defaultMongooseSymbol = Symbol.for('mongoose:default');
 
@@ -627,6 +628,8 @@ Mongoose.prototype._model = function(name, schema, collection, options) {
     }
   }
 
+  applyEmbeddedDiscriminators(schema);
+
   return model;
 };
 

lib/query.js

@@ -4791,16 +4791,14 @@ Query.prototype._castFields = function _castFields(fields) {
       elemMatchKeys,
       keys,
       key,
-      out,
-      i;
+      out;
 
   if (fields) {
     keys = Object.keys(fields);
     elemMatchKeys = [];
-    i = keys.length;
 
     // collect $elemMatch args
-    while (i--) {
+    for (let i = 0; i < keys.length; ++i) {
       key = keys[i];
       if (fields[key].$elemMatch) {
         selected || (selected = {});
@@ -4819,8 +4817,7 @@ Query.prototype._castFields = function _castFields(fields) {
     }
 
     // apply the casted field args
-    i = elemMatchKeys.length;
-    while (i--) {
+    for (let i = 0; i < elemMatchKeys.length; ++i) {
       key = elemMatchKeys[i];
       fields[key] = out[key];
     }

lib/queryHelpers.js

@@ -180,11 +180,12 @@ exports.applyPaths = function applyPaths(fields, schema) {
       if (!isDefiningProjection(field)) {
         continue;
       }
-      // `_id: 1, name: 0` is a mixed inclusive/exclusive projection in
-      // MongoDB 4.0 and earlier, but not in later versions.
       if (keys[keyIndex] === '_id' && keys.length > 1) {
         continue;
       }
+      if (keys[keyIndex] === schema.options.discriminatorKey && keys.length > 1 && field != null && !field) {
+        continue;
+      }
       exclude = !field;
       break;
     }

lib/schema.js

@@ -560,7 +560,7 @@ Schema.prototype.defaultOptions = function(options) {
   const strict = 'strict' in baseOptions ? baseOptions.strict : true;
   const strictQuery = 'strictQuery' in baseOptions ? baseOptions.strictQuery : false;
   const id = 'id' in baseOptions ? baseOptions.id : true;
-  options = utils.options({
+  options = {
     strict,
     strictQuery,
     bufferCommands: true,
@@ -577,8 +577,9 @@ Schema.prototype.defaultOptions = function(options) {
     // the following are only applied at construction time
     _id: true,
     id: id,
-    typeKey: 'type'
-  }, clone(options));
+    typeKey: 'type',
+    ...options
+  };
 
   if (options.versionKey && typeof options.versionKey !== 'string') {
     throw new MongooseError('`versionKey` must be falsy or string, got `' + (typeof options.versionKey) + '`');

lib/schema/bigint.js

@@ -7,7 +7,6 @@
 const CastError = require('../error/cast');
 const SchemaType = require('../schemaType');
 const castBigInt = require('../cast/bigint');
-const utils = require('../utils');
 
 /**
  * BigInt SchemaType constructor.
@@ -177,12 +176,13 @@ SchemaBigInt.prototype.cast = function(value) {
  * ignore
  */
 
-SchemaBigInt.$conditionalHandlers = utils.options(SchemaType.prototype.$conditionalHandlers, {
+SchemaBigInt.$conditionalHandlers = {
+  ...SchemaType.prototype.$conditionalHandlers,
   $gt: handleSingle,
   $gte: handleSingle,
   $lt: handleSingle,
   $lte: handleSingle
-});
+};
 
 /*!
  * ignore

lib/schema/boolean.js

@@ -7,7 +7,6 @@
 const CastError = require('../error/cast');
 const SchemaType = require('../schemaType');
 const castBoolean = require('../cast/boolean');
-const utils = require('../utils');
 
 /**
  * Boolean SchemaType constructor.
@@ -235,8 +234,7 @@ SchemaBoolean.prototype.cast = function(value) {
   }
 };
 
-SchemaBoolean.$conditionalHandlers =
-    utils.options(SchemaType.prototype.$conditionalHandlers, {});
+SchemaBoolean.$conditionalHandlers = { ...SchemaType.prototype.$conditionalHandlers };
 
 /**
  * Casts contents for queries.

lib/schema/buffer.js

@@ -250,17 +250,17 @@ function handleSingle(val, context) {
   return this.castForQuery(null, val, context);
 }
 
-SchemaBuffer.prototype.$conditionalHandlers =
-    utils.options(SchemaType.prototype.$conditionalHandlers, {
-      $bitsAllClear: handleBitwiseOperator,
-      $bitsAnyClear: handleBitwiseOperator,
-      $bitsAllSet: handleBitwiseOperator,
-      $bitsAnySet: handleBitwiseOperator,
-      $gt: handleSingle,
-      $gte: handleSingle,
-      $lt: handleSingle,
-      $lte: handleSingle
-    });
+SchemaBuffer.prototype.$conditionalHandlers = {
+  ...SchemaType.prototype.$conditionalHandlers,
+  $bitsAllClear: handleBitwiseOperator,
+  $bitsAnyClear: handleBitwiseOperator,
+  $bitsAllSet: handleBitwiseOperator,
+  $bitsAnySet: handleBitwiseOperator,
+  $gt: handleSingle,
+  $gte: handleSingle,
+  $lt: handleSingle,
+  $lte: handleSingle
+};
 
 /**
  * Casts contents for queries.

lib/schema/date.js

@@ -388,13 +388,13 @@ function handleSingle(val) {
   return this.cast(val);
 }
 
-SchemaDate.prototype.$conditionalHandlers =
-    utils.options(SchemaType.prototype.$conditionalHandlers, {
-      $gt: handleSingle,
-      $gte: handleSingle,
-      $lt: handleSingle,
-      $lte: handleSingle
-    });
+SchemaDate.prototype.$conditionalHandlers = {
+  ...SchemaType.prototype.$conditionalHandlers,
+  $gt: handleSingle,
+  $gte: handleSingle,
+  $lt: handleSingle,
+  $lte: handleSingle
+};
 
 
 /**

lib/schema/decimal128.js

@@ -7,7 +7,6 @@
 const SchemaType = require('../schemaType');
 const CastError = SchemaType.CastError;
 const castDecimal128 = require('../cast/decimal128');
-const utils = require('../utils');
 const isBsonType = require('../helpers/isBsonType');
 
 /**
@@ -214,13 +213,13 @@ function handleSingle(val) {
   return this.cast(val);
 }
 
-SchemaDecimal128.prototype.$conditionalHandlers =
-    utils.options(SchemaType.prototype.$conditionalHandlers, {
-      $gt: handleSingle,
-      $gte: handleSingle,
-      $lt: handleSingle,
-      $lte: handleSingle
-    });
+SchemaDecimal128.prototype.$conditionalHandlers = {
+  ...SchemaType.prototype.$conditionalHandlers,
+  $gt: handleSingle,
+  $gte: handleSingle,
+  $lt: handleSingle,
+  $lte: handleSingle
+};
 
 /*!
  * Module exports.