mongoose 7.2.4 → 7.3.0

package/lib/aggregate.js

@@ -1094,7 +1094,7 @@ Aggregate.prototype.then = function(resolve, reject) {
 };
 
 /**
- * Executes the query returning a `Promise` which will be
+ * Executes the aggregation returning a `Promise` which will be
  * resolved with either the doc(s) or rejected with the error.
  * Like [`.then()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.then), but only takes a rejection handler.
  * Compatible with `await`.
@@ -1108,6 +1108,21 @@ Aggregate.prototype.catch = function(reject) {
   return this.exec().then(null, reject);
 };
 
+/**
+ * Executes the aggregate returning a `Promise` which will be
+ * resolved with `.finally()` chained.
+ *
+ * More about [Promise `finally()` in JavaScript](https://thecodebarbarian.com/using-promise-finally-in-node-js.html).
+ *
+ * @param {Function} [onFinally]
+ * @return {Promise}
+ * @api public
+ */
+
+Aggregate.prototype.finally = function(onFinally) {
+  return this.exec().finally(onFinally);
+};
+
 /**
  * Returns an asyncIterator for use with [`for/await/of` loops](https://thecodebarbarian.com/getting-started-with-async-iterators-in-node-js)
  * You do not need to call this function explicitly, the JavaScript runtime

package/lib/helpers/populate/getModelsMapForPopulate.js

@@ -436,13 +436,13 @@ function _virtualPopulate(model, docs, options, _virtualRes) {
     data.justOne = justOne;
 
     // `match`
-    let match = get(options, 'match', null) ||
-      get(data, 'virtual.options.match', null) ||
+    const baseMatch = get(data, 'virtual.options.match', null) ||
       get(data, 'virtual.options.options.match', null);
+    let match = get(options, 'match', null) || baseMatch;
 
     let hasMatchFunction = typeof match === 'function';
     if (hasMatchFunction) {
-      match = match.call(doc, doc);
+      match = match.call(doc, doc, data.virtual);
     }
 
     if (Array.isArray(localField) && Array.isArray(foreignField) && localField.length === foreignField.length) {

package/lib/model.js

@@ -356,7 +356,7 @@ Model.prototype.$__handleSave = function(options, callback) {
     const optionsWithCustomValues = Object.assign({}, options, saveOptions);
     const where = this.$__where();
     const optimisticConcurrency = this.$__schema.options.optimisticConcurrency;
-    if (optimisticConcurrency) {
+    if (optimisticConcurrency && !Array.isArray(optimisticConcurrency)) {
       const key = this.$__schema.options.versionKey;
       const val = this.$__getValue(key);
       if (val != null) {
@@ -479,6 +479,7 @@ function generateVersionError(doc, modifiedPaths) {
  *     newProduct === product; // true
  *
  * @param {Object} [options] options optional options
+ * @param {Boolean} [options.ordered] saves the docs in series rather than parallel.
  * @param {Session} [options.session=null] the [session](https://www.mongodb.com/docs/manual/reference/server-sessions/) associated with this save operation. If not specified, defaults to the [document's associated session](https://mongoosejs.com/docs/api/document.html#Document.prototype.session()).
  * @param {Object} [options.safe] (DEPRECATED) overrides [schema's safe option](https://mongoosejs.com/docs/guide.html#safe). Use the `w` option instead.
  * @param {Boolean} [options.validateBeforeSave] set to false to save without validating.
@@ -717,7 +718,15 @@ Model.prototype.$__delta = function() {
 
   const optimisticConcurrency = this.$__schema.options.optimisticConcurrency;
   if (optimisticConcurrency) {
-    this.$__.version = dirty.length ? VERSION_ALL : VERSION_WHERE;
+    if (Array.isArray(optimisticConcurrency)) {
+      const optCon = new Set(optimisticConcurrency);
+      const modPaths = this.modifiedPaths();
+      if (modPaths.find(path => optCon.has(path))) {
+        this.$__.version = dirty.length ? VERSION_ALL : VERSION_WHERE;
+      }
+    } else {
+      this.$__.version = dirty.length ? VERSION_ALL : VERSION_WHERE;
+    }
   }
 
   if (!dirty.length && VERSION_ALL !== this.$__.version) {
@@ -2846,25 +2855,47 @@ Model.create = async function create(doc, options) {
   if (args.length === 0) {
     return Array.isArray(doc) ? [] : null;
   }
+  let res = [];
+  if (options.ordered) {
+    for (let i = 0; i < args.length; i++) {
+      const doc = args[i];
+      const Model = this.discriminators && doc[discriminatorKey] != null ?
+        this.discriminators[doc[discriminatorKey]] || getDiscriminatorByValue(this.discriminators, doc[discriminatorKey]) :
+        this;
+      if (Model == null) {
+        throw new MongooseError(`Discriminator "${doc[discriminatorKey]}" not ` +
+          `found for model "${this.modelName}"`);
+      }
+      let toSave = doc;
+      if (!(toSave instanceof Model)) {
+        toSave = new Model(toSave);
+      }
 
-  const res = await Promise.all(args.map(async doc => {
-    const Model = this.discriminators && doc[discriminatorKey] != null ?
-      this.discriminators[doc[discriminatorKey]] || getDiscriminatorByValue(this.discriminators, doc[discriminatorKey]) :
-      this;
-    if (Model == null) {
-      throw new MongooseError(`Discriminator "${doc[discriminatorKey]}" not ` +
-        `found for model "${this.modelName}"`);
+      await toSave.$save(options);
+      res.push(toSave);
     }
-    let toSave = doc;
+    return res;
+  } else {
+    res = await Promise.all(args.map(async doc => {
+      const Model = this.discriminators && doc[discriminatorKey] != null ?
+        this.discriminators[doc[discriminatorKey]] || getDiscriminatorByValue(this.discriminators, doc[discriminatorKey]) :
+        this;
+      if (Model == null) {
+        throw new MongooseError(`Discriminator "${doc[discriminatorKey]}" not ` +
+          `found for model "${this.modelName}"`);
+      }
+      let toSave = doc;
 
-    if (!(toSave instanceof Model)) {
-      toSave = new Model(toSave);
-    }
+      if (!(toSave instanceof Model)) {
+        toSave = new Model(toSave);
+      }
+
+      await toSave.$save(options);
 
-    await toSave.$save(options);
+      return toSave;
+    }));
+  }
 
-    return toSave;
-  }));
 
   if (!Array.isArray(doc) && args.length === 1) {
     return res[0];

package/lib/schema/SubdocumentPath.js

@@ -347,6 +347,18 @@ SubdocumentPath.defaultOptions = {};
 
 SubdocumentPath.set = SchemaType.set;
 
+/**
+ * Attaches a getter for all SubdocumentPath instances
+ *
+ * @param {Function} getter
+ * @return {this}
+ * @function get
+ * @static
+ * @api public
+ */
+
+SubdocumentPath.get = SchemaType.get;
+
 /*!
  * ignore
  */

