mongoose 8.20.0 → 8.20.2

package/lib/document.js

@@ -5422,6 +5422,38 @@ Document.prototype.$__hasOnlyPrimitiveValues = function $__hasOnlyPrimitiveValue
   }));
 };
 
+/*!
+ * Increment this document's version if necessary.
+ */
+
+Document.prototype._applyVersionIncrement = function _applyVersionIncrement() {
+  if (!this.$__.version) return;
+  const doIncrement = VERSION_INC === (VERSION_INC & this.$__.version);
+
+  this.$__.version = undefined;
+  if (doIncrement) {
+    const key = this.$__schema.options.versionKey;
+    const version = this.$__getValue(key) || 0;
+    this.$__setValue(key, version + 1); // increment version if was successful
+  }
+};
+
+/*!
+ * Increment this document's version if necessary.
+ */
+
+Document.prototype._applyVersionIncrement = function _applyVersionIncrement() {
+  if (!this.$__.version) return;
+  const doIncrement = VERSION_INC === (VERSION_INC & this.$__.version);
+
+  this.$__.version = undefined;
+  if (doIncrement) {
+    const key = this.$__schema.options.versionKey;
+    const version = this.$__getValue(key) || 0;
+    this.$__setValue(key, version + 1); // increment version if was successful
+  }
+};
+
 /*!
  * Module exports.
  */

package/lib/helpers/model/castBulkWrite.js

