@depup/mongoose 9.4.1-depup.0 → 9.8.0-depup.0

package/lib/helpers/populate/splitPopulateQuery.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const createPopulateQueryFilter = require('./createPopulateQueryFilter');
+const get = require('../get');
+const utils = require('../../utils');
+
+module.exports = splitPopulateQuery;
+
+/*!
+ * If a single populate query would have more than this many elements in its `$in` filter,
+ * Mongoose splits the populate into a separate query per document to avoid going over
+ * MongoDB's 16 MB BSON size limit on queries. Overwritable for testing purposes. See gh-5890.
+ */
+
+splitPopulateQuery.maxInFilterLength = 50000;
+
+/*!
+ * Split a populate models-map entry into a separate query per document if either:
+ *
+ * 1. The `perDocumentLimit` option is set, so each document needs its own query with its
+ *    own `limit` (gh-7318), or
+ * 2. A single populate query for `mod` would have too many elements in its `$in` filter
+ *    (gh-5890). With multiple foreign fields, `createPopulateQueryFilter()` repeats the ids
+ *    under `$or` once per foreign field, so the threshold counts one copy of `ids` per
+ *    foreign field.
+ *
+ * Returns a list of `[mod, match, select, assignmentOpts]` params, one per document, for
+ * `_execPopulateQuery()`. Returns `null` if the populate query doesn't need to be split.
+ * A `null` `match` means the document has no ids to query: `_execPopulateQuery()` skips
+ * executing a query, and `_assign()` just sets the document's populated path to the
+ * default value.
+ *
+ * Splitting on document boundaries means each document's populated value is the result of
+ * exactly one query, so split entries can typically be assigned from only their own query's
+ * results (`_assignFromOwnResults`) rather than scanning every populate query's results.
+ * refPath is the exception: a single document's array can contain ids for multiple models,
+ * so assigning refPath populate results relies on every query's results being available for
+ * every document. refPath entries are therefore only split when `perDocumentLimit` requires
+ * it, not to keep the `$in` filter small. A single document whose ids alone overflow the
+ * BSON size limit cannot be split.
+ */
+
+function splitPopulateQuery(mod, ids, select, assignmentOpts) {
+  if (mod.docs.length <= 1) {
+    return null;
+  }
+  const perDocumentLimit = mod.options.perDocumentLimit == null ?
+    get(mod.options, 'options.perDocumentLimit', null) :
+    mod.options.perDocumentLimit;
+  const numInFilterElements = ids.length * mod.foreignField.size;
+  if (perDocumentLimit == null && (numInFilterElements <= splitPopulateQuery.maxInFilterLength || mod.isRefPath)) {
+    return null;
+  }
+
+  return mod.docs.map((doc, i) => {
+    const subMod = {
+      ...mod,
+      docs: [doc],
+      ids: [mod.ids[i]],
+      allIds: [mod.allIds[i]],
+      unpopulatedValues: [mod.unpopulatedValues[i]],
+      match: Array.isArray(mod.match) ? [mod.match[i]] : mod.match,
+      _assignFromOwnResults: !mod.isRefPath
+    };
+    let subIds = utils.array.flatten(subMod.ids, flatten);
+    subIds = utils.array.unique(subIds);
+    const match = subIds.length === 0 || subIds.every(utils.isNullOrUndefined) ?
+      null :
+      createPopulateQueryFilter(subIds, subMod.match, subMod.foreignField, subMod.model, subMod.options.skipInvalidIds);
+    return [subMod, match, select, assignmentOpts];
+  });
+}
+
+/*!
+ * ignore
+ */
+
+function flatten(item) {
+  // no need to include undefined values in our query
+  return undefined !== item;
+}

package/lib/helpers/query/castUpdate.js

@@ -98,6 +98,10 @@ module.exports = function castUpdate(schema, obj, options, context, filter) {
     moveImmutableProperties(schema, obj, context);
   }
 
+  if (obj?.$__ && typeof obj.toObject === 'function') {
+    obj = obj.toObject(internalToObjectOptions);
+  }
+
   const ops = Object.keys(obj);
   let i = ops.length;
   const ret = {};

