mongoose 7.4.3 → 7.4.5

package/lib/connection.js

@@ -517,49 +517,66 @@ Connection.prototype.startSession = async function startSession(options) {
 Connection.prototype.transaction = function transaction(fn, options) {
   return this.startSession().then(session => {
     session[sessionNewDocuments] = new Map();
-    return session.withTransaction(() => fn(session), options).
+    return session.withTransaction(() => _wrapUserTransaction(fn, session), options).
       then(res => {
         delete session[sessionNewDocuments];
         return res;
       }).
       catch(err => {
-        // If transaction was aborted, we need to reset newly
-        // inserted documents' `isNew`.
-        for (const doc of session[sessionNewDocuments].keys()) {
-          const state = session[sessionNewDocuments].get(doc);
-          if (state.hasOwnProperty('isNew')) {
-            doc.$isNew = state.$isNew;
-          }
-          if (state.hasOwnProperty('versionKey')) {
-            doc.set(doc.schema.options.versionKey, state.versionKey);
-          }
-
-          if (state.modifiedPaths.length > 0 && doc.$__.activePaths.states.modify == null) {
-            doc.$__.activePaths.states.modify = {};
-          }
-          for (const path of state.modifiedPaths) {
-            doc.$__.activePaths.paths[path] = 'modify';
-            doc.$__.activePaths.states.modify[path] = true;
-          }
-
-          for (const path of state.atomics.keys()) {
-            const val = doc.$__getValue(path);
-            if (val == null) {
-              continue;
-            }
-            val[arrayAtomicsSymbol] = state.atomics.get(path);
-          }
-        }
         delete session[sessionNewDocuments];
         throw err;
-      })
-      .finally(() => {
-        session.endSession()
-          .catch(() => {});
+      }).
+      finally(() => {
+        session.endSession().catch(() => {});
       });
   });
 };
 
+/*!
+ * Reset document state in between transaction retries re: gh-13698
+ */
+
+async function _wrapUserTransaction(fn, session) {
+  try {
+    const res = await fn(session);
+    return res;
+  } catch (err) {
+    _resetSessionDocuments(session);
+    throw err;
+  }
+}
+
+/*!
+ * If transaction was aborted, we need to reset newly inserted documents' `isNew`.
+ */
+function _resetSessionDocuments(session) {
+  for (const doc of session[sessionNewDocuments].keys()) {
+    const state = session[sessionNewDocuments].get(doc);
+    if (state.hasOwnProperty('isNew')) {
+      doc.$isNew = state.isNew;
+    }
+    if (state.hasOwnProperty('versionKey')) {
+      doc.set(doc.schema.options.versionKey, state.versionKey);
+    }
+
+    if (state.modifiedPaths.length > 0 && doc.$__.activePaths.states.modify == null) {
+      doc.$__.activePaths.states.modify = {};
+    }
+    for (const path of state.modifiedPaths) {
+      doc.$__.activePaths.paths[path] = 'modify';
+      doc.$__.activePaths.states.modify[path] = true;
+    }
+
+    for (const path of state.atomics.keys()) {
+      const val = doc.$__getValue(path);
+      if (val == null) {
+        continue;
+      }
+      val[arrayAtomicsSymbol] = state.atomics.get(path);
+    }
+  }
+}
+
 /**
  * Helper for `dropCollection()`. Will delete the given collection, including
  * all documents and indexes.

package/lib/cursor/ChangeStream.js

@@ -6,6 +6,12 @@
 
 const EventEmitter = require('events').EventEmitter;
 
+/*!
+ * ignore
+ */
+
+const driverChangeStreamEvents = ['close', 'change', 'end', 'error', 'resumeTokenChanged'];
+
 /*!
  * ignore
  */
@@ -52,7 +58,7 @@ class ChangeStream extends EventEmitter {
           this.closed = true;
         });
 
