mongoose 6.3.5 → 6.3.6

package/lgtm.yml

@@ -0,0 +1,12 @@
+path_classifiers:
+  src:
+    - lib
+  types:
+    - types
+  test:
+    - test
+  docs:
+    - docs
+queries:
+  - exclude: "*"
+  - include: lib

package/lib/connection.js

@@ -7,13 +7,13 @@
 const ChangeStream = require('./cursor/ChangeStream');
 const EventEmitter = require('events').EventEmitter;
 const Schema = require('./schema');
-const Collection = require('./driver').get().Collection;
 const STATES = require('./connectionstate');
 const MongooseError = require('./error/index');
 const SyncIndexesError = require('./error/syncIndexes');
 const PromiseProvider = require('./promise_provider');
 const ServerSelectionError = require('./error/serverSelection');
 const applyPlugins = require('./helpers/schema/applyPlugins');
+const driver = require('./driver');
 const promiseOrCallback = require('./helpers/promiseOrCallback');
 const get = require('./helpers/get');
 const immediate = require('./helpers/immediate');
@@ -1026,6 +1026,7 @@ Connection.prototype.collection = function(name, options) {
   };
   options = Object.assign({}, defaultOptions, options ? utils.clone(options) : {});
   options.$wasForceClosed = this.$wasForceClosed;
+  const Collection = driver.get().Collection;
   if (!(name in this.collections)) {
     this.collections[name] = new Collection(name, this, options);
   }

package/lib/document.js

