mongoose 6.6.2 → 6.6.4

package/.mocharc.yml

@@ -1,2 +1,4 @@
 reporter: spec # better to identify failing / slow tests than "dot"
 ui: bdd # explicitly setting, even though it is mocha default
+require:
+  - test/mocha-fixtures.js

package/lib/helpers/discriminator/mergeDiscriminatorSchema.js

@@ -0,0 +1,63 @@
+'use strict';
+const schemaMerge = require('../schema/merge');
+const specialProperties = require('../../helpers/specialProperties');
+const isBsonType = require('../../helpers/isBsonType');
+const ObjectId = require('../../types/objectid');
+const isObject = require('../../helpers/isObject');
+/**
+ * Merges `from` into `to` without overwriting existing properties.
+ *
+ * @param {Object} to
+ * @param {Object} from
+ * @param {String} [path]
+ * @api private
+ */
+
+module.exports = function mergeDiscriminatorSchema(to, from, path) {
+  const keys = Object.keys(from);
+  let i = 0;
+  const len = keys.length;
+  let key;
+
+  path = path || '';
+
+  while (i < len) {
+    key = keys[i++];
+    if (key === 'discriminators' || key === 'base' || key === '_applyDiscriminators') {
+      continue;
+    }
+    if (path === 'tree' && from != null && from.instanceOfSchema) {
+      continue;
+    }
+    if (specialProperties.has(key)) {
+      continue;
+    }
+    if (to[key] == null) {
+      to[key] = from[key];
+    } else if (isObject(from[key])) {
+      if (!isObject(to[key])) {
+        to[key] = {};
+      }
+      if (from[key] != null) {
+        // Skip merging schemas if we're creating a discriminator schema and
+        // base schema has a given path as a single nested but discriminator schema
+        // has the path as a document array, or vice versa (gh-9534)
+        if ((from[key].$isSingleNested && to[key].$isMongooseDocumentArray) ||
+              (from[key].$isMongooseDocumentArray && to[key].$isSingleNested)) {
+          continue;
+        } else if (from[key].instanceOfSchema) {
+          if (to[key].instanceOfSchema) {
+            schemaMerge(to[key], from[key].clone(), true);
+          } else {
+            to[key] = from[key].clone();
+          }
+          continue;
+        } else if (isBsonType(from[key], 'ObjectID')) {
+          to[key] = new ObjectId(from[key]);
+          continue;
+        }
+      }
+      mergeDiscriminatorSchema(to[key], from[key], path ? path + '.' + key : key);
+    }
+  }
+};

package/lib/helpers/model/discriminator.js

@@ -4,6 +4,7 @@ const Mixed = require('../../schema/mixed');
 const defineKey = require('../document/compile').defineKey;
 const get = require('../get');
 const utils = require('../../utils');
+const mergeDiscriminatorSchema = require('../../helpers/discriminator/mergeDiscriminatorSchema');
 
 const CUSTOMIZABLE_DISCRIMINATOR_OPTIONS = {
   toJSON: true,
@@ -108,8 +109,7 @@ module.exports = function discriminator(model, name, schema, tiedValue, applyPlu
       }
     }
 
