mongoose 8.16.1 → 8.16.3

package/lib/cursor/queryCursor.js

@@ -506,14 +506,15 @@ function _next(ctx, cb) {
             return _nextDoc(ctx, doc, null, callback);
           }
 
-          ctx.query.model.populate(doc, ctx._pop).then(
-            doc => {
-              _nextDoc(ctx, doc, ctx._pop, callback);
-            },
-            err => {
-              callback(err);
+          _nextDoc(ctx, doc, ctx._pop, (err, doc) => {
+            if (err != null) {
+              return callback(err);
             }
-          );
+            ctx.query.model.populate(doc, ctx._pop).then(
+              doc => callback(null, doc),
+              err => callback(err)
+            );
+          });
         },
         error => {
           callback(error);

package/lib/document.js

@@ -1517,6 +1517,8 @@ Document.prototype.$set = function $set(path, val, type, options) {
 
   if (schema.$isSingleNested && (this.isDirectModified(path) || val == null)) {
     cleanModifiedSubpaths(this, path);
+  } else if (schema.$isSchemaMap && val == null) {
+    cleanModifiedSubpaths(this, path);
   }
 
   return this;

package/lib/model.js

@@ -3454,35 +3454,36 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
       });
     }
   } else {
-    let remaining = validations.length;
-    let validOps = [];
+    let validOpIndexes = [];
     let validationErrors = [];
     const results = [];
-    await new Promise((resolve) => {
-      if (validations.length === 0) {
-        return resolve();
-      }
-      for (let i = 0; i < validations.length; ++i) {
-        validations[i]((err) => {
-          if (err == null) {
-            validOps.push(i);
-          } else {
-            validationErrors.push({ index: i, error: err });
-            results[i] = err;
-          }
-          if (--remaining <= 0) {
+    if (validations.length > 0) {
+      validOpIndexes = await Promise.all(ops.map((op, i) => {
+        if (i >= validations.length) {
+          return i;
+        }
+        return new Promise((resolve) => {
+          validations[i]((err) => {
+            if (err == null) {
+              resolve(i);
+            } else {
+              validationErrors.push({ index: i, error: err });
+              results[i] = err;
+            }
             resolve();
-          }
+          });
         });
-      }
-    });
+      }));
+      validOpIndexes = validOpIndexes.filter(index => index != null);
+    } else {
+      validOpIndexes = ops.map((op, i) => i);
+    }
 
     validationErrors = validationErrors.
       sort((v1, v2) => v1.index - v2.index).
       map(v => v.error);
 
-    const validOpIndexes = validOps;
-    validOps = validOps.sort().map(index => ops[index]);
+    const validOps = validOpIndexes.sort().map(index => ops[index]);
 
     if (validOps.length === 0) {
       if (options.throwOnValidationError && validationErrors.length) {

package/lib/options/schemaStringOptions.js

@@ -45,7 +45,7 @@ Object.defineProperty(SchemaStringOptions.prototype, 'enum', opts);
 Object.defineProperty(SchemaStringOptions.prototype, 'match', opts);
 
 /**
- * If truthy, Mongoose will add a custom setter that lowercases this string
+ * If truthy, Mongoose will add a [custom setter](https://mongoosejs.com/docs/api/schematype.html#SchemaType.prototype.set()) that lowercases this string
  * using JavaScript's built-in `String#toLowerCase()`.
  *
  * @api public
@@ -58,7 +58,7 @@ Object.defineProperty(SchemaStringOptions.prototype, 'match', opts);
 Object.defineProperty(SchemaStringOptions.prototype, 'lowercase', opts);
 
 /**
- * If truthy, Mongoose will add a custom setter that removes leading and trailing
+ * If truthy, Mongoose will add a [custom setter](https://mongoosejs.com/docs/api/schematype.html#SchemaType.prototype.set()) that removes leading and trailing
  * whitespace using [JavaScript's built-in `String#trim()`](https://masteringjs.io/tutorials/fundamentals/trim-string).
  *
  * @api public

package/lib/schema/documentArray.js

@@ -62,6 +62,7 @@ function SchemaDocumentArray(key, schema, options, schemaOptions) {
   SchemaArray.call(this, key, EmbeddedDocument, options);
 
   this.schema = schema;
+  // EmbeddedDocument schematype options
   this.schemaOptions = schemaOptions || {};
   this.$isMongooseDocumentArray = true;
   this.Constructor = EmbeddedDocument;
@@ -83,9 +84,7 @@ function SchemaDocumentArray(key, schema, options, schemaOptions) {
 
   const $parentSchemaType = this;
   this.$embeddedSchemaType = new DocumentArrayElement(key + '.$', {
-    required: this &&
-      this.schemaOptions &&
-      this.schemaOptions.required || false,
+    ...(schemaOptions || {}),
     $parentSchemaType
   });
 

package/lib/schema/mixed.js

@@ -124,6 +124,19 @@ SchemaMixed.prototype.castForQuery = function($cond, val) {
   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
+ */
+
+// eslint-disable-next-line no-unused-vars
+SchemaMixed.prototype.toJSONSchema = function toJSONSchema(_options) {
+  return {};
+};
+
 /*!
  * Module exports.
  */

package/lib/schemaType.js

@@ -695,10 +695,13 @@ SchemaType.prototype.transform = function(fn) {
  *     console.log(user.email); // 'avenue@q.com'
  *     User.updateOne({ _id: _id }, { $set: { email: 'AVENUE@Q.COM' } }); // update to 'avenue@q.com'
  *
+ *     // Setters also transform query filters
+ *     const user = await User.find({ email: 'AVENUE@Q.COM' }); // query for 'avenue@q.com'
+ *
  * As you can see above, setters allow you to transform the data before it
  * stored in MongoDB, or before executing a query.
  *
- * _NOTE: we could have also just used the built-in `lowercase: true` SchemaType option instead of defining our own function._
+ * _NOTE: we could have also just used the built-in [`lowercase: true` SchemaType option](https://mongoosejs.com/docs/api/schemastringoptions.html#SchemaStringOptions.prototype.lowercase) instead of defining our own function._
  *
  *     new Schema({ email: { type: String, lowercase: true }})
  *
@@ -1779,8 +1782,8 @@ SchemaType.prototype._duplicateKeyErrorMessage = null;
  * @returns {Object} JSON schema properties
  */
 
-SchemaType.prototype.toJSONSchema = function toJSONSchema() {
-  throw new Error('Converting unsupported SchemaType to JSON Schema: ' + this.instance);
+SchemaType.prototype.toJSONSchema = function toJSONSchema(_options) { // eslint-disable-line no-unused-vars
+  throw new Error(`Converting unsupported SchemaType to JSON Schema: ${this.instance} at path "${this.path}"`);
 };
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.16.1",
+  "version": "8.16.3",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -29,9 +29,9 @@
     "sift": "17.1.3"
   },
   "devDependencies": {
-    "@babel/core": "7.27.4",
+    "@babel/core": "7.27.7",
     "@babel/preset-env": "7.27.2",
-    "@mongodb-js/mongodb-downloader": "^0.3.9",
+    "@mongodb-js/mongodb-downloader": "^0.4.2",
     "@typescript-eslint/eslint-plugin": "^8.19.1",
     "@typescript-eslint/parser": "^8.19.1",
     "acquit": "1.4.0",
@@ -42,7 +42,7 @@
     "babel-loader": "8.2.5",
     "broken-link-checker": "^0.7.8",
     "buffer": "^5.6.0",
-    "cheerio": "1.0.0",
+    "cheerio": "1.1.0",
     "crypto-browserify": "3.12.1",
     "dox": "1.0.0",
     "eslint": "8.57.1",
@@ -56,7 +56,7 @@
     "markdownlint-cli2": "^0.18.1",
     "marked": "15.0.12",
     "mkdirp": "^3.0.1",
-    "mocha": "11.5.0",
+    "mocha": "11.7.1",
     "moment": "2.30.1",
     "mongodb-memory-server": "10.1.4",
     "mongodb-runner": "^5.8.2",
@@ -64,7 +64,7 @@
     "nyc": "15.1.0",
     "pug": "3.0.3",
     "q": "1.5.1",
-    "sinon": "20.0.0",
+    "sinon": "21.0.0",
     "stream-browserify": "3.0.0",
     "tsd": "0.32.0",
     "typescript": "5.8.3",

package/types/index.d.ts

@@ -206,7 +206,7 @@ declare module 'mongoose' {
     [k: string]: string;
   }
 
-  export interface ToObjectOptions<THydratedDocumentType = HydratedDocument<unknown>> {
+  export interface ToObjectOptions<RawDocType = unknown, THydratedDocumentType = HydratedDocument<RawDocType>> {
     /** if `options.virtuals = true`, you can set `options.aliases = false` to skip applying aliases. This option is a no-op if `options.virtuals = false`. */
     aliases?: boolean;
     /** if true, replace any conventionally populated paths with the original id in the output. Has no affect on virtual populated paths. */
@@ -224,7 +224,7 @@ declare module 'mongoose' {
     /** if set, mongoose will call this function to allow you to transform the returned object */
     transform?: boolean | ((
       doc: THydratedDocumentType,
-      ret: Record<string, any>,
+      ret: Default__v<Require_id<RawDocType>>,
       options: ToObjectOptions<THydratedDocumentType>
     ) => any);
     /** If true, omits fields that are excluded in this document's projection. Unless you specified a projection, this will omit any field that has `select: false` in the schema. */
@@ -505,7 +505,7 @@ declare module 'mongoose' {
     requiredPaths(invalidate?: boolean): string[];
 
     /** Sets a schema option. */
-    set<K extends keyof SchemaOptions>(key: K, value: SchemaOptions[K], _tags?: any): this;
+    set<K extends keyof SchemaOptions>(key: K, value: SchemaOptions<DocType>[K], _tags?: any): this;
 
     /** Adds static "class" methods to Models compiled from this schema. */
     static<K extends keyof TStaticMethods>(name: K, fn: TStaticMethods[K]): this;
@@ -519,7 +519,7 @@ declare module 'mongoose' {
     toJSONSchema(options?: { useBsonType?: boolean }): Record<string, any>;
 
     /** Creates a virtual type with the given name. */
-    virtual<T = HydratedDocument<DocType, TVirtuals & TInstanceMethods, TQueryHelpers>>(
+    virtual<T = THydratedDocumentType>(
       name: keyof TVirtuals | string,
       options?: VirtualTypeOptions<T, DocType>
     ): VirtualType<T>;

package/types/query.d.ts

@@ -758,7 +758,7 @@ declare module 'mongoose' {
 
     /** Specifies which document fields to include or exclude (also known as the query "projection") */
     select<RawDocTypeOverride extends { [P in keyof RawDocType]?: any } = {}>(
-      arg: string | string[] | Record<string, number | boolean | string | object>
+      arg: string | readonly string[] | Record<string, number | boolean | string | object>
     ): QueryWithHelpers<
       IfEquals<
         RawDocTypeOverride,

package/types/schemaoptions.d.ts

@@ -146,14 +146,14 @@ declare module 'mongoose' {
      */
     strictQuery?: boolean | 'throw';
     /** Exactly the same as the toObject option but only applies when the document's toJSON method is called. */
-    toJSON?: ToObjectOptions<THydratedDocumentType>;
+    toJSON?: ToObjectOptions<DocType, THydratedDocumentType>;
     /**
      * Documents have a toObject method which converts the mongoose document into a plain JavaScript object.
      * This method accepts a few options. Instead of applying these options on a per-document basis, we may
      * declare the options at the schema level and have them applied to all of the schema's documents by
      * default.
      */
-    toObject?: ToObjectOptions<THydratedDocumentType>;
+    toObject?: ToObjectOptions<DocType, THydratedDocumentType>;
     /**
      * By default, if you have an object with key 'type' in your schema, mongoose will interpret it as a
      * type declaration. However, for applications like geoJSON, the 'type' property is important. If you want to

package/types/schematypes.d.ts

@@ -196,13 +196,13 @@ declare module 'mongoose' {
     /** Attaches a validator that succeeds if the data string matches the given regular expression, and fails otherwise. */
     match?: RegExp | [RegExp, string] | readonly [RegExp, string];
 
-    /** If truthy, Mongoose will add a custom setter that lowercases this string using JavaScript's built-in `String#toLowerCase()`. */
+    /** If truthy, Mongoose will add a [custom setter](https://mongoosejs.com/docs/api/schematype.html#SchemaType.prototype.set()) that lowercases this string using JavaScript's built-in `String#toLowerCase()`. */
     lowercase?: boolean;
 
-    /** If truthy, Mongoose will add a custom setter that removes leading and trailing whitespace using JavaScript's built-in `String#trim()`. */
+    /** If truthy, Mongoose will add a [custom setter](https://mongoosejs.com/docs/api/schematype.html#SchemaType.prototype.set()) that removes leading and trailing whitespace using JavaScript's built-in `String#trim()`. */
     trim?: boolean;
 
-    /** If truthy, Mongoose will add a custom setter that uppercases this string using JavaScript's built-in `String#toUpperCase()`. */
+    /** If truthy, Mongoose will add a [custom setter](https://mongoosejs.com/docs/api/schematype.html#SchemaType.prototype.set()) that uppercases this string using JavaScript's built-in `String#toUpperCase()`. */
     uppercase?: boolean;
 
     /** If set, Mongoose will add a custom validator that ensures the given string's `length` is at least the given number. */