mongoose 8.9.7 → 8.10.1

package/lib/query.js

@@ -65,6 +65,25 @@ const queryOptionMethods = new Set([
   'wtimeout'
 ]);
 
+// Map from operation name to the name of the function that executes the actual operation against MongoDB.
+// Called a thunk for legacy reasons, "thunk" means function that takes exactly 1 param, a callback.
+// Currently `_countDocuments()`, etc. are async functions that take no params.
+const opToThunk = new Map([
+  ['countDocuments', '_countDocuments'],
+  ['distinct', '__distinct'],
+  ['estimatedDocumentCount', '_estimatedDocumentCount'],
+  ['find', '_find'],
+  ['findOne', '_findOne'],
+  ['findOneAndReplace', '_findOneAndReplace'],
+  ['findOneAndUpdate', '_findOneAndUpdate'],
+  ['replaceOne', '_replaceOne'],
+  ['updateMany', '_updateMany'],
+  ['updateOne', '_updateOne'],
+  ['deleteMany', '_deleteMany'],
+  ['deleteOne', '_deleteOne'],
+  ['findOneAndDelete', '_findOneAndDelete']
+]);
+
 /**
  * Query constructor used for building queries. You do not need
  * to instantiate a `Query` directly. Instead use Model functions like
@@ -2337,18 +2356,17 @@ Query.prototype._find = async function _find() {
   }
 
   const mongooseOptions = this._mongooseOptions;
-  const _this = this;
-  const userProvidedFields = _this._userProvidedFields || {};
+  const userProvidedFields = this._userProvidedFields || {};
 
   applyGlobalMaxTimeMS(this.options, this.model.db.options, this.model.base.options);
   applyGlobalDiskUse(this.options, this.model.db.options, this.model.base.options);
 
   // Separate options to pass down to `completeMany()` in case we need to
   // set a session on the document
-  const completeManyOptions = Object.assign({}, {
+  const completeManyOptions = {
     session: this && this.options && this.options.session || null,
     lean: mongooseOptions.lean || null
-  });
+  };
 
   const options = this._optionsForExec();
 
@@ -2366,7 +2384,7 @@ Query.prototype._find = async function _find() {
   }
 
   if (!mongooseOptions.populate) {
-    const versionKey = _this.schema.options.versionKey;
+    const versionKey = this.schema.options.versionKey;
     if (mongooseOptions.lean && mongooseOptions.lean.versionKey === false && versionKey) {
       docs.forEach((doc) => {
         if (versionKey in doc) {
@@ -2375,17 +2393,17 @@ Query.prototype._find = async function _find() {
       });
     }
     return mongooseOptions.lean ?
-      _completeManyLean(_this.model.schema, docs, null, completeManyOptions) :
-      _this._completeMany(docs, fields, userProvidedFields, completeManyOptions);
+      _completeManyLean(this.model.schema, docs, null, completeManyOptions) :
+      this._completeMany(docs, fields, userProvidedFields, completeManyOptions);
   }
 
-  const pop = helpers.preparePopulationOptionsMQ(_this, mongooseOptions);
+  const pop = helpers.preparePopulationOptionsMQ(this, mongooseOptions);
 
   if (mongooseOptions.lean) {
-    return _this.model.populate(docs, pop);
+    return this.model.populate(docs, pop);
   }
 
-  docs = await _this._completeMany(docs, fields, userProvidedFields, completeManyOptions);
+  docs = await this._completeMany(docs, fields, userProvidedFields, completeManyOptions);
   await this.model.populate(docs, pop);
 
   return docs;
@@ -3992,6 +4010,10 @@ Query.prototype._replaceOne = async function _replaceOne() {
  *     res.n; // Number of documents matched
  *     res.nModified; // Number of documents modified
  *
+ *     // Other supported syntaxes
+ *     await Person.find({ name: /Stark$/ }).updateMany({ isDeleted: true }); // Using chaining syntax
+ *     await Person.find().updateMany({ isDeleted: true }); // Set `isDeleted` on _all_ Person documents
+ *
  * This function triggers the following middleware.
  *
  * - `updateMany()`
@@ -4062,6 +4084,10 @@ Query.prototype.updateMany = function(conditions, doc, options, callback) {
  *     res.upsertedCount; // Number of documents that were upserted
  *     res.upsertedId; // Identifier of the inserted document (if an upsert took place)
  *
+ *     // Other supported syntaxes
+ *     await Person.findOne({ name: 'Jean-Luc Picard' }).updateOne({ ship: 'USS Enterprise' }); // Using chaining syntax
+ *     await Person.updateOne({ ship: 'USS Enterprise' }); // Updates first doc's `ship` property
+ *
  * This function triggers the following middleware.
  *
  * - `updateOne()`
@@ -4389,22 +4415,14 @@ Query.prototype.exec = async function exec(op) {
   if (this.model == null) {
     throw new MongooseError('Query must have an associated model before executing');
   }
-  this._validateOp();
 
-  if (!this.op) {
-    return;
+  const thunk = opToThunk.get(this.op);
+  if (!thunk) {
+    throw new MongooseError('Query has invalid `op`: "' + this.op + '"');
   }
 
-  if (this.options && this.options.sort) {
-    const keys = Object.keys(this.options.sort);
-    if (keys.includes('')) {
-      throw new Error('Invalid field "" passed to sort()');
-    }
-  }
-
-  let thunk = '_' + this.op;
-  if (this.op === 'distinct') {
-    thunk = '__distinct';
+  if (this.options && this.options.sort && typeof this.options.sort === 'object' && this.options.sort.hasOwnProperty('')) {
+    throw new Error('Invalid field "" passed to sort()');
   }
 
   if (this._executionStack != null) {

package/lib/schema/array.js

@@ -21,6 +21,7 @@ const isOperator = require('../helpers/query/isOperator');
 const util = require('util');
 const utils = require('../utils');
 const castToNumber = require('./operators/helpers').castToNumber;
+const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const geospatial = require('./operators/geospatial');
 const getDiscriminatorByValue = require('../helpers/discriminator/getDiscriminatorByValue');
 
@@ -403,6 +404,9 @@ SchemaArray.prototype.cast = function(value, doc, init, prev, options) {
               opts.arrayPathIndex = i;
             }
           }
+          if (options.hydratedPopulatedDocs) {
+            opts.hydratedPopulatedDocs = options.hydratedPopulatedDocs;
+          }
           rawValue[i] = caster.applySetters(rawValue[i], doc, init, void 0, opts);
         }
       } catch (e) {
@@ -697,6 +701,23 @@ handle.$ne = SchemaArray.prototype._castForQuery;
 handle.$nin = SchemaType.prototype.$conditionalHandlers.$nin;
 handle.$in = SchemaType.prototype.$conditionalHandlers.$in;
 
+/**
+ * Returns this schema type's representation in a JSON schema.
+ *
+ * @param [options]
+ * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {Object} JSON schema properties
+ */
+
+SchemaArray.prototype.toJSONSchema = function toJSONSchema(options) {
+  const embeddedSchemaType = this.getEmbeddedSchemaType();
+  const isRequired = this.options.required && typeof this.options.required !== 'function';
+  return {
+    ...createJSONSchemaTypeDefinition('array', 'array', options?.useBsonType, isRequired),
+    items: embeddedSchemaType.toJSONSchema(options)
+  };
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/bigint.js

@@ -7,6 +7,7 @@
 const CastError = require('../error/cast');
 const SchemaType = require('../schemaType');
 const castBigInt = require('../cast/bigint');
+const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 
 /**
  * BigInt SchemaType constructor.
@@ -240,6 +241,19 @@ SchemaBigInt.prototype._castNullish = function _castNullish(v) {
   return v;
 };
 
+/**
+ * Returns this schema type's representation in a JSON schema.
+ *
+ * @param [options]
+ * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {Object} JSON schema properties
+ */
+
+SchemaBigInt.prototype.toJSONSchema = function toJSONSchema(options) {
+  const isRequired = this.options.required && typeof this.options.required !== 'function';
+  return createJSONSchemaTypeDefinition('string', 'long', options?.useBsonType, isRequired);
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/boolean.js

@@ -7,6 +7,7 @@
 const CastError = require('../error/cast');
 const SchemaType = require('../schemaType');
 const castBoolean = require('../cast/boolean');
+const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 
 /**
  * Boolean SchemaType constructor.
@@ -290,6 +291,19 @@ SchemaBoolean.prototype._castNullish = function _castNullish(v) {
   return v;
 };
 
+/**
+ * Returns this schema type's representation in a JSON schema.
+ *
+ * @param [options]
+ * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {Object} JSON schema properties
+ */
+
+SchemaBoolean.prototype.toJSONSchema = function toJSONSchema(options) {
+  const isRequired = this.options.required && typeof this.options.required !== 'function';
+  return createJSONSchemaTypeDefinition('boolean', 'bool', options?.useBsonType, isRequired);
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/buffer.js

@@ -7,6 +7,7 @@
 const MongooseBuffer = require('../types/buffer');
 const SchemaBufferOptions = require('../options/schemaBufferOptions');
 const SchemaType = require('../schemaType');
+const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const handleBitwiseOperator = require('./operators/bitwise');
 const utils = require('../utils');
 
@@ -140,7 +141,7 @@ SchemaBuffer.prototype.checkRequired = function(value, doc) {
  * @api private
  */
 
-SchemaBuffer.prototype.cast = function(value, doc, init) {
+SchemaBuffer.prototype.cast = function(value, doc, init, prev, options) {
   let ret;
   if (SchemaType._isRef(this, value, doc, init)) {
     if (value && value.isMongooseBuffer) {
@@ -167,7 +168,7 @@ SchemaBuffer.prototype.cast = function(value, doc, init) {
     }
 
     if (value == null || utils.isNonBuiltinObject(value)) {
-      return this._castRef(value, doc, init);
+      return this._castRef(value, doc, init, options);
     }
   }
 
@@ -300,6 +301,19 @@ SchemaBuffer.prototype.castForQuery = function($conditional, val, context) {
   return casted ? casted.toObject({ transform: false, virtuals: false }) : casted;
 };
 
+/**
+ * Returns this schema type's representation in a JSON schema.
+ *
+ * @param [options]
+ * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {Object} JSON schema properties
+ */
+
+SchemaBuffer.prototype.toJSONSchema = function toJSONSchema(options) {
+  const isRequired = this.options.required && typeof this.options.required !== 'function';
+  return createJSONSchemaTypeDefinition('string', 'binData', options?.useBsonType, isRequired);
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/date.js

@@ -8,6 +8,7 @@ const MongooseError = require('../error/index');
 const SchemaDateOptions = require('../options/schemaDateOptions');
 const SchemaType = require('../schemaType');
 const castDate = require('../cast/date');
+const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const getConstructorName = require('../helpers/getConstructorName');
 const utils = require('../utils');
 
@@ -426,6 +427,19 @@ SchemaDate.prototype.castForQuery = function($conditional, val, context) {
   return handler.call(this, val);
 };
 
+/**
+ * Returns this schema type's representation in a JSON schema.
+ *
+ * @param [options]
+ * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {Object} JSON schema properties
+ */
+
+SchemaDate.prototype.toJSONSchema = function toJSONSchema(options) {
+  const isRequired = this.options.required && typeof this.options.required !== 'function';
+  return createJSONSchemaTypeDefinition('string', 'date', options?.useBsonType, isRequired);
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/decimal128.js

@@ -7,6 +7,7 @@
 const SchemaType = require('../schemaType');
 const CastError = SchemaType.CastError;
 const castDecimal128 = require('../cast/decimal128');
+const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const isBsonType = require('../helpers/isBsonType');
 
 /**
@@ -180,13 +181,13 @@ SchemaDecimal128.prototype.checkRequired = function checkRequired(value, doc) {
  * @api private
  */
 
-SchemaDecimal128.prototype.cast = function(value, doc, init) {
+SchemaDecimal128.prototype.cast = function(value, doc, init, prev, options) {
   if (SchemaType._isRef(this, value, doc, init)) {
     if (isBsonType(value, 'Decimal128')) {
       return value;
     }
 
-    return this._castRef(value, doc, init);
+    return this._castRef(value, doc, init, options);
   }
 
   let castDecimal128;
@@ -221,6 +222,19 @@ SchemaDecimal128.prototype.$conditionalHandlers = {
   $lte: handleSingle
 };
 
+/**
+ * Returns this schema type's representation in a JSON schema.
+ *
+ * @param [options]
+ * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {Object} JSON schema properties
+ */
+
+SchemaDecimal128.prototype.toJSONSchema = function toJSONSchema(options) {
+  const isRequired = this.options.required && typeof this.options.required !== 'function';
+  return createJSONSchemaTypeDefinition('string', 'decimal', options?.useBsonType, isRequired);
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/documentArray.js

@@ -12,6 +12,7 @@ const SchemaDocumentArrayOptions =
   require('../options/schemaDocumentArrayOptions');
 const SchemaType = require('../schemaType');
 const cast = require('../cast');
+const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const discriminator = require('../helpers/model/discriminator');
 const handleIdOption = require('../helpers/schema/handleIdOption');
 const handleSpreadDoc = require('../helpers/document/handleSpreadDoc');
@@ -651,6 +652,23 @@ function cast$elemMatch(val, context) {
   return cast(schema, val, null, this && this.$$context);
 }
 
+/**
+ * Returns this schema type's representation in a JSON schema.
+ *
+ * @param [options]
+ * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {Object} JSON schema properties
+ */
+
+SchemaDocumentArray.prototype.toJSONSchema = function toJSONSchema(options) {
+  const itemsTypeDefinition = createJSONSchemaTypeDefinition('object', 'object', options?.useBsonType, false);
+  const isRequired = this.options.required && typeof this.options.required !== 'function';
+  return {
+    ...createJSONSchemaTypeDefinition('array', 'array', options?.useBsonType, isRequired),
+    items: { ...itemsTypeDefinition, ...this.schema.toJSONSchema(options) }
+  };
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/double.js

@@ -7,6 +7,7 @@
 const CastError = require('../error/cast');
 const SchemaType = require('../schemaType');
 const castDouble = require('../cast/double');
+const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 
 /**
  * Double SchemaType constructor.
@@ -204,6 +205,18 @@ SchemaDouble.prototype.$conditionalHandlers = {
   $lte: handleSingle
 };
 
+/**
+ * Returns this schema type's representation in a JSON schema.
+ *
+ * @param [options]
+ * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {Object} JSON schema properties
+ */
+
+SchemaDouble.prototype.toJSONSchema = function toJSONSchema(options) {
+  const isRequired = this.options.required && typeof this.options.required !== 'function';
+  return createJSONSchemaTypeDefinition('number', 'double', options?.useBsonType, isRequired);
+};
 
 /*!
  * Module exports.

package/lib/schema/int32.js

@@ -7,6 +7,7 @@
 const CastError = require('../error/cast');
 const SchemaType = require('../schemaType');
 const castInt32 = require('../cast/int32');
+const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const handleBitwiseOperator = require('./operators/bitwise');
 
 /**
@@ -246,6 +247,19 @@ SchemaInt32.prototype.castForQuery = function($conditional, val, context) {
   }
 };
 
+/**
+ * Returns this schema type's representation in a JSON schema.
+ *
+ * @param [options]
+ * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {Object} JSON schema properties
+ */
+
+SchemaInt32.prototype.toJSONSchema = function toJSONSchema(options) {
+  const isRequired = this.options.required && typeof this.options.required !== 'function';
+  return createJSONSchemaTypeDefinition('number', 'int', options?.useBsonType, isRequired);
+};
+
 
 /*!
  * Module exports.

package/lib/schema/map.js

@@ -7,6 +7,8 @@
 const MongooseMap = require('../types/map');
 const SchemaMapOptions = require('../options/schemaMapOptions');
 const SchemaType = require('../schemaType');
+const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
+
 /*!
  * ignore
  */
@@ -67,6 +69,32 @@ class SchemaMap extends SchemaType {
     }
     return schematype;
   }
+
+  /**
+   * Returns the embedded schema type (i.e. the `.$*` path)
+   */
+  getEmbeddedSchemaType() {
+    return this.$__schemaType;
+  }
+
+  /**
+   * Returns this schema type's representation in a JSON schema.
+   *
+   * @param [options]
+   * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+   * @returns {Object} JSON schema properties
+   */
+
+  toJSONSchema(options) {
+    const useBsonType = options?.useBsonType;
+    const embeddedSchemaType = this.getEmbeddedSchemaType();
+
+    const isRequired = this.options.required && typeof this.options.required !== 'function';
+    const result = createJSONSchemaTypeDefinition('object', 'object', useBsonType, isRequired);
+    result.additionalProperties = embeddedSchemaType.toJSONSchema(options);
+
+    return result;
+  }
 }
 
 /**

package/lib/schema/number.js

@@ -8,6 +8,7 @@ const MongooseError = require('../error/index');
 const SchemaNumberOptions = require('../options/schemaNumberOptions');
 const SchemaType = require('../schemaType');
 const castNumber = require('../cast/number');
+const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const handleBitwiseOperator = require('./operators/bitwise');
 const utils = require('../utils');
 
@@ -354,10 +355,10 @@ SchemaNumber.prototype.enum = function(values, message) {
  * @api private
  */
 
-SchemaNumber.prototype.cast = function(value, doc, init) {
+SchemaNumber.prototype.cast = function(value, doc, init, prev, options) {
   if (typeof value !== 'number' && SchemaType._isRef(this, value, doc, init)) {
     if (value == null || utils.isNonBuiltinObject(value)) {
-      return this._castRef(value, doc, init);
+      return this._castRef(value, doc, init, options);
     }
   }
 
@@ -442,6 +443,19 @@ SchemaNumber.prototype.castForQuery = function($conditional, val, context) {
   return val;
 };
 
+/**
+ * Returns this schema type's representation in a JSON schema.
+ *
+ * @param [options]
+ * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {Object} JSON schema properties
+ */
+
+SchemaNumber.prototype.toJSONSchema = function toJSONSchema(options) {
+  const isRequired = (this.options.required && typeof this.options.required !== 'function') || this.path === '_id';
+  return createJSONSchemaTypeDefinition('number', 'number', options?.useBsonType, isRequired);
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/objectId.js

@@ -7,6 +7,7 @@
 const SchemaObjectIdOptions = require('../options/schemaObjectIdOptions');
 const SchemaType = require('../schemaType');
 const castObjectId = require('../cast/objectid');
+const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const getConstructorName = require('../helpers/getConstructorName');
 const oid = require('../types/objectid');
 const isBsonType = require('../helpers/isBsonType');
@@ -223,7 +224,7 @@ SchemaObjectId.prototype.checkRequired = function checkRequired(value, doc) {
  * @api private
  */
 
-SchemaObjectId.prototype.cast = function(value, doc, init) {
+SchemaObjectId.prototype.cast = function(value, doc, init, prev, options) {
   if (!(isBsonType(value, 'ObjectId')) && SchemaType._isRef(this, value, doc, init)) {
     // wait! we may need to cast this to a document
     if ((getConstructorName(value) || '').toLowerCase() === 'objectid') {
@@ -231,7 +232,7 @@ SchemaObjectId.prototype.cast = function(value, doc, init) {
     }
 
     if (value == null || utils.isNonBuiltinObject(value)) {
-      return this._castRef(value, doc, init);
+      return this._castRef(value, doc, init, options);
     }
   }
 
@@ -290,6 +291,19 @@ function resetId(v) {
   return v;
 }
 
+/**
+ * Returns this schema type's representation in a JSON schema.
+ *
+ * @param [options]
+ * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {Object} JSON schema properties
+ */
+
+SchemaObjectId.prototype.toJSONSchema = function toJSONSchema(options) {
+  const isRequired = (this.options.required && typeof this.options.required !== 'function') || this.path === '_id';
+  return createJSONSchemaTypeDefinition('string', 'objectId', options?.useBsonType, isRequired);
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/string.js

@@ -8,6 +8,7 @@ const SchemaType = require('../schemaType');
 const MongooseError = require('../error/index');
 const SchemaStringOptions = require('../options/schemaStringOptions');
 const castString = require('../cast/string');
+const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const utils = require('../utils');
 const isBsonType = require('../helpers/isBsonType');
 
@@ -586,9 +587,9 @@ SchemaString.prototype.checkRequired = function checkRequired(value, doc) {
  * @api private
  */
 
-SchemaString.prototype.cast = function(value, doc, init) {
+SchemaString.prototype.cast = function(value, doc, init, prev, options) {
   if (typeof value !== 'string' && SchemaType._isRef(this, value, doc, init)) {
-    return this._castRef(value, doc, init);
+    return this._castRef(value, doc, init, options);
   }
 
   let castString;
@@ -698,6 +699,19 @@ SchemaString.prototype.castForQuery = function($conditional, val, context) {
   }
 };
 
+/**
+ * Returns this schema type's representation in a JSON schema.
+ *
+ * @param [options]
+ * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {Object} JSON schema properties
+ */
+
+SchemaString.prototype.toJSONSchema = function toJSONSchema(options) {
+  const isRequired = this.options.required && typeof this.options.required !== 'function';
+  return createJSONSchemaTypeDefinition('string', 'string', options?.useBsonType, isRequired);
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/subdocument.js

@@ -12,6 +12,7 @@ const SchemaType = require('../schemaType');
 const applyDefaults = require('../helpers/document/applyDefaults');
 const $exists = require('./operators/exists');
 const castToNumber = require('./operators/helpers').castToNumber;
+const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const discriminator = require('../helpers/model/discriminator');
 const geospatial = require('./operators/geospatial');
 const getConstructor = require('../helpers/discriminator/getConstructor');
@@ -396,3 +397,19 @@ SchemaSubdocument.prototype.clone = function() {
   schematype._appliedDiscriminators = this._appliedDiscriminators;
   return schematype;
 };
+
+/**
+ * Returns this schema type's representation in a JSON schema.
+ *
+ * @param [options]
+ * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {Object} JSON schema properties
+ */
+
+SchemaSubdocument.prototype.toJSONSchema = function toJSONSchema(options) {
+  const isRequired = this.options.required && typeof this.options.required !== 'function';
+  return {
+    ...this.schema.toJSONSchema(options),
+    ...createJSONSchemaTypeDefinition('object', 'object', options?.useBsonType, isRequired)
+  };
+};

package/lib/schema/uuid.js

@@ -8,6 +8,7 @@ const MongooseBuffer = require('../types/buffer');
 const SchemaType = require('../schemaType');
 const CastError = SchemaType.CastError;
 const castUUID = require('../cast/uuid');
+const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const utils = require('../utils');
 const handleBitwiseOperator = require('./operators/bitwise');
 
@@ -201,10 +202,10 @@ SchemaUUID.prototype.checkRequired = function checkRequired(value) {
  * @api private
  */
 
-SchemaUUID.prototype.cast = function(value, doc, init) {
+SchemaUUID.prototype.cast = function(value, doc, init, prev, options) {
   if (utils.isNonBuiltinObject(value) &&
       SchemaType._isRef(this, value, doc, init)) {
-    return this._castRef(value, doc, init);
+    return this._castRef(value, doc, init, options);
   }
 
   let castFn;
@@ -284,6 +285,19 @@ SchemaUUID.prototype.castForQuery = function($conditional, val, context) {
   }
 };
 
+/**
+ * Returns this schema type's representation in a JSON schema.
+ *
+ * @param [options]
+ * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {Object} JSON schema properties
+ */
+
+SchemaUUID.prototype.toJSONSchema = function toJSONSchema(options) {
+  const isRequired = this.options.required && typeof this.options.required !== 'function';
+  return createJSONSchemaTypeDefinition('string', 'binData', options?.useBsonType, isRequired);
+};
+
 /*!
  * Module exports.
  */