@@ -3474,8 +3474,8 @@ Document.prototype.$toObject = function(options, json) {
   defaultOptions = utils.options(defaultOptions, clone(schemaOptions[path] || {}));
 
   // If options do not exist or is not an object, set it to empty object
-  options = utils.isPOJO(options) ? clone(options) : {};
-  options._calledWithOptions = options._calledWithOptions || clone(options);
+  options = utils.isPOJO(options) ? { ...options } : {};
+  options._calledWithOptions = options._calledWithOptions || { ...options };
 
   let _minimize;
   if (options._calledWithOptions.minimize != null) {
@@ -3499,7 +3499,7 @@ Document.prototype.$toObject = function(options, json) {
   // `clone()` will recursively call `$toObject()` on embedded docs, so we
   // need the original options the user passed in, plus `_isNested` and
   // `_parentOptions` for checking whether we need to depopulate.
-  const cloneOptions = Object.assign(utils.clone(options), {
+  const cloneOptions = Object.assign({}, options, {
     _isNested: true,
     json: json,
     minimize: _minimize,
@@ -4227,8 +4227,10 @@ Document.prototype.populate = function populate() {
  * @api public
  * @return {Array<Document>} array of populated documents. Empty array if there are no populated documents associated with this document.
  * @memberOf Document
+ * @method $getPopulatedDocs
  * @instance
  */
+
 Document.prototype.$getPopulatedDocs = function $getPopulatedDocs() {
   let keys = [];
   if (this.$__.populated != null) {

package/lib/helpers/update/applyTimestampsToChildren.js

@@ -61,6 +61,8 @@ function applyTimestampsToChildren(now, update, schema) {
             if (createdAt != null) {
               subdoc[createdAt] = now;
             }
+
+            applyTimestampsToChildren(now, subdoc, $path.schema);
           });
         } else {
           if (updatedAt != null) {
@@ -69,6 +71,8 @@ function applyTimestampsToChildren(now, update, schema) {
           if (createdAt != null) {
             op[key][createdAt] = now;
           }
+
+          applyTimestampsToChildren(now, op[key], $path.schema);
         }
       }
     }

package/lib/index.js

@@ -154,7 +154,7 @@ Mongoose.prototype.driver = driver;
  *     mongoose.set('debug', function(collectionName, methodName, ...methodArgs) {}); // use custom function to log collection methods + arguments
  *
  * Currently supported options are:
- * - 'debug': If `true`, prints the operations mongoose sends to MongoDB to the console. If a writable stream is passed, it will log to that stream, without colorization. If a callback function is passed, it will receive the collection name, the method name, then all arugments passed to the method. For example, if you wanted to replicate the default logging, you could output from the callback `Mongoose: ${collectionName}.${methodName}(${methodArgs.join(', ')})`.
+ * - 'debug': If `true`, prints the operations mongoose sends to MongoDB to the console. If a writable stream is passed, it will log to that stream, without colorization. If a callback function is passed, it will receive the collection name, the method name, then all arguments passed to the method. For example, if you wanted to replicate the default logging, you could output from the callback `Mongoose: ${collectionName}.${methodName}(${methodArgs.join(', ')})`.
  * - 'returnOriginal': If `false`, changes the default `returnOriginal` option to `findOneAndUpdate()`, `findByIdAndUpdate`, and `findOneAndReplace()` to false. This is equivalent to setting the `new` option to `true` for `findOneAndX()` calls by default. Read our [`findOneAndUpdate()` tutorial](/docs/tutorials/findoneandupdate.html) for more information.
  * - 'bufferCommands': enable/disable mongoose's buffering mechanism for all connections and models
  * - 'cloneSchemas': false by default. Set to `true` to `clone()` all schemas before compiling into a model.
@@ -275,6 +275,7 @@ Mongoose.prototype.get = Mongoose.prototype.set;
 Mongoose.prototype.createConnection = function(uri, options, callback) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
+  const Connection = driver.get().getConnection();
   const conn = new Connection(_mongoose);
   if (typeof options === 'function') {
     callback = options;

package/lib/query.js

@@ -124,7 +124,10 @@ function Query(conditions, options, model, collection) {
   }
 
   // inherit mquery
-  mquery.call(this, this.mongooseCollection, options);
+  mquery.call(this, null, options);
+  if (collection) {
+    this.collection(collection);
+  }
 
   if (conditions) {
     this.find(conditions);

package/lib/schema/map.js

@@ -69,6 +69,14 @@ class Map extends SchemaType {
   }
 }
 
+/**
+ * This schema type's name, to defend against minifiers that mangle
+ * function names.
+ *
+ * @api public
+ */
+Map.schemaName = 'Map';
+
 Map.prototype.OptionsConstructor = SchemaMapOptions;
 
 Map.defaultOptions = {};

package/lib/schema/objectid.js

@@ -9,6 +9,7 @@ const SchemaType = require('../schematype');
 const castObjectId = require('../cast/objectid');
 const getConstructorName = require('../helpers/getConstructorName');
 const oid = require('../types/objectid');
+const isBsonType = require('../helpers/isBsonType');
 const utils = require('../utils');
 
 const CastError = SchemaType.CastError;
@@ -113,7 +114,7 @@ ObjectId.prototype.auto = function(turnOn) {
  * ignore
  */
 
-ObjectId._checkRequired = v => v instanceof oid;
+ObjectId._checkRequired = v => isBsonType(v, 'ObjectID');
 
 /*!
  * ignore
@@ -161,7 +162,7 @@ ObjectId.cast = function cast(caster) {
  */
 
 ObjectId._defaultCaster = v => {
-  if (!(v instanceof oid)) {
+  if (!(isBsonType(v, 'ObjectID'))) {
     throw new Error(v + ' is not an instance of ObjectId');
   }
   return v;
@@ -221,7 +222,7 @@ ObjectId.prototype.checkRequired = function checkRequired(value, doc) {
  */
 
 ObjectId.prototype.cast = function(value, doc, init) {
-  if (!(value instanceof oid) && SchemaType._isRef(this, value, doc, init)) {
+  if (!(isBsonType(value, 'ObjectID')) && SchemaType._isRef(this, value, doc, init)) {
     // wait! we may need to cast this to a document
     if ((getConstructorName(value) || '').toLowerCase() === 'objectid') {
       return new oid(value.toHexString());

package/lib/schema.js

@@ -473,9 +473,39 @@ Schema.prototype.defaultOptions = function(options) {
   return options;
 };
 
+/**
+ * Inherit a Schema by applying a discriminator on an existing Schema.
+ *
+ *
+ * ####Example:
+ *
+ *     const options = { discriminatorKey: 'kind' };
+ *
+ *     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));
+ *
+ *     // 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);
+ *
+ * @param {String} name the name of the discriminator
+ * @param {Schema} schema the Schema of the discriminated Schema
+ * @return {Schema} the Schema instance
+ * @api public
+ */
+
 Schema.prototype.discriminator = function(name, schema) {
-  this._applyDiscriminators = {};
-  this._applyDiscriminators[name] = schema;
+  this._applyDiscriminators = Object.assign(this._applyDiscriminators || {}, { [name]: schema });
+
+  return this;
 };
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "6.3.5",
+  "version": "6.3.6",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -28,10 +28,9 @@
     "sift": "16.0.0"
   },
   "devDependencies": {
-    "@babel/core": "7.17.10",
-    "@babel/preset-env": "7.17.10",
-    "@typescript-eslint/eslint-plugin": "5.21.0",
-    "@typescript-eslint/parser": "5.21.0",
+    "@babel/core": "7.18.2",
+    "@typescript-eslint/eslint-plugin": "5.27.0",
+    "@typescript-eslint/parser": "5.27.0",
     "acquit": "1.2.1",
     "acquit-ignore": "0.2.0",
     "acquit-require": "0.1.1",
@@ -41,31 +40,31 @@
     "benchmark": "2.1.4",
     "bluebird": "3.7.2",
     "buffer": "^5.6.0",
-    "cheerio": "1.0.0-rc.10",
+    "cheerio": "1.0.0-rc.11",
     "crypto-browserify": "3.12.0",
     "dox": "0.3.1",
-    "eslint": "8.14.0",
+    "eslint": "8.16.0",
     "eslint-plugin-mocha-no-only": "1.1.1",
     "highlight.js": "11.5.1",
     "lodash.isequal": "4.5.0",
     "lodash.isequalwith": "4.4.0",
-    "marked": "4.0.14",
+    "marked": "4.0.16",
     "mkdirp": "^1.0.4",
     "mocha": "10.0.0",
     "moment": "2.x",
-    "mongodb-memory-server": "8.5.2",
+    "mongodb-memory-server": "8.6.0",
     "ncp": "^2.0.0",
     "nyc": "15.1.0",
     "pug": "3.0.2",
     "q": "1.5.1",
     "serve-handler": "6.1.3",
-    "sinon": "13.0.2",
+    "sinon": "14.0.0",
     "stream-browserify": "3.0.0",
     "ts-benchmark": "^1.0.2",
     "tsd": "0.20.0",
-    "typescript": "4.6.4",
+    "typescript": "4.7.2",
     "uuid": "8.3.2",
-    "webpack": "5.72.0"
+    "webpack": "5.72.1"
   },
   "directories": {
     "lib": "./lib/mongoose"

package/types/index.d.ts

@@ -120,6 +120,17 @@ declare module 'mongoose' {
     useProjection?: boolean;
   }
 
+  export type DiscriminatorModel<M, T> = T extends Model<infer T1, infer T2, infer T3, infer T4>
+    ?
+    M extends Model<infer M1, infer M2, infer M3, infer M4>
+      ? Model<Omit<M1, keyof T1> & T1, M2 | T2, M3 | T3, M4 | T4>
+      : 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 class Schema<DocType = any, M = Model<DocType, any, any, any>, TInstanceMethods = {}, TQueryHelpers = {}, TVirtuals = any> extends events.EventEmitter {
     /**
      * Create a new schema
@@ -142,6 +153,8 @@ declare module 'mongoose' {
     /** Returns a copy of this schema */
     clone<T = this>(): T;
 
+    discriminator<T extends Schema = Schema>(name: string, schema: T): DiscriminatorSchema<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals, T>;
+
     /** Returns a new schema that has the picked `paths` from this schema. */
     pick<T = this>(paths: string[], options?: SchemaOptions): T;
 
@@ -474,10 +487,10 @@ declare module 'mongoose' {
   type LeanTypeOrArray<T> = T extends unknown[] ? LeanArray<T> : LeanType<T>;
 
   export type LeanArray<T extends unknown[]> =
-  // By checking if it extends Types.Array we can get the original base type before collapsing down,
-  // rather than trying to manually remove the old types. This matches both Array and DocumentArray
+    // By checking if it extends Types.Array we can get the original base type before collapsing down,
+    // rather than trying to manually remove the old types. This matches both Array and DocumentArray
     T extends Types.Array<infer U> ? LeanTypeOrArray<U>[] :
-      // If it isn't a custom mongoose type we fall back to "do our best"
+    // If it isn't a custom mongoose type we fall back to "do our best"
       T extends unknown[][] ? LeanArray<T[number]>[] : LeanType<T[number]>[];
 
   export type _LeanDocument<T> = {

package/types/models.d.ts

@@ -1,9 +1,9 @@
 declare module 'mongoose' {
   import mongodb = require('mongodb');
 
-  export interface AcceptsDiscriminator {
+  export interface AcceptsDiscriminator<B> {
     /** Adds a discriminator type. */
-    discriminator<D>(name: string | number, schema: Schema, value?: string | number | ObjectId): Model<D>;
+    discriminator<D>(name: string | number, schema: Schema<D>, value?: string | number | ObjectId): Model<Omit<B, keyof D> & D>;
     discriminator<T, U>(name: string | number, schema: Schema<T, U>, value?: string | number | ObjectId): U;
   }
 
@@ -116,7 +116,7 @@ declare module 'mongoose' {
   const Model: Model<any>;
   interface Model<T, TQueryHelpers = {}, TMethodsAndOverrides = {}, TVirtuals = {}> extends
     NodeJS.EventEmitter,
-    AcceptsDiscriminator,
+    AcceptsDiscriminator<T>,
     IndexManager,
     SessionStarter {
     new <DocType = AnyKeys<T> & AnyObject>(doc?: DocType, fields?: any | null, options?: boolean | AnyObject): HydratedDocument<T, TMethodsAndOverrides, TVirtuals>;
@@ -416,4 +416,4 @@ declare module 'mongoose' {
     where<ResultDoc = HydratedDocument<T, TMethodsAndOverrides, TVirtuals>>(obj: object): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, T>;
     where<ResultDoc = HydratedDocument<T, TMethodsAndOverrides, TVirtuals>>(): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, T>;
   }
-}
+}

package/types/query.d.ts

@@ -579,7 +579,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 }): this;
+    sort(arg?: string | { [key: string]: SortOrder | { $meta: 'textScore' } } | undefined | null): this;
 
     /** Sets the tailable option (for use with capped collections). */
     tailable(bool?: boolean, opts?: {

package/types/schematypes.d.ts

@@ -126,7 +126,7 @@ declare module 'mongoose' {
     transform?: (this: any, val: T) => any;
 
     /** defines a custom getter for this property using [`Object.defineProperty()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty). */
-    get?: (value: any, doc?: this) => T;
+    get?: (value: any, doc?: this) => T | undefined;
 
     /** defines a custom setter for this property using [`Object.defineProperty()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty). */
     set?: (value: any, priorVal?: T, doc?: this) => any;
@@ -269,17 +269,17 @@ declare module 'mongoose' {
 
   namespace Schema {
     namespace Types {
-      class Array extends SchemaType implements AcceptsDiscriminator {
+      class Array<B = any> extends SchemaType<B> implements AcceptsDiscriminator<B> {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'Array';
 
         static options: { castNonArrays: boolean; };
 
         discriminator<T, U>(name: string | number, schema: Schema<T, U>, value?: string): U;
-        discriminator<D>(name: string | number, schema: Schema, value?: string): Model<D>;
+        discriminator<D>(name: string | number, schema: Schema<D>, value?: string | number | ObjectId): Model<Omit<B, keyof D> & D>;
 
         /** The schematype embedded in this array */
-        caster?: SchemaType;
+        caster?: SchemaType<B>;
 
         /**
          * Adds an enum validator if this is an array of strings or numbers. Equivalent to
@@ -290,7 +290,7 @@ declare module 'mongoose' {
 
       class Boolean extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'Boolean';
 
         /** Configure which values get casted to `true`. */
         static convertToTrue: Set<any>;
@@ -301,7 +301,7 @@ declare module 'mongoose' {
 
       class Buffer extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'Buffer';
 
         /**
          * Sets the default [subtype](https://studio3t.com/whats-new/best-practices-uuid-mongodb/)
@@ -312,7 +312,7 @@ declare module 'mongoose' {
 
       class Date extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'Date';
 
         /** Declares a TTL index (rounded to the nearest second) for _Date_ types only. */
         expires(when: number | string): this;
@@ -326,20 +326,20 @@ declare module 'mongoose' {
 
       class Decimal128 extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'Decimal128';
       }
 
-      class DocumentArray extends SchemaType implements AcceptsDiscriminator {
+      class DocumentArray<B = any> extends SchemaType<B> implements AcceptsDiscriminator<B> {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'DocumentArray';
 
         static options: { castNonArrays: boolean; };
 
-        discriminator<D>(name: string | number, schema: Schema, value?: string): Model<D>;
+        discriminator<D>(name: string | number, schema: Schema<D>, value?: string | number | ObjectId): Model<Omit<B, keyof D> & D>;
         discriminator<T, U>(name: string | number, schema: Schema<T, U>, value?: string): U;
 
         /** The schema used for documents in this array */
-        schema: Schema;
+        schema: Schema<B>;
 
         /** The constructor used for subdocuments in this array */
         caster?: typeof Types.Subdocument;
@@ -347,17 +347,17 @@ declare module 'mongoose' {
 
       class Map extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'Map';
       }
 
       class Mixed extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'Mixed';
       }
 
       class Number extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'Number';
 
         /** Sets a enum validator */
         enum(vals: number[]): this;
@@ -371,26 +371,26 @@ declare module 'mongoose' {
 
       class ObjectId extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'ObjectId';
 
         /** Adds an auto-generated ObjectId default if turnOn is true. */
         auto(turnOn: boolean): this;
       }
 
-      class Subdocument extends SchemaType implements AcceptsDiscriminator {
+      class Subdocument<B = any> extends SchemaType<B> implements AcceptsDiscriminator<B> {
         /** This schema type's name, to defend against minifiers that mangle function names. */
         static schemaName: string;
 
         /** The document's schema */
-        schema: Schema;
+        schema: Schema<B>;
 
         discriminator<T, U>(name: string | number, schema: Schema<T, U>, value?: string): U;
-        discriminator<D>(name: string | number, schema: Schema, value?: string): Model<D>;
+        discriminator<D>(name: string | number, schema: Schema<D>, value?: string | number | ObjectId): Model<Omit<B, keyof D> & D>;
       }
 
       class String extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
-        static schemaName: string;
+        static schemaName: 'String';
 
         /** Adds an enum validator */
         enum(vals: string[] | any): this;

package/.lgtm.yml

@@ -1,3 +0,0 @@
-path_classifiers:
-  test:
-    - lib