mongoose 8.3.0 → 8.3.2

package/lib/document.js

@@ -1053,7 +1053,11 @@ Document.prototype.$set = function $set(path, val, type, options) {
       if (path.$__isNested) {
         path = path.toObject();
       } else {
-        path = path._doc;
+        // This ternary is to support gh-7898 (copying virtuals if same schema)
+        // while not breaking gh-10819, which for some reason breaks if we use toObject()
+        path = path.$__schema === this.$__schema
+          ? applyVirtuals(path, { ...path._doc })
+          : path._doc;
       }
     }
     if (path == null) {
@@ -4087,6 +4091,7 @@ function applyVirtuals(self, json, options, toObjectOptions) {
     ? toObjectOptions.aliases
     : true;
 
+  options = options || {};
   let virtualsToApply = null;
   if (Array.isArray(options.virtuals)) {
     virtualsToApply = new Set(options.virtuals);
@@ -4103,7 +4108,6 @@ function applyVirtuals(self, json, options, toObjectOptions) {
     return json;
   }
 
-  options = options || {};
   for (i = 0; i < numPaths; ++i) {
     path = paths[i];
 
@@ -4184,7 +4188,12 @@ function applyGetters(self, json, options) {
     for (let ii = 0; ii < plen; ++ii) {
       part = parts[ii];
       v = cur[part];
-      if (ii === last) {
+      // If we've reached a non-object part of the branch, continuing would
+      // cause "Cannot create property 'foo' on string 'bar'" error.
+      // Necessary for mongoose-intl plugin re: gh-14446
+      if (branch != null && typeof branch !== 'object') {
+        break;
+      } else if (ii === last) {
         const val = self.$get(path);
         branch[part] = clone(val, options);
         if (Array.isArray(branch[part]) && schema.paths[path].$embeddedSchemaType) {

package/lib/helpers/discriminator/applyEmbeddedDiscriminators.js

@@ -2,7 +2,7 @@
 
 module.exports = applyEmbeddedDiscriminators;
 
-function applyEmbeddedDiscriminators(schema, seen = new WeakSet()) {
+function applyEmbeddedDiscriminators(schema, seen = new WeakSet(), overwriteExisting = false) {
   if (seen.has(schema)) {
     return;
   }
@@ -16,13 +16,20 @@ function applyEmbeddedDiscriminators(schema, seen = new WeakSet()) {
     if (!schemaType.schema._applyDiscriminators) {
       continue;
     }
-    if (schemaType._appliedDiscriminators) {
+    if (schemaType._appliedDiscriminators && !overwriteExisting) {
       continue;
     }
     for (const discriminatorKey of schemaType.schema._applyDiscriminators.keys()) {
-      const discriminatorSchema = schemaType.schema._applyDiscriminators.get(discriminatorKey);
+      const {
+        schema: discriminatorSchema,
+        options
+      } = schemaType.schema._applyDiscriminators.get(discriminatorKey);
       applyEmbeddedDiscriminators(discriminatorSchema, seen);
-      schemaType.discriminator(discriminatorKey, discriminatorSchema);
+      schemaType.discriminator(
+        discriminatorKey,
+        discriminatorSchema,
+        overwriteExisting ? { ...options, overwriteExisting: true } : options
+      );
     }
     schemaType._appliedDiscriminators = true;
   }

package/lib/helpers/model/discriminator.js

@@ -21,7 +21,7 @@ const CUSTOMIZABLE_DISCRIMINATOR_OPTIONS = {
  * ignore
  */
 
-module.exports = function discriminator(model, name, schema, tiedValue, applyPlugins, mergeHooks) {
+module.exports = function discriminator(model, name, schema, tiedValue, applyPlugins, mergeHooks, overwriteExisting) {
   if (!(schema && schema.instanceOfSchema)) {
     throw new Error('You must pass a valid discriminator Schema');
   }
@@ -205,7 +205,7 @@ module.exports = function discriminator(model, name, schema, tiedValue, applyPlu
 
   model.schema.discriminators[name] = schema;
 
-  if (model.discriminators[name] && !schema.options.overwriteModels) {
+  if (model.discriminators[name] && !schema.options.overwriteModels && !overwriteExisting) {
     throw new Error('Discriminator with name "' + name + '" already exists');
   }
 

package/lib/helpers/populate/assignVals.js

@@ -101,8 +101,8 @@ module.exports = function assignVals(o) {
       valueToSet = numDocs(rawIds[i]);
     } else if (Array.isArray(o.match)) {
       valueToSet = Array.isArray(rawIds[i]) ?
-        rawIds[i].filter(sift(o.match[i])) :
-        [rawIds[i]].filter(sift(o.match[i]))[0];
+        rawIds[i].filter(v => v == null || sift(o.match[i])(v)) :
+        [rawIds[i]].filter(v => v == null || sift(o.match[i])(v))[0];
     } else {
       valueToSet = rawIds[i];
     }

package/lib/model.js

@@ -23,6 +23,7 @@ const VersionError = require('./error/version');
 const ParallelSaveError = require('./error/parallelSave');
 const applyDefaultsHelper = require('./helpers/document/applyDefaults');
 const applyDefaultsToPOJO = require('./helpers/model/applyDefaultsToPOJO');
+const applyEmbeddedDiscriminators = require('./helpers/discriminator/applyEmbeddedDiscriminators');
 const applyHooks = require('./helpers/model/applyHooks');
 const applyMethods = require('./helpers/model/applyMethods');
 const applyProjection = require('./helpers/projection/applyProjection');
@@ -375,7 +376,9 @@ Model.prototype.$__handleSave = function(options, callback) {
           }
           minimize(updateOp[key]);
           if (Object.keys(updateOp[key]).length === 0) {
-            updateOp[key] = null;
+            delete updateOp[key];
+            update.$unset = update.$unset || {};
+            update.$unset[key] = 1;
           }
         }
       }
@@ -4746,7 +4749,7 @@ function _assign(model, vals, mod, assignmentOpts) {
       }
       // flag each as result of population
       if (!lean) {
-        val.$__.wasPopulated = val.$__.wasPopulated || true;
+        val.$__.wasPopulated = val.$__.wasPopulated || { value: _val };
       }
     }
   }
@@ -4893,6 +4896,34 @@ Model.compile = function compile(name, schema, collectionName, connection, base)
   return model;
 };
 
+/**
+ * Update this model to use the new connection, including updating all internal
+ * references and creating a new `Collection` instance using the new connection.
+ * Not for external use, only used by `setDriver()` to ensure that you can still
+ * call `setDriver()` after creating a model using `mongoose.model()`.
+ *
+ * @param {Connection} newConnection the new connection to use
+ * @api private
+ */
+
+Model.$__updateConnection = function $__updateConnection(newConnection) {
+  this.db = newConnection;
+  this.prototype.db = newConnection;
+  this.prototype[modelDbSymbol] = newConnection;
+
+  const collection = newConnection.collection(
+    this.collection.collectionName,
+    this.collection.opts
+  );
+
+  this.prototype.collection = collection;
+  this.prototype.$collection = collection;
+  this.prototype[modelCollectionSymbol] = collection;
+
+  this.collection = collection;
+  this.$__collection = collection;
+};
+
 /**
  * Register custom query methods for this model
  *
@@ -5001,6 +5032,14 @@ Model.__subclass = function subclass(conn, schema, collection) {
 
 Model.recompileSchema = function recompileSchema() {
   this.prototype.$__setSchema(this.schema);
+
+  if (this.schema._applyDiscriminators != null) {
+    for (const disc of this.schema._applyDiscriminators.keys()) {
+      this.discriminator(disc, this.schema._applyDiscriminators.get(disc));
+    }
+  }
+
+  applyEmbeddedDiscriminators(this.schema, new WeakSet(), true);
 };
 
 /**

package/lib/mongoose.js

@@ -166,9 +166,19 @@ Mongoose.prototype.setDriver = function setDriver(driver) {
   _mongoose.__driver = driver;
 
   const Connection = driver.Connection;
+  const oldDefaultConnection = _mongoose.connections[0];
   _mongoose.connections = [new Connection(_mongoose)];
   _mongoose.connections[0].models = _mongoose.models;
 
+  // Update all models that pointed to the old default connection to
+  // the new default connection, including collections
+  for (const model of Object.values(_mongoose.models)) {
+    if (model.db !== oldDefaultConnection) {
+      continue;
+    }
+    model.$__updateConnection(_mongoose.connections[0]);
+  }
+
   return _mongoose;
 };
 
@@ -627,7 +637,11 @@ Mongoose.prototype._model = function(name, schema, collection, options) {
 
   if (schema._applyDiscriminators != null) {
     for (const disc of schema._applyDiscriminators.keys()) {
-      model.discriminator(disc, schema._applyDiscriminators.get(disc));
+      const {
+        schema: discriminatorSchema,
+        options
+      } = schema._applyDiscriminators.get(disc);
+      model.discriminator(disc, discriminatorSchema, options);
     }
   }
 

package/lib/schema/documentArray.js

@@ -447,19 +447,9 @@ SchemaDocumentArray.prototype.cast = function(value, doc, init, prev, options) {
 
     const Constructor = getConstructor(this.casterConstructor, rawArray[i]);
 
-    // Check if the document has a different schema (re gh-3701)
-    if (rawArray[i].$__ != null && !(rawArray[i] instanceof Constructor)) {
-      const spreadDoc = handleSpreadDoc(rawArray[i], true);
-      if (rawArray[i] !== spreadDoc) {
-        rawArray[i] = spreadDoc;
-      } else {
-        rawArray[i] = rawArray[i].toObject({
-          transform: false,
-          // Special case: if different model, but same schema, apply virtuals
-          // re: gh-7898
-          virtuals: rawArray[i].schema === Constructor.schema
-        });
-      }
+    const spreadDoc = handleSpreadDoc(rawArray[i], true);
+    if (rawArray[i] !== spreadDoc) {
+      rawArray[i] = spreadDoc;
     }
 
     if (rawArray[i] instanceof Subdocument) {

package/lib/schema/subdocument.js

@@ -325,7 +325,7 @@ SchemaSubdocument.prototype.discriminator = function(name, schema, options) {
     schema = schema.clone();
   }
 
-  schema = discriminator(this.caster, name, schema, value);
+  schema = discriminator(this.caster, name, schema, value, null, null, options.overwriteExisting);
 
   this.caster.discriminators[name] = _createConstructor(schema, this.caster);
 

package/lib/schema.js

@@ -626,12 +626,18 @@ Schema.prototype.defaultOptions = function(options) {
  *
  * @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.
  * @return {Schema} the Schema instance
  * @api public
  */
-Schema.prototype.discriminator = function(name, schema) {
+Schema.prototype.discriminator = function(name, schema, options) {
   this._applyDiscriminators = this._applyDiscriminators || new Map();
-  this._applyDiscriminators.set(name, schema);
+  this._applyDiscriminators.set(name, { schema, options });
 
   return this;
 };
@@ -1952,6 +1958,7 @@ Schema.prototype.plugin = function(fn, opts) {
       'got "' + (typeof fn) + '"');
   }
 
+
   if (opts && opts.deduplicate) {
     for (const plugin of this.plugins) {
       if (plugin.fn === fn) {
@@ -2755,7 +2762,7 @@ function isArrayFilter(piece) {
  */
 
 Schema.prototype._preCompile = function _preCompile() {
-  idGetter(this);
+  this.plugin(idGetter, { deduplicate: true });
 };
 
 /*!

package/lib/schemaType.js

@@ -878,7 +878,7 @@ SchemaType.prototype.validateAll = function(validators) {
  *
  *     schema.path('name').validate({
  *       validator: function() { throw new Error('Oops!'); },
- *       // `errors['name']` will be "Oops!"
+ *       // `errors['name'].message` will be "Oops!"
  *       message: function(props) { return props.reason.message; }
  *     });
  *
@@ -1542,7 +1542,7 @@ SchemaType.prototype._castRef = function _castRef(value, doc, init) {
   }
 
   if (value.$__ != null) {
-    value.$__.wasPopulated = value.$__.wasPopulated || true;
+    value.$__.wasPopulated = value.$__.wasPopulated || { value: value._id };
     return value;
   }
 
@@ -1568,7 +1568,7 @@ SchemaType.prototype._castRef = function _castRef(value, doc, init) {
     !doc.$__.populated[path].options.options ||
     !doc.$__.populated[path].options.options.lean) {
     ret = new pop.options[populateModelSymbol](value);
-    ret.$__.wasPopulated = true;
+    ret.$__.wasPopulated = { value: ret._id };
   }
 
   return ret;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.3.0",
+  "version": "8.3.2",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -20,7 +20,7 @@
   "license": "MIT",
   "dependencies": {
     "bson": "^6.5.0",
-    "kareem": "2.6.0",
+    "kareem": "2.6.3",
     "mongodb": "6.5.0",
     "mpath": "0.9.0",
     "mquery": "5.0.0",

package/types/index.d.ts

@@ -431,7 +431,7 @@ declare module 'mongoose' {
       fn: (
         this: T,
         next: (err?: CallbackError) => void,
-        ops: Array<mongodb.AnyBulkWriteOperation<any> & MongooseBulkWritePerWriteOptions>,
+        ops: Array<AnyBulkWriteOperation<any>>,
         options?: mongodb.BulkWriteOptions & MongooseBulkWriteOptions
       ) => void | Promise<void>
     ): this;

package/types/models.d.ts

@@ -23,13 +23,21 @@ declare module 'mongoose' {
     ): U;
   }
 
-  interface MongooseBulkWriteOptions {
+  interface MongooseBulkWriteOptions extends mongodb.BulkWriteOptions {
+    session?: ClientSession;
     skipValidation?: boolean;
     throwOnValidationError?: boolean;
-    timestamps?: boolean;
     strict?: boolean | 'throw';
   }
 
+  interface MongooseBulkSaveOptions extends mongodb.BulkWriteOptions {
+    timestamps?: boolean;
+    session?: ClientSession;
+  }
+
+  /**
+   * @deprecated use AnyBulkWriteOperation instead
+   */
   interface MongooseBulkWritePerWriteOptions {
     timestamps?: boolean;
     strict?: boolean | 'throw';
@@ -200,6 +208,8 @@ declare module 'mongoose' {
     hint?: mongodb.Hint;
     /** When true, creates a new document if no document matches the query. */
     upsert?: boolean;
+    /** When false, do not add timestamps. */
+    timestamps?: boolean;
   }
 
   export interface UpdateManyModel<TSchema = AnyObject> {
@@ -215,6 +225,8 @@ declare module 'mongoose' {
     hint?: mongodb.Hint;
     /** When true, creates a new document if no document matches the query. */
     upsert?: boolean;
+    /** When false, do not add timestamps. */
+    timestamps?: boolean;
   }
 
   export interface DeleteOneModel<TSchema = AnyObject> {
@@ -281,11 +293,11 @@ declare module 'mongoose' {
      */
     bulkWrite<DocContents = TRawDocType>(
       writes: Array<AnyBulkWriteOperation<DocContents extends Document ? any : (DocContents extends {} ? DocContents : any)>>,
-      options: mongodb.BulkWriteOptions & MongooseBulkWriteOptions & { ordered: false }
+      options: MongooseBulkWriteOptions & { ordered: false }
     ): Promise<mongodb.BulkWriteResult & { mongoose?: { validationErrors: Error[] } }>;
     bulkWrite<DocContents = TRawDocType>(
       writes: Array<AnyBulkWriteOperation<DocContents extends Document ? any : (DocContents extends {} ? DocContents : any)>>,
-      options?: mongodb.BulkWriteOptions & MongooseBulkWriteOptions
+      options?: MongooseBulkWriteOptions
     ): Promise<mongodb.BulkWriteResult>;
 
     /**
@@ -293,7 +305,7 @@ declare module 'mongoose' {
      * sending multiple `save()` calls because with `bulkSave()` there is only one
      * network round trip to the MongoDB server.
      */
-    bulkSave(documents: Array<Document>, options?: mongodb.BulkWriteOptions & { timestamps?: boolean }): Promise<mongodb.BulkWriteResult>;
+    bulkSave(documents: Array<Document>, options?: MongooseBulkSaveOptions): Promise<mongodb.BulkWriteResult>;
 
     /** Collection the model uses. */
     collection: Collection;

package/types/query.d.ts

@@ -1,24 +1,7 @@
 declare module 'mongoose' {
   import mongodb = require('mongodb');
 
-  type StringQueryTypeCasting = string | RegExp;
-  type ObjectIdQueryTypeCasting = Types.ObjectId | string;
-  type UUIDQueryTypeCasting = Types.UUID | string;
-
-  type QueryTypeCasting<T> = T extends string
-    ? StringQueryTypeCasting
-    : T extends Types.ObjectId
-      ? ObjectIdQueryTypeCasting
-      : T extends Types.UUID
-        ? UUIDQueryTypeCasting
-        : T | any;
-
-  export type ApplyBasicQueryCasting<T> = T | T[] | (T extends (infer U)[] ? QueryTypeCasting<U> : T);
-  export type Condition<T> = ApplyBasicQueryCasting<QueryTypeCasting<T>> | QuerySelector<ApplyBasicQueryCasting<QueryTypeCasting<T>>>;
-
-  type _FilterQuery<T> = {
-    [P in keyof T]?: Condition<T[P]>;
-  } & RootQuerySelector<T>;
+  export type Condition<T> = T | QuerySelector<T | any> | any;
 
   /**
    * Filter query to select the documents that match the query
@@ -27,7 +10,9 @@ declare module 'mongoose' {
    * { age: { $gte: 30 } }
    * ```
    */
-  type FilterQuery<T> = _FilterQuery<T>;
+  type FilterQuery<T> = {
+    [P in keyof T]?: Condition<T[P]>;
+  } & RootQuerySelector<T>;
 
   type MongooseBaseQueryOptionKeys =
     | 'context'

package/types/schematypes.d.ts

@@ -193,9 +193,10 @@ declare module 'mongoose' {
   }
 
   interface Validator<DocType = any> {
-    message?: string;
+    message?: string | ((props: ValidatorProps) => string);
     type?: string;
     validator?: ValidatorFunction<DocType>;
+    reason?: Error;
   }
 
   type ValidatorFunction<DocType = any> = (this: DocType, value: any, validatorProperties?: Validator) => any;

package/types/types.d.ts

@@ -60,7 +60,7 @@ declare module 'mongoose' {
 
     class Decimal128 extends mongodb.Decimal128 { }
 
-    class DocumentArray<T> extends Types.Array<T extends Types.Subdocument ? T : Types.Subdocument<InferId<T>> & T> {
+    class DocumentArray<T> extends Types.Array<T extends Types.Subdocument ? T : Types.Subdocument<InferId<T>, any, T> & T> {
       /** DocumentArray constructor */
       constructor(values: AnyObject[]);
 
@@ -83,7 +83,7 @@ declare module 'mongoose' {
     class ObjectId extends mongodb.ObjectId {
     }
 
-    class Subdocument<IdType = any> extends Document<IdType> {
+    class Subdocument<IdType = any, TQueryHelpers = any, DocType = any> extends Document<IdType, TQueryHelpers, DocType> {
       $isSingleNested: true;
 
       /** Returns the top level document of this sub-document. */

package/types/validation.d.ts

@@ -6,6 +6,7 @@ declare module 'mongoose' {
     path: string;
     fullPath: string;
     value: any;
+    reason?: Error;
   }
 
   interface ValidatorMessageFn {