package/lib/helpers/schema/getKeysInSchemaOrder.js

@@ -3,25 +3,22 @@
 const get = require('../get');
 
 module.exports = function getKeysInSchemaOrder(schema, val, path) {
+  const valKeys = Object.keys(val);
+  if (valKeys.length <= 1) {
+    return valKeys;
+  }
+
   const schemaKeys = path != null ? Object.keys(get(schema.tree, path, {})) : Object.keys(schema.tree);
-  const valKeys = new Set(Object.keys(val));
+  const remaining = new Set(valKeys);
 
-  let keys;
-  if (valKeys.size > 1) {
-    keys = new Set();
-    for (const key of schemaKeys) {
-      if (valKeys.has(key)) {
-        keys.add(key);
-      }
+  const keys = [];
+  for (const key of schemaKeys) {
+    if (remaining.delete(key)) {
+      keys.push(key);
     }
-    for (const key of valKeys) {
-      if (!keys.has(key)) {
-        keys.add(key);
-      }
-    }
-    keys = Array.from(keys);
-  } else {
-    keys = Array.from(valKeys);
+  }
+  for (const key of remaining) {
+    keys.push(key);
   }
 
   return keys;

package/lib/helpers/update/applyTimestampsToUpdate.js

@@ -82,7 +82,9 @@ function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, optio
 
   if (!skipCreatedAt && createdAt) {
     const overwriteImmutable = get(options, 'overwriteImmutable', false);
-    const hasUserCreatedAt = currentUpdate[createdAt] != null || currentUpdate.$set?.[createdAt] != null;
+    const hasUserCreatedAt = currentUpdate[createdAt] != null
+      || currentUpdate.$set?.[createdAt] != null
+      || currentUpdate.$setOnInsert?.[createdAt] != null;
 
     // If overwriteImmutable is true and user provided createdAt, keep their value
     if (overwriteImmutable && hasUserCreatedAt) {
@@ -91,7 +93,7 @@ function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, optio
         updates.$set[createdAt] = currentUpdate[createdAt];
         delete currentUpdate[createdAt];
       }
-      // User's value is already in $set, nothing more to do
+      // User's value is already in $set or $setOnInsert, nothing more to do
     } else {
       if (currentUpdate[createdAt]) {
         delete currentUpdate[createdAt];

package/lib/model.js

@@ -7,6 +7,10 @@
 const Aggregate = require('./aggregate');
 const ChangeStream = require('./cursor/changeStream');
 const Document = require('./document');
+const { createTracedChannel } = require('./tracing');
+const { trace: traceSave } = createTracedChannel('mongoose:model:save');
+const { trace: traceInsertMany } = createTracedChannel('mongoose:model:insertMany');
+const { trace: traceBulkWrite } = createTracedChannel('mongoose:model:bulkWrite');
 const DocumentNotFoundError = require('./error/notFound');
 const EventEmitter = require('events').EventEmitter;
 const Kareem = require('kareem');
@@ -37,6 +41,7 @@ const applyVirtualsHelper = require('./helpers/document/applyVirtuals');
 const assignVals = require('./helpers/populate/assignVals');
 const castBulkWrite = require('./helpers/model/castBulkWrite');
 const clone = require('./helpers/clone');
+const convertErrorToStandardSchemaIssues = require('./standardSchema/convertErrorToIssues');
 const createPopulateQueryFilter = require('./helpers/populate/createPopulateQueryFilter');
 const decorateUpdateWithVersionKey = require('./helpers/update/decorateUpdateWithVersionKey');
 const getDefaultBulkwriteResult = require('./helpers/getDefaultBulkwriteResult');
@@ -66,6 +71,7 @@ const prepareDiscriminatorPipeline = require('./helpers/aggregate/prepareDiscrim
 const pushNestedArrayPaths = require('./helpers/model/pushNestedArrayPaths');
 const removeDeselectedForeignField = require('./helpers/populate/removeDeselectedForeignField');
 const setDottedPath = require('./helpers/path/setDottedPath');
+const splitPopulateQuery = require('./helpers/populate/splitPopulateQuery');
 const { buildMiddlewareFilter } = require('./helpers/buildMiddlewareFilter');
 const util = require('util');
 const utils = require('./utils');
@@ -663,19 +669,29 @@ Model.prototype.save = async function save(options) {
 
   this.$__.saveOptions = options;
 
-  try {
-    await this.$__save(options);
-  } catch (error) {
-    this.$__handleReject(error);
-    throw error;
-  } finally {
-    this.$__.saving = null;
-    this.$__.saveOptions = null;
-    this.$__.$versionError = null;
-    this.$op = null;
-  }
-
-  return this;
+  const _this = this;
+  return traceSave(async function maybeTracedSave() {
+    try {
+      await _this.$__save(options);
+    } catch (error) {
+      _this.$__handleReject(error);
+      throw error;
+    } finally {
+      _this.$__.saving = null;
+      _this.$__.saveOptions = null;
+      _this.$__.$versionError = null;
+      _this.$op = null;
+    }
+
+    return _this;
+  }, () => ({
+    operation: 'save',
+    collection: _this.constructor.collection.name,
+    database: _this.constructor.db?.name,
+    serverAddress: _this.constructor.db?.host,
+    serverPort: _this.constructor.db?.port,
+    args: { options }
+  }));
 };
 
 Model.prototype.$save = Model.prototype.save;
@@ -2325,7 +2341,7 @@ Model.where = function where(path, val) {
  *
  * Sometimes you need to query for things in mongodb using a JavaScript expression. You can do so via `find({ $where: javascript })`, or you can use the mongoose shortcut method $where via a Query chain or from your mongoose Model.
  *
- *     Blog.$where('this.username.indexOf("val") !== -1').exec(function (err, docs) {});
+ *     const result = await Blog.$where('this.username.indexOf("val") !== -1').exec();
  *
  * @param {string|Function} argument is a javascript string or anonymous function
  * @method $where
@@ -2418,13 +2434,6 @@ Model.findOneAndUpdate = function(conditions, update, options) {
     fields = options.fields || options.projection;
   }
 
-  update = clone(update, {
-    depopulate: true,
-    _isNested: true
-  });
-
-  decorateUpdateWithVersionKey(update, options, this.schema.options.versionKey);
-
   const mq = new this.Query({}, {}, this, this.$__collection);
   mq.select(fields);
 
@@ -2864,6 +2873,10 @@ Model.create = async function create(doc, options) {
 Model.insertOne = async function insertOne(doc, options) {
   _checkContext(this, 'insertOne');
 
+  if (doc == null || typeof doc !== 'object') {
+    throw new ObjectParameterError(doc, 'doc', 'insertOne');
+  }
+
   const discriminatorKey = this.schema.options.discriminatorKey;
   const Model = this.discriminators && doc[discriminatorKey] != null ?
     this.discriminators[doc[discriminatorKey]] || getDiscriminatorByValue(this.discriminators, doc[discriminatorKey]) :
@@ -3018,6 +3031,18 @@ Model.insertMany = async function insertMany(arr, options) {
     throw new MongooseError('Model.insertMany() no longer accepts a callback');
   }
 
+  const ThisModel = this;
+  return traceInsertMany(function maybeTracedInsertMany() { return _insertMany.call(ThisModel, arr, options); }, () => ({
+    operation: 'insertMany',
+    collection: ThisModel.collection.name,
+    database: ThisModel.db?.name,
+    serverAddress: ThisModel.db?.host,
+    serverPort: ThisModel.db?.port,
+    args: { docs: arr, options }
+  }));
+};
+
+async function _insertMany(arr, options) {
   options = options || {};
   const preFilter = buildMiddlewareFilter(options, 'pre');
   const postFilter = buildMiddlewareFilter(options, 'post');
@@ -3253,7 +3278,7 @@ Model.insertMany = async function insertMany(arr, options) {
 
   const [result] = await this._middleware.execPost('insertMany', this, [docAttributes], { filter: postFilter });
   return result;
-};
+}
 
 /*!
  * ignore
@@ -3381,6 +3406,19 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
       typeof arguments[2] === 'function') {
     throw new MongooseError('Model.bulkWrite() no longer accepts a callback');
   }
+
+  const ThisModel = this;
+  return traceBulkWrite(function maybeTracedBulkWrite() { return _bulkWrite.call(ThisModel, ops, options); }, () => ({
+    operation: 'bulkWrite',
+    collection: ThisModel.collection.name,
+    database: ThisModel.db?.name,
+    serverAddress: ThisModel.db?.host,
+    serverPort: ThisModel.db?.port,
+    args: { ops, options }
+  }));
+};
+
+async function _bulkWrite(ops, options) {
   options = options || {};
   const preFilter = buildMiddlewareFilter(options, 'pre');
   const postFilter = buildMiddlewareFilter(options, 'post');
@@ -3519,7 +3557,7 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
   await this.hooks.execPost('bulkWrite', this, [res], { filter: postFilter });
 
   return res;
-};
+}
 
 /**
  * Takes an array of documents, gets the changes and inserts/updates documents in the database
@@ -3618,12 +3656,16 @@ async function buildPreSavePromise(document, options) {
 }
 
 async function handleSuccessfulWrite(document, options) {
-  if (document.$isNew) {
+  const wasNew = document.$isNew;
+  if (wasNew) {
     _setIsNew(document, false);
   }
 
   document.$__reset();
-  document._applyVersionIncrement();
+  // version key gets initialized to 0 when inserting a new document so avoid incrementing version key here
+  if (!wasNew) {
+    document._applyVersionIncrement();
+  }
   const postFilter = buildMiddlewareFilter(options, 'post');
   return document.schema.s.hooks.execPost('save', document, [document], { filter: postFilter });
 }
@@ -3864,7 +3906,7 @@ Model.buildBulkWriteOperations = function buildBulkWriteOperations(documents, op
         throw new MongooseError(`documents.${i} was not a mongoose document, documents must be an array of mongoose documents (instanceof mongoose.Document).`);
       }
       if (options.validateBeforeSave == null || options.validateBeforeSave) {
-        const err = document.validateSync();
+        const err = document.$__validateSync();
         if (err != null) {
           throw err;
         }
@@ -3873,6 +3915,12 @@ Model.buildBulkWriteOperations = function buildBulkWriteOperations(documents, op
 
     const isANewDocument = document.isNew;
     if (isANewDocument) {
+      // Like `$__version()` on insert, initialize the version key so
+      // inserted documents get the same shape as `save()` gives them
+      const versionKey = document.$__schema.options.versionKey;
+      if (versionKey) {
+        document.$__setValue(versionKey, 0);
+      }
       const writeOperation = { insertOne: { document } };
       utils.injectTimestampsOption(writeOperation.insertOne, options.timestamps);
       return writeOperation;
@@ -4191,13 +4239,24 @@ Model.aggregate = function aggregate(pipeline, options) {
  *       age: { type: Number, required: true }
  *     });
  *
+ *     // Succeeds
+ *     await Model.validate({ name: 'John Smith', age: 31 });
+ *
  *     try {
- *       await Model.validate({ name: null }, ['name'])
+ *       await Model.validate({ name: null });
  *     } catch (err) {
  *       err instanceof mongoose.Error.ValidationError; // true
  *       Object.keys(err.errors); // ['name']
  *     }
  *
+ * Note: the `pathsToSkip` and `pathsToValidate` options **only** apply to validation, not
+ * casting. This function will still throw an error for values that cannot be casted to the
+ * schema-specified type. Remove any paths you do not want to cast.
+ *
+ *     // The following will still throw an error because the value of `age` cannot be
+ *     // casted to a number. Remove the `age` property before calling `validate()`.
+ *     await Model.validate({ name: 'Test', age: 'not a number' }, ['name']);
+ *
  * @param {object} obj
  * @param {object|Array|string} pathsOrOptions
  * @param {object} [context]
@@ -4302,6 +4361,33 @@ Model.validate = async function validate(obj, pathsOrOptions, context) {
   return obj;
 };
 
+/**
+ * Standard Schema adapter for this model.
+ * Calls [`Model.validate()`](https://mongoosejs.com/docs/api/model.html#Model.validate()) internally with the provided `libraryOptions`
+ * to cast and validate the given value.
+ *
+ * @api public
+ * @property ~standard
+ * @memberOf Model
+ * @static
+ */
+
+Object.defineProperty(Model, '~standard', {
+  configurable: true,
+  get() {
+    return {
+      version: 1,
+      vendor: 'mongoose',
+      validate: (value, options) => {
+        return this.validate(value, options?.libraryOptions).then(
+          value => ({ value }),
+          error => ({ issues: convertErrorToStandardSchemaIssues(error) })
+        );
+      }
+    };
+  }
+});
+
 /**
  * Populates document references.
  *
@@ -4468,7 +4554,6 @@ async function _populatePath(model, docs, populateOptions) {
       mod.foreignField.clear();
       mod.foreignField.add(populateOptions.foreignField);
     }
-    const match = createPopulateQueryFilter(ids, mod.match, mod.foreignField, mod.model, mod.options.skipInvalidIds);
     if (assignmentOpts.excludeId) {
       // override the exclusion from the query so we can use the _id
       // for document matching during assignment. we'll delete the
@@ -4489,6 +4574,17 @@ async function _populatePath(model, docs, populateOptions) {
     } else if (mod.options.limit != null) {
       assignmentOpts.originalLimit = mod.options.limit;
     }
+
+    // Execute a separate query per document if `perDocumentLimit` is set (gh-7318), or if
+    // there are so many ids that the `$in` filter may overflow MongoDB's 16 MB BSON size
+    // limit on queries (gh-5890).
+    const splitParams = splitPopulateQuery(mod, ids, select, assignmentOpts);
+    if (splitParams != null) {
+      params.push(...splitParams);
+      continue;
+    }
+
+    const match = createPopulateQueryFilter(ids, mod.match, mod.foreignField, mod.model, mod.options.skipInvalidIds);
     params.push([mod, match, select, assignmentOpts]);
   }
   if (!hasOne) {
@@ -4509,6 +4605,9 @@ async function _populatePath(model, docs, populateOptions) {
 
   // Track deferred populates per-param (per model) to avoid mixing them
   const deferredPopulatesPerParam = new Map();
+  // Query results per param. Batches that were split off of a large populate query (gh-5890)
+  // are assigned from only their own query's results rather than the combined `vals`.
+  const valsByParam = [];
 
   if (populateOptions.ordered) {
     // Populate in series, primarily for transactions because MongoDB doesn't support multiple operations on
@@ -4516,7 +4615,10 @@ async function _populatePath(model, docs, populateOptions) {
     for (let i = 0; i < params.length; i++) {
       const arr = params[i];
       const { docs, deferredPopulates } = await _execPopulateQuery.apply(null, arr);
-      vals = vals.concat(docs);
+      valsByParam.push(docs);
+      if (!arr[0]._assignFromOwnResults) {
+        vals = vals.concat(docs);
+      }
       if (deferredPopulates.length > 0) {
         deferredPopulatesPerParam.set(i, deferredPopulates);
       }
@@ -4531,7 +4633,10 @@ async function _populatePath(model, docs, populateOptions) {
     const results = await Promise.all(promises);
     for (let i = 0; i < results.length; i++) {
       const { docs, deferredPopulates } = results[i];
-      vals = vals.concat(docs);
+      valsByParam.push(docs);
+      if (!params[i][0]._assignFromOwnResults) {
+        vals = vals.concat(docs);
+      }
       if (deferredPopulates.length > 0) {
         deferredPopulatesPerParam.set(i, deferredPopulates);
       }
@@ -4539,13 +4644,15 @@ async function _populatePath(model, docs, populateOptions) {
   }
 
 
-  for (const arr of params) {
+  for (let i = 0; i < params.length; i++) {
+    const arr = params[i];
     const mod = arr[0];
     const assignmentOpts = arr[3];
-    for (const val of vals) {
+    const valsForMod = mod._assignFromOwnResults ? valsByParam[i] : vals;
+    for (const val of valsForMod) {
       mod.options._childDocs.push(val);
     }
-    _assign(model, vals, mod, assignmentOpts);
+    _assign(model, valsForMod, mod, assignmentOpts);
   }
 
   // Handle deferred populate for cases with per-document match functions.
@@ -4585,13 +4692,15 @@ async function _populatePath(model, docs, populateOptions) {
     }
   }
 
-  for (const arr of params) {
-    removeDeselectedForeignField(arr[0].foreignField, arr[0].options, vals);
+  for (let i = 0; i < params.length; i++) {
+    const mod = params[i][0];
+    removeDeselectedForeignField(mod.foreignField, mod.options, mod._assignFromOwnResults ? valsByParam[i] : vals);
   }
-  for (const arr of params) {
-    const mod = arr[0];
+  for (let i = 0; i < params.length; i++) {
+    const mod = params[i][0];
     if (mod.options?.options?._leanTransform) {
-      for (const doc of vals) {
+      const valsForMod = mod._assignFromOwnResults ? valsByParam[i] : vals;
+      for (const doc of valsForMod) {
         mod.options.options._leanTransform(doc);
       }
     }
@@ -4603,6 +4712,12 @@ async function _populatePath(model, docs, populateOptions) {
  */
 
 function _execPopulateQuery(mod, match, select) {
+  // `null` match means `mod`'s documents have no ids to query, possible if a large populate
+  // was split into a query per document (gh-5890). Skip executing a query: `_assign()` still
+  // sets the documents' populated paths to the appropriate default value.
+  if (match == null) {
+    return Promise.resolve({ docs: [], deferredPopulates: [] });
+  }
   let subPopulate = clone(mod.options.populate);
   const queryOptions = {};
   if (mod.options.skip !== undefined) {

package/lib/mongoose.js

@@ -228,7 +228,7 @@ Mongoose.prototype.setDriver = function setDriver(driver) {
  * - `bufferCommands`: enable/disable mongoose's buffering mechanism for all connections and models
  * - `bufferTimeoutMS`: If bufferCommands is on, this option sets the maximum amount of time Mongoose buffering will wait before throwing an error. If not specified, Mongoose will use 10000 (10 seconds).
  * - `cloneSchemas`: `false` by default. Set to `true` to `clone()` all schemas before compiling into a model.
- * - `debug`: If `true`, prints the operations mongoose sends to MongoDB to the console. If a writable stream is passed, it will log to that stream, without colorization. If a callback function is passed, it will receive the collection name, the method name, then all arguments passed to the method. For example, if you wanted to replicate the default logging, you could output from the callback `Mongoose: ${collectionName}.${methodName}(${methodArgs.join(', ')})`.
+ * - `debug`: If `true`, prints the operations mongoose sends to MongoDB to the console. If an object is passed, you can set `color`, `shell`, and `timestamp` options. If `timestamp` is `true`, Mongoose prefixes console debug output with an ISO timestamp in brackets. If a writable stream is passed, it will log to that stream, without colorization. If a callback function is passed, it will receive the collection name, the method name, then all arguments passed to the method. For example, if you wanted to replicate the default logging, you could output from the callback `Mongoose: ${collectionName}.${methodName}(${methodArgs.join(', ')})`.
  * - `id`: If `true`, adds a `id` virtual to all schemas unless overwritten on a per-schema basis.
  * - `maxTimeMS`: If set, attaches [maxTimeMS](https://www.mongodb.com/docs/manual/reference/operator/meta/maxTimeMS/) to every query
  * - `objectIdGetter`: `true` by default. Mongoose adds a getter to MongoDB ObjectId's called `_id` that returns `this` for convenience with populate. Set this to false to remove the getter.
@@ -398,8 +398,8 @@ Mongoose.prototype.get = Mongoose.prototype.set;
  * @param {string} [options.user] username for authentication, equivalent to `options.auth.username`. Maintained for backwards compatibility.
  * @param {string} [options.pass] password for authentication, equivalent to `options.auth.password`. Maintained for backwards compatibility.
  * @param {boolean} [options.autoIndex=true] Mongoose-specific option. Set to false to disable automatic index creation for all models associated with this connection.
- * @param {number} [options.maxPoolSize=5] The maximum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](https://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
- * @param {number} [options.minPoolSize=1] The minimum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](https://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
+ * @param {number} [options.maxPoolSize=100] The maximum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](https://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
+ * @param {number} [options.minPoolSize=0] The minimum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](https://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
  * @param {number} [options.socketTimeoutMS=0] How long the MongoDB driver will wait before killing a socket due to inactivity _after initial connection_. Defaults to 0, which means Node.js will not time out the socket due to inactivity. A socket may be inactive because of either no activity or a long-running operation. This option is passed to [Node.js `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback) after the MongoDB driver successfully completes.
  * @param {number} [options.family=0] Passed transparently to [Node.js' `dns.lookup()`](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback) function. May be either `0`, `4`, or `6`. `4` means use IPv4 only, `6` means use IPv6 only, `0` means try both.
  * @return {Connection} the created Connection object. Connections are not thenable, so you can't do `await mongoose.createConnection()`. To await use `mongoose.createConnection(uri).asPromise()` instead.

package/lib/options/schemaTypeOptions.js

@@ -94,6 +94,20 @@ Object.defineProperty(SchemaTypeOptions.prototype, 'cast', opts);
 
 Object.defineProperty(SchemaTypeOptions.prototype, 'required', opts);
 
+/**
+ * Controls whether this path may be set to `null`. By default, Mongoose allows
+ * `null` for non-required paths. Set `allowNull: false` to allow `undefined`
+ * but disallow `null`.
+ *
+ * @api public
+ * @property allowNull
+ * @memberOf SchemaTypeOptions
+ * @type {boolean}
+ * @instance
+ */
+
+Object.defineProperty(SchemaTypeOptions.prototype, 'allowNull', opts);
+
 /**
  * The default value for this path. If a function, Mongoose executes the function
  * and uses the return value as the default.

package/lib/plugins/saveSubdocs.js

@@ -16,7 +16,10 @@ module.exports = function saveSubdocs(schema) {
 };
 
 
-async function saveSubdocsPreSave() {
+// These hooks are deliberately not `async` so that they don't allocate a
+// promise and force an extra microtask hop on every `save()` when there are
+// no subdocuments. kareem only awaits hooks that return a promise.
+function saveSubdocsPreSave() {
   if (this.$isSubdocument) {
     return;
   }
@@ -28,15 +31,15 @@ async function saveSubdocsPreSave() {
   }
 
   const options = this.$__.saveOptions;
-  await Promise.all(subdocs.map(subdoc => subdoc._execDocumentPreHooks('save', options, [options])));
-
-  // Invalidate subdocs cache because subdoc pre hooks can add new subdocuments
-  if (this.$__.saveOptions) {
-    this.$__.saveOptions.__subdocs = null;
-  }
+  return Promise.all(subdocs.map(subdoc => subdoc._execDocumentPreHooks('save', options, [options]))).then(() => {
+    // Invalidate subdocs cache because subdoc pre hooks can add new subdocuments
+    if (this.$__.saveOptions) {
+      this.$__.saveOptions.__subdocs = null;
+    }
+  });
 }
 
-async function saveSubdocsPostSave() {
+function saveSubdocsPostSave() {
   if (this.$isSubdocument) {
     return;
   }
@@ -53,10 +56,10 @@ async function saveSubdocsPostSave() {
     promises.push(subdoc._execDocumentPostHooks('save', options));
   }
 
-  await Promise.all(promises);
+  return Promise.all(promises);
 }
 
-async function saveSubdocsPreDeleteOne() {
+function saveSubdocsPreDeleteOne() {
   const removedSubdocs = this.$__.removedSubdocs;
   if (!removedSubdocs?.length) {
     return;
@@ -68,10 +71,10 @@ async function saveSubdocsPreDeleteOne() {
     promises.push(subdoc._execDocumentPreHooks('deleteOne', options));
   }
 
-  await Promise.all(promises);
+  return Promise.all(promises);
 }
 
-async function saveSubdocsPostDeleteOne() {
+function saveSubdocsPostDeleteOne() {
   const removedSubdocs = this.$__.removedSubdocs;
   if (!removedSubdocs?.length) {
     return;
@@ -84,7 +87,7 @@ async function saveSubdocsPostDeleteOne() {
   }
 
   this.$__.removedSubdocs = null;
-  await Promise.all(promises);
+  return Promise.all(promises);
 }