mongoose 8.9.7 → 8.10.1

package/lib/schema.js

@@ -1118,6 +1118,9 @@ Schema.prototype.path = function(path, obj) {
   this.paths[path] = this.interpretAsType(path, obj, this.options);
   const schemaType = this.paths[path];
 
+  // If overwriting an existing path, make sure to clear the childSchemas
+  this.childSchemas = this.childSchemas.filter(childSchema => childSchema.path !== path);
+
   if (schemaType.$isSchemaMap) {
     // Maps can have arbitrary keys, so `$*` is internal shorthand for "any key"
     // The '$' is to imply this path should never be stored in MongoDB so we
@@ -1939,13 +1942,11 @@ Schema.prototype.pre = function(name) {
  *     const Model = mongoose.model('Model', schema);
  *
  *     const m = new Model(..);
- *     m.save(function(err) {
- *       console.log('this fires after the `post` hook');
- *     });
+ *     await m.save();
+ *     console.log('this fires after the `post` hook');
  *
- *     m.find(function(err, docs) {
- *       console.log('this fires after the post find hook');
- *     });
+ *     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]
@@ -2382,9 +2383,15 @@ Schema.prototype.virtual = function(name, options) {
             const PopulateModel = this.db.model(modelNames[0]);
             for (let i = 0; i < populatedVal.length; ++i) {
               if (!populatedVal[i].$__) {
-                populatedVal[i] = PopulateModel.hydrate(populatedVal[i]);
+                populatedVal[i] = PopulateModel.hydrate(populatedVal[i], null, { hydratedPopulatedDocs: true });
               }
             }
+            const foreignField = options.foreignField;
+            this.$populated(
+              name,
+              populatedVal.map(doc => doc == null ? doc : doc.get(typeof foreignField === 'function' ? foreignField.call(doc, doc) : foreignField)),
+              { populateModelSymbol: PopulateModel }
+            );
           }
         }
 
@@ -2882,6 +2889,92 @@ Schema.prototype._preCompile = function _preCompile() {
   this.plugin(idGetter, { deduplicate: true });
 };
 
+/**
+ * Returns a JSON schema representation of this Schema.
+ *
+ * By default, returns normal [JSON schema representation](https://json-schema.org/learn/getting-started-step-by-step), which is not typically what you want to use with
+ * [MongoDB's `$jsonSchema` collection option](https://www.mongodb.com/docs/manual/core/schema-validation/specify-json-schema/).
+ * Use the `useBsonType: true` option to return MongoDB `$jsonSchema` syntax instead.
+ *
+ * In addition to types, `jsonSchema()` supports the following Mongoose validators:
+ * - `enum` for strings and numbers
+ *
+ * #### Example:
+ *    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 });
+ *
+ * @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) {
+  const useBsonType = options?.useBsonType ?? false;
+  const result = useBsonType ? { required: [], properties: {} } : { type: 'object', required: [], properties: {} };
+  for (const path of Object.keys(this.paths)) {
+    const schemaType = this.paths[path];
+
+    // Skip Map embedded paths, maps will be handled seperately.
+    if (schemaType._presplitPath.indexOf('$*') !== -1) {
+      continue;
+    }
+
+    // Nested paths are stored as `nested.path` in the schema type, so create nested paths in the json schema
+    // when necessary.
+    const isNested = schemaType._presplitPath.length > 1;
+    let jsonSchemaForPath = result;
+    if (isNested) {
+      for (let i = 0; i < schemaType._presplitPath.length - 1; ++i) {
+        const subpath = schemaType._presplitPath[i];
+        if (jsonSchemaForPath.properties[subpath] == null) {
+          jsonSchemaForPath.properties[subpath] = useBsonType
+            ? {
+              bsonType: ['object', 'null'],
+              properties: {}
+            }
+            : {
+              type: ['object', 'null'],
+              properties: {}
+            };
+        }
+        jsonSchemaForPath = jsonSchemaForPath.properties[subpath];
+      }
+    }
+
+    const lastSubpath = schemaType._presplitPath[schemaType._presplitPath.length - 1];
+    let isRequired = false;
+    if (path === '_id') {
+      if (!jsonSchemaForPath.required) {
+        jsonSchemaForPath.required = [];
+      }
+      jsonSchemaForPath.required.push('_id');
+      isRequired = true;
+    } else if (schemaType.options.required && typeof schemaType.options.required !== 'function') {
+      if (!jsonSchemaForPath.required) {
+        jsonSchemaForPath.required = [];
+      }
+      // Only `required: true` paths are required, conditional required is not required
+      jsonSchemaForPath.required.push(lastSubpath);
+      isRequired = true;
+    }
+    jsonSchemaForPath.properties[lastSubpath] = schemaType.toJSONSchema(options);
+    if (schemaType.options.enum) {
+      jsonSchemaForPath.properties[lastSubpath].enum = isRequired
+        ? schemaType.options.enum
+        : [...schemaType.options.enum, null];
+    }
+  }
+
+  // Otherwise MongoDB errors with "$jsonSchema keyword 'required' cannot be an empty array"
+  if (result.required.length === 0) {
+    delete result.required;
+  }
+  return result;
+};
+
 /*!
  * Module exports.
  */

package/lib/schemaType.js

@@ -1555,7 +1555,7 @@ SchemaType._isRef = function(self, value, doc, init) {
  * ignore
  */
 
-SchemaType.prototype._castRef = function _castRef(value, doc, init) {
+SchemaType.prototype._castRef = function _castRef(value, doc, init, options) {
   if (value == null) {
     return value;
   }
@@ -1587,7 +1587,7 @@ SchemaType.prototype._castRef = function _castRef(value, doc, init) {
     !doc.$__.populated[path].options.options ||
     !doc.$__.populated[path].options.options.lean) {
     const PopulatedModel = pop ? pop.options[populateModelSymbol] : doc.constructor.db.model(this.options.ref);
-    ret = new PopulatedModel(value);
+    ret = PopulatedModel.hydrate(value, null, options);
     ret.$__.wasPopulated = { value: ret._doc._id, options: { [populateModelSymbol]: PopulatedModel } };
   }
 
@@ -1771,6 +1771,18 @@ SchemaType.prototype.getEmbeddedSchemaType = function getEmbeddedSchemaType() {
 
 SchemaType.prototype._duplicateKeyErrorMessage = null;
 
+/**
+ * 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
+ */
+
+SchemaType.prototype.toJSONSchema = function toJSONSchema() {
+  throw new Error('Converting unsupported SchemaType to JSON Schema: ' + this.instance);
+};
+
 /*!
  * Module exports.
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.9.7",
+  "version": "8.10.1",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -17,11 +17,12 @@
     "orm",
     "db"
   ],
+  "type": "commonjs",
   "license": "MIT",
   "dependencies": {
     "bson": "^6.10.1",
     "kareem": "2.6.3",
-    "mongodb": "~6.12.0",
+    "mongodb": "~6.13.0",
     "mpath": "0.9.0",
     "mquery": "5.0.0",
     "ms": "2.1.3",
@@ -35,6 +36,7 @@
     "acquit": "1.3.0",
     "acquit-ignore": "0.2.1",
     "acquit-require": "0.1.1",
+    "ajv": "8.17.1",
     "assert-browserify": "2.0.0",
     "babel-loader": "8.2.5",
     "broken-link-checker": "^0.7.8",
@@ -102,6 +104,8 @@
     "test-deno": "deno run --allow-env --allow-read --allow-net --allow-run --allow-sys --allow-write ./test/deno.js",
     "test-rs": "START_REPLICA_SET=1 mocha --timeout 30000 --exit ./test/*.test.js",
     "test-tsd": "node ./test/types/check-types-filename && tsd",
+    "setup-test-encryption": "bash scripts/configure-cluster-with-encryption.sh",
+    "test-encryption": "mocha --exit ./test/encryption/*.test.js",
     "tdd": "mocha ./test/*.test.js --inspect --watch --recursive --watch-files ./**/*.{js,ts}",
     "test-coverage": "nyc --reporter=html --reporter=text npm test",
     "ts-benchmark": "cd ./benchmarks/typescript/simple && npm install && npm run benchmark | node ../../../scripts/tsc-diagnostics-check"

package/types/connection.d.ts

@@ -59,6 +59,8 @@ declare module 'mongoose' {
   }
 
   class Connection extends events.EventEmitter implements SessionStarter {
+    aggregate<ResultType = unknown>(pipeline?: PipelineStage[] | null, options?: AggregateOptions): Aggregate<Array<ResultType>>;
+
     /** Returns a promise that resolves when this connection successfully connects to MongoDB */
     asPromise(): Promise<this>;
 

package/types/document.d.ts

@@ -256,21 +256,21 @@ declare module 'mongoose' {
     set(value: string | Record<string, any>): this;
 
     /** The return value of this method is used in calls to JSON.stringify(doc). */
-    toJSON(options?: ToObjectOptions & { flattenMaps?: true, flattenObjectIds?: false }): FlattenMaps<Require_id<DocType>>;
-    toJSON(options: ToObjectOptions & { flattenObjectIds: false }): FlattenMaps<Require_id<DocType>>;
-    toJSON(options: ToObjectOptions & { flattenObjectIds: true }): ObjectIdToString<FlattenMaps<Require_id<DocType>>>;
-    toJSON(options: ToObjectOptions & { flattenMaps: false }): Require_id<DocType>;
-    toJSON(options: ToObjectOptions & { flattenMaps: false; flattenObjectIds: true }): ObjectIdToString<Require_id<DocType>>;
-
-    toJSON<T = Require_id<DocType>>(options?: ToObjectOptions & { flattenMaps?: true, flattenObjectIds?: false }): FlattenMaps<T>;
-    toJSON<T = Require_id<DocType>>(options: ToObjectOptions & { flattenObjectIds: false }): FlattenMaps<T>;
-    toJSON<T = Require_id<DocType>>(options: ToObjectOptions & { flattenObjectIds: true }): ObjectIdToString<FlattenMaps<T>>;
-    toJSON<T = Require_id<DocType>>(options: ToObjectOptions & { flattenMaps: false }): T;
-    toJSON<T = Require_id<DocType>>(options: ToObjectOptions & { flattenMaps: false; flattenObjectIds: true }): ObjectIdToString<T>;
+    toJSON(options?: ToObjectOptions & { flattenMaps?: true, flattenObjectIds?: false }): FlattenMaps<Default__v<Require_id<DocType>>>;
+    toJSON(options: ToObjectOptions & { flattenObjectIds: false }): FlattenMaps<Default__v<Require_id<DocType>>>;
+    toJSON(options: ToObjectOptions & { flattenObjectIds: true }): ObjectIdToString<FlattenMaps<Default__v<Require_id<DocType>>>>;
+    toJSON(options: ToObjectOptions & { flattenMaps: false }): Default__v<Require_id<DocType>>;
+    toJSON(options: ToObjectOptions & { flattenMaps: false; flattenObjectIds: true }): ObjectIdToString<Default__v<Require_id<DocType>>>;
+
+    toJSON<T = Default__v<Require_id<DocType>>>(options?: ToObjectOptions & { flattenMaps?: true, flattenObjectIds?: false }): FlattenMaps<T>;
+    toJSON<T = Default__v<Require_id<DocType>>>(options: ToObjectOptions & { flattenObjectIds: false }): FlattenMaps<T>;
+    toJSON<T = Default__v<Require_id<DocType>>>(options: ToObjectOptions & { flattenObjectIds: true }): ObjectIdToString<FlattenMaps<T>>;
+    toJSON<T = Default__v<Require_id<DocType>>>(options: ToObjectOptions & { flattenMaps: false }): T;
+    toJSON<T = Default__v<Require_id<DocType>>>(options: ToObjectOptions & { flattenMaps: false; flattenObjectIds: true }): ObjectIdToString<T>;
 
     /** Converts this document into a plain-old JavaScript object ([POJO](https://masteringjs.io/tutorials/fundamentals/pojo)). */
-    toObject(options?: ToObjectOptions): Require_id<DocType>;
-    toObject<T>(options?: ToObjectOptions): Require_id<T>;
+    toObject(options?: ToObjectOptions): Default__v<Require_id<DocType>>;
+    toObject<T>(options?: ToObjectOptions): Default__v<Require_id<T>>;
 
     /** Clears the modified state on the specified path. */
     unmarkModified<T extends keyof DocType>(path: T): void;

package/types/index.d.ts

@@ -273,10 +273,10 @@ declare module 'mongoose' {
     /**
      * Create a new schema
      */
-    constructor(definition?: SchemaDefinition<SchemaDefinitionType<RawDocType>, RawDocType> | DocType, options?: SchemaOptions<FlatRecord<DocType>, TInstanceMethods, TQueryHelpers, TStaticMethods, TVirtuals, THydratedDocumentType> | ResolveSchemaOptions<TSchemaOptions>);
+    constructor(definition?: SchemaDefinition<SchemaDefinitionType<RawDocType>, RawDocType, THydratedDocumentType> | DocType, options?: SchemaOptions<FlatRecord<DocType>, TInstanceMethods, TQueryHelpers, TStaticMethods, TVirtuals, THydratedDocumentType> | ResolveSchemaOptions<TSchemaOptions>);
 
     /** Adds key path / schema type pairs to this schema. */
-    add(obj: SchemaDefinition<SchemaDefinitionType<RawDocType>> | Schema, prefix?: string): this;
+    add(obj: SchemaDefinition<SchemaDefinitionType<RawDocType>, RawDocType> | Schema, prefix?: string): this;
 
     /**
      * Add an alias for `path`. This means getting or setting the `alias`
@@ -297,7 +297,7 @@ declare module 'mongoose' {
     /** Returns a copy of this schema */
     clone<T = this>(): T;
 
-    discriminator<DisSchema = Schema>(name: string | number, schema: DisSchema): this;
+    discriminator<DisSchema = Schema>(name: string | number, schema: DisSchema, options?: DiscriminatorOptions): this;
 
     /** Returns a new schema that has the picked `paths` from this schema. */
     pick<T = this>(paths: string[], options?: SchemaOptions): T;
@@ -508,6 +508,8 @@ declare module 'mongoose' {
     statics: { [F in keyof TStaticMethods]: TStaticMethods[F] } &
     { [name: string]: (this: TModelType, ...args: any[]) => unknown };
 
+    toJSONSchema(options?: { useBsonType?: boolean }): Record<string, any>;
+
     /** Creates a virtual type with the given name. */
     virtual<T = HydratedDocument<DocType, TVirtuals & TInstanceMethods, TQueryHelpers>>(
       name: keyof TVirtuals | string,
@@ -539,21 +541,21 @@ declare module 'mongoose' {
           ? DateSchemaDefinition
           : (Function | string);
 
-  export type SchemaDefinitionProperty<T = undefined, EnforcedDocType = any> = SchemaDefinitionWithBuiltInClass<T> |
-  SchemaTypeOptions<T extends undefined ? any : T, EnforcedDocType> |
-    typeof SchemaType |
-  Schema<any, any, any> |
-  Schema<any, any, any>[] |
-  SchemaTypeOptions<T extends undefined ? any : Unpacked<T>, EnforcedDocType>[] |
-  Function[] |
-  SchemaDefinition<T, EnforcedDocType> |
-  SchemaDefinition<Unpacked<T>, EnforcedDocType>[] |
-    typeof Schema.Types.Mixed |
-  MixedSchemaTypeOptions<EnforcedDocType>;
-
-  export type SchemaDefinition<T = undefined, EnforcedDocType = any> = T extends undefined
+  export type SchemaDefinitionProperty<T = undefined, EnforcedDocType = any, THydratedDocumentType = HydratedDocument<EnforcedDocType>> = SchemaDefinitionWithBuiltInClass<T>
+    | SchemaTypeOptions<T extends undefined ? any : T, EnforcedDocType, THydratedDocumentType>
+    | typeof SchemaType
+    | Schema<any, any, any>
+    | Schema<any, any, any>[]
+    | SchemaTypeOptions<T extends undefined ? any : Unpacked<T>, EnforcedDocType, THydratedDocumentType>[]
+    | Function[]
+    | SchemaDefinition<T, EnforcedDocType, THydratedDocumentType>
+    | SchemaDefinition<Unpacked<T>, EnforcedDocType, THydratedDocumentType>[]
+    | typeof Schema.Types.Mixed
+    | MixedSchemaTypeOptions<EnforcedDocType>;
+
+  export type SchemaDefinition<T = undefined, EnforcedDocType = any, THydratedDocumentType = HydratedDocument<EnforcedDocType>> = T extends undefined
     ? { [path: string]: SchemaDefinitionProperty; }
-    : { [path in keyof T]?: SchemaDefinitionProperty<T[path], EnforcedDocType>; };
+    : { [path in keyof T]?: SchemaDefinitionProperty<T[path], EnforcedDocType, THydratedDocumentType>; };
 
   export type AnyArray<T> = T[] | ReadonlyArray<T>;
   export type ExtractMongooseArray<T> = T extends Types.Array<any> ? AnyArray<Unpacked<T>> : T;
@@ -827,7 +829,7 @@ declare module 'mongoose' {
         ? Types.DocumentArray<FlattenMaps<ItemType>> : FlattenMaps<T>;
 
   export type actualPrimitives = string | boolean | number | bigint | symbol | null | undefined;
-  export type TreatAsPrimitives = actualPrimitives | NativeDate | RegExp | symbol | Error | BigInt | Types.ObjectId | Buffer | Function | mongodb.Binary;
+  export type TreatAsPrimitives = actualPrimitives | NativeDate | RegExp | symbol | Error | BigInt | Types.ObjectId | Buffer | Function | mongodb.Binary | mongodb.ClientSession;
 
   export type SchemaDefinitionType<T> = T extends Document ? Omit<T, Exclude<keyof Document, '_id' | 'id' | '__v'>> : T;
 

package/types/models.d.ts

@@ -577,6 +577,13 @@ declare module 'mongoose' {
       Array<MergeType<THydratedDocumentType, Omit<DocContents, '_id'>>>
     >;
 
+    /**
+     * Shortcut for saving one document to the database.
+     * `MyModel.insertOne(obj, options)` is almost equivalent to `new MyModel(obj).save(options)`.
+     * The difference is that `insertOne()` checks if `obj` is already a document, and checks for discriminators.
+     */
+    insertOne<DocContents = AnyKeys<TRawDocType>>(doc: DocContents | TRawDocType, options?: SaveOptions): Promise<THydratedDocumentType>;
+
     /**
      * List all [Atlas search indexes](https://www.mongodb.com/docs/atlas/atlas-search/create-index/) on this model's collection.
      * This function only works when connected to MongoDB Atlas.
@@ -608,6 +615,13 @@ declare module 'mongoose' {
      */
     updateSearchIndex(name: string, definition: AnyObject): Promise<void>;
 
+    /**
+     * Changes the Connection instance this model uses to make requests to MongoDB.
+     * This function is most useful for changing the Connection that a Model defined using `mongoose.model()` uses
+     * after initialization.
+     */
+    useConnection(connection: Connection): this;
+
     /** Casts and validates the given object against this model's schema, passing the given `context` to custom validators. */
     validate(): Promise<void>;
     validate(obj: any): Promise<void>;
@@ -869,17 +883,20 @@ declare module 'mongoose' {
 
     /** Creates a `updateMany` query: updates all documents that match `filter` with `update`. */
     updateMany<ResultDoc = THydratedDocumentType>(
-      filter?: RootFilterQuery<TRawDocType>,
-      update?: UpdateQuery<TRawDocType> | UpdateWithAggregationPipeline,
+      filter: RootFilterQuery<TRawDocType>,
+      update: UpdateQuery<TRawDocType> | UpdateWithAggregationPipeline,
       options?: (mongodb.UpdateOptions & MongooseUpdateQueryOptions<TRawDocType>) | null
     ): QueryWithHelpers<UpdateWriteOpResult, ResultDoc, TQueryHelpers, TRawDocType, 'updateMany', TInstanceMethods & TVirtuals>;
 
     /** Creates a `updateOne` query: updates the first document that matches `filter` with `update`. */
     updateOne<ResultDoc = THydratedDocumentType>(
-      filter?: RootFilterQuery<TRawDocType>,
-      update?: UpdateQuery<TRawDocType> | UpdateWithAggregationPipeline,
+      filter: RootFilterQuery<TRawDocType>,
+      update: UpdateQuery<TRawDocType> | UpdateWithAggregationPipeline,
       options?: (mongodb.UpdateOptions & MongooseUpdateQueryOptions<TRawDocType>) | null
     ): QueryWithHelpers<UpdateWriteOpResult, ResultDoc, TQueryHelpers, TRawDocType, 'updateOne', TInstanceMethods & TVirtuals>;
+    updateOne<ResultDoc = THydratedDocumentType>(
+      update: UpdateQuery<TRawDocType> | UpdateWithAggregationPipeline
+    ): QueryWithHelpers<UpdateWriteOpResult, ResultDoc, TQueryHelpers, TRawDocType, 'updateOne', TInstanceMethods & TVirtuals>;
 
     /** Creates a Query, applies the passed conditions, and returns the Query. */
     where<ResultDoc = THydratedDocumentType>(

package/types/query.d.ts

@@ -850,20 +850,26 @@ declare module 'mongoose' {
      * the `multi` option.
      */
     updateMany(
-      filter?: RootFilterQuery<RawDocType>,
-      update?: UpdateQuery<RawDocType> | UpdateWithAggregationPipeline,
+      filter: RootFilterQuery<RawDocType>,
+      update: UpdateQuery<RawDocType> | UpdateWithAggregationPipeline,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<UpdateWriteOpResult, DocType, THelpers, RawDocType, 'updateMany', TDocOverrides>;
+    updateMany(
+      update: UpdateQuery<RawDocType> | UpdateWithAggregationPipeline
+    ): QueryWithHelpers<UpdateWriteOpResult, DocType, THelpers, RawDocType, 'updateMany', TDocOverrides>;
 
     /**
      * Declare and/or execute this query as an updateOne() operation. Same as
      * `update()`, except it does not support the `multi` or `overwrite` options.
      */
     updateOne(
-      filter?: RootFilterQuery<RawDocType>,
-      update?: UpdateQuery<RawDocType> | UpdateWithAggregationPipeline,
+      filter: RootFilterQuery<RawDocType>,
+      update: UpdateQuery<RawDocType> | UpdateWithAggregationPipeline,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<UpdateWriteOpResult, DocType, THelpers, RawDocType, 'updateOne', TDocOverrides>;
+    updateOne(
+      update: UpdateQuery<RawDocType> | UpdateWithAggregationPipeline
+    ): QueryWithHelpers<UpdateWriteOpResult, DocType, THelpers, RawDocType, 'updateOne', TDocOverrides>;
 
     /**
      * Sets the specified number of `mongod` servers, or tag set of `mongod` servers,

package/types/schematypes.d.ts

@@ -56,7 +56,7 @@ declare module 'mongoose' {
 
   type DefaultType<T> = T extends Schema.Types.Mixed ? any : Partial<ExtractMongooseArray<T>>;
 
-  class SchemaTypeOptions<T, EnforcedDocType = any> {
+  class SchemaTypeOptions<T, EnforcedDocType = any, THydratedDocumentType = HydratedDocument<EnforcedDocType>> {
     type?:
     T extends string ? StringSchemaDefinition :
       T extends number ? NumberSchemaDefinition :
@@ -65,19 +65,19 @@ declare module 'mongoose' {
             T extends Map<any, any> ? SchemaDefinition<typeof Map> :
               T extends Buffer ? SchemaDefinition<typeof Buffer> :
                 T extends Types.ObjectId ? ObjectIdSchemaDefinition :
-                  T extends Types.ObjectId[] ? AnyArray<ObjectIdSchemaDefinition> | AnyArray<SchemaTypeOptions<ObjectId, EnforcedDocType>> :
-                    T extends object[] ? (AnyArray<Schema<any, any, any>> | AnyArray<SchemaDefinition<Unpacked<T>>> | AnyArray<SchemaTypeOptions<Unpacked<T>, EnforcedDocType>>) :
-                      T extends string[] ? AnyArray<StringSchemaDefinition> | AnyArray<SchemaTypeOptions<string, EnforcedDocType>> :
-                        T extends number[] ? AnyArray<NumberSchemaDefinition> | AnyArray<SchemaTypeOptions<number, EnforcedDocType>> :
-                          T extends boolean[] ? AnyArray<BooleanSchemaDefinition> | AnyArray<SchemaTypeOptions<boolean, EnforcedDocType>> :
-                            T extends Function[] ? AnyArray<Function | string> | AnyArray<SchemaTypeOptions<Unpacked<T>, EnforcedDocType>> :
+                  T extends Types.ObjectId[] ? AnyArray<ObjectIdSchemaDefinition> | AnyArray<SchemaTypeOptions<ObjectId, EnforcedDocType, THydratedDocumentType>> :
+                    T extends object[] ? (AnyArray<Schema<any, any, any>> | AnyArray<SchemaDefinition<Unpacked<T>>> | AnyArray<SchemaTypeOptions<Unpacked<T>, EnforcedDocType, THydratedDocumentType>>) :
+                      T extends string[] ? AnyArray<StringSchemaDefinition> | AnyArray<SchemaTypeOptions<string, EnforcedDocType, THydratedDocumentType>> :
+                        T extends number[] ? AnyArray<NumberSchemaDefinition> | AnyArray<SchemaTypeOptions<number, EnforcedDocType, THydratedDocumentType>> :
+                          T extends boolean[] ? AnyArray<BooleanSchemaDefinition> | AnyArray<SchemaTypeOptions<boolean, EnforcedDocType, THydratedDocumentType>> :
+                            T extends Function[] ? AnyArray<Function | string> | AnyArray<SchemaTypeOptions<Unpacked<T>, EnforcedDocType, THydratedDocumentType>> :
                               T | typeof SchemaType | Schema<any, any, any> | SchemaDefinition<T> | Function | AnyArray<Function>;
 
     /** Defines a virtual with the given name that gets/sets this path. */
     alias?: string | string[];
 
     /** Function or object describing how to validate this schematype. See [validation docs](https://mongoosejs.com/docs/validation.html). */
-    validate?: SchemaValidator<T, EnforcedDocType> | AnyArray<SchemaValidator<T, EnforcedDocType>>;
+    validate?: SchemaValidator<T, EnforcedDocType, THydratedDocumentType> | AnyArray<SchemaValidator<T, EnforcedDocType, THydratedDocumentType>>;
 
     /** Allows overriding casting logic for this individual path. If a string, the given string overwrites Mongoose's default cast error message. */
     cast?: string |
@@ -300,6 +300,8 @@ declare module 'mongoose' {
     /** Declares a full text index. */
     text(bool: boolean): this;
 
+    toJSONSchema(options?: { useBsonType?: boolean }): Record<string, any>;
+
     /** Defines a custom function for transforming this path when converting a document to JSON. */
     transform(fn: (value: any) => any): this;
 
@@ -387,10 +389,10 @@ declare module 'mongoose' {
         expires(when: number | string): this;
 
         /** Sets a maximum date validator. */
-        max(value: NativeDate, message: string): this;
+        max(value: NativeDate, message?: string): this;
 
         /** Sets a minimum date validator. */
-        min(value: NativeDate, message: string): this;
+        min(value: NativeDate, message?: string): this;
 
         /** Default options for this SchemaType */
         defaultOptions: Record<string, any>;
@@ -455,10 +457,10 @@ declare module 'mongoose' {
         enum(vals: number[]): this;
 
         /** Sets a maximum number validator. */
-        max(value: number, message: string): this;
+        max(value: number, message?: string): this;
 
         /** Sets a minimum number validator. */
-        min(value: number, message: string): this;
+        min(value: number, message?: string): this;
 
         /** Default options for this SchemaType */
         defaultOptions: Record<string, any>;

package/types/validation.d.ts

@@ -1,6 +1,11 @@
 declare module 'mongoose' {
 
-  type SchemaValidator<T, EnforcedDocType> = RegExp | [RegExp, string] | Function | [Function, string] | ValidateOpts<T, EnforcedDocType> | ValidateOpts<T, EnforcedDocType>[];
+  type SchemaValidator<T, EnforcedDocType, THydratedDocumentType> = RegExp
+    | [RegExp, string]
+    | Function
+    | [Function, string]
+    | ValidateOpts<T, THydratedDocumentType>
+    | ValidateOpts<T, THydratedDocumentType>[];
 
   interface ValidatorProps {
     path: string;