package/lib/schema/array.js

@@ -170,6 +170,18 @@ SchemaArray.defaultOptions = {};
  */
 SchemaArray.set = SchemaType.set;
 
+/**
+ * Attaches a getter for all Array instances
+ *
+ * @param {Function} getter
+ * @return {this}
+ * @function get
+ * @static
+ * @api public
+ */
+
+SchemaArray.get = SchemaType.get;
+
 /*!
  * Inherits from SchemaType.
  */

package/lib/schema/bigint.js

@@ -62,6 +62,23 @@ SchemaBigInt._cast = castBigInt;
 
 SchemaBigInt.set = SchemaType.set;
 
+/**
+ * Attaches a getter for all BigInt instances
+ *
+ * #### Example:
+ *
+ *     // Convert bigints to numbers
+ *     mongoose.Schema.BigInt.get(v => v == null ? v : Number(v));
+ *
+ * @param {Function} getter
+ * @return {this}
+ * @function get
+ * @static
+ * @api public
+ */
+
+SchemaBigInt.get = SchemaType.get;
+
 /**
  * Get/set the function used to cast arbitrary values to booleans.
  *

package/lib/schema/boolean.js

@@ -65,6 +65,25 @@ SchemaBoolean._cast = castBoolean;
 
 SchemaBoolean.set = SchemaType.set;
 
+/**
+ * Attaches a getter for all Boolean instances
+ *
+ * #### Example:
+ *
+ *     mongoose.Schema.Boolean.get(v => v === true ? 'yes' : 'no');
+ *
+ *     const Order = mongoose.model('Order', new Schema({ isPaid: Boolean }));
+ *     new Order({ isPaid: false }).isPaid; // 'no'
+ *
+ * @param {Function} getter
+ * @return {this}
+ * @function get
+ * @static
+ * @api public
+ */
+
+SchemaBoolean.get = SchemaType.get;
+
 /**
  * Get/set the function used to cast arbitrary values to booleans.
  *

package/lib/schema/buffer.js

@@ -70,6 +70,26 @@ SchemaBuffer._checkRequired = v => !!(v && v.length);
 
 SchemaBuffer.set = SchemaType.set;
 
+/**
+ * Attaches a getter for all Buffer instances
+ *
+ * #### Example:
+ *
+ *     // Always convert to string when getting an ObjectId
+ *     mongoose.Schema.Types.Buffer.get(v => v.toString('hex'));
+ *
+ *     const Model = mongoose.model('Test', new Schema({ buf: Buffer } }));
+ *     typeof (new Model({ buf: Buffer.fromString('hello') }).buf); // 'string'
+ *
+ * @param {Function} getter
+ * @return {this}
+ * @function get
+ * @static
+ * @api public
+ */
+
+SchemaBuffer.get = SchemaType.get;
+
 /**
  * Override the function the required validator uses to check whether a string
  * passes the `required` check.

package/lib/schema/date.js

@@ -70,6 +70,26 @@ SchemaDate._cast = castDate;
 
 SchemaDate.set = SchemaType.set;
 
+/**
+ * Attaches a getter for all Date instances
+ *
+ * #### Example:
+ *
+ *     // Always convert Dates to string
+ *     mongoose.Date.get(v => v.toString());
+ *
+ *     const Model = mongoose.model('Test', new Schema({ date: { type: Date, default: () => new Date() } }));
+ *     typeof (new Model({}).date); // 'string'
+ *
+ * @param {Function} getter
+ * @return {this}
+ * @function get
+ * @static
+ * @api public
+ */
+
+SchemaDate.get = SchemaType.get;
+
 /**
  * Get/set the function used to cast arbitrary values to dates.
  *

package/lib/schema/decimal128.js

@@ -66,6 +66,23 @@ Decimal128._cast = castDecimal128;
 
 Decimal128.set = SchemaType.set;
 
+/**
+ * Attaches a getter for all Decimal128 instances
+ *
+ * #### Example:
+ *
+ *     // Automatically convert Decimal128s to Numbers
+ *     mongoose.Schema.Decimal128.get(v => v == null ? v : Number(v));
+ *
+ * @param {Function} getter
+ * @return {this}
+ * @function get
+ * @static
+ * @api public
+ */
+
+Decimal128.get = SchemaType.get;
+
 /**
  * Get/set the function used to cast arbitrary values to decimals.
  *

package/lib/schema/documentarray.js

@@ -37,7 +37,7 @@ let Subdocument;
  */
 
 function DocumentArrayPath(key, schema, options, schemaOptions) {
-  if (schema.options.timeseries) {
+  if (schema.options && schema.options.timeseries) {
     throw new InvalidSchemaOptionError(key, 'timeseries');
   }
   const schemaTypeIdOption = DocumentArrayPath.defaultOptions &&
@@ -605,6 +605,18 @@ DocumentArrayPath.defaultOptions = {};
 
 DocumentArrayPath.set = SchemaType.set;
 
+/**
+ * Attaches a getter for all DocumentArrayPath instances
+ *
+ * @param {Function} getter
+ * @return {this}
+ * @function get
+ * @static
+ * @api public
+ */
+
+DocumentArrayPath.get = SchemaType.get;
+
 /*!
  * Module exports.
  */

package/lib/schema/uuid.js

@@ -153,6 +153,26 @@ SchemaUUID._cast = function(value) {
   throw new CastError(SchemaUUID.schemaName, value, this.path);
 };
 
+/**
+ * Attaches a getter for all UUID instances.
+ *
+ * #### Example:
+ *
+ *     // Note that `v` is a string by default
+ *     mongoose.Schema.UUID.get(v => v.toUpperCase());
+ *
+ *     const Model = mongoose.model('Test', new Schema({ test: 'UUID' }));
+ *     new Model({ test: uuid.v4() }).test; // UUID with all uppercase
+ *
+ * @param {Function} getter
+ * @return {this}
+ * @function get
+ * @static
+ * @api public
+ */
+
+SchemaUUID.get = SchemaType.get;
+
 /**
  * Sets a default option for all UUID instances.
  *

package/lib/schema.js

@@ -70,6 +70,7 @@ let id = 0;
  * - [toObject](https://mongoosejs.com/docs/guide.html#toObject) - object - no default
  * - [typeKey](https://mongoosejs.com/docs/guide.html#typeKey) - string - defaults to 'type'
  * - [validateBeforeSave](https://mongoosejs.com/docs/guide.html#validateBeforeSave) - bool - defaults to `true`
+ * - [validateModifiedOnly](https://mongoosejs.com/docs/api/document.html#Document.prototype.validate()) - bool - defaults to `false`
  * - [versionKey](https://mongoosejs.com/docs/guide.html#versionKey): string or object - defaults to "__v"
  * - [optimisticConcurrency](https://mongoosejs.com/docs/guide.html#optimisticConcurrency): bool - defaults to false. Set to true to enable [optimistic concurrency](https://thecodebarbarian.com/whats-new-in-mongoose-5-10-optimistic-concurrency.html).
  * - [collation](https://mongoosejs.com/docs/guide.html#collation): object - defaults to null (which means use no collation)
@@ -549,6 +550,7 @@ Schema.prototype.defaultOptions = function(options) {
     shardKey: null,
     read: null,
     validateBeforeSave: true,
+    validateModifiedOnly: false,
     // the following are only applied at construction time
     _id: true,
     id: id,
@@ -2192,6 +2194,7 @@ Schema.prototype.indexes = function() {
  * @param {Boolean|Function} [options.justOne=false] Only works with populate virtuals. If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), will be a single doc or `null`. Otherwise, the populate virtual will be an array.
  * @param {Boolean} [options.count=false] Only works with populate virtuals. If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), this populate virtual will contain the number of documents rather than the documents themselves when you `populate()`.
  * @param {Function|null} [options.get=null] Adds a [getter](https://mongoosejs.com/docs/tutorials/getters-setters.html) to this virtual to transform the populated doc.
+ * @param {Object|Function} [options.match=null] Apply a default [`match` option to populate](https://mongoosejs.com/docs/populate.html#match), adding an additional filter to the populate query.
  * @return {VirtualType}
  */
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "7.2.4",
+  "version": "7.3.0",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -21,7 +21,7 @@
   "dependencies": {
     "bson": "^5.3.0",
     "kareem": "2.5.1",
-    "mongodb": "5.5.0",
+    "mongodb": "5.6.0",
     "mpath": "0.9.0",
     "mquery": "5.0.0",
     "ms": "2.1.3",

package/types/aggregate.d.ts

@@ -16,6 +16,9 @@ declare module 'mongoose' {
      */
     [Symbol.asyncIterator](): AsyncIterableIterator<Unpacked<ResultType>>;
 
+    // Returns a string representation of this aggregation.
+    [Symbol.toStringTag]: string;
+
     options: AggregateOptions;
 
     /**
@@ -73,6 +76,12 @@ declare module 'mongoose' {
     /** Appends a new $fill operator to this aggregate pipeline */
     fill(arg: PipelineStage.Fill['$fill']): this;
 
+    /**
+     * Executes the aggregation returning a `Promise` which will be
+     * resolved with `.finally()` chained.
+     */
+    finally: Promise<ResultType>['finally'];
+
     /** Appends new custom $graphLookup operator(s) to this aggregate pipeline, performing a recursive search on a collection. */
     graphLookup(options: PipelineStage.GraphLookup['$graphLookup']): this;
 

package/types/index.d.ts

@@ -512,7 +512,7 @@ declare module 'mongoose' {
     count?: boolean;
 
     /** Add an extra match condition to `populate()`. */
-    match?: FilterQuery<any> | Function;
+    match?: FilterQuery<any> | ((doc: Record<string, any>, virtual?: this) => Record<string, any> | null);
 
     /** Add a default `limit` to the `populate()` query. */
     limit?: number;

package/types/models.d.ts

@@ -123,6 +123,7 @@ declare module 'mongoose' {
     SessionOption {
     checkKeys?: boolean;
     j?: boolean;
+    ordered?: boolean;
     safe?: boolean | WriteConcern;
     timestamps?: boolean | QueryTimestampsConfig;
     validateBeforeSave?: boolean;

package/types/query.d.ts

@@ -622,7 +622,31 @@ declare module 'mongoose' {
     ): QueryWithHelpers<any, DocType, THelpers, RawDocType, 'replaceOne'>;
 
     /** Specifies which document fields to include or exclude (also known as the query "projection") */
-    select(arg: string | string[] | Record<string, number | boolean | object>): this;
+    select<RawDocTypeOverride extends { [P in keyof RawDocType]?: any } = {}>(
+      arg: string | string[] | Record<string, number | boolean | object>
+    ): QueryWithHelpers<
+      IfEquals<
+        RawDocTypeOverride,
+        {},
+        ResultType,
+        ResultType extends any[] ?
+          ResultType extends HydratedDocument<any>[] ?
+            HydratedDocument<RawDocTypeOverride>[] :
+            RawDocTypeOverride[] :
+          ResultType extends HydratedDocument<any> ?
+            HydratedDocument<RawDocTypeOverride> :
+            RawDocTypeOverride
+      >,
+      DocType,
+      THelpers,
+      IfEquals<
+        RawDocTypeOverride,
+        {},
+        RawDocType,
+        RawDocTypeOverride
+      >,
+      QueryOp
+    >;
 
     /** Determines if field selection has been made. */
     selected(): boolean;

package/types/schemaoptions.d.ts

@@ -154,6 +154,11 @@ declare module 'mongoose' {
      * objects which don't pass validation, you can set validateBeforeSave to false.
      */
     validateBeforeSave?: boolean;
+    /**
+     * By default, validation will run on modified and required paths before saving to the database.
+     * You can choose to have Mongoose only validate modified paths by setting validateModifiedOnly to true.
+     */
+    validateModifiedOnly?: boolean;
     /**
      * The versionKey is a property set on each document when first created by Mongoose. This keys value
      * contains the internal revision of the document. The versionKey option is a string that represents