mongoose 8.5.2 → 8.5.4

package/lib/cast.js

@@ -8,6 +8,7 @@ const CastError = require('./error/cast');
 const StrictModeError = require('./error/strict');
 const Types = require('./schema/index');
 const cast$expr = require('./helpers/query/cast$expr');
+const castString = require('./cast/string');
 const castTextSearch = require('./schema/operators/text');
 const get = require('./helpers/get');
 const getSchemaDiscriminatorByValue = require('./helpers/discriminator/getSchemaDiscriminatorByValue');
@@ -95,6 +96,9 @@ module.exports = function cast(schema, obj, options, context) {
       val = cast(schema, val, options, context);
     } else if (path === '$text') {
       val = castTextSearch(val, path);
+    } else if (path === '$comment' && !schema.paths.hasOwnProperty('$comment')) {
+      val = castString(val, path);
+      obj[path] = val;
     } else {
       if (!schema) {
         // no casting for Mixed types

package/lib/document.js

@@ -2770,15 +2770,6 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip) {
     }
   }
 
-  for (const path of paths) {
-    // Single nested paths (paths embedded under single nested subdocs) will
-    // be validated on their own when we call `validate()` on the subdoc itself.
-    // Re: gh-8468
-    if (doc.$__schema.singleNestedPaths.hasOwnProperty(path)) {
-      paths.delete(path);
-      continue;
-    }
-  }
 
   if (Array.isArray(pathsToValidate)) {
     paths = _handlePathsToValidate(paths, pathsToValidate);
@@ -2800,7 +2791,10 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip) {
         _v = _v.toObject({ transform: false });
       }
       const flat = flatten(_v, pathToCheck, flattenOptions, doc.$__schema);
-      Object.keys(flat).forEach(addToPaths);
+      // Single nested paths (paths embedded under single nested subdocs) will
+      // be validated on their own when we call `validate()` on the subdoc itself.
+      // Re: gh-8468
+      Object.keys(flat).filter(path => !doc.$__schema.singleNestedPaths.hasOwnProperty(path)).forEach(addToPaths);
     }
   }
 
