mongoose 8.10.0 → 8.10.2

package/lib/connection.js

@@ -23,6 +23,7 @@ const CreateCollectionsError = require('./error/createCollectionsError');
 const castBulkWrite = require('./helpers/model/castBulkWrite');
 const { modelSymbol } = require('./helpers/symbols');
 const isPromise = require('./helpers/isPromise');
+const decorateBulkWriteResult = require('./helpers/model/decorateBulkWriteResult');
 
 const arrayAtomicsSymbol = require('./helpers/symbols').arrayAtomicsSymbol;
 const sessionNewDocuments = require('./helpers/symbols').sessionNewDocuments;
@@ -559,7 +560,9 @@ Connection.prototype.bulkWrite = async function bulkWrite(ops, options) {
           'bulkWrite'
         );
       }
-      return getDefaultBulkwriteResult();
+      const BulkWriteResult = this.base.driver.get().BulkWriteResult;
+      const res = new BulkWriteResult(getDefaultBulkwriteResult(), false);
+      return decorateBulkWriteResult(res, validationErrors, results);
     }
 
     let error;
@@ -567,16 +570,17 @@ Connection.prototype.bulkWrite = async function bulkWrite(ops, options) {
       then(res => ([res, null])).
       catch(err => ([null, err]));
 
+    for (let i = 0; i < validOpIndexes.length; ++i) {
+      results[validOpIndexes[i]] = null;
+    }
     if (error) {
       if (validationErrors.length > 0) {
+        decorateBulkWriteResult(error, validationErrors, results);
         error.mongoose = error.mongoose || {};
         error.mongoose.validationErrors = validationErrors;
       }
     }
 
-    for (let i = 0; i < validOpIndexes.length; ++i) {
-      results[validOpIndexes[i]] = null;
-    }
     if (validationErrors.length > 0) {
       if (options.throwOnValidationError) {
         throw new MongooseBulkWriteError(
@@ -586,9 +590,7 @@ Connection.prototype.bulkWrite = async function bulkWrite(ops, options) {
           'bulkWrite'
         );
       } else {
-        res.mongoose = res.mongoose || {};
-        res.mongoose.validationErrors = validationErrors;
-        res.mongoose.results = results;
+        decorateBulkWriteResult(res, validationErrors, results);
       }
     }
   }
@@ -818,32 +820,41 @@ Connection.prototype.dropCollection = async function dropCollection(collection)
 /**
  * Waits for connection to be established, so the connection has a `client`
  *
+ * @param {Boolean} [noTimeout=false] if set, don't put a timeout on the operation. Used internally so `mongoose.model()` doesn't leave open handles.
  * @return Promise
  * @api private
  */
 
-Connection.prototype._waitForConnect = async function _waitForConnect() {
+Connection.prototype._waitForConnect = async function _waitForConnect(noTimeout) {
   if ((this.readyState === STATES.connecting || this.readyState === STATES.disconnected) && this._shouldBufferCommands()) {
     const bufferTimeoutMS = this._getBufferTimeoutMS();
     let timeout = null;
     let timedOut = false;
     // The element that this function pushes onto `_queue`, stored to make it easy to remove later
     const queueElement = {};
-    await Promise.race([
-      new Promise(resolve => {
-        queueElement.fn = resolve;
-        this._queue.push(queueElement);
-      }),
-      new Promise(resolve => {
-        timeout = setTimeout(
-          () => {
-            timedOut = true;
-            resolve();
-          },
-          bufferTimeoutMS
-        );
-      })
-    ]);
+
+    // Mongoose executes all elements in `_queue` when initial connection succeeds in `onOpen()`.
+    const waitForConnectPromise = new Promise(resolve => {
+      queueElement.fn = resolve;
+      this._queue.push(queueElement);
+    });
+
+    if (noTimeout) {
+      await waitForConnectPromise;
+    } else {
+      await Promise.race([
+        waitForConnectPromise,
+        new Promise(resolve => {
+          timeout = setTimeout(
+            () => {
+              timedOut = true;
+              resolve();
+            },
+            bufferTimeoutMS
+          );
+        })
+      ]);
+    }
 
     if (timedOut) {
       const index = this._queue.indexOf(queueElement);

package/lib/document.js

@@ -741,15 +741,10 @@ function init(self, obj, doc, opts, prefix) {
   let schemaType;
   let path;
   let i;
-  let index = 0;
   const strict = self.$__.strictMode;
   const docSchema = self.$__schema;
 
-  while (index < len) {
-    _init(index++);
-  }
-
-  function _init(index) {
+  for (let index = 0; index < len; ++index) {
     i = keys[index];
     // avoid prototype pollution
     if (i === '__proto__' || i === 'constructor') {
@@ -3558,8 +3553,10 @@ Document.prototype.$__undoReset = function $__undoReset() {
     }
   }
 
-  for (const subdoc of this.$getAllSubdocs()) {
-    subdoc.$__undoReset();
+  if (!this.$isSubdocument) {
+    for (const subdoc of this.$getAllSubdocs()) {
+      subdoc.$__undoReset();
+    }
   }
 };
 

package/lib/drivers/browser/index.js

@@ -10,3 +10,4 @@ exports.Collection = function() {
 exports.Connection = function() {
   throw new Error('Cannot create a connection from browser library');
 };
+exports.BulkWriteResult = function() {};

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

@@ -0,0 +1,5 @@
+'use strict';
+
+const BulkWriteResult = require('mongodb/lib/bulk/common').BulkWriteResult;
+
+module.exports = BulkWriteResult;

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

@@ -13,6 +13,8 @@ const internalToObjectOptions = require('../../options').internalToObjectOptions
 const stream = require('stream');
 const util = require('util');
 
+const formatToObjectOptions = Object.freeze({ ...internalToObjectOptions, copyTrustedSymbol: false });
+
 /**
  * A [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) collection implementation.
  *
@@ -384,7 +386,9 @@ function format(obj, sub, color, shell) {
   }
 
   const clone = require('../../helpers/clone');
-  let x = clone(obj, internalToObjectOptions);
+  // `sub` indicates `format()` was called recursively, so skip cloning because we already
+  // did a deep clone on the top-level object.
+  let x = sub ? obj : clone(obj, formatToObjectOptions);
   const constructorName = getConstructorName(x);
 
   if (constructorName === 'Binary') {

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

@@ -4,5 +4,6 @@
 
 'use strict';
 
+exports.BulkWriteResult = require('./bulkWriteResult');
 exports.Collection = require('./collection');
 exports.Connection = require('./connection');

package/lib/helpers/clone.js

@@ -147,7 +147,7 @@ function cloneObject(obj, options, isArrayChild) {
   } else if (seen) {
     seen.set(obj, ret);
   }
-  if (trustedSymbol in obj) {
+  if (trustedSymbol in obj && options?.copyTrustedSymbol !== false) {
     ret[trustedSymbol] = obj[trustedSymbol];
   }
 

package/lib/helpers/getDefaultBulkwriteResult.js

@@ -1,26 +1,17 @@
 'use strict';
+
 function getDefaultBulkwriteResult() {
   return {
-    result: {
-      ok: 1,
-      writeErrors: [],
-      writeConcernErrors: [],
-      insertedIds: [],
-      nInserted: 0,
-      nUpserted: 0,
-      nMatched: 0,
-      nModified: 0,
-      nRemoved: 0,
-      upserted: []
-    },
-    insertedCount: 0,
-    matchedCount: 0,
-    modifiedCount: 0,
-    deletedCount: 0,
-    upsertedCount: 0,
-    upsertedIds: {},
-    insertedIds: {},
-    n: 0
+    ok: 1,
+    nInserted: 0,
+    nUpserted: 0,
+    nMatched: 0,
+    nModified: 0,
+    nRemoved: 0,
+    upserted: [],
+    writeErrors: [],
+    insertedIds: [],
+    writeConcernErrors: []
   };
 }
 

package/lib/helpers/model/decorateBulkWriteResult.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = function decorateBulkWriteResult(resultOrError, validationErrors, results) {
+  resultOrError.mongoose = resultOrError.mongoose || {};
+  resultOrError.mongoose.validationErrors = validationErrors;
+  resultOrError.mongoose.results = results;
+  return resultOrError;
+};

package/lib/helpers/query/castUpdate.js

@@ -82,6 +82,16 @@ module.exports = function castUpdate(schema, obj, options, context, filter) {
     schema = schema.discriminators[discriminatorValue] ||
       (byValue && byValue.schema) ||
       schema;
+  } else if (schema != null &&
+      options.overwriteDiscriminatorKey &&
+      obj.$set != null &&
+      utils.hasUserDefinedProperty(obj.$set, schema.options.discriminatorKey) &&
+      schema.discriminators != null) {
+    const discriminatorValue = obj.$set[schema.options.discriminatorKey];
+    const byValue = getDiscriminatorByValue(context.model.discriminators, discriminatorValue);
+    schema = schema.discriminators[discriminatorValue] ||
+      (byValue && byValue.schema) ||
+      schema;
   }
 
   if (options.upsert) {

package/lib/model.js

@@ -10,7 +10,6 @@ const Document = require('./document');
 const DocumentNotFoundError = require('./error/notFound');
 const EventEmitter = require('events').EventEmitter;
 const Kareem = require('kareem');
-const { MongoBulkWriteError } = require('mongodb');
 const MongooseBulkWriteError = require('./error/bulkWriteError');
 const MongooseError = require('./error/index');
 const ObjectParameterError = require('./error/objectParameter');
@@ -69,6 +68,7 @@ const utils = require('./utils');
 const minimize = require('./helpers/minimize');
 const MongooseBulkSaveIncompleteError = require('./error/bulkSaveIncompleteError');
 const ObjectExpectedError = require('./error/objectExpected');
+const decorateBulkWriteResult = require('./helpers/model/decorateBulkWriteResult');
 
 const modelCollectionSymbol = Symbol('mongoose#Model#collection');
 const modelDbSymbol = Symbol('mongoose#Model#db');
@@ -1103,16 +1103,28 @@ Model.init = function init() {
     return results;
   };
   const _createCollection = async() => {
-    await conn._waitForConnect();
-    const autoCreate = utils.getOption(
+    let autoCreate = utils.getOption(
       'autoCreate',
       this.schema.options,
-      conn.config,
-      conn.base.options
+      conn.config
+      // No base.options here because we don't want to take the base value if the connection hasn't
+      // set it yet
     );
+    if (autoCreate == null) {
+      // `autoCreate` may later be set when the connection is opened, so wait for connect before checking
+      await conn._waitForConnect(true);
+      autoCreate = utils.getOption(
+        'autoCreate',
+        this.schema.options,
+        conn.config,
+        conn.base.options
+      );
+    }
+
     if (!autoCreate) {
       return;
     }
+
     return await this.createCollection();
   };
 
@@ -3387,7 +3399,11 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
   const ordered = options.ordered == null ? true : options.ordered;
 
   if (ops.length === 0) {
-    return getDefaultBulkwriteResult();
+    const BulkWriteResult = this.base.driver.get().BulkWriteResult;
+    const bulkWriteResult = new BulkWriteResult(getDefaultBulkwriteResult(), false);
+    bulkWriteResult.n = 0;
+    decorateBulkWriteResult(bulkWriteResult, [], []);
+    return bulkWriteResult;
   }
 
   const validations = ops.map(op => castBulkWrite(this, op, options));
@@ -3458,7 +3474,11 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
           'bulkWrite'
         );
       }
-      return getDefaultBulkwriteResult();
+      const BulkWriteResult = this.base.driver.get().BulkWriteResult;
+      const bulkWriteResult = new BulkWriteResult(getDefaultBulkwriteResult(), false);
+      bulkWriteResult.result = getDefaultBulkwriteResult();
+      decorateBulkWriteResult(bulkWriteResult, validationErrors, results);
+      return bulkWriteResult;
     }
 
     let error;
@@ -3466,10 +3486,12 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
       then(res => ([res, null])).
       catch(error => ([null, error]));
 
+    for (let i = 0; i < validOpIndexes.length; ++i) {
+      results[validOpIndexes[i]] = null;
+    }
     if (error) {
       if (validationErrors.length > 0) {
-        error.mongoose = error.mongoose || {};
-        error.mongoose.validationErrors = validationErrors;
+        decorateBulkWriteResult(error, validationErrors, results);
       }
 
       await new Promise((resolve, reject) => {
@@ -3483,9 +3505,6 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
       });
     }
 
-    for (let i = 0; i < validOpIndexes.length; ++i) {
-      results[validOpIndexes[i]] = null;
-    }
     if (validationErrors.length > 0) {
       if (options.throwOnValidationError) {
         throw new MongooseBulkWriteError(
@@ -3495,9 +3514,7 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
           'bulkWrite'
         );
       } else {
-        res.mongoose = res.mongoose || {};
-        res.mongoose.validationErrors = validationErrors;
-        res.mongoose.results = results;
+        decorateBulkWriteResult(res, validationErrors, results);
       }
     }
   }
@@ -3563,7 +3580,7 @@ Model.bulkSave = async function bulkSave(documents, options) {
     (err) => ({ bulkWriteResult: null, bulkWriteError: err })
   );
   // If not a MongoBulkWriteError, treat this as all documents failed to save.
-  if (bulkWriteError != null && !(bulkWriteError instanceof MongoBulkWriteError)) {
+  if (bulkWriteError != null && bulkWriteError.name !== 'MongoBulkWriteError') {
     throw bulkWriteError;
   }
 

package/lib/query.js

@@ -65,6 +65,25 @@ const queryOptionMethods = new Set([
   'wtimeout'
 ]);
 
+// Map from operation name to the name of the function that executes the actual operation against MongoDB.
+// Called a thunk for legacy reasons, "thunk" means function that takes exactly 1 param, a callback.
+// Currently `_countDocuments()`, etc. are async functions that take no params.
+const opToThunk = new Map([
+  ['countDocuments', '_countDocuments'],
+  ['distinct', '__distinct'],
+  ['estimatedDocumentCount', '_estimatedDocumentCount'],
+  ['find', '_find'],
+  ['findOne', '_findOne'],
+  ['findOneAndReplace', '_findOneAndReplace'],
+  ['findOneAndUpdate', '_findOneAndUpdate'],
+  ['replaceOne', '_replaceOne'],
+  ['updateMany', '_updateMany'],
+  ['updateOne', '_updateOne'],
+  ['deleteMany', '_deleteMany'],
+  ['deleteOne', '_deleteOne'],
+  ['findOneAndDelete', '_findOneAndDelete']
+]);
+
 /**
  * Query constructor used for building queries. You do not need
  * to instantiate a `Query` directly. Instead use Model functions like
@@ -2337,18 +2356,17 @@ Query.prototype._find = async function _find() {
   }
 
   const mongooseOptions = this._mongooseOptions;
-  const _this = this;
-  const userProvidedFields = _this._userProvidedFields || {};
+  const userProvidedFields = this._userProvidedFields || {};
 
   applyGlobalMaxTimeMS(this.options, this.model.db.options, this.model.base.options);
   applyGlobalDiskUse(this.options, this.model.db.options, this.model.base.options);
 
   // Separate options to pass down to `completeMany()` in case we need to
   // set a session on the document
-  const completeManyOptions = Object.assign({}, {
+  const completeManyOptions = {
     session: this && this.options && this.options.session || null,
     lean: mongooseOptions.lean || null
-  });
+  };
 
   const options = this._optionsForExec();
 
@@ -2366,7 +2384,7 @@ Query.prototype._find = async function _find() {
   }
 
   if (!mongooseOptions.populate) {
-    const versionKey = _this.schema.options.versionKey;
+    const versionKey = this.schema.options.versionKey;
     if (mongooseOptions.lean && mongooseOptions.lean.versionKey === false && versionKey) {
       docs.forEach((doc) => {
         if (versionKey in doc) {
@@ -2375,17 +2393,17 @@ Query.prototype._find = async function _find() {
       });
     }
     return mongooseOptions.lean ?
-      _completeManyLean(_this.model.schema, docs, null, completeManyOptions) :
-      _this._completeMany(docs, fields, userProvidedFields, completeManyOptions);
+      _completeManyLean(this.model.schema, docs, null, completeManyOptions) :
+      this._completeMany(docs, fields, userProvidedFields, completeManyOptions);
   }
 
-  const pop = helpers.preparePopulationOptionsMQ(_this, mongooseOptions);
+  const pop = helpers.preparePopulationOptionsMQ(this, mongooseOptions);
 
   if (mongooseOptions.lean) {
-    return _this.model.populate(docs, pop);
+    return this.model.populate(docs, pop);
   }
 
-  docs = await _this._completeMany(docs, fields, userProvidedFields, completeManyOptions);
+  docs = await this._completeMany(docs, fields, userProvidedFields, completeManyOptions);
   await this.model.populate(docs, pop);
 
   return docs;
@@ -4397,22 +4415,14 @@ Query.prototype.exec = async function exec(op) {
   if (this.model == null) {
     throw new MongooseError('Query must have an associated model before executing');
   }
-  this._validateOp();
-
-  if (!this.op) {
-    return;
-  }
 
-  if (this.options && this.options.sort) {
-    const keys = Object.keys(this.options.sort);
-    if (keys.includes('')) {
-      throw new Error('Invalid field "" passed to sort()');
-    }
+  const thunk = opToThunk.get(this.op);
+  if (!thunk) {
+    throw new MongooseError('Query has invalid `op`: "' + this.op + '"');
   }
 
-  let thunk = '_' + this.op;
-  if (this.op === 'distinct') {
-    thunk = '__distinct';
+  if (this.options && this.options.sort && typeof this.options.sort === 'object' && this.options.sort.hasOwnProperty('')) {
+    throw new Error('Invalid field "" passed to sort()');
   }
 
   if (this._executionStack != null) {

package/lib/schema/map.js

@@ -91,14 +91,7 @@ class SchemaMap extends SchemaType {
 
     const isRequired = this.options.required && typeof this.options.required !== 'function';
     const result = createJSONSchemaTypeDefinition('object', 'object', useBsonType, isRequired);
-
-    if (embeddedSchemaType.schema) {
-      result.additionalProperties = useBsonType
-        ? { ...embeddedSchemaType.toJSONSchema(options) }
-        : { ...embeddedSchemaType.toJSONSchema(options) };
-    } else {
-      result.additionalProperties = embeddedSchemaType.toJSONSchema(options);
-    }
+    result.additionalProperties = embeddedSchemaType.toJSONSchema(options);
 
     return result;
   }

package/lib/schema.js

@@ -1118,6 +1118,9 @@ Schema.prototype.path = function(path, obj) {
   this.paths[path] = this.interpretAsType(path, obj, this.options);
   const schemaType = this.paths[path];
 
+  // If overwriting an existing path, make sure to clear the childSchemas
+  this.childSchemas = this.childSchemas.filter(childSchema => childSchema.path !== path);
+
   if (schemaType.$isSchemaMap) {
     // Maps can have arbitrary keys, so `$*` is internal shorthand for "any key"
     // The '$' is to imply this path should never be stored in MongoDB so we

package/package.json

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