mongoose 8.20.0 → 9.0.0-rc0

package/lib/document.js

@@ -30,7 +30,6 @@ const getEmbeddedDiscriminatorPath = require('./helpers/document/getEmbeddedDisc
 const getKeysInSchemaOrder = require('./helpers/schema/getKeysInSchemaOrder');
 const getSubdocumentStrictValue = require('./helpers/schema/getSubdocumentStrictValue');
 const handleSpreadDoc = require('./helpers/document/handleSpreadDoc');
-const immediate = require('./helpers/immediate');
 const isBsonType = require('./helpers/isBsonType');
 const isDefiningProjection = require('./helpers/projection/isDefiningProjection');
 const isExclusive = require('./helpers/projection/isExclusive');
@@ -80,32 +79,33 @@ const VERSION_ALL = VERSION_WHERE | VERSION_INC;
  * @param {Object} [fields] optional object containing the fields which were selected in the query returning this document and any populated paths data
  * @param {Object} [options] various configuration options for the document
  * @param {Boolean} [options.defaults=true] if `false`, skip applying default values to this document.
+ * @param {Boolean} [options.skipId=false] By default, Mongoose document if one is not provided and the document's schema does not override Mongoose's default `_id`. Set `skipId` to `true` to skip this generation step.
  * @inherits NodeJS EventEmitter https://nodejs.org/api/events.html#class-eventemitter
  * @event `init`: Emitted on a document after it has been retrieved from the db and fully hydrated by Mongoose.
  * @event `save`: Emitted when the document is successfully saved
  * @api private
  */
 
-function Document(obj, fields, skipId, options) {
-  if (typeof skipId === 'object' && skipId != null) {
-    options = skipId;
-    skipId = options.skipId;
+function Document(obj, fields, options) {
+  if (typeof options === 'boolean') {
+    throw new Error('The skipId parameter has been removed. Use { skipId: true } in the options parameter instead.');
   }
   options = Object.assign({}, options);
+  let skipId = options.skipId;
+
+  this.$__ = new InternalCache();
 
   // Support `browserDocument.js` syntax
   if (this.$__schema == null) {
     const _schema = utils.isObject(fields) && !fields.instanceOfSchema ?
       new Schema(fields) :
       fields;
+
     this.$__setSchema(_schema);
-    fields = skipId;
-    skipId = options;
-    options = arguments[4] || {};
+    fields = options;
+    skipId = options.skipId;
   }
 
-  this.$__ = new InternalCache();
-
   // Avoid setting `isNew` to `true`, because it is `true` by default
   if (options.isNew != null && options.isNew !== true) {
     this.$isNew = options.isNew;
@@ -733,6 +733,10 @@ Document.prototype.$__init = function(doc, opts) {
 function init(self, obj, doc, opts, prefix) {
   prefix = prefix || '';
 
+  if (typeof obj !== 'object' || Array.isArray(obj)) {
+    throw new ObjectExpectedError(self.$basePath, obj);
+  }
+
   if (obj.$__ != null) {
     obj = obj._doc;
   }
@@ -849,14 +853,25 @@ function init(self, obj, doc, opts, prefix) {
  * @instance
  */
 
-Document.prototype.updateOne = function updateOne(doc, options, callback) {
+Document.prototype.updateOne = function updateOne(doc, options) {
   const query = this.constructor.updateOne({ _id: this._doc._id }, doc, options);
   const self = this;
-  query.pre(function queryPreUpdateOne(cb) {
-    self.constructor._middleware.execPre('updateOne', self, [self], cb);
+  query.pre(async function queryPreUpdateOne() {
+    const res = await self._execDocumentPreHooks('updateOne', self);
+    // `self` is passed to pre hooks as argument for backwards compatibility, but that
+    // isn't the actual arguments passed to the wrapped function.
+    if (res?.length !== 1 || res[0] !== self) {
+      throw new Error('Document updateOne pre hooks cannot overwrite arguments');
+    }
+    // Apply custom where conditions _after_ document updateOne middleware for
+    // consistency with save() - sharding plugin needs to set $where
+    if (self.$where != null) {
+      this.where(self.$where);
+    }
+    return res;
   });
-  query.post(function queryPostUpdateOne(cb) {
-    self.constructor._middleware.execPost('updateOne', self, [self], {}, cb);
+  query.post(function queryPostUpdateOne() {
+    return self._execDocumentPostHooks('updateOne');
   });
 
   if (this.$session() != null) {
@@ -865,10 +880,6 @@ Document.prototype.updateOne = function updateOne(doc, options, callback) {
     }
   }
 
-  if (callback != null) {
-    return query.exec(callback);
-  }
-
   return query;
 };
 
@@ -2648,16 +2659,12 @@ Document.prototype.validate = async function validate(pathsToValidate, options)
     this.$__.validating = true;
   }
 
-  return new Promise((resolve, reject) => {
-    this.$__validate(pathsToValidate, options, (error) => {
-      this.$op = null;
-      this.$__.validating = null;
-      if (error != null) {
-        return reject(error);
-      }
-      resolve();
-    });
-  });
+  try {
+    await this.$__validate(pathsToValidate, options);
+  } finally {
+    this.$op = null;
+    this.$__.validating = null;
+  }
 };
 
 /**
@@ -2808,13 +2815,13 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip, isNestedValidate
 
     // Optimization: if primitive path with no validators, or array of primitives
     // with no validators, skip validating this path entirely.
-    if (!_pathType.caster && _pathType.validators.length === 0 && !_pathType.$parentSchemaDocArray) {
+    if (!_pathType.schema && !_pathType.embeddedSchemaType && _pathType.validators.length === 0 && !_pathType.$parentSchemaDocArray) {
       paths.delete(path);
     } else if (_pathType.$isMongooseArray &&
       !_pathType.$isMongooseDocumentArray && // Skip document arrays...
-      !_pathType.$embeddedSchemaType.$isMongooseArray && // and arrays of arrays
+      !_pathType.embeddedSchemaType.$isMongooseArray && // and arrays of arrays
       _pathType.validators.length === 0 && // and arrays with top-level validators
-      _pathType.$embeddedSchemaType.validators.length === 0) {
+      _pathType.embeddedSchemaType.validators.length === 0) {
       paths.delete(path);
     }
   }
@@ -2899,8 +2906,8 @@ function _addArrayPathsToValidate(doc, paths) {
     // on the array type, there's no need to run validation on the individual array elements.
     if (_pathType.$isMongooseArray &&
         !_pathType.$isMongooseDocumentArray && // Skip document arrays...
-        !_pathType.$embeddedSchemaType.$isMongooseArray && // and arrays of arrays
-        _pathType.$embeddedSchemaType.validators.length === 0) {
+        !_pathType.embeddedSchemaType.$isMongooseArray && // and arrays of arrays
+        _pathType.embeddedSchemaType.validators.length === 0) {
       continue;
     }
 
@@ -2926,16 +2933,32 @@ function _pushNestedArrayPaths(val, paths, path) {
  * ignore
  */
 
-Document.prototype.$__validate = function(pathsToValidate, options, callback) {
+Document.prototype._execDocumentPreHooks = async function _execDocumentPreHooks(opName, ...args) {
+  return this.$__middleware.execPre(opName, this, [...args]);
+};
+
+/*!
+ * ignore
+ */
+
+Document.prototype._execDocumentPostHooks = async function _execDocumentPostHooks(opName, error) {
+  return this.$__middleware.execPost(opName, this, [this], { error });
+};
+
+/*!
+ * ignore
+ */
+
+Document.prototype.$__validate = async function $__validate(pathsToValidate, options) {
+  try {
+    [options] = await this._execDocumentPreHooks('validate', options);
+  } catch (error) {
+    await this._execDocumentPostHooks('validate', error);
+    return;
+  }
+
   if (this.$__.saveOptions && this.$__.saveOptions.pathsToSave && !pathsToValidate) {
     pathsToValidate = [...this.$__.saveOptions.pathsToSave];
-  } else if (typeof pathsToValidate === 'function') {
-    callback = pathsToValidate;
-    options = null;
-    pathsToValidate = null;
-  } else if (typeof options === 'function') {
-    callback = options;
-    options = null;
   }
 
   const hasValidateModifiedOnlyOption = options &&
@@ -3033,110 +3056,90 @@ Document.prototype.$__validate = function(pathsToValidate, options, callback) {
   }
 
   if (paths.length === 0) {
-    return immediate(function() {
-      const error = _complete();
-      if (error) {
-        return _this.$__schema.s.hooks.execPost('validate:error', _this, [_this], { error: error }, function(error) {
-          callback(error);
-        });
-      }
-      callback(null, _this);
-    });
+    const error = _complete();
+    await this._execDocumentPostHooks('validate', error);
+    return;
   }
 
   const validated = {};
-  let total = 0;
 
   let pathsToSave = this.$__.saveOptions?.pathsToSave;
+  const promises = [];
   if (Array.isArray(pathsToSave)) {
     pathsToSave = new Set(pathsToSave);
     for (const path of paths) {
       if (!pathsToSave.has(path)) {
         continue;
       }
-      validatePath(path);
+      promises.push(validatePath(path));
     }
   } else {
     for (const path of paths) {
-      validatePath(path);
+      promises.push(validatePath(path));
     }
   }
+  await Promise.all(promises);
+  const error = _complete();
+  await this._execDocumentPostHooks('validate', error);
 
-  function validatePath(path) {
+  async function validatePath(path) {
     if (path == null || validated[path]) {
       return;
     }
 
     validated[path] = true;
-    total++;
+    const schemaType = _this.$__schema.path(path);
 
-    immediate(function() {
-      const schemaType = _this.$__schema.path(path);
+    if (!schemaType) {
+      return;
+    }
 
-      if (!schemaType) {
-        return --total || complete();
-      }
+    // If user marked as invalid or there was a cast error, don't validate
+    if (!_this.$isValid(path)) {
+      return;
+    }
 
-      // If user marked as invalid or there was a cast error, don't validate
-      if (!_this.$isValid(path)) {
-        --total || complete();
-        return;
-      }
+    // If setting a path under a mixed path, avoid using the mixed path validator (gh-10141)
+    if (schemaType[schemaMixedSymbol] != null && path !== schemaType.path) {
+      return;
+    }
 
-      // If setting a path under a mixed path, avoid using the mixed path validator (gh-10141)
-      if (schemaType[schemaMixedSymbol] != null && path !== schemaType.path) {
-        return --total || complete();
-      }
+    let val = _this.$__getValue(path);
 
-      let val = _this.$__getValue(path);
-
-      // If you `populate()` and get back a null value, required validators
-      // shouldn't fail (gh-8018). We should always fall back to the populated
-      // value.
-      let pop;
-      if ((pop = _this.$populated(path))) {
-        val = pop;
-      } else if (val != null && val.$__ != null && val.$__.wasPopulated) {
-        // Array paths, like `somearray.1`, do not show up as populated with `$populated()`,
-        // so in that case pull out the document's id
-        val = val._doc._id;
-      }
-      const scope = _this.$__.pathsToScopes != null && path in _this.$__.pathsToScopes ?
-        _this.$__.pathsToScopes[path] :
-        _this;
-
-      const doValidateOptions = {
-        ...doValidateOptionsByPath[path],
-        path: path,
-        validateAllPaths,
-        _nestedValidate: true
-      };
-
-      schemaType.doValidate(val, function(err) {
-        if (err) {
-          const isSubdoc = schemaType.$isSingleNested ||
-              schemaType.$isArraySubdocument ||
-              schemaType.$isMongooseDocumentArray;
-          if (isSubdoc && err instanceof ValidationError) {
-            return --total || complete();
-          }
-          _this.invalidate(path, err, undefined, true);
-        }
-        --total || complete();
-      }, scope, doValidateOptions);
-    });
-  }
+    // If you `populate()` and get back a null value, required validators
+    // shouldn't fail (gh-8018). We should always fall back to the populated
+    // value.
+    let pop;
+    if ((pop = _this.$populated(path))) {
+      val = pop;
+    } else if (val != null && val.$__ != null && val.$__.wasPopulated) {
+      // Array paths, like `somearray.1`, do not show up as populated with `$populated()`,
+      // so in that case pull out the document's id
+      val = val._doc._id;
+    }
+    const scope = _this.$__.pathsToScopes != null && path in _this.$__.pathsToScopes ?
+      _this.$__.pathsToScopes[path] :
+      _this;
 
-  function complete() {
-    const error = _complete();
-    if (error) {
-      return _this.$__schema.s.hooks.execPost('validate:error', _this, [_this], { error: error }, function(error) {
-        callback(error);
-      });
+    const doValidateOptions = {
+      ...doValidateOptionsByPath[path],
+      path: path,
+      validateAllPaths,
+      _nestedValidate: true
+    };
+
+    try {
+      await schemaType.doValidate(val, scope, doValidateOptions);
+    } catch (err) {
+      const isSubdoc = schemaType.$isSingleNested ||
+          schemaType.$isArraySubdocument ||
+          schemaType.$isMongooseDocumentArray;
+      if (isSubdoc && err instanceof ValidationError) {
+        return;
+      }
+      _this.invalidate(path, err, undefined, true);
     }
-    callback(null, _this);
   }
-
 };
 
 /*!
@@ -3681,6 +3684,7 @@ Document.prototype.$__setSchema = function(schema) {
     this.schema = schema;
   }
   this.$__schema = schema;
+  this.$__middleware = schema._getDocumentMiddleware();
   this[documentSchemaSymbol] = schema;
 };
 
@@ -4274,9 +4278,9 @@ function applyGetters(self, json) {
           branch[part],
           self
         );
-        if (Array.isArray(branch[part]) && schema.paths[path].$embeddedSchemaType) {
+        if (Array.isArray(branch[part]) && schema.paths[path].embeddedSchemaType) {
           for (let i = 0; i < branch[part].length; ++i) {
-            branch[part][i] = schema.paths[path].$embeddedSchemaType.applyGetters(
+            branch[part][i] = schema.paths[path].embeddedSchemaType.applyGetters(
               branch[part][i],
               self
             );
@@ -4318,8 +4322,8 @@ function applySchemaTypeTransforms(self, json) {
   for (const path of paths) {
     const schematype = schema.paths[path];
     const topLevelTransformFunction = schematype.options.transform ?? schematype.constructor?.defaultOptions?.transform;
-    const embeddedSchemaTypeTransformFunction = schematype.$embeddedSchemaType?.options?.transform
-      ?? schematype.$embeddedSchemaType?.constructor?.defaultOptions?.transform;
+    const embeddedSchemaTypeTransformFunction = schematype.embeddedSchemaType?.options?.transform
+      ?? schematype.embeddedSchemaType?.constructor?.defaultOptions?.transform;
     if (typeof topLevelTransformFunction === 'function') {
       const val = self.$get(path);
       if (val === undefined) {
@@ -5046,7 +5050,7 @@ Document.prototype.$__delta = function $__delta() {
   }
 
   if (divergent.length) {
-    return new DivergentArrayError(divergent);
+    throw new DivergentArrayError(divergent);
   }
 
   if (this.$__.version) {

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

@@ -55,7 +55,6 @@ Object.setPrototypeOf(NativeConnection.prototype, MongooseConnection.prototype);
  * @param {String} name The database name
  * @param {Object} [options]
  * @param {Boolean} [options.useCache=false] If true, cache results so calling `useDb()` multiple times with the same name only creates 1 connection object.
- * @param {Boolean} [options.noListener=false] If true, the new connection object won't listen to any events on the base connection. This is better for memory usage in cases where you're calling `useDb()` for every request.
  * @return {Connection} New Connection Object
  * @api public
  */
@@ -107,21 +106,15 @@ NativeConnection.prototype.useDb = function(name, options) {
 
   function wireup() {
     newConn.client = _this.client;
-    const _opts = {};
-    if (options.hasOwnProperty('noListener')) {
-      _opts.noListener = options.noListener;
-    }
-    newConn.db = _this.client.db(name, _opts);
+    newConn.db = _this.client.db(name);
     newConn._lastHeartbeatAt = _this._lastHeartbeatAt;
     newConn.onOpen();
   }
 
   newConn.name = name;
 
-  // push onto the otherDbs stack, this is used when state changes and when heartbeat is received
-  if (options.noListener !== true) {
-    this.otherDbs.push(newConn);
-  }
+  // push onto the otherDbs stack, this is used when state changes
+  this.otherDbs.push(newConn);
   newConn.otherDbs.push(this);
 
   // push onto the relatedDbs cache, this is used when state changes

package/lib/error/objectParameter.js

@@ -17,10 +17,9 @@ const MongooseError = require('./mongooseError');
  */
 
 class ObjectParameterError extends MongooseError {
-
   constructor(value, paramName, fnName) {
     super('Parameter "' + paramName + '" to ' + fnName +
-      '() must be an object, got "' + value.toString() + '" (type ' + typeof value + ')');
+      '() must be an object, got "' + (value == null ? value : value.toString()) + '" (type ' + typeof value + ')');
   }
 }
 

package/lib/error/validation.js

@@ -44,14 +44,6 @@ class ValidationError extends MongooseError {
     return this.name + ': ' + combinePathErrors(this);
   }
 
-  /**
-   * inspect helper
-   * @api private
-   */
-  inspect() {
-    return Object.assign(new Error(this.message), this);
-  }
-
   /**
   * add message
   * @param {String} path

package/lib/helpers/clone.js

@@ -11,7 +11,7 @@ const isObject = require('./isObject');
 const isPOJO = require('./isPOJO');
 const symbols = require('./symbols');
 const trustedSymbol = require('./query/trusted').trustedSymbol;
-const BSON = require('bson');
+const BSON = require('mongodb/lib/bson');
 
 /**
  * Object clone with Mongoose natives support.

package/lib/helpers/common.js

@@ -4,7 +4,7 @@
  * Module dependencies.
  */
 
-const Binary = require('bson').Binary;
+const Binary = require('mongodb/lib/bson').Binary;
 const isBsonType = require('./isBsonType');
 const isMongooseObject = require('./isMongooseObject');
 const MongooseError = require('../error');

package/lib/helpers/indexes/isIndexEqual.js

@@ -20,7 +20,6 @@ module.exports = function isIndexEqual(schemaIndexKeysObject, options, dbIndex)
   //   key: { _fts: 'text', _ftsx: 1 },
   //   name: 'name_text',
   //   ns: 'test.tests',
-  //   background: true,
   //   weights: { name: 1 },
   //   default_language: 'english',
   //   language_override: 'language',

package/lib/helpers/model/applyDefaultsToPOJO.js

@@ -23,7 +23,7 @@ module.exports = function applyDefaultsToPOJO(doc, schema) {
       if (j === len - 1) {
         if (typeof doc_[piece] !== 'undefined') {
           if (type.$isSingleNested) {
-            applyDefaultsToPOJO(doc_[piece], type.caster.schema);
+            applyDefaultsToPOJO(doc_[piece], type.schema);
           } else if (type.$isMongooseDocumentArray && Array.isArray(doc_[piece])) {
             doc_[piece].forEach(el => applyDefaultsToPOJO(el, type.schema));
           }
@@ -36,7 +36,7 @@ module.exports = function applyDefaultsToPOJO(doc, schema) {
           doc_[piece] = def;
 
           if (type.$isSingleNested) {
-            applyDefaultsToPOJO(def, type.caster.schema);
+            applyDefaultsToPOJO(def, type.schema);
           } else if (type.$isMongooseDocumentArray && Array.isArray(def)) {
             def.forEach(el => applyDefaultsToPOJO(el, type.schema));
           }

package/lib/helpers/model/applyHooks.js

@@ -1,8 +1,5 @@
 'use strict';
 
-const symbols = require('../../schema/symbols');
-const promiseOrCallback = require('../promiseOrCallback');
-
 /*!
  * ignore
  */
@@ -15,10 +12,10 @@ module.exports = applyHooks;
 
 applyHooks.middlewareFunctions = [
   'deleteOne',
-  'save',
-  'validate',
   'remove',
+  'save',
   'updateOne',
+  'validate',
   'init'
 ];
 
@@ -47,15 +44,15 @@ function applyHooks(model, schema, options) {
     contextParameter: true
   };
   const objToDecorate = options.decorateDoc ? model : model.prototype;
-
   model.$appliedHooks = true;
   for (const key of Object.keys(schema.paths)) {
-    const type = schema.paths[key];
+    let type = schema.paths[key];
     let childModel = null;
-    if (type.$isSingleNested) {
-      childModel = type.caster;
-    } else if (type.$isMongooseDocumentArray) {
-      childModel = type.Constructor;
+
+    const result = findChildModel(type);
+    if (result) {
+      childModel = result.childModel;
+      type = result.type;
     } else {
       continue;
     }
@@ -64,7 +61,11 @@ function applyHooks(model, schema, options) {
       continue;
     }
 
-    applyHooks(childModel, type.schema, { ...options, isChildSchema: true });
+    applyHooks(childModel, type.schema, {
+      ...options,
+      decorateDoc: false,
+      isChildSchema: true
+    });
     if (childModel.discriminators != null) {
       const keys = Object.keys(childModel.discriminators);
       for (const key of keys) {
@@ -78,39 +79,10 @@ function applyHooks(model, schema, options) {
   // promises and make it so that `doc.save.toString()` provides meaningful
   // information.
 
-  const middleware = schema.s.hooks.
-    filter(hook => {
-      if (hook.name === 'updateOne' || hook.name === 'deleteOne') {
-        return !!hook['document'];
-      }
-      if (hook.name === 'remove' || hook.name === 'init') {
-        return hook['document'] == null || !!hook['document'];
-      }
-      if (hook.query != null || hook.document != null) {
-        return hook.document !== false;
-      }
-      return true;
-    }).
-    filter(hook => {
-      // If user has overwritten the method, don't apply built-in middleware
-      if (schema.methods[hook.name]) {
-        return !hook.fn[symbols.builtInMiddleware];
-      }
-
-      return true;
-    });
+  const middleware = schema._getDocumentMiddleware();
 
   model._middleware = middleware;
 
-  objToDecorate.$__originalValidate = objToDecorate.$__originalValidate || objToDecorate.$__validate;
-
-  const internalMethodsToWrap = options && options.isChildSchema ? ['save', 'validate', 'deleteOne'] : ['save', 'validate'];
-  for (const method of internalMethodsToWrap) {
-    const toWrap = method === 'validate' ? '$__originalValidate' : `$__${method}`;
-    const wrapped = middleware.
-      createWrapper(method, objToDecorate[toWrap], null, kareemOptions);
-    objToDecorate[`$__${method}`] = wrapped;
-  }
   objToDecorate.$__init = middleware.
     createWrapperSync('init', objToDecorate.$__init, null, kareemOptions);
 
@@ -134,17 +106,35 @@ function applyHooks(model, schema, options) {
       continue;
     }
     const originalMethod = objToDecorate[method];
-    objToDecorate[method] = function() {
-      const args = Array.prototype.slice.call(arguments);
-      const cb = args.slice(-1).pop();
-      const argsWithoutCallback = typeof cb === 'function' ?
-        args.slice(0, args.length - 1) : args;
-      return promiseOrCallback(cb, callback => {
-        return this[`$__${method}`].apply(this,
-          argsWithoutCallback.concat([callback]));
-      }, model.events);
-    };
-    objToDecorate[`$__${method}`] = middleware.
+    objToDecorate[`$__${method}`] = objToDecorate[method];
+    objToDecorate[method] = middleware.
       createWrapper(method, originalMethod, null, customMethodOptions);
   }
 }
+
+/**
+ * Check if there is an embedded schematype in the given schematype. Handles drilling down into primitive
+ * arrays and maps in case of array of array of subdocs or map of subdocs.
+ *
+ * @param {SchemaType} curType
+ * @returns {{ childModel: Model | typeof Subdocument, curType: SchemaType } | null}
+ */
+
+function findChildModel(curType) {
+  if (curType.$isSingleNested || curType.$isMongooseDocumentArray) {
+    return { childModel: curType.Constructor, type: curType };
+  }
+  if (curType.instance === 'Array') {
+    const embedded = curType.getEmbeddedSchemaType();
+    if (embedded) {
+      return findChildModel(embedded);
+    }
+  }
+  if (curType.instance === 'Map') {
+    const mapType = curType.getEmbeddedSchemaType();
+    if (mapType) {
+      return findChildModel(mapType);
+    }
+  }
+  return null;
+}

package/lib/helpers/model/applyMethods.js

@@ -60,8 +60,8 @@ module.exports = function applyMethods(model, schema) {
   model.$appliedMethods = true;
   for (const key of Object.keys(schema.paths)) {
     const type = schema.paths[key];
-    if (type.$isSingleNested && !type.caster.$appliedMethods) {
-      applyMethods(type.caster, type.schema);
+    if (type.$isSingleNested && !type.Constructor.$appliedMethods) {
+      applyMethods(type.Constructor, type.schema);
     }
     if (type.$isMongooseDocumentArray && !type.Constructor.$appliedMethods) {
       applyMethods(type.Constructor, type.schema);