mongoose 6.3.7 → 6.4.0

package/lib/index.js

@@ -8,6 +8,7 @@ require('./driver').set(require('./drivers/node-mongodb-native'));
 
 const Document = require('./document');
 const EventEmitter = require('events').EventEmitter;
+const Kareem = require('kareem');
 const Schema = require('./schema');
 const SchemaType = require('./schematype');
 const SchemaTypes = require('./schema/index');
@@ -35,6 +36,7 @@ const shardingPlugin = require('./plugins/sharding');
 const trusted = require('./helpers/query/trusted').trusted;
 const sanitizeFilter = require('./helpers/query/sanitizeFilter');
 const isBsonType = require('./helpers/isBsonType');
+const MongooseError = require('./error/mongooseError');
 
 const defaultMongooseSymbol = Symbol.for('mongoose:default');
 
@@ -62,6 +64,7 @@ function Mongoose(options) {
   this.connections = [];
   this.models = {};
   this.events = new EventEmitter();
+  this.__driver = driver.get();
   // default global options
   this.options = Object.assign({
     pluralization: true,
@@ -135,6 +138,7 @@ Mongoose.prototype.ConnectionStates = STATES;
  * uses to communicate with the database. A driver is a Mongoose-specific interface that defines functions
  * like `find()`.
  *
+ * @deprecated
  * @memberOf Mongoose
  * @property driver
  * @api public
@@ -142,6 +146,36 @@ Mongoose.prototype.ConnectionStates = STATES;
 
 Mongoose.prototype.driver = driver;
 
+/**
+ * Overwrites the current driver used by this Mongoose instance. A driver is a
+ * Mongoose-specific interface that defines functions like `find()`.
+ *
+ * @memberOf Mongoose
+ * @method setDriver
+ * @api public
+ */
+
+Mongoose.prototype.setDriver = function setDriver(driver) {
+  const _mongoose = this instanceof Mongoose ? this : mongoose;
+
+  if (_mongoose.__driver === driver) {
+    return _mongoose;
+  }
+
+  const openConnection = _mongoose.connections && _mongoose.connections.find(conn => conn.readyState !== STATES.disconnected);
+  if (openConnection) {
+    const msg = 'Cannot modify Mongoose driver if a connection is already open. ' +
+      'Call `mongoose.disconnect()` before modifying the driver';
+    throw new MongooseError(msg);
+  }
+  _mongoose.__driver = driver;
+
+  const Connection = driver.getConnection();
+  _mongoose.connections = [new Connection(_mongoose)];
+
+  return _mongoose;
+};
+
 /**
  * Sets mongoose options
  *
@@ -154,23 +188,26 @@ Mongoose.prototype.driver = driver;
  *     mongoose.set('debug', function(collectionName, methodName, ...methodArgs) {}); // use custom function to log collection methods + arguments
  *
  * Currently supported options are:
+ * - 'applyPluginsToChildSchemas': `true` by default. Set to false to skip applying global plugins to child schemas
+ * - 'applyPluginsToDiscriminators': `false` by default. Set to true to apply global plugins to discriminator schemas. This typically isn't necessary because plugins are applied to the base schema and discriminators copy all middleware, methods, statics, and properties from the base schema.
+ * - 'autoCreate': Set to `true` to make Mongoose call [`Model.createCollection()`](/docs/api/model.html#model_Model.createCollection) automatically when you create a model with `mongoose.model()` or `conn.model()`. This is useful for testing transactions, change streams, and other features that require the collection to exist.
+ * - 'autoIndex': `true` by default. Set to false to disable automatic index creation for all models associated with this Mongoose instance.
  * - '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(', ')})`.
  * - 'returnOriginal': If `false`, changes the default `returnOriginal` option to `findOneAndUpdate()`, `findByIdAndUpdate`, and `findOneAndReplace()` to false. This is equivalent to setting the `new` option to `true` for `findOneAndX()` calls by default. Read our [`findOneAndUpdate()` tutorial](/docs/tutorials/findoneandupdate.html) for more information.
  * - 'bufferCommands': enable/disable mongoose's buffering mechanism for all connections and models
- * - 'cloneSchemas': false by default. Set to `true` to `clone()` all schemas before compiling into a model.
- * - 'applyPluginsToDiscriminators': false by default. Set to true to apply global plugins to discriminator schemas. This typically isn't necessary because plugins are applied to the base schema and discriminators copy all middleware, methods, statics, and properties from the base schema.
- * - 'applyPluginsToChildSchemas': true by default. Set to false to skip applying global plugins to child schemas
- * - '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.
- * - 'runValidators': false by default. Set to true to enable [update validators](/docs/validation.html#update-validators) for all validators by default.
- * - 'toObject': `{ transform: true, flattenDecimals: true }` by default. Overwrites default objects to [`toObject()`](/docs/api.html#document_Document-toObject)
- * - 'toJSON': `{ transform: true, flattenDecimals: true }` by default. Overwrites default objects to [`toJSON()`](/docs/api.html#document_Document-toJSON), for determining how Mongoose documents get serialized by `JSON.stringify()`
- * - 'strict': true by default, may be `false`, `true`, or `'throw'`. Sets the default strict mode for schemas.
- * - 'strictQuery': same value as 'strict' by default (`true`), may be `false`, `true`, or `'throw'`. Sets the default [strictQuery](/docs/guide.html#strictQuery) mode for schemas.
- * - 'selectPopulatedPaths': true by default. Set to false to opt out of Mongoose adding all fields that you `populate()` to your `select()`. The schema-level option `selectPopulatedPaths` overwrites this one.
+ * - '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 arugments 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(', ')})`.
+ * - 'timestamps.createdAt.immutable': `true` by default. If `false`, it will change the `createdAt` field to be [`immutable: false`](https://mongoosejs.com/docs/api/schematype.html#schematype_SchemaType-immutable) which means you can update the `createdAt`
  * - 'maxTimeMS': If set, attaches [maxTimeMS](https://docs.mongodb.com/manual/reference/operator/meta/maxTimeMS/) to every query
- * - 'autoIndex': true by default. Set to false to disable automatic index creation for all models associated with this Mongoose instance.
- * - 'autoCreate': Set to `true` to make Mongoose call [`Model.createCollection()`](/docs/api/model.html#model_Model.createCollection) automatically when you create a model with `mongoose.model()` or `conn.model()`. This is useful for testing transactions, change streams, and other features that require the collection to exist.
+ * - '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.
  * - 'overwriteModels': Set to `true` to default to overwriting models with the same name when calling `mongoose.model()`, as opposed to throwing an `OverwriteModelError`.
+ * - 'returnOriginal': If `false`, changes the default `returnOriginal` option to `findOneAndUpdate()`, `findByIdAndUpdate`, and `findOneAndReplace()` to false. This is equivalent to setting the `new` option to `true` for `findOneAndX()` calls by default. Read our [`findOneAndUpdate()` tutorial](/docs/tutorials/findoneandupdate.html) for more information.
+ * - 'runValidators': `false` by default. Set to true to enable [update validators](/docs/validation.html#update-validators) for all validators by default.
+ * - 'selectPopulatedPaths': `true` by default. Set to false to opt out of Mongoose adding all fields that you `populate()` to your `select()`. The schema-level option `selectPopulatedPaths` overwrites this one.
+ * - 'strict': `true` by default, may be `false`, `true`, or `'throw'`. Sets the default strict mode for schemas.
+ * - 'strictQuery': same value as 'strict' by default (`true`), may be `false`, `true`, or `'throw'`. Sets the default [strictQuery](/docs/guide.html#strictQuery) mode for schemas.
+ * - 'toJSON': `{ transform: true, flattenDecimals: true }` by default. Overwrites default objects to [`toJSON()`](/docs/api.html#document_Document-toJSON), for determining how Mongoose documents get serialized by `JSON.stringify()`
+ * - 'toObject': `{ transform: true, flattenDecimals: true }` by default. Overwrites default objects to [`toObject()`](/docs/api.html#document_Document-toObject)
  *
  * @param {String} key
  * @param {String|Function|Boolean} value
@@ -260,8 +297,6 @@ Mongoose.prototype.get = Mongoose.prototype.set;
  * @param {String} [options.user] username for authentication, equivalent to `options.auth.user`. 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.reconnectTries=30] If you're connected to a single server or mongos proxy (as opposed to a replica set), the MongoDB driver will try to reconnect every `reconnectInterval` milliseconds for `reconnectTries` times, and give up afterward. When the driver gives up, the mongoose connection emits a `reconnectFailed` event. This option does nothing for replica set connections.
- * @param {Number} [options.reconnectInterval=1000] See `reconnectTries` option above.
  * @param {Class} [options.promiseLibrary] Sets the [underlying driver's promise library](https://mongodb.github.io/node-mongodb-native/3.1/api/MongoClient.html).
  * @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).
@@ -275,7 +310,7 @@ Mongoose.prototype.get = Mongoose.prototype.set;
 Mongoose.prototype.createConnection = function(uri, options, callback) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
-  const Connection = driver.get().getConnection();
+  const Connection = _mongoose.__driver.getConnection();
   const conn = new Connection(_mongoose);
   if (typeof options === 'function') {
     callback = options;
@@ -323,8 +358,6 @@ Mongoose.prototype.createConnection = function(uri, options, callback) {
  * @param {Number} [options.serverSelectionTimeoutMS] If `useUnifiedTopology = true`, the MongoDB driver will try to find a server to send any given operation to, and keep retrying for `serverSelectionTimeoutMS` milliseconds before erroring out. If not set, the MongoDB driver defaults to using `30000` (30 seconds).
  * @param {Number} [options.heartbeatFrequencyMS] If `useUnifiedTopology = true`, the MongoDB driver sends a heartbeat every `heartbeatFrequencyMS` to check on the status of the connection. A heartbeat is subject to `serverSelectionTimeoutMS`, so the MongoDB driver will retry failed heartbeats for up to 30 seconds by default. Mongoose only emits a `'disconnected'` event after a heartbeat has failed, so you may want to decrease this setting to reduce the time between when your server goes down and when Mongoose emits `'disconnected'`. We recommend you do **not** set this setting below 1000, too many heartbeats can lead to performance degradation.
  * @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.reconnectTries=30] If you're connected to a single server or mongos proxy (as opposed to a replica set), the MongoDB driver will try to reconnect every `reconnectInterval` milliseconds for `reconnectTries` times, and give up afterward. When the driver gives up, the mongoose connection emits a `reconnectFailed` event. This option does nothing for replica set connections.
- * @param {Number} [options.reconnectInterval=1000] See `reconnectTries` option above.
  * @param {Class} [options.promiseLibrary] Sets the [underlying driver's promise library](https://mongodb.github.io/node-mongodb-native/3.1/api/MongoClient.html).
  * @param {Number} [options.connectTimeoutMS=30000] How long the MongoDB driver will wait before killing a socket due to inactivity _during initial connection_. Defaults to 30000. This option is passed transparently to [Node.js' `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback).
  * @param {Number} [options.socketTimeoutMS=30000] How long the MongoDB driver will wait before killing a socket due to inactivity _after initial connection_. A socket may be inactive because of either no activity or a long-running operation. This is set to `30000` by default, you should set this to 2-3x your longest running operation if you expect some of your database operations to run longer than 20 seconds. 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.
@@ -471,7 +504,6 @@ Mongoose.prototype.pluralize = function(fn) {
  */
 
 Mongoose.prototype.model = function(name, schema, collection, options) {
-
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
   if (typeof schema === 'string') {
@@ -688,7 +720,7 @@ Mongoose.prototype.__defineGetter__('connection', function() {
 });
 
 Mongoose.prototype.__defineSetter__('connection', function(v) {
-  if (v instanceof Connection) {
+  if (v instanceof this.__driver.getConnection()) {
     this.connections[0] = v;
     this.models = v.models;
   }
@@ -717,18 +749,6 @@ Mongoose.prototype.__defineSetter__('connection', function(v) {
 
 Mongoose.prototype.connections;
 
-/*!
- * Connection
- */
-
-const Connection = driver.get().getConnection();
-
-/*!
- * Collection
- */
-
-const Collection = driver.get().Collection;
-
 /**
  * The Mongoose Aggregate constructor
  *
@@ -745,7 +765,14 @@ Mongoose.prototype.Aggregate = Aggregate;
  * @api public
  */
 
-Mongoose.prototype.Collection = Collection;
+Object.defineProperty(Mongoose.prototype, 'Collection', {
+  get: function() {
+    return this.__driver.Collection;
+  },
+  set: function(Collection) {
+    this.__driver.Collection = Collection;
+  }
+});
 
 /**
  * The Mongoose [Connection](#connection_Connection) constructor
@@ -756,7 +783,18 @@ Mongoose.prototype.Collection = Collection;
  * @api public
  */
 
-Mongoose.prototype.Connection = Connection;
+Object.defineProperty(Mongoose.prototype, 'Connection', {
+  get: function() {
+    return this.__driver.getConnection();
+  },
+  set: function(Connection) {
+    if (Connection === this.__driver.getConnection()) {
+      return;
+    }
+
+    this.__driver.getConnection = () => Connection;
+  }
+});
 
 /**
  * The Mongoose version
@@ -1182,6 +1220,43 @@ Mongoose.prototype._promiseOrCallback = function(callback, fn, ee) {
   return promiseOrCallback(callback, fn, ee, this.Promise);
 };
 
+/**
+ * Use this function in `pre()` middleware to skip calling the wrapped function.
+ *
+ * ####Example:
+ *
+ *     schema.pre('save', function() {
+ *       // Will skip executing `save()`, but will execute post hooks as if
+ *       // `save()` had executed with the result `{ matchedCount: 0 }`
+ *       return mongoose.skipMiddlewareFunction({ matchedCount: 0 });
+ *     });
+ *
+ * @method skipMiddlewareFunction
+ * @param {any} result
+ * @api public
+ */
+
+Mongoose.prototype.skipMiddlewareFunction = Kareem.skipWrappedFunction;
+
+/**
+ * Use this function in `post()` middleware to replace the result
+ *
+ * ####Example:
+ *
+ *     schema.post('find', function(res) {
+ *       // Normally you have to modify `res` in place. But with
+ *       // `overwriteMiddlewarResult()`, you can make `find()` return a
+ *       // completely different value.
+ *       return mongoose.overwriteMiddlewareResult(res.filter(doc => !doc.isDeleted));
+ *     });
+ *
+ * @method overwriteMiddlewareResult
+ * @param {any} result
+ * @api public
+ */
+
+Mongoose.prototype.overwriteMiddlewareResult = Kareem.overwriteResult;
+
 /*!
  * The exports object is an instance of Mongoose.
  *

package/lib/model.js

@@ -4281,7 +4281,7 @@ Model.validate = function validate(obj, pathsToValidate, context, callback) {
 
     for (const path of paths) {
       const schemaType = schema.path(path);
-      if (!schemaType || !schemaType.$isMongooseArray) {
+      if (!schemaType || !schemaType.$isMongooseArray || schemaType.$isMongooseDocumentArray) {
         continue;
       }
 

package/lib/query.js

@@ -27,6 +27,7 @@ const immediate = require('./helpers/immediate');
 const isExclusive = require('./helpers/projection/isExclusive');
 const isInclusive = require('./helpers/projection/isInclusive');
 const isSubpath = require('./helpers/projection/isSubpath');
+const mpath = require('mpath');
 const mquery = require('mquery');
 const parseProjection = require('./helpers/projection/parseProjection');
 const removeUnusedArrayFilters = require('./helpers/update/removeUnusedArrayFilters');
@@ -2196,7 +2197,6 @@ function _castArrayFilters(query) {
  * @api private
  */
 Query.prototype._find = wrapThunk(function(callback) {
-
   this._castConditions();
 
   if (this.error() != null) {
@@ -2220,7 +2220,8 @@ Query.prototype._find = wrapThunk(function(callback) {
   // Separate options to pass down to `completeMany()` in case we need to
   // set a session on the document
   const completeManyOptions = Object.assign({}, {
-    session: this && this.options && this.options.session || null
+    session: this && this.options && this.options.session || null,
+    lean: mongooseOptions.lean || null
   });
 
   const cb = (err, docs) => {
@@ -2244,7 +2245,9 @@ Query.prototype._find = wrapThunk(function(callback) {
         });
       }
       return mongooseOptions.lean ?
-        callback(null, docs) :
+      // call _completeManyLean here?
+        _completeManyLean(_this.model.schema, docs, null, completeManyOptions, callback) :
+        // callback(null, docs) :
         completeMany(_this.model, docs, fields, userProvidedFields, completeManyOptions, callback);
     }
 
@@ -2418,6 +2421,9 @@ Query.prototype._completeOne = function(doc, res, callback) {
   const mongooseOptions = this._mongooseOptions;
   // `rawResult`
   const options = this.options;
+  if (!options.lean && mongooseOptions.lean) {
+    options.lean = mongooseOptions.lean;
+  }
 
   if (options.explain) {
     return callback(null, doc);
@@ -2431,7 +2437,7 @@ Query.prototype._completeOne = function(doc, res, callback) {
       }
     }
     return mongooseOptions.lean ?
-      _completeOneLean(doc, res, options, callback) :
+      _completeOneLean(model.schema, doc, null, res, options, callback) :
       completeOne(model, doc, res, options, projection, userProvidedFields,
         null, callback);
   }
@@ -2442,7 +2448,7 @@ Query.prototype._completeOne = function(doc, res, callback) {
       if (err != null) {
         return callback(err);
       }
-      _completeOneLean(doc, res, options, callback);
+      _completeOneLean(model.schema, doc, null, res, options, callback);
     });
   }
 
@@ -4009,13 +4015,62 @@ Query.prototype._findAndModify = function(type, callback) {
  * ignore
  */
 
-function _completeOneLean(doc, res, opts, callback) {
+function _completeOneLean(schema, doc, path, res, opts, callback) {
+  if (opts.lean && opts.lean.transform) {
+    for (let i = 0; i < schema.childSchemas.length; i++) {
+      const childPath = path ? path + '.' + schema.childSchemas[i].model.path : schema.childSchemas[i].model.path;
+      const _schema = schema.childSchemas[i].schema;
+      const obj = mpath.get(childPath, doc);
+      if (obj == null) {
+        continue;
+      }
+      if (Array.isArray(obj)) {
+        for (let i = 0; i < obj.length; i++) {
+          opts.lean.transform(obj[i]);
+        }
+      } else {
+        opts.lean.transform(obj);
+      }
+      _completeOneLean(_schema, obj, childPath, res, opts);
+    }
+    if (callback) {
+      return callback(null, doc);
+    } else {
+      return;
+    }
+  }
   if (opts.rawResult) {
     return callback(null, res);
   }
   return callback(null, doc);
 }
 
+/*!
+ * ignore
+ */
+
+function _completeManyLean(schema, docs, path, opts, callback) {
+  if (opts.lean && opts.lean.transform) {
+    for (let i = 0; i < schema.childSchemas.length; i++) {
+      const childPath = path ? path + '.' + schema.childSchemas[i].model.path : schema.childSchemas[i].model.path;
+      const _schema = schema.childSchemas[i].schema;
+      let doc = mpath.get(childPath, docs);
+      if (doc == null) {
+        continue;
+      }
+      doc = doc.flat();
+      for (let i = 0; i < doc.length; i++) {
+        opts.lean.transform(doc[i]);
+      }
+      _completeManyLean(_schema, doc, childPath, opts);
+    }
+  }
+
+  if (!callback) {
+    return;
+  }
+  return callback(null, docs);
+}
 /*!
  * Override mquery.prototype._mergeUpdate to handle mongoose objects in
  * updates.

package/lib/schema/SubdocumentPath.js

@@ -167,7 +167,7 @@ SubdocumentPath.prototype.cast = function(val, doc, init, priorVal, options) {
     }
     return obj;
   }, null);
-  options = priorVal != null ? Object.assign({}, options, { priorDoc: priorVal }) : options;
+  options = Object.assign({}, options, { priorDoc: priorVal });
   if (init) {
     subdoc = new Constructor(void 0, selected, doc);
     subdoc.$init(val);

package/lib/schema/documentarray.js

@@ -10,6 +10,7 @@ const EventEmitter = require('events').EventEmitter;
 const SchemaDocumentArrayOptions =
   require('../options/SchemaDocumentArrayOptions');
 const SchemaType = require('../schematype');
+const SubdocumentPath = require('./SubdocumentPath');
 const discriminator = require('../helpers/model/discriminator');
 const handleIdOption = require('../helpers/schema/handleIdOption');
 const handleSpreadDoc = require('../helpers/document/handleSpreadDoc');
@@ -75,6 +76,15 @@ function DocumentArrayPath(key, schema, options, schemaOptions) {
   this.$embeddedSchemaType.cast = function(value, doc, init) {
     return parentSchemaType.cast(value, doc, init)[0];
   };
+  this.$embeddedSchemaType.doValidate = function(value, fn, scope, options) {
+    const Constructor = getConstructor(this.caster, value);
+
+    if (value && !(value instanceof Constructor)) {
+      value = new Constructor(value, scope, null, null, options && options.index != null ? options.index : null);
+    }
+
+    return SubdocumentPath.prototype.doValidate.call(this, value, fn, scope, options);
+  };
   this.$embeddedSchemaType.$isMongooseDocumentArrayElement = true;
   this.$embeddedSchemaType.caster = this.Constructor;
   this.$embeddedSchemaType.schema = this.schema;
@@ -391,6 +401,8 @@ DocumentArrayPath.prototype.cast = function(value, doc, init, prev, options) {
   let selected;
   let subdoc;
 
+  options = options || {};
+
   if (!Array.isArray(value)) {
     if (!init && !DocumentArrayPath.options.castNonArrays) {
       throw new CastError('DocumentArray', value, this.path, null, this);
@@ -405,7 +417,7 @@ DocumentArrayPath.prototype.cast = function(value, doc, init, prev, options) {
 
   // We need to create a new array, otherwise change tracking will
   // update the old doc (gh-4449)
-  if (!options || !options.skipDocumentArrayCast || utils.isMongooseDocumentArray(value)) {
+  if (!options.skipDocumentArrayCast || utils.isMongooseDocumentArray(value)) {
     value = new MongooseDocumentArray(value, this.path, doc);
   }
 
@@ -413,7 +425,7 @@ DocumentArrayPath.prototype.cast = function(value, doc, init, prev, options) {
     value[arrayAtomicsSymbol] = prev[arrayAtomicsSymbol] || {};
   }
 
-  if (options && options.arrayPathIndex != null) {
+  if (options.arrayPathIndex != null) {
     value[arrayPathSymbol] = this.path + '.' + options.arrayPathIndex;
   }
 

package/lib/schema.js

@@ -107,11 +107,11 @@ function Schema(obj, options) {
   this.inherits = {};
   this.callQueue = [];
   this._indexes = [];
-  this.methods = {};
+  this.methods = (options && options.methods) || {};
   this.methodOptions = {};
-  this.statics = {};
+  this.statics = (options && options.statics) || {};
   this.tree = {};
-  this.query = {};
+  this.query = (options && options.query) || {};
   this.childSchemas = [];
   this.plugins = [];
   // For internal debugging. Do not use this to try to save a schema in MDB.
@@ -766,7 +766,6 @@ reserved['prototype'] =
 // EventEmitter
 reserved.emit =
 reserved.listeners =
-reserved.on =
 reserved.removeListener =
 
 // document properties and functions

package/lib/schematype.js

@@ -1181,7 +1181,6 @@ SchemaType.prototype._castNullish = function _castNullish(v) {
 
 SchemaType.prototype.applySetters = function(value, scope, init, priorVal, options) {
   let v = this._applySetters(value, scope, init, priorVal, options);
-
   if (v == null) {
     return this._castNullish(v);
   }

package/lib/statemachine.js

@@ -95,6 +95,19 @@ StateMachine.prototype.clear = function clear(state) {
   }
 };
 
+/*!
+ * ignore
+ */
+
+StateMachine.prototype.clearPath = function clearPath(path) {
+  const state = this.paths[path];
+  if (!state) {
+    return;
+  }
+  delete this.paths[path];
+  delete this.states[state][path];
+};
+
 /*!
  * Checks to see if at least one path is in the states passed in via `arguments`
  * e.g., this.some('required', 'inited')

package/lib/utils.js

@@ -935,6 +935,9 @@ exports.getOption = function(name) {
   const sources = Array.prototype.slice.call(arguments, 1);
 
   for (const source of sources) {
+    if (source == null) {
+      continue;
+    }
     if (source[name] != null) {
       return source[name];
     }

package/lib/validoptions.js

@@ -15,6 +15,7 @@ const VALID_OPTIONS = Object.freeze([
   'bufferTimeoutMS',
   'cloneSchemas',
   'debug',
+  'timestamps.createdAt.immutable',
   'maxTimeMS',
   'objectIdGetter',
   'overwriteModels',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "6.3.7",
+  "version": "6.4.0",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -20,8 +20,8 @@
   "license": "MIT",
   "dependencies": {
     "bson": "^4.6.2",
-    "kareem": "2.3.5",
-    "mongodb": "4.5.0",
+    "kareem": "2.4.1",
+    "mongodb": "4.7.0",
     "mpath": "0.9.0",
     "mquery": "4.0.3",
     "ms": "2.1.3",

package/tsconfig.json

@@ -1,5 +1,6 @@
 {
   "compilerOptions": {
+    "strict": true,
     "strictNullChecks": true,
     "paths": {
       "mongoose" : ["./types/index.d.ts"]

package/types/aggregate.d.ts

@@ -1,6 +1,9 @@
 declare module 'mongoose' {
   import mongodb = require('mongodb');
 
+  /** Extract generic type from Aggregate class */
+  type AggregateExtract<P> = P extends Aggregate<infer T> ? T : never;
+
   interface AggregateOptions extends
     SessionOption {
     /**

package/types/connection.d.ts

@@ -66,6 +66,11 @@ declare module 'mongoose' {
     close(callback: CallbackWithoutResult): void;
     close(force?: boolean): Promise<void>;
 
+    /** Closes and destroys the connection. Connection once destroyed cannot be reopened */
+    destroy(force: boolean, callback: CallbackWithoutResult): void;
+    destroy(callback: CallbackWithoutResult): void;
+    destroy(force?: boolean): Promise<void>;
+
     /** Retrieves a collection, creating it if not cached. */
     collection<T extends AnyObject = AnyObject>(name: string, options?: mongodb.CreateCollectionOptions): Collection<T>;
 

package/types/document.d.ts

@@ -19,6 +19,9 @@ declare module 'mongoose' {
     /** This documents __v. */
     __v?: any;
 
+    /** Assert that a given path or paths is populated. Throws an error if not populated. */
+    $assertPopulated<Paths = {}>(paths: string | string[]): Omit<this, keyof Paths> & Paths;
+
     /* Get all subdocs (by bfs) */
     $getAllSubdocs(): Document[];
 
@@ -193,8 +196,8 @@ declare module 'mongoose' {
     /** Populates document references. */
     populate<Paths = {}>(path: string | PopulateOptions | (string | PopulateOptions)[]): Promise<this & Paths>;
     populate<Paths = {}>(path: string | PopulateOptions | (string | PopulateOptions)[], callback: Callback<this & Paths>): void;
-    populate<Paths = {}>(path: string, select?: string | AnyObject, model?: Model<unknown>, match?: AnyObject, options?: PopulateOptions): Promise<this & Paths>;
-    populate<Paths = {}>(path: string, select?: string | AnyObject, model?: Model<unknown>, match?: AnyObject, options?: PopulateOptions, callback?: Callback<this & Paths>): void;
+    populate<Paths = {}>(path: string, select?: string | AnyObject, model?: Model<any>, match?: AnyObject, options?: PopulateOptions): Promise<this & Paths>;
+    populate<Paths = {}>(path: string, select?: string | AnyObject, model?: Model<any>, match?: AnyObject, options?: PopulateOptions, callback?: Callback<this & Paths>): void;
 
     /** Gets _id(s) used during population of the given `path`. If the path was not populated, returns `undefined`. */
     populated(path: string): any;