mongoose 8.1.2 → 8.2.0

package/lib/aggregate.js

@@ -1019,8 +1019,8 @@ Aggregate.prototype.exec = async function exec() {
   const model = this._model;
   const collection = this._model.collection;
 
-  applyGlobalMaxTimeMS(this.options, model);
-  applyGlobalDiskUse(this.options, model);
+  applyGlobalMaxTimeMS(this.options, model.db.options, model.base.options);
+  applyGlobalDiskUse(this.options, model.db.options, model.base.options);
 
   if (this.options && this.options.cursor) {
     return new AggregationCursor(this);

package/lib/connection.js

@@ -443,6 +443,28 @@ Connection.prototype.createCollections = async function createCollections(option
   return result;
 };
 
+/**
+ * A convenience wrapper for `connection.client.withSession()`.
+ *
+ * #### Example:
+ *
+ *     await conn.withSession(async session => {
+ *       const doc = await TestModel.findOne().session(session);
+ *     });
+ *
+ * @method withSession
+ * @param {Function} executor called with 1 argument: a `ClientSession` instance
+ * @return {Promise} resolves to the return value of the executor function
+ * @api public
+ */
+
+Connection.prototype.withSession = async function withSession(executor) {
+  if (arguments.length === 0) {
+    throw new Error('Please provide an executor function');
+  }
+  return await this.client.withSession(executor);
+};
+
 /**
  * _Requires MongoDB >= 3.6.0._ Starts a [MongoDB session](https://www.mongodb.com/docs/manual/release-notes/3.6/#client-sessions)
  * for benefits like causal consistency, [retryable writes](https://www.mongodb.com/docs/manual/core/retryable-writes/),

package/lib/constants.js

@@ -0,0 +1,36 @@
+'use strict';
+
+/*!
+ * ignore
+ */
+
+const queryOperations = Object.freeze([
+  // Read
+  'countDocuments',
+  'distinct',
+  'estimatedDocumentCount',
+  'find',
+  'findOne',
+  // Update
+  'findOneAndReplace',
+  'findOneAndUpdate',
+  'replaceOne',
+  'updateMany',
+  'updateOne',
+  // Delete
+  'deleteMany',
+  'deleteOne',
+  'findOneAndDelete'
+]);
+
+exports.queryOperations = queryOperations;
+
+/*!
+ * ignore
+ */
+
+const queryMiddlewareFunctions = queryOperations.concat([
+  'validate'
+]);
+
+exports.queryMiddlewareFunctions = queryMiddlewareFunctions;

package/lib/cursor/aggregationCursor.js

@@ -57,12 +57,20 @@ util.inherits(AggregationCursor, Readable);
 function _init(model, c, agg) {
   if (!model.collection.buffer) {
     model.hooks.execPre('aggregate', agg, function() {
+      if (typeof agg.options?.cursor?.transform === 'function') {
+        c._transforms.push(agg.options.cursor.transform);
+      }
+
       c.cursor = model.collection.aggregate(agg._pipeline, agg.options || {});
       c.emit('cursor', c.cursor);
     });
   } else {
     model.collection.emitter.once('queue', function() {
       model.hooks.execPre('aggregate', agg, function() {
+        if (typeof agg.options?.cursor?.transform === 'function') {
+          c._transforms.push(agg.options.cursor.transform);
+        }
+
         c.cursor = model.collection.aggregate(agg._pipeline, agg.options || {});
         c.emit('cursor', c.cursor);
       });

package/lib/document.js

@@ -694,7 +694,6 @@ Document.prototype.$__init = function(doc, opts) {
   init(this, doc, this._doc, opts);
 
   markArraySubdocsPopulated(this, opts.populated);
-
   this.$emit('init', this);
   this.constructor.emit('init', this);
 
@@ -703,7 +702,6 @@ Document.prototype.$__init = function(doc, opts) {
     null;
 
   applyDefaults(this, this.$__.selected, this.$__.exclude, hasIncludedChildren, false, this.$__.skipDefaults);
-
   return this;
 };
 
@@ -746,7 +744,6 @@ function init(self, obj, doc, opts, prefix) {
     }
     path = prefix + 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
     // base model and the discriminated model has a projection
@@ -770,15 +767,14 @@ function init(self, obj, doc, opts, prefix) {
       }
     } else {
       // Retain order when overwriting defaults
-      if (doc.hasOwnProperty(i) && obj[i] !== void 0) {
+      if (doc.hasOwnProperty(i) && obj[i] !== void 0 && !opts.hydratedPopulatedDocs) {
         delete doc[i];
       }
       if (obj[i] === null) {
         doc[i] = schemaType._castNullish(null);
       } else if (obj[i] !== undefined) {
         const wasPopulated = obj[i].$__ == null ? null : obj[i].$__.wasPopulated;
-
-        if (schemaType && !wasPopulated) {
+        if ((schemaType && !wasPopulated) && !opts.hydratedPopulatedDocs) {
           try {
             if (opts && opts.setters) {
               // Call applySetters with `init = false` because otherwise setters are a noop
@@ -3901,14 +3897,24 @@ Document.prototype.$toObject = function(options, json) {
  *
  * _Note: if a transform function returns `undefined`, the return value will be ignored._
  *
- * Transformations may also be applied inline, overridding any transform set in the options:
+ * Transformations may also be applied inline, overridding any transform set in the schema options.
+ * Any transform function specified in `toObject` options also propagates to any subdocuments.
  *
- *     function xform (doc, ret, options) {
- *       return { inline: ret.name, custom: true }
+ *     function deleteId(doc, ret, options) {
+ *       delete ret._id;
+ *       return ret;
  *     }
  *
- *     // pass the transform as an inline option
- *     doc.toObject({ transform: xform }); // { inline: 'Wreck-it Ralph', custom: true }
+ *     const schema = mongoose.Schema({ name: String, docArr: [{ name: String }] });
+ *     const TestModel = mongoose.model('Test', schema);
+ *
+ *     const doc = new TestModel({ name: 'test', docArr: [{ name: 'test' }] });
+ *
+ *     // pass the transform as an inline option. Deletes `_id` property
+ *     // from both the top-level document and the subdocument.
+ *     const obj = doc.toObject({ transform: deleteId });
+ *     obj._id; // undefined
+ *     obj.docArr[0]._id; // undefined
  *
  * If you want to skip transformations, use `transform: false`:
  *

package/lib/helpers/model/applyStaticHooks.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const middlewareFunctions = require('../query/applyQueryMiddleware').middlewareFunctions;
+const middlewareFunctions = require('../../constants').queryMiddlewareFunctions;
 const promiseOrCallback = require('../promiseOrCallback');
 
 module.exports = function applyStaticHooks(model, hooks, statics) {

package/lib/helpers/populate/getModelsMapForPopulate.js

@@ -494,7 +494,7 @@ function addModelNamesToMap(model, map, available, modelNames, options, data, re
 
   let k = modelNames.length;
   while (k--) {
-    const modelName = modelNames[k];
+    let modelName = modelNames[k];
     if (modelName == null) {
       continue;
     }
@@ -504,6 +504,7 @@ function addModelNamesToMap(model, map, available, modelNames, options, data, re
       Model = options.model;
     } else if (modelName[modelSymbol]) {
       Model = modelName;
+      modelName = Model.modelName;
     } else {
       try {
         Model = _getModelFromConn(connection, modelName);

package/lib/helpers/query/applyGlobalOption.js

@@ -2,12 +2,12 @@
 
 const utils = require('../../utils');
 
-function applyGlobalMaxTimeMS(options, model) {
-  applyGlobalOption(options, model, 'maxTimeMS');
+function applyGlobalMaxTimeMS(options, connectionOptions, baseOptions) {
+  applyGlobalOption(options, connectionOptions, baseOptions, 'maxTimeMS');
 }
 
-function applyGlobalDiskUse(options, model) {
-  applyGlobalOption(options, model, 'allowDiskUse');
+function applyGlobalDiskUse(options, connectionOptions, baseOptions) {
+  applyGlobalOption(options, connectionOptions, baseOptions, 'allowDiskUse');
 }
 
 module.exports = {
@@ -16,14 +16,14 @@ module.exports = {
 };
 
 
-function applyGlobalOption(options, model, optionName) {
+function applyGlobalOption(options, connectionOptions, baseOptions, optionName) {
   if (utils.hasUserDefinedProperty(options, optionName)) {
     return;
   }
 
-  if (utils.hasUserDefinedProperty(model.db.options, optionName)) {
-    options[optionName] = model.db.options[optionName];
-  } else if (utils.hasUserDefinedProperty(model.base.options, optionName)) {
-    options[optionName] = model.base.options[optionName];
+  if (utils.hasUserDefinedProperty(connectionOptions, optionName)) {
+    options[optionName] = connectionOptions[optionName];
+  } else if (utils.hasUserDefinedProperty(baseOptions, optionName)) {
+    options[optionName] = baseOptions[optionName];
   }
 }

package/lib/helpers/query/castFilterPath.js

@@ -2,8 +2,7 @@
 
 const isOperator = require('./isOperator');
 
-module.exports = function castFilterPath(query, schematype, val) {
-  const ctx = query;
+module.exports = function castFilterPath(ctx, schematype, val) {
   const any$conditionals = Object.keys(val).some(isOperator);
 
   if (!any$conditionals) {

package/lib/helpers/query/validOps.js

@@ -1,20 +1,3 @@
 'use strict';
 
-module.exports = Object.freeze([
-  // Read
-  'countDocuments',
-  'distinct',
-  'estimatedDocumentCount',
-  'find',
-  'findOne',
-  // Update
-  'findOneAndReplace',
-  'findOneAndUpdate',
-  'replaceOne',
-  'updateMany',
-  'updateOne',
-  // Delete
-  'deleteMany',
-  'deleteOne',
-  'findOneAndDelete'
-]);
+module.exports = require('../../constants').queryMiddlewareFunctions;

package/lib/model.js

@@ -23,7 +23,6 @@ const VersionError = require('./error/version');
 const ParallelSaveError = require('./error/parallelSave');
 const applyDefaultsHelper = require('./helpers/document/applyDefaults');
 const applyDefaultsToPOJO = require('./helpers/model/applyDefaultsToPOJO');
-const applyQueryMiddleware = require('./helpers/query/applyQueryMiddleware');
 const applyHooks = require('./helpers/model/applyHooks');
 const applyMethods = require('./helpers/model/applyMethods');
 const applyProjection = require('./helpers/projection/applyProjection');
@@ -1415,6 +1414,18 @@ Model.createCollection = async function createCollection(options) {
     throw new MongooseError('Model.createCollection() no longer accepts a callback');
   }
 
+  const shouldSkip = await new Promise((resolve, reject) => {
+    this.hooks.execPre('createCollection', this, [options], (err) => {
+      if (err != null) {
+        if (err instanceof Kareem.skipWrappedFunction) {
+          return resolve(true);
+        }
+        return reject(err);
+      }
+      resolve();
+    });
+  });
+
   const collectionOptions = this &&
     this.schema &&
     this.schema.options &&
@@ -1468,13 +1479,32 @@ Model.createCollection = async function createCollection(options) {
   }
 
   try {
-    await this.db.createCollection(this.$__collection.collectionName, options);
+    if (!shouldSkip) {
+      await this.db.createCollection(this.$__collection.collectionName, options);
+    }
   } catch (err) {
-
     if (err != null && (err.name !== 'MongoServerError' || err.code !== 48)) {
-      throw err;
+      await new Promise((resolve, reject) => {
+        const _opts = { error: err };
+        this.hooks.execPost('createCollection', this, [null], _opts, (err) => {
+          if (err != null) {
+            return reject(err);
+          }
+          resolve();
+        });
+      });
     }
   }
+
+  await new Promise((resolve, reject) => {
+    this.hooks.execPost('createCollection', this, [this.$__collection], (err) => {
+      if (err != null) {
+        return reject(err);
+      }
+      resolve();
+    });
+  });
+
   return this.$__collection;
 };
 
@@ -3428,44 +3458,62 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
     throw new MongooseError('Model.bulkWrite() no longer accepts a callback');
   }
   options = options || {};
+
+  const shouldSkip = await new Promise((resolve, reject) => {
+    this.hooks.execPre('bulkWrite', this, [ops, options], (err) => {
+      if (err != null) {
+        if (err instanceof Kareem.skipWrappedFunction) {
+          return resolve(err);
+        }
+        return reject(err);
+      }
+      resolve();
+    });
+  });
+
+  if (shouldSkip) {
+    return shouldSkip.args[0];
+  }
+
   const ordered = options.ordered == null ? true : options.ordered;
 
+  if (ops.length === 0) {
+    return getDefaultBulkwriteResult();
+  }
+
   const validations = ops.map(op => castBulkWrite(this, op, options));
 
-  return new Promise((resolve, reject) => {
-    if (ordered) {
+  let res = null;
+  if (ordered) {
+    await new Promise((resolve, reject) => {
       each(validations, (fn, cb) => fn(cb), error => {
         if (error) {
           return reject(error);
         }
 
-        if (ops.length === 0) {
-          return resolve(getDefaultBulkwriteResult());
-        }
-
-        try {
-          this.$__collection.bulkWrite(ops, options, (error, res) => {
-            if (error) {
-              return reject(error);
-            }
-
-            resolve(res);
-          });
-        } catch (err) {
-          return reject(err);
-        }
+        resolve();
       });
+    });
 
-      return;
+    try {
+      res = await this.$__collection.bulkWrite(ops, options);
+    } catch (error) {
+      await new Promise((resolve, reject) => {
+        const _opts = { error: error };
+        this.hooks.execPost('bulkWrite', this, [null], _opts, (err) => {
+          if (err != null) {
+            return reject(err);
+          }
+          resolve();
+        });
+      });
     }
-
+  } else {
     let remaining = validations.length;
     let validOps = [];
     let validationErrors = [];
     const results = [];
-    if (remaining === 0) {
-      completeUnorderedValidation.call(this);
-    } else {
+    await new Promise((resolve) => {
       for (let i = 0; i < validations.length; ++i) {
         validations[i]((err) => {
           if (err == null) {
@@ -3475,56 +3523,74 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
             results[i] = err;
           }
           if (--remaining <= 0) {
-            completeUnorderedValidation.call(this);
+            resolve();
           }
         });
       }
-    }
+    });
 
     validationErrors = validationErrors.
       sort((v1, v2) => v1.index - v2.index).
       map(v => v.error);
 
-    function completeUnorderedValidation() {
-      const validOpIndexes = validOps;
-      validOps = validOps.sort().map(index => ops[index]);
+    const validOpIndexes = validOps;
+    validOps = validOps.sort().map(index => ops[index]);
 
-      if (validOps.length === 0) {
-        return resolve(getDefaultBulkwriteResult());
-      }
+    if (validOps.length === 0) {
+      return getDefaultBulkwriteResult();
+    }
 
-      this.$__collection.bulkWrite(validOps, options, (error, res) => {
-        if (error) {
-          if (validationErrors.length > 0) {
-            error.mongoose = error.mongoose || {};
-            error.mongoose.validationErrors = validationErrors;
-          }
+    let error;
+    [res, error] = await this.$__collection.bulkWrite(validOps, options).
+      then(res => ([res, null])).
+      catch(err => ([null, err]));
 
-          return reject(error);
-        }
+    if (error) {
+      if (validationErrors.length > 0) {
+        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) {
-            return reject(new MongooseBulkWriteError(
-              validationErrors,
-              results,
-              res,
-              'bulkWrite'
-            ));
-          } else {
-            res.mongoose = res.mongoose || {};
-            res.mongoose.validationErrors = validationErrors;
-            res.mongoose.results = results;
+      await new Promise((resolve, reject) => {
+        const _opts = { error: error };
+        this.hooks.execPost('bulkWrite', this, [null], _opts, (err) => {
+          if (err != null) {
+            return reject(err);
           }
-        }
-
-        resolve(res);
+          resolve();
+        });
       });
     }
+
+    for (let i = 0; i < validOpIndexes.length; ++i) {
+      results[validOpIndexes[i]] = null;
+    }
+    if (validationErrors.length > 0) {
+      if (options.throwOnValidationError) {
+        throw new MongooseBulkWriteError(
+          validationErrors,
+          results,
+          res,
+          'bulkWrite'
+        );
+      } else {
+        res.mongoose = res.mongoose || {};
+        res.mongoose.validationErrors = validationErrors;
+        res.mongoose.results = results;
+      }
+    }
+  }
+
+  await new Promise((resolve, reject) => {
+    this.hooks.execPost('bulkWrite', this, [res], (err) => {
+      if (err != null) {
+        return reject(err);
+      }
+      resolve();
+    });
   });
+
+  return res;
 };
 
 /**
@@ -3830,6 +3896,7 @@ Model.buildBulkWriteOperations = function buildBulkWriteOperations(documents, op
  * @param {Object|String|String[]} [projection] optional projection containing which fields should be selected for this document
  * @param {Object} [options] optional options
  * @param {Boolean} [options.setters=false] if true, apply schema setters when hydrating
+ * @param {Boolean} [options.hydratedPopulatedDocs=false] if true, populates the docs if passing pre-populated data
  * @return {Document} document instance
  * @api public
  */
@@ -3843,7 +3910,6 @@ Model.hydrate = function(obj, projection, options) {
     }
     obj = applyProjection(obj, projection);
   }
-
   const document = require('./queryHelpers').createModel(this, obj, projection);
   document.$init(obj, options);
   return document;
@@ -4774,7 +4840,7 @@ Model.compile = function compile(name, schema, collectionName, connection, base)
   Object.setPrototypeOf(model.Query.prototype, Query.prototype);
   model.Query.base = Query.base;
   model.Query.prototype.constructor = Query;
-  applyQueryMiddleware(model.Query, model);
+  model._applyQueryMiddleware();
   applyQueryMethods(model, schema.query);
 
   return model;
@@ -4861,6 +4927,35 @@ Model.__subclass = function subclass(conn, schema, collection) {
   return Model;
 };
 
+/**
+ * Apply changes made to this model's schema after this model was compiled.
+ * By default, adding virtuals and other properties to a schema after the model is compiled does nothing.
+ * Call this function to apply virtuals and properties that were added later.
+ *
+ * #### Example:
+ *
+ *     const schema = new mongoose.Schema({ field: String });
+ *     const TestModel = mongoose.model('Test', schema);
+ *     TestModel.schema.virtual('myVirtual').get(function() {
+ *       return this.field + ' from myVirtual';
+ *     });
+ *     const doc = new TestModel({ field: 'Hello' });
+ *     doc.myVirtual; // undefined
+ *
+ *     TestModel.recompileSchema();
+ *     doc.myVirtual; // 'Hello from myVirtual'
+ *
+ * @return {undefined}
+ * @api public
+ * @memberOf Model
+ * @static
+ * @method recompileSchema
+ */
+
+Model.recompileSchema = function recompileSchema() {
+  this.prototype.$__setSchema(this.schema);
+};
+
 /**
  * Helper for console.log. Given a model named 'MyModel', returns the string
  * `'Model { MyModel }'`.
@@ -4883,6 +4978,41 @@ if (util.inspect.custom) {
   Model[util.inspect.custom] = Model.inspect;
 }
 
+/*!
+ * Applies query middleware from this model's schema to this model's
+ * Query constructor.
+ */
+
+Model._applyQueryMiddleware = function _applyQueryMiddleware() {
+  const Query = this.Query;
+  const queryMiddleware = this.schema.s.hooks.filter(hook => {
+    const contexts = _getContexts(hook);
+    if (hook.name === 'validate') {
+      return !!contexts.query;
+    }
+    if (hook.name === 'deleteOne' || hook.name === 'updateOne') {
+      return !!contexts.query || Object.keys(contexts).length === 0;
+    }
+    if (hook.query != null || hook.document != null) {
+      return !!hook.query;
+    }
+    return true;
+  });
+
+  Query.prototype._queryMiddleware = queryMiddleware;
+};
+
+function _getContexts(hook) {
+  const ret = {};
+  if (hook.hasOwnProperty('query')) {
+    ret.query = hook.query;
+  }
+  if (hook.hasOwnProperty('document')) {
+    ret.document = hook.document;
+  }
+  return ret;
+}
+
 /*!
  * Module exports.
  */

package/lib/options.js

@@ -11,5 +11,6 @@ exports.internalToObjectOptions = {
   _skipDepopulateTopLevel: true,
   depopulate: true,
   flattenDecimals: false,
-  useProjection: false
+  useProjection: false,
+  versionKey: true
 };

package/lib/plugins/trackTransaction.js

@@ -85,7 +85,7 @@ function mergeAtomics(destination, source) {
     destination.$addToSet = (destination.$addToSet || []).concat(source.$addToSet);
   }
   if (source.$set != null) {
-    destination.$set = Object.assign(destination.$set || {}, source.$set);
+    destination.$set = Array.isArray(source.$set) ? [...source.$set] : Object.assign({}, source.$set);
   }
 
   return destination;