mongoose 8.20.4 → 8.21.0

package/lib/document.js

@@ -842,7 +842,7 @@ function init(self, obj, doc, opts, prefix) {
  *  - same as in [Model.updateOne](https://mongoosejs.com/docs/api/model.html#Model.updateOne)
  *
  * @see Model.updateOne https://mongoosejs.com/docs/api/model.html#Model.updateOne
- * @param {Object} doc
+ * @param {Object} update
  * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
  * @param {Object} [options.lean] if truthy, mongoose will return the document as a plain JavaScript object rather than a mongoose document. See [`Query.lean()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.lean()) and the [Mongoose lean tutorial](https://mongoosejs.com/docs/tutorials/lean.html).
  * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
@@ -853,22 +853,24 @@ function init(self, obj, doc, opts, prefix) {
  * @instance
  */
 
-Document.prototype.updateOne = function updateOne(doc, options, callback) {
-  const query = this.constructor.updateOne({ _id: this._doc._id }, doc, options);
+Document.prototype.updateOne = function updateOne(update, options, callback) {
+  const query = this.constructor.updateOne();
   const self = this;
   query.pre(function queryPreUpdateOne(cb) {
-    self.constructor._middleware.execPre('updateOne', self, [self], cb);
+    self.constructor._middleware.execPre('updateOne', self, [self, update, options], (err, res) => {
+      this.updateOne({ _id: self._doc._id }, update, options);
+      if (self.$session() != null) {
+        if (!('session' in query.options)) {
+          query.options.session = self.$session();
+        }
+      }
+      return cb(err, res);
+    });
   });
   query.post(function queryPostUpdateOne(cb) {
     self.constructor._middleware.execPost('updateOne', self, [self], {}, cb);
   });
 
-  if (this.$session() != null) {
-    if (!('session' in query.options)) {
-      query.options.session = this.$session();
-    }
-  }
-
   if (callback != null) {
     return query.exec(callback);
   }
@@ -3545,7 +3547,9 @@ Document.prototype.$__reset = function reset() {
   this.$__dirty().forEach(function(dirt) {
     const type = dirt.value;
 
-    if (type && type[arrayAtomicsSymbol]) {
+    if (type && typeof type.clearAtomics === 'function') {
+      type.clearAtomics();
+    } else if (type && type[arrayAtomicsSymbol]) {
       type[arrayAtomicsBackupSymbol] = type[arrayAtomicsSymbol];
       type[arrayAtomicsSymbol] = {};
     }
@@ -5028,8 +5032,8 @@ Document.prototype.$__delta = function $__delta() {
       operand(this, where, delta, data, 1, '$unset');
     } else if (value === null) {
       operand(this, where, delta, data, null);
-    } else if (utils.isMongooseArray(value) && value.$path() && value[arrayAtomicsSymbol]) {
-      // arrays and other custom types (support plugins etc)
+    } else if (typeof value.getAtomics === 'function') {
+      // arrays and other custom container types
       handleAtomics(this, where, delta, data, value);
     } else if (value[MongooseBuffer.pathSymbol] && Buffer.isBuffer(value)) {
       // MongooseBuffer
@@ -5206,6 +5210,15 @@ function handleAtomics(self, where, delta, data, value) {
     return;
   }
 
+  if (typeof value.getAtomics === 'function') {
+    value.getAtomics().forEach(function(atomic) {
+      const op = atomic[0];
+      const val = atomic[1];
+      operand(self, where, delta, data, val, op);
+    });
+    return;
+  }
+
   if (typeof value.$__getAtomics === 'function') {
     value.$__getAtomics().forEach(function(atomic) {
       const op = atomic[0];

package/lib/model.js

@@ -789,7 +789,7 @@ Model.prototype.deleteOne = function deleteOne(options) {
   if (where instanceof Error) {
     throw where;
   }
-  const query = self.constructor.deleteOne(where, options);
+  const query = self.constructor.deleteOne();
 
   if (this.$session() != null) {
     if (!('session' in query.options)) {
@@ -799,7 +799,8 @@ Model.prototype.deleteOne = function deleteOne(options) {
 
   query.pre(async function queryPreDeleteOne() {
     await new Promise((resolve, reject) => {
-      self.constructor._middleware.execPre('deleteOne', self, [self], err => {
+      self.constructor._middleware.execPre('deleteOne', self, [self, options], err => {
+        query.deleteOne(where, options);
         if (err) reject(err);
         else resolve();
       });
@@ -812,7 +813,7 @@ Model.prototype.deleteOne = function deleteOne(options) {
   });
   query.pre(function callSubdocPreHooks(cb) {
     each(self.$getAllSubdocs(), (subdoc, cb) => {
-      subdoc.constructor._middleware.execPre('deleteOne', subdoc, [subdoc], cb);
+      subdoc.constructor._middleware.execPre('deleteOne', subdoc, [subdoc, options], cb);
     }, cb);
   });
   query.pre(function skipIfAlreadyDeleted(cb) {

package/lib/schema/number.js

@@ -330,7 +330,25 @@ SchemaNumber.prototype.enum = function(values, message) {
     }
 
     if (utils.isPOJO(values)) {
-      values = Object.values(values);
+      // TypeScript numeric enums produce objects with reverse
+      // mappings, e.g. { 0: 'Zero', 1: 'One', Zero: 0, One: 1 }.
+      // Object.values on that will yield ['Zero','One',0,1].
+      // For Number schema enums we only want the numeric values,
+      // otherwise casting the name strings to Number will throw.
+      const keys = Object.keys(values).sort();
+      const objVals = Object.values(values).sort();
+      // If keys and values are equal and half of values are numbers,
+      // this is likely a TS enum with reverse mapping, so use only the numbers.
+      if (
+        keys.length === objVals.length &&
+        keys.every((k, i) => k === String(objVals[i])) &&
+        objVals.filter(v => typeof v === 'number').length === Math.floor(objVals.length / 2)
+      ) {
+        values = objVals.filter(v => typeof v === 'number');
+      } else {
+        // Avoid sorting the values to preserve user-specified order
+        values = Object.values(values);
+      }
     }
     message = message || MongooseError.messages.Number.enum;
   }

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

@@ -10,6 +10,7 @@ const mpath = require('mpath');
 const utils = require('../../../utils');
 const isBsonType = require('../../../helpers/isBsonType');
 
+const arrayAtomicsBackupSymbol = require('../../../helpers/symbols').arrayAtomicsBackupSymbol;
 const arrayAtomicsSymbol = require('../../../helpers/symbols').arrayAtomicsSymbol;
 const arrayParentSymbol = require('../../../helpers/symbols').arrayParentSymbol;
 const arrayPathSymbol = require('../../../helpers/symbols').arrayPathSymbol;
@@ -75,6 +76,36 @@ const methods = {
     return ret;
   },
 
+  /**
+   * Public API for getting atomics. Alias for $__getAtomics() that can be
+   * implemented by custom container types.
+   *
+   * @return {Array}
+   * @method getAtomics
+   * @memberOf MongooseArray
+   * @instance
+   * @api public
+   */
+
+  getAtomics() {
+    return this.$__getAtomics();
+  },
+
+  /**
+   * Clears all pending atomic operations. Called by Mongoose after save().
+   *
+   * @return {void}
+   * @method clearAtomics
+   * @memberOf MongooseArray
+   * @instance
+   * @api public
+   */
+
+  clearAtomics() {
+    this[arrayAtomicsBackupSymbol] = this[arrayAtomicsSymbol];
+    this[arrayAtomicsSymbol] = {};
+  },
+
   /*!
    * ignore
    */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.20.4",
+  "version": "8.21.0",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",

package/types/index.d.ts

@@ -468,9 +468,14 @@ declare module 'mongoose' {
     pre<T = never>(method: MongooseDistinctDocumentMiddleware | MongooseDistinctDocumentMiddleware[] | RegExp, options: SchemaPreOptions & { document: false, query: boolean }, fn: PreMiddlewareFunction<T>): this;
     // this = Union of Document and Query, could be called with any of them
     pre<T = THydratedDocumentType | Query<any, any>>(
-      method: MongooseQueryAndDocumentMiddleware | MongooseQueryAndDocumentMiddleware[] | RegExp,
+      method: 'updateOne' | RegExp,
       options: SchemaPreOptions & { document: true, query: true },
-      fn: PreMiddlewareFunction<T>
+      fn: PreUpdateOneMiddlewareFunction<T>
+    ): this;
+    pre<T = THydratedDocumentType | Query<any, any>>(
+      method: 'deleteOne' | RegExp,
+      options: SchemaPreOptions & { document: true, query: true },
+      fn: PreDeleteOneMiddlewareFunction<T>
     ): this;
     // this = Document
     pre<T = THydratedDocumentType>(method: 'save', fn: PreSaveMiddlewareFunction<T>): this;
@@ -478,9 +483,14 @@ declare module 'mongoose' {
     pre<T = THydratedDocumentType>(method: MongooseDistinctDocumentMiddleware|MongooseDistinctDocumentMiddleware[], fn: PreMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType>(method: MongooseDistinctDocumentMiddleware|MongooseDistinctDocumentMiddleware[], options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType>(
-      method: MongooseQueryAndDocumentMiddleware | MongooseQueryAndDocumentMiddleware[] | RegExp,
+      method: 'updateOne' | RegExp,
+      options: SchemaPreOptions & { document: true },
+      fn: PreUpdateOneMiddlewareFunction<T>
+    ): this;
+    pre<T = THydratedDocumentType>(
+      method: 'deleteOne' | RegExp,
       options: SchemaPreOptions & { document: true },
-      fn: PreMiddlewareFunction<T>
+      fn: PreDeleteOneMiddlewareFunction<T>
     ): this;
     pre<T = THydratedDocumentType>(method: MongooseQueryOrDocumentMiddleware | MongooseQueryOrDocumentMiddleware[] | RegExp, options: SchemaPreOptions & { document: true, query: false }, fn: PreMiddlewareFunction<T>): this;
     // this = Query

package/types/middlewares.d.ts

@@ -39,6 +39,19 @@ declare module 'mongoose' {
     next: CallbackWithoutResultAndOptionalError,
     opts?: Record<string, any>
   ) => void | Promise<void> | Kareem.SkipWrappedFunction;
+  type PreDeleteOneMiddlewareFunction<ThisType = any> = (
+    this: ThisType,
+    next: CallbackWithoutResultAndOptionalError,
+    doc: ThisType,
+    opts?: Record<string, any>
+  ) => void | Promise<void> | Kareem.SkipWrappedFunction;
+  type PreUpdateOneMiddlewareFunction<ThisType = any> = (
+    this: ThisType,
+    next: CallbackWithoutResultAndOptionalError,
+    doc: ThisType,
+    update?: Record<string, any>,
+    opts?: Record<string, any>
+  ) => void | Promise<void> | Kareem.SkipWrappedFunction;
   type PreSaveMiddlewareFunction<ThisType = any> = (
     this: ThisType,
     next: CallbackWithoutResultAndOptionalError,