mongoose 6.2.11 → 6.3.2

package/lib/aggregate.js

@@ -6,7 +6,7 @@
 
 const AggregationCursor = require('./cursor/AggregationCursor');
 const Query = require('./query');
-const applyGlobalMaxTimeMS = require('./helpers/query/applyGlobalMaxTimeMS');
+const { applyGlobalMaxTimeMS, applyGlobalDiskUse } = require('./helpers/query/applyGlobalOption');
 const getConstructorName = require('./helpers/getConstructorName');
 const prepareDiscriminatorPipeline = require('./helpers/aggregate/prepareDiscriminatorPipeline');
 const promiseOrCallback = require('./helpers/promiseOrCallback');
@@ -15,6 +15,8 @@ const utils = require('./utils');
 const read = Query.prototype.read;
 const readConcern = Query.prototype.readConcern;
 
+const validRedactStringValues = new Set(['$$DESCEND', '$$PRUNE', '$$KEEP']);
+
 /**
  * Aggregate constructor used for building aggregation pipelines. Do not
  * instantiate this class directly, use [Model.aggregate()](/docs/api.html#model_Model.aggregate) instead.
@@ -672,8 +674,6 @@ Aggregate.prototype.readConcern = function(level) {
  * @api public
  */
 
-const validRedactStringValues = new Set(['$$DESCEND', '$$PRUNE', '$$KEEP']);
-
 Aggregate.prototype.redact = function(expression, thenExpr, elseExpr) {
   if (arguments.length === 3) {
     if ((typeof thenExpr === 'string' && !validRedactStringValues.has(thenExpr)) ||
@@ -973,6 +973,7 @@ Aggregate.prototype.exec = function(callback) {
   const collection = this._model.collection;
 
   applyGlobalMaxTimeMS(this.options, model);
+  applyGlobalDiskUse(this.options, model);
 
   if (this.options && this.options.cursor) {
     return new AggregationCursor(this);

package/lib/collection.js

@@ -23,13 +23,6 @@ function Collection(name, conn, opts) {
   if (opts === void 0) {
     opts = {};
   }
-  if (opts.capped === void 0) {
-    opts.capped = {};
-  }
-
-  if (typeof opts.capped === 'number') {
-    opts.capped = { size: opts.capped };
-  }
 
   this.opts = opts;
   this.name = name;

package/lib/connection.js

@@ -1357,7 +1357,8 @@ Connection.prototype.optionsProvideAuthenticationData = function(options) {
  * that this connection uses to talk to MongoDB.
  *
  * #### Example:
- *     const conn = await mongoose.createConnection('mongodb://localhost:27017/test');
+ *     const conn = await mongoose.createConnection('mongodb://localhost:27017/test').
+ *       asPromise();
  *
  *     conn.getClient(); // MongoClient { ... }
  *

package/lib/cursor/ChangeStream.js

@@ -16,6 +16,7 @@ class ChangeStream extends EventEmitter {
 
     this.driverChangeStream = null;
     this.closed = false;
+    this.bindedEvents = false;
     this.pipeline = pipeline;
     this.options = options;
 
@@ -27,21 +28,60 @@ class ChangeStream extends EventEmitter {
       }
 
       this.driverChangeStream = driverChangeStream;
-      this._bindEvents();
       this.emit('ready');
     });
   }
 
   _bindEvents() {
+    if (this.bindedEvents) {
+      return;
+    }
+
+    this.bindedEvents = true;
+
+    if (this.driverChangeStream == null) {
+      this.once('ready', () => {
+        this.driverChangeStream.on('close', () => {
+          this.closed = true;
+        });
+
+        ['close', 'change', 'end', 'error'].forEach(ev => {
+          this.driverChangeStream.on(ev, data => this.emit(ev, data));
+        });
+      });
+
+      return;
+    }
+
     this.driverChangeStream.on('close', () => {
       this.closed = true;
     });
 
     ['close', 'change', 'end', 'error'].forEach(ev => {
-      this.driverChangeStream.on(ev, data => this.emit(ev, data));
+      this.driverChangeStream.on(ev, data => {
+        this.emit(ev, data);
+      });
     });
   }
 
+  hasNext(cb) {
+    return this.driverChangeStream.hasNext(cb);
+  }
+
+  next(cb) {
+    return this.driverChangeStream.next(cb);
+  }
+
+  on(event, handler) {
+    this._bindEvents();
+    return super.on(event, handler);
+  }
+
+  once(event, handler) {
+    this._bindEvents();
+    return super.once(event, handler);
+  }
+
   _queue(cb) {
     this.once('ready', () => cb());
   }

package/lib/cursor/QueryCursor.js

@@ -225,6 +225,8 @@ QueryCursor.prototype.next = function(callback) {
  * @param {Function} fn
  * @param {Object} [options]
  * @param {Number} [options.parallel] the number of promises to execute in parallel. Defaults to 1.
+ * @param {Number} [options.batchSize] if set, will call `fn()` with arrays of documents with length at most `batchSize`
+ * @param {Boolean} [options.continueOnError=false] if true, `eachAsync()` iterates through all docs even if `fn` throws an error. If false, `eachAsync()` throws an error immediately if the given function `fn()` throws an error.
  * @param {Function} [callback] executed when all docs have been processed
  * @return {Promise}
  * @api public

package/lib/document.js

@@ -1048,7 +1048,6 @@ Document.prototype.$set = function $set(path, val, type, options) {
   const merge = options.merge;
   const adhoc = type && type !== true;
   const constructing = type === true;
-  const typeKey = this.$__schema.options.typeKey;
   let adhocs;
   let keys;
   let i = 0;
@@ -1150,14 +1149,15 @@ Document.prototype.$set = function $set(path, val, type, options) {
       }
     }
 
-    // Ensure all properties are in correct order by deleting and recreating every property.
-    for (const key of Object.keys(this.$__schema.tree)) {
-      if (this._doc.hasOwnProperty(key)) {
-        const val = this._doc[key];
-        delete this._doc[key];
-        this._doc[key] = val;
-      }
+    // Ensure all properties are in correct order
+    const orderedDoc = {};
+    const orderedKeys = Object.keys(this.$__schema.tree);
+    for (let i = 0, len = orderedKeys.length; i < len; ++i) {
+      (key = orderedKeys[i]) &&
+      (this._doc.hasOwnProperty(key)) &&
+      (orderedDoc[key] = undefined);
     }
+    this._doc = Object.assign(orderedDoc, this._doc);
 
     return this;
   }
@@ -1381,6 +1381,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
     }
 
     let popOpts;
+    const typeKey = this.$__schema.options.typeKey;
     if (schema.options &&
         Array.isArray(schema.options[typeKey]) &&
         schema.options[typeKey].length &&
@@ -1400,7 +1401,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
       // later in `$__set()` because we don't take `_doc` when we iterate through
       // a single nested doc. That's to make sure we get the correct context.
       // Otherwise we would double-call the setter, see gh-7196.
-      val = schema.applySetters(val, this, false, priorVal);
+      val = schema.applySetters(val, this, false, priorVal, options);
     }
 
     if (Array.isArray(val) &&
@@ -1454,14 +1455,18 @@ Document.prototype.$set = function $set(path, val, type, options) {
   }
 
   if (shouldSet) {
-    const doc = this.$isSubdocument ? this.ownerDocument() : this;
-    const savedState = doc.$__.savedState;
-    const savedStatePath = this.$isSubdocument ? this.$__.fullPath + '.' + path : path;
-    if (savedState != null) {
-      const firstDot = savedStatePath.indexOf('.');
-      const topLevelPath = firstDot === -1 ? savedStatePath : savedStatePath.slice(0, firstDot);
-      if (!savedState.hasOwnProperty(topLevelPath)) {
-        savedState[topLevelPath] = utils.clone(doc.$__getValue(topLevelPath));
+    let savedState = null;
+    let savedStatePath = null;
+    if (!constructing) {
+      const doc = this.$isSubdocument ? this.ownerDocument() : this;
+      savedState = doc.$__.savedState;
+      savedStatePath = this.$isSubdocument ? this.$__.fullPath + '.' + path : path;
+      if (savedState != null) {
+        const firstDot = savedStatePath.indexOf('.');
+        const topLevelPath = firstDot === -1 ? savedStatePath : savedStatePath.slice(0, firstDot);
+        if (!savedState.hasOwnProperty(topLevelPath)) {
+          savedState[topLevelPath] = utils.clone(doc.$__getValue(topLevelPath));
+        }
       }
     }
 
@@ -1618,7 +1623,6 @@ Document.prototype.$__set = function(pathToMark, path, options, constructing, pa
 
   const shouldModify = this.$__shouldModify(pathToMark, path, options, constructing, parts,
     schema, val, priorVal);
-  const _this = this;
 
   if (shouldModify) {
     this.markModified(pathToMark);
@@ -1634,14 +1638,6 @@ Document.prototype.$__set = function(pathToMark, path, options, constructing, pa
           item && item.__parentArray && (item.__parentArray = val);
         });
       }
-
-      // Small hack for gh-1638: if we're overwriting the entire array, ignore
-      // paths that were modified before the array overwrite
-      this.$__.activePaths.forEach(function(modifiedPath) {
-        if (modifiedPath.startsWith(path + '.')) {
-          _this.$__.activePaths.ignore(modifiedPath);
-        }
-      });
     }
   } else if (Array.isArray(val) && Array.isArray(priorVal) && utils.isMongooseArray(val) && utils.isMongooseArray(priorVal)) {
     val[arrayAtomicsSymbol] = priorVal[arrayAtomicsSymbol];

package/lib/error/cast.js

@@ -23,7 +23,7 @@ class CastError extends MongooseError {
       const stringValue = getStringValue(value);
       const valueType = getValueType(value);
       const messageFormat = getMessageFormat(schemaType);
-      const msg = formatMessage(null, type, stringValue, path, messageFormat, valueType);
+      const msg = formatMessage(null, type, stringValue, path, messageFormat, valueType, reason);
       super(msg);
       this.init(type, value, path, reason, schemaType);
     } else {
@@ -122,7 +122,7 @@ function getMessageFormat(schemaType) {
  * ignore
  */
 
-function formatMessage(model, kind, stringValue, path, messageFormat, valueType) {
+function formatMessage(model, kind, stringValue, path, messageFormat, valueType, reason) {
   if (messageFormat != null) {
     let ret = messageFormat.
       replace('{KIND}', kind).
@@ -140,6 +140,12 @@ function formatMessage(model, kind, stringValue, path, messageFormat, valueType)
     if (model != null) {
       ret += ' for model "' + model.modelName + '"';
     }
+    if (reason != null &&
+        typeof reason.constructor === 'function' &&
+        reason.constructor.name !== 'AssertionError' &&
+        reason.constructor.name !== 'Error') {
+      ret += ' because of "' + reason.constructor.name + '"';
+    }
     return ret;
   }
 }

package/lib/error/eachAsyncMultiError.js

@@ -0,0 +1,41 @@
+/*!
+ * Module dependencies.
+ */
+
+'use strict';
+
+const MongooseError = require('./');
+
+
+/**
+ * If `eachAsync()` is called with `continueOnError: true`, there can be
+ * multiple errors. This error class contains an `errors` property, which
+ * contains an array of all errors that occurred in `eachAsync()`.
+ *
+ * @api private
+ */
+
+class EachAsyncMultiError extends MongooseError {
+  /**
+   * @param {String} connectionString
+   */
+  constructor(errors) {
+    let preview = errors.map(e => e.message).join(', ');
+    if (preview.length > 50) {
+      preview = preview.slice(0, 50) + '...';
+    }
+    super(`eachAsync() finished with ${errors.length} errors: ${preview}`);
+
+    this.errors = errors;
+  }
+}
+
+Object.defineProperty(EachAsyncMultiError.prototype, 'name', {
+  value: 'EachAsyncMultiError'
+});
+
+/*!
+ * exports
+ */
+
+module.exports = EachAsyncMultiError;

package/lib/helpers/common.js

@@ -80,14 +80,6 @@ function modifiedPaths(update, path, result) {
 
     const _path = path + key;
     result[_path] = true;
-    if (_path.indexOf('.') !== -1) {
-      const sp = _path.split('.');
-      let cur = sp[0];
-      for (let i = 1; i < sp.length; ++i) {
-        result[cur] = true;
-        cur += '.' + sp[i];
-      }
-    }
     if (!Buffer.isBuffer(val) && isMongooseObject(val)) {
       val = val.toObject({ transform: false, virtuals: false });
     }

package/lib/helpers/cursor/eachAsync.js

@@ -4,6 +4,7 @@
  * Module dependencies.
  */
 
+const EachAsyncMultiError = require('../../error/eachAsyncMultiError');
 const immediate = require('../immediate');
 const promiseOrCallback = require('../promiseOrCallback');
 
@@ -24,10 +25,11 @@ const promiseOrCallback = require('../promiseOrCallback');
 module.exports = function eachAsync(next, fn, options, callback) {
   const parallel = options.parallel || 1;
   const batchSize = options.batchSize;
+  const continueOnError = options.continueOnError;
+  const aggregatedErrors = [];
   const enqueue = asyncQueue();
 
   return promiseOrCallback(callback, cb => {
-
     if (batchSize != null) {
       if (typeof batchSize !== 'number') {
         throw new TypeError('batchSize must be a number');
@@ -62,14 +64,22 @@ module.exports = function eachAsync(next, fn, options, callback) {
           return done();
         }
         if (err != null) {
-          error = err;
-          finalCallback(err);
-          return done();
+          if (continueOnError) {
+            aggregatedErrors.push(err);
+          } else {
+            error = err;
+            finalCallback(err);
+            return done();
+          }
         }
         if (doc == null) {
           drained = true;
           if (handleResultsInProgress <= 0) {
-            finalCallback(null);
+            const finalErr = continueOnError ?
+              createEachAsyncMultiError(aggregatedErrors) :
+              error;
+
+            finalCallback(finalErr);
           } else if (batchSize && documentsBatch.length) {
             handleNextResult(documentsBatch, currentDocumentIndex++, handleNextResultCallBack);
           }
@@ -102,11 +112,18 @@ module.exports = function eachAsync(next, fn, options, callback) {
             --handleResultsInProgress;
           }
           if (err != null) {
-            error = err;
-            return finalCallback(err);
+            if (continueOnError) {
+              aggregatedErrors.push(err);
+            } else {
+              error = err;
+              return finalCallback(err);
+            }
           }
           if (drained && handleResultsInProgress <= 0) {
-            return finalCallback(null);
+            const finalErr = continueOnError ?
+              createEachAsyncMultiError(aggregatedErrors) :
+              error;
+            return finalCallback(finalErr);
           }
 
           immediate(() => enqueue(fetch));
@@ -118,11 +135,18 @@ module.exports = function eachAsync(next, fn, options, callback) {
   }
 
   function handleNextResult(doc, i, callback) {
-    const promise = fn(doc, i);
-    if (promise && typeof promise.then === 'function') {
-      promise.then(
+    let maybePromise;
+    try {
+      maybePromise = fn(doc, i);
+    } catch (err) {
+      return callback(err);
+    }
+    if (maybePromise && typeof maybePromise.then === 'function') {
+      maybePromise.then(
         function() { callback(null); },
-        function(error) { callback(error || new Error('`eachAsync()` promise rejected without error')); });
+        function(error) {
+          callback(error || new Error('`eachAsync()` promise rejected without error'));
+        });
     } else {
       callback(null);
     }
@@ -158,3 +182,11 @@ function asyncQueue() {
     }
   }
 }
+
+function createEachAsyncMultiError(aggregatedErrors) {
+  if (aggregatedErrors.length === 0) {
+    return null;
+  }
+
+  return new EachAsyncMultiError(aggregatedErrors);
+}

package/lib/helpers/immediate.js

@@ -7,7 +7,9 @@
 
 'use strict';
 
-const nextTick = process.nextTick.bind(process);
+const nextTick = typeof process !== 'undefined' && typeof process.nextTick === 'function' ?
+  process.nextTick.bind(process) :
+  cb => setTimeout(cb, 0); // Fallback for browser build
 
 module.exports = function immediate(cb) {
   return nextTick(cb);

package/lib/helpers/isAsyncFunction.js

@@ -1,10 +1,22 @@
 'use strict';
 
-const asyncFunctionPrototype = Object.getPrototypeOf(async function() {});
+let asyncFunctionPrototype = null;
+// try/catch for Babel compatibility, because Babel preset-env requires
+// regenerator-runtime for async/await and we don't want to include that
+// for a simple check.
+try {
+  asyncFunctionPrototype = Object.getPrototypeOf(async function() {});
+} catch (err) {}
 
-module.exports = function isAsyncFunction(v) {
-  return (
-    typeof v === 'function' &&
-    Object.getPrototypeOf(v) === asyncFunctionPrototype
-  );
-};
+if (asyncFunctionPrototype == null) {
+  module.exports = function isAsyncFunction() {
+    return false;
+  };
+} else {
+  module.exports = function isAsyncFunction(v) {
+    return (
+      typeof v === 'function' &&
+      Object.getPrototypeOf(v) === asyncFunctionPrototype
+    );
+  };
+}

package/lib/helpers/model/discriminator.js

@@ -17,7 +17,6 @@ const CUSTOMIZABLE_DISCRIMINATOR_OPTIONS = {
  */
 
 module.exports = function discriminator(model, name, schema, tiedValue, applyPlugins) {
-
   if (!(schema && schema.instanceOfSchema)) {
     throw new Error('You must pass a valid discriminator Schema');
   }
@@ -109,7 +108,7 @@ module.exports = function discriminator(model, name, schema, tiedValue, applyPlu
 
     utils.merge(schema, baseSchema, {
       isDiscriminatorSchemaMerge: true,
-      omit: { discriminators: true, base: true },
+      omit: { discriminators: true, base: true, _applyDiscriminators: true },
       omitNested: conflictingPaths.reduce((cur, path) => {
         cur['tree.' + path] = true;
         return cur;
@@ -141,7 +140,6 @@ module.exports = function discriminator(model, name, schema, tiedValue, applyPlu
     obj[key][schema.options.typeKey] = existingPath ? existingPath.options[schema.options.typeKey] : String;
     schema.add(obj);
 
-
     schema.discriminatorMapping = { key: key, value: value, isRoot: false };
 
     if (baseSchema.options.collection) {

package/lib/helpers/populate/getModelsMapForPopulate.js

@@ -76,17 +76,20 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
     let schemaOptions = null;
     let modelNamesInOrder = null;
 
-    if (schema != null && schema.instance === 'Embedded' && schema.options.ref) {
-      const data = {
-        localField: options.path + '._id',
-        foreignField: '_id',
-        justOne: true
-      };
-      const res = _getModelNames(doc, schema, modelNameFromQuery, model);
+    if (schema != null && schema.instance === 'Embedded') {
+      if (schema.options.ref) {
+        const data = {
+          localField: options.path + '._id',
+          foreignField: '_id',
+          justOne: true
+        };
+        const res = _getModelNames(doc, schema, modelNameFromQuery, model);
 
-      const unpopulatedValue = mpath.get(options.path, doc);
-      const id = mpath.get('_id', unpopulatedValue);
-      addModelNamesToMap(model, map, available, res.modelNames, options, data, id, doc, schemaOptions, unpopulatedValue);
+        const unpopulatedValue = mpath.get(options.path, doc);
+        const id = mpath.get('_id', unpopulatedValue);
+        addModelNamesToMap(model, map, available, res.modelNames, options, data, id, doc, schemaOptions, unpopulatedValue);
+      }
+      // No-op if no `ref` set. See gh-11538
       continue;
     }
 

package/lib/helpers/query/applyGlobalOption.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const utils = require('../../utils');
+
+function applyGlobalMaxTimeMS(options, model) {
+  applyGlobalOption(options, model, 'maxTimeMS');
+}
+
+function applyGlobalDiskUse(options, model) {
+  applyGlobalOption(options, model, 'allowDiskUse');
+}
+
+module.exports = {
+  applyGlobalMaxTimeMS,
+  applyGlobalDiskUse
+};
+
+
+function applyGlobalOption(options, model, 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];
+  }
+}

package/lib/helpers/schematype/handleImmutable.js

@@ -19,13 +19,16 @@ module.exports = function(schematype) {
 };
 
 function createImmutableSetter(path, immutable) {
-  return function immutableSetter(v) {
+  return function immutableSetter(v, _priorVal, _doc, options) {
     if (this == null || this.$__ == null) {
       return v;
     }
     if (this.isNew) {
       return v;
     }
+    if (options && options.overwriteImmutable) {
+      return v;
+    }
 
     const _immutable = typeof immutable === 'function' ?
       immutable.call(this, this) :

package/lib/helpers/timestamps/setupTimestamps.js

@@ -48,8 +48,8 @@ module.exports = function setupTimestamps(schema, timestamps) {
       currentTime() :
       this.ownerDocument().constructor.base.now();
 
-    if (!skipCreatedAt && this.isNew && createdAt && !this.$__getValue(createdAt) && this.$__isSelected(createdAt)) {
-      this.$set(createdAt, defaultTimestamp);
+    if (!skipCreatedAt && (this.isNew || this.$isSubdocument) && createdAt && !this.$__getValue(createdAt) && this.$__isSelected(createdAt)) {
+      this.$set(createdAt, defaultTimestamp, undefined, { overwriteImmutable: true });
     }
 
     if (!skipUpdatedAt && updatedAt && (this.isNew || this.$isModified())) {

package/lib/index.js

@@ -179,7 +179,9 @@ Mongoose.prototype.driver = driver;
 Mongoose.prototype.set = function(key, value) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
-  if (VALID_OPTIONS.indexOf(key) === -1) throw new Error(`\`${key}\` is an invalid option.`);
+  if (VALID_OPTIONS.indexOf(key) === -1) {
+    throw new Error(`\`${key}\` is an invalid option.`);
+  }
 
   if (arguments.length === 1) {
     return _mongoose.options[key];
@@ -265,7 +267,7 @@ Mongoose.prototype.get = Mongoose.prototype.set;
  * @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.
  * @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 thenable, so you can do `await mongoose.createConnection()`
+ * @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.
  * @api public
  */
 
@@ -467,6 +469,7 @@ Mongoose.prototype.pluralize = function(fn) {
  */
 
 Mongoose.prototype.model = function(name, schema, collection, options) {
+
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
   if (typeof schema === 'string') {
@@ -519,7 +522,6 @@ Mongoose.prototype.model = function(name, schema, collection, options) {
   }
 
   const model = _mongoose._model(name, schema, collection, options);
-
   _mongoose.connection.models[name] = model;
   _mongoose.models[name] = model;
 
@@ -561,12 +563,17 @@ Mongoose.prototype._model = function(name, schema, collection, options) {
 
   const connection = options.connection || _mongoose.connection;
   model = _mongoose.Model.compile(model || name, schema, collection, connection, _mongoose);
-
   // Errors handled internally, so safe to ignore error
   model.init(function $modelInitNoop() {});
 
   connection.emit('model', model);
 
+  if (schema._applyDiscriminators != null) {
+    for (const disc of Object.keys(schema._applyDiscriminators)) {
+      model.discriminator(disc, schema._applyDiscriminators[disc]);
+    }
+  }
+
   return model;
 };
 

package/lib/internal.js

@@ -11,7 +11,6 @@ module.exports = exports = InternalCache;
 
 function InternalCache() {
   this.activePaths = new ActiveRoster();
-  this.strictMode = undefined;
 }
 
 InternalCache.prototype.fullPath = undefined;