-    utils.merge(schema, baseSchema, {
-      isDiscriminatorSchemaMerge: true,
+    mergeDiscriminatorSchema(schema, baseSchema, {
       omit: { discriminators: true, base: true, _applyDiscriminators: true },
       omitNested: conflictingPaths.reduce((cur, path) => {
         cur['tree.' + path] = true;

package/lib/helpers/projection/isPathExcluded.js

@@ -12,6 +12,10 @@ const isDefiningProjection = require('./isDefiningProjection');
  */
 
 module.exports = function isPathExcluded(projection, path) {
+  if (projection == null) {
+    return false;
+  }
+
   if (path === '_id') {
     return projection._id === 0;
   }

package/lib/helpers/timestamps/setupTimestamps.js

@@ -27,16 +27,16 @@ module.exports = function setupTimestamps(schema, timestamps) {
 
   schema.$timestamps = { createdAt: createdAt, updatedAt: updatedAt };
 
-  if (updatedAt && !schema.paths[updatedAt]) {
-    schemaAdditions[updatedAt] = Date;
-  }
-
   if (createdAt && !schema.paths[createdAt]) {
     const baseImmutableCreatedAt = schema.base.get('timestamps.createdAt.immutable');
     const immutable = baseImmutableCreatedAt != null ? baseImmutableCreatedAt : true;
     schemaAdditions[createdAt] = { [schema.options.typeKey || 'type']: Date, immutable };
   }
 
+  if (updatedAt && !schema.paths[updatedAt]) {
+    schemaAdditions[updatedAt] = Date;
+  }
+
   schema.add(schemaAdditions);
 
   schema.pre('save', function timestampsPreSave(next) {

package/lib/model.js

@@ -51,11 +51,13 @@ const {
   getRelatedDBIndexes,
   getRelatedSchemaIndexes
 } = require('./helpers/indexes/getRelatedIndexes');
+const isPathExcluded = require('./helpers/projection/isPathExcluded');
 const decorateDiscriminatorIndexOptions = require('./helpers/indexes/decorateDiscriminatorIndexOptions');
 const isPathSelectedInclusive = require('./helpers/projection/isPathSelectedInclusive');
 const leanPopulateMap = require('./helpers/populate/leanPopulateMap');
 const modifiedPaths = require('./helpers/update/modifiedPaths');
 const parallelLimit = require('./helpers/parallelLimit');
+const parentPaths = require('./helpers/path/parentPaths');
 const prepareDiscriminatorPipeline = require('./helpers/aggregate/prepareDiscriminatorPipeline');
 const pushNestedArrayPaths = require('./helpers/model/pushNestedArrayPaths');
 const removeDeselectedForeignField = require('./helpers/populate/removeDeselectedForeignField');
@@ -760,6 +762,19 @@ Model.prototype.$__delta = function() {
       }
     }
 
+    // If this path is set to default, and either this path or one of
+    // its parents is excluded, don't treat this path as dirty.
+    if (this.$isDefault(data.path) && this.$__.selected) {
+      if (data.path.indexOf('.') === -1 && isPathExcluded(this.$__.selected, data.path)) {
+        continue;
+      }
+
+      const pathsToCheck = parentPaths(data.path);
+      if (pathsToCheck.find(path => isPathExcluded(this.$__.isSelected, path))) {
+        continue;
+      }
+    }
+
     if (divergent.length) continue;
     if (value === undefined) {
       operand(this, where, delta, data, 1, '$unset');
@@ -798,6 +813,11 @@ Model.prototype.$__delta = function() {
   if (this.$__.version) {
     this.$__version(where, delta);
   }
+
+  if (Object.keys(delta).length === 0) {
+    return [where, null];
+  }
+
   return [where, delta];
 };
 
@@ -1196,7 +1216,6 @@ Model.exists = function exists(filter, options, callback) {
  */
 
 Model.discriminator = function(name, schema, options) {
-
   let model;
   if (typeof name === 'function') {
     model = name;

package/lib/query.js

@@ -2402,6 +2402,10 @@ Query.prototype.merge = function(source) {
 
     utils.merge(this._mongooseOptions, source._mongooseOptions);
 
+    return this;
+  } else if (this.model != null && source instanceof this.model.base.Types.ObjectId) {
+    utils.merge(this._conditions, { _id: source }, opts);
+
     return this;
   }
 
@@ -2951,11 +2955,14 @@ Query.prototype.distinct = function(field, conditions, callback) {
  *     // equivalent
  *     query.sort('field -test');
  *
+ *     // also possible is to use a array with array key-value pairs
+ *     query.sort([['field', 'asc']]);
+ *
  * #### Note:
  *
  * Cannot be used with `distinct()`
  *
- * @param {Object|String} arg
+ * @param {Object|String|Array<Array<(string | number)>>} arg
  * @return {Query} this
  * @see cursor.sort https://docs.mongodb.org/manual/reference/method/cursor.sort/
  * @api public

package/lib/schema.js

@@ -502,25 +502,21 @@ Schema.prototype.defaultOptions = function(options) {
  *
  * #### Example:
  *
- *     const options = { discriminatorKey: 'kind' };
+ *     const eventSchema = new mongoose.Schema({ timestamp: Date }, { discriminatorKey: 'kind' });
+ *
+ *     const clickedEventSchema = new mongoose.Schema({ element: String }, { discriminatorKey: 'kind' });
+ *     const ClickedModel = eventSchema.discriminator('clicked', clickedEventSchema);
  *
- *     const eventSchema = new mongoose.Schema({ time: Date }, options);
  *     const Event = mongoose.model('Event', eventSchema);
  *
- *     // ClickedLinkEvent is a special type of Event that has
- *     // a URL.
- *     const ClickedLinkEvent = Event.discriminator('ClickedLink',
- *     new mongoose.Schema({ url: String }, options));
+ *     Event.discriminators['clicked']; // Model { clicked }
  *
- *     // When you create a generic event, it can't have a URL field...
- *     const genericEvent = new Event({ time: Date.now(), url: 'google.com' });
- *     assert.ok(!genericEvent.url);
- *     // But a ClickedLinkEvent can
- *     const clickedEvent = new ClickedLinkEvent({ time: Date.now(), url: 'google.com' });
- *     assert.ok(clickedEvent.url);
+ *     const doc = await Event.create({ kind: 'clicked', element: '#hero' });
+ *     doc.element; // '#hero'
+ *     doc instanceof ClickedModel; // true
  *
  * @param {String} name the name of the discriminator
- * @param {Schema} schema the Schema of the discriminated Schema
+ * @param {Schema} schema the discriminated Schema
  * @return {Schema} the Schema instance
  * @api public
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "6.6.2",
+  "version": "6.6.4",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -28,9 +28,9 @@
     "sift": "16.0.0"
   },
   "devDependencies": {
-    "@babel/core": "7.19.0",
-    "@typescript-eslint/eslint-plugin": "5.36.2",
-    "@typescript-eslint/parser": "5.36.2",
+    "@babel/core": "7.19.3",
+    "@typescript-eslint/eslint-plugin": "5.38.1",
+    "@typescript-eslint/parser": "5.38.1",
     "acquit": "1.2.1",
     "acquit-ignore": "0.2.0",
     "acquit-require": "0.1.1",
@@ -43,17 +43,17 @@
     "cheerio": "1.0.0-rc.12",
     "crypto-browserify": "3.12.0",
     "dox": "1.0.0",
-    "eslint": "8.23.0",
+    "eslint": "8.24.0",
     "eslint-plugin-mocha-no-only": "1.1.1",
     "express": "^4.18.1",
     "highlight.js": "11.6.0",
     "lodash.isequal": "4.5.0",
     "lodash.isequalwith": "4.4.0",
-    "marked": "4.1.0",
+    "marked": "4.1.1",
     "mkdirp": "^1.0.4",
     "mocha": "10.0.0",
     "moment": "2.x",
-    "mongodb-memory-server": "8.9.1",
+    "mongodb-memory-server": "8.9.3",
     "ncp": "^2.0.0",
     "nyc": "15.1.0",
     "pug": "3.0.2",
@@ -61,8 +61,8 @@
     "sinon": "14.0.0",
     "stream-browserify": "3.0.0",
     "ts-benchmark": "^1.1.10",
-    "tsd": "0.23.0",
-    "typescript": "4.8.3",
+    "tsd": "0.24.1",
+    "typescript": "4.8.4",
     "uuid": "9.0.0",
     "webpack": "5.74.0"
   },

package/types/index.d.ts

@@ -162,19 +162,20 @@ declare module 'mongoose' {
       : M
     : M;
 
-  export type DiscriminatorSchema<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals, T> = T extends Schema<infer T1, infer T2, infer T3, infer T4, infer T5>
-    ? Schema<Omit<DocType, keyof T1> & T1, DiscriminatorModel<T2, M>, T3 | TInstanceMethods, T4 | TQueryHelpers, T5 | TVirtuals>
-    : Schema<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals>;
+  export type DiscriminatorSchema<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals, TStaticMethods, DisSchema> =
+    DisSchema extends Schema<infer DisSchemaEDocType, infer DisSchemaM, infer DisSchemaInstanceMethods, infer DisSchemaQueryhelpers, infer DisSchemaVirtuals, infer DisSchemaStatics>
+      ? Schema<Omit<DocType, keyof DisSchemaEDocType> & DisSchemaEDocType, DiscriminatorModel<DisSchemaM, M>, DisSchemaInstanceMethods | TInstanceMethods, DisSchemaQueryhelpers | TQueryHelpers, DisSchemaVirtuals | TVirtuals, DisSchemaStatics & TStaticMethods>
+      : Schema<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals, TStaticMethods>;
 
   type QueryResultType<T> = T extends Query<infer ResultType, any> ? ResultType : never;
 
   type PluginFunction<
     DocType,
-    M = Model<DocType, any, any, any>,
-    TInstanceMethods = {},
-    TQueryHelpers = {},
-    TVirtuals = {},
-    TStaticMethods = {}> = (schema: Schema<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals, TStaticMethods>, opts?: any) => void;
+    M,
+    TInstanceMethods,
+    TQueryHelpers,
+    TVirtuals,
+    TStaticMethods> = (schema: Schema<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals, TStaticMethods>, opts?: any) => void;
 
   export class Schema<
     EnforcedDocType = any,
@@ -207,7 +208,7 @@ declare module 'mongoose' {
     /** Returns a copy of this schema */
     clone<T = this>(): T;
 
-    discriminator<T = Schema>(name: string, schema: T): DiscriminatorSchema<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals, T>;
+    discriminator<DisSchema = Schema>(name: string, schema: DisSchema): DiscriminatorSchema<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals, TStaticMethods, DisSchema>;
 
     /** Returns a new schema that has the picked `paths` from this schema. */
     pick<T = this>(paths: string[], options?: SchemaOptions): T;
@@ -263,7 +264,7 @@ declare module 'mongoose' {
     pathType(path: string): string;
 
     /** Registers a plugin for this schema. */
-    plugin<PFunc extends PluginFunction<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals, TStaticMethods>, POptions extends Parameters<PFunc>[1] = Parameters<PFunc>[1]>(fn: PFunc, opts?: POptions): this;
+    plugin<PFunc extends PluginFunction<DocType, M, any, any, any, any>, POptions extends Parameters<PFunc>[1] = Parameters<PFunc>[1]>(fn: PFunc, opts?: POptions): this;
 
     /** Defines a post hook for the model. */
     post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: PostMiddlewareFunction<T, T>): this;

package/types/models.d.ts

@@ -146,9 +146,9 @@ declare module 'mongoose' {
      * if you use `create()`) because with `bulkWrite()` there is only one network
      * round trip to the MongoDB server.
      */
-    bulkWrite(writes: Array<mongodb.AnyBulkWriteOperation<T extends {} ? T : any>>, options: mongodb.BulkWriteOptions & MongooseBulkWriteOptions, callback: Callback<mongodb.BulkWriteResult>): void;
-    bulkWrite(writes: Array<mongodb.AnyBulkWriteOperation<T extends {} ? T : any>>, callback: Callback<mongodb.BulkWriteResult>): void;
-    bulkWrite(writes: Array<mongodb.AnyBulkWriteOperation<T extends {} ? T : any>>, options?: mongodb.BulkWriteOptions & MongooseBulkWriteOptions): Promise<mongodb.BulkWriteResult>;
+    bulkWrite(writes: Array<mongodb.AnyBulkWriteOperation<T extends Document ? any : (T extends {} ? T : any)>>, options: mongodb.BulkWriteOptions & MongooseBulkWriteOptions, callback: Callback<mongodb.BulkWriteResult>): void;
+    bulkWrite(writes: Array<mongodb.AnyBulkWriteOperation<T extends Document ? any : (T extends {} ? T : any)>>, callback: Callback<mongodb.BulkWriteResult>): void;
+    bulkWrite(writes: Array<mongodb.AnyBulkWriteOperation<T extends Document ? any : (T extends {} ? T : any)>>, options?: mongodb.BulkWriteOptions & MongooseBulkWriteOptions): Promise<mongodb.BulkWriteResult>;
 
     /**
      * Sends multiple `save()` calls in a single `bulkWrite()`. This is faster than

package/types/query.d.ts

@@ -601,7 +601,7 @@ declare module 'mongoose' {
     snapshot(val?: boolean): this;
 
     /** Sets the sort order. If an object is passed, values allowed are `asc`, `desc`, `ascending`, `descending`, `1`, and `-1`. */
-    sort(arg?: string | { [key: string]: SortOrder | { $meta: 'textScore' } } | undefined | null): this;
+    sort(arg?: string | { [key: string]: SortOrder | { $meta: 'textScore' } } | [string, SortOrder][] | undefined | null): this;
 
     /** Sets the tailable option (for use with capped collections). */
     tailable(bool?: boolean, opts?: {
@@ -616,7 +616,7 @@ declare module 'mongoose' {
     then: Promise<ResultType>['then'];
 
     /** Converts this query to a customized, reusable query constructor with all arguments and options retained. */
-    toConstructor(): typeof this;
+    toConstructor(): typeof Query<ResultType, DocType, THelpers, RawDocType>;
 
     /** Declare and/or execute this query as an update() operation. */
     update(filter?: FilterQuery<DocType>, update?: UpdateQuery<DocType> | UpdateWithAggregationPipeline, options?: QueryOptions<DocType> | null, callback?: Callback<UpdateWriteOpResult>): QueryWithHelpers<UpdateWriteOpResult, DocType, THelpers, RawDocType>;

package/types/schemaoptions.d.ts

@@ -201,7 +201,7 @@ declare module 'mongoose' {
     /**
      * Query helper functions.
      */
-    query?: Record<any, <T extends QueryWithHelpers<unknown, DocType>>(this: T, ...args: any) => T> | QueryHelpers,
+    query?: Record<any, <T extends QueryWithHelpers<unknown, HydratedDocument<DocType>>>(this: T, ...args: any) => T> | QueryHelpers,
 
     /**
      * Set whether to cast non-array values to arrays.

package/types/schematypes.d.ts

@@ -100,7 +100,7 @@ declare module 'mongoose' {
      * If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose will
      * build an index on this path when the model is compiled.
      */
-    index?: boolean | number | IndexOptions | '2d' | '2dsphere' | 'hashed' | 'text';
+    index?: boolean | IndexDirection;
 
     /**
      * If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose