mongoose 6.6.2 → 6.6.3

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/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/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "6.6.2",
+  "version": "6.6.3",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -53,7 +53,7 @@
     "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",

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/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?: {

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