@@ -3801,7 +3795,7 @@ Document.prototype.$__handleReject = function handleReject(err) {
 };
 
 /**
- * Internal helper for toObject() and toJSON() that doesn't manipulate options
+ * Internal common logic for toObject() and toJSON()
  *
  * @return {Object}
  * @api private
@@ -3834,14 +3828,17 @@ Document.prototype.$toObject = function(options, json) {
   }
 
   const depopulate = options._calledWithOptions.depopulate
-    ?? options._parentOptions?.depopulate
     ?? defaultOptions?.depopulate
+    ?? options.depopulate
     ?? false;
   // _isNested will only be true if this is not the top level document, we
   // should never depopulate the top-level document
   if (depopulate && options._isNested && this.$__.wasPopulated) {
     return clone(this.$__.wasPopulated.value || this._doc._id, options);
   }
+  if (depopulate) {
+    options.depopulate = true;
+  }
 
   // merge default options with input options.
   if (defaultOptions != null) {
@@ -3855,7 +3852,9 @@ Document.prototype.$toObject = function(options, json) {
   options.json = json;
   options.minimize = _minimize;
 
-  options._parentOptions = options;
+  const parentOptions = options._parentOptions;
+  // Parent options should only bubble down for subdocuments, not populated docs
+  options._parentOptions = this.$isSubdocument ? options : null;
 
   options._skipSingleNestedGetters = false;
   // remember the root transform function
@@ -3886,6 +3885,7 @@ Document.prototype.$toObject = function(options, json) {
 
   const virtuals = options._calledWithOptions.virtuals
     ?? defaultOptions.virtuals
+    ?? parentOptions?.virtuals
     ?? undefined;
 
   if (virtuals || (getters && virtuals !== false)) {
@@ -4768,7 +4768,23 @@ Document.prototype.depopulate = function(path) {
         continue;
       }
       delete populated[key];
-      utils.setValue(key, populatedIds, this._doc);
+      if (Array.isArray(populatedIds)) {
+        const arr = utils.getValue(key, this._doc);
+        if (arr.isMongooseArray) {
+          const rawArray = arr.__array;
+          for (let i = 0; i < rawArray.length; ++i) {
+            const subdoc = rawArray[i];
+            if (subdoc == null) {
+              continue;
+            }
+            rawArray[i] = subdoc instanceof Document ? subdoc._doc._id : subdoc._id;
+          }
+        } else {
+          utils.setValue(key, populatedIds, this._doc);
+        }
+      } else {
+        utils.setValue(key, populatedIds, this._doc);
+      }
     }
     return this;
   }
@@ -4781,7 +4797,23 @@ Document.prototype.depopulate = function(path) {
       delete this.$$populatedVirtuals[singlePath];
       delete this._doc[singlePath];
     } else if (populatedIds) {
-      utils.setValue(singlePath, populatedIds, this._doc);
+      if (Array.isArray(populatedIds)) {
+        const arr = utils.getValue(singlePath, this._doc);
+        if (arr.isMongooseArray) {
+          const rawArray = arr.__array;
+          for (let i = 0; i < rawArray.length; ++i) {
+            const subdoc = rawArray[i];
+            if (subdoc == null) {
+              continue;
+            }
+            rawArray[i] = subdoc instanceof Document ? subdoc._doc._id : subdoc._id;
+          }
+        } else {
+          utils.setValue(singlePath, populatedIds, this._doc);
+        }
+      } else {
+        utils.setValue(singlePath, populatedIds, this._doc);
+      }
     }
   }
   return this;

package/lib/model.js

@@ -10,6 +10,7 @@ const Document = require('./document');
 const DocumentNotFoundError = require('./error/notFound');
 const EventEmitter = require('events').EventEmitter;
 const Kareem = require('kareem');
+const MongooseBulkWriteError = require('./error/bulkWriteError');
 const MongooseError = require('./error/index');
 const ObjectParameterError = require('./error/objectParameter');
 const OverwriteModelError = require('./error/overwriteModel');
@@ -62,7 +63,6 @@ const setDottedPath = require('./helpers/path/setDottedPath');
 const STATES = require('./connectionState');
 const util = require('util');
 const utils = require('./utils');
-const MongooseBulkWriteError = require('./error/bulkWriteError');
 const minimize = require('./helpers/minimize');
 
 const modelCollectionSymbol = Symbol('mongoose#Model#collection');
@@ -3202,8 +3202,8 @@ function _setIsNew(doc, val) {
  * @param {Boolean} [options.j=true] If false, disable [journal acknowledgement](https://www.mongodb.com/docs/manual/reference/write-concern/#j-option)
  * @param {Boolean} [options.skipValidation=false] Set to true to skip Mongoose schema validation on bulk write operations. Mongoose currently runs validation on `insertOne` and `replaceOne` operations by default.
  * @param {Boolean} [options.bypassDocumentValidation=false] If true, disable [MongoDB server-side schema validation](https://www.mongodb.com/docs/manual/core/schema-validation/) for all writes in this bulk.
- * @param {Boolean} [options.throwOnValidationError=false] If true and `ordered: false`, throw an error if one of the operations failed validation, but all valid operations completed successfully.
- * @param {Boolean} [options.strict=null] Overwrites the [`strict` option](https://mongoosejs.com/docs/guide.html#strict) on schema. If false, allows filtering and writing fields not defined in the schema for all writes in this bulk.
+ * @param {Boolean} [options.throwOnValidationError=false] If true and `ordered: false`, throw an error if one of the operations failed validation, but all valid operations completed successfully. Note that Mongoose will still send all valid operations to the MongoDB server.
+ * @param {Boolean|"throw"} [options.strict=null] Overwrites the [`strict` option](https://mongoosejs.com/docs/guide.html#strict) on schema. If false, allows filtering and writing fields not defined in the schema for all writes in this bulk.
  * @return {Promise} resolves to a [`BulkWriteOpResult`](https://mongodb.github.io/node-mongodb-native/4.9/classes/BulkWriteResult.html) if the operation succeeds
  * @api public
  */