-        ['close', 'change', 'end', 'error'].forEach(ev => {
+        driverChangeStreamEvents.forEach(ev => {
           this.driverChangeStream.on(ev, data => {
             // Sometimes Node driver still polls after close, so
             // avoid any uncaught exceptions due to closed change streams
@@ -75,7 +81,7 @@ class ChangeStream extends EventEmitter {
       this.closed = true;
     });
 
-    ['close', 'change', 'end', 'error'].forEach(ev => {
+    driverChangeStreamEvents.forEach(ev => {
       this.driverChangeStream.on(ev, data => {
         // Sometimes Node driver still polls after close, so
         // avoid any uncaught exceptions due to closed change streams
@@ -122,6 +128,11 @@ class ChangeStream extends EventEmitter {
     return this.driverChangeStream.next(cb);
   }
 
+  addListener(event, handler) {
+    this._bindEvents();
+    return super.addListener(event, handler);
+  }
+
   on(event, handler) {
     this._bindEvents();
     return super.on(event, handler);

package/lib/drivers/node-mongodb-native/collection.js

@@ -9,6 +9,7 @@ const MongooseError = require('../../error/mongooseError');
 const Collection = require('mongodb').Collection;
 const ObjectId = require('../../types/objectid');
 const getConstructorName = require('../../helpers/getConstructorName');
+const internalToObjectOptions = require('../../options').internalToObjectOptions;
 const stream = require('stream');
 const util = require('util');
 
@@ -377,7 +378,7 @@ function format(obj, sub, color, shell) {
   }
 
   const clone = require('../../helpers/clone');
-  let x = clone(obj, { transform: false });
+  let x = clone(obj, internalToObjectOptions);
   const constructorName = getConstructorName(x);
 
   if (constructorName === 'Binary') {

package/lib/helpers/query/selectPopulatedFields.js

@@ -21,12 +21,25 @@ module.exports = function selectPopulatedFields(fields, userProvidedFields, popu
       } else if (userProvidedFields[path] === 0) {
         delete fields[path];
       }
+
+      const refPath = populateOptions[path]?.refPath;
+      if (typeof refPath === 'string') {
+        if (!isPathInFields(userProvidedFields, refPath)) {
+          fields[refPath] = 1;
+        } else if (userProvidedFields[refPath] === 0) {
+          delete fields[refPath];
+        }
+      }
     }
   } else if (isExclusive(fields)) {
     for (const path of paths) {
       if (userProvidedFields[path] == null) {
         delete fields[path];
       }
+      const refPath = populateOptions[path]?.refPath;
+      if (typeof refPath === 'string' && userProvidedFields[refPath] == null) {
+        delete fields[refPath];
+      }
     }
   }
 };

package/lib/helpers/schema/getIndexes.js

@@ -78,7 +78,15 @@ module.exports = function getIndexes(schema) {
           field[prefix + key] = 'text';
           delete options.text;
         } else {
-          const isDescendingIndex = Number(index) === -1;
+          let isDescendingIndex = false;
+          if (index === 'descending' || index === 'desc') {
+            isDescendingIndex = true;
+          } else if (index === 'ascending' || index === 'asc') {
+            isDescendingIndex = false;
+          } else {
+            isDescendingIndex = Number(index) === -1;
+          }
+
           field[prefix + key] = isDescendingIndex ? -1 : 1;
         }
 

package/lib/model.js

@@ -1481,9 +1481,7 @@ Model.syncIndexes = async function syncIndexes(options) {
 };
 
 /**
- * Does a dry-run of Model.syncIndexes(), meaning that
- * the result of this function would be the result of
- * Model.syncIndexes().
+ * Does a dry-run of `Model.syncIndexes()`, returning the indexes that `syncIndexes()` would drop and create if you were to run `syncIndexes()`.
  *
  * @param {Object} [options]
  * @returns {Promise} which contains an object, {toDrop, toCreate}, which
@@ -3498,6 +3496,10 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
       const validOpIndexes = validOps;
       validOps = validOps.sort().map(index => ops[index]);
 
+      if (validOps.length === 0) {
+        return resolve(getDefaultBulkwriteResult());
+      }
+
       this.$__collection.bulkWrite(validOps, options, (error, res) => {
         if (error) {
           if (validationErrors.length > 0) {

package/lib/schema/SubdocumentPath.js

@@ -17,6 +17,7 @@ const geospatial = require('./operators/geospatial');
 const getConstructor = require('../helpers/discriminator/getConstructor');
 const handleIdOption = require('../helpers/schema/handleIdOption');
 const internalToObjectOptions = require('../options').internalToObjectOptions;
+const isExclusive = require('../helpers/projection/isExclusive');
 const utils = require('../utils');
 const InvalidSchemaOptionError = require('../error/invalidSchemaOption');
 
@@ -178,7 +179,8 @@ SubdocumentPath.prototype.cast = function(val, doc, init, priorVal, options) {
     subdoc = new Constructor(void 0, selected, doc, false, { defaults: false });
     delete subdoc.$__.defaults;
     subdoc.$init(val);
-    applyDefaults(subdoc, selected);
+    const exclude = isExclusive(selected);
+    applyDefaults(subdoc, selected, exclude);
   } else {
     options = Object.assign({}, options, { priorDoc: priorVal });
     if (Object.keys(val).length === 0) {

package/lib/schema.js

@@ -2046,6 +2046,14 @@ Schema.prototype.index = function(fields, options) {
     utils.expires(options);
   }
 
+  for (const field of Object.keys(fields)) {
+    if (fields[field] === 'ascending' || fields[field] === 'asc') {
+      fields[field] = 1;
+    } else if (fields[field] === 'descending' || fields[field] === 'desc') {
+      fields[field] = -1;
+    }
+  }
+
   this._indexes.push([fields, options]);
   return this;
 };

package/package.json

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

package/types/document.d.ts

@@ -135,6 +135,7 @@ declare module 'mongoose' {
     errors?: Error.ValidationError;
 
     /** Returns the value of a path. */
+    get<T extends keyof DocType>(path: T, type?: any, options?: any): DocType[T];
     get(path: string, type?: any, options?: any): any;
 
     /**
@@ -157,30 +158,37 @@ declare module 'mongoose' {
     init(obj: AnyObject, opts?: AnyObject): this;
 
     /** Marks a path as invalid, causing validation to fail. */
+    invalidate<T extends keyof DocType>(path: T, errorMsg: string | NativeError, value?: any, kind?: string): NativeError | null;
     invalidate(path: string, errorMsg: string | NativeError, value?: any, kind?: string): NativeError | null;
 
     /** Returns true if `path` was directly set and modified, else false. */
+    isDirectModified<T extends keyof DocType>(path: T | Array<T>): boolean;
     isDirectModified(path: string | Array<string>): boolean;
 
     /** Checks if `path` was explicitly selected. If no projection, always returns true. */
+    isDirectSelected<T extends keyof DocType>(path: T): boolean;
     isDirectSelected(path: string): boolean;
 
     /** Checks if `path` is in the `init` state, that is, it was set by `Document#init()` and not modified since. */
+    isInit<T extends keyof DocType>(path: T): boolean;
     isInit(path: string): boolean;
 
     /**
      * Returns true if any of the given paths are modified, else false. If no arguments, returns `true` if any path
      * in this document is modified.
      */
+    isModified<T extends keyof DocType>(path?: T | Array<T>): boolean;
     isModified(path?: string | Array<string>): boolean;
 
     /** Boolean flag specifying if the document is new. */
     isNew: boolean;
 
     /** Checks if `path` was selected in the source query which initialized this document. */
+    isSelected<T extends keyof DocType>(path: T): boolean;
     isSelected(path: string): boolean;
 
     /** Marks the path as having pending changes to write to the db. */
+    markModified<T extends keyof DocType>(path: T, scope?: any): void;
     markModified(path: string, scope?: any): void;
 
     /** Returns the list of paths that have been modified. */
@@ -216,6 +224,7 @@ declare module 'mongoose' {
     schema: Schema;
 
     /** Sets the value of a path, or many paths. */
+    set<T extends keyof DocType>(path: T, val: DocType[T], type: any, options?: DocumentSetOptions): this;
     set(path: string | Record<string, any>, val: any, type: any, options?: DocumentSetOptions): this;
     set(path: string | Record<string, any>, val: any, options?: DocumentSetOptions): this;
     set(value: string | Record<string, any>): this;
@@ -228,17 +237,20 @@ declare module 'mongoose' {
     toObject<T = Require_id<DocType>>(options?: ToObjectOptions): Require_id<T>;
 
     /** Clears the modified state on the specified path. */
+    unmarkModified<T extends keyof DocType>(path: T): void;
     unmarkModified(path: string): void;
 
     /** Sends an updateOne command with this document `_id` as the query selector. */
     updateOne(update?: UpdateQuery<this> | UpdateWithAggregationPipeline, options?: QueryOptions | null): Query<any, this>;
 
     /** Executes registered validation rules for this document. */
+    validate<T extends keyof DocType>(pathsToValidate?: T | T[], options?: AnyObject): Promise<void>;
     validate(pathsToValidate?: pathsToValidate, options?: AnyObject): Promise<void>;
     validate(options: { pathsToSkip?: pathsToSkip }): Promise<void>;
 
     /** Executes registered validation rules (skipping asynchronous validators) for this document. */
     validateSync(options: { pathsToSkip?: pathsToSkip, [k: string]: any }): Error.ValidationError | null;
+    validateSync<T extends keyof DocType>(pathsToValidate?: T | T[], options?: AnyObject): Error.ValidationError | null;
     validateSync(pathsToValidate?: pathsToValidate, options?: AnyObject): Error.ValidationError | null;
   }
 }

package/types/inferschematype.d.ts

@@ -30,7 +30,7 @@ declare module 'mongoose' {
      OptionalPaths<DocDefinition, TSchemaOptions['typeKey']>)]: ObtainDocumentPathType<DocDefinition[K], TSchemaOptions['typeKey']>;
    };
 
-  /**
+   /**
    * @summary Obtains document schema type from Schema instance.
    * @param {Schema} TSchema `typeof` a schema instance.
    * @example
@@ -39,7 +39,7 @@ declare module 'mongoose' {
    * // result
    * type UserType = {userName?: string}
    */
-  type InferSchemaType<TSchema> = IfAny<TSchema, any, ObtainSchemaGeneric<TSchema, 'DocType'>>;
+   export type InferSchemaType<TSchema> = IfAny<TSchema, any, ObtainSchemaGeneric<TSchema, 'DocType'>>;
 
   /**
    * @summary Obtains schema Generic type by using generic alias.

package/types/models.d.ts

@@ -557,6 +557,11 @@ declare module 'mongoose' {
       update: UpdateQuery<TRawDocType>,
       options: QueryOptions<TRawDocType> & { rawResult: true }
     ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate'>;
+    findByIdAndUpdate<ResultDoc = THydratedDocumentType>(
+      id: mongodb.ObjectId | any,
+      update: UpdateQuery<TRawDocType>,
+      options: QueryOptions<TRawDocType> & { includeResultMetadata: true }
+    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate'>;
     findByIdAndUpdate<ResultDoc = THydratedDocumentType>(
       id: mongodb.ObjectId | any,
       update: UpdateQuery<TRawDocType>,
@@ -611,6 +616,11 @@ declare module 'mongoose' {
       replacement: TRawDocType | AnyObject,
       options: QueryOptions<TRawDocType> & { rawResult: true }
     ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndReplace'>;
+    findOneAndReplace<ResultDoc = THydratedDocumentType>(
+      filter: FilterQuery<TRawDocType>,
+      replacement: TRawDocType | AnyObject,
+      options: QueryOptions<TRawDocType> & { includeResultMetadata: true }
+    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndReplace'>;
     findOneAndReplace<ResultDoc = THydratedDocumentType>(
       filter: FilterQuery<TRawDocType>,
       replacement: TRawDocType | AnyObject,
@@ -639,6 +649,11 @@ declare module 'mongoose' {
       update: UpdateQuery<TRawDocType>,
       options: QueryOptions<TRawDocType> & { rawResult: true }
     ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate'>;
+    findOneAndUpdate<ResultDoc = THydratedDocumentType>(
+      filter: FilterQuery<TRawDocType>,
+      update: UpdateQuery<TRawDocType>,
+      options: QueryOptions<TRawDocType> & { includeResultMetadata: true }
+    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate'>;
     findOneAndUpdate<ResultDoc = THydratedDocumentType>(
       filter: FilterQuery<TRawDocType>,
       update: UpdateQuery<TRawDocType>,