@nullix/zod-mongoose-studio 1.0.12 → 2.0.0

package/.output/server/node_modules/mongoose/lib/schema.js

@@ -23,6 +23,7 @@ const merge = require('./helpers/schema/merge');
 const mpath = require('mpath');
 const setPopulatedVirtualValue = require('./helpers/populate/setPopulatedVirtualValue');
 const setupTimestamps = require('./helpers/timestamps/setupTimestamps');
+const symbols = require('./schema/symbols');
 const utils = require('./utils');
 const validateRef = require('./helpers/populate/validateRef');
 
@@ -31,7 +32,7 @@ const hasNumericSubpathRegex = /\.\d+(\.|$)/;
 let MongooseTypes;
 
 const queryHooks = require('./constants').queryMiddlewareFunctions;
-const documentHooks = require('./helpers/model/applyHooks').middlewareFunctions;
+const documentHooks = require('./constants').documentMiddlewareFunctions;
 const hookNames = queryHooks.concat(documentHooks).
   reduce((s, hook) => s.add(hook), new Set());
 
@@ -58,7 +59,7 @@ const numberRE = /^\d+$/;
  * - [autoIndex](https://mongoosejs.com/docs/guide.html#autoIndex): bool - defaults to null (which means use the connection's autoIndex option)
  * - [autoCreate](https://mongoosejs.com/docs/guide.html#autoCreate): bool - defaults to null (which means use the connection's autoCreate option)
  * - [bufferCommands](https://mongoosejs.com/docs/guide.html#bufferCommands): bool - defaults to true
- * - [bufferTimeoutMS](https://mongoosejs.com/docs/guide.html#bufferTimeoutMS): number - defaults to 10000 (10 seconds). If `bufferCommands` is enabled, the amount of time Mongoose will wait for connectivity to be restablished before erroring out.
+ * - [bufferTimeoutMS](https://mongoosejs.com/docs/guide.html#bufferTimeoutMS): number - defaults to 10000 (10 seconds). If `bufferCommands` is enabled, the amount of time Mongoose will wait for connectivity to be established before erroring out.
  * - [capped](https://mongoosejs.com/docs/guide.html#capped): bool | number | object - defaults to false
  * - [collection](https://mongoosejs.com/docs/guide.html#collection): string - no default
  * - [discriminatorKey](https://mongoosejs.com/docs/guide.html#discriminatorKey): string - defaults to `__t`
@@ -77,7 +78,7 @@ const numberRE = /^\d+$/;
  * - [validateBeforeSave](https://mongoosejs.com/docs/guide.html#validateBeforeSave) - bool - defaults to `true`
  * - [validateModifiedOnly](https://mongoosejs.com/docs/api/document.html#Document.prototype.validate()) - bool - defaults to `false`
  * - [versionKey](https://mongoosejs.com/docs/guide.html#versionKey): string or object - defaults to "__v"
- * - [optimisticConcurrency](https://mongoosejs.com/docs/guide.html#optimisticConcurrency): bool or string[] or { exclude: string[] } - defaults to false. Set to true to enable [optimistic concurrency](https://thecodebarbarian.com/whats-new-in-mongoose-5-10-optimistic-concurrency.html). Set to string array to enable optimistic concurrency for only certain fields, or `{ exclude: string[] }` to define a list of fields to ignore for optimistic concurrency.
+ * - [optimisticConcurrency](https://mongoosejs.com/docs/guide.html#optimisticConcurrency): bool or string[] or { exclude: string[] } - defaults to false. Set to true to enable [optimistic concurrency](https://thecodebarbarian.com/whats-new-in-mongoose-5-10-optimistic-concurrency.html) for all fields. Set to a string array to enable optimistic concurrency only for the specified fields; note that this **replaces** the default array versioning behavior. Set to `{ exclude: string[] }` to enable optimistic concurrency for all fields except the specified ones; this also replaces the default array versioning.
  * - [collation](https://mongoosejs.com/docs/guide.html#collation): object - defaults to null (which means use no collation)
  * - [timeseries](https://mongoosejs.com/docs/guide.html#timeseries): object - defaults to null (which means this schema's collection won't be a timeseries collection)
  * - [selectPopulatedPaths](https://mongoosejs.com/docs/guide.html#selectPopulatedPaths): boolean - defaults to `true`
@@ -86,7 +87,8 @@ const numberRE = /^\d+$/;
  * - [pluginTags](https://mongoosejs.com/docs/guide.html#pluginTags): array of strings - defaults to `undefined`. If set and plugin called with `tags` option, will only apply that plugin to schemas with a matching tag.
  * - [virtuals](https://mongoosejs.com/docs/tutorials/virtuals.html#virtuals-via-schema-options): object - virtuals to define, alias for [`.virtual`](https://mongoosejs.com/docs/api/schema.html#Schema.prototype.virtual())
  * - [collectionOptions]: object with options passed to [`createCollection()`](https://www.mongodb.com/docs/manual/reference/method/db.createCollection/) when calling `Model.createCollection()` or `autoCreate` set to true.
- * - [encryptionType]: the encryption type for the schema.  Valid options are `csfle` or `queryableEncryption`.  See https://mongoosejs.com/docs/field-level-encryption.
+ * - [encryptionType]: the encryption type for the schema.  Valid options are `csfle` or `queryableEncryption`.  See https://mongoosejs.com/docs/field-level-encryption.html.
+ * - [lean]: boolean - set to true to make all queries use [lean](https://mongoosejs.com/docs/tutorials/lean.html) by default. Defaults to false.
  *
  * #### Options for Nested Schemas:
  *
@@ -96,8 +98,8 @@ const numberRE = /^\d+$/;
  *
  * _When nesting schemas, (`children` in the example above), always declare the child schema first before passing it into its parent._
  *
- * @param {Object|Schema|Array} [definition] Can be one of: object describing schema paths, or schema to copy, or array of objects and schemas
- * @param {Object} [options]
+ * @param {object|Schema|Array} [definition] Can be one of: object describing schema paths, or schema to copy, or array of objects and schemas
+ * @param {object} [options]
  * @inherits NodeJS EventEmitter https://nodejs.org/api/events.html#class-eventemitter
  * @event `init`: Emitted after the schema is compiled into a `Model`.
  * @api public
@@ -119,11 +121,11 @@ function Schema(obj, options) {
   this.callQueue = [];
   this._indexes = [];
   this._searchIndexes = [];
-  this.methods = (options && options.methods) || {};
+  this.methods = options?.methods || {};
   this.methodOptions = {};
-  this.statics = (options && options.statics) || {};
+  this.statics = options?.statics || {};
   this.tree = {};
-  this.query = (options && options.query) || {};
+  this.query = options?.query || {};
   this.childSchemas = [];
   this.plugins = [];
   // For internal debugging. Do not use this to try to save a schema in MDB.
@@ -146,7 +148,7 @@ function Schema(obj, options) {
   }
 
   // build virtual paths
-  if (options && options.virtuals) {
+  if (options?.virtuals) {
     const virtuals = options.virtuals;
     const pathNames = Object.keys(virtuals);
     for (const pathName of pathNames) {
@@ -164,7 +166,7 @@ function Schema(obj, options) {
   }
 
   // check if _id's value is a subdocument (gh-2276)
-  const _idSubDoc = obj && obj._id && utils.isObject(obj._id);
+  const _idSubDoc = obj?._id && utils.isObject(obj._id);
 
   // ensure the documents get an auto _id unless disabled
   const auto_id = !this.paths['_id'] &&
@@ -203,7 +205,7 @@ function aliasFields(schema, paths) {
     if (Array.isArray(alias)) {
       for (const a of alias) {
         if (typeof a !== 'string') {
-          throw new Error('Invalid value for alias option on ' + prop + ', got ' + a);
+          throw new MongooseError('Invalid value for alias option on ' + prop + ', got ' + a);
         }
 
         schema.aliases[a] = prop;
@@ -229,7 +231,7 @@ function aliasFields(schema, paths) {
     }
 
     if (typeof alias !== 'string') {
-      throw new Error('Invalid value for alias option on ' + prop + ', got ' + alias);
+      throw new MongooseError('Invalid value for alias option on ' + prop + ', got ' + alias);
     }
 
     schema.aliases[alias] = prop;
@@ -372,6 +374,29 @@ Schema.prototype.paths;
 
 Schema.prototype.tree;
 
+/**
+ * Creates a new schema with the given definition and options. Equivalent to `new Schema(definition, options)`.
+ *
+ * `Schema.create()` is primarily useful for automatic schema type inference in TypeScript.
+ *
+ * #### Example:
+ *
+ *     const schema = Schema.create({ name: String }, { toObject: { virtuals: true } });
+ *     // Equivalent:
+ *     const schema2 = new Schema({ name: String }, { toObject: { virtuals: true } });
+ *
+ * @param {object} definition
+ * @param {object} [options]
+ * @return {Schema} the new schema
+ * @api public
+ * @memberOf Schema
+ * @static
+ */
+
+Schema.create = function create(definition, options) {
+  return new Schema(definition, options);
+};
+
 /**
  * Returns a deep copy of the schema
  *
@@ -485,8 +510,8 @@ Schema.prototype._clone = function _clone(Constructor) {
  *     newSchema.path('name'); // SchemaString { ... }
  *     newSchema.path('age'); // undefined
  *
- * @param {String[]} paths List of Paths to pick for the new Schema
- * @param {Object} [options] Options to pass to the new Schema Constructor (same as `new Schema(.., Options)`). Defaults to `this.options` if not set.
+ * @param {string[]} paths List of Paths to pick for the new Schema
+ * @param {object} [options] Options to pass to the new Schema Constructor (same as `new Schema(.., Options)`). Defaults to `this.options` if not set.
  * @return {Schema}
  * @api public
  */
@@ -540,8 +565,8 @@ Schema.prototype.pick = function(paths, options) {
  *     newSchema.path('name'); // SchemaString { ... }
  *     newSchema.path('age'); // undefined
  *
- * @param {String[]} paths List of Paths to omit for the new Schema
- * @param {Object} [options] Options to pass to the new Schema Constructor (same as `new Schema(.., Options)`). Defaults to `this.options` if not set.
+ * @param {string[]} paths List of Paths to omit for the new Schema
+ * @param {object} [options] Options to pass to the new Schema Constructor (same as `new Schema(.., Options)`). Defaults to `this.options` if not set.
  * @return {Schema}
  * @api public
  */
@@ -571,20 +596,20 @@ Schema.prototype.omit = function(paths, options) {
 /**
  * Returns default options for this schema, merged with `options`.
  *
- * @param {Object} [options] Options to overwrite the default options
- * @return {Object} The merged options of `options` and the default options
+ * @param {object} [options] Options to overwrite the default options
+ * @return {object} The merged options of `options` and the default options
  * @api private
  */
 
 Schema.prototype.defaultOptions = function(options) {
   this._userProvidedOptions = options == null ? {} : clone(options);
-  const baseOptions = this.base && this.base.options || {};
-  const strict = 'strict' in baseOptions ? baseOptions.strict : true;
-  const strictQuery = 'strictQuery' in baseOptions ? baseOptions.strictQuery : false;
-  const id = 'id' in baseOptions ? baseOptions.id : true;
+  const baseOptions = this.base?.options || {};
+  const defaultStrict = baseOptions.strict ?? true;
+  const defaultStrictQuery = baseOptions.strictQuery ?? false;
+  const defaultId = baseOptions.id ?? true;
   options = {
-    strict,
-    strictQuery,
+    strict: defaultStrict,
+    strictQuery: defaultStrictQuery,
     bufferCommands: true,
     capped: false, // { size, max, autoIndexId }
     versionKey: '__v',
@@ -598,11 +623,16 @@ Schema.prototype.defaultOptions = function(options) {
     validateModifiedOnly: false,
     // the following are only applied at construction time
     _id: true,
-    id: id,
+    id: defaultId,
     typeKey: 'type',
     ...options
   };
 
+  // Treat `undefined` as "not provided" for these options
+  options.strict ??= defaultStrict;
+  options.strictQuery ??= defaultStrictQuery;
+  options.id ??= defaultId;
+
   if (options.versionKey && typeof options.versionKey !== 'string') {
     throw new MongooseError('`versionKey` must be falsy or string, got `' + (typeof options.versionKey) + '`');
   }
@@ -642,14 +672,14 @@ Schema.prototype.defaultOptions = function(options) {
  *     doc.element; // '#hero'
  *     doc instanceof ClickedModel; // true
  *
- * @param {String} name the name of the discriminator
+ * @param {string} name the name of the discriminator
  * @param {Schema} schema the discriminated Schema
- * @param {Object} [options] discriminator options
- * @param {String} [options.value] the string stored in the `discriminatorKey` property. If not specified, Mongoose uses the `name` parameter.
- * @param {Boolean} [options.clone=true] By default, `discriminator()` clones the given `schema`. Set to `false` to skip cloning.
- * @param {Boolean} [options.overwriteModels=false] by default, Mongoose does not allow you to define a discriminator with the same name as another discriminator. Set this to allow overwriting discriminators with the same name.
- * @param {Boolean} [options.mergeHooks=true] By default, Mongoose merges the base schema's hooks with the discriminator schema's hooks. Set this option to `false` to make Mongoose use the discriminator schema's hooks instead.
- * @param {Boolean} [options.mergePlugins=true] By default, Mongoose merges the base schema's plugins with the discriminator schema's plugins. Set this option to `false` to make Mongoose use the discriminator schema's plugins instead.
+ * @param {object} [options] discriminator options
+ * @param {string} [options.value] the string stored in the `discriminatorKey` property. If not specified, Mongoose uses the `name` parameter.
+ * @param {boolean} [options.clone=true] By default, `discriminator()` clones the given `schema`. Set to `false` to skip cloning.
+ * @param {boolean} [options.overwriteModels=false] by default, Mongoose does not allow you to define a discriminator with the same name as another discriminator. Set this to allow overwriting discriminators with the same name.
+ * @param {boolean} [options.mergeHooks=true] By default, Mongoose merges the base schema's hooks with the discriminator schema's hooks. Set this option to `false` to make Mongoose use the discriminator schema's hooks instead.
+ * @param {boolean} [options.mergePlugins=true] By default, Mongoose merges the base schema's plugins with the discriminator schema's plugins. Set this option to `false` to make Mongoose use the discriminator schema's plugins instead.
  * @return {Schema} the Schema instance
  * @api public
  */
@@ -660,6 +690,33 @@ Schema.prototype.discriminator = function(name, schema, options) {
   return this;
 };
 
+/*!
+ * Get the document middleware for this schema, filtering out any hooks that are specific to queries.
+ */
+Schema.prototype._getDocumentMiddleware = function _getDocumentMiddleware() {
+  return this.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 (this.methods[hook.name]) {
+        return !hook.fn[symbols.builtInMiddleware];
+      }
+
+      return true;
+    });
+};
+
 /*!
  * Get this schema's default toObject/toJSON options, including Mongoose global
  * options.
@@ -671,9 +728,7 @@ Schema.prototype._defaultToObjectOptions = function(json) {
     return this._defaultToObjectOptionsMap[path];
   }
 
-  const baseOptions = this.base &&
-    this.base.options &&
-    this.base.options[path] || {};
+  const baseOptions = this.base?.options?.[path] || {};
   const schemaOptions = this.options[path] || {};
   // merge base default options with Schema's set default options if available.
   // `clone` is necessary here because `utils.options` directly modifies the second input.
@@ -695,7 +750,7 @@ Schema.prototype.encryptionType = function encryptionType(encryptionType) {
     return this.options.encryptionType;
   }
   if (!(typeof encryptionType === 'string' || encryptionType === null)) {
-    throw new Error('invalid `encryptionType`: ${encryptionType}');
+    throw new MongooseError(`invalid \`encryptionType\`: ${encryptionType}`);
   }
   this.options.encryptionType = encryptionType;
 };
@@ -713,14 +768,14 @@ Schema.prototype.encryptionType = function encryptionType(encryptionType) {
  *     // getters, setters, indexes, methods, and statics.
  *     TurboManSchema.add(ToySchema).add({ year: Number });
  *
- * @param {Object|Schema} obj plain object with paths to add, or another schema
- * @param {String} [prefix] path to prefix the newly added paths with
+ * @param {object|Schema} obj plain object with paths to add, or another schema
+ * @param {string} [prefix] path to prefix the newly added paths with
  * @return {Schema} the Schema instance
  * @api public
  */
 
 Schema.prototype.add = function add(obj, prefix) {
-  if (obj instanceof Schema || (obj != null && obj.instanceOfSchema)) {
+  if (obj instanceof Schema || obj?.instanceOfSchema) {
     merge(this, obj);
     return this;
   }
@@ -760,7 +815,7 @@ Schema.prototype.add = function add(obj, prefix) {
     let isMongooseTypeString = false;
     if (typeof val === 'string') {
       // Handle the case in which the type is specified as a string (eg. 'date', 'oid', ...)
-      const MongooseTypes = this.base != null ? this.base.Schema.Types : Schema.Types;
+      const MongooseTypes = this.base?.Schema.Types ?? Schema.Types;
       const upperVal = val.charAt(0).toUpperCase() + val.substring(1);
       isMongooseTypeString = MongooseTypes[upperVal] != null;
     }
@@ -773,7 +828,7 @@ Schema.prototype.add = function add(obj, prefix) {
         `a valid type at path \`${key}\`. See ` +
         'https://bit.ly/mongoose-schematypes for a list of valid schema types.');
     }
-    if (val instanceof VirtualType || (val.constructor && val.constructor.name || null) === 'VirtualType') {
+    if (val instanceof VirtualType || (val.constructor?.name ?? null) === 'VirtualType') {
       this.virtual(val);
       continue;
     }
@@ -790,13 +845,13 @@ Schema.prototype.add = function add(obj, prefix) {
         this.nested[prefix.substring(0, prefix.length - 1)] = true;
       }
       this.path(prefix + key, val);
-      if (val[0] != null && !(val[0].instanceOfSchema) && utils.isPOJO(val[0].discriminators)) {
+      if (!val[0]?.instanceOfSchema && utils.isPOJO(val[0]?.discriminators)) {
         const schemaType = this.path(prefix + key);
         for (const key in val[0].discriminators) {
           schemaType.discriminator(key, val[0].discriminators[key]);
         }
       }
-    } else if (Object.keys(val).length < 1) {
+    } else if (utils.hasOwnKeys(val) === false) {
       // Special-case: {} always interpreted as Mixed path so leaf at this node
       if (prefix) {
         this.nested[prefix.substring(0, prefix.length - 1)] = true;
@@ -811,7 +866,7 @@ Schema.prototype.add = function add(obj, prefix) {
     } else {
       // There IS a bona-fide type key that may also be a POJO
       const _typeDef = val[typeKey];
-      if (isPOJO(_typeDef) && Object.keys(_typeDef).length > 0) {
+      if (isPOJO(_typeDef) && utils.hasOwnKeys(_typeDef)) {
         // If a POJO is the value of a type key, make it a subdocument
         if (prefix) {
           this.nested[prefix.substring(0, prefix.length - 1)] = true;
@@ -842,7 +897,7 @@ Schema.prototype.add = function add(obj, prefix) {
           this.nested[prefix.substring(0, prefix.length - 1)] = true;
         }
         this.path(prefix + key, val);
-        if (val != null && !(val.instanceOfSchema) && utils.isPOJO(val.discriminators)) {
+        if (!val?.instanceOfSchema && utils.isPOJO(val?.discriminators)) {
           const schemaType = this.path(prefix + key);
           for (const key in val.discriminators) {
             schemaType.discriminator(key, val.discriminators[key]);
@@ -854,7 +909,7 @@ Schema.prototype.add = function add(obj, prefix) {
     if (val.instanceOfSchema && val.encryptionType() != null) {
       // schema.add({ field: <instance of encrypted schema> })
       if (this.encryptionType() != val.encryptionType()) {
-        throw new Error('encryptionType of a nested schema must match the encryption type of the parent schema.');
+        throw new MongooseError('encryptionType of a nested schema must match the encryption type of the parent schema.');
       }
 
       for (const [encryptedField, encryptedFieldConfig] of Object.entries(val.encryptedFields)) {
@@ -866,7 +921,7 @@ Schema.prototype.add = function add(obj, prefix) {
       const { encrypt } = val;
 
       if (this.encryptionType() == null) {
-        throw new Error('encryptionType must be provided');
+        throw new MongooseError('encryptionType must be provided');
       }
 
       this._addEncryptedField(fullPath, encrypt);
@@ -893,7 +948,7 @@ Schema.prototype.add = function add(obj, prefix) {
 Schema.prototype._addEncryptedField = function _addEncryptedField(path, fieldConfig) {
   const type = this.path(path).autoEncryptionType();
   if (type == null) {
-    throw new Error(`Invalid BSON type for FLE field: '${path}'`);
+    throw new MongooseError(`Invalid BSON type for FLE field: '${path}'`);
   }
 
   this.encryptedFields[path] = clone(fieldConfig);
@@ -914,7 +969,7 @@ Schema.prototype._removeEncryptedField = function _removeEncryptedField(path) {
  * @returns {boolean}
  */
 Schema.prototype._hasEncryptedFields = function _hasEncryptedFields() {
-  return Object.keys(this.encryptedFields).length > 0;
+  return utils.hasOwnKeys(this.encryptedFields);
 };
 
 /**
@@ -1018,8 +1073,8 @@ Schema.prototype._buildSchemaMap = function() {
  *     await turboMan.save(); // Saves { _id: ..., n: 'Turbo Man Action Figure' }
  *
  *
- * @param {String} path real path to alias
- * @param {String|String[]} alias the path(s) to use as an alias for `path`
+ * @param {string} path real path to alias
+ * @param {string|string[]} alias the path(s) to use as an alias for `path`
  * @return {Schema} the Schema instance
  * @api public
  */
@@ -1051,18 +1106,18 @@ Schema.prototype.alias = function alias(path, alias) {
  *     // Remove index by name
  *     ToySchema.removeIndex('my custom index name');
  *
- * @param {Object|string} index name or index specification
+ * @param {object|string} index name or index specification
  * @return {Schema} the Schema instance
  * @api public
  */
 
 Schema.prototype.removeIndex = function removeIndex(index) {
   if (arguments.length > 1) {
-    throw new Error('removeIndex() takes only 1 argument');
+    throw new MongooseError('removeIndex() takes only 1 argument');
   }
 
   if (typeof index !== 'object' && typeof index !== 'string') {
-    throw new Error('removeIndex() may only take either an object or a string as an argument');
+    throw new MongooseError('removeIndex() may only take either an object or a string as an argument');
   }
 
   if (typeof index === 'object') {
@@ -1118,9 +1173,9 @@ Schema.prototype.clearIndexes = function clearIndexes() {
  *     const ToySchema = new Schema({ name: String, color: String, price: Number });
  *     ToySchema.searchIndex({ name: 'test', definition: { mappings: { dynamic: true } } });
  *
- * @param {Object} description index options, including `name` and `definition`
- * @param {String} description.name
- * @param {Object} description.definition
+ * @param {object} description index options, including `name` and `definition`
+ * @param {string} description.name
+ * @param {object} description.definition
  * @return {Schema} the Schema instance
  * @api public
  */
@@ -1206,8 +1261,8 @@ reserved.collection = 1;
  *     schema.path('name') // returns a SchemaType
  *     schema.path('name', Number) // changes the schemaType of `name` to Number
  *
- * @param {String} path The name of the Path to get / set
- * @param {Object} [obj] The Type to set the path to, if provided the path will be SET, otherwise the path will be GET
+ * @param {string} path The name of the Path to get / set
+ * @param {object} [obj] The Type to set the path to, if provided the path will be SET, otherwise the path will be GET
  * @api public
  */
 
@@ -1263,7 +1318,7 @@ Schema.prototype.path = function(path, obj) {
 
   for (const sub of subpaths) {
     if (utils.specialProperties.has(sub)) {
-      throw new Error('Cannot set special property `' + sub + '` on a schema');
+      throw new MongooseError('Cannot set special property `' + sub + '` on a schema');
     }
     fullPath = fullPath += (fullPath.length > 0 ? '.' : '') + sub;
     if (!branch[sub]) {
@@ -1276,7 +1331,7 @@ Schema.prototype.path = function(path, obj) {
           + fullPath
           + '` already set to type ' + branch[sub].name
           + '.';
-      throw new Error(msg);
+      throw new MongooseError(msg);
     }
     branch = branch[sub];
   }
@@ -1300,7 +1355,7 @@ Schema.prototype.path = function(path, obj) {
     if (schemaType.$__schemaType.$isSingleNested) {
       this.childSchemas.push({
         schema: schemaType.$__schemaType.schema,
-        model: schemaType.$__schemaType.caster,
+        model: schemaType.$__schemaType.Constructor,
         path: path
       });
     }
@@ -1329,10 +1384,10 @@ Schema.prototype.path = function(path, obj) {
       value: this.base
     });
 
-    schemaType.caster.base = this.base;
+    schemaType.Constructor.base = this.base;
     this.childSchemas.push({
       schema: schemaType.schema,
-      model: schemaType.caster,
+      model: schemaType.Constructor,
       path: path
     });
   } else if (schemaType.$isMongooseDocumentArray) {
@@ -1343,15 +1398,15 @@ Schema.prototype.path = function(path, obj) {
       value: this.base
     });
 
-    schemaType.casterConstructor.base = this.base;
+    schemaType.Constructor.base = this.base;
     this.childSchemas.push({
       schema: schemaType.schema,
-      model: schemaType.casterConstructor,
+      model: schemaType.Constructor,
       path: path
     });
   }
 
-  if (schemaType.$isMongooseArray && schemaType.caster instanceof SchemaType) {
+  if (schemaType.$isMongooseArray && !schemaType.$isMongooseDocumentArray) {
     let arrayPath = path;
     let _schemaType = schemaType;
 
@@ -1359,16 +1414,9 @@ Schema.prototype.path = function(path, obj) {
     while (_schemaType.$isMongooseArray) {
       arrayPath = arrayPath + '.$';
 
-      // Skip arrays of document arrays
-      if (_schemaType.$isMongooseDocumentArray) {
-        _schemaType.$embeddedSchemaType._arrayPath = arrayPath;
-        _schemaType.$embeddedSchemaType._arrayParentPath = path;
-        _schemaType = _schemaType.$embeddedSchemaType;
-      } else {
-        _schemaType.caster._arrayPath = arrayPath;
-        _schemaType.caster._arrayParentPath = path;
-        _schemaType = _schemaType.caster;
-      }
+      _schemaType.embeddedSchemaType._arrayPath = arrayPath;
+      _schemaType.embeddedSchemaType._arrayParentPath = path;
+      _schemaType = _schemaType.embeddedSchemaType;
 
       this.subpaths[arrayPath] = _schemaType;
     }
@@ -1420,13 +1468,13 @@ Schema.prototype._gatherChildSchemas = function _gatherChildSchemas() {
     if (schematype.$isMongooseDocumentArray || schematype.$isSingleNested) {
       childSchemas.push({
         schema: schematype.schema,
-        model: schematype.caster,
+        model: schematype.Constructor,
         path: path
       });
     } else if (schematype.$isSchemaMap && schematype.$__schemaType.$isSingleNested) {
       childSchemas.push({
         schema: schematype.$__schemaType.schema,
-        model: schematype.$__schemaType.caster,
+        model: schematype.$__schemaType.Constructor,
         path: path
       });
     }
@@ -1523,9 +1571,9 @@ Object.defineProperty(Schema.prototype, 'base', {
 /**
  * Converts type arguments into Mongoose Types.
  *
- * @param {String} path
- * @param {Object} obj constructor
- * @param {Object} options schema options
+ * @param {string} path
+ * @param {object} obj constructor
+ * @param {object} options schema options
  * @api private
  */
 
@@ -1541,8 +1589,8 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
 
   // If this schema has an associated Mongoose object, use the Mongoose object's
   // copy of SchemaTypes re: gh-7158 gh-6933
-  const MongooseTypes = this.base != null ? this.base.Schema.Types : Schema.Types;
-  const Types = this.base != null ? this.base.Types : require('./types');
+  const MongooseTypes = this.base?.Schema.Types ?? Schema.Types;
+  const Types = this.base?.Types ?? require('./types');
 
   if (!utils.isPOJO(obj) && !(obj instanceof SchemaTypeOptions)) {
     const constructorName = utils.getFunctionName(obj.constructor);
@@ -1582,7 +1630,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
       : type[0];
 
     // new Schema({ path: [new Schema({ ... })] })
-    if (cast && cast.instanceOfSchema) {
+    if (cast?.instanceOfSchema) {
       if (!(cast instanceof Schema)) {
         if (this.options._isMerging) {
           cast = new Schema(cast);
@@ -1616,7 +1664,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
     }
     if (typeof cast !== 'undefined') {
       if (Array.isArray(cast) || cast.type === Array || cast.type == 'Array') {
-        if (cast && cast.type == 'Array') {
+        if (cast?.type == 'Array') {
           cast.type = Array;
         }
         return new MongooseTypes.Array(path, this.interpretAsType(path, cast, options), obj, null, this);
@@ -1630,7 +1678,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
     if (typeof cast === 'string') {
       cast = MongooseTypes[cast.charAt(0).toUpperCase() + cast.substring(1)];
     } else if (utils.isPOJO(castFromTypeKey)) {
-      if (Object.keys(castFromTypeKey).length) {
+      if (utils.hasOwnKeys(castFromTypeKey)) {
         // The `minimize` and `typeKey` options propagate to child schemas
         // declared inline, like `{ arr: [{ val: { $type: String } }] }`.
         // See gh-3560
@@ -1703,7 +1751,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
     return new MongooseTypes.Array(path, cast || MongooseTypes.Mixed, obj, options, this);
   }
 
-  if (type && type.instanceOfSchema) {
+  if (type?.instanceOfSchema) {
     return new MongooseTypes.Subdocument(type, path, obj, this);
   }
 
@@ -1792,7 +1840,7 @@ Schema.prototype.eachPath = function(fn) {
  *     s.requiredPaths(); // [ 'age', 'name' ]
  *
  * @api public
- * @param {Boolean} invalidate Refresh the cache
+ * @param {boolean} invalidate Refresh the cache
  * @return {Array}
  */
 
@@ -1844,8 +1892,8 @@ Schema.prototype.indexedPaths = function indexedPaths() {
  *     s.pathType('foo'); // "virtual"
  *     s.pathType('fail'); // "adhocOrUndefined"
  *
- * @param {String} path
- * @return {String}
+ * @param {string} path
+ * @return {string}
  * @api public
  */
 
@@ -1887,8 +1935,8 @@ Schema.prototype.pathType = function(path) {
 /**
  * Returns true iff this path is a child of a mixed schema.
  *
- * @param {String} path
- * @return {Boolean}
+ * @param {string} path
+ * @return {boolean}
  * @api private
  */
 
@@ -1909,7 +1957,7 @@ Schema.prototype.hasMixedParent = function(path) {
 /**
  * Setup updatedAt and createdAt timestamps to documents if enabled
  *
- * @param {Boolean|Object} timestamps timestamps options
+ * @param {boolean|object} timestamps timestamps options
  * @api private
  */
 Schema.prototype.setupTimestamp = function(timestamps) {
@@ -1918,8 +1966,8 @@ Schema.prototype.setupTimestamp = function(timestamps) {
 
 /**
  * ignore. Deprecated re: #6405
- * @param {Any} self
- * @param {String} path
+ * @param {any} self
+ * @param {string} path
  * @api private
  */
 
@@ -1945,10 +1993,10 @@ function getPositionalPathType(self, path, cleanPath) {
 
     if (i === last && val && !/\D/.test(subpath)) {
       if (val.$isMongooseDocumentArray) {
-        val = val.$embeddedSchemaType;
+        val = val.embeddedSchemaType;
       } else if (val instanceof MongooseTypes.Array) {
         // StringSchema, NumberSchema, etc
-        val = val.caster;
+        val = val.embeddedSchemaType;
       } else {
         val = undefined;
       }
@@ -1959,12 +2007,12 @@ function getPositionalPathType(self, path, cleanPath) {
     if (!/\D/.test(subpath)) {
       // Nested array
       if (val instanceof MongooseTypes.Array && i !== last) {
-        val = val.caster;
+        val = val.embeddedSchemaType;
       }
       continue;
     }
 
-    if (!(val && val.schema)) {
+    if (!val?.schema) {
       val = undefined;
       break;
     }
@@ -2005,7 +2053,7 @@ function getPositionalPath(self, path, cleanPath) {
  *     const Model = mongoose.model('Test', schema);
  *     new Model({ name: 'test' }); // Prints '{"_id": ..., "name": "test" }'
  *
- * @param {String} name name of the document method to call later
+ * @param {string} name name of the document method to call later
  * @param {Array} args arguments to pass to the method
  * @api public
  */
@@ -2022,23 +2070,21 @@ Schema.prototype.queue = function(name, args) {
  *
  *     const toySchema = new Schema({ name: String, created: Date });
  *
- *     toySchema.pre('save', function(next) {
+ *     toySchema.pre('save', function() {
  *       if (!this.created) this.created = new Date;
- *       next();
  *     });
  *
- *     toySchema.pre('validate', function(next) {
+ *     toySchema.pre('validate', function() {
  *       if (this.name !== 'Woody') this.name = 'Woody';
- *       next();
  *     });
  *
  *     // Equivalent to calling `pre()` on `find`, `findOne`, `findOneAndUpdate`.
- *     toySchema.pre(/^find/, function(next) {
+ *     toySchema.pre(/^find/, function() {
  *       console.log(this.getFilter());
  *     });
  *
  *     // Equivalent to calling `pre()` on `updateOne`, `findOneAndUpdate`.
- *     toySchema.pre(['updateOne', 'findOneAndUpdate'], function(next) {
+ *     toySchema.pre(['updateOne', 'findOneAndUpdate'], function() {
  *       console.log(this.getFilter());
  *     });
  *
@@ -2050,10 +2096,10 @@ Schema.prototype.queue = function(name, args) {
  *       // Runs when you call `doc.deleteOne()`
  *     });
  *
- * @param {String|RegExp|String[]} methodName The method name or regular expression to match method name
- * @param {Object} [options]
- * @param {Boolean} [options.document] If `name` is a hook for both document and query middleware, set to `true` to run on document middleware. For example, set `options.document` to `true` to apply this hook to `Document#deleteOne()` rather than `Query#deleteOne()`.
- * @param {Boolean} [options.query] If `name` is a hook for both document and query middleware, set to `true` to run on query middleware.
+ * @param {string|RegExp|string[]} methodName The method name or regular expression to match method name
+ * @param {object} [options]
+ * @param {boolean} [options.document] If `name` is a hook for both document and query middleware, set to `true` to run on document middleware. For example, set `options.document` to `true` to apply this hook to `Document#deleteOne()` rather than `Query#deleteOne()`.
+ * @param {boolean} [options.query] If `name` is a hook for both document and query middleware, set to `true` to run on query middleware.
  * @param {Function} callback
  * @api public
  */
@@ -2104,10 +2150,10 @@ Schema.prototype.pre = function(name) {
  *     await m.find();
  *     console.log('this fires after the post find hook');
  *
- * @param {String|RegExp|String[]} methodName The method name or regular expression to match method name
- * @param {Object} [options]
- * @param {Boolean} [options.document] If `name` is a hook for both document and query middleware, set to `true` to run on document middleware.
- * @param {Boolean} [options.query] If `name` is a hook for both document and query middleware, set to `true` to run on query middleware.
+ * @param {string|RegExp|string[]} methodName The method name or regular expression to match method name
+ * @param {object} [options]
+ * @param {boolean} [options.document] If `name` is a hook for both document and query middleware, set to `true` to run on document middleware.
+ * @param {boolean} [options.query] If `name` is a hook for both document and query middleware, set to `true` to run on query middleware.
  * @param {Function} fn callback
  * @see middleware https://mongoosejs.com/docs/middleware.html
  * @see kareem https://npmjs.org/package/kareem
@@ -2151,20 +2197,20 @@ Schema.prototype.post = function(name) {
  *     mongoose.model('Test', s); // Prints 'Schema Path Name: name'
  *
  * @param {Function} plugin The Plugin's callback
- * @param {Object} [opts] Options to pass to the plugin
- * @param {Boolean} [opts.deduplicate=false] If true, ignore duplicate plugins (same `fn` argument using `===`)
+ * @param {object} [opts] Options to pass to the plugin
+ * @param {boolean} [opts.deduplicate=false] If true, ignore duplicate plugins (same `fn` argument using `===`)
  * @see plugins https://mongoosejs.com/docs/plugins.html
  * @api public
  */
 
 Schema.prototype.plugin = function(fn, opts) {
   if (typeof fn !== 'function') {
-    throw new Error('First param to `schema.plugin()` must be a function, ' +
+    throw new MongooseError('First param to `schema.plugin()` must be a function, ' +
       'got "' + (typeof fn) + '"');
   }
 
 
-  if (opts && opts.deduplicate) {
+  if (opts?.deduplicate) {
     for (const plugin of this.plugins) {
       if (plugin.fn === fn) {
         return this;
@@ -2207,7 +2253,7 @@ Schema.prototype.plugin = function(fn, opts) {
  *
  * NOTE: `Schema.method()` adds instance methods to the `Schema.methods` object. You can also add instance methods directly to the `Schema.methods` object as seen in the [guide](https://mongoosejs.com/docs/guide.html#methods)
  *
- * @param {String|Object} name The Method Name for a single function, or a Object of "string-function" pairs.
+ * @param {string|object} name The Method Name for a single function, or an Object of "string-function" pairs.
  * @param {Function} [fn] The Function in a single-function definition.
  * @api public
  */
@@ -2252,7 +2298,7 @@ Schema.prototype.method = function(name, fn, options) {
  *
  * If a hash of name/fn pairs is passed as the only argument, each name/fn pair will be added as statics.
  *
- * @param {String|Object} name The Method Name for a single function, or a Object of "string-function" pairs.
+ * @param {string|object} name The Method Name for a single function, or an Object of "string-function" pairs.
  * @param {Function} [fn] The Function in a single-function definition.
  * @api public
  * @see Statics https://mongoosejs.com/docs/guide.html#statics
@@ -2276,10 +2322,10 @@ Schema.prototype.static = function(name, fn) {
  *
  *     schema.index({ first: 1, last: -1 })
  *
- * @param {Object} fields The Fields to index, with the order, available values: `1 | -1 | '2d' | '2dsphere' | 'geoHaystack' | 'hashed' | 'text'`
- * @param {Object} [options] Options to pass to [MongoDB driver's `createIndex()` function](https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#createIndex)
- * @param {String | number} [options.expires=null] Mongoose-specific syntactic sugar, uses [ms](https://www.npmjs.com/package/ms) to convert `expires` option into seconds for the `expireAfterSeconds` in the above link.
- * @param {String} [options.language_override=null] Tells mongodb to use the specified field instead of `language` for parsing text indexes.
+ * @param {object} fields The Fields to index, with the order, available values: `1 | -1 | '2d' | '2dsphere' | 'geoHaystack' | 'hashed' | 'text'`
+ * @param {object} [options] Options to pass to [MongoDB driver's `createIndex()` function](https://mongodb.github.io/node-mongodb-native/7.0/classes/Collection.html#createIndex)
+ * @param {string | number} [options.expires=null] Mongoose-specific syntactic sugar, uses [ms](https://www.npmjs.com/package/ms) to convert `expires` option into seconds for the `expireAfterSeconds` in the above link.
+ * @param {string} [options.language_override=null] Tells mongodb to use the specified field instead of `language` for parsing text indexes.
  * @api public
  */
 
@@ -2303,12 +2349,6 @@ Schema.prototype.index = function(fields, options) {
     }
   }
 
-  for (const existingIndex of this.indexes()) {
-    if (options.name == null && existingIndex[1].name == null && isIndexSpecEqual(existingIndex[0], fields)) {
-      utils.warn(`Duplicate schema index on ${JSON.stringify(fields)} found. This is often due to declaring an index using both "index: true" and "schema.index()". Please remove the duplicate index definition.`);
-    }
-  }
-
   this._indexes.push([fields, options]);
   return this;
 };
@@ -2322,9 +2362,9 @@ Schema.prototype.index = function(fields, options) {
  *     schema.set('strict', false); // Sets 'strict' to false
  *     schema.set('strict'); // 'false'
  *
- * @param {String} key The name of the option to set the value to
- * @param {Object} [value] The value to set the option to, if not passed, the option will be reset to default
- * @param {Array<string>} [tags] tags to add to read preference if key === 'read'
+ * @param {string} key The name of the option to set the value to
+ * @param {object} [value] The value to set the option to, if not passed, the option will be reset to default
+ * @param {string[]} [tags] tags to add to read preference if key === 'read'
  * @see Schema https://mongoosejs.com/docs/api/schema.html#Schema()
  * @api public
  */
@@ -2415,9 +2455,9 @@ function _propagateOptionsToImplicitlyCreatedSchemas(baseSchema, options) {
  *     schema.set('strict', false);
  *     schema.get('strict'); // false
  *
- * @param {String} key The name of the Option to get the current value for
+ * @param {string} key The name of the Option to get the current value for
  * @api public
- * @return {Any} the option's value
+ * @return {any} the option's value
  */
 
 Schema.prototype.get = function(key) {
@@ -2429,7 +2469,7 @@ const indexTypes = '2d 2dsphere hashed text'.split(' ');
 /**
  * The allowed index types
  *
- * @property {String[]} indexTypes
+ * @property {string[]} indexTypes
  * @memberOf Schema
  * @static
  * @api public
@@ -2440,7 +2480,7 @@ Object.defineProperty(Schema, 'indexTypes', {
     return indexTypes;
   },
   set: function() {
-    throw new Error('Cannot overwrite Schema.indexTypes');
+    throw new MongooseError('Cannot overwrite Schema.indexTypes');
   }
 });
 
@@ -2455,8 +2495,8 @@ Object.defineProperty(Schema, 'indexTypes', {
  *       registeredAt: { type: Date, index: true }
  *     });
  *
- *     // [ [ { email: 1 }, { unique: true, background: true } ],
- *     //   [ { registeredAt: 1 }, { background: true } ] ]
+ *     // [ [ { email: 1 }, { unique: true } ],
+ *     //   [ { registeredAt: 1 }, {} ] ]
  *     userSchema.indexes();
  *
  * [Plugins](https://mongoosejs.com/docs/plugins.html) can use the return value of this function to modify a schema's indexes.
@@ -2481,16 +2521,16 @@ Schema.prototype.indexes = function() {
 /**
  * Creates a virtual type with the given name.
  *
- * @param {String} name The name of the Virtual
- * @param {Object} [options]
- * @param {String|Model} [options.ref] model name or model instance. Marks this as a [populate virtual](https://mongoosejs.com/docs/populate.html#populate-virtuals).
- * @param {String|Function} [options.localField] Required for populate virtuals. See [populate virtual docs](https://mongoosejs.com/docs/populate.html#populate-virtuals) for more information.
- * @param {String|Function} [options.foreignField] Required for populate virtuals. See [populate virtual docs](https://mongoosejs.com/docs/populate.html#populate-virtuals) for more information.
- * @param {Boolean|Function} [options.justOne=false] Only works with populate virtuals. If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), will be a single doc or `null`. Otherwise, the populate virtual will be an array.
- * @param {Boolean} [options.count=false] Only works with populate virtuals. If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), this populate virtual will contain the number of documents rather than the documents themselves when you `populate()`.
+ * @param {string} name The name of the Virtual
+ * @param {object} [options]
+ * @param {string|Model} [options.ref] model name or model instance. Marks this as a [populate virtual](https://mongoosejs.com/docs/populate.html#populate-virtuals).
+ * @param {string|Function} [options.localField] Required for populate virtuals. See [populate virtual docs](https://mongoosejs.com/docs/populate.html#populate-virtuals) for more information.
+ * @param {string|Function} [options.foreignField] Required for populate virtuals. See [populate virtual docs](https://mongoosejs.com/docs/populate.html#populate-virtuals) for more information.
+ * @param {boolean|Function} [options.justOne=false] Only works with populate virtuals. If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), will be a single doc or `null`. Otherwise, the populate virtual will be an array.
+ * @param {boolean} [options.count=false] Only works with populate virtuals. If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), this populate virtual will contain the number of documents rather than the documents themselves when you `populate()`.
  * @param {Function|null} [options.get=null] Adds a [getter](https://mongoosejs.com/docs/tutorials/getters-setters.html) to this virtual to transform the populated doc.
- * @param {Object|Function} [options.match=null] Apply a default [`match` option to populate](https://mongoosejs.com/docs/populate.html#match), adding an additional filter to the populate query.
- * @param {Boolean} [options.applyToArray=false] If true and the given `name` is a direct child of an array, apply the virtual to the array rather than the elements.
+ * @param {object|Function} [options.match=null] Apply a default [`match` option to populate](https://mongoosejs.com/docs/populate.html#match), adding an additional filter to the populate query.
+ * @param {boolean} [options.applyToArray=false] If true and the given `name` is a direct child of an array, apply the virtual to the array rather than the elements.
  * @return {VirtualType}
  */
 
@@ -2502,11 +2542,11 @@ Schema.prototype.virtual = function(name, options) {
 
   if (utils.hasUserDefinedProperty(options, ['ref', 'refPath'])) {
     if (options.localField == null) {
-      throw new Error('Reference virtuals require `localField` option');
+      throw new MongooseError('Reference virtuals require `localField` option');
     }
 
     if (options.foreignField == null) {
-      throw new Error('Reference virtuals require `foreignField` option');
+      throw new MongooseError('Reference virtuals require `foreignField` option');
     }
 
     const virtual = this.virtual(name);
@@ -2602,7 +2642,7 @@ Schema.prototype.virtual = function(name, options) {
   const parts = name.split('.');
 
   if (this.pathType(name) === 'real') {
-    throw new Error('Virtual path "' + name + '"' +
+    throw new MongooseError('Virtual path "' + name + '"' +
       ' conflicts with a real path in the schema');
   }
 
@@ -2613,9 +2653,9 @@ Schema.prototype.virtual = function(name, options) {
     return mem[part];
   }, this.tree);
 
-  if (options && options.applyToArray && parts.length > 1) {
+  if (options?.applyToArray && parts.length > 1) {
     const path = this.path(parts.slice(0, -1).join('.'));
-    if (path && path.$isMongooseArray) {
+    if (path?.$isMongooseArray) {
       return path.virtual(parts[parts.length - 1], options);
     } else {
       throw new MongooseError(`Path "${path}" is not an array`);
@@ -2628,7 +2668,7 @@ Schema.prototype.virtual = function(name, options) {
 /**
  * Returns the virtual type with the given `name`.
  *
- * @param {String} name The name of the Virtual to get
+ * @param {string} name The name of the Virtual to get
  * @return {VirtualType|null}
  */
 
@@ -2652,7 +2692,7 @@ Schema.prototype.virtualpath = function(name) {
  *     schema.path('name'); // Undefined
  *     schema.path('age'); // Undefined
  *
- * @param {String|Array} path The Path(s) to remove
+ * @param {string|Array} path The Path(s) to remove
  * @return {Schema} the Schema instance
  * @api public
  */
@@ -2710,7 +2750,7 @@ function _deletePath(schema, name) {
 /**
  * Removes the given virtual or virtuals from the schema.
  *
- * @param {String|Array} path The virutal path(s) to remove.
+ * @param {string|Array} path The virutal path(s) to remove.
  * @returns {Schema} the Schema instance, or a mongoose error if the virtual does not exist.
  * @api public
  */
@@ -2775,7 +2815,7 @@ Schema.prototype.removeVirtual = function(path) {
  * ```
  *
  * @param {Function} model The Class to load
- * @param {Boolean} [virtualsOnly] if truthy, only pulls virtuals from the class, not methods or statics
+ * @param {boolean} [virtualsOnly] if truthy, only pulls virtuals from the class, not methods or statics
  */
 Schema.prototype.loadClass = function(model, virtualsOnly) {
   // Stop copying when hit certain base classes
@@ -2854,11 +2894,11 @@ Schema.prototype._getSchema = function(path) {
       if (foundschema) {
         resultPath.push(trypath);
 
-        if (foundschema.caster) {
+        if (foundschema.embeddedSchemaType || foundschema.Constructor) {
           // array of Mixed?
-          if (foundschema.caster instanceof MongooseTypes.Mixed) {
-            foundschema.caster.$fullPath = resultPath.join('.');
-            return foundschema.caster;
+          if (foundschema.embeddedSchemaType instanceof MongooseTypes.Mixed) {
+            foundschema.embeddedSchemaType.$fullPath = resultPath.join('.');
+            return foundschema.embeddedSchemaType;
           }
 
           // Now that we found the array, we need to check if there
@@ -2868,8 +2908,8 @@ Schema.prototype._getSchema = function(path) {
           // If there is no foundschema.schema we are dealing with
           // a path like array.$
           if (p !== parts.length) {
-            if (p + 1 === parts.length && foundschema.$embeddedSchemaType && (parts[p] === '$' || isArrayFilter(parts[p]))) {
-              return foundschema.$embeddedSchemaType;
+            if (p + 1 === parts.length && foundschema.embeddedSchemaType && (parts[p] === '$' || isArrayFilter(parts[p]))) {
+              return foundschema.embeddedSchemaType;
             }
 
             if (foundschema.schema) {
@@ -2877,7 +2917,7 @@ Schema.prototype._getSchema = function(path) {
               if (parts[p] === '$' || isArrayFilter(parts[p])) {
                 if (p + 1 === parts.length) {
                   // comments.$
-                  return foundschema.$embeddedSchemaType;
+                  return foundschema.embeddedSchemaType;
                 }
                 // comments.$.comments.$.title
                 ret = search(parts.slice(p + 1), foundschema.schema);
@@ -2957,9 +2997,9 @@ Schema.prototype._getPathType = function(path) {
       trypath = parts.slice(0, p).join('.');
       foundschema = schema.path(trypath);
       if (foundschema) {
-        if (foundschema.caster) {
+        if (foundschema.embeddedSchemaType || foundschema.Constructor) {
           // array of Mixed?
-          if (foundschema.caster instanceof MongooseTypes.Mixed) {
+          if (foundschema.embeddedSchemaType instanceof MongooseTypes.Mixed) {
             return { schema: foundschema, pathType: 'mixed' };
           }
 
@@ -3049,8 +3089,27 @@ function isArrayFilter(piece) {
 
 Schema.prototype._preCompile = function _preCompile() {
   this.plugin(idGetter, { deduplicate: true });
+  _precomputeOptimisticConcurrency(this);
 };
 
+/*!
+ * Build precomputed sets for optimisticConcurrency include/exclude,
+ * expanding user-specified paths to include all schema subpaths so that
+ * lookups at save time are a simple `Set.has()`.
+ */
+
+function _precomputeOptimisticConcurrency(schema) {
+  const opt = schema.options.optimisticConcurrency;
+  if (!opt || opt === true) {
+    return;
+  }
+  if (Array.isArray(opt)) {
+    schema.options._optimisticConcurrencySet = new Set(opt);
+  } else if (Array.isArray(opt.exclude)) {
+    schema.options._optimisticConcurrencyExcludeSet = new Set(opt.exclude);
+  }
+}
+
 /**
  * Returns a JSON schema representation of this Schema.
  *
@@ -3062,15 +3121,15 @@ Schema.prototype._preCompile = function _preCompile() {
  * - `enum` for strings and numbers
  *
  * #### Example:
- *    const schema = new Schema({ name: String });
- *    // { required: ['_id'], properties: { name: { type: ['string', 'null'] }, _id: { type: 'string' } } }
- *    schema.toJSONSchema();
+ *     const schema = new Schema({ name: String });
+ *     // { required: ['_id'], properties: { name: { type: ['string', 'null'] }, _id: { type: 'string' } } }
+ *     schema.toJSONSchema();
  *
- *    // { required: ['_id'], properties: { name: { bsonType: ['string', 'null'] }, _id: { bsonType: 'objectId' } } }
- *    schema.toJSONSchema({ useBsonType: true });
+ *     // { required: ['_id'], properties: { name: { bsonType: ['string', 'null'] }, _id: { bsonType: 'objectId' } } }
+ *     schema.toJSONSchema({ useBsonType: true });
  *
- * @param {Object} [options]
- * @param [Boolean] [options.useBsonType=false] if true, specify each path's type using `bsonType` rather than `type` for MongoDB $jsonSchema support
+ * @param {object} [options]
+ * @param {boolean} [options.useBsonType=false] if true, specify each path's type using `bsonType` rather than `type` for MongoDB $jsonSchema support
  */
 
 Schema.prototype.toJSONSchema = function toJSONSchema(options) {
@@ -3079,7 +3138,7 @@ Schema.prototype.toJSONSchema = function toJSONSchema(options) {
   for (const path of Object.keys(this.paths)) {
     const schemaType = this.paths[path];
 
-    // Skip Map embedded paths, maps will be handled seperately.
+    // Skip Map embedded paths, maps will be handled separately.
     if (schemaType._presplitPath.indexOf('$*') !== -1) {
       continue;
     }