@@ -118,7 +118,10 @@ module.exports.castUpdateOne = function castUpdateOne(originalModel, updateOne,
   if (model.schema.$timestamps != null && doInitTimestamps) {
     const createdAt = model.schema.$timestamps.createdAt;
     const updatedAt = model.schema.$timestamps.updatedAt;
-    applyTimestampsToUpdate(now, createdAt, updatedAt, update, {});
+    applyTimestampsToUpdate(now, createdAt, updatedAt, update, {
+      timestamps: updateOne.timestamps,
+      overwriteImmutable: updateOne.overwriteImmutable
+    });
   }
 
   if (doInitTimestamps) {
@@ -150,7 +153,8 @@ module.exports.castUpdateOne = function castUpdateOne(originalModel, updateOne,
     strict: strict,
     upsert: updateOne.upsert,
     arrayFilters: updateOne.arrayFilters,
-    overwriteDiscriminatorKey: updateOne.overwriteDiscriminatorKey
+    overwriteDiscriminatorKey: updateOne.overwriteDiscriminatorKey,
+    overwriteImmutable: updateOne.overwriteImmutable
   }, model, updateOne['filter']);
 
   return updateOne;
@@ -185,7 +189,10 @@ module.exports.castUpdateMany = function castUpdateMany(originalModel, updateMan
   if (model.schema.$timestamps != null && doInitTimestamps) {
     const createdAt = model.schema.$timestamps.createdAt;
     const updatedAt = model.schema.$timestamps.updatedAt;
-    applyTimestampsToUpdate(now, createdAt, updatedAt, updateMany['update'], {});
+    applyTimestampsToUpdate(now, createdAt, updatedAt, updateMany['update'], {
+      timestamps: updateMany.timestamps,
+      overwriteImmutable: updateMany.overwriteImmutable
+    });
   }
   if (doInitTimestamps) {
     applyTimestampsToChildren(now, updateMany['update'], model.schema);
@@ -208,7 +215,8 @@ module.exports.castUpdateMany = function castUpdateMany(originalModel, updateMan
     strict: strict,
     upsert: updateMany.upsert,
     arrayFilters: updateMany.arrayFilters,
-    overwriteDiscriminatorKey: updateMany.overwriteDiscriminatorKey
+    overwriteDiscriminatorKey: updateMany.overwriteDiscriminatorKey,
+    overwriteImmutable: updateMany.overwriteImmutable
   }, model, updateMany['filter']);
 };
 
@@ -295,7 +303,6 @@ function decideModelByObject(model, object) {
   return model;
 }
 
-
 /**
  * gets timestamps option for a given operation. If the option is set within an individual operation, use it. Otherwise, use the global timestamps option configured in the `bulkWrite` options. Overall default is `true`.
  * @api private

package/lib/helpers/update/applyTimestampsToUpdate.js

@@ -80,33 +80,46 @@ function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, optio
   }
 
   if (!skipCreatedAt && createdAt) {
-    if (currentUpdate[createdAt]) {
-      delete currentUpdate[createdAt];
-    }
-    if (currentUpdate.$set && currentUpdate.$set[createdAt]) {
-      delete currentUpdate.$set[createdAt];
-    }
-    let timestampSet = false;
-    if (createdAt.indexOf('.') !== -1) {
-      const pieces = createdAt.split('.');
-      for (let i = 1; i < pieces.length; ++i) {
-        const remnant = pieces.slice(-i).join('.');
-        const start = pieces.slice(0, -i).join('.');
-        if (currentUpdate[start] != null) {
-          currentUpdate[start][remnant] = now;
-          timestampSet = true;
-          break;
-        } else if (currentUpdate.$set && currentUpdate.$set[start]) {
-          currentUpdate.$set[start][remnant] = now;
-          timestampSet = true;
-          break;
+    const overwriteImmutable = get(options, 'overwriteImmutable', false);
+    const hasUserCreatedAt = currentUpdate[createdAt] != null || currentUpdate?.$set[createdAt] != null;
+
+    // If overwriteImmutable is true and user provided createdAt, keep their value
+    if (overwriteImmutable && hasUserCreatedAt) {
+      // Move createdAt from top-level to $set if needed
+      if (currentUpdate[createdAt] != null) {
+        updates.$set[createdAt] = currentUpdate[createdAt];
+        delete currentUpdate[createdAt];
+      }
+      // User's value is already in $set, nothing more to do
+    } else {
+      if (currentUpdate[createdAt]) {
+        delete currentUpdate[createdAt];
+      }
+      if (currentUpdate.$set && currentUpdate.$set[createdAt]) {
+        delete currentUpdate.$set[createdAt];
+      }
+      let timestampSet = false;
+      if (createdAt.indexOf('.') !== -1) {
+        const pieces = createdAt.split('.');
+        for (let i = 1; i < pieces.length; ++i) {
+          const remnant = pieces.slice(-i).join('.');
+          const start = pieces.slice(0, -i).join('.');
+          if (currentUpdate[start] != null) {
+            currentUpdate[start][remnant] = now;
+            timestampSet = true;
+            break;
+          } else if (currentUpdate.$set && currentUpdate.$set[start]) {
+            currentUpdate.$set[start][remnant] = now;
+            timestampSet = true;
+            break;
+          }
         }
       }
-    }
 
-    if (!timestampSet) {
-      updates.$setOnInsert = updates.$setOnInsert || {};
-      updates.$setOnInsert[createdAt] = now;
+      if (!timestampSet) {
+        updates.$setOnInsert = updates.$setOnInsert || {};
+        updates.$setOnInsert[createdAt] = now;
+      }
     }
   }
 

package/lib/model.js

@@ -523,11 +523,9 @@ Model.prototype.$__save = function(options, callback) {
       const versionBump = this.$__.version;
       // was this an update that required a version bump?
       if (versionBump && !this.$__.inserting) {
-        const doIncrement = VERSION_INC === (VERSION_INC & this.$__.version);
-        this.$__.version = undefined;
-        const key = this.$__schema.options.versionKey;
-        const version = this.$__getValue(key) || 0;
         if (numAffected <= 0) {
+          const key = this.$__schema.options.versionKey;
+          const version = this.$__getValue(key) || 0;
           // the update failed. pass an error back
           this.$__undoReset();
           const err = this.$__.$versionError ||
@@ -535,10 +533,7 @@ Model.prototype.$__save = function(options, callback) {
           return callback(err, this);
         }
 
-        // increment version if was successful
-        if (doIncrement) {
-          this.$__setValue(key, version + 1);
-        }
+        this._applyVersionIncrement();
       }
       if (result != null && numAffected <= 0) {
         this.$__undoReset();
@@ -3666,6 +3661,8 @@ function handleSuccessfulWrite(document) {
     }
 
     document.$__reset();
+    document._applyVersionIncrement();
+
     document.schema.s.hooks.execPost('save', document, [document], {}, (err) => {
       if (err) {
         reject(err);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.20.0",
+  "version": "8.20.2",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -55,7 +55,7 @@
     "lodash.isequal": "4.5.0",
     "lodash.isequalwith": "4.4.0",
     "markdownlint-cli2": "^0.18.1",
-    "marked": "16.4.1",
+    "marked": "15.x",
     "mkdirp": "^3.0.1",
     "mocha": "11.7.4",
     "moment": "2.30.1",
@@ -91,6 +91,7 @@
     "docs:prepare:publish:5x": "git checkout 5.x && git merge 5.x && npm run docs:clean:stable && npm run docs:generate && npm run docs:copy:tmp && git checkout gh-pages && npm run docs:copy:tmp:5x",
     "docs:prepare:publish:6x": "git checkout 6.x && git merge 6.x && npm run docs:clean:stable && env DOCS_DEPLOY=true npm run docs:generate && mv ./docs/6.x ./tmp && git checkout gh-pages && npm run docs:copy:tmp:6x",
     "docs:prepare:publish:7x": "env DOCS_DEPLOY=true npm run docs:generate && git checkout gh-pages && rimraf ./docs/7.x && mv ./tmp ./docs/7.x",
+    "docs:prepare:publish:8x": "env DOCS_DEPLOY=true npm run docs:generate && git checkout gh-pages && rimraf ./docs/8.x && mv ./tmp ./docs/8.x",
     "docs:check-links": "blc http://127.0.0.1:8089 -ro",
     "lint": "eslint .",
     "lint-js": "eslint . --ext .js --ext .cjs",

package/types/index.d.ts

@@ -542,6 +542,7 @@ declare module 'mongoose' {
 
     /** Adds static "class" methods to Models compiled from this schema. */
     static<K extends keyof TStaticMethods>(name: K, fn: TStaticMethods[K]): this;
+    static(obj: { [F in keyof TStaticMethods]: TStaticMethods[F] }): this;
     static(obj: { [F in keyof TStaticMethods]: TStaticMethods[F] } & { [name: string]: (this: TModelType, ...args: any[]) => any }): this;
     static(name: string, fn: (this: TModelType, ...args: any[]) => any): this;
 

package/types/models.d.ts

@@ -172,94 +172,47 @@ declare module 'mongoose' {
 
   interface RemoveOptions extends SessionOption, Omit<mongodb.DeleteOptions, 'session'> {}
 
-  const Model: Model<any>;
-
-  export type AnyBulkWriteOperation<TSchema = AnyObject> = {
-    insertOne: InsertOneModel<TSchema>;
-  } | {
-    replaceOne: ReplaceOneModel<TSchema>;
-  } | {
-    updateOne: UpdateOneModel<TSchema>;
-  } | {
-    updateMany: UpdateManyModel<TSchema>;
-  } | {
-    deleteOne: DeleteOneModel<TSchema>;
-  } | {
-    deleteMany: DeleteManyModel<TSchema>;
-  };
-
-  export interface InsertOneModel<TSchema> {
-    document: mongodb.OptionalId<TSchema>;
+  interface MongooseBulkWritePerOperationOptions {
+    /** Skip validation for this operation. */
+    skipValidation?: boolean;
     /** When false, do not add timestamps. When true, overrides the `timestamps` option set in the `bulkWrite` options. */
     timestamps?: boolean;
   }
 
-  export interface ReplaceOneModel<TSchema = AnyObject> {
-    /** The filter to limit the replaced document. */
-    filter: RootFilterQuery<TSchema>;
-    /** The document with which to replace the matched document. */
-    replacement: mongodb.WithoutId<TSchema>;
-    /** Specifies a collation. */
-    collation?: mongodb.CollationOptions;
-    /** The index to use. If specified, then the query system will only consider plans using the hinted index. */
-    hint?: mongodb.Hint;
-    /** When true, creates a new document if no document matches the query. */
-    upsert?: boolean;
-    /** When false, do not add timestamps. When true, overrides the `timestamps` option set in the `bulkWrite` options. */
-    timestamps?: boolean;
+  interface MongooseBulkUpdatePerOperationOptions extends MongooseBulkWritePerOperationOptions {
+    /** When true, allows updating fields that are marked as `immutable` in the schema. */
+    overwriteImmutable?: boolean;
+    /** When false, do not set default values on insert. */
+    setDefaultsOnInsert?: boolean;
   }
 
-  export interface UpdateOneModel<TSchema = AnyObject> {
-    /** The filter to limit the updated documents. */
-    filter: RootFilterQuery<TSchema>;
-    /** A document or pipeline containing update operators. */
-    update: UpdateQuery<TSchema>;
-    /** A set of filters specifying to which array elements an update should apply. */
-    arrayFilters?: AnyObject[];
-    /** Specifies a collation. */
-    collation?: mongodb.CollationOptions;
-    /** The index to use. If specified, then the query system will only consider plans using the hinted index. */
-    hint?: mongodb.Hint;
-    /** When true, creates a new document if no document matches the query. */
-    upsert?: boolean;
-    /** When false, do not add timestamps. When true, overrides the `timestamps` option set in the `bulkWrite` options. */
-    timestamps?: boolean;
-  }
+  export type InsertOneModel<TSchema extends mongodb.Document = mongodb.Document> =
+    mongodb.InsertOneModel<TSchema> & MongooseBulkWritePerOperationOptions;
 
-  export interface UpdateManyModel<TSchema = AnyObject> {
-    /** The filter to limit the updated documents. */
-    filter: RootFilterQuery<TSchema>;
-    /** A document or pipeline containing update operators. */
-    update: UpdateQuery<TSchema>;
-    /** A set of filters specifying to which array elements an update should apply. */
-    arrayFilters?: AnyObject[];
-    /** Specifies a collation. */
-    collation?: mongodb.CollationOptions;
-    /** The index to use. If specified, then the query system will only consider plans using the hinted index. */
-    hint?: mongodb.Hint;
-    /** When true, creates a new document if no document matches the query. */
-    upsert?: boolean;
-    /** When false, do not add timestamps. When true, overrides the `timestamps` option set in the `bulkWrite` options. */
-    timestamps?: boolean;
-  }
+  export type ReplaceOneModel<TSchema extends mongodb.Document = mongodb.Document> =
+    mongodb.ReplaceOneModel<TSchema> & MongooseBulkWritePerOperationOptions;
 
-  export interface DeleteOneModel<TSchema = AnyObject> {
-    /** The filter to limit the deleted documents. */
-    filter: RootFilterQuery<TSchema>;
-    /** Specifies a collation. */
-    collation?: mongodb.CollationOptions;
-    /** The index to use. If specified, then the query system will only consider plans using the hinted index. */
-    hint?: mongodb.Hint;
-  }
+  export type UpdateOneModel<TSchema extends mongodb.Document = mongodb.Document> =
+    mongodb.UpdateOneModel<TSchema> & MongooseBulkUpdatePerOperationOptions;
 
-  export interface DeleteManyModel<TSchema = AnyObject> {
-    /** The filter to limit the deleted documents. */
-    filter: RootFilterQuery<TSchema>;
-    /** Specifies a collation. */
-    collation?: mongodb.CollationOptions;
-    /** The index to use. If specified, then the query system will only consider plans using the hinted index. */
-    hint?: mongodb.Hint;
-  }
+  export type UpdateManyModel<TSchema extends mongodb.Document = mongodb.Document> =
+    mongodb.UpdateManyModel<TSchema> & MongooseBulkUpdatePerOperationOptions;
+
+  export type DeleteOneModel<TSchema extends mongodb.Document = mongodb.Document> =
+    mongodb.DeleteOneModel<TSchema>;
+
+  export type DeleteManyModel<TSchema extends mongodb.Document = mongodb.Document> =
+    mongodb.DeleteManyModel<TSchema>;
+
+  export type AnyBulkWriteOperation<TSchema extends mongodb.Document = mongodb.Document> =
+    | { insertOne: InsertOneModel<TSchema> }
+    | { replaceOne: ReplaceOneModel<TSchema> }
+    | { updateOne: UpdateOneModel<TSchema> }
+    | { updateMany: UpdateManyModel<TSchema> }
+    | { deleteOne: DeleteOneModel<TSchema> }
+    | { deleteMany: DeleteManyModel<TSchema> };
+
+  const Model: Model<any>;
 
   type HasLeanOption<TSchema> = 'lean' extends keyof ObtainSchemaGeneric<TSchema, 'TSchemaOptions'> ?
     ObtainSchemaGeneric<TSchema, 'TSchemaOptions'>['lean'] extends Record<string, any> ?
@@ -319,13 +272,13 @@ declare module 'mongoose' {
      * round trip to the MongoDB server.
      */
     bulkWrite<DocContents = TRawDocType>(
-      writes: Array<AnyBulkWriteOperation<DocContents>>,
-      options: MongooseBulkWriteOptions & { ordered: false }
-    ): Promise<MongooseBulkWriteResult>;
+      writes: Array<AnyBulkWriteOperation<DocContents extends mongodb.Document ? DocContents : any>>,
+      options: mongodb.BulkWriteOptions & MongooseBulkWriteOptions & { ordered: false }
+    ): Promise<mongodb.BulkWriteResult & { mongoose?: { validationErrors: Error[] } }>;
     bulkWrite<DocContents = TRawDocType>(
-      writes: Array<AnyBulkWriteOperation<DocContents>>,
-      options?: MongooseBulkWriteOptions
-    ): Promise<MongooseBulkWriteResult>;
+      writes: Array<AnyBulkWriteOperation<DocContents extends mongodb.Document ? DocContents : any>>,
+      options?: mongodb.BulkWriteOptions & MongooseBulkWriteOptions
+    ): Promise<mongodb.BulkWriteResult>;
 
     /**
      * Sends multiple `save()` calls in a single `bulkWrite()`. This is faster than