@@ -4468,7 +4468,7 @@ function _assign(model, vals, mod, assignmentOpts) {
             rawOrder[key].push(i);
           } else if (isVirtual ||
             rawDocs[key].constructor !== val.constructor ||
-            String(rawDocs[key]._doc._id) !== String(val._doc._id)) {
+            (rawDocs[key] instanceof Document ? String(rawDocs[key]._doc._id) : String(rawDocs[key]._id)) !== (val instanceof Document ? String(val._doc._id) : String(val._id))) {
             // May need to store multiple docs with the same id if there's multiple models
             // if we have discriminators or a ref function. But avoid converting to an array
             // if we have multiple queries on the same model because of `perDocumentLimit` re: gh-9906

package/lib/mongoose.js

@@ -358,7 +358,7 @@ Mongoose.prototype.get = Mongoose.prototype.set;
  *
  *     // initialize now, connect later
  *     db = mongoose.createConnection();
- *     db.openUri('127.0.0.1', 'database', port, [opts]);
+ *     await db.openUri('mongodb://127.0.0.1:27017/database');
  *
  * @param {String} uri mongodb URI to connect to
  * @param {Object} [options] passed down to the [MongoDB driver's `connect()` function](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/MongoClientOptions.html), except for 4 mongoose-specific options explained below.
@@ -406,11 +406,10 @@ Mongoose.prototype.createConnection = function(uri, options) {
  *     // with options
  *     mongoose.connect(uri, options);
  *
- *     // optional callback that gets fired when initial connection completed
+ *     // Using `await` throws "MongooseServerSelectionError: Server selection timed out after 30000 ms"
+ *     // if Mongoose can't connect.
  *     const uri = 'mongodb://nonexistent.domain:27000';
- *     mongoose.connect(uri, function(error) {
- *       // if error is truthy, the initial connection failed.
- *     })
+ *     await mongoose.connect(uri);
  *
  * @param {String} uri mongodb URI to connect to
  * @param {Object} [options] passed down to the [MongoDB driver's `connect()` function](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/MongoClientOptions.html), except for 4 mongoose-specific options explained below.

package/lib/query.js

@@ -2446,19 +2446,23 @@ Query.prototype.merge = function(source) {
   }
 
   opts.omit = {};
-  if (source.$and) {
+  if (Array.isArray(source.$and)) {
     opts.omit['$and'] = true;
     if (!this._conditions) {
       this._conditions = {};
     }
-    this._conditions.$and = (this._conditions.$and || []).concat(source.$and);
+    this._conditions.$and = (this._conditions.$and || []).concat(
+      source.$and.map(el => utils.isPOJO(el) ? utils.merge({}, el) : el)
+    );
   }
-  if (source.$or) {
+  if (Array.isArray(source.$or)) {
     opts.omit['$or'] = true;
     if (!this._conditions) {
       this._conditions = {};
     }
-    this._conditions.$or = (this._conditions.$or || []).concat(source.$or);
+    this._conditions.$or = (this._conditions.$or || []).concat(
+      source.$or.map(el => utils.isPOJO(el) ? utils.merge({}, el) : el)
+    );
   }
 
   // plain object

package/lib/schema/operators/text.js

@@ -15,7 +15,7 @@ const castString = require('../../cast/string');
  * @api private
  */
 
-module.exports = function(val, path) {
+module.exports = function castTextSearch(val, path) {
   if (val == null || typeof val !== 'object') {
     throw new CastError('$text', val, path);
   }

package/lib/types/array/methods/index.js

@@ -721,6 +721,7 @@ const methods = {
     }
 
     this._registerAtomic('$push', atomic);
+
     return ret;
   },
 

package/lib/types/map.js

@@ -68,10 +68,17 @@ class MongooseMap extends Map {
    * and change tracking. Note that Mongoose maps _only_ support strings and
    * ObjectIds as keys.
    *
+   * Keys also cannot:
+   * - be named after special properties `prototype`, `constructor`, and `__proto__`
+   * - start with a dollar sign (`$`)
+   * - contain any dots (`.`)
+   *
    * #### Example:
    *
    *     doc.myMap.set('test', 42); // works
    *     doc.myMap.set({ obj: 42 }, 42); // Throws "Mongoose maps only support string keys"
+   *     doc.myMap.set(10, 42); // Throws "Mongoose maps only support string keys"
+   *     doc.myMap.set("$test", 42); // Throws "Mongoose maps do not support keys that start with "$", got "$test""
    *
    * @api public
    * @method set

package/lib/utils.js

@@ -53,6 +53,12 @@ exports.toCollectionName = function(name, pluralize) {
     return name;
   }
   if (typeof pluralize === 'function') {
+    if (typeof name !== 'string') {
+      throw new TypeError('Collection name must be a string');
+    }
+    if (name.length === 0) {
+      throw new TypeError('Collection name cannot be empty');
+    }
     return pluralize(name);
   }
   return name;
@@ -301,6 +307,8 @@ exports.merge = function merge(to, from, options, path) {
       to[key] = from[key];
     }
   }
+
+  return to;
 };
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.5.2",
+  "version": "8.5.4",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -29,7 +29,7 @@
   },
   "devDependencies": {
     "@babel/core": "7.24.7",
-    "@babel/preset-env": "7.24.7",
+    "@babel/preset-env": "7.25.3",
     "@typescript-eslint/eslint-plugin": "^6.21.0",
     "@typescript-eslint/parser": "^6.21.0",
     "acquit": "1.3.0",
@@ -49,13 +49,13 @@
     "eslint-plugin-mocha-no-only": "1.2.0",
     "express": "^4.19.2",
     "fs-extra": "~11.2.0",
-    "highlight.js": "11.9.0",
+    "highlight.js": "11.10.0",
     "lodash.isequal": "4.5.0",
     "lodash.isequalwith": "4.4.0",
     "markdownlint-cli2": "^0.13.0",
-    "marked": "4.3.0",
+    "marked": "14.0.0",
     "mkdirp": "^3.0.1",
-    "mocha": "10.6.0",
+    "mocha": "10.7.0",
     "moment": "2.30.1",
     "mongodb-memory-server": "10.0.0",
     "ncp": "^2.0.0",
@@ -65,9 +65,9 @@
     "sinon": "18.0.0",
     "stream-browserify": "3.0.0",
     "tsd": "0.31.1",
-    "typescript": "5.5.3",
+    "typescript": "5.5.4",
     "uuid": "10.0.0",
-    "webpack": "5.92.1"
+    "webpack": "5.93.0"
   },
   "directories": {
     "lib": "./lib/mongoose"

package/types/connection.d.ts

@@ -72,7 +72,7 @@ declare module 'mongoose' {
     readonly config: any;
 
     /** The mongodb.Db instance, set when the connection is opened */
-    readonly db: mongodb.Db;
+    readonly db: mongodb.Db | undefined;
 
     /**
      * Helper for `createCollection()`. Will explicitly create the given collection

package/types/cursor.d.ts

@@ -51,7 +51,7 @@ declare module 'mongoose' {
      * Get the next document from this cursor. Will return `null` when there are
      * no documents left.
      */
-    next(): Promise<DocType>;
+    next(): Promise<DocType | null>;
 
     options: Options;
   }

package/types/index.d.ts

@@ -157,8 +157,37 @@ declare module 'mongoose' {
         >
       >
   >;
-  export type HydratedSingleSubdocument<DocType, TOverrides = {}> = Types.Subdocument<unknown, Record<string, never>, DocType> & Require_id<DocType> & TOverrides;
-  export type HydratedArraySubdocument<DocType, TOverrides = {}> = Types.ArraySubdocument<unknown, Record<string, never>, DocType> & Require_id<DocType> & TOverrides;
+  export type HydratedSingleSubdocument<
+    DocType,
+    TOverrides = {}
+  > = IfAny<
+  DocType,
+  any,
+  TOverrides extends Record<string, never> ?
+    Types.Subdocument<unknown, Record<string, never>, DocType> & Require_id<DocType> :
+    IfAny<
+      TOverrides,
+      Types.Subdocument<unknown, Record<string, never>, DocType> & Require_id<DocType>,
+      Types.Subdocument<unknown, Record<string, never>, DocType> & MergeType<
+        Require_id<DocType>,
+        TOverrides
+      >
+    >
+  >;
+  export type HydratedArraySubdocument<DocType, TOverrides = {}> = IfAny<
+    DocType,
+    any,
+    TOverrides extends Record<string, never> ?
+      Types.ArraySubdocument<unknown, Record<string, never>, DocType> & Require_id<DocType> :
+      IfAny<
+        TOverrides,
+        Types.ArraySubdocument<unknown, Record<string, never>, DocType> & Require_id<DocType>,
+        Types.ArraySubdocument<unknown, Record<string, never>, DocType> & MergeType<
+          Require_id<DocType>,
+          TOverrides
+        >
+      >
+    >;
 
   export type HydratedDocumentFromSchema<TSchema extends Schema> = HydratedDocument<
   InferSchemaType<TSchema>,

package/types/inferrawdoctype.d.ts

@@ -10,12 +10,12 @@ declare module 'mongoose' {
   export type InferRawDocType<
     DocDefinition,
     TSchemaOptions extends Record<any, any> = DefaultSchemaOptions
-  > = {
+  > = ApplySchemaOptions<{
     [
     K in keyof (RequiredPaths<DocDefinition, TSchemaOptions['typeKey']> &
     OptionalPaths<DocDefinition, TSchemaOptions['typeKey']>)
     ]: ObtainRawDocumentPathType<DocDefinition[K], TSchemaOptions['typeKey']>;
-  };
+  }, TSchemaOptions>;
 
   /**
    * @summary Obtains schema Path type.

package/types/inferschematype.d.ts

@@ -74,14 +74,25 @@ declare module 'mongoose' {
 
   type ApplySchemaOptions<T, O = DefaultSchemaOptions> = ResolveTimestamps<T, O>;
 
-  type ResolveTimestamps<T, O> = O extends { timestamps: true }
+  type ResolveTimestamps<T, O> = O extends { methods: any } | { statics: any } | { virtuals: any } | { timestamps?: false } ? T
     // For some reason, TypeScript sets all the document properties to unknown
     // if we use methods, statics, or virtuals. So avoid inferring timestamps
     // if any of these are set for now. See gh-12807
-    ? O extends { methods: any } | { statics: any } | { virtuals: any }
-      ? T
-      : { createdAt: NativeDate; updatedAt: NativeDate; } & T
-    : T;
+    : O extends { timestamps: infer TimestampOptions } ? TimestampOptions extends true
+      ? { createdAt: NativeDate; updatedAt: NativeDate; } & T
+      : TimestampOptions extends SchemaTimestampsConfig
+        ? {
+          -readonly [K in keyof Pick<
+            TimestampOptions,
+            'createdAt' | 'updatedAt'
+          > as TimestampOptions[K] extends true
+            ? K
+            : TimestampOptions[K] extends string
+              ? TimestampOptions[K]
+              : never]: NativeDate;
+        } & T
+        : T
+      : T;
 }
 
 type IsPathDefaultUndefined<PathType> = PathType extends { default: undefined } ?

package/types/query.d.ts

@@ -431,7 +431,7 @@ declare module 'mongoose' {
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne', TInstanceMethods>;
     findOne(
       filter?: FilterQuery<RawDocType>
-    ): QueryWithHelpers<DocType | null, RawDocType, THelpers, RawDocType, 'findOne', TInstanceMethods>;
+    ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne', TInstanceMethods>;
 
     /** Creates a `findOneAndDelete` query: atomically finds the given document, deletes it, and returns the document as it was before deletion. */
     findOneAndDelete(